struct gdb_transport *gdbudp_configure ( const char *name, struct sockaddr_in *addr ) {
struct settings *settings;
/* Release old network device */
netdev_put ( netdev );
netdev = find_netdev ( name );
if ( !netdev ) {
return NULL;
}
/* Hold network device */
netdev_get ( netdev );
/* Source UDP port */
source_addr.sin_port = ( addr && addr->sin_port ) ? addr->sin_port : htons ( DEFAULT_PORT );
/* Source IP address */
if ( addr && addr->sin_addr.s_addr ) {
source_addr.sin_addr.s_addr = addr->sin_addr.s_addr;
} else {
settings = netdev_settings ( netdev );
fetch_ipv4_setting ( settings, &ip_setting, &source_addr.sin_addr );
if ( source_addr.sin_addr.s_addr == 0 ) {
netdev_put ( netdev );
netdev = NULL;
return NULL;
}
}
return &udp_gdb_transport;
}
/**
* Remove device
*
* @v func USB function
*/
static void smsc95xx_remove ( struct usb_function *func ) {
struct net_device *netdev = usb_func_get_drvdata ( func );
unregister_netdev ( netdev );
netdev_nullify ( netdev );
netdev_put ( netdev );
}
/**
* Detach driver from device
*
* @v efidev EFI device
*/
void snpnet_stop ( struct efi_device *efidev ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
struct net_device *netdev = efidev_get_drvdata ( efidev );
struct snp_nic *snp = netdev->priv;
EFI_HANDLE device = efidev->device;
EFI_STATUS efirc;
int rc;
/* Unregister network device */
unregister_netdev ( netdev );
/* Stop SNP protocol */
if ( ( efirc = snp->snp->Stop ( snp->snp ) ) != 0 ) {
rc = -EEFI ( efirc );
DBGC ( device, "SNP %s could not stop: %s\n",
efi_handle_name ( device ), strerror ( rc ) );
/* Nothing we can do about this */
}
/* Free network device */
list_del ( &snp->dev.siblings );
netdev_nullify ( netdev );
netdev_put ( netdev );
/* Close SNP protocol */
bs->CloseProtocol ( device, &efi_simple_network_protocol_guid,
efi_image_handle, device );
}
/** Remove the device */
static void af_packet_nic_remove ( struct linux_device *device )
{
struct net_device *netdev = linux_get_drvdata(device);
unregister_netdev(netdev);
netdev_nullify(netdev);
netdev_put(netdev);
}
static void aoe_free ( struct refcnt *refcnt ) {
struct aoe_session *aoe =
container_of ( refcnt, struct aoe_session, refcnt );
netdev_put ( aoe->netdev );
free ( aoe );
}
/**
* Set network device as current PXE network device
*
* @v netdev Network device, or NULL
*/
void pxe_set_netdev ( struct net_device *netdev ) {
if ( pxe_netdev )
netdev_put ( pxe_netdev );
pxe_netdev = NULL;
if ( netdev )
pxe_netdev = netdev_get ( netdev );
}
/**
* Probe PCI device
*
* @v pci PCI device
* @ret rc Return status code
*/
static int intelx_probe ( struct pci_device *pci ) {
struct net_device *netdev;
struct intel_nic *intel;
int rc;
/* Allocate and initialise net device */
netdev = alloc_etherdev ( sizeof ( *intel ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &intelx_operations );
intel = netdev->priv;
pci_set_drvdata ( pci, netdev );
netdev->dev = &pci->dev;
memset ( intel, 0, sizeof ( *intel ) );
intel->port = PCI_FUNC ( pci->busdevfn );
intel_init_ring ( &intel->tx, INTEL_NUM_TX_DESC, INTELX_TD );
intel_init_ring ( &intel->rx, INTEL_NUM_RX_DESC, INTELX_RD );
/* Fix up PCI device */
adjust_pci_device ( pci );
/* Map registers */
intel->regs = ioremap ( pci->membase, INTEL_BAR_SIZE );
if ( ! intel->regs ) {
rc = -ENODEV;
goto err_ioremap;
}
/* Reset the NIC */
if ( ( rc = intelx_reset ( intel ) ) != 0 )
goto err_reset;
/* Fetch MAC address */
if ( ( rc = intelx_fetch_mac ( intel, netdev->hw_addr ) ) != 0 )
goto err_fetch_mac;
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register_netdev;
/* Set initial link state */
intelx_check_link ( netdev );
return 0;
unregister_netdev ( netdev );
err_register_netdev:
err_fetch_mac:
intelx_reset ( intel );
err_reset:
iounmap ( intel->regs );
err_ioremap:
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
return rc;
}
/**
* Execute PXE image
*
* @v image PXE image
* @ret rc Return status code
*/
static int pxe_exec ( struct image *image ) {
userptr_t buffer = real_to_user ( 0, 0x7c00 );
struct net_device *netdev;
int rc;
/* Verify and prepare segment */
if ( ( rc = prep_segment ( buffer, image->len, image->len ) ) != 0 ) {
DBGC ( image, "IMAGE %p could not prepare segment: %s\n",
image, strerror ( rc ) );
return rc;
}
/* Copy image to segment */
memcpy_user ( buffer, 0, image->data, 0, image->len );
/* Arbitrarily pick the most recently opened network device */
if ( ( netdev = last_opened_netdev() ) == NULL ) {
DBGC ( image, "IMAGE %p could not locate PXE net device\n",
image );
return -ENODEV;
}
netdev_get ( netdev );
/* Activate PXE */
pxe_activate ( netdev );
/* Construct fake DHCP packets */
pxe_fake_cached_info();
/* Set PXE command line */
pxe_cmdline = image->cmdline;
/* Reset console since PXE NBP will probably use it */
console_reset();
/* Disable IRQ, if applicable */
if ( netdev_irq_supported ( netdev ) && netdev->dev->desc.irq )
disable_irq ( netdev->dev->desc.irq );
/* Start PXE NBP */
rc = pxe_start_nbp();
/* Clear PXE command line */
pxe_cmdline = NULL;
/* Deactivate PXE */
pxe_deactivate();
/* Try to reopen network device. Ignore errors, since the NBP
* may have called PXENV_STOP_UNDI.
*/
netdev_open ( netdev );
netdev_put ( netdev );
return rc;
}
/**
* Probe PCI device
*
* @v pci PCI device
* @ret rc Return status code
*/
static int skeleton_probe ( struct pci_device *pci ) {
struct net_device *netdev;
struct skeleton_nic *skel;
int rc;
/* Allocate and initialise net device */
netdev = alloc_etherdev ( sizeof ( *skel ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &skeleton_operations );
skel = netdev->priv;
pci_set_drvdata ( pci, netdev );
netdev->dev = &pci->dev;
memset ( skel, 0, sizeof ( *skel ) );
/* Fix up PCI device */
adjust_pci_device ( pci );
/* Map registers */
skel->regs = ioremap ( pci->membase, SKELETON_BAR_SIZE );
/* Reset the NIC */
if ( ( rc = skeleton_reset ( skel ) ) != 0 )
goto err_reset;
/* Initialise and reset MII interface */
mii_init ( &skel->mii, &skeleton_mii_operations );
if ( ( rc = mii_reset ( &skel->mii ) ) != 0 ) {
DBGC ( skel, "SKELETON %p could not reset MII: %s\n",
skel, strerror ( rc ) );
goto err_mii_reset;
}
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register_netdev;
/* Set initial link state */
skeleton_check_link ( netdev );
return 0;
unregister_netdev ( netdev );
err_register_netdev:
err_mii_reset:
skeleton_reset ( skel );
err_reset:
iounmap ( skel->regs );
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
return rc;
}
/**
* Remove device
*
* @v pci PCI device
*/
static void b44_remove(struct pci_device *pci)
{
struct net_device *netdev = pci_get_drvdata(pci);
struct b44_private *bp = netdev_priv(netdev);
ssb_core_disable(bp);
unregister_netdev(netdev);
iounmap(bp->regs);
netdev_nullify(netdev);
netdev_put(netdev);
}
/** Handle a device request for the af_packet driver */
static int af_packet_nic_probe ( struct linux_device *device,
struct linux_device_request *request )
{
struct linux_setting *if_setting;
struct net_device *netdev;
struct af_packet_nic *nic;
int rc;
netdev = alloc_etherdev(sizeof(*nic));
if (! netdev)
return -ENOMEM;
netdev_init(netdev, &af_packet_nic_operations);
nic = netdev->priv;
linux_set_drvdata(device, netdev);
netdev->dev = &device->dev;
memset(nic, 0, sizeof(*nic));
/* Look for the mandatory if setting */
if_setting = linux_find_setting("if", &request->settings);
/* No if setting */
if (! if_setting) {
printf("af_packet missing a mandatory if setting\n");
rc = -EINVAL;
goto err_settings;
}
nic->ifname = if_setting->value;
snprintf ( device->dev.name, sizeof ( device->dev.name ), "%s",
nic->ifname );
device->dev.desc.bus_type = BUS_TYPE_TAP;
af_packet_update_properties(netdev);
if_setting->applied = 1;
/* Apply rest of the settings */
linux_apply_settings(&request->settings, &netdev->settings.settings);
/* Register network device */
if ((rc = register_netdev(netdev)) != 0)
goto err_register;
netdev_link_up(netdev);
return 0;
err_settings:
unregister_netdev(netdev);
err_register:
netdev_nullify(netdev);
netdev_put(netdev);
return rc;
}
/**
* Probe PCI device
*
* @v pci PCI device
* @ret rc Return status code
*/
static int myson_probe ( struct pci_device *pci ) {
struct net_device *netdev;
struct myson_nic *myson;
union myson_physical_address mac;
int rc;
/* Allocate and initialise net device */
netdev = alloc_etherdev ( sizeof ( *myson ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &myson_operations );
myson = netdev->priv;
pci_set_drvdata ( pci, netdev );
netdev->dev = &pci->dev;
memset ( myson, 0, sizeof ( *myson ) );
myson_init_ring ( &myson->tx, MYSON_NUM_TX_DESC, MYSON_TXLBA );
myson_init_ring ( &myson->rx, MYSON_NUM_RX_DESC, MYSON_RXLBA );
/* Fix up PCI device */
adjust_pci_device ( pci );
/* Map registers */
myson->regs = ioremap ( pci->membase, MYSON_BAR_SIZE );
/* Reset the NIC */
if ( ( rc = myson_reset ( myson ) ) != 0 )
goto err_reset;
/* Read MAC address */
mac.reg.low = cpu_to_le32 ( readl ( myson->regs + MYSON_PAR0 ) );
mac.reg.high = cpu_to_le32 ( readl ( myson->regs + MYSON_PAR4 ) );
memcpy ( netdev->hw_addr, mac.raw, ETH_ALEN );
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register_netdev;
/* Mark as link up; we don't yet handle link state */
netdev_link_up ( netdev );
return 0;
unregister_netdev ( netdev );
err_register_netdev:
myson_reset ( myson );
err_reset:
iounmap ( myson->regs );
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
return rc;
}
/**
* Set network device as current PXE network device
*
* @v netdev Network device, or NULL
*/
void pxe_set_netdev ( struct net_device *netdev ) {
if ( pxe_netdev ) {
netdev_rx_unfreeze ( pxe_netdev );
netdev_put ( pxe_netdev );
}
pxe_netdev = NULL;
if ( netdev )
pxe_netdev = netdev_get ( netdev );
}
/**
* Remove PCI device
*
* @v pci PCI device
*/
static void rhine_remove ( struct pci_device *pci ) {
struct net_device *netdev = pci_get_drvdata ( pci );
struct rhine_nic *nic = netdev->priv;
/* Unregister network device */
unregister_netdev ( netdev );
/* Reset card */
rhine_reset ( nic );
/* Free network device */
netdev_nullify ( netdev );
netdev_put ( netdev );
}
/**
* Remove PCI device
*
* @v pci PCI device
*/
static void myson_remove ( struct pci_device *pci ) {
struct net_device *netdev = pci_get_drvdata ( pci );
struct myson_nic *myson = netdev->priv;
/* Unregister network device */
unregister_netdev ( netdev );
/* Reset card */
myson_reset ( myson );
/* Free network device */
netdev_nullify ( netdev );
netdev_put ( netdev );
}
/**
* Remove PCI device
*
* @v pci PCI device
*/
static void skeleton_remove ( struct pci_device *pci ) {
struct net_device *netdev = pci_get_drvdata ( pci );
struct skeleton_nic *skel = netdev->priv;
/* Unregister network device */
unregister_netdev ( netdev );
/* Reset card */
skeleton_reset ( skel );
/* Free network device */
iounmap ( skel->regs );
netdev_nullify ( netdev );
netdev_put ( netdev );
}
/**
* Remove Xen device
*
* @v xendev Xen device
*/
static void netfront_remove ( struct xen_device *xendev ) {
struct net_device *netdev = xen_get_drvdata ( xendev );
struct netfront_nic *netfront = netdev->priv;
struct xen_hypervisor *xen = xendev->xen;
/* Unregister network device */
unregister_netdev ( netdev );
/* Free resources */
xengrant_free ( xen, netfront->refs, NETFRONT_REF_COUNT );
/* Free network device */
netdev_nullify ( netdev );
netdev_put ( netdev );
}
/**
* Remove PCI device
*
* @v pci PCI device
*/
static void intelxvf_remove ( struct pci_device *pci ) {
struct net_device *netdev = pci_get_drvdata ( pci );
struct intel_nic *intel = netdev->priv;
/* Unregister network device */
unregister_netdev ( netdev );
/* Reset the NIC */
intelxvf_reset ( intel );
/* Free network device */
iounmap ( intel->regs );
netdev_nullify ( netdev );
netdev_put ( netdev );
}
/**
* e1000e_remove - Device Removal Routine
*
* @v pdev PCI device information struct
*
**/
void e1000e_remove ( struct pci_device *pdev )
{
struct net_device *netdev = pci_get_drvdata ( pdev );
struct e1000_adapter *adapter = netdev_priv ( netdev );
DBGP ( "e1000e_remove\n" );
if ( adapter->hw.flash_address )
iounmap ( adapter->hw.flash_address );
if ( adapter->hw.hw_addr )
iounmap ( adapter->hw.hw_addr );
unregister_netdev ( netdev );
e1000e_reset ( adapter );
netdev_nullify ( netdev );
netdev_put ( netdev );
}
/**
* Remove PCI device
*
* @v pci PCI device
*/
static void intelxlvf_remove ( struct pci_device *pci ) {
struct net_device *netdev = pci_get_drvdata ( pci );
struct intelxl_nic *intelxl = netdev->priv;
/* Unregister network device */
unregister_netdev ( netdev );
/* Reset the function via admin queue */
intelxlvf_reset_admin ( intelxl );
/* Close admin queues */
intelxl_close_admin ( intelxl );
/* Disable MSI-X dummy interrupt */
intelxl_msix_disable ( intelxl, pci );
/* Reset the function via PCIe FLR */
intelxlvf_reset_flr ( intelxl, pci );
/* Free network device */
iounmap ( intelxl->regs );
netdev_nullify ( netdev );
netdev_put ( netdev );
}
/**
* Detach driver from device
*
* @v efidev EFI device
*/
void nii_stop ( struct efi_device *efidev ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
struct net_device *netdev = efidev_get_drvdata ( efidev );
struct nii_nic *nii = netdev->priv;
EFI_HANDLE device = efidev->device;
/* Unregister network device */
unregister_netdev ( netdev );
/* Stop UNDI */
nii_stop_undi ( nii );
/* Close PCI I/O protocols */
nii_pci_close ( nii );
/* Close NII protocol */
bs->CloseProtocol ( device, &efi_nii31_protocol_guid,
efi_image_handle, device );
/* Free network device */
list_del ( &nii->dev.siblings );
netdev_nullify ( netdev );
netdev_put ( netdev );
}
/**
* Probe device
*
* @v func USB function
* @v config Configuration descriptor
* @ret rc Return status code
*/
static int smsc95xx_probe ( struct usb_function *func,
struct usb_configuration_descriptor *config ) {
struct usb_device *usb = func->usb;
struct net_device *netdev;
struct smsc95xx_device *smsc95xx;
int rc;
/* Allocate and initialise structure */
netdev = alloc_etherdev ( sizeof ( *smsc95xx ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &smsc95xx_operations );
netdev->dev = &func->dev;
smsc95xx = netdev->priv;
memset ( smsc95xx, 0, sizeof ( *smsc95xx ) );
smsc95xx->usb = usb;
smsc95xx->bus = usb->port->hub->bus;
smsc95xx->netdev = netdev;
usbnet_init ( &smsc95xx->usbnet, func, &smsc95xx_intr_operations,
&smsc95xx_in_operations, &smsc95xx_out_operations );
usb_refill_init ( &smsc95xx->usbnet.intr, 0, 0,
SMSC95XX_INTR_MAX_FILL );
usb_refill_init ( &smsc95xx->usbnet.in,
( sizeof ( struct smsc95xx_tx_header ) -
sizeof ( struct smsc95xx_rx_header ) ),
SMSC95XX_IN_MTU, SMSC95XX_IN_MAX_FILL );
mii_init ( &smsc95xx->mii, &smsc95xx_mii_operations );
DBGC ( smsc95xx, "SMSC95XX %p on %s\n", smsc95xx, func->name );
/* Describe USB network device */
if ( ( rc = usbnet_describe ( &smsc95xx->usbnet, config ) ) != 0 ) {
DBGC ( smsc95xx, "SMSC95XX %p could not describe: %s\n",
smsc95xx, strerror ( rc ) );
goto err_describe;
}
/* Reset device */
if ( ( rc = smsc95xx_reset ( smsc95xx ) ) != 0 )
goto err_reset;
/* Read MAC address */
if ( ( rc = smsc95xx_fetch_mac ( smsc95xx, netdev->hw_addr ) ) != 0 )
goto err_fetch_mac;
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register;
usb_func_set_drvdata ( func, netdev );
return 0;
unregister_netdev ( netdev );
err_register:
err_fetch_mac:
err_reset:
err_describe:
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
return rc;
}
/**
* Probe PCI device
*
* @v pci PCI device
* @ret rc Return status code
*/
static int rhine_probe ( struct pci_device *pci ) {
struct net_device *netdev;
struct rhine_nic *rhn;
uint8_t revision;
unsigned int i;
int rc;
/* Allocate and initialise net device */
netdev = alloc_etherdev ( sizeof ( *rhn ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &rhine_operations );
rhn = netdev->priv;
pci_set_drvdata ( pci, netdev );
netdev->dev = &pci->dev;
memset ( rhn, 0, sizeof ( *rhn ) );
rhine_init_ring ( &rhn->tx, RHINE_TXDESC_NUM, RHINE_TXQUEUE_BASE );
rhine_init_ring ( &rhn->rx, RHINE_RXDESC_NUM, RHINE_RXQUEUE_BASE );
/* Fix up PCI device */
adjust_pci_device ( pci );
/* Map registers */
rhn->regs = ioremap ( pci->membase, RHINE_BAR_SIZE );
rhn->ioaddr = pci->ioaddr;
DBGC ( rhn, "RHINE %p regs at %08lx, I/O at %04lx\n", rhn,
pci->membase, pci->ioaddr );
/* Reset the NIC */
if ( ( rc = rhine_reset ( rhn ) ) != 0 )
goto err_reset;
/* Reload EEPROM */
if ( ( rc = rhine_reload_eeprom ( rhn ) ) != 0 )
goto err_reload_eeprom;
/* Read card revision and enable MMIO */
pci_read_config_byte ( pci, PCI_REVISION, &revision );
DBGC ( rhn, "RHINE %p revision %#02x detected\n", rhn, revision );
rhine_enable_mmio ( rhn, revision );
/* Read MAC address */
for ( i = 0 ; i < ETH_ALEN ; i++ )
netdev->hw_addr[i] = readb ( rhn->regs + RHINE_MAC + i );
/* Initialise and reset MII interface */
mii_init ( &rhn->mii, &rhine_mii_operations );
if ( ( rc = mii_reset ( &rhn->mii ) ) != 0 ) {
DBGC ( rhn, "RHINE %p could not reset MII: %s\n",
rhn, strerror ( rc ) );
goto err_mii_reset;
}
DBGC ( rhn, "RHINE PHY vendor %04x device %04x\n",
rhine_mii_read ( &rhn->mii, 0x02 ),
rhine_mii_read ( &rhn->mii, 0x03 ) );
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register_netdev;
/* Set initial link state */
rhine_check_link ( netdev );
return 0;
err_register_netdev:
err_mii_reset:
err_reload_eeprom:
rhine_reset ( rhn );
err_reset:
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
return rc;
}
/**
* Probe device
*
* @v pci PCI device
* @v id Matching entry in ID table
* @ret rc Return status code
*/
static int b44_probe(struct pci_device *pci, const struct pci_device_id *id)
{
struct net_device *netdev;
struct b44_private *bp;
int rc;
/*
* Bail out if more than 1GB of physical RAM is installed.
* This limitation will be removed later when dma mapping
* is merged into mainline.
*/
if (!phys_ram_within_limit(B44_30BIT_DMA_MASK)) {
DBG("Sorry, this version of the driver does not\n"
"support systems with more than 1GB of RAM.\n");
return -ENOMEM;
}
/* Set up netdev */
netdev = alloc_etherdev(sizeof(*bp));
if (!netdev)
return -ENOMEM;
netdev_init(netdev, &b44_operations);
pci_set_drvdata(pci, netdev);
netdev->dev = &pci->dev;
/* Set up private data */
bp = netdev_priv(netdev);
memset(bp, 0, sizeof(*bp));
bp->netdev = netdev;
bp->pci = pci;
/* Map device registers */
bp->regs = ioremap(pci->membase, B44_REGS_SIZE);
if (!bp->regs) {
netdev_put(netdev);
return -ENOMEM;
}
/* Enable PCI bus mastering */
adjust_pci_device(pci);
b44_load_mac_and_phy_addr(bp);
/* Link management currently not implemented */
netdev_link_up(netdev);
rc = register_netdev(netdev);
if (rc != 0) {
iounmap(bp->regs);
netdev_put(netdev);
return rc;
}
b44_chip_reset(bp, B44_CHIP_RESET_FULL);
DBG("b44 %s (%04x:%04x) regs=%p MAC=%s\n", id->name, id->vendor,
id->device, bp->regs, eth_ntoa(netdev->ll_addr));
return 0;
}
/**
* Probe Xen device
*
* @v xendev Xen device
* @ret rc Return status code
*/
static int netfront_probe ( struct xen_device *xendev ) {
struct xen_hypervisor *xen = xendev->xen;
struct net_device *netdev;
struct netfront_nic *netfront;
int rc;
/* Allocate and initialise structure */
netdev = alloc_etherdev ( sizeof ( *netfront ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &netfront_operations );
netdev->dev = &xendev->dev;
netfront = netdev->priv;
netfront->xendev = xendev;
DBGC ( netfront, "NETFRONT %s backend=\"%s\" in domain %ld\n",
xendev->key, xendev->backend, xendev->backend_id );
/* Allocate grant references and initialise descriptor rings */
if ( ( rc = xengrant_alloc ( xen, netfront->refs,
NETFRONT_REF_COUNT ) ) != 0 ) {
DBGC ( netfront, "NETFRONT %s could not allocate grant "
"references: %s\n", xendev->key, strerror ( rc ) );
goto err_grant_alloc;
}
netfront_init_ring ( &netfront->tx, "tx-ring-ref",
netfront->refs[NETFRONT_REF_TX_RING],
NETFRONT_NUM_TX_DESC, netfront->tx_iobufs,
&netfront->refs[NETFRONT_REF_TX_BASE],
netfront->tx_ids );
netfront_init_ring ( &netfront->rx, "rx-ring-ref",
netfront->refs[NETFRONT_REF_RX_RING],
NETFRONT_NUM_RX_DESC, netfront->rx_iobufs,
&netfront->refs[NETFRONT_REF_RX_BASE],
netfront->rx_ids );
/* Fetch MAC address */
if ( ( rc = netfront_read_mac ( netfront, netdev->hw_addr ) ) != 0 )
goto err_read_mac;
/* Reset device. Ignore failures; allow the device to be
* registered so that reset errors can be observed by the user
* when attempting to open the device.
*/
netfront_reset ( netfront );
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register_netdev;
/* Set initial link state */
netdev_link_down ( netdev );
xen_set_drvdata ( xendev, netdev );
return 0;
unregister_netdev ( netdev );
err_register_netdev:
err_read_mac:
xengrant_free ( xen, netfront->refs, NETFRONT_REF_COUNT );
err_grant_alloc:
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
return rc;
}
/**
* Attach driver to device
*
* @v efidev EFI device
* @ret rc Return status code
*/
int snpnet_start ( struct efi_device *efidev ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
EFI_HANDLE device = efidev->device;
EFI_SIMPLE_NETWORK_MODE *mode;
struct net_device *netdev;
struct snp_nic *snp;
void *interface;
EFI_STATUS efirc;
int rc;
/* Open SNP protocol */
if ( ( efirc = bs->OpenProtocol ( device,
&efi_simple_network_protocol_guid,
&interface, efi_image_handle, device,
( EFI_OPEN_PROTOCOL_BY_DRIVER |
EFI_OPEN_PROTOCOL_EXCLUSIVE )))!=0) {
rc = -EEFI ( efirc );
DBGC ( device, "SNP %s cannot open SNP protocol: %s\n",
efi_handle_name ( device ), strerror ( rc ) );
DBGC_EFI_OPENERS ( device, device,
&efi_simple_network_protocol_guid );
goto err_open_protocol;
}
/* Allocate and initialise structure */
netdev = alloc_etherdev ( sizeof ( *snp ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &snpnet_operations );
snp = netdev->priv;
snp->efidev = efidev;
snp->snp = interface;
mode = snp->snp->Mode;
efidev_set_drvdata ( efidev, netdev );
/* Populate underlying device information */
efi_device_info ( device, "SNP", &snp->dev );
snp->dev.driver_name = "SNP";
snp->dev.parent = &efidev->dev;
list_add ( &snp->dev.siblings, &efidev->dev.children );
INIT_LIST_HEAD ( &snp->dev.children );
netdev->dev = &snp->dev;
/* Bring to the Started state */
if ( ( mode->State == EfiSimpleNetworkStopped ) &&
( ( efirc = snp->snp->Start ( snp->snp ) ) != 0 ) ) {
rc = -EEFI ( efirc );
DBGC ( device, "SNP %s could not start: %s\n",
efi_handle_name ( device ), strerror ( rc ) );
goto err_start;
}
if ( ( mode->State == EfiSimpleNetworkInitialized ) &&
( ( efirc = snp->snp->Shutdown ( snp->snp ) ) != 0 ) ) {
rc = -EEFI ( efirc );
DBGC ( device, "SNP %s could not shut down: %s\n",
efi_handle_name ( device ), strerror ( rc ) );
goto err_shutdown;
}
/* Populate network device parameters */
if ( mode->HwAddressSize != netdev->ll_protocol->hw_addr_len ) {
DBGC ( device, "SNP %s has invalid hardware address length "
"%d\n", efi_handle_name ( device ), mode->HwAddressSize);
rc = -ENOTSUP;
goto err_hw_addr_len;
}
memcpy ( netdev->hw_addr, &mode->PermanentAddress,
netdev->ll_protocol->hw_addr_len );
if ( mode->HwAddressSize != netdev->ll_protocol->ll_addr_len ) {
DBGC ( device, "SNP %s has invalid link-layer address length "
"%d\n", efi_handle_name ( device ), mode->HwAddressSize);
rc = -ENOTSUP;
goto err_ll_addr_len;
}
memcpy ( netdev->ll_addr, &mode->CurrentAddress,
netdev->ll_protocol->ll_addr_len );
snp->mtu = ( snp->snp->Mode->MaxPacketSize +
snp->snp->Mode->MediaHeaderSize );
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register_netdev;
DBGC ( device, "SNP %s registered as %s\n",
efi_handle_name ( device ), netdev->name );
/* Set initial link state */
if ( snp->snp->Mode->MediaPresentSupported ) {
snpnet_check_link ( netdev );
} else {
netdev_link_up ( netdev );
}
return 0;
unregister_netdev ( netdev );
err_register_netdev:
err_ll_addr_len:
err_hw_addr_len:
err_shutdown:
err_start:
list_del ( &snp->dev.siblings );
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
bs->CloseProtocol ( device, &efi_simple_network_protocol_guid,
efi_image_handle, device );
err_open_protocol:
return rc;
}
/**
* Probe PCI device
*
* @v pci PCI device
* @ret rc Return status code
*/
static int intelxlvf_probe ( struct pci_device *pci ) {
struct net_device *netdev;
struct intelxl_nic *intelxl;
int rc;
/* Allocate and initialise net device */
netdev = alloc_etherdev ( sizeof ( *intelxl ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &intelxlvf_operations );
intelxl = netdev->priv;
pci_set_drvdata ( pci, netdev );
netdev->dev = &pci->dev;
memset ( intelxl, 0, sizeof ( *intelxl ) );
intelxl->intr = INTELXLVF_VFINT_DYN_CTL0;
intelxl_init_admin ( &intelxl->command, INTELXLVF_ADMIN,
&intelxlvf_admin_command_offsets );
intelxl_init_admin ( &intelxl->event, INTELXLVF_ADMIN,
&intelxlvf_admin_event_offsets );
intelxlvf_init_ring ( &intelxl->tx, INTELXL_TX_NUM_DESC,
sizeof ( intelxl->tx.desc.tx[0] ),
INTELXLVF_QTX_TAIL );
intelxlvf_init_ring ( &intelxl->rx, INTELXL_RX_NUM_DESC,
sizeof ( intelxl->rx.desc.rx[0] ),
INTELXLVF_QRX_TAIL );
/* Fix up PCI device */
adjust_pci_device ( pci );
/* Map registers */
intelxl->regs = ioremap ( pci->membase, INTELXLVF_BAR_SIZE );
if ( ! intelxl->regs ) {
rc = -ENODEV;
goto err_ioremap;
}
/* Locate PCI Express capability */
intelxl->exp = pci_find_capability ( pci, PCI_CAP_ID_EXP );
if ( ! intelxl->exp ) {
DBGC ( intelxl, "INTELXL %p missing PCIe capability\n",
intelxl );
rc = -ENXIO;
goto err_exp;
}
/* Reset the function via PCIe FLR */
intelxlvf_reset_flr ( intelxl, pci );
/* Enable MSI-X dummy interrupt */
if ( ( rc = intelxl_msix_enable ( intelxl, pci ) ) != 0 )
goto err_msix;
/* Open admin queues */
if ( ( rc = intelxl_open_admin ( intelxl ) ) != 0 )
goto err_open_admin;
/* Reset the function via admin queue */
if ( ( rc = intelxlvf_reset_admin ( intelxl ) ) != 0 )
goto err_reset_admin;
/* Get MAC address */
if ( ( rc = intelxlvf_admin_get_resources ( netdev ) ) != 0 )
goto err_get_resources;
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register_netdev;
return 0;
unregister_netdev ( netdev );
err_register_netdev:
err_get_resources:
err_reset_admin:
intelxl_close_admin ( intelxl );
err_open_admin:
intelxl_msix_disable ( intelxl, pci );
err_msix:
intelxlvf_reset_flr ( intelxl, pci );
err_exp:
iounmap ( intelxl->regs );
err_ioremap:
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
return rc;
}
/**
* e1000_probe - Initial configuration of e1000 NIC
*
* @v pci PCI device
* @v id PCI IDs
*
* @ret rc Return status code
**/
int e1000e_probe ( struct pci_device *pdev,
const struct pci_device_id *ent)
{
int i, err;
struct net_device *netdev;
struct e1000_adapter *adapter;
unsigned long mmio_start, mmio_len;
unsigned long flash_start, flash_len;
struct e1000_hw *hw;
const struct e1000_info *ei = e1000_info_tbl[ent->driver_data];
DBGP ( "e1000_probe\n" );
err = -ENOMEM;
/* Allocate net device ( also allocates memory for netdev->priv
and makes netdev-priv point to it ) */
netdev = alloc_etherdev ( sizeof ( struct e1000_adapter ) );
if ( ! netdev ) {
DBG ( "err_alloc_etherdev\n" );
goto err_alloc_etherdev;
}
/* Associate e1000-specific network operations operations with
* generic network device layer */
netdev_init ( netdev, &e1000e_operations );
/* Associate this network device with given PCI device */
pci_set_drvdata ( pdev, netdev );
netdev->dev = &pdev->dev;
/* Initialize driver private storage */
adapter = netdev_priv ( netdev );
memset ( adapter, 0, ( sizeof ( *adapter ) ) );
adapter->pdev = pdev;
adapter->ioaddr = pdev->ioaddr;
adapter->hw.io_base = pdev->ioaddr;
hw = &adapter->hw;
hw->device_id = pdev->device;
adapter->irqno = pdev->irq;
adapter->netdev = netdev;
adapter->hw.back = adapter;
adapter->ei = ei;
adapter->pba = ei->pba;
adapter->flags = ei->flags;
adapter->flags2 = ei->flags2;
adapter->hw.adapter = adapter;
adapter->hw.mac.type = ei->mac;
adapter->max_hw_frame_size = ETH_FRAME_LEN + ETH_FCS_LEN;
adapter->tx_ring_size = sizeof ( *adapter->tx_base ) * NUM_TX_DESC;
adapter->rx_ring_size = sizeof ( *adapter->rx_base ) * NUM_RX_DESC;
/* Fix up PCI device */
adjust_pci_device ( pdev );
err = -EIO;
mmio_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_0 );
mmio_len = pci_bar_size ( pdev, PCI_BASE_ADDRESS_0 );
DBG ( "mmio_start: %#08lx\n", mmio_start );
DBG ( "mmio_len: %#08lx\n", mmio_len );
adapter->hw.hw_addr = ioremap ( mmio_start, mmio_len );
DBG ( "adapter->hw.hw_addr: %p\n", adapter->hw.hw_addr );
if ( ! adapter->hw.hw_addr ) {
DBG ( "err_ioremap\n" );
goto err_ioremap;
}
/* Flash BAR mapping depends on mac_type */
if ( ( adapter->flags & FLAG_HAS_FLASH) && ( pdev->ioaddr ) ) {
flash_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_1 );
flash_len = pci_bar_size ( pdev, PCI_BASE_ADDRESS_1 );
adapter->hw.flash_address = ioremap ( flash_start, flash_len );
if ( ! adapter->hw.flash_address ) {
DBG ( "err_flashmap\n" );
goto err_flashmap;
}
}
/* setup adapter struct */
err = e1000e_sw_init ( adapter );
if (err) {
DBG ( "err_sw_init\n" );
goto err_sw_init;
}
if (ei->get_variants) {
err = ei->get_variants(adapter);
if (err) {
DBG ( "err_hw_initr\n" );
goto err_hw_init;
}
}
/* Copper options */
if (adapter->hw.phy.media_type == e1000_media_type_copper) {
adapter->hw.phy.mdix = AUTO_ALL_MODES;
adapter->hw.phy.disable_polarity_correction = 0;
adapter->hw.phy.ms_type = e1000_ms_hw_default;
}
DBG ( "adapter->hw.mac.type: %#08x\n", adapter->hw.mac.type );
/* Force auto-negotiation */
adapter->hw.mac.autoneg = 1;
adapter->fc_autoneg = 1;
adapter->hw.phy.autoneg_wait_to_complete = true;
adapter->hw.mac.adaptive_ifs = true;
adapter->hw.fc.requested_mode = e1000_fc_default;
adapter->hw.fc.current_mode = e1000_fc_default;
/*
* before reading the NVM, reset the controller to
* put the device in a known good starting state
*/
adapter->hw.mac.ops.reset_hw(&adapter->hw);
/*
* systems with ASPM and others may see the checksum fail on the first
* attempt. Let's give it a few tries
*/
for (i = 0;; i++) {
if (e1000e_validate_nvm_checksum(&adapter->hw) >= 0)
break;
if (i == 2) {
DBG("The NVM Checksum Is Not Valid\n");
err = -EIO;
goto err_eeprom;
}
}
/* copy the MAC address out of the EEPROM */
if ( e1000e_read_mac_addr ( &adapter->hw ) )
DBG ( "EEPROM Read Error\n" );
memcpy ( netdev->hw_addr, adapter->hw.mac.perm_addr, ETH_ALEN );
/* reset the hardware with the new settings */
e1000e_reset ( adapter );
/* Mark as link up; we don't yet handle link state */
netdev_link_up ( netdev );
if ( ( err = register_netdev ( netdev ) ) != 0) {
DBG ( "err_register\n" );
goto err_register;
}
for (i = 0; i < 6; i++)
DBG ("%02x%s", netdev->ll_addr[i], i == 5 ? "\n" : ":");
DBG ( "e1000e_probe succeeded!\n" );
/* No errors, return success */
return 0;
/* Error return paths */
err_register:
err_hw_init:
err_eeprom:
err_flashmap:
if (!e1000e_check_reset_block(&adapter->hw))
e1000e_phy_hw_reset(&adapter->hw);
if (adapter->hw.flash_address)
iounmap(adapter->hw.flash_address);
err_sw_init:
iounmap ( adapter->hw.hw_addr );
err_ioremap:
netdev_put ( netdev );
err_alloc_etherdev:
return err;
}
/**
* Attach driver to device
*
* @v efidev EFI device
* @ret rc Return status code
*/
int nii_start ( struct efi_device *efidev ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
EFI_HANDLE device = efidev->device;
struct net_device *netdev;
struct nii_nic *nii;
void *interface;
EFI_STATUS efirc;
int rc;
/* Allocate and initialise structure */
netdev = alloc_netdev ( sizeof ( *nii ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &nii_operations );
nii = netdev->priv;
nii->efidev = efidev;
netdev->ll_broadcast = nii->broadcast;
efidev_set_drvdata ( efidev, netdev );
/* Populate underlying device information */
efi_device_info ( device, "NII", &nii->dev );
nii->dev.driver_name = "NII";
nii->dev.parent = &efidev->dev;
list_add ( &nii->dev.siblings, &efidev->dev.children );
INIT_LIST_HEAD ( &nii->dev.children );
netdev->dev = &nii->dev;
/* Open NII protocol */
if ( ( efirc = bs->OpenProtocol ( device, &efi_nii31_protocol_guid,
&interface, efi_image_handle, device,
( EFI_OPEN_PROTOCOL_BY_DRIVER |
EFI_OPEN_PROTOCOL_EXCLUSIVE )))!=0){
rc = -EEFI ( efirc );
DBGC ( nii, "NII %s cannot open NII protocol: %s\n",
nii->dev.name, strerror ( rc ) );
DBGC_EFI_OPENERS ( device, device, &efi_nii31_protocol_guid );
goto err_open_protocol;
}
nii->nii = interface;
/* Locate UNDI and entry point */
nii->undi = ( ( void * ) ( intptr_t ) nii->nii->Id );
if ( ! nii->undi ) {
DBGC ( nii, "NII %s has no UNDI\n", nii->dev.name );
rc = -ENODEV;
goto err_no_undi;
}
if ( nii->undi->Implementation & PXE_ROMID_IMP_HW_UNDI ) {
DBGC ( nii, "NII %s is a mythical hardware UNDI\n",
nii->dev.name );
rc = -ENOTSUP;
goto err_hw_undi;
}
if ( nii->undi->Implementation & PXE_ROMID_IMP_SW_VIRT_ADDR ) {
nii->issue = ( ( void * ) ( intptr_t ) nii->undi->EntryPoint );
} else {
nii->issue = ( ( ( void * ) nii->undi ) +
nii->undi->EntryPoint );
}
DBGC ( nii, "NII %s using UNDI v%x.%x at %p entry %p\n", nii->dev.name,
nii->nii->MajorVer, nii->nii->MinorVer, nii->undi, nii->issue );
/* Open PCI I/O protocols and locate BARs */
if ( ( rc = nii_pci_open ( nii ) ) != 0 )
goto err_pci_open;
/* Start UNDI */
if ( ( rc = nii_start_undi ( nii ) ) != 0 )
goto err_start_undi;
/* Get initialisation information */
if ( ( rc = nii_get_init_info ( nii, netdev ) ) != 0 )
goto err_get_init_info;
/* Get MAC addresses */
if ( ( rc = nii_get_station_address ( nii, netdev ) ) != 0 )
goto err_get_station_address;
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register_netdev;
DBGC ( nii, "NII %s registered as %s for %p %s\n", nii->dev.name,
netdev->name, device, efi_handle_name ( device ) );
/* Set initial link state (if media detection is not supported) */
if ( ! nii->media )
netdev_link_up ( netdev );
return 0;
unregister_netdev ( netdev );
err_register_netdev:
err_get_station_address:
err_get_init_info:
nii_stop_undi ( nii );
err_start_undi:
nii_pci_close ( nii );
err_pci_open:
err_hw_undi:
err_no_undi:
bs->CloseProtocol ( device, &efi_nii31_protocol_guid,
efi_image_handle, device );
err_open_protocol:
list_del ( &nii->dev.siblings );
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
return rc;
}
/**
* Probe PCI device
*
* @v pci PCI device
* @ret rc Return status code
*/
static int intelxvf_probe ( struct pci_device *pci ) {
struct net_device *netdev;
struct intel_nic *intel;
int rc;
/* Allocate and initialise net device */
netdev = alloc_etherdev ( sizeof ( *intel ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &intelxvf_operations );
intel = netdev->priv;
pci_set_drvdata ( pci, netdev );
netdev->dev = &pci->dev;
memset ( intel, 0, sizeof ( *intel ) );
intel_init_mbox ( &intel->mbox, INTELXVF_MBCTRL, INTELXVF_MBMEM );
intel_init_ring ( &intel->tx, INTEL_NUM_TX_DESC, INTELXVF_TD(0),
intel_describe_tx_adv );
intel_init_ring ( &intel->rx, INTEL_NUM_RX_DESC, INTELXVF_RD(0),
intel_describe_rx );
/* Fix up PCI device */
adjust_pci_device ( pci );
/* Map registers */
intel->regs = ioremap ( pci->membase, INTELVF_BAR_SIZE );
if ( ! intel->regs ) {
rc = -ENODEV;
goto err_ioremap;
}
/* Reset the function */
intelxvf_reset ( intel );
/* Send reset message and fetch MAC address */
if ( ( rc = intelvf_mbox_reset ( intel, netdev->hw_addr ) ) != 0 ) {
DBGC ( intel, "INTEL %p could not reset and fetch MAC: %s\n",
intel, strerror ( rc ) );
goto err_mbox_reset;
}
/* Reset the function (since we will not respond to Control
* ("ping") mailbox messages until the network device is opened.
*/
intelxvf_reset ( intel );
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register_netdev;
/* Set initial link state */
intelxvf_check_link ( netdev );
return 0;
unregister_netdev ( netdev );
err_register_netdev:
err_mbox_reset:
intelxvf_reset ( intel );
iounmap ( intel->regs );
err_ioremap:
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
return rc;
}
