![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to efi_snp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / interface / efi|
Return to efi_snp.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / interface / efi |
1.1 root 1: /*
2: * Copyright (C) 2008 Michael Brown <[email protected]>.
3: *
4: * This program is free software; you can redistribute it and/or
5: * modify it under the terms of the GNU General Public License as
6: * published by the Free Software Foundation; either version 2 of the
7: * License, or any later version.
8: *
9: * This program is distributed in the hope that it will be useful, but
10: * WITHOUT ANY WARRANTY; without even the implied warranty of
11: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12: * General Public License for more details.
13: *
14: * You should have received a copy of the GNU General Public License
15: * along with this program; if not, write to the Free Software
16: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17: */
18:
19: FILE_LICENCE ( GPL2_OR_LATER );
20:
21: #include <stdlib.h>
22: #include <string.h>
23: #include <errno.h>
24: #include <assert.h>
25: #include <byteswap.h>
26: #include <ipxe/netdevice.h>
27: #include <ipxe/iobuf.h>
28: #include <ipxe/in.h>
29: #include <ipxe/pci.h>
30: #include <ipxe/efi/efi.h>
31: #include <ipxe/efi/efi_pci.h>
32: #include <ipxe/efi/efi_driver.h>
33: #include <ipxe/efi/efi_strings.h>
34: #include <ipxe/efi/efi_hii.h>
35: #include <ipxe/efi/Protocol/SimpleNetwork.h>
36: #include <ipxe/efi/Protocol/NetworkInterfaceIdentifier.h>
37: #include <ipxe/efi/Protocol/DevicePath.h>
38: #include <ipxe/efi/Protocol/HiiConfigAccess.h>
39: #include <ipxe/efi/Protocol/HiiDatabase.h>
40: #include <config/general.h>
41:
42: /** @file
43: *
44: * iPXE EFI SNP interface
45: *
46: */
47:
48: /** An SNP device */
49: struct efi_snp_device {
50: /** List of SNP devices */
51: struct list_head list;
52: /** The underlying iPXE network device */
53: struct net_device *netdev;
54: /** The underlying EFI PCI device */
55: struct efi_pci_device *efipci;
56: /** EFI device handle */
57: EFI_HANDLE handle;
58: /** The SNP structure itself */
59: EFI_SIMPLE_NETWORK_PROTOCOL snp;
60: /** The SNP "mode" (parameters) */
61: EFI_SIMPLE_NETWORK_MODE mode;
62: /** Outstanding TX packet count (via "interrupt status")
63: *
64: * Used in order to generate TX completions.
65: */
66: unsigned int tx_count_interrupts;
67: /** Outstanding TX packet count (via "recycled tx buffers")
68: *
69: * Used in order to generate TX completions.
70: */
71: unsigned int tx_count_txbufs;
72: /** Outstanding RX packet count (via "interrupt status") */
73: unsigned int rx_count_interrupts;
74: /** Outstanding RX packet count (via WaitForPacket event) */
75: unsigned int rx_count_events;
76: /** The network interface identifier */
77: EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL nii;
78: /** HII configuration access protocol */
79: EFI_HII_CONFIG_ACCESS_PROTOCOL hii;
80: /** HII package list */
81: EFI_HII_PACKAGE_LIST_HEADER *package_list;
82: /** HII handle */
83: EFI_HII_HANDLE hii_handle;
84: /** Device name */
85: wchar_t name[ sizeof ( ( ( struct net_device * ) NULL )->name ) ];
86: /** The device path
87: *
88: * This field is variable in size and must appear at the end
89: * of the structure.
90: */
91: EFI_DEVICE_PATH_PROTOCOL path;
92: };
93:
94: /** EFI simple network protocol GUID */
95: static EFI_GUID efi_simple_network_protocol_guid
96: = EFI_SIMPLE_NETWORK_PROTOCOL_GUID;
97:
98: /** EFI device path protocol GUID */
99: static EFI_GUID efi_device_path_protocol_guid
100: = EFI_DEVICE_PATH_PROTOCOL_GUID;
101:
102: /** EFI network interface identifier GUID */
103: static EFI_GUID efi_nii_protocol_guid
104: = EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_GUID;
105:
106: /** EFI network interface identifier GUID (extra special version) */
107: static EFI_GUID efi_nii31_protocol_guid = {
108: /* At some point, it seems that someone decided to change the
109: * GUID. Current EFI builds ignore the older GUID, older EFI
110: * builds ignore the newer GUID, so we have to expose both.
111: */
112: 0x1ACED566, 0x76ED, 0x4218,
113: { 0xBC, 0x81, 0x76, 0x7F, 0x1F, 0x97, 0x7A, 0x89 }
114: };
115:
116: /** List of SNP devices */
117: static LIST_HEAD ( efi_snp_devices );
118:
119: /**
120: * Set EFI SNP mode based on iPXE net device parameters
121: *
122: * @v snp SNP interface
123: */
124: static void efi_snp_set_mode ( struct efi_snp_device *snpdev ) {
125: struct net_device *netdev = snpdev->netdev;
126: EFI_SIMPLE_NETWORK_MODE *mode = &snpdev->mode;
127: struct ll_protocol *ll_protocol = netdev->ll_protocol;
128: unsigned int ll_addr_len = ll_protocol->ll_addr_len;
129:
130: mode->HwAddressSize = ll_addr_len;
131: mode->MediaHeaderSize = ll_protocol->ll_header_len;
132: mode->MaxPacketSize = netdev->max_pkt_len;
133: mode->ReceiveFilterMask = ( EFI_SIMPLE_NETWORK_RECEIVE_UNICAST |
134: EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST |
135: EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST );
136: assert ( ll_addr_len <= sizeof ( mode->CurrentAddress ) );
137: memcpy ( &mode->CurrentAddress, netdev->ll_addr, ll_addr_len );
138: memcpy ( &mode->BroadcastAddress, netdev->ll_broadcast, ll_addr_len );
139: ll_protocol->init_addr ( netdev->hw_addr, &mode->PermanentAddress );
140: mode->IfType = ntohs ( ll_protocol->ll_proto );
141: mode->MacAddressChangeable = TRUE;
142: mode->MediaPresentSupported = TRUE;
143: mode->MediaPresent = ( netdev_link_ok ( netdev ) ? TRUE : FALSE );
144: }
145:
146: /**
147: * Poll net device and count received packets
148: *
149: * @v snpdev SNP device
150: */
151: static void efi_snp_poll ( struct efi_snp_device *snpdev ) {
152: struct io_buffer *iobuf;
153: unsigned int before = 0;
154: unsigned int after = 0;
155: unsigned int arrived;
156:
157: /* We have to report packet arrivals, and this is the easiest
158: * way to fake it.
159: */
160: list_for_each_entry ( iobuf, &snpdev->netdev->rx_queue, list )
161: before++;
162: netdev_poll ( snpdev->netdev );
163: list_for_each_entry ( iobuf, &snpdev->netdev->rx_queue, list )
164: after++;
165: arrived = ( after - before );
166:
167: snpdev->rx_count_interrupts += arrived;
168: snpdev->rx_count_events += arrived;
169: }
170:
171: /**
172: * Change SNP state from "stopped" to "started"
173: *
174: * @v snp SNP interface
175: * @ret efirc EFI status code
176: */
177: static EFI_STATUS EFIAPI
178: efi_snp_start ( EFI_SIMPLE_NETWORK_PROTOCOL *snp ) {
179: struct efi_snp_device *snpdev =
180: container_of ( snp, struct efi_snp_device, snp );
181:
182: DBGC2 ( snpdev, "SNPDEV %p START\n", snpdev );
183:
184: snpdev->mode.State = EfiSimpleNetworkStarted;
185: return 0;
186: }
187:
188: /**
189: * Change SNP state from "started" to "stopped"
190: *
191: * @v snp SNP interface
192: * @ret efirc EFI status code
193: */
194: static EFI_STATUS EFIAPI
195: efi_snp_stop ( EFI_SIMPLE_NETWORK_PROTOCOL *snp ) {
196: struct efi_snp_device *snpdev =
197: container_of ( snp, struct efi_snp_device, snp );
198:
199: DBGC2 ( snpdev, "SNPDEV %p STOP\n", snpdev );
200:
201: snpdev->mode.State = EfiSimpleNetworkStopped;
202: return 0;
203: }
204:
205: /**
206: * Open the network device
207: *
208: * @v snp SNP interface
209: * @v extra_rx_bufsize Extra RX buffer size, in bytes
210: * @v extra_tx_bufsize Extra TX buffer size, in bytes
211: * @ret efirc EFI status code
212: */
213: static EFI_STATUS EFIAPI
214: efi_snp_initialize ( EFI_SIMPLE_NETWORK_PROTOCOL *snp,
215: UINTN extra_rx_bufsize, UINTN extra_tx_bufsize ) {
216: struct efi_snp_device *snpdev =
217: container_of ( snp, struct efi_snp_device, snp );
218: int rc;
219:
220: DBGC2 ( snpdev, "SNPDEV %p INITIALIZE (%ld extra RX, %ld extra TX)\n",
221: snpdev, ( ( unsigned long ) extra_rx_bufsize ),
222: ( ( unsigned long ) extra_tx_bufsize ) );
223:
224: if ( ( rc = netdev_open ( snpdev->netdev ) ) != 0 ) {
225: DBGC ( snpdev, "SNPDEV %p could not open %s: %s\n",
226: snpdev, snpdev->netdev->name, strerror ( rc ) );
227: return RC_TO_EFIRC ( rc );
228: }
229:
230: snpdev->mode.State = EfiSimpleNetworkInitialized;
231: return 0;
232: }
233:
234: /**
235: * Reset the network device
236: *
237: * @v snp SNP interface
238: * @v ext_verify Extended verification required
239: * @ret efirc EFI status code
240: */
241: static EFI_STATUS EFIAPI
242: efi_snp_reset ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, BOOLEAN ext_verify ) {
243: struct efi_snp_device *snpdev =
244: container_of ( snp, struct efi_snp_device, snp );
245: int rc;
246:
247: DBGC2 ( snpdev, "SNPDEV %p RESET (%s extended verification)\n",
248: snpdev, ( ext_verify ? "with" : "without" ) );
249:
250: netdev_close ( snpdev->netdev );
251: snpdev->mode.State = EfiSimpleNetworkStarted;
252:
253: if ( ( rc = netdev_open ( snpdev->netdev ) ) != 0 ) {
254: DBGC ( snpdev, "SNPDEV %p could not reopen %s: %s\n",
255: snpdev, snpdev->netdev->name, strerror ( rc ) );
256: return RC_TO_EFIRC ( rc );
257: }
258:
259: snpdev->mode.State = EfiSimpleNetworkInitialized;
260: return 0;
261: }
262:
263: /**
264: * Shut down the network device
265: *
266: * @v snp SNP interface
267: * @ret efirc EFI status code
268: */
269: static EFI_STATUS EFIAPI
270: efi_snp_shutdown ( EFI_SIMPLE_NETWORK_PROTOCOL *snp ) {
271: struct efi_snp_device *snpdev =
272: container_of ( snp, struct efi_snp_device, snp );
273:
274: DBGC2 ( snpdev, "SNPDEV %p SHUTDOWN\n", snpdev );
275:
276: netdev_close ( snpdev->netdev );
277: snpdev->mode.State = EfiSimpleNetworkStarted;
278: return 0;
279: }
280:
281: /**
282: * Manage receive filters
283: *
284: * @v snp SNP interface
285: * @v enable Receive filters to enable
286: * @v disable Receive filters to disable
287: * @v mcast_reset Reset multicast filters
288: * @v mcast_count Number of multicast filters
289: * @v mcast Multicast filters
290: * @ret efirc EFI status code
291: */
292: static EFI_STATUS EFIAPI
293: efi_snp_receive_filters ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, UINT32 enable,
294: UINT32 disable, BOOLEAN mcast_reset,
295: UINTN mcast_count, EFI_MAC_ADDRESS *mcast ) {
296: struct efi_snp_device *snpdev =
297: container_of ( snp, struct efi_snp_device, snp );
298: unsigned int i;
299:
300: DBGC2 ( snpdev, "SNPDEV %p RECEIVE_FILTERS %08x&~%08x%s %ld mcast\n",
301: snpdev, enable, disable, ( mcast_reset ? " reset" : "" ),
302: ( ( unsigned long ) mcast_count ) );
303: for ( i = 0 ; i < mcast_count ; i++ ) {
304: DBGC2_HDA ( snpdev, i, &mcast[i],
305: snpdev->netdev->ll_protocol->ll_addr_len );
306: }
307:
308: /* Lie through our teeth, otherwise MNP refuses to accept us */
309: return 0;
310: }
311:
312: /**
313: * Set station address
314: *
315: * @v snp SNP interface
316: * @v reset Reset to permanent address
317: * @v new New station address
318: * @ret efirc EFI status code
319: */
320: static EFI_STATUS EFIAPI
321: efi_snp_station_address ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, BOOLEAN reset,
322: EFI_MAC_ADDRESS *new ) {
323: struct efi_snp_device *snpdev =
324: container_of ( snp, struct efi_snp_device, snp );
325: struct ll_protocol *ll_protocol = snpdev->netdev->ll_protocol;
326:
327: DBGC2 ( snpdev, "SNPDEV %p STATION_ADDRESS %s\n", snpdev,
328: ( reset ? "reset" : ll_protocol->ntoa ( new ) ) );
329:
330: /* Set the MAC address */
331: if ( reset )
332: new = &snpdev->mode.PermanentAddress;
333: memcpy ( snpdev->netdev->ll_addr, new, ll_protocol->ll_addr_len );
334:
335: /* MAC address changes take effect only on netdev_open() */
336: if ( netdev_is_open ( snpdev->netdev ) ) {
337: DBGC ( snpdev, "SNPDEV %p MAC address changed while net "
338: "devive open\n", snpdev );
339: }
340:
341: return 0;
342: }
343:
344: /**
345: * Get (or reset) statistics
346: *
347: * @v snp SNP interface
348: * @v reset Reset statistics
349: * @v stats_len Size of statistics table
350: * @v stats Statistics table
351: * @ret efirc EFI status code
352: */
353: static EFI_STATUS EFIAPI
354: efi_snp_statistics ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, BOOLEAN reset,
355: UINTN *stats_len, EFI_NETWORK_STATISTICS *stats ) {
356: struct efi_snp_device *snpdev =
357: container_of ( snp, struct efi_snp_device, snp );
358: EFI_NETWORK_STATISTICS stats_buf;
359:
360: DBGC2 ( snpdev, "SNPDEV %p STATISTICS%s", snpdev,
361: ( reset ? " reset" : "" ) );
362:
363: /* Gather statistics */
364: memset ( &stats_buf, 0, sizeof ( stats_buf ) );
365: stats_buf.TxGoodFrames = snpdev->netdev->tx_stats.good;
366: stats_buf.TxDroppedFrames = snpdev->netdev->tx_stats.bad;
367: stats_buf.TxTotalFrames = ( snpdev->netdev->tx_stats.good +
368: snpdev->netdev->tx_stats.bad );
369: stats_buf.RxGoodFrames = snpdev->netdev->rx_stats.good;
370: stats_buf.RxDroppedFrames = snpdev->netdev->rx_stats.bad;
371: stats_buf.RxTotalFrames = ( snpdev->netdev->rx_stats.good +
372: snpdev->netdev->rx_stats.bad );
373: if ( *stats_len > sizeof ( stats_buf ) )
374: *stats_len = sizeof ( stats_buf );
375: if ( stats )
376: memcpy ( stats, &stats_buf, *stats_len );
377:
378: /* Reset statistics if requested to do so */
379: if ( reset ) {
380: memset ( &snpdev->netdev->tx_stats, 0,
381: sizeof ( snpdev->netdev->tx_stats ) );
382: memset ( &snpdev->netdev->rx_stats, 0,
383: sizeof ( snpdev->netdev->rx_stats ) );
384: }
385:
386: return 0;
387: }
388:
389: /**
390: * Convert multicast IP address to MAC address
391: *
392: * @v snp SNP interface
393: * @v ipv6 Address is IPv6
394: * @v ip IP address
395: * @v mac MAC address
396: * @ret efirc EFI status code
397: */
398: static EFI_STATUS EFIAPI
399: efi_snp_mcast_ip_to_mac ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, BOOLEAN ipv6,
400: EFI_IP_ADDRESS *ip, EFI_MAC_ADDRESS *mac ) {
401: struct efi_snp_device *snpdev =
402: container_of ( snp, struct efi_snp_device, snp );
403: struct ll_protocol *ll_protocol = snpdev->netdev->ll_protocol;
404: const char *ip_str;
405: int rc;
406:
407: ip_str = ( ipv6 ? "(IPv6)" /* FIXME when we have inet6_ntoa() */ :
408: inet_ntoa ( *( ( struct in_addr * ) ip ) ) );
409: DBGC2 ( snpdev, "SNPDEV %p MCAST_IP_TO_MAC %s\n", snpdev, ip_str );
410:
411: /* Try to hash the address */
412: if ( ( rc = ll_protocol->mc_hash ( ( ipv6 ? AF_INET6 : AF_INET ),
413: ip, mac ) ) != 0 ) {
414: DBGC ( snpdev, "SNPDEV %p could not hash %s: %s\n",
415: snpdev, ip_str, strerror ( rc ) );
416: return RC_TO_EFIRC ( rc );
417: }
418:
419: return 0;
420: }
421:
422: /**
423: * Read or write non-volatile storage
424: *
425: * @v snp SNP interface
426: * @v read Operation is a read
427: * @v offset Starting offset within NVRAM
428: * @v len Length of data buffer
429: * @v data Data buffer
430: * @ret efirc EFI status code
431: */
432: static EFI_STATUS EFIAPI
433: efi_snp_nvdata ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, BOOLEAN read,
434: UINTN offset, UINTN len, VOID *data ) {
435: struct efi_snp_device *snpdev =
436: container_of ( snp, struct efi_snp_device, snp );
437:
438: DBGC2 ( snpdev, "SNPDEV %p NVDATA %s %lx+%lx\n", snpdev,
439: ( read ? "read" : "write" ), ( ( unsigned long ) offset ),
440: ( ( unsigned long ) len ) );
441: if ( ! read )
442: DBGC2_HDA ( snpdev, offset, data, len );
443:
444: return EFI_UNSUPPORTED;
445: }
446:
447: /**
448: * Read interrupt status and TX recycled buffer status
449: *
450: * @v snp SNP interface
451: * @v interrupts Interrupt status, or NULL
452: * @v txbufs Recycled transmit buffer address, or NULL
453: * @ret efirc EFI status code
454: */
455: static EFI_STATUS EFIAPI
456: efi_snp_get_status ( EFI_SIMPLE_NETWORK_PROTOCOL *snp,
457: UINT32 *interrupts, VOID **txbufs ) {
458: struct efi_snp_device *snpdev =
459: container_of ( snp, struct efi_snp_device, snp );
460:
461: DBGC2 ( snpdev, "SNPDEV %p GET_STATUS", snpdev );
462:
463: /* Poll the network device */
464: efi_snp_poll ( snpdev );
465:
466: /* Interrupt status. In practice, this seems to be used only
467: * to detect TX completions.
468: */
469: if ( interrupts ) {
470: *interrupts = 0;
471: /* Report TX completions once queue is empty; this
472: * avoids having to add hooks in the net device layer.
473: */
474: if ( snpdev->tx_count_interrupts &&
475: list_empty ( &snpdev->netdev->tx_queue ) ) {
476: *interrupts |= EFI_SIMPLE_NETWORK_TRANSMIT_INTERRUPT;
477: snpdev->tx_count_interrupts--;
478: }
479: /* Report RX */
480: if ( snpdev->rx_count_interrupts ) {
481: *interrupts |= EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT;
482: snpdev->rx_count_interrupts--;
483: }
484: DBGC2 ( snpdev, " INTS:%02x", *interrupts );
485: }
486:
487: /* TX completions. It would be possible to design a more
488: * idiotic scheme for this, but it would be a challenge.
489: * According to the UEFI header file, txbufs will be filled in
490: * with a list of "recycled transmit buffers" (i.e. completed
491: * TX buffers). Observant readers may care to note that
492: * *txbufs is a void pointer. Precisely how a list of
493: * completed transmit buffers is meant to be represented as an
494: * array of voids is left as an exercise for the reader.
495: *
496: * The only users of this interface (MnpDxe/MnpIo.c and
497: * PxeBcDxe/Bc.c within the EFI dev kit) both just poll until
498: * seeing a non-NULL result return in txbufs. This is valid
499: * provided that they do not ever attempt to transmit more
500: * than one packet concurrently (and that TX never times out).
501: */
502: if ( txbufs ) {
503: if ( snpdev->tx_count_txbufs &&
504: list_empty ( &snpdev->netdev->tx_queue ) ) {
505: *txbufs = "Which idiot designed this API?";
506: snpdev->tx_count_txbufs--;
507: } else {
508: *txbufs = NULL;
509: }
510: DBGC2 ( snpdev, " TX:%s", ( *txbufs ? "some" : "none" ) );
511: }
512:
513: DBGC2 ( snpdev, "\n" );
514: return 0;
515: }
516:
517: /**
518: * Start packet transmission
519: *
520: * @v snp SNP interface
521: * @v ll_header_len Link-layer header length, if to be filled in
522: * @v len Length of data buffer
523: * @v data Data buffer
524: * @v ll_src Link-layer source address, if specified
525: * @v ll_dest Link-layer destination address, if specified
526: * @v net_proto Network-layer protocol (in host order)
527: * @ret efirc EFI status code
528: */
529: static EFI_STATUS EFIAPI
530: efi_snp_transmit ( EFI_SIMPLE_NETWORK_PROTOCOL *snp,
531: UINTN ll_header_len, UINTN len, VOID *data,
532: EFI_MAC_ADDRESS *ll_src, EFI_MAC_ADDRESS *ll_dest,
533: UINT16 *net_proto ) {
534: struct efi_snp_device *snpdev =
535: container_of ( snp, struct efi_snp_device, snp );
536: struct ll_protocol *ll_protocol = snpdev->netdev->ll_protocol;
537: struct io_buffer *iobuf;
538: size_t ll_headroom;
539: int rc;
540: EFI_STATUS efirc;
541:
542: DBGC2 ( snpdev, "SNPDEV %p TRANSMIT %p+%lx", snpdev, data,
543: ( ( unsigned long ) len ) );
544: if ( ll_header_len ) {
545: if ( ll_src ) {
546: DBGC2 ( snpdev, " src %s",
547: ll_protocol->ntoa ( ll_src ) );
548: }
549: if ( ll_dest ) {
550: DBGC2 ( snpdev, " dest %s",
551: ll_protocol->ntoa ( ll_dest ) );
552: }
553: if ( net_proto ) {
554: DBGC2 ( snpdev, " proto %04x", *net_proto );
555: }
556: }
557: DBGC2 ( snpdev, "\n" );
558:
559: /* Sanity checks */
560: if ( ll_header_len ) {
561: if ( ll_header_len != ll_protocol->ll_header_len ) {
562: DBGC ( snpdev, "SNPDEV %p TX invalid header length "
563: "%ld\n", snpdev,
564: ( ( unsigned long ) ll_header_len ) );
565: efirc = EFI_INVALID_PARAMETER;
566: goto err_sanity;
567: }
568: if ( len < ll_header_len ) {
569: DBGC ( snpdev, "SNPDEV %p invalid packet length %ld\n",
570: snpdev, ( ( unsigned long ) len ) );
571: efirc = EFI_BUFFER_TOO_SMALL;
572: goto err_sanity;
573: }
574: if ( ! ll_dest ) {
575: DBGC ( snpdev, "SNPDEV %p TX missing destination "
576: "address\n", snpdev );
577: efirc = EFI_INVALID_PARAMETER;
578: goto err_sanity;
579: }
580: if ( ! net_proto ) {
581: DBGC ( snpdev, "SNPDEV %p TX missing network "
582: "protocol\n", snpdev );
583: efirc = EFI_INVALID_PARAMETER;
584: goto err_sanity;
585: }
586: if ( ! ll_src )
587: ll_src = &snpdev->mode.CurrentAddress;
588: }
589:
590: /* Allocate buffer */
591: ll_headroom = ( MAX_LL_HEADER_LEN - ll_header_len );
592: iobuf = alloc_iob ( ll_headroom + len );
593: if ( ! iobuf ) {
594: DBGC ( snpdev, "SNPDEV %p TX could not allocate %ld-byte "
595: "buffer\n", snpdev, ( ( unsigned long ) len ) );
596: efirc = EFI_DEVICE_ERROR;
597: goto err_alloc_iob;
598: }
599: iob_reserve ( iobuf, ll_headroom );
600: memcpy ( iob_put ( iobuf, len ), data, len );
601:
602: /* Create link-layer header, if specified */
603: if ( ll_header_len ) {
604: iob_pull ( iobuf, ll_header_len );
605: if ( ( rc = ll_protocol->push ( snpdev->netdev,
606: iobuf, ll_dest, ll_src,
607: htons ( *net_proto ) )) != 0 ){
608: DBGC ( snpdev, "SNPDEV %p TX could not construct "
609: "header: %s\n", snpdev, strerror ( rc ) );
610: efirc = RC_TO_EFIRC ( rc );
611: goto err_ll_push;
612: }
613: }
614:
615: /* Transmit packet */
616: if ( ( rc = netdev_tx ( snpdev->netdev, iob_disown ( iobuf ) ) ) != 0){
617: DBGC ( snpdev, "SNPDEV %p TX could not transmit: %s\n",
618: snpdev, strerror ( rc ) );
619: efirc = RC_TO_EFIRC ( rc );
620: goto err_tx;
621: }
622:
623: /* Record transmission as outstanding */
624: snpdev->tx_count_interrupts++;
625: snpdev->tx_count_txbufs++;
626:
627: return 0;
628:
629: err_tx:
630: err_ll_push:
631: free_iob ( iobuf );
632: err_alloc_iob:
633: err_sanity:
634: return efirc;
635: }
636:
637: /**
638: * Receive packet
639: *
640: * @v snp SNP interface
641: * @v ll_header_len Link-layer header length, if to be filled in
642: * @v len Length of data buffer
643: * @v data Data buffer
644: * @v ll_src Link-layer source address, if specified
645: * @v ll_dest Link-layer destination address, if specified
646: * @v net_proto Network-layer protocol (in host order)
647: * @ret efirc EFI status code
648: */
649: static EFI_STATUS EFIAPI
650: efi_snp_receive ( EFI_SIMPLE_NETWORK_PROTOCOL *snp,
651: UINTN *ll_header_len, UINTN *len, VOID *data,
652: EFI_MAC_ADDRESS *ll_src, EFI_MAC_ADDRESS *ll_dest,
653: UINT16 *net_proto ) {
654: struct efi_snp_device *snpdev =
655: container_of ( snp, struct efi_snp_device, snp );
656: struct ll_protocol *ll_protocol = snpdev->netdev->ll_protocol;
657: struct io_buffer *iobuf;
658: const void *iob_ll_dest;
659: const void *iob_ll_src;
660: uint16_t iob_net_proto;
661: int rc;
662: EFI_STATUS efirc;
663:
664: DBGC2 ( snpdev, "SNPDEV %p RECEIVE %p(+%lx)", snpdev, data,
665: ( ( unsigned long ) *len ) );
666:
667: /* Poll the network device */
668: efi_snp_poll ( snpdev );
669:
670: /* Dequeue a packet, if one is available */
671: iobuf = netdev_rx_dequeue ( snpdev->netdev );
672: if ( ! iobuf ) {
673: DBGC2 ( snpdev, "\n" );
674: efirc = EFI_NOT_READY;
675: goto out_no_packet;
676: }
677: DBGC2 ( snpdev, "+%zx\n", iob_len ( iobuf ) );
678:
679: /* Return packet to caller */
680: memcpy ( data, iobuf->data, iob_len ( iobuf ) );
681: *len = iob_len ( iobuf );
682:
683: /* Attempt to decode link-layer header */
684: if ( ( rc = ll_protocol->pull ( snpdev->netdev, iobuf, &iob_ll_dest,
685: &iob_ll_src, &iob_net_proto ) ) != 0 ){
686: DBGC ( snpdev, "SNPDEV %p could not parse header: %s\n",
687: snpdev, strerror ( rc ) );
688: efirc = RC_TO_EFIRC ( rc );
689: goto out_bad_ll_header;
690: }
691:
692: /* Return link-layer header parameters to caller, if required */
693: if ( ll_header_len )
694: *ll_header_len = ll_protocol->ll_header_len;
695: if ( ll_src )
696: memcpy ( ll_src, iob_ll_src, ll_protocol->ll_addr_len );
697: if ( ll_dest )
698: memcpy ( ll_dest, iob_ll_dest, ll_protocol->ll_addr_len );
699: if ( net_proto )
700: *net_proto = ntohs ( iob_net_proto );
701:
702: efirc = 0;
703:
704: out_bad_ll_header:
705: free_iob ( iobuf );
706: out_no_packet:
707: return efirc;
708: }
709:
710: /**
711: * Poll event
712: *
713: * @v event Event
714: * @v context Event context
715: */
716: static VOID EFIAPI efi_snp_wait_for_packet ( EFI_EVENT event,
717: VOID *context ) {
718: EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
719: struct efi_snp_device *snpdev = context;
720:
721: DBGCP ( snpdev, "SNPDEV %p WAIT_FOR_PACKET\n", snpdev );
722:
723: /* Do nothing unless the net device is open */
724: if ( ! netdev_is_open ( snpdev->netdev ) )
725: return;
726:
727: /* Poll the network device */
728: efi_snp_poll ( snpdev );
729:
730: /* Fire event if packets have been received */
731: if ( snpdev->rx_count_events != 0 ) {
732: DBGC2 ( snpdev, "SNPDEV %p firing WaitForPacket event\n",
733: snpdev );
734: bs->SignalEvent ( event );
735: snpdev->rx_count_events--;
736: }
737: }
738:
739: /** SNP interface */
740: static EFI_SIMPLE_NETWORK_PROTOCOL efi_snp_device_snp = {
741: .Revision = EFI_SIMPLE_NETWORK_PROTOCOL_REVISION,
742: .Start = efi_snp_start,
743: .Stop = efi_snp_stop,
744: .Initialize = efi_snp_initialize,
745: .Reset = efi_snp_reset,
746: .Shutdown = efi_snp_shutdown,
747: .ReceiveFilters = efi_snp_receive_filters,
748: .StationAddress = efi_snp_station_address,
749: .Statistics = efi_snp_statistics,
750: .MCastIpToMac = efi_snp_mcast_ip_to_mac,
751: .NvData = efi_snp_nvdata,
752: .GetStatus = efi_snp_get_status,
753: .Transmit = efi_snp_transmit,
754: .Receive = efi_snp_receive,
755: };
756:
757: /******************************************************************************
758: *
759: * Human Interface Infrastructure
760: *
761: ******************************************************************************
762: */
763:
764: /** EFI configuration access protocol GUID */
765: static EFI_GUID efi_hii_config_access_protocol_guid
766: = EFI_HII_CONFIG_ACCESS_PROTOCOL_GUID;
767:
768: /** EFI HII database protocol */
769: static EFI_HII_DATABASE_PROTOCOL *efihii;
770: EFI_REQUIRE_PROTOCOL ( EFI_HII_DATABASE_PROTOCOL, &efihii );
771:
772: /** Local GUID used for our EFI SNP formset */
773: #define EFI_SNP_FORMSET_GUID \
774: { 0xc4f84019, 0x6dfd, 0x4a27, \
775: { 0x9b, 0x94, 0xb7, 0x2e, 0x1f, 0xbc, 0xad, 0xca } }
776:
777: /** Form identifiers used for our EFI SNP HII */
778: enum efi_snp_hii_form_id {
779: EFI_SNP_FORM = 0x0001, /**< The only form */
780: };
781:
782: /** String identifiers used for our EFI SNP HII */
783: enum efi_snp_hii_string_id {
784: /* Language name */
785: EFI_SNP_LANGUAGE_NAME = 0x0001,
786: /* Formset */
787: EFI_SNP_FORMSET_TITLE, EFI_SNP_FORMSET_HELP,
788: /* Product name */
789: EFI_SNP_PRODUCT_PROMPT, EFI_SNP_PRODUCT_HELP, EFI_SNP_PRODUCT_TEXT,
790: /* Version */
791: EFI_SNP_VERSION_PROMPT, EFI_SNP_VERSION_HELP, EFI_SNP_VERSION_TEXT,
792: /* Driver */
793: EFI_SNP_DRIVER_PROMPT, EFI_SNP_DRIVER_HELP, EFI_SNP_DRIVER_TEXT,
794: /* Device */
795: EFI_SNP_DEVICE_PROMPT, EFI_SNP_DEVICE_HELP, EFI_SNP_DEVICE_TEXT,
796: /* End of list */
797: EFI_SNP_MAX_STRING_ID
798: };
799:
800: /** EFI SNP formset */
801: struct efi_snp_formset {
802: EFI_HII_PACKAGE_HEADER Header;
803: EFI_IFR_FORM_SET_TYPE(1) FormSet;
804: EFI_IFR_GUID_CLASS Class;
805: EFI_IFR_GUID_SUBCLASS SubClass;
806: EFI_IFR_FORM Form;
807: EFI_IFR_TEXT ProductText;
808: EFI_IFR_TEXT VersionText;
809: EFI_IFR_TEXT DriverText;
810: EFI_IFR_TEXT DeviceText;
811: EFI_IFR_END EndForm;
812: EFI_IFR_END EndFormSet;
813: } __attribute__ (( packed )) efi_snp_formset = {
814: .Header = {
815: .Length = sizeof ( efi_snp_formset ),
816: .Type = EFI_HII_PACKAGE_FORMS,
817: },
818: .FormSet = EFI_IFR_FORM_SET ( EFI_SNP_FORMSET_GUID,
819: EFI_SNP_FORMSET_TITLE,
820: EFI_SNP_FORMSET_HELP,
821: typeof ( efi_snp_formset.FormSet ),
822: EFI_HII_PLATFORM_SETUP_FORMSET_GUID ),
823: .Class = EFI_IFR_GUID_CLASS ( EFI_NETWORK_DEVICE_CLASS ),
824: .SubClass = EFI_IFR_GUID_SUBCLASS ( 0x03 ),
825: .Form = EFI_IFR_FORM ( EFI_SNP_FORM, EFI_SNP_FORMSET_TITLE ),
826: .ProductText = EFI_IFR_TEXT ( EFI_SNP_PRODUCT_PROMPT,
827: EFI_SNP_PRODUCT_HELP,
828: EFI_SNP_PRODUCT_TEXT ),
829: .VersionText = EFI_IFR_TEXT ( EFI_SNP_VERSION_PROMPT,
830: EFI_SNP_VERSION_HELP,
831: EFI_SNP_VERSION_TEXT ),
832: .DriverText = EFI_IFR_TEXT ( EFI_SNP_DRIVER_PROMPT,
833: EFI_SNP_DRIVER_HELP,
834: EFI_SNP_DRIVER_TEXT ),
835: .DeviceText = EFI_IFR_TEXT ( EFI_SNP_DEVICE_PROMPT,
836: EFI_SNP_DEVICE_HELP,
837: EFI_SNP_DEVICE_TEXT ),
838: .EndForm = EFI_IFR_END(),
839: .EndFormSet = EFI_IFR_END(),
840: };
841:
842: /**
843: * Generate EFI SNP string
844: *
845: * @v wbuf Buffer
846: * @v swlen Size of buffer (in wide characters)
847: * @v snpdev SNP device
848: * @ret wlen Length of string (in wide characters)
849: */
850: static int efi_snp_string ( wchar_t *wbuf, ssize_t swlen,
851: enum efi_snp_hii_string_id id,
852: struct efi_snp_device *snpdev ) {
853: struct net_device *netdev = snpdev->netdev;
854: struct device *dev = netdev->dev;
855:
856: switch ( id ) {
857: case EFI_SNP_LANGUAGE_NAME:
858: return efi_ssnprintf ( wbuf, swlen, "English" );
859: case EFI_SNP_FORMSET_TITLE:
860: return efi_ssnprintf ( wbuf, swlen, "%s (%s)",
861: ( PRODUCT_NAME[0] ?
862: PRODUCT_NAME : PRODUCT_SHORT_NAME ),
863: netdev_addr ( netdev ) );
864: case EFI_SNP_FORMSET_HELP:
865: return efi_ssnprintf ( wbuf, swlen,
866: "Configure " PRODUCT_SHORT_NAME );
867: case EFI_SNP_PRODUCT_PROMPT:
868: return efi_ssnprintf ( wbuf, swlen, "Name" );
869: case EFI_SNP_PRODUCT_HELP:
870: return efi_ssnprintf ( wbuf, swlen, "Firmware product name" );
871: case EFI_SNP_PRODUCT_TEXT:
872: return efi_ssnprintf ( wbuf, swlen, "%s",
873: ( PRODUCT_NAME[0] ?
874: PRODUCT_NAME : PRODUCT_SHORT_NAME ) );
875: case EFI_SNP_VERSION_PROMPT:
876: return efi_ssnprintf ( wbuf, swlen, "Version" );
877: case EFI_SNP_VERSION_HELP:
878: return efi_ssnprintf ( wbuf, swlen, "Firmware version" );
879: case EFI_SNP_VERSION_TEXT:
880: return efi_ssnprintf ( wbuf, swlen, VERSION );
881: case EFI_SNP_DRIVER_PROMPT:
882: return efi_ssnprintf ( wbuf, swlen, "Driver" );
883: case EFI_SNP_DRIVER_HELP:
884: return efi_ssnprintf ( wbuf, swlen, "Firmware driver" );
885: case EFI_SNP_DRIVER_TEXT:
886: return efi_ssnprintf ( wbuf, swlen, "%s", dev->driver_name );
887: case EFI_SNP_DEVICE_PROMPT:
888: return efi_ssnprintf ( wbuf, swlen, "Device" );
889: case EFI_SNP_DEVICE_HELP:
890: return efi_ssnprintf ( wbuf, swlen, "Hardware device" );
891: case EFI_SNP_DEVICE_TEXT:
892: return efi_ssnprintf ( wbuf, swlen, "%s", dev->name );
893: default:
894: assert ( 0 );
895: return 0;
896: }
897: }
898:
899: /**
900: * Generate EFI SNP string package
901: *
902: * @v strings String package header buffer
903: * @v max_len Buffer length
904: * @v snpdev SNP device
905: * @ret len Length of string package
906: */
907: static int efi_snp_strings ( EFI_HII_STRING_PACKAGE_HDR *strings,
908: size_t max_len, struct efi_snp_device *snpdev ) {
909: static const char language[] = "en-us";
910: void *buf = strings;
911: ssize_t remaining = max_len;
912: size_t hdrsize;
913: EFI_HII_SIBT_STRING_UCS2_BLOCK *string;
914: ssize_t wremaining;
915: size_t string_wlen;
916: unsigned int id;
917: EFI_HII_STRING_BLOCK *end;
918: size_t len;
919:
920: /* Calculate header size */
921: hdrsize = ( offsetof ( typeof ( *strings ), Language ) +
922: sizeof ( language ) );
923: buf += hdrsize;
924: remaining -= hdrsize;
925:
926: /* Fill in strings */
927: for ( id = 1 ; id < EFI_SNP_MAX_STRING_ID ; id++ ) {
928: string = buf;
929: if ( remaining >= ( ( ssize_t ) sizeof ( string->Header ) ) )
930: string->Header.BlockType = EFI_HII_SIBT_STRING_UCS2;
931: buf += offsetof ( typeof ( *string ), StringText );
932: remaining -= offsetof ( typeof ( *string ), StringText );
933: wremaining = ( remaining /
934: ( ( ssize_t ) sizeof ( string->StringText[0] )));
935: assert ( ! ( ( remaining <= 0 ) && ( wremaining > 0 ) ) );
936: string_wlen = efi_snp_string ( string->StringText, wremaining,
937: id, snpdev );
938: buf += ( ( string_wlen + 1 /* wNUL */ ) *
939: sizeof ( string->StringText[0] ) );
940: remaining -= ( ( string_wlen + 1 /* wNUL */ ) *
941: sizeof ( string->StringText[0] ) );
942: }
943:
944: /* Fill in end marker */
945: end = buf;
946: if ( remaining >= ( ( ssize_t ) sizeof ( *end ) ) )
947: end->BlockType = EFI_HII_SIBT_END;
948: buf += sizeof ( *end );
949: remaining -= sizeof ( *end );
950:
951: /* Calculate overall length */
952: len = ( max_len - remaining );
953:
954: /* Fill in string package header */
955: if ( strings ) {
956: memset ( strings, 0, sizeof ( *strings ) );
957: strings->Header.Length = len;
958: strings->Header.Type = EFI_HII_PACKAGE_STRINGS;
959: strings->HdrSize = hdrsize;
960: strings->StringInfoOffset = hdrsize;
961: strings->LanguageName = EFI_SNP_LANGUAGE_NAME;
962: memcpy ( strings->Language, language, sizeof ( language ) );
963: }
964:
965: return len;
966: }
967:
968: /**
969: * Generate EFI SNP package list
970: *
971: * @v snpdev SNP device
972: * @ret package_list Package list, or NULL on error
973: *
974: * The package list is allocated using malloc(), and must eventually
975: * be freed by the caller.
976: */
977: static EFI_HII_PACKAGE_LIST_HEADER *
978: efi_snp_package_list ( struct efi_snp_device *snpdev ) {
979: size_t strings_len = efi_snp_strings ( NULL, 0, snpdev );
980: struct {
981: EFI_HII_PACKAGE_LIST_HEADER header;
982: struct efi_snp_formset formset;
983: union {
984: EFI_HII_STRING_PACKAGE_HDR strings;
985: uint8_t pad[strings_len];
986: } __attribute__ (( packed )) strings;
987: EFI_HII_PACKAGE_HEADER end;
988: } __attribute__ (( packed )) *package_list;
989:
990: /* Allocate package list */
991: package_list = zalloc ( sizeof ( *package_list ) );
992: if ( ! package_list )
993: return NULL;
994:
995: /* Populate package list */
996: memcpy ( &package_list->header.PackageListGuid,
997: &efi_snp_formset.FormSet.FormSet.Guid,
998: sizeof ( package_list->header.PackageListGuid ) );
999: package_list->header.PackageLength = sizeof ( *package_list );
1000: memcpy ( &package_list->formset, &efi_snp_formset,
1001: sizeof ( package_list->formset ) );
1002: efi_snp_strings ( &package_list->strings.strings,
1003: sizeof ( package_list->strings ), snpdev );
1004: package_list->end.Length = sizeof ( package_list->end );
1005: package_list->end.Type = EFI_HII_PACKAGE_END;
1006:
1007: return &package_list->header;
1008: }
1009:
1010: /**
1011: * Fetch configuration
1012: *
1013: * @v hii HII configuration access protocol
1014: * @v request Configuration to fetch
1015: * @ret progress Progress made through configuration to fetch
1016: * @ret results Query results
1017: * @ret efirc EFI status code
1018: */
1019: static EFI_STATUS EFIAPI
1020: efi_snp_hii_extract_config ( const EFI_HII_CONFIG_ACCESS_PROTOCOL *hii,
1021: EFI_STRING request, EFI_STRING *progress,
1022: EFI_STRING *results __unused ) {
1023: struct efi_snp_device *snpdev =
1024: container_of ( hii, struct efi_snp_device, hii );
1025:
1026: DBGC ( snpdev, "SNPDEV %p ExtractConfig\n", snpdev );
1027:
1028: *progress = request;
1029: return EFI_INVALID_PARAMETER;
1030: }
1031:
1032: /**
1033: * Store configuration
1034: *
1035: * @v hii HII configuration access protocol
1036: * @v config Configuration to store
1037: * @ret progress Progress made through configuration to store
1038: * @ret efirc EFI status code
1039: */
1040: static EFI_STATUS EFIAPI
1041: efi_snp_hii_route_config ( const EFI_HII_CONFIG_ACCESS_PROTOCOL *hii,
1042: EFI_STRING config, EFI_STRING *progress ) {
1043: struct efi_snp_device *snpdev =
1044: container_of ( hii, struct efi_snp_device, hii );
1045:
1046: DBGC ( snpdev, "SNPDEV %p RouteConfig\n", snpdev );
1047:
1048: *progress = config;
1049: return EFI_INVALID_PARAMETER;
1050: }
1051:
1052: /**
1053: * Handle form actions
1054: *
1055: * @v hii HII configuration access protocol
1056: * @v action Form browser action
1057: * @v question_id Question ID
1058: * @v type Type of value
1059: * @v value Value
1060: * @ret action_request Action requested by driver
1061: * @ret efirc EFI status code
1062: */
1063: static EFI_STATUS EFIAPI
1064: efi_snp_hii_callback ( const EFI_HII_CONFIG_ACCESS_PROTOCOL *hii,
1065: EFI_BROWSER_ACTION action __unused,
1066: EFI_QUESTION_ID question_id __unused,
1067: UINT8 type __unused, EFI_IFR_TYPE_VALUE *value __unused,
1068: EFI_BROWSER_ACTION_REQUEST *action_request __unused ) {
1069: struct efi_snp_device *snpdev =
1070: container_of ( hii, struct efi_snp_device, hii );
1071:
1072: DBGC ( snpdev, "SNPDEV %p Callback\n", snpdev );
1073: return EFI_UNSUPPORTED;
1074: }
1075:
1076: /** HII configuration access protocol */
1077: static EFI_HII_CONFIG_ACCESS_PROTOCOL efi_snp_device_hii = {
1078: .ExtractConfig = efi_snp_hii_extract_config,
1079: .RouteConfig = efi_snp_hii_route_config,
1080: .Callback = efi_snp_hii_callback,
1081: };
1082:
1083: /******************************************************************************
1084: *
1085: * iPXE network driver
1086: *
1087: ******************************************************************************
1088: */
1089:
1090: /**
1091: * Locate SNP device corresponding to network device
1092: *
1093: * @v netdev Network device
1094: * @ret snp SNP device, or NULL if not found
1095: */
1096: static struct efi_snp_device * efi_snp_demux ( struct net_device *netdev ) {
1097: struct efi_snp_device *snpdev;
1098:
1099: list_for_each_entry ( snpdev, &efi_snp_devices, list ) {
1100: if ( snpdev->netdev == netdev )
1101: return snpdev;
1102: }
1103: return NULL;
1104: }
1105:
1106: /**
1107: * Create SNP device
1108: *
1109: * @v netdev Network device
1110: * @ret rc Return status code
1111: */
1112: static int efi_snp_probe ( struct net_device *netdev ) {
1113: EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
1114: struct efi_pci_device *efipci;
1115: struct efi_snp_device *snpdev;
1116: EFI_DEVICE_PATH_PROTOCOL *path_end;
1117: MAC_ADDR_DEVICE_PATH *macpath;
1118: size_t path_prefix_len = 0;
1119: EFI_STATUS efirc;
1120: int rc;
1121:
1122: /* Find EFI PCI device */
1123: efipci = efipci_find ( netdev->dev );
1124: if ( ! efipci ) {
1125: DBG ( "SNP skipping non-PCI device %s\n", netdev->name );
1126: rc = 0;
1127: goto err_no_pci;
1128: }
1129:
1130: /* Calculate device path prefix length */
1131: path_end = efi_devpath_end ( efipci->path );
1132: path_prefix_len = ( ( ( void * ) path_end ) -
1133: ( ( void * ) efipci->path ) );
1134:
1135: /* Allocate the SNP device */
1136: snpdev = zalloc ( sizeof ( *snpdev ) + path_prefix_len +
1137: sizeof ( *macpath ) );
1138: if ( ! snpdev ) {
1139: rc = -ENOMEM;
1140: goto err_alloc_snp;
1141: }
1142: snpdev->netdev = netdev_get ( netdev );
1143: snpdev->efipci = efipci;
1144:
1145: /* Sanity check */
1146: if ( netdev->ll_protocol->ll_addr_len > sizeof ( EFI_MAC_ADDRESS ) ) {
1147: DBGC ( snpdev, "SNPDEV %p cannot support link-layer address "
1148: "length %d for %s\n", snpdev,
1149: netdev->ll_protocol->ll_addr_len, netdev->name );
1150: rc = -ENOTSUP;
1151: goto err_ll_addr_len;
1152: }
1153:
1154: /* Populate the SNP structure */
1155: memcpy ( &snpdev->snp, &efi_snp_device_snp, sizeof ( snpdev->snp ) );
1156: snpdev->snp.Mode = &snpdev->mode;
1157: if ( ( efirc = bs->CreateEvent ( EVT_NOTIFY_WAIT, TPL_NOTIFY,
1158: efi_snp_wait_for_packet, snpdev,
1159: &snpdev->snp.WaitForPacket ) ) != 0 ){
1160: DBGC ( snpdev, "SNPDEV %p could not create event: %s\n",
1161: snpdev, efi_strerror ( efirc ) );
1162: rc = EFIRC_TO_RC ( efirc );
1163: goto err_create_event;
1164: }
1165:
1166: /* Populate the SNP mode structure */
1167: snpdev->mode.State = EfiSimpleNetworkStopped;
1168: efi_snp_set_mode ( snpdev );
1169:
1170: /* Populate the NII structure */
1171: snpdev->nii.Revision =
1172: EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION;
1173: strncpy ( snpdev->nii.StringId, "iPXE",
1174: sizeof ( snpdev->nii.StringId ) );
1175:
1176: /* Populate the HII configuration access structure */
1177: memcpy ( &snpdev->hii, &efi_snp_device_hii, sizeof ( snpdev->hii ) );
1178:
1179: /* Populate the device name */
1180: efi_snprintf ( snpdev->name, ( sizeof ( snpdev->name ) /
1181: sizeof ( snpdev->name[0] ) ),
1182: "%s", netdev->name );
1183:
1184: /* Populate the device path */
1185: memcpy ( &snpdev->path, efipci->path, path_prefix_len );
1186: macpath = ( ( ( void * ) &snpdev->path ) + path_prefix_len );
1187: path_end = ( ( void * ) ( macpath + 1 ) );
1188: memset ( macpath, 0, sizeof ( *macpath ) );
1189: macpath->Header.Type = MESSAGING_DEVICE_PATH;
1190: macpath->Header.SubType = MSG_MAC_ADDR_DP;
1191: macpath->Header.Length[0] = sizeof ( *macpath );
1192: memcpy ( &macpath->MacAddress, netdev->ll_addr,
1193: sizeof ( macpath->MacAddress ) );
1194: macpath->IfType = ntohs ( netdev->ll_protocol->ll_proto );
1195: memset ( path_end, 0, sizeof ( *path_end ) );
1196: path_end->Type = END_DEVICE_PATH_TYPE;
1197: path_end->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
1198: path_end->Length[0] = sizeof ( *path_end );
1199:
1200: /* Install the SNP */
1201: if ( ( efirc = bs->InstallMultipleProtocolInterfaces (
1202: &snpdev->handle,
1203: &efi_simple_network_protocol_guid, &snpdev->snp,
1204: &efi_device_path_protocol_guid, &snpdev->path,
1205: &efi_nii_protocol_guid, &snpdev->nii,
1206: &efi_nii31_protocol_guid, &snpdev->nii,
1207: &efi_hii_config_access_protocol_guid, &snpdev->hii,
1208: NULL ) ) != 0 ) {
1209: DBGC ( snpdev, "SNPDEV %p could not install protocols: "
1210: "%s\n", snpdev, efi_strerror ( efirc ) );
1211: rc = EFIRC_TO_RC ( efirc );
1212: goto err_install_protocol_interface;
1213: }
1214:
1215: /* Add as child of PCI device */
1216: if ( ( efirc = efipci_child_add ( efipci, snpdev->handle ) ) != 0 ) {
1217: DBGC ( snpdev, "SNPDEV %p could not become child of " PCI_FMT
1218: ": %s\n", snpdev, PCI_ARGS ( &efipci->pci ),
1219: efi_strerror ( efirc ) );
1220: rc = EFIRC_TO_RC ( efirc );
1221: goto err_efipci_child_add;
1222: }
1223:
1224: /* Create HII package list */
1225: snpdev->package_list = efi_snp_package_list ( snpdev );
1226: if ( ! snpdev->package_list ) {
1227: DBGC ( snpdev, "SNPDEV %p could not create HII package list\n",
1228: snpdev );
1229: rc = -ENOMEM;
1230: goto err_create_hii;
1231: }
1232:
1233: /* Add HII packages */
1234: if ( ( efirc = efihii->NewPackageList ( efihii, snpdev->package_list,
1235: snpdev->handle,
1236: &snpdev->hii_handle ) ) != 0 ) {
1237: DBGC ( snpdev, "SNPDEV %p could not add HII packages: %s\n",
1238: snpdev, efi_strerror ( efirc ) );
1239: rc = EFIRC_TO_RC ( efirc );
1240: goto err_register_hii;
1241: }
1242:
1243: /* Add to list of SNP devices */
1244: list_add ( &snpdev->list, &efi_snp_devices );
1245:
1246: DBGC ( snpdev, "SNPDEV %p installed for %s as device %p\n",
1247: snpdev, netdev->name, snpdev->handle );
1248: return 0;
1249:
1250: efihii->RemovePackageList ( efihii, snpdev->hii_handle );
1251: err_register_hii:
1252: free ( snpdev->package_list );
1253: err_create_hii:
1254: efipci_child_del ( efipci, snpdev->handle );
1255: err_efipci_child_add:
1256: bs->UninstallMultipleProtocolInterfaces (
1257: snpdev->handle,
1258: &efi_simple_network_protocol_guid, &snpdev->snp,
1259: &efi_device_path_protocol_guid, &snpdev->path,
1260: &efi_nii_protocol_guid, &snpdev->nii,
1261: &efi_nii31_protocol_guid, &snpdev->nii,
1262: &efi_hii_config_access_protocol_guid, &snpdev->hii,
1263: NULL );
1264: err_install_protocol_interface:
1265: bs->CloseEvent ( snpdev->snp.WaitForPacket );
1266: err_create_event:
1267: err_ll_addr_len:
1268: netdev_put ( netdev );
1269: free ( snpdev );
1270: err_alloc_snp:
1271: err_no_pci:
1272: return rc;
1273: }
1274:
1275: /**
1276: * Handle SNP device or link state change
1277: *
1278: * @v netdev Network device
1279: */
1280: static void efi_snp_notify ( struct net_device *netdev __unused ) {
1281: /* Nothing to do */
1282: }
1283:
1284: /**
1285: * Destroy SNP device
1286: *
1287: * @v netdev Network device
1288: */
1289: static void efi_snp_remove ( struct net_device *netdev ) {
1290: EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
1291: struct efi_snp_device *snpdev;
1292:
1293: /* Locate SNP device */
1294: snpdev = efi_snp_demux ( netdev );
1295: if ( ! snpdev ) {
1296: DBG ( "SNP skipping non-SNP device %s\n", netdev->name );
1297: return;
1298: }
1299:
1300: /* Uninstall the SNP */
1301: efihii->RemovePackageList ( efihii, snpdev->hii_handle );
1302: free ( snpdev->package_list );
1303: efipci_child_del ( snpdev->efipci, snpdev->handle );
1304: list_del ( &snpdev->list );
1305: bs->UninstallMultipleProtocolInterfaces (
1306: snpdev->handle,
1307: &efi_simple_network_protocol_guid, &snpdev->snp,
1308: &efi_device_path_protocol_guid, &snpdev->path,
1309: &efi_nii_protocol_guid, &snpdev->nii,
1310: &efi_nii31_protocol_guid, &snpdev->nii,
1311: &efi_hii_config_access_protocol_guid, &snpdev->hii,
1312: NULL );
1313: bs->CloseEvent ( snpdev->snp.WaitForPacket );
1314: netdev_put ( snpdev->netdev );
1315: free ( snpdev );
1316: }
1317:
1318: /** SNP driver */
1319: struct net_driver efi_snp_driver __net_driver = {
1320: .name = "SNP",
1321: .probe = efi_snp_probe,
1322: .notify = efi_snp_notify,
1323: .remove = efi_snp_remove,
1324: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.