nii.c File Reference

NII driver. More...

#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <ipxe/netdevice.h>
#include <ipxe/ethernet.h>
#include <ipxe/if_ether.h>
#include <ipxe/umalloc.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/efi_driver.h>
#include <ipxe/efi/efi_pci.h>
#include <ipxe/efi/efi_utils.h>
#include <ipxe/efi/Protocol/NetworkInterfaceIdentifier.h>
#include <ipxe/efi/IndustryStandard/Acpi10.h>
#include "nii.h"

Go to the source code of this file.

Data Structures
struct	nii_mapping
	An NII memory mapping. More...
struct	nii_nic
	An NII NIC. More...

Macros
#define	EIO_INVALID_CDB   __einfo_error ( EINFO_EIO_INVALID_CDB )
#define	EINFO_EIO_INVALID_CDB
#define	EIO_INVALID_CPB   __einfo_error ( EINFO_EIO_INVALID_CPB )
#define	EINFO_EIO_INVALID_CPB
#define	EIO_BUSY   __einfo_error ( EINFO_EIO_BUSY )
#define	EINFO_EIO_BUSY
#define	EIO_QUEUE_FULL   __einfo_error ( EINFO_EIO_QUEUE_FULL )
#define	EINFO_EIO_QUEUE_FULL
#define	EIO_ALREADY_STARTED   __einfo_error ( EINFO_EIO_ALREADY_STARTED )
#define	EINFO_EIO_ALREADY_STARTED
#define	EIO_NOT_STARTED   __einfo_error ( EINFO_EIO_NOT_STARTED )
#define	EINFO_EIO_NOT_STARTED
#define	EIO_NOT_SHUTDOWN   __einfo_error ( EINFO_EIO_NOT_SHUTDOWN )
#define	EINFO_EIO_NOT_SHUTDOWN
#define	EIO_ALREADY_INITIALIZED   __einfo_error ( EINFO_EIO_ALREADY_INITIALIZED )
#define	EINFO_EIO_ALREADY_INITIALIZED
#define	EIO_NOT_INITIALIZED   __einfo_error ( EINFO_EIO_NOT_INITIALIZED )
#define	EINFO_EIO_NOT_INITIALIZED
#define	EIO_DEVICE_FAILURE   __einfo_error ( EINFO_EIO_DEVICE_FAILURE )
#define	EINFO_EIO_DEVICE_FAILURE
#define	EIO_NVDATA_FAILURE   __einfo_error ( EINFO_EIO_NVDATA_FAILURE )
#define	EINFO_EIO_NVDATA_FAILURE
#define	EIO_UNSUPPORTED   __einfo_error ( EINFO_EIO_UNSUPPORTED )
#define	EINFO_EIO_UNSUPPORTED
#define	EIO_BUFFER_FULL   __einfo_error ( EINFO_EIO_BUFFER_FULL )
#define	EINFO_EIO_BUFFER_FULL
#define	EIO_INVALID_PARAMETER   __einfo_error ( EINFO_EIO_INVALID_PARAMETER )
#define	EINFO_EIO_INVALID_PARAMETER
#define	EIO_INVALID_UNDI   __einfo_error ( EINFO_EIO_INVALID_UNDI )
#define	EINFO_EIO_INVALID_UNDI
#define	EIO_IPV4_NOT_SUPPORTED   __einfo_error ( EINFO_EIO_IPV4_NOT_SUPPORTED )
#define	EINFO_EIO_IPV4_NOT_SUPPORTED
#define	EIO_IPV6_NOT_SUPPORTED   __einfo_error ( EINFO_EIO_IPV6_NOT_SUPPORTED )
#define	EINFO_EIO_IPV6_NOT_SUPPORTED
#define	EIO_NOT_ENOUGH_MEMORY   __einfo_error ( EINFO_EIO_NOT_ENOUGH_MEMORY )
#define	EINFO_EIO_NOT_ENOUGH_MEMORY
#define	EIO_NO_DATA   __einfo_error ( EINFO_EIO_NO_DATA )
#define	EINFO_EIO_NO_DATA
#define	EIO_STAT(stat)
#define	PCI_MAX_BAR   6
	Maximum PCI BAR.
#define	NII_RX_QUOTA   4
	Maximum number of received packets per poll.
#define	NII_OP(opcode, opflags)
	Construct operation from opcode and flags.
#define	NII_OPCODE(op)
	Extract opcode from operation.
#define	NII_OPFLAGS(op)
	Extract flags from operation.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static int	nii_pci_open (struct nii_nic *nii)
	Open PCI I/O protocol and identify BARs.
static void	nii_pci_close (struct nii_nic *nii)
	Close PCI I/O protocol.
static EFIAPI VOID	nii_io (UINT64 unique_id, UINT8 op, UINT8 len, UINT64 addr, UINT64 data)
	I/O callback.
static EFIAPI VOID	nii_map (UINT64 unique_id, UINT64 addr, UINT32 len, UINT32 dir, UINT64 mapped)
	Map callback.
static EFIAPI VOID	nii_unmap (UINT64 unique_id, UINT64 addr, UINT32 len, UINT32 dir __unused, UINT64 mapped)
	Unmap callback.
static EFIAPI VOID	nii_sync (UINT64 unique_id __unused, UINT64 addr, UINT32 len, UINT32 dir, UINT64 mapped)
	Sync callback.
static EFIAPI VOID	nii_delay (UINT64 unique_id __unused, UINTN microseconds)
	Delay callback.
static EFIAPI VOID	nii_block (UINT64 unique_id, UINT32 acquire)
	Block callback.
static int	nii_issue_cpb_db (struct nii_nic *nii, unsigned int op, void *cpb, size_t cpb_len, void *db, size_t db_len)
	Issue command with parameter block and data block.
static int	nii_issue_cpb (struct nii_nic *nii, unsigned int op, void *cpb, size_t cpb_len)
	Issue command with parameter block.
static int	nii_issue_db (struct nii_nic *nii, unsigned int op, void *db, size_t db_len)
	Issue command with data block.
static int	nii_issue (struct nii_nic *nii, unsigned int op)
	Issue command.
static int	nii_start_undi (struct nii_nic *nii)
	Start UNDI.
static void	nii_stop_undi (struct nii_nic *nii)
	Stop UNDI.
static int	nii_get_init_info (struct nii_nic *nii, struct net_device *netdev)
	Get initialisation information.
static int	nii_initialise_flags (struct nii_nic *nii, unsigned int flags)
	Initialise UNDI.
static int	nii_initialise_cable (struct nii_nic *nii)
	Initialise UNDI with cable detection.
static int	nii_initialise (struct nii_nic *nii)
	Initialise UNDI.
static void	nii_shutdown (struct nii_nic *nii)
	Shut down UNDI.
static int	nii_get_station_address (struct nii_nic *nii, struct net_device *netdev)
	Get station addresses.
static int	nii_set_station_address (struct nii_nic *nii, struct net_device *netdev)
	Set station address.
static int	nii_set_rx_filters (struct nii_nic *nii, unsigned int flags)
	Set receive filters.
static int	nii_enable_rx_filters (struct nii_nic *nii)
	Enable receive filters.
static int	nii_disable_rx_filters (struct nii_nic *nii)
	Disable receive filters.
static int	nii_transmit (struct net_device *netdev, struct io_buffer *iobuf)
	Transmit packet.
static void	nii_poll_tx (struct net_device *netdev, unsigned int stat)
	Poll for completed packets.
static void	nii_poll_rx (struct net_device *netdev)
	Poll for received packets.
static void	nii_poll_link (struct net_device *netdev, unsigned int stat)
	Check for link state changes.
static void	nii_poll (struct net_device *netdev)
	Poll for completed packets.
static int	nii_open (struct net_device *netdev)
	Open network device.
static void	nii_close (struct net_device *netdev)
	Close network device.
int	nii_exclude (EFI_HANDLE device)
	Exclude existing drivers.
int	nii_start (struct efi_device *efidev)
	Attach driver to device.
void	nii_stop (struct efi_device *efidev)
	Detach driver from device.

Variables
static struct net_device_operations	nii_operations
	NII network device operations.

Detailed Description

NII driver.

Definition in file nii.c.

Macro Definition Documentation

EIO_INVALID_CDB

#define EIO_INVALID_CDB   __einfo_error ( EINFO_EIO_INVALID_CDB )

Definition at line 51 of file nii.c.

EINFO_EIO_INVALID_CDB

#define EINFO_EIO_INVALID_CDB

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_INVALID_CDB,                \
                          "Invalid CDB" )

Definition at line 52 of file nii.c.

#define EINFO_EIO_INVALID_CDB                                                 \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_INVALID_CDB,                \
                          "Invalid CDB" )

EIO_INVALID_CPB

#define EIO_INVALID_CPB   __einfo_error ( EINFO_EIO_INVALID_CPB )

Definition at line 55 of file nii.c.

EINFO_EIO_INVALID_CPB

#define EINFO_EIO_INVALID_CPB

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_INVALID_CPB,                \
                          "Invalid CPB" )

Definition at line 56 of file nii.c.

#define EINFO_EIO_INVALID_CPB                                                 \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_INVALID_CPB,                \
                          "Invalid CPB" )

EIO_BUSY

#define EIO_BUSY   __einfo_error ( EINFO_EIO_BUSY )

Definition at line 59 of file nii.c.

EINFO_EIO_BUSY

#define EINFO_EIO_BUSY

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_BUSY,                              \
                          "Busy" )

Definition at line 60 of file nii.c.

#define EINFO_EIO_BUSY                                                        \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_BUSY,                       \
                          "Busy" )

EIO_QUEUE_FULL

#define EIO_QUEUE_FULL   __einfo_error ( EINFO_EIO_QUEUE_FULL )

Definition at line 63 of file nii.c.

EINFO_EIO_QUEUE_FULL

#define EINFO_EIO_QUEUE_FULL

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_QUEUE_FULL,                  \
                          "Queue full" )

Definition at line 64 of file nii.c.

#define EINFO_EIO_QUEUE_FULL                                                  \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_QUEUE_FULL,                 \
                          "Queue full" )

EIO_ALREADY_STARTED

#define EIO_ALREADY_STARTED   __einfo_error ( EINFO_EIO_ALREADY_STARTED )

Definition at line 67 of file nii.c.

EINFO_EIO_ALREADY_STARTED

#define EINFO_EIO_ALREADY_STARTED

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_ALREADY_STARTED,        \
                          "Already started" )

Definition at line 68 of file nii.c.

#define EINFO_EIO_ALREADY_STARTED                                             \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_ALREADY_STARTED,            \
                          "Already started" )

EIO_NOT_STARTED

#define EIO_NOT_STARTED   __einfo_error ( EINFO_EIO_NOT_STARTED )

Definition at line 71 of file nii.c.

EINFO_EIO_NOT_STARTED

#define EINFO_EIO_NOT_STARTED

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NOT_STARTED,                \
                          "Not started" )

Definition at line 72 of file nii.c.

#define EINFO_EIO_NOT_STARTED                                                 \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NOT_STARTED,                \
                          "Not started" )

EIO_NOT_SHUTDOWN

#define EIO_NOT_SHUTDOWN   __einfo_error ( EINFO_EIO_NOT_SHUTDOWN )

Definition at line 75 of file nii.c.

EINFO_EIO_NOT_SHUTDOWN

#define EINFO_EIO_NOT_SHUTDOWN

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NOT_SHUTDOWN,                      \
                          "Not shutdown" )

Definition at line 76 of file nii.c.

#define EINFO_EIO_NOT_SHUTDOWN                                                \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NOT_SHUTDOWN,               \
                          "Not shutdown" )

EIO_ALREADY_INITIALIZED

#define EIO_ALREADY_INITIALIZED   __einfo_error ( EINFO_EIO_ALREADY_INITIALIZED )

Definition at line 79 of file nii.c.

EINFO_EIO_ALREADY_INITIALIZED

#define EINFO_EIO_ALREADY_INITIALIZED

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_ALREADY_INITIALIZED,        \
                          "Already initialized" )

Definition at line 80 of file nii.c.

#define EINFO_EIO_ALREADY_INITIALIZED                                         \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_ALREADY_INITIALIZED,        \
                          "Already initialized" )

EIO_NOT_INITIALIZED

#define EIO_NOT_INITIALIZED   __einfo_error ( EINFO_EIO_NOT_INITIALIZED )

Definition at line 83 of file nii.c.

EINFO_EIO_NOT_INITIALIZED

#define EINFO_EIO_NOT_INITIALIZED

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NOT_INITIALIZED,        \
                          "Not initialized" )

Definition at line 84 of file nii.c.

#define EINFO_EIO_NOT_INITIALIZED                                             \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NOT_INITIALIZED,            \
                          "Not initialized" )

EIO_DEVICE_FAILURE

#define EIO_DEVICE_FAILURE   __einfo_error ( EINFO_EIO_DEVICE_FAILURE )

Definition at line 87 of file nii.c.

EINFO_EIO_DEVICE_FAILURE

#define EINFO_EIO_DEVICE_FAILURE

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_DEVICE_FAILURE,          \
                          "Device failure" )

Definition at line 88 of file nii.c.

#define EINFO_EIO_DEVICE_FAILURE                                              \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_DEVICE_FAILURE,             \
                          "Device failure" )

EIO_NVDATA_FAILURE

#define EIO_NVDATA_FAILURE   __einfo_error ( EINFO_EIO_NVDATA_FAILURE )

Definition at line 91 of file nii.c.

EINFO_EIO_NVDATA_FAILURE

#define EINFO_EIO_NVDATA_FAILURE

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NVDATA_FAILURE,          \
                          "Non-volatile data failure" )

Definition at line 92 of file nii.c.

#define EINFO_EIO_NVDATA_FAILURE                                              \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NVDATA_FAILURE,             \
                          "Non-volatile data failure" )

EIO_UNSUPPORTED

#define EIO_UNSUPPORTED   __einfo_error ( EINFO_EIO_UNSUPPORTED )

Definition at line 95 of file nii.c.

EINFO_EIO_UNSUPPORTED

#define EINFO_EIO_UNSUPPORTED

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_UNSUPPORTED,                \
                          "Unsupported" )

Definition at line 96 of file nii.c.

#define EINFO_EIO_UNSUPPORTED                                                 \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_UNSUPPORTED,                \
                          "Unsupported" )

EIO_BUFFER_FULL

#define EIO_BUFFER_FULL   __einfo_error ( EINFO_EIO_BUFFER_FULL )

Definition at line 99 of file nii.c.

EINFO_EIO_BUFFER_FULL

#define EINFO_EIO_BUFFER_FULL

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_BUFFER_FULL,                \
                          "Buffer full" )

Definition at line 100 of file nii.c.

#define EINFO_EIO_BUFFER_FULL                                                 \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_BUFFER_FULL,                \
                          "Buffer full" )

EIO_INVALID_PARAMETER

#define EIO_INVALID_PARAMETER   __einfo_error ( EINFO_EIO_INVALID_PARAMETER )

Definition at line 103 of file nii.c.

EINFO_EIO_INVALID_PARAMETER

#define EINFO_EIO_INVALID_PARAMETER

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_INVALID_PARAMETER,            \
                          "Invalid parameter" )

Definition at line 104 of file nii.c.

#define EINFO_EIO_INVALID_PARAMETER                                           \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_INVALID_PARAMETER,          \
                          "Invalid parameter" )

EIO_INVALID_UNDI

#define EIO_INVALID_UNDI   __einfo_error ( EINFO_EIO_INVALID_UNDI )

Definition at line 107 of file nii.c.

EINFO_EIO_INVALID_UNDI

#define EINFO_EIO_INVALID_UNDI

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_INVALID_UNDI,                      \
                          "Invalid UNDI" )

Definition at line 108 of file nii.c.

#define EINFO_EIO_INVALID_UNDI                                                \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_INVALID_UNDI,               \
                          "Invalid UNDI" )

EIO_IPV4_NOT_SUPPORTED

#define EIO_IPV4_NOT_SUPPORTED   __einfo_error ( EINFO_EIO_IPV4_NOT_SUPPORTED )

Definition at line 111 of file nii.c.

EINFO_EIO_IPV4_NOT_SUPPORTED

#define EINFO_EIO_IPV4_NOT_SUPPORTED

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_IPV4_NOT_SUPPORTED,          \
                          "IPv4 not supported" )

Definition at line 112 of file nii.c.

#define EINFO_EIO_IPV4_NOT_SUPPORTED                                          \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_IPV4_NOT_SUPPORTED,         \
                          "IPv4 not supported" )

EIO_IPV6_NOT_SUPPORTED

#define EIO_IPV6_NOT_SUPPORTED   __einfo_error ( EINFO_EIO_IPV6_NOT_SUPPORTED )

Definition at line 115 of file nii.c.

EINFO_EIO_IPV6_NOT_SUPPORTED

#define EINFO_EIO_IPV6_NOT_SUPPORTED

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_IPV6_NOT_SUPPORTED,          \
                          "IPv6 not supported" )

Definition at line 116 of file nii.c.

#define EINFO_EIO_IPV6_NOT_SUPPORTED                                          \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_IPV6_NOT_SUPPORTED,         \
                          "IPv6 not supported" )

EIO_NOT_ENOUGH_MEMORY

#define EIO_NOT_ENOUGH_MEMORY   __einfo_error ( EINFO_EIO_NOT_ENOUGH_MEMORY )

Definition at line 119 of file nii.c.

EINFO_EIO_NOT_ENOUGH_MEMORY

#define EINFO_EIO_NOT_ENOUGH_MEMORY

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NOT_ENOUGH_MEMORY,            \
                          "Not enough memory" )

Definition at line 120 of file nii.c.

#define EINFO_EIO_NOT_ENOUGH_MEMORY                                           \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NOT_ENOUGH_MEMORY,          \
                          "Not enough memory" )

EIO_NO_DATA

#define EIO_NO_DATA   __einfo_error ( EINFO_EIO_NO_DATA )

Definition at line 123 of file nii.c.

EINFO_EIO_NO_DATA

#define EINFO_EIO_NO_DATA

Value:

        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NO_DATA,                \
                          "No data" )

Definition at line 124 of file nii.c.

#define EINFO_EIO_NO_DATA                                                     \
        __einfo_uniqify ( EINFO_EIO, PXE_STATCODE_NO_DATA,                    \
                          "No data" )

EIO_STAT

#define EIO_STAT

(

stat

)

Value:

        EUNIQ ( EINFO_EIO, -(stat), EIO_INVALID_CDB, EIO_INVALID_CPB,         \
                EIO_BUSY, EIO_QUEUE_FULL, EIO_ALREADY_STARTED,               \
                EIO_NOT_STARTED, EIO_NOT_SHUTDOWN, EIO_ALREADY_INITIALIZED,   \
                EIO_NOT_INITIALIZED, EIO_DEVICE_FAILURE, EIO_NVDATA_FAILURE,  \
                EIO_UNSUPPORTED, EIO_BUFFER_FULL, EIO_INVALID_PARAMETER,      \
                EIO_INVALID_UNDI, EIO_IPV4_NOT_SUPPORTED,               \
                EIO_IPV6_NOT_SUPPORTED, EIO_NOT_ENOUGH_MEMORY, EIO_NO_DATA )

Definition at line 127 of file nii.c.

#define EIO_STAT( stat )                                                      \
        EUNIQ ( EINFO_EIO, -(stat), EIO_INVALID_CDB, EIO_INVALID_CPB,         \
                EIO_BUSY, EIO_QUEUE_FULL, EIO_ALREADY_STARTED,                \
                EIO_NOT_STARTED, EIO_NOT_SHUTDOWN, EIO_ALREADY_INITIALIZED,   \
                EIO_NOT_INITIALIZED, EIO_DEVICE_FAILURE, EIO_NVDATA_FAILURE,  \
                EIO_UNSUPPORTED, EIO_BUFFER_FULL, EIO_INVALID_PARAMETER,      \
                EIO_INVALID_UNDI, EIO_IPV4_NOT_SUPPORTED,                     \
                EIO_IPV6_NOT_SUPPORTED, EIO_NOT_ENOUGH_MEMORY, EIO_NO_DATA )

Referenced by nii_get_init_info(), nii_get_station_address(), nii_initialise_flags(), nii_poll(), nii_poll_rx(), nii_set_rx_filters(), nii_set_station_address(), nii_shutdown(), nii_start_undi(), nii_stop_undi(), and nii_transmit().

PCI_MAX_BAR

#define PCI_MAX_BAR   6

Maximum PCI BAR.

This is defined in <ipxe/efi/IndustryStandard/Pci22.h>, but we can't #include that since it collides with <ipxe/pci.h>.

Definition at line 141 of file nii.c.

Referenced by nii_pci_open().

NII_RX_QUOTA

#define NII_RX_QUOTA   4

Maximum number of received packets per poll.

Definition at line 201 of file nii.c.

Referenced by nii_poll_rx().

NII_OP

#define NII_OP	(		opcode,
			opflags )

Value:

( (opcode) | ( (opflags) << 16 ) )

Construct operation from opcode and flags.

Parameters

opcode	Opcode
opflags	Flags

Return values

op

Operation

Definition at line 529 of file nii.c.

Referenced by nii_get_station_address(), nii_initialise_flags(), nii_poll(), nii_set_rx_filters(), nii_set_station_address(), and nii_transmit().

NII_OPCODE

#define NII_OPCODE

(

op

)

Value:

( (op) & 0xffff )

Extract opcode from operation.

Parameters

op

Operation

Return values

opcode

Opcode

Definition at line 537 of file nii.c.

Referenced by nii_issue_cpb_db().

NII_OPFLAGS

#define NII_OPFLAGS

(

op

)

Value:

( (op) >> 16 )

Extract flags from operation.

Parameters

op

Operation

Return values

opflags

Flags

Definition at line 545 of file nii.c.

Referenced by nii_issue_cpb_db().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

nii_pci_open()

int nii_pci_open ( struct nii_nic * nii )

static

Open PCI I/O protocol and identify BARs.

Parameters

nii

NII NIC

Return values

rc	Return status code

Definition at line 209 of file nii.c.

                                                {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_HANDLE device = nii->efidev->device;
        EFI_HANDLE pci_device;
        union {
                EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *acpi;
                void *resource;
        } desc;
        int bar;
        EFI_STATUS efirc;
        int rc;
 
        /* Locate PCI I/O protocol */
        if ( ( rc = efi_locate_device ( device, &efi_pci_io_protocol_guid,
                                        &pci_device, 0 ) ) != 0 ) {
                DBGC ( nii, "NII %s could not locate PCI I/O protocol: %s\n",
                       nii->dev.name, strerror ( rc ) );
                goto err_locate;
        }
        nii->pci_device = pci_device;
 
        /* Open PCI I/O protocol
         *
         * We cannot open this safely as a by-driver open, since doing
         * so would disconnect the underlying NII driver.  We must
         * therefore use an unsafe open.
         */
        if ( ( rc = efi_open_unsafe ( pci_device, &efi_pci_io_protocol_guid,
                                      &nii->pci_io ) ) != 0 ) {
                DBGC ( nii, "NII %s could not open PCI I/O protocol: %s\n",
                       nii->dev.name, strerror ( rc ) );
                goto err_open;
        }
 
        /* Identify memory and I/O BARs */
        nii->mem_bar = PCI_MAX_BAR;
        nii->io_bar = PCI_MAX_BAR;
        for ( bar = ( PCI_MAX_BAR - 1 ) ; bar >= 0 ; bar-- ) {
                efirc = nii->pci_io->GetBarAttributes ( nii->pci_io, bar, NULL,
                                                        &desc.resource );
                if ( efirc == EFI_UNSUPPORTED ) {
                        /* BAR not present; ignore */
                        continue;
                }
                if ( efirc != 0 ) {
                        rc = -EEFI ( efirc );
                        DBGC ( nii, "NII %s could not get BAR %d attributes: "
                               "%s\n", nii->dev.name, bar, strerror ( rc ) );
                        goto err_get_bar_attributes;
                }
                if ( desc.acpi->ResType == ACPI_ADDRESS_SPACE_TYPE_MEM ) {
                        nii->mem_bar = bar;
                } else if ( desc.acpi->ResType == ACPI_ADDRESS_SPACE_TYPE_IO ) {
                        nii->io_bar = bar;
                }
                bs->FreePool ( desc.resource );
        }
        DBGC ( nii, "NII %s has ", nii->dev.name );
        if ( nii->mem_bar < PCI_MAX_BAR ) {
                DBGC ( nii, "memory BAR %d and ", nii->mem_bar );
        } else {
                DBGC ( nii, "no memory BAR and " );
        }
        if ( nii->io_bar < PCI_MAX_BAR ) {
                DBGC ( nii, "I/O BAR %d\n", nii->io_bar );
        } else {
                DBGC ( nii, "no I/O BAR\n" );
        }
 
        return 0;
 
 err_get_bar_attributes:
        efi_close_unsafe ( pci_device, &efi_pci_io_protocol_guid );
 err_open:
 err_locate:
        return rc;
}

References acpi, ACPI_ADDRESS_SPACE_TYPE_IO, ACPI_ADDRESS_SPACE_TYPE_MEM, DBGC, desc, nii_nic::dev, efi_device::device, EEFI, efi_close_unsafe(), EFI_HANDLE, efi_locate_device(), efi_open_unsafe, efi_pci_io_protocol_guid, efi_systab, EFI_UNSUPPORTED, nii_nic::efidev, EFI_BOOT_SERVICES::FreePool, _EFI_PCI_IO_PROTOCOL::GetBarAttributes, nii_nic::io_bar, nii_nic::mem_bar, device::name, NULL, nii_nic::pci_device, nii_nic::pci_io, PCI_MAX_BAR, rc, and strerror().

Referenced by nii_start().

nii_pci_close()

void nii_pci_close ( struct nii_nic * nii )

static

Close PCI I/O protocol.

Parameters

nii

NII NIC

Return values

rc	Return status code

Definition at line 293 of file nii.c.

                                                  {
        struct nii_mapping *map;
        struct nii_mapping *tmp;
 
        /* Remove any stale mappings */
        list_for_each_entry_safe ( map, tmp, &nii->mappings, list ) {
                DBGC ( nii, "NII %s removing stale mapping %#llx\n",
                       nii->dev.name, ( ( unsigned long long ) map->addr ) );
                nii->pci_io->Unmap ( nii->pci_io, map->mapping );
                list_del ( &map->list );
                free ( map );
        }
 
        /* Close protocols */
        efi_close_unsafe ( nii->pci_device, &efi_pci_io_protocol_guid );
}

References DBGC, nii_nic::dev, efi_close_unsafe(), efi_pci_io_protocol_guid, free, nii_mapping::list, list_del, list_for_each_entry_safe, map, nii_nic::mappings, device::name, nii_nic::pci_device, nii_nic::pci_io, tmp, and _EFI_PCI_IO_PROTOCOL::Unmap.

Referenced by nii_start(), and nii_stop().

nii_io()

EFIAPI VOID nii_io ( UINT64 unique_id, UINT8 op, UINT8 len, UINT64 addr, UINT64 data )

static

I/O callback.

Parameters

unique_id	NII NIC
op	Operations
len	Length of data
addr	Address
data	Data buffer

Definition at line 319 of file nii.c.

                                          {
        struct nii_nic *nii = ( ( void * ) ( intptr_t ) unique_id );
        EFI_PCI_IO_PROTOCOL_ACCESS *access;
        EFI_PCI_IO_PROTOCOL_IO_MEM io;
        EFI_PCI_IO_PROTOCOL_WIDTH width;
        unsigned int bar;
        EFI_STATUS efirc;
        int rc;
 
        /* Determine accessor and BAR */
        if ( op & ( PXE_MEM_READ | PXE_MEM_WRITE ) ) {
                access = &nii->pci_io->Mem;
                bar = nii->mem_bar;
        } else {
                access = &nii->pci_io->Io;
                bar = nii->io_bar;
        }
 
        /* Determine operaton */
        io = ( ( op & ( PXE_IO_WRITE | PXE_MEM_WRITE ) ) ?
               access->Write : access->Read );
 
        /* Determine width */
        width = ( fls ( len ) - 1 );
 
        /* Issue operation */
        if ( ( efirc = io ( nii->pci_io, width, bar, addr, 1,
                            ( ( void * ) ( intptr_t ) data ) ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( nii, "NII %s I/O operation %#x failed: %s\n",
                       nii->dev.name, op, strerror ( rc ) );
                /* No way to report failure */
                return;
        }
}

References addr, data, DBGC, EEFI, EFIAPI, fls, len, nii_nic::nii, op, PXE_IO_WRITE, PXE_MEM_READ, PXE_MEM_WRITE, rc, EFI_PCI_IO_PROTOCOL_ACCESS::Read, strerror(), VOID, and EFI_PCI_IO_PROTOCOL_ACCESS::Write.

Referenced by nii_start_undi().

nii_map()

EFIAPI VOID nii_map ( UINT64 unique_id, UINT64 addr, UINT32 len, UINT32 dir, UINT64 mapped )

static

Map callback.

Parameters

unique_id	NII NIC
addr	Address of memory to be mapped
len	Length of memory to be mapped
dir	Direction of data flow
mapped	Device mapped address to fill in

Definition at line 365 of file nii.c.

                                                         {
        struct nii_nic *nii = ( ( void * ) ( intptr_t ) unique_id );
        EFI_PHYSICAL_ADDRESS *phys = ( ( void * ) ( intptr_t ) mapped );
        EFI_PCI_IO_PROTOCOL_OPERATION op;
        struct nii_mapping *map;
        UINTN count = len;
        EFI_STATUS efirc;
        int rc;
 
        /* Return a zero mapped address on failure */
        *phys = 0;
 
        /* Determine PCI mapping operation */
        switch ( dir ) {
        case TO_AND_FROM_DEVICE:
                op = EfiPciIoOperationBusMasterCommonBuffer;
                break;
        case FROM_DEVICE:
                op = EfiPciIoOperationBusMasterWrite;
                break;
        case TO_DEVICE:
                op = EfiPciIoOperationBusMasterRead;
                break;
        default:
                DBGC ( nii, "NII %s unsupported mapping direction %d\n",
                       nii->dev.name, dir );
                goto err_dir;
        }
 
        /* Allocate a mapping record */
        map = zalloc ( sizeof ( *map ) );
        if ( ! map )
                goto err_alloc;
        map->addr = addr;
 
        /* Create map */
        if ( ( efirc = nii->pci_io->Map ( nii->pci_io, op,
                                          ( ( void * ) ( intptr_t ) addr ),
                                          &count, phys, &map->mapping ) ) != 0){
                rc = -EEFI ( efirc );
                DBGC ( nii, "NII %s map operation failed: %s\n",
                       nii->dev.name, strerror ( rc ) );
                goto err_map;
        }
 
        /* Add to list of mappings */
        list_add ( &map->list, &nii->mappings );
        DBGC2 ( nii, "NII %s mapped %#llx+%#x->%#llx\n",
                nii->dev.name, ( ( unsigned long long ) addr ),
                len, ( ( unsigned long long ) *phys ) );
        return;
 
        list_del ( &map->list );
 err_map:
        free ( map );
 err_alloc:
 err_dir:
        return;
}

References addr, count, DBGC, DBGC2, nii_nic::dev, EEFI, EFIAPI, EfiPciIoOperationBusMasterCommonBuffer, EfiPciIoOperationBusMasterRead, EfiPciIoOperationBusMasterWrite, free, FROM_DEVICE, len, list_add, list_del, _EFI_PCI_IO_PROTOCOL::Map, map, nii_nic::mappings, device::name, nii_nic::nii, op, nii_nic::pci_io, phys, rc, strerror(), TO_AND_FROM_DEVICE, TO_DEVICE, VOID, and zalloc().

Referenced by nii_start_undi().

nii_unmap()

EFIAPI VOID nii_unmap ( UINT64 unique_id, UINT64 addr, UINT32 len, UINT32 dir __unused, UINT64 mapped )

static

Unmap callback.

Parameters

unique_id	NII NIC
addr	Address of mapped memory
len	Length of mapped memory
dir	Direction of data flow
mapped	Device mapped address

Definition at line 435 of file nii.c.

                                                                    {
        struct nii_nic *nii = ( ( void * ) ( intptr_t ) unique_id );
        struct nii_mapping *map;
 
        /* Locate mapping record */
        list_for_each_entry ( map, &nii->mappings, list ) {
                if ( map->addr == addr ) {
                        nii->pci_io->Unmap ( nii->pci_io, map->mapping );
                        list_del ( &map->list );
                        free ( map );
                        DBGC2 ( nii, "NII %s unmapped %#llx+%#x->%#llx\n",
                                nii->dev.name, ( ( unsigned long long ) addr ),
                                len, ( ( unsigned long long ) mapped ) );
                        return;
                }
        }
 
        DBGC ( nii, "NII %s non-existent mapping %#llx+%#x->%#llx\n",
               nii->dev.name, ( ( unsigned long long ) addr ),
               len, ( ( unsigned long long ) mapped ) );
}

References __unused, addr, DBGC, DBGC2, nii_nic::dev, EFIAPI, free, len, nii_mapping::list, list_del, list_for_each_entry, map, nii_nic::mappings, device::name, nii_nic::nii, nii_nic::pci_io, _EFI_PCI_IO_PROTOCOL::Unmap, and VOID.

Referenced by nii_start_undi().

nii_sync()

EFIAPI VOID nii_sync ( UINT64 unique_id __unused, UINT64 addr, UINT32 len, UINT32 dir, UINT64 mapped )

static

Sync callback.

Parameters

unique_id	NII NIC
addr	Address of mapped memory
len	Length of mapped memory
dir	Direction of data flow
mapped	Device mapped address

Definition at line 467 of file nii.c.

                                                                      {
        const void *src;
        void *dst;
 
        /* Do nothing if this is an identity mapping */
        if ( addr == mapped )
                return;
 
        /* Determine direction */
        if ( dir == FROM_DEVICE ) {
                src = ( ( void * ) ( intptr_t ) mapped );
                dst = ( ( void * ) ( intptr_t ) addr );
        } else {
                src = ( ( void * ) ( intptr_t ) addr );
                dst = ( ( void * ) ( intptr_t ) mapped );
        }
 
        /* Copy data */
        memcpy ( dst, src, len );
}

References __unused, addr, EFIAPI, FROM_DEVICE, len, memcpy(), src, and VOID.

Referenced by nii_start_undi().

nii_delay()

EFIAPI VOID nii_delay ( UINT64 unique_id __unused, UINTN microseconds )

static

Delay callback.

Parameters

unique_id	NII NIC
microseconds	Delay in microseconds

Definition at line 495 of file nii.c.

                                                                               {
 
        udelay ( microseconds );
}

References __unused, EFIAPI, udelay(), and VOID.

Referenced by nii_start_undi().

nii_block()

EFIAPI VOID nii_block ( UINT64 unique_id, UINT32 acquire )

static

Block callback.

Parameters

unique_id	NII NIC
acquire	Acquire lock

Definition at line 506 of file nii.c.

                                                                  {
        struct nii_nic *nii = ( ( void * ) ( intptr_t ) unique_id );
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
 
        /* This functionality (which is copied verbatim from the
         * SnpDxe implementation of this function) appears to be
         * totally brain-dead, since it produces no actual blocking
         * behaviour.
         */
        if ( acquire ) {
                nii->saved_tpl = bs->RaiseTPL ( TPL_NOTIFY );
        } else {
                bs->RestoreTPL ( nii->saved_tpl );
        }
}

References efi_systab, EFIAPI, nii_nic::nii, EFI_BOOT_SERVICES::RaiseTPL, EFI_BOOT_SERVICES::RestoreTPL, TPL_NOTIFY, and VOID.

Referenced by nii_start_undi().

nii_issue_cpb_db()

int nii_issue_cpb_db ( struct nii_nic * nii, unsigned int op, void * cpb, size_t cpb_len, void * db, size_t db_len )

static

Issue command with parameter block and data block.

Parameters

nii	NII NIC
op	Operation
cpb	Command parameter block, or NULL
cpb_len	Command parameter block length
db	Data block, or NULL
db_len	Data block length

Return values

stat	Status flags, or negative status code

Definition at line 558 of file nii.c.

                                                                        {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        PXE_CDB cdb;
        UINTN tpl;
 
        /* Prepare command descriptor block */
        memset ( &cdb, 0, sizeof ( cdb ) );
        cdb.OpCode = NII_OPCODE ( op );
        cdb.OpFlags = NII_OPFLAGS ( op );
        cdb.CPBaddr = ( ( intptr_t ) cpb );
        cdb.CPBsize = cpb_len;
        cdb.DBaddr = ( ( intptr_t ) db );
        cdb.DBsize = db_len;
        cdb.IFnum = nii->nii->IfNum;
 
        /* Raise task priority level */
        tpl = bs->RaiseTPL ( efi_internal_tpl );
 
        /* Issue command */
        DBGC2 ( nii, "NII %s issuing %02x:%04x ifnum %d%s%s\n",
                nii->dev.name, cdb.OpCode, cdb.OpFlags, cdb.IFnum,
                ( cpb ? " cpb" : "" ), ( db ? " db" : "" ) );
        if ( cpb )
                DBGC2_HD ( nii, cpb, cpb_len );
        if ( db )
                DBGC2_HD ( nii, db, db_len );
        nii->issue ( ( intptr_t ) &cdb );
 
        /* Restore task priority level */
        bs->RestoreTPL ( tpl );
 
        /* Check completion status */
        if ( cdb.StatCode != PXE_STATCODE_SUCCESS )
                return -cdb.StatCode;
 
        /* Return command-specific status flags */
        return ( cdb.StatFlags & ~PXE_STATFLAGS_STATUS_MASK );
}

References s_pxe_cdb::CPBaddr, s_pxe_cdb::CPBsize, db, s_pxe_cdb::DBaddr, DBGC2, DBGC2_HD, s_pxe_cdb::DBsize, efi_internal_tpl, efi_systab, s_pxe_cdb::IFnum, _EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL::IfNum, memset(), nii_nic::nii, NII_OPCODE, NII_OPFLAGS, op, s_pxe_cdb::OpCode, s_pxe_cdb::OpFlags, PXE_STATCODE_SUCCESS, PXE_STATFLAGS_STATUS_MASK, EFI_BOOT_SERVICES::RaiseTPL, EFI_BOOT_SERVICES::RestoreTPL, s_pxe_cdb::StatCode, and s_pxe_cdb::StatFlags.

Referenced by nii_initialise_flags(), nii_issue(), nii_issue_cpb(), nii_issue_db(), and nii_poll_rx().

nii_issue_cpb()

int nii_issue_cpb ( struct nii_nic * nii, unsigned int op, void * cpb, size_t cpb_len )

static

Issue command with parameter block.

Parameters

nii	NII NIC
op	Operation
cpb	Command parameter block, or NULL
cpb_len	Command parameter block length

Return values

stat	Status flags, or negative status code

Definition at line 607 of file nii.c.

                                            {
 
        return nii_issue_cpb_db ( nii, op, cpb, cpb_len, NULL, 0 );
}

References nii_nic::nii, nii_issue_cpb_db(), NULL, and op.

Referenced by nii_set_station_address(), nii_start_undi(), and nii_transmit().

nii_issue_db()

int nii_issue_db ( struct nii_nic * nii, unsigned int op, void * db, size_t db_len )

static

Issue command with data block.

Parameters

nii	NII NIC
op	Operation
db	Data block, or NULL
db_len	Data block length

Return values

stat	Status flags, or negative status code

Definition at line 622 of file nii.c.

                                          {
 
        return nii_issue_cpb_db ( nii, op, NULL, 0, db, db_len );
}

References db, nii_nic::nii, nii_issue_cpb_db(), NULL, and op.

Referenced by nii_get_init_info(), nii_get_station_address(), and nii_poll().

nii_issue()

int nii_issue ( struct nii_nic * nii, unsigned int op )

static

Issue command.

Parameters

nii	NII NIC
op	Operation

Return values

stat	Status flags, or negative status code

Definition at line 636 of file nii.c.

                                                              {
 
        return nii_issue_cpb_db ( nii, op, NULL, 0, NULL, 0 );
}

References nii_nic::nii, nii_issue_cpb_db(), NULL, and op.

Referenced by nii_set_rx_filters(), nii_shutdown(), and nii_stop_undi().

nii_start_undi()

int nii_start_undi ( struct nii_nic * nii )

static

Start UNDI.

Parameters

nii

NII NIC

Return values

rc	Return status code

Definition at line 647 of file nii.c.

                                                  {
        PXE_CPB_START_31 cpb;
        int stat;
        int rc;
 
        /* Construct parameter block */
        memset ( &cpb, 0, sizeof ( cpb ) );
        cpb.Delay = ( ( intptr_t ) nii_delay );
        cpb.Block = ( ( intptr_t ) nii_block );
        cpb.Mem_IO = ( ( intptr_t ) nii_io );
        cpb.Map_Mem = ( ( intptr_t ) nii_map );
        cpb.UnMap_Mem = ( ( intptr_t ) nii_unmap );
        cpb.Sync_Mem = ( ( intptr_t ) nii_sync );
        cpb.Unique_ID = ( ( intptr_t ) nii );
 
        /* Issue command */
        if ( ( stat = nii_issue_cpb ( nii, PXE_OPCODE_START, &cpb,
                                      sizeof ( cpb ) ) ) < 0 ) {
                rc = -EIO_STAT ( stat );
                DBGC ( nii, "NII %s could not start: %s\n",
                       nii->dev.name, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References s_pxe_cpb_start_31::Block, DBGC, s_pxe_cpb_start_31::Delay, EIO_STAT, s_pxe_cpb_start_31::Map_Mem, s_pxe_cpb_start_31::Mem_IO, memset(), nii_nic::nii, nii_block(), nii_delay(), nii_io(), nii_issue_cpb(), nii_map(), nii_sync(), nii_unmap(), PXE_OPCODE_START, rc, stat, strerror(), s_pxe_cpb_start_31::Sync_Mem, s_pxe_cpb_start_31::Unique_ID, and s_pxe_cpb_start_31::UnMap_Mem.

Referenced by nii_start().

nii_stop_undi()

void nii_stop_undi ( struct nii_nic * nii )

static

Stop UNDI.

Parameters

nii

NII NIC

Definition at line 679 of file nii.c.

                                                  {
        int stat;
        int rc;
 
        /* Issue command */
        if ( ( stat = nii_issue ( nii, PXE_OPCODE_STOP ) ) < 0 ) {
                rc = -EIO_STAT ( stat );
                DBGC ( nii, "NII %s could not stop: %s\n",
                       nii->dev.name, strerror ( rc ) );
                /* Nothing we can do about it */
                return;
        }
}

References DBGC, EIO_STAT, nii_nic::nii, nii_issue(), PXE_OPCODE_STOP, rc, stat, and strerror().

Referenced by nii_start(), and nii_stop().

nii_get_init_info()

int nii_get_init_info ( struct nii_nic * nii, struct net_device * netdev )

static

Get initialisation information.

Parameters

nii	NII NIC
netdev	Network device to fill in

Return values

rc	Return status code

Definition at line 700 of file nii.c.

                                                           {
        PXE_DB_GET_INIT_INFO db;
        int stat;
        int rc;
 
        /* Issue command */
        if ( ( stat = nii_issue_db ( nii, PXE_OPCODE_GET_INIT_INFO, &db,
                                     sizeof ( db ) ) ) < 0 ) {
                rc = -EIO_STAT ( stat );
                DBGC ( nii, "NII %s could not get initialisation info: %s\n",
                       nii->dev.name, strerror ( rc ) );
                return rc;
        }
 
        /* Determine link layer protocol */
        switch ( db.IFtype ) {
        case PXE_IFTYPE_ETHERNET :
                netdev->ll_protocol = &ethernet_protocol;
                break;
        default:
                DBGC ( nii, "NII %s unknown interface type %#02x\n",
                       nii->dev.name, db.IFtype );
                return -ENOTSUP;
        }
 
        /* Sanity checks */
        assert ( db.MediaHeaderLen == netdev->ll_protocol->ll_header_len );
        assert ( db.HWaddrLen == netdev->ll_protocol->hw_addr_len );
        assert ( db.HWaddrLen == netdev->ll_protocol->ll_addr_len );
 
        /* Extract parameters */
        nii->buffer_len = db.MemoryRequired;
        nii->mtu = ( db.FrameDataLen + db.MediaHeaderLen );
        netdev->max_pkt_len = nii->mtu;
        nii->media = ( stat & PXE_STATFLAGS_GET_STATUS_NO_MEDIA_SUPPORTED );
 
        return 0;
}

References assert, db, DBGC, EIO_STAT, ENOTSUP, netdev, nii_nic::nii, nii_issue_db(), PXE_IFTYPE_ETHERNET, PXE_OPCODE_GET_INIT_INFO, PXE_STATFLAGS_GET_STATUS_NO_MEDIA_SUPPORTED, rc, stat, and strerror().

Referenced by nii_start().

nii_initialise_flags()

int nii_initialise_flags ( struct nii_nic * nii, unsigned int flags )

static

Initialise UNDI.

Parameters

nii	NII NIC
flags	Flags

Return values

rc	Return status code

Definition at line 747 of file nii.c.

                                                                            {
        PXE_CPB_INITIALIZE cpb;
        PXE_DB_INITIALIZE db;
        unsigned int op;
        int stat;
        int rc;
 
        /* Allocate memory buffer */
        nii->buffer = umalloc ( nii->buffer_len );
        if ( ! nii->buffer ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
 
        /* Construct parameter block */
        memset ( &cpb, 0, sizeof ( cpb ) );
        cpb.MemoryAddr = ( ( intptr_t ) nii->buffer );
        cpb.MemoryLength = nii->buffer_len;
 
        /* Construct data block */
        memset ( &db, 0, sizeof ( db ) );
 
        /* Issue command */
        op = NII_OP ( PXE_OPCODE_INITIALIZE, flags );
        if ( ( stat = nii_issue_cpb_db ( nii, op, &cpb, sizeof ( cpb ),
                                         &db, sizeof ( db ) ) ) < 0 ) {
                rc = -EIO_STAT ( stat );
                DBGC ( nii, "NII %s could not initialise: %s\n",
                       nii->dev.name, strerror ( rc ) );
                goto err_initialize;
        }
 
        return 0;
 
 err_initialize:
        ufree ( nii->buffer );
 err_alloc:
        return rc;
}

References db, DBGC, EIO_STAT, ENOMEM, flags, s_pxe_cpb_initialize::MemoryAddr, s_pxe_cpb_initialize::MemoryLength, memset(), nii_nic::nii, nii_issue_cpb_db(), NII_OP, op, PXE_OPCODE_INITIALIZE, rc, stat, strerror(), ufree(), and umalloc().

Referenced by nii_initialise(), and nii_initialise_cable().

nii_initialise_cable()

int nii_initialise_cable ( struct nii_nic * nii )

static

Initialise UNDI with cable detection.

Parameters

nii

NII NIC

Return values

rc	Return status code

Definition at line 793 of file nii.c.

                                                        {
        unsigned int flags;
 
        /* Initialise UNDI */
        flags = PXE_OPFLAGS_INITIALIZE_DETECT_CABLE;
        return nii_initialise_flags ( nii, flags );
}

References flags, nii_nic::nii, nii_initialise_flags(), and PXE_OPFLAGS_INITIALIZE_DETECT_CABLE.

Referenced by nii_open().

nii_initialise()

int nii_initialise ( struct nii_nic * nii )

static

Initialise UNDI.

Parameters

nii

NII NIC

Return values

rc	Return status code

Definition at line 807 of file nii.c.

                                                  {
        unsigned int flags;
 
        /* Initialise UNDI */
        flags = PXE_OPFLAGS_INITIALIZE_DO_NOT_DETECT_CABLE;
        return nii_initialise_flags ( nii, flags );
}

References flags, nii_nic::nii, nii_initialise_flags(), and PXE_OPFLAGS_INITIALIZE_DO_NOT_DETECT_CABLE.

Referenced by nii_get_station_address(), and nii_open().

nii_shutdown()

void nii_shutdown ( struct nii_nic * nii )

static

Shut down UNDI.

Parameters

nii

NII NIC

Definition at line 820 of file nii.c.

                                                 {
        int stat;
        int rc;
 
        /* Issue command */
        if ( ( stat = nii_issue ( nii, PXE_OPCODE_SHUTDOWN ) ) < 0 ) {
                rc = -EIO_STAT ( stat );
                DBGC ( nii, "NII %s could not shut down: %s\n",
                       nii->dev.name, strerror ( rc ) );
                /* Leak memory to avoid corruption */
                return;
        }
 
        /* Free buffer */
        ufree ( nii->buffer );
}

References DBGC, EIO_STAT, nii_nic::nii, nii_issue(), PXE_OPCODE_SHUTDOWN, rc, stat, strerror(), and ufree().

Referenced by nii_close(), nii_get_station_address(), and nii_open().

nii_get_station_address()

int nii_get_station_address ( struct nii_nic * nii, struct net_device * netdev )

static

Get station addresses.

Parameters

nii	NII NIC
netdev	Network device to fill in

Return values

rc	Return status code

Definition at line 844 of file nii.c.

                                                                 {
        PXE_DB_STATION_ADDRESS db;
        unsigned int op;
        int stat;
        int rc;
 
        /* Initialise UNDI */
        if ( ( rc = nii_initialise ( nii ) ) != 0 )
                goto err_initialise;
 
        /* Issue command */
        op = NII_OP ( PXE_OPCODE_STATION_ADDRESS,
                      PXE_OPFLAGS_STATION_ADDRESS_READ );
        if ( ( stat = nii_issue_db ( nii, op, &db, sizeof ( db ) ) ) < 0 ) {
                rc = -EIO_STAT ( stat );
                DBGC ( nii, "NII %s could not get station address: %s\n",
                       nii->dev.name, strerror ( rc ) );
                goto err_station_address;
        }
 
        /* Copy MAC addresses */
        memcpy ( netdev->ll_addr, db.StationAddr,
                 netdev->ll_protocol->ll_addr_len );
        memcpy ( netdev->hw_addr, db.PermanentAddr,
                 netdev->ll_protocol->hw_addr_len );
        memcpy ( nii->broadcast, db.BroadcastAddr,
                 sizeof ( nii->broadcast ) );
 
 err_station_address:
        nii_shutdown ( nii );
 err_initialise:
        return rc;
}

References db, DBGC, EIO_STAT, memcpy(), netdev, nii_nic::nii, nii_initialise(), nii_issue_db(), NII_OP, nii_shutdown(), op, PXE_OPCODE_STATION_ADDRESS, PXE_OPFLAGS_STATION_ADDRESS_READ, rc, stat, and strerror().

Referenced by nii_start().

nii_set_station_address()

int nii_set_station_address ( struct nii_nic * nii, struct net_device * netdev )

static

Set station address.

Parameters

nii	NII NIC
netdev	Network device

Return values

rc	Return status code

Definition at line 886 of file nii.c.

                                                                 {
        uint32_t implementation = nii->undi->Implementation;
        PXE_CPB_STATION_ADDRESS cpb;
        unsigned int op;
        int stat;
        int rc;
 
        /* Fail if setting station address is unsupported */
        if ( ! ( implementation & PXE_ROMID_IMP_STATION_ADDR_SETTABLE ) )
                return -ENOTSUP;
 
        /* Construct parameter block */
        memset ( &cpb, 0, sizeof ( cpb ) );
        memcpy ( cpb.StationAddr, netdev->ll_addr,
                 netdev->ll_protocol->ll_addr_len );
 
        /* Issue command */
        op = NII_OP ( PXE_OPCODE_STATION_ADDRESS,
                      PXE_OPFLAGS_STATION_ADDRESS_WRITE );
        if ( ( stat = nii_issue_cpb ( nii, op, &cpb, sizeof ( cpb ) ) ) < 0 ) {
                rc = -EIO_STAT ( stat );
                DBGC ( nii, "NII %s could not set station address: %s\n",
                       nii->dev.name, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, EIO_STAT, ENOTSUP, implementation, memcpy(), memset(), netdev, nii_nic::nii, nii_issue_cpb(), NII_OP, op, PXE_OPCODE_STATION_ADDRESS, PXE_OPFLAGS_STATION_ADDRESS_WRITE, PXE_ROMID_IMP_STATION_ADDR_SETTABLE, rc, stat, s_pxe_cpb_station_address::StationAddr, and strerror().

Referenced by nii_open().

nii_set_rx_filters()

int nii_set_rx_filters ( struct nii_nic * nii, unsigned int flags )

static

Set receive filters.

Parameters

nii	NII NIC
flags	Flags

Return values

rc	Return status code

Definition at line 923 of file nii.c.

                                                                          {
        uint32_t implementation = nii->undi->Implementation;
        unsigned int op;
        int stat;
        int rc;
 
        /* Construct receive filter set */
        flags |= PXE_OPFLAGS_RECEIVE_FILTER_UNICAST;
        if ( implementation & PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED )
                flags |= PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST;
        if ( implementation & PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED )
                flags |= PXE_OPFLAGS_RECEIVE_FILTER_PROMISCUOUS;
        if ( implementation & PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED )
                flags |= PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST;
 
        /* Issue command */
        op = NII_OP ( PXE_OPCODE_RECEIVE_FILTERS, flags );
        if ( ( stat = nii_issue ( nii, op ) ) < 0 ) {
                rc = -EIO_STAT ( stat );
                DBGC ( nii, "NII %s could not %s%sable receive filters "
                       "%#04x: %s\n", nii->dev.name,
                       ( ( flags & PXE_OPFLAGS_RECEIVE_FILTER_ENABLE ) ?
                         "en" : "" ),
                       ( ( flags & PXE_OPFLAGS_RECEIVE_FILTER_DISABLE ) ?
                         "dis" : "" ), flags, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, EIO_STAT, flags, implementation, nii_nic::nii, nii_issue(), NII_OP, op, PXE_OPCODE_RECEIVE_FILTERS, PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST, PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST, PXE_OPFLAGS_RECEIVE_FILTER_DISABLE, PXE_OPFLAGS_RECEIVE_FILTER_ENABLE, PXE_OPFLAGS_RECEIVE_FILTER_PROMISCUOUS, PXE_OPFLAGS_RECEIVE_FILTER_UNICAST, PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED, PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED, PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED, rc, stat, and strerror().

Referenced by nii_disable_rx_filters(), and nii_enable_rx_filters().

nii_enable_rx_filters()

int nii_enable_rx_filters ( struct nii_nic * nii )

static

Enable receive filters.

Parameters

nii

NII NIC

Return values

rc	Return status code

Definition at line 960 of file nii.c.

                                                         {
 
        return nii_set_rx_filters ( nii, PXE_OPFLAGS_RECEIVE_FILTER_ENABLE );
}

References nii_nic::nii, nii_set_rx_filters(), and PXE_OPFLAGS_RECEIVE_FILTER_ENABLE.

Referenced by nii_open().

nii_disable_rx_filters()

int nii_disable_rx_filters ( struct nii_nic * nii )

static

Disable receive filters.

Parameters

nii

NII NIC

Return values

rc	Return status code

Definition at line 971 of file nii.c.

                                                          {
 
        return nii_set_rx_filters ( nii, PXE_OPFLAGS_RECEIVE_FILTER_DISABLE );
}

References nii_nic::nii, nii_set_rx_filters(), and PXE_OPFLAGS_RECEIVE_FILTER_DISABLE.

Referenced by nii_open().

nii_transmit()

int nii_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 983 of file nii.c.

                                                    {
        struct nii_nic *nii = netdev->priv;
        PXE_CPB_TRANSMIT cpb;
        unsigned int op;
        int stat;
        int rc;
 
        /* Defer the packet if there is already a transmission in progress */
        if ( nii->txbuf ) {
                netdev_tx_defer ( netdev, iobuf );
                return 0;
        }
 
        /* Pad to minimum Ethernet length, to work around underlying
         * drivers that do not correctly handle frame padding
         * themselves.
         */
        iob_pad ( iobuf, ETH_ZLEN );
 
        /* Construct parameter block */
        memset ( &cpb, 0, sizeof ( cpb ) );
        cpb.FrameAddr = ( ( intptr_t ) iobuf->data );
        cpb.DataLen = iob_len ( iobuf );
 
        /* Transmit packet */
        op = NII_OP ( PXE_OPCODE_TRANSMIT,
                      ( PXE_OPFLAGS_TRANSMIT_WHOLE |
                        PXE_OPFLAGS_TRANSMIT_DONT_BLOCK ) );
        if ( ( stat = nii_issue_cpb ( nii, op, &cpb, sizeof ( cpb ) ) ) < 0 ) {
                rc = -EIO_STAT ( stat );
                DBGC ( nii, "NII %s could not transmit: %s\n",
                       nii->dev.name, strerror ( rc ) );
                return rc;
        }
        nii->txbuf = iobuf;
 
        return 0;
}

References io_buffer::data, s_pxe_cpb_transmit::DataLen, DBGC, EIO_STAT, ETH_ZLEN, s_pxe_cpb_transmit::FrameAddr, iob_len(), iob_pad(), memset(), netdev, netdev_tx_defer(), nii_nic::nii, nii_issue_cpb(), NII_OP, op, PXE_OPCODE_TRANSMIT, PXE_OPFLAGS_TRANSMIT_DONT_BLOCK, PXE_OPFLAGS_TRANSMIT_WHOLE, rc, stat, and strerror().

nii_poll_tx()

void nii_poll_tx ( struct net_device * netdev, unsigned int stat )

static

Poll for completed packets.

Parameters

netdev	Network device
stat	Status flags

Definition at line 1029 of file nii.c.

                                                                         {
        struct nii_nic *nii = netdev->priv;
        struct io_buffer *iobuf;
 
        /* Do nothing unless we have a completion */
        if ( stat & PXE_STATFLAGS_GET_STATUS_NO_TXBUFS_WRITTEN )
                return;
 
        /* Ignore spurious completions reported by some devices */
        if ( ! nii->txbuf )
                return;
 
        /* Complete transmission */
        iobuf = nii->txbuf;
        nii->txbuf = NULL;
        netdev_tx_complete ( netdev, iobuf );
}

References netdev, netdev_tx_complete(), nii_nic::nii, NULL, PXE_STATFLAGS_GET_STATUS_NO_TXBUFS_WRITTEN, stat, and nii_nic::txbuf.

Referenced by nii_poll().

nii_poll_rx()

void nii_poll_rx ( struct net_device * netdev )

static

Poll for received packets.

Parameters

netdev

Network device

Definition at line 1052 of file nii.c.

                                                      {
        struct nii_nic *nii = netdev->priv;
        PXE_CPB_RECEIVE cpb;
        PXE_DB_RECEIVE db;
        unsigned int quota;
        int stat;
        int rc;
 
        /* Retrieve up to NII_RX_QUOTA packets */
        for ( quota = NII_RX_QUOTA ; quota ; quota-- ) {
 
                /* Allocate buffer, if required */
                if ( ! nii->rxbuf ) {
                        nii->rxbuf = alloc_iob ( nii->mtu );
                        if ( ! nii->rxbuf ) {
                                /* Leave for next poll */
                                break;
                        }
                }
 
                /* Construct parameter block */
                memset ( &cpb, 0, sizeof ( cpb ) );
                cpb.BufferAddr = ( ( intptr_t ) nii->rxbuf->data );
                cpb.BufferLen = iob_tailroom ( nii->rxbuf );
 
                /* Issue command */
                if ( ( stat = nii_issue_cpb_db ( nii, PXE_OPCODE_RECEIVE,
                                                 &cpb, sizeof ( cpb ),
                                                 &db, sizeof ( db ) ) ) < 0 ) {
 
                        /* PXE_STATCODE_NO_DATA is just the usual "no packet"
                         * status indicator; ignore it.
                         */
                        if ( stat == -PXE_STATCODE_NO_DATA )
                                break;
 
                        /* Anything else is an error */
                        rc = -EIO_STAT ( stat );
                        DBGC ( nii, "NII %s could not receive: %s\n",
                               nii->dev.name, strerror ( rc ) );
                        netdev_rx_err ( netdev, NULL, rc );
                        break;
                }
 
                /* Hand off to network stack */
                iob_put ( nii->rxbuf, db.FrameLen );
                netdev_rx ( netdev, nii->rxbuf );
                nii->rxbuf = NULL;
        }
}

References alloc_iob(), s_pxe_cpb_receive::BufferAddr, s_pxe_cpb_receive::BufferLen, db, DBGC, EIO_STAT, iob_put, iob_tailroom(), memset(), netdev, netdev_rx(), netdev_rx_err(), nii_nic::nii, nii_issue_cpb_db(), NII_RX_QUOTA, NULL, PXE_OPCODE_RECEIVE, PXE_STATCODE_NO_DATA, rc, stat, and strerror().

Referenced by nii_poll().

nii_poll_link()

void nii_poll_link ( struct net_device * netdev, unsigned int stat )

static

Check for link state changes.

Parameters

netdev	Network device
stat	Status flags

Definition at line 1109 of file nii.c.

                                                                           {
        int no_media = ( stat & PXE_STATFLAGS_GET_STATUS_NO_MEDIA );
 
        if ( no_media && netdev_link_ok ( netdev ) ) {
                netdev_link_down ( netdev );
        } else if ( ( ! no_media ) && ( ! netdev_link_ok ( netdev ) ) ) {
                netdev_link_up ( netdev );
        }
}

References netdev, netdev_link_down(), netdev_link_ok(), netdev_link_up(), PXE_STATFLAGS_GET_STATUS_NO_MEDIA, and stat.

Referenced by nii_poll().

nii_poll()

void nii_poll ( struct net_device * netdev )

static

Poll for completed packets.

Parameters

netdev

Network device

Definition at line 1124 of file nii.c.

                                                   {
        struct nii_nic *nii = netdev->priv;
        PXE_DB_GET_STATUS db;
        unsigned int op;
        int stat;
        int rc;
 
        /* Construct data block */
        memset ( &db, 0, sizeof ( db ) );
 
        /* Get status */
        op = NII_OP ( PXE_OPCODE_GET_STATUS,
                      ( PXE_OPFLAGS_GET_INTERRUPT_STATUS |
                        PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS |
                        ( nii->media ? PXE_OPFLAGS_GET_MEDIA_STATUS : 0 ) ) );
        if ( ( stat = nii_issue_db ( nii, op, &db, sizeof ( db ) ) ) < 0 ) {
                rc = -EIO_STAT ( stat );
                DBGC ( nii, "NII %s could not get status: %s\n",
                       nii->dev.name, strerror ( rc ) );
                return;
        }
 
        /* Process any TX completions */
        nii_poll_tx ( netdev, stat );
 
        /* Process any RX completions */
        nii_poll_rx ( netdev );
 
        /* Check for link state changes */
        if ( nii->media )
                nii_poll_link ( netdev, stat );
}

References db, DBGC, EIO_STAT, memset(), netdev, nii_nic::nii, nii_issue_db(), NII_OP, nii_poll_link(), nii_poll_rx(), nii_poll_tx(), op, PXE_OPCODE_GET_STATUS, PXE_OPFLAGS_GET_INTERRUPT_STATUS, PXE_OPFLAGS_GET_MEDIA_STATUS, PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS, rc, stat, and strerror().

nii_open()

int nii_open ( struct net_device * netdev )

static

Open network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 1163 of file nii.c.

                                                  {
        struct nii_nic *nii = netdev->priv;
        int rc;
 
        /* Initialise NIC
         *
         * We don't care about link state here, and would prefer to
         * have the NIC initialise even if no cable is present, to
         * match the behaviour of all other iPXE drivers.
         *
         * Some Emulex NII drivers have a bug which prevents packets
         * from being sent or received unless we specifically ask it
         * to detect cable presence during initialisation.
         *
         * Unfortunately, some other NII drivers (e.g. Mellanox) may
         * time out and report failure if asked to detect cable
         * presence during initialisation on links that are physically
         * slow to reach link-up.
         *
         * Attempt to work around both of these problems by first
         * attempting to initialise with cable presence detection,
         * then falling back to initialising without cable presence
         * detection.
         */
        if ( ( rc = nii_initialise_cable ( nii ) ) != 0 ) {
                DBGC ( nii, "NII %s could not initialise with cable "
                       "detection: %s\n", nii->dev.name, strerror ( rc ) );
                if ( ( rc = nii_initialise ( nii ) ) != 0 ) {
                        DBGC ( nii, "NII %s could not initialise without "
                               "cable detection: %s\n",
                               nii->dev.name, strerror ( rc ) );
                        goto err_initialise;
                }
        }
 
        /* Attempt to set station address */
        if ( ( rc = nii_set_station_address ( nii, netdev ) ) != 0 ) {
                DBGC ( nii, "NII %s could not set station address: %s\n",
                       nii->dev.name, strerror ( rc ) );
                /* Treat as non-fatal */
        }
 
        /* Disable receive filters
         *
         * We have no reason to disable receive filters here (or
         * anywhere), but some NII drivers have a bug which prevents
         * packets from being received unless we attempt to disable
         * the receive filters.
         *
         * Ignore any failures, since we genuinely don't care if the
         * NII driver cannot disable the filters.
         */
        nii_disable_rx_filters ( nii );
 
        /* Enable receive filters */
        if ( ( rc = nii_enable_rx_filters ( nii ) ) != 0 )
                goto err_enable_rx_filters;
 
        return 0;
 
 err_enable_rx_filters:
        nii_shutdown ( nii );
 err_initialise:
        return rc;
}

References DBGC, netdev, nii_nic::nii, nii_disable_rx_filters(), nii_enable_rx_filters(), nii_initialise(), nii_initialise_cable(), nii_set_station_address(), nii_shutdown(), rc, and strerror().

nii_close()

void nii_close ( struct net_device * netdev )

static

Close network device.

Parameters

netdev

Network device

Definition at line 1234 of file nii.c.

                                                    {
        struct nii_nic *nii = netdev->priv;
 
        /* Shut down NIC */
        nii_shutdown ( nii );
 
        /* Discard transmit buffer, if applicable */
        if ( nii->txbuf ) {
                netdev_tx_complete_err ( netdev, nii->txbuf, -ECANCELED );
                nii->txbuf = NULL;
        }
 
        /* Discard receive buffer, if applicable */
        if ( nii->rxbuf ) {
                free_iob ( nii->rxbuf );
                nii->rxbuf = NULL;
        }
}

References ECANCELED, free_iob(), netdev, netdev_tx_complete_err(), nii_nic::nii, nii_shutdown(), and NULL.

nii_exclude()

int nii_exclude

(

EFI_HANDLE

device

)

Exclude existing drivers.

Parameters

device

EFI device handle

Return values

rc	Return status code

Definition at line 1267 of file nii.c.

                                      {
        EFI_GUID *protocol = &efi_nii31_protocol_guid;
        int rc;
 
        /* Exclude existing NII protocol drivers */
        if ( ( rc = efi_driver_exclude ( device, protocol ) ) != 0 ) {
                DBGC ( device, "NII %s could not exclude drivers: %s\n",
                       efi_handle_name ( device ), strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, efi_driver_exclude(), EFI_HANDLE, efi_handle_name(), efi_nii31_protocol_guid, protocol, rc, and strerror().

Referenced by __efi_driver().

nii_start()

int nii_start

(

struct efi_device *

efidev

)

Attach driver to device.

Parameters

efidev

EFI device

Return values

rc	Return status code

Definition at line 1287 of file nii.c.

                                            {
        EFI_HANDLE device = efidev->device;
        struct net_device *netdev;
        struct nii_nic *nii;
        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;
        INIT_LIST_HEAD ( &nii->mappings );
        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 ( ( rc = efi_open_by_driver ( device, &efi_nii31_protocol_guid,
                                         &nii->nii ) ) != 0 ) {
                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;
        }
 
        /* 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 impl %#08x\n",
               nii->dev.name, nii->nii->MajorVer, nii->nii->MinorVer,
               nii->undi, nii->issue, nii->undi->Implementation );
 
        /* 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 %s\n", nii->dev.name,
               netdev->name, 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:
        efi_close_by_driver ( device, &efi_nii31_protocol_guid );
 err_open_protocol:
        list_del ( &nii->dev.siblings );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
 err_alloc:
        return rc;
}

References alloc_netdev(), device::children, DBGC, DBGC_EFI_OPENERS, efi_device::dev, efi_device::device, efi_close_by_driver(), efi_device_info(), EFI_HANDLE, efi_handle_name(), efi_nii31_protocol_guid, efi_open_by_driver, nii_nic::efidev, efidev_set_drvdata(), ENODEV, ENOMEM, ENOTSUP, _EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL::Id, INIT_LIST_HEAD, list_add, list_del, _EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL::MajorVer, _EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL::MinorVer, netdev, netdev_init(), netdev_link_up(), netdev_nullify(), netdev_put(), nii_nic::nii, nii_get_init_info(), nii_get_station_address(), nii_operations, nii_pci_close(), nii_pci_open(), nii_start_undi(), nii_stop_undi(), PXE_ROMID_IMP_HW_UNDI, PXE_ROMID_IMP_SW_VIRT_ADDR, rc, register_netdev(), strerror(), and unregister_netdev().

Referenced by __efi_driver().

nii_stop()

void nii_stop

(

struct efi_device *

efidev

)

Detach driver from device.

Parameters

efidev

EFI device

Definition at line 1398 of file nii.c.

                                            {
        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 */
        efi_close_by_driver ( device, &efi_nii31_protocol_guid );
 
        /* Free network device */
        list_del ( &nii->dev.siblings );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
}

References efi_device::device, efi_close_by_driver(), EFI_HANDLE, efi_nii31_protocol_guid, nii_nic::efidev, efidev_get_drvdata(), list_del, netdev, netdev_nullify(), netdev_put(), nii_nic::nii, nii_pci_close(), nii_stop_undi(), and unregister_netdev().

Referenced by __efi_driver().

Variable Documentation

nii_operations

struct net_device_operations nii_operations

static

Initial value:

= {
        .open = nii_open,
        .close = nii_close,
        .transmit = nii_transmit,
        .poll = nii_poll,
}

NII network device operations.

Definition at line 1254 of file nii.c.

                                                     {
        .open = nii_open,
        .close = nii_close,
        .transmit = nii_transmit,
        .poll = nii_poll,
};

Referenced by nii_start().