snpnet.h File Reference

SNP NIC driver. More...

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER)
	FILE_SECBOOT (PERMITTED)
int	snpnet_supported (EFI_HANDLE device, EFI_GUID *protocol, int inhibit_wifi)
	Check to see if driver supports a device.
int	snpnet_exclude (EFI_HANDLE device)
	Exclude existing drivers.
int	snpnet_start (struct efi_device *efidev)
	Attach driver to device.
void	snpnet_stop (struct efi_device *efidev)
	Detach driver from device.

Detailed Description

SNP NIC driver.

Definition in file snpnet.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

References EFI_HANDLE, and protocol.

snpnet_supported()

int snpnet_supported ( EFI_HANDLE device, EFI_GUID * protocol, int inhibit_wifi )

extern

Check to see if driver supports a device.

Parameters

device	EFI device handle
protocol	Protocol GUID
inhibit_wifi	Inhibit wireless devices

Return values

rc	Return status code

Definition at line 511 of file snpnet.c.

                                          {
        EFI_HANDLE parent;
        int rc;
 
        /* Check that this is not a device we are providing ourselves */
        if ( find_snpdev ( device ) != NULL ) {
                DBGCP ( device, "HANDLE %s is provided by this binary\n",
                        efi_handle_name ( device ) );
                return -ENOTTY;
        }
 
        /* Test for presence of protocol */
        if ( ( rc = efi_test ( device, protocol ) ) != 0 ) {
                DBGCP ( device, "HANDLE %s is not a %s device\n",
                        efi_handle_name ( device ),
                        efi_guid_ntoa ( protocol ) );
                return rc;
        }
 
        /* Check that there are no instances of this protocol further
         * up this device path.
         */
        if ( ( rc = efi_locate_device ( device, protocol,
                                        &parent, 1 ) ) == 0 ) {
                DBGC2 ( device, "HANDLE %s has %s-supporting parent ",
                        efi_handle_name ( device ),
                        efi_guid_ntoa ( protocol ) );
                DBGC2 ( device, "%s\n", efi_handle_name ( parent ) );
                return -ENOTTY;
        }
        DBGC ( device, "HANDLE %s is a %s device\n",
               efi_handle_name ( device ), efi_guid_ntoa ( protocol ) );
 
        /* Check for wireless devices, if applicable */
        if ( inhibit_wifi &&
             ( ( efi_test ( device, &efi_wifi2_protocol_guid ) ) == 0 ) ) {
                DBGC ( device, "HANDLE %s is wireless: assuming vendor %s "
                       "driver is too unreliable to use\n",
                       efi_handle_name ( device ),
                       efi_guid_ntoa ( protocol ) );
                return -ENOTTY;
        }
 
        return 0;
}

References DBGC, DBGC2, DBGCP, efi_guid_ntoa(), EFI_HANDLE, efi_handle_name(), efi_locate_device(), efi_test, efi_wifi2_protocol_guid, ENOTTY, find_snpdev(), NULL, protocol, and rc.

Referenced by mnp_supported(), nii_supported(), and snp_supported().

snpnet_exclude()

int snpnet_exclude ( EFI_HANDLE device )

extern

Exclude existing drivers.

Parameters

device

EFI device handle

Return values

rc	Return status code

Definition at line 693 of file snpnet.c.

                                         {
        EFI_GUID *protocol = &efi_simple_network_protocol_guid;
        struct snp_insomniac_patch patch;
        int insomniac;
        int rc;
 
        /* Check if this is a device that must not ever be shut down */
        insomniac = snpnet_is_insomniac ( device );
 
        /* Inhibit calls to Shutdown() and Stop(), if applicable */
        if ( insomniac &&
             ( ( rc = snpnet_insomniac_patch ( device, &patch ) ) != 0 ) ) {
                goto err_patch;
        }
 
        /* Exclude existing SNP drivers */
        if ( ( rc = efi_driver_exclude ( device, protocol ) ) != 0 ) {
                DBGC ( device, "SNP %s could not exclude drivers: %s\n",
                       efi_handle_name ( device ), strerror ( rc ) );
                goto err_exclude;
        }
 
 err_exclude:
        if ( insomniac )
                snpnet_insomniac_restore ( device, &patch );
 err_patch:
        return rc;
}

References DBGC, efi_driver_exclude(), EFI_HANDLE, efi_handle_name(), efi_simple_network_protocol_guid, protocol, rc, snpnet_insomniac_patch(), snpnet_insomniac_restore(), snpnet_is_insomniac(), and strerror().

Referenced by __efi_driver().

snpnet_start()

int snpnet_start ( struct efi_device * efidev )

extern

Attach driver to device.

Parameters

efidev

EFI device

Return values

rc	Return status code

Definition at line 728 of file snpnet.c.

                                               {
        EFI_HANDLE device = efidev->device;
        EFI_SIMPLE_NETWORK_PROTOCOL *interface;
        EFI_SIMPLE_NETWORK_MODE *mode;
        struct net_device *netdev;
        struct snp_nic *snp;
        EFI_STATUS efirc;
        int rc;
 
        /* Open SNP protocol */
        if ( ( rc = efi_open_by_driver ( device,
                                         &efi_simple_network_protocol_guid,
                                         &interface ) ) != 0 ) {
                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;
 
        /* Check if device is insomniac */
        if ( snpnet_is_insomniac ( device ) )
                netdev->state |= NETDEV_INSOMNIAC;
 
        /* Bring to the correct state for a closed interface */
        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 ) &&
             ( ! netdev_insomniac ( netdev ) ) &&
             ( ( 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:
        efi_close_by_driver ( device, &efi_simple_network_protocol_guid );
 err_open_protocol:
        return rc;
}

References alloc_etherdev(), device::children, DBGC, DBGC_EFI_OPENERS, efi_device::dev, efi_device::device, EEFI, efi_close_by_driver(), efi_device_info(), EFI_HANDLE, efi_handle_name(), efi_open_by_driver, efi_simple_network_protocol_guid, snp_nic::efidev, efidev_set_drvdata(), EfiSimpleNetworkInitialized, EfiSimpleNetworkStopped, ENOMEM, ENOTSUP, INIT_LIST_HEAD, list_add, list_del, EFI_SIMPLE_NETWORK_MODE::MaxPacketSize, EFI_SIMPLE_NETWORK_MODE::MediaHeaderSize, EFI_SIMPLE_NETWORK_MODE::MediaPresentSupported, memcpy(), _EFI_SIMPLE_NETWORK_PROTOCOL::Mode, mode, netdev, netdev_init(), NETDEV_INSOMNIAC, netdev_insomniac(), netdev_link_up(), netdev_nullify(), netdev_put(), rc, register_netdev(), _EFI_SIMPLE_NETWORK_PROTOCOL::Shutdown, snp_nic::snp, snpnet_check_link(), snpnet_is_insomniac(), snpnet_operations, _EFI_SIMPLE_NETWORK_PROTOCOL::Start, strerror(), and unregister_netdev().

Referenced by __efi_driver().

snpnet_stop()

void snpnet_stop ( struct efi_device * efidev )

extern

Detach driver from device.

Parameters

efidev

EFI device

Definition at line 845 of file snpnet.c.

                                               {
        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 (unless whole system shutdown is in progress) */
        if ( ( ! efi_shutdown_in_progress ) &&
             ( ( 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 */
        efi_close_by_driver ( device, &efi_simple_network_protocol_guid );
}

References DBGC, efi_device::device, EEFI, efi_close_by_driver(), EFI_HANDLE, efi_handle_name(), efi_shutdown_in_progress, efi_simple_network_protocol_guid, snp_nic::efidev, efidev_get_drvdata(), list_del, netdev, netdev_nullify(), netdev_put(), rc, snp_nic::snp, _EFI_SIMPLE_NETWORK_PROTOCOL::Stop, strerror(), and unregister_netdev().

Referenced by __efi_driver().