/* * Copyright (C) 2008 Michael Brown . * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA * 02110-1301, USA. */ FILE_LICENCE ( GPL2_OR_LATER ); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /** List of SNP devices */ static LIST_HEAD ( efi_snp_devices ); /** Network devices are currently claimed for use by iPXE */ static int efi_snp_claimed; /** TPL prior to network devices being claimed */ static EFI_TPL efi_snp_old_tpl; /* Downgrade user experience if configured to do so * * The default UEFI user experience for network boot is somewhat * excremental: only TFTP is available as a download protocol, and if * anything goes wrong the user will be shown just a dot on an * otherwise blank screen. (Some programmer was clearly determined to * win a bet that they could outshine Apple at producing uninformative * error messages.) * * For comparison, the default iPXE user experience provides the * option to use protocols designed more recently than 1980 (such as * HTTP and iSCSI), and if anything goes wrong the the user will be * shown one of over 1200 different error messages, complete with a * link to a wiki page describing that specific error. * * We default to upgrading the user experience to match that available * in a "legacy" BIOS environment, by installing our own instance of * EFI_LOAD_FILE_PROTOCOL. * * Note that unfortunately we can't sensibly provide the choice of * both options to the user in the same build, because the UEFI boot * menu ignores the multitude of ways in which a network device handle * can be described and opaquely labels both menu entries as just "EFI * Network". */ #ifdef EFI_DOWNGRADE_UX static EFI_GUID dummy_load_file_protocol_guid = { 0x6f6c7323, 0x2077, 0x7523, { 0x6e, 0x68, 0x65, 0x6c, 0x70, 0x66, 0x75, 0x6c } }; #define efi_load_file_protocol_guid dummy_load_file_protocol_guid #endif /** * Set EFI SNP mode state * * @v snp SNP interface */ static void efi_snp_set_state ( struct efi_snp_device *snpdev ) { struct net_device *netdev = snpdev->netdev; EFI_SIMPLE_NETWORK_MODE *mode = &snpdev->mode; /* Calculate state */ if ( ! snpdev->started ) { /* Start() method not called; report as Stopped */ mode->State = EfiSimpleNetworkStopped; } else if ( ! netdev_is_open ( netdev ) ) { /* Network device not opened; report as Started */ mode->State = EfiSimpleNetworkStarted; } else if ( efi_snp_claimed ) { /* Network device opened but claimed for use by iPXE; report * as Started to inhibit receive polling. */ mode->State = EfiSimpleNetworkStarted; } else { /* Network device opened and available for use via SNP; report * as Initialized. */ mode->State = EfiSimpleNetworkInitialized; } } /** * Set EFI SNP mode based on iPXE net device parameters * * @v snp SNP interface */ static void efi_snp_set_mode ( struct efi_snp_device *snpdev ) { struct net_device *netdev = snpdev->netdev; EFI_SIMPLE_NETWORK_MODE *mode = &snpdev->mode; struct ll_protocol *ll_protocol = netdev->ll_protocol; unsigned int ll_addr_len = ll_protocol->ll_addr_len; mode->HwAddressSize = ll_addr_len; mode->MediaHeaderSize = ll_protocol->ll_header_len; mode->MaxPacketSize = netdev->max_pkt_len; mode->ReceiveFilterMask = ( EFI_SIMPLE_NETWORK_RECEIVE_UNICAST | EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST | EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST ); assert ( ll_addr_len <= sizeof ( mode->CurrentAddress ) ); memcpy ( &mode->CurrentAddress, netdev->ll_addr, ll_addr_len ); memcpy ( &mode->BroadcastAddress, netdev->ll_broadcast, ll_addr_len ); ll_protocol->init_addr ( netdev->hw_addr, &mode->PermanentAddress ); mode->IfType = ntohs ( ll_protocol->ll_proto ); mode->MacAddressChangeable = TRUE; mode->MediaPresentSupported = TRUE; mode->MediaPresent = ( netdev_link_ok ( netdev ) ? TRUE : FALSE ); } /** * Flush transmit ring and receive queue * * @v snpdev SNP device */ static void efi_snp_flush ( struct efi_snp_device *snpdev ) { struct io_buffer *iobuf; struct io_buffer *tmp; /* Reset transmit completion ring */ snpdev->tx_prod = 0; snpdev->tx_cons = 0; /* Discard any queued receive buffers */ list_for_each_entry_safe ( iobuf, tmp, &snpdev->rx, list ) { list_del ( &iobuf->list ); free_iob ( iobuf ); } } /** * Poll net device and count received packets * * @v snpdev SNP device */ static void efi_snp_poll ( struct efi_snp_device *snpdev ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; struct io_buffer *iobuf; /* Poll network device */ netdev_poll ( snpdev->netdev ); /* Retrieve any received packets */ while ( ( iobuf = netdev_rx_dequeue ( snpdev->netdev ) ) ) { list_add_tail ( &iobuf->list, &snpdev->rx ); snpdev->interrupts |= EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT; bs->SignalEvent ( &snpdev->snp.WaitForPacket ); } } /** * Change SNP state from "stopped" to "started" * * @v snp SNP interface * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_start ( EFI_SIMPLE_NETWORK_PROTOCOL *snp ) { struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); DBGC ( snpdev, "SNPDEV %p START\n", snpdev ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) return EFI_NOT_READY; snpdev->started = 1; efi_snp_set_state ( snpdev ); return 0; } /** * Change SNP state from "started" to "stopped" * * @v snp SNP interface * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_stop ( EFI_SIMPLE_NETWORK_PROTOCOL *snp ) { struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); DBGC ( snpdev, "SNPDEV %p STOP\n", snpdev ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) return EFI_NOT_READY; snpdev->started = 0; efi_snp_set_state ( snpdev ); return 0; } /** * Open the network device * * @v snp SNP interface * @v extra_rx_bufsize Extra RX buffer size, in bytes * @v extra_tx_bufsize Extra TX buffer size, in bytes * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_initialize ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, UINTN extra_rx_bufsize, UINTN extra_tx_bufsize ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); EFI_TPL saved_tpl; int rc; DBGC ( snpdev, "SNPDEV %p INITIALIZE (%ld extra RX, %ld extra TX)\n", snpdev, ( ( unsigned long ) extra_rx_bufsize ), ( ( unsigned long ) extra_tx_bufsize ) ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) { rc = -EAGAIN; goto err_claimed; } /* Raise TPL */ saved_tpl = bs->RaiseTPL ( TPL_CALLBACK ); /* Open network device */ if ( ( rc = netdev_open ( snpdev->netdev ) ) != 0 ) { DBGC ( snpdev, "SNPDEV %p could not open %s: %s\n", snpdev, snpdev->netdev->name, strerror ( rc ) ); goto err_open; } efi_snp_set_state ( snpdev ); err_open: bs->RestoreTPL ( saved_tpl ); err_claimed: return EFIRC ( rc ); } /** * Reset the network device * * @v snp SNP interface * @v ext_verify Extended verification required * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_reset ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, BOOLEAN ext_verify ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); EFI_TPL saved_tpl; int rc; DBGC ( snpdev, "SNPDEV %p RESET (%s extended verification)\n", snpdev, ( ext_verify ? "with" : "without" ) ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) { rc = -EAGAIN; goto err_claimed; } /* Raise TPL */ saved_tpl = bs->RaiseTPL ( TPL_CALLBACK ); /* Close network device */ netdev_close ( snpdev->netdev ); efi_snp_set_state ( snpdev ); efi_snp_flush ( snpdev ); /* Reopen network device */ if ( ( rc = netdev_open ( snpdev->netdev ) ) != 0 ) { DBGC ( snpdev, "SNPDEV %p could not reopen %s: %s\n", snpdev, snpdev->netdev->name, strerror ( rc ) ); goto err_open; } efi_snp_set_state ( snpdev ); err_open: bs->RestoreTPL ( saved_tpl ); err_claimed: return EFIRC ( rc ); } /** * Shut down the network device * * @v snp SNP interface * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_shutdown ( EFI_SIMPLE_NETWORK_PROTOCOL *snp ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); EFI_TPL saved_tpl; DBGC ( snpdev, "SNPDEV %p SHUTDOWN\n", snpdev ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) return EFI_NOT_READY; /* Raise TPL */ saved_tpl = bs->RaiseTPL ( TPL_CALLBACK ); /* Close network device */ netdev_close ( snpdev->netdev ); efi_snp_set_state ( snpdev ); efi_snp_flush ( snpdev ); /* Restore TPL */ bs->RestoreTPL ( saved_tpl ); return 0; } /** * Manage receive filters * * @v snp SNP interface * @v enable Receive filters to enable * @v disable Receive filters to disable * @v mcast_reset Reset multicast filters * @v mcast_count Number of multicast filters * @v mcast Multicast filters * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_receive_filters ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, UINT32 enable, UINT32 disable, BOOLEAN mcast_reset, UINTN mcast_count, EFI_MAC_ADDRESS *mcast ) { struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); unsigned int i; DBGC ( snpdev, "SNPDEV %p RECEIVE_FILTERS %08x&~%08x%s %ld mcast\n", snpdev, enable, disable, ( mcast_reset ? " reset" : "" ), ( ( unsigned long ) mcast_count ) ); for ( i = 0 ; i < mcast_count ; i++ ) { DBGC2_HDA ( snpdev, i, &mcast[i], snpdev->netdev->ll_protocol->ll_addr_len ); } /* Lie through our teeth, otherwise MNP refuses to accept us. * * Return success even if the SNP device is currently claimed * for use by iPXE, since otherwise Windows Deployment * Services refuses to attempt to receive further packets via * our EFI PXE Base Code protocol. */ return 0; } /** * Set station address * * @v snp SNP interface * @v reset Reset to permanent address * @v new New station address * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_station_address ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, BOOLEAN reset, EFI_MAC_ADDRESS *new ) { struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); struct ll_protocol *ll_protocol = snpdev->netdev->ll_protocol; DBGC ( snpdev, "SNPDEV %p STATION_ADDRESS %s\n", snpdev, ( reset ? "reset" : ll_protocol->ntoa ( new ) ) ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) return EFI_NOT_READY; /* Set the MAC address */ if ( reset ) new = &snpdev->mode.PermanentAddress; memcpy ( snpdev->netdev->ll_addr, new, ll_protocol->ll_addr_len ); /* MAC address changes take effect only on netdev_open() */ if ( netdev_is_open ( snpdev->netdev ) ) { DBGC ( snpdev, "SNPDEV %p MAC address changed while net " "device open\n", snpdev ); } return 0; } /** * Get (or reset) statistics * * @v snp SNP interface * @v reset Reset statistics * @v stats_len Size of statistics table * @v stats Statistics table * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_statistics ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, BOOLEAN reset, UINTN *stats_len, EFI_NETWORK_STATISTICS *stats ) { struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); EFI_NETWORK_STATISTICS stats_buf; DBGC ( snpdev, "SNPDEV %p STATISTICS%s", snpdev, ( reset ? " reset" : "" ) ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) return EFI_NOT_READY; /* Gather statistics */ memset ( &stats_buf, 0, sizeof ( stats_buf ) ); stats_buf.TxGoodFrames = snpdev->netdev->tx_stats.good; stats_buf.TxDroppedFrames = snpdev->netdev->tx_stats.bad; stats_buf.TxTotalFrames = ( snpdev->netdev->tx_stats.good + snpdev->netdev->tx_stats.bad ); stats_buf.RxGoodFrames = snpdev->netdev->rx_stats.good; stats_buf.RxDroppedFrames = snpdev->netdev->rx_stats.bad; stats_buf.RxTotalFrames = ( snpdev->netdev->rx_stats.good + snpdev->netdev->rx_stats.bad ); if ( *stats_len > sizeof ( stats_buf ) ) *stats_len = sizeof ( stats_buf ); if ( stats ) memcpy ( stats, &stats_buf, *stats_len ); /* Reset statistics if requested to do so */ if ( reset ) { memset ( &snpdev->netdev->tx_stats, 0, sizeof ( snpdev->netdev->tx_stats ) ); memset ( &snpdev->netdev->rx_stats, 0, sizeof ( snpdev->netdev->rx_stats ) ); } return 0; } /** * Convert multicast IP address to MAC address * * @v snp SNP interface * @v ipv6 Address is IPv6 * @v ip IP address * @v mac MAC address * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_mcast_ip_to_mac ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, BOOLEAN ipv6, EFI_IP_ADDRESS *ip, EFI_MAC_ADDRESS *mac ) { struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); struct ll_protocol *ll_protocol = snpdev->netdev->ll_protocol; const char *ip_str; int rc; ip_str = ( ipv6 ? "(IPv6)" /* FIXME when we have inet6_ntoa() */ : inet_ntoa ( *( ( struct in_addr * ) ip ) ) ); DBGC ( snpdev, "SNPDEV %p MCAST_IP_TO_MAC %s\n", snpdev, ip_str ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) return EFI_NOT_READY; /* Try to hash the address */ if ( ( rc = ll_protocol->mc_hash ( ( ipv6 ? AF_INET6 : AF_INET ), ip, mac ) ) != 0 ) { DBGC ( snpdev, "SNPDEV %p could not hash %s: %s\n", snpdev, ip_str, strerror ( rc ) ); return EFIRC ( rc ); } return 0; } /** * Read or write non-volatile storage * * @v snp SNP interface * @v read Operation is a read * @v offset Starting offset within NVRAM * @v len Length of data buffer * @v data Data buffer * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_nvdata ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, BOOLEAN read, UINTN offset, UINTN len, VOID *data ) { struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); DBGC ( snpdev, "SNPDEV %p NVDATA %s %lx+%lx\n", snpdev, ( read ? "read" : "write" ), ( ( unsigned long ) offset ), ( ( unsigned long ) len ) ); if ( ! read ) DBGC2_HDA ( snpdev, offset, data, len ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) return EFI_NOT_READY; return EFI_UNSUPPORTED; } /** * Read interrupt status and TX recycled buffer status * * @v snp SNP interface * @v interrupts Interrupt status, or NULL * @v txbuf Recycled transmit buffer address, or NULL * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_get_status ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, UINT32 *interrupts, VOID **txbuf ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); EFI_TPL saved_tpl; DBGC2 ( snpdev, "SNPDEV %p GET_STATUS", snpdev ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) { DBGC2 ( snpdev, "\n" ); return EFI_NOT_READY; } /* Raise TPL */ saved_tpl = bs->RaiseTPL ( TPL_CALLBACK ); /* Poll the network device */ efi_snp_poll ( snpdev ); /* Interrupt status. In practice, this seems to be used only * to detect TX completions. */ if ( interrupts ) { *interrupts = snpdev->interrupts; DBGC2 ( snpdev, " INTS:%02x", *interrupts ); snpdev->interrupts = 0; } /* TX completions */ if ( txbuf ) { if ( snpdev->tx_prod != snpdev->tx_cons ) { *txbuf = snpdev->tx[snpdev->tx_cons++ % EFI_SNP_NUM_TX]; } else { *txbuf = NULL; } DBGC2 ( snpdev, " TX:%p", *txbuf ); } /* Restore TPL */ bs->RestoreTPL ( saved_tpl ); DBGC2 ( snpdev, "\n" ); return 0; } /** * Start packet transmission * * @v snp SNP interface * @v ll_header_len Link-layer header length, if to be filled in * @v len Length of data buffer * @v data Data buffer * @v ll_src Link-layer source address, if specified * @v ll_dest Link-layer destination address, if specified * @v net_proto Network-layer protocol (in host order) * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_transmit ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, UINTN ll_header_len, UINTN len, VOID *data, EFI_MAC_ADDRESS *ll_src, EFI_MAC_ADDRESS *ll_dest, UINT16 *net_proto ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); struct ll_protocol *ll_protocol = snpdev->netdev->ll_protocol; struct io_buffer *iobuf; size_t payload_len; unsigned int tx_fill; EFI_TPL saved_tpl; int rc; DBGC2 ( snpdev, "SNPDEV %p TRANSMIT %p+%lx", snpdev, data, ( ( unsigned long ) len ) ); if ( ll_header_len ) { if ( ll_src ) { DBGC2 ( snpdev, " src %s", ll_protocol->ntoa ( ll_src ) ); } if ( ll_dest ) { DBGC2 ( snpdev, " dest %s", ll_protocol->ntoa ( ll_dest ) ); } if ( net_proto ) { DBGC2 ( snpdev, " proto %04x", *net_proto ); } } DBGC2 ( snpdev, "\n" ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) { rc = -EAGAIN; goto err_claimed; } /* Raise TPL */ saved_tpl = bs->RaiseTPL ( TPL_CALLBACK ); /* Sanity checks */ if ( ll_header_len ) { if ( ll_header_len != ll_protocol->ll_header_len ) { DBGC ( snpdev, "SNPDEV %p TX invalid header length " "%ld\n", snpdev, ( ( unsigned long ) ll_header_len ) ); rc = -EINVAL; goto err_sanity; } if ( len < ll_header_len ) { DBGC ( snpdev, "SNPDEV %p invalid packet length %ld\n", snpdev, ( ( unsigned long ) len ) ); rc = -EINVAL; goto err_sanity; } if ( ! ll_dest ) { DBGC ( snpdev, "SNPDEV %p TX missing destination " "address\n", snpdev ); rc = -EINVAL; goto err_sanity; } if ( ! net_proto ) { DBGC ( snpdev, "SNPDEV %p TX missing network " "protocol\n", snpdev ); rc = -EINVAL; goto err_sanity; } if ( ! ll_src ) ll_src = &snpdev->mode.CurrentAddress; } /* Allocate buffer */ payload_len = ( len - ll_protocol->ll_header_len ); iobuf = alloc_iob ( MAX_LL_HEADER_LEN + ( ( payload_len > IOB_ZLEN ) ? payload_len : IOB_ZLEN ) ); if ( ! iobuf ) { DBGC ( snpdev, "SNPDEV %p TX could not allocate %ld-byte " "buffer\n", snpdev, ( ( unsigned long ) len ) ); rc = -ENOMEM; goto err_alloc_iob; } iob_reserve ( iobuf, ( MAX_LL_HEADER_LEN - ll_protocol->ll_header_len ) ); memcpy ( iob_put ( iobuf, len ), data, len ); /* Create link-layer header, if specified */ if ( ll_header_len ) { iob_pull ( iobuf, ll_protocol->ll_header_len ); if ( ( rc = ll_protocol->push ( snpdev->netdev, iobuf, ll_dest, ll_src, htons ( *net_proto ) )) != 0 ){ DBGC ( snpdev, "SNPDEV %p TX could not construct " "header: %s\n", snpdev, strerror ( rc ) ); goto err_ll_push; } } /* Transmit packet */ if ( ( rc = netdev_tx ( snpdev->netdev, iob_disown ( iobuf ) ) ) != 0){ DBGC ( snpdev, "SNPDEV %p TX could not transmit: %s\n", snpdev, strerror ( rc ) ); goto err_tx; } /* Record in transmit completion ring. If we run out of * space, report the failure even though we have already * transmitted the packet. * * This allows us to report completions only for packets for * which we had reported successfully initiating transmission, * while continuing to support clients that never poll for * transmit completions. */ tx_fill = ( snpdev->tx_prod - snpdev->tx_cons ); if ( tx_fill >= EFI_SNP_NUM_TX ) { DBGC ( snpdev, "SNPDEV %p TX completion ring full\n", snpdev ); rc = -ENOBUFS; goto err_ring_full; } snpdev->tx[ snpdev->tx_prod++ % EFI_SNP_NUM_TX ] = data; snpdev->interrupts |= EFI_SIMPLE_NETWORK_TRANSMIT_INTERRUPT; /* Restore TPL */ bs->RestoreTPL ( saved_tpl ); return 0; err_ring_full: err_tx: err_ll_push: free_iob ( iobuf ); err_alloc_iob: err_sanity: bs->RestoreTPL ( saved_tpl ); err_claimed: return EFIRC ( rc ); } /** * Receive packet * * @v snp SNP interface * @v ll_header_len Link-layer header length, if to be filled in * @v len Length of data buffer * @v data Data buffer * @v ll_src Link-layer source address, if specified * @v ll_dest Link-layer destination address, if specified * @v net_proto Network-layer protocol (in host order) * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_receive ( EFI_SIMPLE_NETWORK_PROTOCOL *snp, UINTN *ll_header_len, UINTN *len, VOID *data, EFI_MAC_ADDRESS *ll_src, EFI_MAC_ADDRESS *ll_dest, UINT16 *net_proto ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; struct efi_snp_device *snpdev = container_of ( snp, struct efi_snp_device, snp ); struct ll_protocol *ll_protocol = snpdev->netdev->ll_protocol; struct io_buffer *iobuf; const void *iob_ll_dest; const void *iob_ll_src; uint16_t iob_net_proto; unsigned int iob_flags; size_t copy_len; EFI_TPL saved_tpl; int rc; DBGC2 ( snpdev, "SNPDEV %p RECEIVE %p(+%lx)", snpdev, data, ( ( unsigned long ) *len ) ); /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) { rc = -EAGAIN; goto err_claimed; } /* Raise TPL */ saved_tpl = bs->RaiseTPL ( TPL_CALLBACK ); /* Poll the network device */ efi_snp_poll ( snpdev ); /* Check for an available packet */ iobuf = list_first_entry ( &snpdev->rx, struct io_buffer, list ); if ( ! iobuf ) { DBGC2 ( snpdev, "\n" ); rc = -EAGAIN; goto out_no_packet; } DBGC2 ( snpdev, "+%zx\n", iob_len ( iobuf ) ); /* Dequeue packet */ list_del ( &iobuf->list ); /* Return packet to caller, truncating to buffer length */ copy_len = iob_len ( iobuf ); if ( copy_len > *len ) copy_len = *len; memcpy ( data, iobuf->data, copy_len ); *len = iob_len ( iobuf ); /* Attempt to decode link-layer header */ if ( ( rc = ll_protocol->pull ( snpdev->netdev, iobuf, &iob_ll_dest, &iob_ll_src, &iob_net_proto, &iob_flags ) ) != 0 ) { DBGC ( snpdev, "SNPDEV %p could not parse header: %s\n", snpdev, strerror ( rc ) ); goto out_bad_ll_header; } /* Return link-layer header parameters to caller, if required */ if ( ll_header_len ) *ll_header_len = ll_protocol->ll_header_len; if ( ll_src ) memcpy ( ll_src, iob_ll_src, ll_protocol->ll_addr_len ); if ( ll_dest ) memcpy ( ll_dest, iob_ll_dest, ll_protocol->ll_addr_len ); if ( net_proto ) *net_proto = ntohs ( iob_net_proto ); /* Check buffer length */ rc = ( ( copy_len == *len ) ? 0 : -ERANGE ); out_bad_ll_header: free_iob ( iobuf ); out_no_packet: bs->RestoreTPL ( saved_tpl ); err_claimed: return EFIRC ( rc ); } /** * Poll event * * @v event Event * @v context Event context */ static VOID EFIAPI efi_snp_wait_for_packet ( EFI_EVENT event __unused, VOID *context ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; struct efi_snp_device *snpdev = context; EFI_TPL saved_tpl; DBGCP ( snpdev, "SNPDEV %p WAIT_FOR_PACKET\n", snpdev ); /* Do nothing unless the net device is open */ if ( ! netdev_is_open ( snpdev->netdev ) ) return; /* Do nothing if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) return; /* Raise TPL */ saved_tpl = bs->RaiseTPL ( TPL_CALLBACK ); /* Poll the network device */ efi_snp_poll ( snpdev ); /* Restore TPL */ bs->RestoreTPL ( saved_tpl ); } /** SNP interface */ static EFI_SIMPLE_NETWORK_PROTOCOL efi_snp_device_snp = { .Revision = EFI_SIMPLE_NETWORK_PROTOCOL_REVISION, .Start = efi_snp_start, .Stop = efi_snp_stop, .Initialize = efi_snp_initialize, .Reset = efi_snp_reset, .Shutdown = efi_snp_shutdown, .ReceiveFilters = efi_snp_receive_filters, .StationAddress = efi_snp_station_address, .Statistics = efi_snp_statistics, .MCastIpToMac = efi_snp_mcast_ip_to_mac, .NvData = efi_snp_nvdata, .GetStatus = efi_snp_get_status, .Transmit = efi_snp_transmit, .Receive = efi_snp_receive, }; /****************************************************************************** * * UNDI protocol * ****************************************************************************** */ /** Union type for command parameter blocks */ typedef union { PXE_CPB_STATION_ADDRESS station_address; PXE_CPB_FILL_HEADER fill_header; PXE_CPB_FILL_HEADER_FRAGMENTED fill_header_fragmented; PXE_CPB_TRANSMIT transmit; PXE_CPB_RECEIVE receive; } PXE_CPB_ANY; /** Union type for data blocks */ typedef union { PXE_DB_GET_INIT_INFO get_init_info; PXE_DB_STATION_ADDRESS station_address; PXE_DB_GET_STATUS get_status; PXE_DB_RECEIVE receive; } PXE_DB_ANY; /** * Calculate UNDI byte checksum * * @v data Data * @v len Length of data * @ret sum Checksum */ static uint8_t efi_undi_checksum ( void *data, size_t len ) { uint8_t *bytes = data; uint8_t sum = 0; while ( len-- ) sum += *bytes++; return sum; } /** * Get UNDI SNP device interface number * * @v snpdev SNP device * @ret ifnum UNDI interface number */ static unsigned int efi_undi_ifnum ( struct efi_snp_device *snpdev ) { /* iPXE network device indexes are one-based (leaving zero * meaning "unspecified"). UNDI interface numbers are * zero-based. */ return ( snpdev->netdev->index - 1 ); } /** * Identify UNDI SNP device * * @v ifnum Interface number * @ret snpdev SNP device, or NULL if not found */ static struct efi_snp_device * efi_undi_snpdev ( unsigned int ifnum ) { struct efi_snp_device *snpdev; list_for_each_entry ( snpdev, &efi_snp_devices, list ) { if ( efi_undi_ifnum ( snpdev ) == ifnum ) return snpdev; } return NULL; } /** * Convert EFI status code to UNDI status code * * @v efirc EFI status code * @ret statcode UNDI status code */ static PXE_STATCODE efi_undi_statcode ( EFI_STATUS efirc ) { switch ( efirc ) { case EFI_INVALID_PARAMETER: return PXE_STATCODE_INVALID_PARAMETER; case EFI_UNSUPPORTED: return PXE_STATCODE_UNSUPPORTED; case EFI_OUT_OF_RESOURCES: return PXE_STATCODE_BUFFER_FULL; case EFI_PROTOCOL_ERROR: return PXE_STATCODE_DEVICE_FAILURE; case EFI_NOT_READY: return PXE_STATCODE_NO_DATA; default: return PXE_STATCODE_INVALID_CDB; } } /** * Get state * * @v snpdev SNP device * @v cdb Command description block * @ret efirc EFI status code */ static EFI_STATUS efi_undi_get_state ( struct efi_snp_device *snpdev, PXE_CDB *cdb ) { EFI_SIMPLE_NETWORK_MODE *mode = &snpdev->mode; DBGC ( snpdev, "UNDI %p GET STATE\n", snpdev ); /* Return current state */ if ( mode->State == EfiSimpleNetworkInitialized ) { cdb->StatFlags |= PXE_STATFLAGS_GET_STATE_INITIALIZED; } else if ( mode->State == EfiSimpleNetworkStarted ) { cdb->StatFlags |= PXE_STATFLAGS_GET_STATE_STARTED; } else { cdb->StatFlags |= PXE_STATFLAGS_GET_STATE_STOPPED; } return 0; } /** * Start * * @v snpdev SNP device * @ret efirc EFI status code */ static EFI_STATUS efi_undi_start ( struct efi_snp_device *snpdev ) { EFI_STATUS efirc; DBGC ( snpdev, "UNDI %p START\n", snpdev ); /* Start SNP device */ if ( ( efirc = efi_snp_start ( &snpdev->snp ) ) != 0 ) return efirc; return 0; } /** * Stop * * @v snpdev SNP device * @ret efirc EFI status code */ static EFI_STATUS efi_undi_stop ( struct efi_snp_device *snpdev ) { EFI_STATUS efirc; DBGC ( snpdev, "UNDI %p STOP\n", snpdev ); /* Stop SNP device */ if ( ( efirc = efi_snp_stop ( &snpdev->snp ) ) != 0 ) return efirc; return 0; } /** * Get initialisation information * * @v snpdev SNP device * @v cdb Command description block * @v db Data block * @ret efirc EFI status code */ static EFI_STATUS efi_undi_get_init_info ( struct efi_snp_device *snpdev, PXE_CDB *cdb, PXE_DB_GET_INIT_INFO *db ) { struct net_device *netdev = snpdev->netdev; struct ll_protocol *ll_protocol = netdev->ll_protocol; DBGC ( snpdev, "UNDI %p GET INIT INFO\n", snpdev ); /* Populate structure */ memset ( db, 0, sizeof ( *db ) ); db->FrameDataLen = ( netdev->max_pkt_len - ll_protocol->ll_header_len ); db->MediaHeaderLen = ll_protocol->ll_header_len; db->HWaddrLen = ll_protocol->ll_addr_len; db->IFtype = ntohs ( ll_protocol->ll_proto ); cdb->StatFlags |= ( PXE_STATFLAGS_CABLE_DETECT_SUPPORTED | PXE_STATFLAGS_GET_STATUS_NO_MEDIA_SUPPORTED ); return 0; } /** * Initialise * * @v snpdev SNP device * @v cdb Command description block * @v efirc EFI status code */ static EFI_STATUS efi_undi_initialize ( struct efi_snp_device *snpdev, PXE_CDB *cdb ) { struct net_device *netdev = snpdev->netdev; EFI_STATUS efirc; DBGC ( snpdev, "UNDI %p INITIALIZE\n", snpdev ); /* Reset SNP device */ if ( ( efirc = efi_snp_initialize ( &snpdev->snp, 0, 0 ) ) != 0 ) return efirc; /* Report link state */ if ( ! netdev_link_ok ( netdev ) ) cdb->StatFlags |= PXE_STATFLAGS_INITIALIZED_NO_MEDIA; return 0; } /** * Reset * * @v snpdev SNP device * @v efirc EFI status code */ static EFI_STATUS efi_undi_reset ( struct efi_snp_device *snpdev ) { EFI_STATUS efirc; DBGC ( snpdev, "UNDI %p RESET\n", snpdev ); /* Reset SNP device */ if ( ( efirc = efi_snp_reset ( &snpdev->snp, 0 ) ) != 0 ) return efirc; return 0; } /** * Shutdown * * @v snpdev SNP device * @v efirc EFI status code */ static EFI_STATUS efi_undi_shutdown ( struct efi_snp_device *snpdev ) { EFI_STATUS efirc; DBGC ( snpdev, "UNDI %p SHUTDOWN\n", snpdev ); /* Reset SNP device */ if ( ( efirc = efi_snp_shutdown ( &snpdev->snp ) ) != 0 ) return efirc; return 0; } /** * Get/set receive filters * * @v snpdev SNP device * @v cdb Command description block * @v efirc EFI status code */ static EFI_STATUS efi_undi_receive_filters ( struct efi_snp_device *snpdev, PXE_CDB *cdb ) { DBGC ( snpdev, "UNDI %p RECEIVE FILTERS\n", snpdev ); /* Mark everything as supported */ cdb->StatFlags |= ( PXE_STATFLAGS_RECEIVE_FILTER_UNICAST | PXE_STATFLAGS_RECEIVE_FILTER_BROADCAST | PXE_STATFLAGS_RECEIVE_FILTER_PROMISCUOUS | PXE_STATFLAGS_RECEIVE_FILTER_ALL_MULTICAST ); return 0; } /** * Get/set station address * * @v snpdev SNP device * @v cdb Command description block * @v cpb Command parameter block * @v efirc EFI status code */ static EFI_STATUS efi_undi_station_address ( struct efi_snp_device *snpdev, PXE_CDB *cdb, PXE_CPB_STATION_ADDRESS *cpb, PXE_DB_STATION_ADDRESS *db ) { struct net_device *netdev = snpdev->netdev; struct ll_protocol *ll_protocol = netdev->ll_protocol; void *mac; int reset; EFI_STATUS efirc; DBGC ( snpdev, "UNDI %p STATION ADDRESS\n", snpdev ); /* Update address if applicable */ reset = ( cdb->OpFlags & PXE_OPFLAGS_STATION_ADDRESS_RESET ); mac = ( cpb ? &cpb->StationAddr : NULL ); if ( ( reset || mac ) && ( ( efirc = efi_snp_station_address ( &snpdev->snp, reset, mac ) ) != 0 ) ) return efirc; /* Fill in current addresses, if applicable */ if ( db ) { memset ( db, 0, sizeof ( *db ) ); memcpy ( &db->StationAddr, netdev->ll_addr, ll_protocol->ll_addr_len ); memcpy ( &db->BroadcastAddr, netdev->ll_broadcast, ll_protocol->ll_addr_len ); memcpy ( &db->PermanentAddr, netdev->hw_addr, ll_protocol->hw_addr_len ); } return 0; } /** * Get interrupt status * * @v snpdev SNP device * @v cdb Command description block * @v db Data block * @v efirc EFI status code */ static EFI_STATUS efi_undi_get_status ( struct efi_snp_device *snpdev, PXE_CDB *cdb, PXE_DB_GET_STATUS *db ) { UINT32 interrupts; VOID *txbuf; struct io_buffer *rxbuf; EFI_STATUS efirc; DBGC2 ( snpdev, "UNDI %p GET STATUS\n", snpdev ); /* Get status */ if ( ( efirc = efi_snp_get_status ( &snpdev->snp, &interrupts, &txbuf ) ) != 0 ) return efirc; /* Report status */ memset ( db, 0, sizeof ( *db ) ); if ( interrupts & EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT ) cdb->StatFlags |= PXE_STATFLAGS_GET_STATUS_RECEIVE; if ( interrupts & EFI_SIMPLE_NETWORK_TRANSMIT_INTERRUPT ) cdb->StatFlags |= PXE_STATFLAGS_GET_STATUS_TRANSMIT; if ( txbuf ) { db->TxBuffer[0] = ( ( intptr_t ) txbuf ); } else { cdb->StatFlags |= PXE_STATFLAGS_GET_STATUS_NO_TXBUFS_WRITTEN; /* The specification states clearly that UNDI drivers * should set TXBUF_QUEUE_EMPTY if all completed * buffer addresses are written into the returned data * block. However, SnpDxe chooses to interpret * TXBUF_QUEUE_EMPTY as a synonym for * NO_TXBUFS_WRITTEN, thereby rendering it entirely * pointless. Work around this UEFI stupidity, as per * usual. */ if ( snpdev->tx_prod == snpdev->tx_cons ) cdb->StatFlags |= PXE_STATFLAGS_GET_STATUS_TXBUF_QUEUE_EMPTY; } rxbuf = list_first_entry ( &snpdev->rx, struct io_buffer, list ); if ( rxbuf ) db->RxFrameLen = iob_len ( rxbuf ); if ( ! netdev_link_ok ( snpdev->netdev ) ) cdb->StatFlags |= PXE_STATFLAGS_GET_STATUS_NO_MEDIA; return 0; } /** * Fill header * * @v snpdev SNP device * @v cdb Command description block * @v cpb Command parameter block * @v efirc EFI status code */ static EFI_STATUS efi_undi_fill_header ( struct efi_snp_device *snpdev, PXE_CDB *cdb, PXE_CPB_ANY *cpb ) { struct net_device *netdev = snpdev->netdev; struct ll_protocol *ll_protocol = netdev->ll_protocol; PXE_CPB_FILL_HEADER *whole = &cpb->fill_header; PXE_CPB_FILL_HEADER_FRAGMENTED *fragged = &cpb->fill_header_fragmented; VOID *data; void *dest; void *src; uint16_t proto; struct io_buffer iobuf; int rc; /* SnpDxe will (pointlessly) use PXE_CPB_FILL_HEADER_FRAGMENTED * even though we choose to explicitly not claim support for * fragments via PXE_ROMID_IMP_FRAG_SUPPORTED. */ if ( cdb->OpFlags & PXE_OPFLAGS_FILL_HEADER_FRAGMENTED ) { data = ( ( void * ) ( intptr_t ) fragged->FragDesc[0].FragAddr); dest = &fragged->DestAddr; src = &fragged->SrcAddr; proto = fragged->Protocol; } else { data = ( ( void * ) ( intptr_t ) whole->MediaHeader ); dest = &whole->DestAddr; src = &whole->SrcAddr; proto = whole->Protocol; } /* Construct link-layer header */ iob_populate ( &iobuf, data, 0, ll_protocol->ll_header_len ); iob_reserve ( &iobuf, ll_protocol->ll_header_len ); if ( ( rc = ll_protocol->push ( netdev, &iobuf, dest, src, proto ) ) != 0 ) return EFIRC ( rc ); return 0; } /** * Transmit * * @v snpdev SNP device * @v cpb Command parameter block * @v efirc EFI status code */ static EFI_STATUS efi_undi_transmit ( struct efi_snp_device *snpdev, PXE_CPB_TRANSMIT *cpb ) { VOID *data = ( ( void * ) ( intptr_t ) cpb->FrameAddr ); EFI_STATUS efirc; DBGC2 ( snpdev, "UNDI %p TRANSMIT\n", snpdev ); /* Transmit packet */ if ( ( efirc = efi_snp_transmit ( &snpdev->snp, 0, cpb->DataLen, data, NULL, NULL, NULL ) ) != 0 ) return efirc; return 0; } /** * Receive * * @v snpdev SNP device * @v cpb Command parameter block * @v efirc EFI status code */ static EFI_STATUS efi_undi_receive ( struct efi_snp_device *snpdev, PXE_CPB_RECEIVE *cpb, PXE_DB_RECEIVE *db ) { struct net_device *netdev = snpdev->netdev; struct ll_protocol *ll_protocol = netdev->ll_protocol; VOID *data = ( ( void * ) ( intptr_t ) cpb->BufferAddr ); UINTN hdr_len; UINTN len = cpb->BufferLen; EFI_MAC_ADDRESS src; EFI_MAC_ADDRESS dest; UINT16 proto; EFI_STATUS efirc; DBGC2 ( snpdev, "UNDI %p RECEIVE\n", snpdev ); /* Receive packet */ if ( ( efirc = efi_snp_receive ( &snpdev->snp, &hdr_len, &len, data, &src, &dest, &proto ) ) != 0 ) return efirc; /* Describe frame */ memset ( db, 0, sizeof ( *db ) ); memcpy ( &db->SrcAddr, &src, ll_protocol->ll_addr_len ); memcpy ( &db->DestAddr, &dest, ll_protocol->ll_addr_len ); db->FrameLen = len; db->Protocol = proto; db->MediaHeaderLen = ll_protocol->ll_header_len; db->Type = PXE_FRAME_TYPE_PROMISCUOUS; return 0; } /** UNDI entry point */ static EFIAPI VOID efi_undi_issue ( UINT64 cdb_phys ) { PXE_CDB *cdb = ( ( void * ) ( intptr_t ) cdb_phys ); PXE_CPB_ANY *cpb = ( ( void * ) ( intptr_t ) cdb->CPBaddr ); PXE_DB_ANY *db = ( ( void * ) ( intptr_t ) cdb->DBaddr ); struct efi_snp_device *snpdev; EFI_STATUS efirc; /* Identify device */ snpdev = efi_undi_snpdev ( cdb->IFnum ); if ( ! snpdev ) { DBGC ( cdb, "UNDI invalid interface number %d\n", cdb->IFnum ); cdb->StatCode = PXE_STATCODE_INVALID_CDB; cdb->StatFlags = PXE_STATFLAGS_COMMAND_FAILED; return; } /* Fail if net device is currently claimed for use by iPXE */ if ( efi_snp_claimed ) { cdb->StatCode = PXE_STATCODE_BUSY; cdb->StatFlags = PXE_STATFLAGS_COMMAND_FAILED; return; } /* Handle opcode */ cdb->StatCode = PXE_STATCODE_SUCCESS; cdb->StatFlags = PXE_STATFLAGS_COMMAND_COMPLETE; switch ( cdb->OpCode ) { case PXE_OPCODE_GET_STATE: efirc = efi_undi_get_state ( snpdev, cdb ); break; case PXE_OPCODE_START: efirc = efi_undi_start ( snpdev ); break; case PXE_OPCODE_STOP: efirc = efi_undi_stop ( snpdev ); break; case PXE_OPCODE_GET_INIT_INFO: efirc = efi_undi_get_init_info ( snpdev, cdb, &db->get_init_info ); break; case PXE_OPCODE_INITIALIZE: efirc = efi_undi_initialize ( snpdev, cdb ); break; case PXE_OPCODE_RESET: efirc = efi_undi_reset ( snpdev ); break; case PXE_OPCODE_SHUTDOWN: efirc = efi_undi_shutdown ( snpdev ); break; case PXE_OPCODE_RECEIVE_FILTERS: efirc = efi_undi_receive_filters ( snpdev, cdb ); break; case PXE_OPCODE_STATION_ADDRESS: efirc = efi_undi_station_address ( snpdev, cdb, &cpb->station_address, &db->station_address ); break; case PXE_OPCODE_GET_STATUS: efirc = efi_undi_get_status ( snpdev, cdb, &db->get_status ); break; case PXE_OPCODE_FILL_HEADER: efirc = efi_undi_fill_header ( snpdev, cdb, cpb ); break; case PXE_OPCODE_TRANSMIT: efirc = efi_undi_transmit ( snpdev, &cpb->transmit ); break; case PXE_OPCODE_RECEIVE: efirc = efi_undi_receive ( snpdev, &cpb->receive, &db->receive ); break; default: DBGC ( snpdev, "UNDI %p unsupported opcode %#04x\n", snpdev, cdb->OpCode ); efirc = EFI_UNSUPPORTED; break; } /* Convert EFI status code to UNDI status code */ if ( efirc != 0 ) { cdb->StatFlags &= ~PXE_STATFLAGS_STATUS_MASK; cdb->StatFlags |= PXE_STATFLAGS_COMMAND_FAILED; cdb->StatCode = efi_undi_statcode ( efirc ); } } /** UNDI interface * * Must be aligned on a 16-byte boundary, for no particularly good * reason. */ static PXE_SW_UNDI efi_snp_undi __attribute__ (( aligned ( 16 ) )) = { .Signature = PXE_ROMID_SIGNATURE, .Len = sizeof ( efi_snp_undi ), .Rev = PXE_ROMID_REV, .MajorVer = PXE_ROMID_MAJORVER, .MinorVer = PXE_ROMID_MINORVER, .Implementation = ( PXE_ROMID_IMP_SW_VIRT_ADDR | PXE_ROMID_IMP_STATION_ADDR_SETTABLE | PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED | PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED | PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED | PXE_ROMID_IMP_TX_COMPLETE_INT_SUPPORTED | PXE_ROMID_IMP_PACKET_RX_INT_SUPPORTED ), /* SnpDxe checks that BusCnt is non-zero. It makes no further * use of BusCnt, and never looks as BusType[]. As with much * of the EDK2 code, this check seems to serve no purpose * whatsoever but must nonetheless be humoured. */ .BusCnt = 1, .BusType[0] = PXE_BUSTYPE ( 'i', 'P', 'X', 'E' ), }; /** Network Identification Interface (NII) */ static EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL efi_snp_device_nii = { .Revision = EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION, .StringId = "UNDI", .Type = EfiNetworkInterfaceUndi, .MajorVer = 3, .MinorVer = 1, .Ipv6Supported = TRUE, /* This is a raw packet interface, FFS! */ }; /****************************************************************************** * * Component name protocol * ****************************************************************************** */ /** * Look up driver name * * @v name2 Component name protocol * @v language Language to use * @v driver_name Driver name to fill in * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_get_driver_name ( EFI_COMPONENT_NAME2_PROTOCOL *name2, CHAR8 *language __unused, CHAR16 **driver_name ) { struct efi_snp_device *snpdev = container_of ( name2, struct efi_snp_device, name2 ); *driver_name = snpdev->driver_name; return 0; } /** * Look up controller name * * @v name2 Component name protocol * @v device Device * @v child Child device, or NULL * @v language Language to use * @v driver_name Device name to fill in * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_get_controller_name ( EFI_COMPONENT_NAME2_PROTOCOL *name2, EFI_HANDLE device __unused, EFI_HANDLE child __unused, CHAR8 *language __unused, CHAR16 **controller_name ) { struct efi_snp_device *snpdev = container_of ( name2, struct efi_snp_device, name2 ); *controller_name = snpdev->controller_name; return 0; } /****************************************************************************** * * Load file protocol * ****************************************************************************** */ /** * Load file * * @v loadfile Load file protocol * @v path File path * @v booting Loading as part of a boot attempt * @ret efirc EFI status code */ static EFI_STATUS EFIAPI efi_snp_load_file ( EFI_LOAD_FILE_PROTOCOL *load_file, EFI_DEVICE_PATH_PROTOCOL *path __unused, BOOLEAN booting, UINTN *len __unused, VOID *data __unused ) { struct efi_snp_device *snpdev = container_of ( load_file, struct efi_snp_device, load_file ); struct net_device *netdev = snpdev->netdev; int rc; /* Fail unless this is a boot attempt */ if ( ! booting ) { DBGC ( snpdev, "SNPDEV %p cannot load non-boot file\n", snpdev ); return EFI_UNSUPPORTED; } /* Claim network devices for use by iPXE */ efi_snp_claim(); /* Start watchdog holdoff timer */ efi_watchdog_start(); /* Boot from network device */ if ( ( rc = ipxe ( netdev ) ) != 0 ) goto err_ipxe; /* Reset console */ console_reset(); err_ipxe: efi_watchdog_stop(); efi_snp_release(); return EFIRC ( rc ); } /** Load file protocol */ static EFI_LOAD_FILE_PROTOCOL efi_snp_load_file_protocol = { .LoadFile = efi_snp_load_file, }; /****************************************************************************** * * iPXE network driver * ****************************************************************************** */ /** * Locate SNP device corresponding to network device * * @v netdev Network device * @ret snp SNP device, or NULL if not found */ static struct efi_snp_device * efi_snp_demux ( struct net_device *netdev ) { struct efi_snp_device *snpdev; list_for_each_entry ( snpdev, &efi_snp_devices, list ) { if ( snpdev->netdev == netdev ) return snpdev; } return NULL; } /** * Create SNP device * * @v netdev Network device * @ret rc Return status code */ static int efi_snp_probe ( struct net_device *netdev ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; struct efi_device *efidev; struct efi_snp_device *snpdev; EFI_DEVICE_PATH_PROTOCOL *path_end; MAC_ADDR_DEVICE_PATH *macpath; VLAN_DEVICE_PATH *vlanpath; size_t path_prefix_len = 0; unsigned int ifcnt; unsigned int tag; void *interface; EFI_STATUS efirc; int rc; /* Find parent EFI device */ efidev = efidev_parent ( netdev->dev ); if ( ! efidev ) { DBG ( "SNP skipping non-EFI device %s\n", netdev->name ); rc = 0; goto err_no_efidev; } /* Allocate the SNP device */ snpdev = zalloc ( sizeof ( *snpdev ) ); if ( ! snpdev ) { rc = -ENOMEM; goto err_alloc_snp; } snpdev->netdev = netdev_get ( netdev ); snpdev->efidev = efidev; INIT_LIST_HEAD ( &snpdev->rx ); /* Sanity check */ if ( netdev->ll_protocol->ll_addr_len > sizeof ( EFI_MAC_ADDRESS ) ) { DBGC ( snpdev, "SNPDEV %p cannot support link-layer address " "length %d for %s\n", snpdev, netdev->ll_protocol->ll_addr_len, netdev->name ); rc = -ENOTSUP; goto err_ll_addr_len; } /* Populate the SNP structure */ memcpy ( &snpdev->snp, &efi_snp_device_snp, sizeof ( snpdev->snp ) ); snpdev->snp.Mode = &snpdev->mode; if ( ( efirc = bs->CreateEvent ( EVT_NOTIFY_WAIT, TPL_NOTIFY, efi_snp_wait_for_packet, snpdev, &snpdev->snp.WaitForPacket ) ) != 0 ){ rc = -EEFI ( efirc ); DBGC ( snpdev, "SNPDEV %p could not create event: %s\n", snpdev, strerror ( rc ) ); goto err_create_event; } /* Populate the SNP mode structure */ snpdev->mode.State = EfiSimpleNetworkStopped; efi_snp_set_mode ( snpdev ); /* Populate the NII structure */ memcpy ( &snpdev->nii, &efi_snp_device_nii, sizeof ( snpdev->nii ) ); snpdev->nii.Id = ( ( intptr_t ) &efi_snp_undi ); snpdev->nii.IfNum = efi_undi_ifnum ( snpdev ); efi_snp_undi.EntryPoint = ( ( intptr_t ) efi_undi_issue ); ifcnt = ( ( efi_snp_undi.IFcntExt << 8 ) | efi_snp_undi.IFcnt ); if ( ifcnt < snpdev->nii.IfNum ) ifcnt = snpdev->nii.IfNum; efi_snp_undi.IFcnt = ( ifcnt & 0xff ); efi_snp_undi.IFcntExt = ( ifcnt >> 8 ); efi_snp_undi.Fudge -= efi_undi_checksum ( &efi_snp_undi, sizeof ( efi_snp_undi ) ); /* Populate the component name structure */ efi_snprintf ( snpdev->driver_name, ( sizeof ( snpdev->driver_name ) / sizeof ( snpdev->driver_name[0] ) ), "%s %s", product_short_name, netdev->dev->driver_name ); efi_snprintf ( snpdev->controller_name, ( sizeof ( snpdev->controller_name ) / sizeof ( snpdev->controller_name[0] ) ), "%s %s (%s, %s)", product_short_name, netdev->dev->driver_name, netdev->dev->name, netdev_addr ( netdev ) ); snpdev->name2.GetDriverName = efi_snp_get_driver_name; snpdev->name2.GetControllerName = efi_snp_get_controller_name; snpdev->name2.SupportedLanguages = "en"; /* Populate the load file protocol structure */ memcpy ( &snpdev->load_file, &efi_snp_load_file_protocol, sizeof ( snpdev->load_file ) ); /* Populate the device name */ efi_snprintf ( snpdev->name, ( sizeof ( snpdev->name ) / sizeof ( snpdev->name[0] ) ), "%s", netdev->name ); /* Allocate the new device path */ path_prefix_len = efi_devpath_len ( efidev->path ); snpdev->path = zalloc ( path_prefix_len + sizeof ( *macpath ) + sizeof ( *vlanpath ) + sizeof ( *path_end ) ); if ( ! snpdev->path ) { rc = -ENOMEM; goto err_alloc_device_path; } /* Populate the device path */ memcpy ( snpdev->path, efidev->path, path_prefix_len ); macpath = ( ( ( void * ) snpdev->path ) + path_prefix_len ); memset ( macpath, 0, sizeof ( *macpath ) ); macpath->Header.Type = MESSAGING_DEVICE_PATH; macpath->Header.SubType = MSG_MAC_ADDR_DP; macpath->Header.Length[0] = sizeof ( *macpath ); memcpy ( &macpath->MacAddress, netdev->ll_addr, netdev->ll_protocol->ll_addr_len ); macpath->IfType = ntohs ( netdev->ll_protocol->ll_proto ); if ( ( tag = vlan_tag ( netdev ) ) ) { vlanpath = ( ( ( void * ) macpath ) + sizeof ( *macpath ) ); memset ( vlanpath, 0, sizeof ( *vlanpath ) ); vlanpath->Header.Type = MESSAGING_DEVICE_PATH; vlanpath->Header.SubType = MSG_VLAN_DP; vlanpath->Header.Length[0] = sizeof ( *vlanpath ); vlanpath->VlanId = tag; path_end = ( ( ( void * ) vlanpath ) + sizeof ( *vlanpath ) ); } else { path_end = ( ( ( void * ) macpath ) + sizeof ( *macpath ) ); } memset ( path_end, 0, sizeof ( *path_end ) ); path_end->Type = END_DEVICE_PATH_TYPE; path_end->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE; path_end->Length[0] = sizeof ( *path_end ); /* Install the SNP */ if ( ( efirc = bs->InstallMultipleProtocolInterfaces ( &snpdev->handle, &efi_simple_network_protocol_guid, &snpdev->snp, &efi_device_path_protocol_guid, snpdev->path, &efi_nii_protocol_guid, &snpdev->nii, &efi_nii31_protocol_guid, &snpdev->nii, &efi_component_name2_protocol_guid, &snpdev->name2, &efi_load_file_protocol_guid, &snpdev->load_file, NULL ) ) != 0 ) { rc = -EEFI ( efirc ); DBGC ( snpdev, "SNPDEV %p could not install protocols: %s\n", snpdev, strerror ( rc ) ); goto err_install_protocol_interface; } /* SnpDxe will repeatedly start up and shut down our NII/UNDI * interface (in order to obtain the MAC address) before * discovering that it cannot install another SNP on the same * handle. This causes the underlying network device to be * unexpectedly closed. * * Prevent this by opening our own NII (and NII31) protocol * instances to prevent SnpDxe from attempting to bind to * them. */ if ( ( efirc = bs->OpenProtocol ( snpdev->handle, &efi_nii_protocol_guid, &interface, efi_image_handle, snpdev->handle, ( EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE )))!=0){ rc = -EEFI ( efirc ); DBGC ( snpdev, "SNPDEV %p could not open NII protocol: %s\n", snpdev, strerror ( rc ) ); goto err_open_nii; } if ( ( efirc = bs->OpenProtocol ( snpdev->handle, &efi_nii31_protocol_guid, &interface, efi_image_handle, snpdev->handle, ( EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE )))!=0){ rc = -EEFI ( efirc ); DBGC ( snpdev, "SNPDEV %p could not open NII31 protocol: %s\n", snpdev, strerror ( rc ) ); goto err_open_nii31; } /* Add as child of EFI parent device */ if ( ( rc = efi_child_add ( efidev->device, snpdev->handle ) ) != 0 ) { DBGC ( snpdev, "SNPDEV %p could not become child of %s: %s\n", snpdev, efi_handle_name ( efidev->device ), strerror ( rc ) ); goto err_efi_child_add; } /* Install HII */ if ( ( rc = efi_snp_hii_install ( snpdev ) ) != 0 ) { DBGC ( snpdev, "SNPDEV %p could not install HII: %s\n", snpdev, strerror ( rc ) ); /* HII fails on several platforms. It's * non-essential, so treat this as a non-fatal * error. */ } /* Add to list of SNP devices */ list_add ( &snpdev->list, &efi_snp_devices ); /* Close device path */ bs->CloseProtocol ( efidev->device, &efi_device_path_protocol_guid, efi_image_handle, efidev->device ); DBGC ( snpdev, "SNPDEV %p installed for %s as device %s\n", snpdev, netdev->name, efi_handle_name ( snpdev->handle ) ); return 0; list_del ( &snpdev->list ); if ( snpdev->package_list ) efi_snp_hii_uninstall ( snpdev ); efi_child_del ( efidev->device, snpdev->handle ); err_efi_child_add: bs->CloseProtocol ( snpdev->handle, &efi_nii_protocol_guid, efi_image_handle, snpdev->handle ); err_open_nii: bs->CloseProtocol ( snpdev->handle, &efi_nii31_protocol_guid, efi_image_handle, snpdev->handle ); err_open_nii31: bs->UninstallMultipleProtocolInterfaces ( snpdev->handle, &efi_simple_network_protocol_guid, &snpdev->snp, &efi_device_path_protocol_guid, snpdev->path, &efi_nii_protocol_guid, &snpdev->nii, &efi_nii31_protocol_guid, &snpdev->nii, &efi_component_name2_protocol_guid, &snpdev->name2, &efi_load_file_protocol_guid, &snpdev->load_file, NULL ); err_install_protocol_interface: free ( snpdev->path ); err_alloc_device_path: bs->CloseEvent ( snpdev->snp.WaitForPacket ); err_create_event: err_ll_addr_len: netdev_put ( netdev ); free ( snpdev ); err_alloc_snp: err_no_efidev: return rc; } /** * Handle SNP device or link state change * * @v netdev Network device */ static void efi_snp_notify ( struct net_device *netdev ) { struct efi_snp_device *snpdev; /* Locate SNP device */ snpdev = efi_snp_demux ( netdev ); if ( ! snpdev ) { DBG ( "SNP skipping non-SNP device %s\n", netdev->name ); return; } /* Update link state */ snpdev->mode.MediaPresent = ( netdev_link_ok ( netdev ) ? TRUE : FALSE ); DBGC ( snpdev, "SNPDEV %p link is %s\n", snpdev, ( snpdev->mode.MediaPresent ? "up" : "down" ) ); /* Update mode state */ efi_snp_set_state ( snpdev ); } /** * Destroy SNP device * * @v netdev Network device */ static void efi_snp_remove ( struct net_device *netdev ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; struct efi_snp_device *snpdev; /* Locate SNP device */ snpdev = efi_snp_demux ( netdev ); if ( ! snpdev ) { DBG ( "SNP skipping non-SNP device %s\n", netdev->name ); return; } /* Uninstall the SNP */ list_del ( &snpdev->list ); if ( snpdev->package_list ) efi_snp_hii_uninstall ( snpdev ); efi_child_del ( snpdev->efidev->device, snpdev->handle ); bs->CloseProtocol ( snpdev->handle, &efi_nii_protocol_guid, efi_image_handle, snpdev->handle ); bs->CloseProtocol ( snpdev->handle, &efi_nii31_protocol_guid, efi_image_handle, snpdev->handle ); bs->UninstallMultipleProtocolInterfaces ( snpdev->handle, &efi_simple_network_protocol_guid, &snpdev->snp, &efi_device_path_protocol_guid, snpdev->path, &efi_nii_protocol_guid, &snpdev->nii, &efi_nii31_protocol_guid, &snpdev->nii, &efi_component_name2_protocol_guid, &snpdev->name2, &efi_load_file_protocol_guid, &snpdev->load_file, NULL ); free ( snpdev->path ); bs->CloseEvent ( snpdev->snp.WaitForPacket ); netdev_put ( snpdev->netdev ); free ( snpdev ); } /** SNP driver */ struct net_driver efi_snp_driver __net_driver = { .name = "SNP", .probe = efi_snp_probe, .notify = efi_snp_notify, .remove = efi_snp_remove, }; /** * Find SNP device by EFI device handle * * @v handle EFI device handle * @ret snpdev SNP device, or NULL */ struct efi_snp_device * find_snpdev ( EFI_HANDLE handle ) { struct efi_snp_device *snpdev; list_for_each_entry ( snpdev, &efi_snp_devices, list ) { if ( snpdev->handle == handle ) return snpdev; } return NULL; } /** * Get most recently opened SNP device * * @ret snpdev Most recently opened SNP device, or NULL */ struct efi_snp_device * last_opened_snpdev ( void ) { struct net_device *netdev; netdev = last_opened_netdev(); if ( ! netdev ) return NULL; return efi_snp_demux ( netdev ); } /** * Add to SNP claimed/released count * * @v delta Claim count change */ void efi_snp_add_claim ( int delta ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; struct efi_snp_device *snpdev; /* Raise TPL if we are about to claim devices */ if ( ! efi_snp_claimed ) efi_snp_old_tpl = bs->RaiseTPL ( TPL_CALLBACK ); /* Claim SNP devices */ efi_snp_claimed += delta; assert ( efi_snp_claimed >= 0 ); /* Update SNP mode state for each interface */ list_for_each_entry ( snpdev, &efi_snp_devices, list ) efi_snp_set_state ( snpdev ); /* Restore TPL if we have released devices */ if ( ! efi_snp_claimed ) bs->RestoreTPL ( efi_snp_old_tpl ); }