mnpnet.c File Reference

MNP NIC driver. More...

#include <string.h>
#include <errno.h>
#include <ipxe/iobuf.h>
#include <ipxe/netdevice.h>
#include <ipxe/ethernet.h>
#include <ipxe/cachedhcp.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/efi_driver.h>
#include <ipxe/efi/efi_service.h>
#include <ipxe/efi/efi_utils.h>
#include <ipxe/efi/mnpnet.h>
#include <ipxe/efi/Protocol/ManagedNetwork.h>

Go to the source code of this file.

Data Structures
struct	mnp_token
	An MNP transmit or receive token. More...
struct	mnp_nic
	An MNP NIC. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static VOID EFIAPI	mnpnet_event (EFI_EVENT event __unused, VOID *context)
	Transmit or receive token event.
static int	mnpnet_transmit (struct net_device *netdev, struct io_buffer *iobuf)
	Transmit packet.
static void	mnpnet_refill_rx (struct net_device *netdev)
	Refill receive token.
static void	mnpnet_poll_tx (struct net_device *netdev)
	Poll for completed packets.
static void	mnpnet_poll_rx (struct net_device *netdev)
	Poll for received packets.
static void	mnpnet_poll (struct net_device *netdev)
	Poll for completed packets.
static int	mnpnet_open (struct net_device *netdev)
	Open network device.
static void	mnpnet_close (struct net_device *netdev)
	Close network device.
int	mnpnet_start (struct efi_device *efidev)
	Attach driver to device.
void	mnpnet_stop (struct efi_device *efidev)
	Detach driver from device.
int	mnptemp_create (EFI_HANDLE handle, struct net_device **netdev)
	Create temporary MNP network device.
void	mnptemp_destroy (struct net_device *netdev)
	Destroy temporary MNP network device.

Variables
static struct net_device_operations	mnpnet_operations
	MNP network device operations.

Detailed Description

MNP NIC driver.

Definition in file mnpnet.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

mnpnet_event()

VOID EFIAPI mnpnet_event ( EFI_EVENT event __unused, VOID * context )

static

Transmit or receive token event.

Parameters

event	Event
context	Event context

Definition at line 80 of file mnpnet.c.

                                                                            {
        struct mnp_token *token = context;
 
        /* Sanity check */
        assert ( token->busy );
 
        /* Mark token as no longer owned by MNP */
        token->busy = 0;
}

References __unused, assert, EFI_EVENT, EFIAPI, token, and VOID.

Referenced by mnpnet_open().

mnpnet_transmit()

int mnpnet_transmit ( struct net_device * netdev, struct io_buffer * iobuf )

static

Transmit packet.

Parameters

netdev	Network device
iobuf	I/O buffer

Return values

rc	Return status code

Definition at line 97 of file mnpnet.c.

                                                       {
        struct mnp_nic *mnp = netdev->priv;
        struct ll_protocol *ll_protocol = netdev->ll_protocol;
        EFI_STATUS efirc;
        int rc;
 
        /* Do nothing if shutdown is in progress */
        if ( efi_shutdown_in_progress )
                return -ECANCELED;
 
        /* Defer the packet if there is already a transmission in progress */
        if ( mnp->txbuf ) {
                netdev_tx_defer ( netdev, iobuf );
                return 0;
        }
 
        /* Construct transmit token */
        mnp->txdata.DataLength =
                ( iob_len ( iobuf ) - ll_protocol->ll_header_len );
        mnp->txdata.HeaderLength = ll_protocol->ll_header_len;
        mnp->txdata.FragmentCount = 1;
        mnp->txdata.FragmentTable[0].FragmentLength = iob_len ( iobuf );
        mnp->txdata.FragmentTable[0].FragmentBuffer = iobuf->data;
        mnp->tx.token.Packet.TxData = &mnp->txdata;
 
        /* Record as in use */
        mnp->tx.busy = 1;
 
        /* Transmit packet */
        if ( ( efirc = mnp->mnp->Transmit ( mnp->mnp, &mnp->tx.token ) ) != 0 ){
                rc = -EEFI ( efirc );
                DBGC ( mnp, "MNP %s could not transmit: %s\n",
                       netdev->name, strerror ( rc ) );
                mnp->tx.busy = 0;
                return rc;
        }
 
        /* Record I/O buffer */
        mnp->txbuf = iobuf;
 
        return 0;
}

References mnp_token::busy, io_buffer::data, EFI_MANAGED_NETWORK_TRANSMIT_DATA::DataLength, DBGC, ECANCELED, EEFI, efi_shutdown_in_progress, EFI_MANAGED_NETWORK_FRAGMENT_DATA::FragmentBuffer, EFI_MANAGED_NETWORK_TRANSMIT_DATA::FragmentCount, EFI_MANAGED_NETWORK_FRAGMENT_DATA::FragmentLength, EFI_MANAGED_NETWORK_TRANSMIT_DATA::FragmentTable, EFI_MANAGED_NETWORK_TRANSMIT_DATA::HeaderLength, iob_len(), ll_protocol::ll_header_len, mnp_nic::mnp, netdev, netdev_tx_defer(), EFI_MANAGED_NETWORK_COMPLETION_TOKEN::Packet, rc, strerror(), mnp_token::token, _EFI_MANAGED_NETWORK_PROTOCOL::Transmit, mnp_nic::tx, mnp_nic::txbuf, EFI_MANAGED_NETWORK_COMPLETION_TOKEN::TxData, and mnp_nic::txdata.

mnpnet_refill_rx()

void mnpnet_refill_rx ( struct net_device * netdev )

static

Refill receive token.

Parameters

netdev

Network device

Definition at line 146 of file mnpnet.c.

                                                           {
        struct mnp_nic *mnp = netdev->priv;
        EFI_STATUS efirc;
        int rc;
 
        /* Do nothing if receive token is still in use */
        if ( mnp->rx.busy )
                return;
 
        /* Mark as in use */
        mnp->rx.busy = 1;
 
        /* Queue receive token */
        if ( ( efirc = mnp->mnp->Receive ( mnp->mnp, &mnp->rx.token ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( mnp, "MNP %s could not receive: %s\n",
                       netdev->name, strerror ( rc ) );
                /* Wait for next refill */
                mnp->rx.busy = 0;
                return;
        }
}

References DBGC, EEFI, mnp_nic::mnp, netdev, rc, _EFI_MANAGED_NETWORK_PROTOCOL::Receive, and strerror().

Referenced by mnpnet_open(), and mnpnet_poll().

mnpnet_poll_tx()

void mnpnet_poll_tx ( struct net_device * netdev )

static

Poll for completed packets.

Parameters

netdev

Network device

Definition at line 174 of file mnpnet.c.

                                                         {
        struct mnp_nic *mnp = netdev->priv;
        struct io_buffer *iobuf;
        EFI_STATUS efirc;
        int rc;
 
        /* Do nothing if transmit token is still in use */
        if ( mnp->tx.busy )
                return;
 
        /* Do nothing unless we have a completion */
        if ( ! mnp->txbuf )
                return;
 
        /* Get completion status */
        efirc = mnp->tx.token.Status;
        rc = ( efirc ? -EEFI ( efirc ) : 0 );
 
        /* Complete transmission */
        iobuf = mnp->txbuf;
        mnp->txbuf = NULL;
        netdev_tx_complete_err ( netdev, iobuf, rc );
}

References mnp_token::busy, EEFI, mnp_nic::mnp, netdev, netdev_tx_complete_err(), NULL, rc, EFI_MANAGED_NETWORK_COMPLETION_TOKEN::Status, mnp_token::token, mnp_nic::tx, and mnp_nic::txbuf.

Referenced by mnpnet_poll().

mnpnet_poll_rx()

void mnpnet_poll_rx ( struct net_device * netdev )

static

Poll for received packets.

Parameters

netdev

Network device

Definition at line 203 of file mnpnet.c.

                                                         {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct mnp_nic *mnp = netdev->priv;
        EFI_MANAGED_NETWORK_RECEIVE_DATA *rxdata;
        struct io_buffer *iobuf;
        size_t len;
        EFI_STATUS efirc;
        int rc;
 
        /* Do nothing unless we have a completion */
        if ( mnp->rx.busy )
                return;
        rxdata = mnp->rx.token.Packet.RxData;
 
        /* Get completion status */
        if ( ( efirc = mnp->rx.token.Status ) != 0 ) {
                rc = -EEFI ( efirc );
                netdev_rx_err ( netdev, NULL, rc );
                goto recycle;
        }
 
        /* Allocate and fill I/O buffer */
        len = rxdata->PacketLength;
        iobuf = alloc_iob ( len );
        if ( ! iobuf ) {
                netdev_rx_err ( netdev, NULL, -ENOMEM );
                goto recycle;
        }
        memcpy ( iob_put ( iobuf, len ), rxdata->MediaHeader, len );
 
        /* Hand off to network stack */
        netdev_rx ( netdev, iobuf );
 
 recycle:
        /* Recycle token */
        bs->SignalEvent ( rxdata->RecycleEvent );
}

References alloc_iob(), mnp_token::busy, EEFI, efi_systab, ENOMEM, iob_put, len, EFI_MANAGED_NETWORK_RECEIVE_DATA::MediaHeader, memcpy(), mnp_nic::mnp, netdev, netdev_rx(), netdev_rx_err(), NULL, EFI_MANAGED_NETWORK_COMPLETION_TOKEN::Packet, EFI_MANAGED_NETWORK_RECEIVE_DATA::PacketLength, rc, EFI_MANAGED_NETWORK_RECEIVE_DATA::RecycleEvent, mnp_nic::rx, EFI_MANAGED_NETWORK_COMPLETION_TOKEN::RxData, EFI_BOOT_SERVICES::SignalEvent, EFI_MANAGED_NETWORK_COMPLETION_TOKEN::Status, and mnp_token::token.

Referenced by mnpnet_poll().

mnpnet_poll()

void mnpnet_poll ( struct net_device * netdev )

static

Poll for completed packets.

Parameters

netdev

Network device

Definition at line 246 of file mnpnet.c.

                                                      {
        struct mnp_nic *mnp = netdev->priv;
 
        /* Do nothing if shutdown is in progress */
        if ( efi_shutdown_in_progress )
                return;
 
        /* Poll interface */
        mnp->mnp->Poll ( mnp->mnp );
 
        /* Process any transmit completions */
        mnpnet_poll_tx ( netdev );
 
        /* Process any receive completions */
        mnpnet_poll_rx ( netdev );
 
        /* Refill receive token */
        mnpnet_refill_rx ( netdev );
}

References efi_shutdown_in_progress, mnp_nic::mnp, mnpnet_poll_rx(), mnpnet_poll_tx(), mnpnet_refill_rx(), netdev, and _EFI_MANAGED_NETWORK_PROTOCOL::Poll.

mnpnet_open()

int mnpnet_open ( struct net_device * netdev )

static

Open network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 272 of file mnpnet.c.

                                                     {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        static EFI_MANAGED_NETWORK_CONFIG_DATA config = {
                .EnableUnicastReceive = TRUE,
                .EnableMulticastReceive = TRUE,
                .EnableBroadcastReceive = TRUE,
                .EnablePromiscuousReceive = TRUE,
                .FlushQueuesOnReset = TRUE,
                .DisableBackgroundPolling = TRUE,
        };
        struct mnp_nic *mnp = netdev->priv;
        EFI_STATUS efirc;
        int rc;
 
        /* Create transmit event */
        if ( ( efirc = bs->CreateEvent ( EVT_NOTIFY_SIGNAL, TPL_NOTIFY,
                                         mnpnet_event, &mnp->tx,
                                         &mnp->tx.token.Event ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( mnp, "MNP %s could not create TX event: %s\n",
                       netdev->name, strerror ( rc ) );
                goto err_tx_event;
        }
 
        /* Create receive event */
        if ( ( efirc = bs->CreateEvent ( EVT_NOTIFY_SIGNAL, TPL_NOTIFY,
                                         mnpnet_event, &mnp->rx,
                                         &mnp->rx.token.Event ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( mnp, "MNP %s could not create RX event: %s\n",
                       netdev->name, strerror ( rc ) );
                goto err_rx_event;
        }
 
        /* Configure MNP */
        if ( ( efirc = mnp->mnp->Configure ( mnp->mnp, &config ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( mnp, "MNP %s could not configure: %s\n",
                       netdev->name, strerror ( rc ) );
                goto err_configure;
        }
 
        /* Refill receive token */
        mnpnet_refill_rx ( netdev );
 
        return 0;
 
        mnp->mnp->Configure ( mnp->mnp, NULL );
 err_configure:
        bs->CloseEvent ( mnp->rx.token.Event );
 err_rx_event:
        bs->CloseEvent ( mnp->tx.token.Event );
 err_tx_event:
        return rc;
}

References EFI_BOOT_SERVICES::CloseEvent, _EFI_MANAGED_NETWORK_PROTOCOL::Configure, EFI_BOOT_SERVICES::CreateEvent, DBGC, EEFI, efi_systab, EVT_NOTIFY_SIGNAL, mnp_nic::mnp, mnpnet_event(), mnpnet_refill_rx(), netdev, NULL, rc, strerror(), TPL_NOTIFY, and TRUE.

mnpnet_close()

void mnpnet_close ( struct net_device * netdev )

static

Close network device.

Parameters

netdev

Network device

Definition at line 333 of file mnpnet.c.

                                                       {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct mnp_nic *mnp = netdev->priv;
 
        /* Reset MNP (unless whole system shutdown is in progress) */
        if ( ! efi_shutdown_in_progress )
                mnp->mnp->Configure ( mnp->mnp, NULL );
 
        /* Close events */
        bs->CloseEvent ( mnp->rx.token.Event );
        bs->CloseEvent ( mnp->tx.token.Event );
 
        /* Reset tokens */
        mnp->tx.busy = 0;
        mnp->rx.busy = 0;
 
        /* Discard any incomplete I/O buffer */
        if ( mnp->txbuf ) {
                netdev_tx_complete_err ( netdev, mnp->txbuf, -ECANCELED );
                mnp->txbuf = NULL;
        }
}

References EFI_BOOT_SERVICES::CloseEvent, _EFI_MANAGED_NETWORK_PROTOCOL::Configure, ECANCELED, efi_shutdown_in_progress, efi_systab, mnp_nic::mnp, netdev, netdev_tx_complete_err(), and NULL.

mnpnet_start()

int mnpnet_start

(

struct efi_device *

efidev

)

Attach driver to device.

Parameters

efidev

EFI device

Return values

rc	Return status code

Definition at line 370 of file mnpnet.c.

                                               {
        EFI_HANDLE device = efidev->device;
        EFI_GUID *binding = &efi_managed_network_service_binding_protocol_guid;
        EFI_SIMPLE_NETWORK_MODE mode;
        struct net_device *netdev;
        struct mnp_nic *mnp;
        EFI_STATUS efirc;
        int rc;
 
        /* Allocate and initalise structure */
        netdev = alloc_etherdev ( sizeof ( *mnp ) );
        if ( ! netdev ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        netdev_init ( netdev, &mnpnet_operations );
        mnp = netdev->priv;
        mnp->efidev = efidev;
        efidev_set_drvdata ( efidev, netdev );
 
        /* Populate underlying device information */
        efi_device_info ( device, "MNP", &mnp->dev );
        mnp->dev.driver_name = "MNP";
        mnp->dev.parent = &efidev->dev;
        list_add ( &mnp->dev.siblings, &efidev->dev.children );
        INIT_LIST_HEAD ( &mnp->dev.children );
        netdev->dev = &mnp->dev;
 
        /* Create MNP child */
        if ( ( rc = efi_service_add ( device, binding,
                                      &efidev->child ) ) != 0 ) {
                DBGC ( mnp, "MNP %s could not create child: %s\n",
                       efi_handle_name ( device ), strerror ( rc ) );
                goto err_service;
        }
 
        /* Open MNP protocol */
        if ( ( rc = efi_open_by_driver ( efidev->child,
                                         &efi_managed_network_protocol_guid,
                                         &mnp->mnp ) ) != 0 ) {
                DBGC ( mnp, "MNP %s could not open MNP protocol: %s\n",
                       efi_handle_name ( device ), strerror ( rc ) );
                goto err_open;
        }
 
        /* Get configuration */
        efirc = mnp->mnp->GetModeData ( mnp->mnp, NULL, &mode );
        if ( ( efirc != 0 ) && ( efirc != EFI_NOT_STARTED ) ) {
                rc = -EEFI ( efirc );
                DBGC ( mnp, "MNP %s could not get mode data: %s\n",
                       efi_handle_name ( device ), strerror ( rc ) );
                goto err_mode;
        }
 
        /* Populate network device parameters */
        if ( mode.HwAddressSize != netdev->ll_protocol->hw_addr_len ) {
                DBGC ( device, "MNP %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, "MNP %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 );
 
        /* Register network device */
        if ( ( rc = register_netdev ( netdev ) ) != 0 )
                goto err_register;
        DBGC ( mnp, "MNP %s registered as %s\n",
               efi_handle_name ( device ), netdev->name );
 
        /* Mark as link up: we don't handle link state */
        netdev_link_up ( netdev );
 
        return 0;
 
        unregister_netdev ( netdev );
 err_register:
 err_ll_addr_len:
 err_hw_addr_len:
 err_mode:
        efi_close_by_driver ( efidev->child,
                              &efi_managed_network_protocol_guid );
 err_open:
        efi_service_del ( device, binding, efidev->child );
 err_service:
        list_del ( &mnp->dev.siblings );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
 err_alloc:
        return rc;
}

References alloc_etherdev(), efi_device::child, device::children, DBGC, efi_device::dev, efi_device::device, EEFI, efi_close_by_driver(), efi_device_info(), EFI_HANDLE, efi_handle_name(), efi_managed_network_protocol_guid, efi_managed_network_service_binding_protocol_guid, EFI_NOT_STARTED, efi_open_by_driver, efi_service_add(), efi_service_del(), mnp_nic::efidev, efidev_set_drvdata(), ENOMEM, ENOTSUP, _EFI_MANAGED_NETWORK_PROTOCOL::GetModeData, INIT_LIST_HEAD, list_add, list_del, memcpy(), mnp_nic::mnp, mnpnet_operations, mode, netdev, netdev_init(), netdev_link_up(), netdev_nullify(), netdev_put(), NULL, rc, register_netdev(), strerror(), and unregister_netdev().

Referenced by __efi_driver(), and mnptemp_create().

mnpnet_stop()

void mnpnet_stop

(

struct efi_device *

efidev

)

Detach driver from device.

Parameters

efidev

EFI device

Definition at line 475 of file mnpnet.c.

                                               {
        EFI_GUID *binding = &efi_managed_network_service_binding_protocol_guid;
        struct net_device *netdev = efidev_get_drvdata ( efidev );
        struct mnp_nic *mnp = netdev->priv;
 
        /* Unregister network device */
        unregister_netdev ( netdev );
 
        /* Close MNP protocol */
        efi_close_by_driver ( efidev->child,
                              &efi_managed_network_protocol_guid );
 
        /* Remove MNP child (unless whole system shutdown is in progress) */
        if ( ! efi_shutdown_in_progress )
                efi_service_del ( efidev->device, binding, efidev->child );
 
        /* Free network device */
        list_del ( &mnp->dev.siblings );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
}

References efi_device::child, efi_device::device, efi_close_by_driver(), efi_managed_network_protocol_guid, efi_managed_network_service_binding_protocol_guid, efi_service_del(), efi_shutdown_in_progress, mnp_nic::efidev, efidev_get_drvdata(), list_del, mnp_nic::mnp, netdev, netdev_nullify(), netdev_put(), and unregister_netdev().

Referenced by __efi_driver(), mnptemp_create(), and mnptemp_destroy().

mnptemp_create()

int mnptemp_create	(	EFI_HANDLE	handle,
		struct net_device **	netdev )

Create temporary MNP network device.

Parameters

handle	MNP service binding handle
netdev	Network device to fill in

Return values

rc	Return status code

Definition at line 504 of file mnpnet.c.

                                                                     {
        struct efi_device *efidev;
        int rc;
 
        /* Create temporary EFI device */
        efidev = efidev_alloc ( handle );
        if ( ! efidev ) {
                DBGC ( handle, "MNP %s could not create temporary device\n",
                       efi_handle_name ( handle ) );
                rc = -ENOMEM;
                goto err_alloc;
        }
 
        /* Start temporary network device */
        if ( ( rc = mnpnet_start ( efidev ) ) != 0 ) {
                DBGC ( handle, "MNP %s could not start MNP: %s\n",
                       efi_handle_name ( handle ), strerror ( rc ) );
                goto err_start;
        }
 
        /* Fill in network device */
        *netdev = efidev_get_drvdata ( efidev );
 
        return 0;
 
        mnpnet_stop ( efidev );
 err_start:
        efidev_free ( efidev );
 err_alloc:
        return rc;
}

References DBGC, EFI_HANDLE, efi_handle_name(), efidev_alloc(), efidev_free(), efidev_get_drvdata(), ENOMEM, handle, mnpnet_start(), mnpnet_stop(), netdev, rc, and strerror().

Referenced by efi_autoexec_network().

mnptemp_destroy()

void mnptemp_destroy

(

struct net_device *

netdev

)

Destroy temporary MNP network device.

Parameters

netdev

Network device

Definition at line 541 of file mnpnet.c.

                                                   {
        struct mnp_nic *mnp = netdev->priv;
        struct efi_device *efidev = mnp->efidev;
 
        /* Recycle any cached DHCP packet */
        cachedhcp_recycle ( netdev );
 
        /* Stop temporary network device */
        mnpnet_stop ( efidev );
 
        /* Free temporary EFI device */
        efidev_free ( efidev );
}

References cachedhcp_recycle(), mnp_nic::efidev, efidev_free(), mnp_nic::mnp, mnpnet_stop(), and netdev.

Referenced by efi_autoexec_network().

Variable Documentation

mnpnet_operations

struct net_device_operations mnpnet_operations

static

Initial value:

= {
        .open = mnpnet_open,
        .close = mnpnet_close,
        .transmit = mnpnet_transmit,
        .poll = mnpnet_poll,
}

MNP network device operations.

Definition at line 357 of file mnpnet.c.

                                                        {
        .open = mnpnet_open,
        .close = mnpnet_close,
        .transmit = mnpnet_transmit,
        .poll = mnpnet_poll,
};

Referenced by mnpnet_start().