ice.c File Reference

Intel 100 Gigabit Ethernet network card driver. More...

#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/netdevice.h>
#include <ipxe/ethernet.h>
#include <ipxe/if_ether.h>
#include <ipxe/iobuf.h>
#include <ipxe/pci.h>
#include "ice.h"

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static int	ice_admin_version (struct intelxl_nic *intelxl)
	Get firmware version.
static int	ice_admin_mac_read (struct net_device *netdev)
	Get MAC address.
static int	ice_admin_mac_write (struct net_device *netdev)
	Set MAC address.
static int	ice_admin_switch (struct intelxl_nic *intelxl)
	Get switch configuration.
static int	ice_admin_rules (struct intelxl_nic *intelxl, uint8_t *mac)
	Add switch rules.
static struct ice_admin_schedule_node *	ice_admin_schedule_is_parent (struct ice_admin_schedule_branch *branch, struct ice_admin_schedule_node *node)
	Check if scheduler node is a parent (i.e.
static int	ice_admin_schedule (struct intelxl_nic *intelxl)
	Query default scheduling tree topology.
static int	ice_admin_autoneg (struct intelxl_nic *intelxl)
	Restart autonegotiation.
static int	ice_admin_link (struct net_device *netdev)
	Get link status.
static void	ice_admin_event (struct net_device *netdev, struct intelxl_admin_descriptor *xlevt, union intelxl_admin_buffer *xlbuf __unused)
	Handle admin event.
static int	ice_admin_add_txq (struct intelxl_nic *intelxl, struct intelxl_ring *ring)
	Add transmit queue.
static int	ice_admin_disable_txq (struct intelxl_nic *intelxl)
	Disable transmit queue.
static void	ice_dump_tx (struct intelxl_nic *intelxl)
	Dump transmit queue context (for debugging)
static void	ice_dump_rx (struct intelxl_nic *intelxl)
	Dump receive queue context (for debugging)
static int	ice_create_tx (struct intelxl_nic *intelxl, struct intelxl_ring *ring)
	Create transmit queue.
static void	ice_destroy_tx (struct intelxl_nic *intelxl, struct intelxl_ring *ring)
	Destroy transmit queue.
static int	ice_context_rx (struct intelxl_nic *intelxl, physaddr_t address)
	Program receive queue context.
static int	ice_open (struct net_device *netdev)
	Open network device.
static void	ice_close (struct net_device *netdev)
	Close network device.
static int	ice_probe (struct pci_device *pci)
	Probe PCI device.
static void	ice_remove (struct pci_device *pci)
	Remove PCI device.

Variables
static uint8_t	ice_magic_mac [ETH_HLEN] = { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 }
	Magic MAC address.
static struct net_device_operations	ice_operations
	Network device operations.
static struct pci_device_id	ice_nics []
	PCI device IDs.
struct pci_driver ice_driver	__pci_driver
	PCI driver.

Detailed Description

Intel 100 Gigabit Ethernet network card driver.

Definition in file ice.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

ice_admin_version()

int ice_admin_version ( struct intelxl_nic * intelxl )

static

Get firmware version.

Parameters

intelxl

Intel device

Return values

rc	Return status code

Definition at line 66 of file ice.c.

                                                             {
        struct ice_admin_descriptor *cmd;
        struct ice_admin_version_params *version;
        unsigned int api;
        int rc;
 
        /* Populate descriptor */
        cmd = ice_admin_command_descriptor ( intelxl );
        cmd->opcode = cpu_to_le16 ( INTELXL_ADMIN_VERSION );
        version = &cmd->params.version;
 
        /* Issue command */
        if ( ( rc = intelxl_admin_command ( intelxl ) ) != 0 )
                return rc;
        api = version->api.major;
        DBGC ( intelxl, "ICE %p firmware v%d/%d.%d.%d API v%d/%d.%d.%d\n",
               intelxl, version->firmware.branch, version->firmware.major,
               version->firmware.minor, version->firmware.patch,
               version->api.branch, version->api.major, version->api.minor,
               version->api.patch );
 
        /* Check for API compatibility */
        if ( api > INTELXL_ADMIN_API_MAJOR ) {
                DBGC ( intelxl, "ICE %p unsupported API v%d\n", intelxl, api );
                return -ENOTSUP;
        }
 
        return 0;
}

References api, cmd, cpu_to_le16, DBGC, ENOTSUP, ice_admin_command_descriptor(), INTELXL_ADMIN_API_MAJOR, intelxl_admin_command(), INTELXL_ADMIN_VERSION, rc, and version.

ice_admin_mac_read()

int ice_admin_mac_read ( struct net_device * netdev )

static

Get MAC address.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 102 of file ice.c.

                                                            {
        struct intelxl_nic *intelxl = netdev->priv;
        struct ice_admin_descriptor *cmd;
        struct ice_admin_mac_read_params *read;
        struct ice_admin_mac_read_address *mac;
        union ice_admin_buffer *buf;
        unsigned int i;
        int rc;
 
        /* Populate descriptor */
        cmd = ice_admin_command_descriptor ( intelxl );
        cmd->opcode = cpu_to_le16 ( INTELXL_ADMIN_MAC_READ );
        cmd->flags = cpu_to_le16 ( INTELXL_ADMIN_FL_BUF );
        cmd->len = cpu_to_le16 ( sizeof ( buf->mac_read ) );
        read = &cmd->params.mac_read;
        buf = ice_admin_command_buffer ( intelxl );
 
        /* Issue command */
        if ( ( rc = intelxl_admin_command ( intelxl ) ) != 0 )
                return rc;
 
        /* Check that MAC address is present in response */
        if ( ! ( read->valid & INTELXL_ADMIN_MAC_READ_VALID_LAN ) ) {
                DBGC ( intelxl, "ICE %p has no MAC address\n", intelxl );
                return -ENOENT;
        }
 
        /* Identify MAC address */
        for ( i = 0 ; i < read->count ; i++ ) {
 
                /* Check for a LAN MAC address */
                mac = &buf->mac_read.mac[i];
                if ( mac->type != ICE_ADMIN_MAC_READ_TYPE_LAN )
                        continue;
 
                /* Check that address is valid */
                if ( ! is_valid_ether_addr ( mac->mac ) ) {
                        DBGC ( intelxl, "ICE %p has invalid MAC address "
                               "(%s)\n", intelxl, eth_ntoa ( mac->mac ) );
                        return -EINVAL;
                }
 
                /* Copy MAC address */
                DBGC ( intelxl, "ICE %p has MAC address %s\n",
                       intelxl, eth_ntoa ( mac->mac ) );
                memcpy ( netdev->hw_addr, mac->mac, ETH_ALEN );
 
                return 0;
        }
 
        /* Missing LAN MAC address */
        DBGC ( intelxl, "ICE %p has no LAN MAC address\n",
               intelxl );
        return -ENOENT;
}

References cmd, cpu_to_le16, DBGC, EINVAL, ENOENT, ETH_ALEN, eth_ntoa(), ice_admin_command_buffer(), ice_admin_command_descriptor(), ICE_ADMIN_MAC_READ_TYPE_LAN, intelxl_admin_command(), INTELXL_ADMIN_FL_BUF, INTELXL_ADMIN_MAC_READ, INTELXL_ADMIN_MAC_READ_VALID_LAN, is_valid_ether_addr(), ice_admin_mac_read_buffer::mac, mac, ice_admin_buffer::mac_read, memcpy(), netdev, rc, and read.

Referenced by ice_probe().

ice_admin_mac_write()

int ice_admin_mac_write ( struct net_device * netdev )

static

Set MAC address.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 164 of file ice.c.

                                                             {
        struct intelxl_nic *intelxl = netdev->priv;
        struct ice_admin_descriptor *cmd;
        struct ice_admin_mac_write_params *write;
        int rc;
 
        /* Populate descriptor */
        cmd = ice_admin_command_descriptor ( intelxl );
        cmd->opcode = cpu_to_le16 ( INTELXL_ADMIN_MAC_WRITE );
        write = &cmd->params.mac_write;
        memcpy ( write->mac, netdev->ll_addr, ETH_ALEN );
 
        /* Issue command */
        if ( ( rc = intelxl_admin_command ( intelxl ) ) != 0 )
                return rc;
 
        return 0;
}

References cmd, cpu_to_le16, ETH_ALEN, ice_admin_command_descriptor(), intelxl_admin_command(), INTELXL_ADMIN_MAC_WRITE, memcpy(), netdev, rc, and write.

Referenced by ice_open().

ice_admin_switch()

int ice_admin_switch ( struct intelxl_nic * intelxl )

static

Get switch configuration.

Parameters

intelxl

Intel device

Return values

rc	Return status code

Definition at line 189 of file ice.c.

                                                            {
        struct ice_admin_descriptor *cmd;
        struct ice_admin_switch_params *sw;
        union ice_admin_buffer *buf;
        uint16_t next = 0;
        uint16_t seid;
        uint16_t type;
        int rc;
 
        /* Get each configuration in turn */
        do {
                /* Populate descriptor */
                cmd = ice_admin_command_descriptor ( intelxl );
                cmd->opcode = cpu_to_le16 ( INTELXL_ADMIN_SWITCH );
                cmd->flags = cpu_to_le16 ( INTELXL_ADMIN_FL_BUF );
                cmd->len = cpu_to_le16 ( sizeof ( buf->sw ) );
                sw = &cmd->params.sw;
                sw->next = next;
                buf = ice_admin_command_buffer ( intelxl );
 
                /* Issue command */
                if ( ( rc = intelxl_admin_command ( intelxl ) ) != 0 )
                        return rc;
                seid = le16_to_cpu ( buf->sw.cfg[0].seid );
 
                /* Dump raw configuration */
                DBGC2 ( intelxl, "ICE %p SEID %#04x:\n", intelxl, seid );
                DBGC2_HDA ( intelxl, 0, &buf->sw.cfg[0],
                            sizeof ( buf->sw.cfg[0] ) );
 
                /* Parse response */
                type = ( seid & ICE_ADMIN_SWITCH_TYPE_MASK );
                if ( type == ICE_ADMIN_SWITCH_TYPE_VSI ) {
                        intelxl->vsi = ( seid & ~ICE_ADMIN_SWITCH_TYPE_MASK );
                        DBGC ( intelxl, "ICE %p VSI %#04x uplink %#04x func "
                               "%#04x\n", intelxl, intelxl->vsi,
                               le16_to_cpu ( buf->sw.cfg[0].uplink ),
                               le16_to_cpu ( buf->sw.cfg[0].func ) );
                }
 
        } while ( ( next = sw->next ) );
 
        /* Check that we found a VSI */
        if ( ! intelxl->vsi ) {
                DBGC ( intelxl, "ICE %p has no VSI\n", intelxl );
                return -ENOENT;
        }
 
        return 0;
}

References ice_admin_switch_buffer::cfg, cmd, cpu_to_le16, DBGC, DBGC2, DBGC2_HDA, ENOENT, ice_admin_switch_config::func, ice_admin_command_buffer(), ice_admin_command_descriptor(), ICE_ADMIN_SWITCH_TYPE_MASK, ICE_ADMIN_SWITCH_TYPE_VSI, intelxl_admin_command(), INTELXL_ADMIN_FL_BUF, INTELXL_ADMIN_SWITCH, le16_to_cpu, next, rc, ice_admin_switch_config::seid, ice_admin_buffer::sw, type, ice_admin_switch_config::uplink, and intelxl_nic::vsi.

Referenced by ice_probe().

ice_admin_rules()

int ice_admin_rules ( struct intelxl_nic * intelxl, uint8_t * mac )

static

Add switch rules.

Parameters

intelxl	Intel device
mac	MAC address

Return values

rc	Return status code

Definition at line 247 of file ice.c.

                                                                         {
        struct ice_admin_descriptor *cmd;
        struct ice_admin_rules_params *rules;
        union ice_admin_buffer *buf;
        int rc;
 
        /* Populate descriptor */
        cmd = ice_admin_command_descriptor ( intelxl );
        cmd->opcode = cpu_to_le16 ( ICE_ADMIN_ADD_RULES );
        cmd->flags = cpu_to_le16 ( INTELXL_ADMIN_FL_BUF | INTELXL_ADMIN_FL_RD );
        cmd->len = cpu_to_le16 ( sizeof ( buf->rules ) );
        rules = &cmd->params.rules;
        rules->count = cpu_to_le16 ( 1 );
        buf = ice_admin_command_buffer ( intelxl );
        buf->rules.recipe = cpu_to_le16 ( ICE_ADMIN_RULES_RECIPE_PROMISC );
        buf->rules.port = cpu_to_le16 ( intelxl->port );
        buf->rules.action =
                cpu_to_le32 ( ICE_ADMIN_RULES_ACTION_VALID |
                              ICE_ADMIN_RULES_ACTION_VSI ( intelxl->vsi ) );
        buf->rules.len = cpu_to_le16 ( sizeof ( buf->rules.hdr ) );
        memcpy ( buf->rules.hdr.eth.h_dest, mac, ETH_ALEN );
        memcpy ( buf->rules.hdr.eth.h_source, ice_magic_mac, ETH_ALEN );
        buf->rules.hdr.eth.h_protocol = htons ( ETH_P_8021Q );
 
        /* Issue command */
        if ( ( rc = intelxl_admin_command ( intelxl ) ) != 0 )
                return rc;
 
        return 0;
}

References ice_admin_rules_buffer::action, cmd, cpu_to_le16, cpu_to_le32, ice_admin_rules_buffer::eth, ETH_ALEN, ETH_P_8021Q, ethhdr::h_dest, ethhdr::h_protocol, ethhdr::h_source, ice_admin_rules_buffer::hdr, htons, ICE_ADMIN_ADD_RULES, ice_admin_command_buffer(), ice_admin_command_descriptor(), ICE_ADMIN_RULES_ACTION_VALID, ICE_ADMIN_RULES_ACTION_VSI, ICE_ADMIN_RULES_RECIPE_PROMISC, ice_magic_mac, intelxl_admin_command(), INTELXL_ADMIN_FL_BUF, INTELXL_ADMIN_FL_RD, ice_admin_rules_buffer::len, mac, memcpy(), ice_admin_rules_buffer::port, intelxl_nic::port, rc, ice_admin_rules_buffer::recipe, ice_admin_buffer::rules, and intelxl_nic::vsi.

Referenced by ice_probe().

ice_admin_schedule_is_parent()

struct ice_admin_schedule_node * ice_admin_schedule_is_parent ( struct ice_admin_schedule_branch * branch, struct ice_admin_schedule_node * node )

static

Check if scheduler node is a parent (i.e.

non-leaf) node

Parameters

branch	Scheduler topology branch
node	Scheduler topology node

Return values

child

Any child node, or NULL if not found

Definition at line 286 of file ice.c.

                                                                      {
        unsigned int count = le16_to_cpu ( branch->count );
        struct ice_admin_schedule_node *child;
        unsigned int i;
 
        /* Find a child element, if any */
        for ( i = 0 ; i < count ; i++ ) {
                child = &branch->node[i];
                if ( child->parent == node->teid )
                        return child;
        }
 
        return NULL;
}

References count, ice_admin_schedule_branch::count, le16_to_cpu, ice_admin_schedule_branch::node, node, NULL, and ice_admin_schedule_node::parent.

Referenced by ice_admin_schedule().

ice_admin_schedule()

int ice_admin_schedule ( struct intelxl_nic * intelxl )

static

Query default scheduling tree topology.

Parameters

intelxl

Intel device

Return values

rc	Return status code

Definition at line 308 of file ice.c.

                                                              {
        struct ice_admin_descriptor *cmd;
        struct ice_admin_schedule_params *sched;
        struct ice_admin_schedule_branch *branch;
        struct ice_admin_schedule_node *node;
        union ice_admin_buffer *buf;
        int i;
        int rc;
 
        /* Populate descriptor */
        cmd = ice_admin_command_descriptor ( intelxl );
        cmd->opcode = cpu_to_le16 ( ICE_ADMIN_SCHEDULE );
        cmd->flags = cpu_to_le16 ( INTELXL_ADMIN_FL_BUF );
        cmd->len = cpu_to_le16 ( sizeof ( buf->sched ) );
        sched = &cmd->params.sched;
        buf = ice_admin_command_buffer ( intelxl );
 
        /* Issue command */
        if ( ( rc = intelxl_admin_command ( intelxl ) ) != 0 )
                return rc;
 
        /* Sanity checks */
        if ( ! sched->branches ) {
                DBGC ( intelxl, "ICE %p topology has no branches\n", intelxl );
                return -EINVAL;
        }
        branch = buf->sched.branch;
 
        /* Identify leaf node */
        for ( i = ( le16_to_cpu ( branch->count ) - 1 ) ; i >= 0 ; i-- ) {
                node = &branch->node[i];
                if ( ! ice_admin_schedule_is_parent ( branch, node ) ) {
                        intelxl->teid = le32_to_cpu ( node->teid );
                        DBGC2 ( intelxl, "ICE %p TEID %#08x type %d\n",
                                intelxl, intelxl->teid, node->config.type );
                        break;
                }
        }
        if ( ! intelxl->teid ) {
                DBGC ( intelxl, "ICE %p found no leaf TEID\n", intelxl );
                return -EINVAL;
        }
 
        return 0;
}

References ice_admin_schedule_buffer::branch, cmd, ice_admin_schedule_branch::count, cpu_to_le16, DBGC, DBGC2, EINVAL, ice_admin_command_buffer(), ice_admin_command_descriptor(), ICE_ADMIN_SCHEDULE, ice_admin_schedule_is_parent(), intelxl_admin_command(), INTELXL_ADMIN_FL_BUF, le16_to_cpu, le32_to_cpu, ice_admin_schedule_branch::node, node, rc, ice_admin_buffer::sched, and intelxl_nic::teid.

Referenced by ice_probe().

ice_admin_autoneg()

int ice_admin_autoneg ( struct intelxl_nic * intelxl )

static

Restart autonegotiation.

Parameters

intelxl

Intel device

Return values

rc	Return status code

Definition at line 360 of file ice.c.

                                                             {
        struct ice_admin_descriptor *cmd;
        struct ice_admin_autoneg_params *autoneg;
        int rc;
 
        /* Populate descriptor */
        cmd = ice_admin_command_descriptor ( intelxl );
        cmd->opcode = cpu_to_le16 ( INTELXL_ADMIN_AUTONEG );
        autoneg = &cmd->params.autoneg;
        autoneg->flags = ( INTELXL_ADMIN_AUTONEG_FL_RESTART |
                           INTELXL_ADMIN_AUTONEG_FL_ENABLE );
 
        /* Issue command */
        if ( ( rc = intelxl_admin_command ( intelxl ) ) != 0 )
                return rc;
 
        return 0;
}

References cmd, cpu_to_le16, ice_admin_autoneg_params::flags, ice_admin_command_descriptor(), INTELXL_ADMIN_AUTONEG, INTELXL_ADMIN_AUTONEG_FL_ENABLE, INTELXL_ADMIN_AUTONEG_FL_RESTART, intelxl_admin_command(), and rc.

Referenced by ice_open().

ice_admin_link()

int ice_admin_link ( struct net_device * netdev )

static

Get link status.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 385 of file ice.c.

                                                        {
        struct intelxl_nic *intelxl = netdev->priv;
        struct ice_admin_descriptor *cmd;
        struct ice_admin_link_params *link;
        union ice_admin_buffer *buf;
        int rc;
 
        /* Populate descriptor */
        cmd = ice_admin_command_descriptor ( intelxl );
        cmd->opcode = cpu_to_le16 ( INTELXL_ADMIN_LINK );
        cmd->flags = cpu_to_le16 ( INTELXL_ADMIN_FL_BUF );
        cmd->len = cpu_to_le16 ( sizeof ( buf->link ) );
        link = &cmd->params.link;
        link->notify = INTELXL_ADMIN_LINK_NOTIFY;
        buf = ice_admin_command_buffer ( intelxl );
 
        /* Issue command */
        if ( ( rc = intelxl_admin_command ( intelxl ) ) != 0 )
                return rc;
        DBGC ( intelxl, "ICE %p speed %#02x status %#02x\n",
               intelxl, le16_to_cpu ( buf->link.speed ), buf->link.status );
 
        /* Update network device */
        if ( buf->link.status & INTELXL_ADMIN_LINK_UP ) {
                netdev_link_up ( netdev );
        } else {
                netdev_link_down ( netdev );
        }
 
        return 0;
}

References cmd, cpu_to_le16, DBGC, ice_admin_command_buffer(), ice_admin_command_descriptor(), intelxl_admin_command(), INTELXL_ADMIN_FL_BUF, INTELXL_ADMIN_LINK, INTELXL_ADMIN_LINK_NOTIFY, INTELXL_ADMIN_LINK_UP, le16_to_cpu, ice_admin_buffer::link, link, netdev, netdev_link_down(), netdev_link_up(), rc, ice_admin_link_buffer::speed, and ice_admin_link_buffer::status.

Referenced by ice_admin_event(), ice_open(), and ice_probe().

ice_admin_event()

void ice_admin_event ( struct net_device * netdev, struct intelxl_admin_descriptor * xlevt, union intelxl_admin_buffer *xlbuf __unused )

static

Handle admin event.

Parameters

netdev	Network device
xlevt	Event descriptor
xlbuf	Data buffer

Definition at line 424 of file ice.c.

                                                                           {
        struct intelxl_nic *intelxl = netdev->priv;
        struct ice_admin_descriptor *evt =
                container_of ( xlevt, struct ice_admin_descriptor, xl );
 
        /* Ignore unrecognised events */
        if ( evt->opcode != cpu_to_le16 ( INTELXL_ADMIN_LINK ) ) {
                DBGC ( intelxl, "INTELXL %p unrecognised event opcode "
                       "%#04x\n", intelxl, le16_to_cpu ( evt->opcode ) );
                return;
        }
 
        /* Update link status */
        ice_admin_link ( netdev );
}

References __unused, container_of, cpu_to_le16, DBGC, ice_admin_link(), INTELXL_ADMIN_LINK, le16_to_cpu, netdev, ice_admin_descriptor::opcode, and ice_admin_descriptor::xl.

Referenced by ice_probe().

ice_admin_add_txq()

int ice_admin_add_txq ( struct intelxl_nic * intelxl, struct intelxl_ring * ring )

static

Add transmit queue.

Parameters

intelxl	Intel device
ring	Descriptor ring

Return values

rc	Return status code

Definition at line 449 of file ice.c.

                                                           {
        struct ice_admin_descriptor *cmd;
        struct ice_admin_add_txq_params *add_txq;
        union ice_admin_buffer *buf;
        struct ice_context_tx *ctx;
        struct ice_schedule_tx *sched;
        physaddr_t address;
        int rc;
 
        /* Populate descriptor */
        cmd = ice_admin_command_descriptor ( intelxl );
        cmd->opcode = cpu_to_le16 ( ICE_ADMIN_ADD_TXQ );
        cmd->flags = cpu_to_le16 ( INTELXL_ADMIN_FL_RD | INTELXL_ADMIN_FL_BUF );
        cmd->len = cpu_to_le16 ( sizeof ( buf->add_txq ) );
        add_txq = &cmd->params.add_txq;
        add_txq->count = 1;
        buf = ice_admin_command_buffer ( intelxl );
        buf->add_txq.parent = cpu_to_le32 ( intelxl->teid );
        buf->add_txq.count = 1;
        ctx = &buf->add_txq.ctx;
        address = dma ( &ring->map, ring->desc.raw );
        ctx->base_port =
                cpu_to_le64 ( ICE_TXQ_BASE_PORT ( address, intelxl->port ) );
        ctx->pf_type = cpu_to_le16 ( ICE_TXQ_PF_TYPE ( intelxl->pf ) );
        ctx->vsi = cpu_to_le16 ( intelxl->vsi );
        ctx->len = cpu_to_le16 ( ICE_TXQ_LEN ( INTELXL_TX_NUM_DESC ) );
        ctx->flags = cpu_to_le16 ( ICE_TXQ_FL_TSO | ICE_TXQ_FL_LEGACY );
        sched = &buf->add_txq.sched;
        sched->sections = ( ICE_SCHEDULE_GENERIC | ICE_SCHEDULE_COMMIT |
                            ICE_SCHEDULE_EXCESS );
        sched->commit_weight = cpu_to_le16 ( ICE_SCHEDULE_WEIGHT );
        sched->excess_weight = cpu_to_le16 ( ICE_SCHEDULE_WEIGHT );
 
        /* Issue command */
        if ( ( rc = intelxl_admin_command ( intelxl ) ) != 0 )
                return rc;
        DBGC ( intelxl, "ICE %p added TEID %#04x\n",
               intelxl, le32_to_cpu ( buf->add_txq.teid ) );
 
        return 0;
}

References ice_admin_buffer::add_txq, address, cmd, ice_schedule_tx::commit_weight, ice_admin_add_txq_buffer::count, ice_admin_add_txq_params::count, cpu_to_le16, cpu_to_le32, cpu_to_le64, ctx, ice_admin_add_txq_buffer::ctx, DBGC, intelxl_ring::desc, dma(), ice_schedule_tx::excess_weight, ICE_ADMIN_ADD_TXQ, ice_admin_command_buffer(), ice_admin_command_descriptor(), ICE_SCHEDULE_COMMIT, ICE_SCHEDULE_EXCESS, ICE_SCHEDULE_GENERIC, ICE_SCHEDULE_WEIGHT, ICE_TXQ_BASE_PORT, ICE_TXQ_FL_LEGACY, ICE_TXQ_FL_TSO, ICE_TXQ_LEN, ICE_TXQ_PF_TYPE, intelxl_admin_command(), INTELXL_ADMIN_FL_BUF, INTELXL_ADMIN_FL_RD, INTELXL_TX_NUM_DESC, le32_to_cpu, intelxl_ring::map, ice_admin_add_txq_buffer::parent, intelxl_nic::pf, intelxl_nic::port, intelxl_ring::raw, rc, ice_admin_add_txq_buffer::sched, ice_schedule_tx::sections, ice_admin_add_txq_buffer::teid, intelxl_nic::teid, and intelxl_nic::vsi.

Referenced by ice_create_tx().

ice_admin_disable_txq()

int ice_admin_disable_txq ( struct intelxl_nic * intelxl )

static

Disable transmit queue.

Parameters

intelxl	Intel device
ring	Descriptor ring

Return values

rc	Return status code

Definition at line 499 of file ice.c.

                                                                 {
        struct ice_admin_descriptor *cmd;
        struct ice_admin_disable_txq_params *disable_txq;
        union ice_admin_buffer *buf;
        int rc;
 
        /* Populate descriptor */
        cmd = ice_admin_command_descriptor ( intelxl );
        cmd->opcode = cpu_to_le16 ( ICE_ADMIN_DISABLE_TXQ );
        cmd->flags = cpu_to_le16 ( INTELXL_ADMIN_FL_RD | INTELXL_ADMIN_FL_BUF );
        cmd->len = cpu_to_le16 ( sizeof ( buf->disable_txq ) );
        disable_txq = &cmd->params.disable_txq;
        disable_txq->flags = ICE_TXQ_FL_FLUSH;
        disable_txq->count = 1;
        disable_txq->timeout = ICE_TXQ_TIMEOUT;
        buf = ice_admin_command_buffer ( intelxl );
        buf->disable_txq.parent = cpu_to_le32 ( intelxl->teid );
        buf->disable_txq.count = 1;
 
        /* Issue command */
        if ( ( rc = intelxl_admin_command ( intelxl ) ) != 0 )
                return rc;
 
        return 0;
}

References cmd, ice_admin_disable_txq_buffer::count, cpu_to_le16, cpu_to_le32, ice_admin_buffer::disable_txq, ice_admin_command_buffer(), ice_admin_command_descriptor(), ICE_ADMIN_DISABLE_TXQ, ICE_TXQ_FL_FLUSH, ICE_TXQ_TIMEOUT, intelxl_admin_command(), INTELXL_ADMIN_FL_BUF, INTELXL_ADMIN_FL_RD, ice_admin_disable_txq_buffer::parent, rc, and intelxl_nic::teid.

Referenced by ice_destroy_tx().

ice_dump_tx()

void ice_dump_tx ( struct intelxl_nic * intelxl )

static

Dump transmit queue context (for debugging)

Parameters

intelxl

Intel device

Definition at line 537 of file ice.c.

                                                        {
        uint32_t ctx[ sizeof ( struct ice_context_tx ) / sizeof ( uint32_t ) ];
        uint32_t stat;
        unsigned int i;
 
        /* Do nothing unless debug output is enabled */
        if ( ! DBG_EXTRA )
                return;
 
        /* Trigger reading of transmit context */
        writel ( ( ICE_GLCOMM_QTX_CNTX_CTL_CMD_READ |
                   ICE_GLCOMM_QTX_CNTX_CTL_EXEC ),
                 intelxl->regs + ICE_GLCOMM_QTX_CNTX_CTL );
 
        /* Wait for operation to complete */
        for ( i = 0 ; i < INTELXL_CTX_MAX_WAIT_MS ; i++ ) {
 
                /* Check if operation is complete */
                stat = readl ( intelxl->regs + ICE_GLCOMM_QTX_CNTX_STAT );
                if ( ! ( stat & ICE_GLCOMM_QTX_CNTX_BUSY ) )
                        break;
 
                /* Delay */
                mdelay ( 1 );
        }
 
        /* Read context registers */
        for ( i = 0 ; i < ( sizeof ( ctx ) / sizeof ( ctx[0] ) ) ; i++ ) {
                ctx[i] = cpu_to_le32 ( readl ( intelxl->regs +
                                               ICE_GLCOMM_QTX_CNTX_DATA ( i )));
        }
 
        /* Dump context */
        DBGC2 ( intelxl, "ICE %p TX context:\n", intelxl );
        DBGC2_HDA ( intelxl, 0, ctx, sizeof ( ctx ) );
}

References cpu_to_le32, ctx, DBG_EXTRA, DBGC2, DBGC2_HDA, ICE_GLCOMM_QTX_CNTX_BUSY, ICE_GLCOMM_QTX_CNTX_CTL, ICE_GLCOMM_QTX_CNTX_CTL_CMD_READ, ICE_GLCOMM_QTX_CNTX_CTL_EXEC, ICE_GLCOMM_QTX_CNTX_DATA, ICE_GLCOMM_QTX_CNTX_STAT, INTELXL_CTX_MAX_WAIT_MS, mdelay(), readl, intelxl_nic::regs, stat, and writel.

Referenced by ice_close().

ice_dump_rx()

void ice_dump_rx ( struct intelxl_nic * intelxl )

static

Dump receive queue context (for debugging)

Parameters

intelxl

Intel device

Definition at line 579 of file ice.c.

                                                        {
        uint32_t ctx[ sizeof ( struct intelxl_context_rx ) /
                      sizeof ( uint32_t ) ];
        unsigned int i;
 
        /* Do nothing unless debug output is enabled */
        if ( ! DBG_EXTRA )
                return;
 
        /* Read context registers */
        for ( i = 0 ; i < ( sizeof ( ctx ) / sizeof ( ctx[0] ) ) ; i++ ) {
                ctx[i] = cpu_to_le32 ( readl ( intelxl->regs +
                                               ICE_QRX_CONTEXT ( i ) ) );
        }
 
        /* Dump context */
        DBGC2 ( intelxl, "ICE %p RX context:\n", intelxl );
        DBGC2_HDA ( intelxl, 0, ctx, sizeof ( ctx ) );
}

References cpu_to_le32, ctx, DBG_EXTRA, DBGC2, DBGC2_HDA, ICE_QRX_CONTEXT, readl, and intelxl_nic::regs.

Referenced by ice_close().

ice_create_tx()

int ice_create_tx ( struct intelxl_nic * intelxl, struct intelxl_ring * ring )

static

Create transmit queue.

Parameters

intelxl	Intel device
ring	Descriptor ring

Return values

rc	Return status code

Definition at line 606 of file ice.c.

                                                       {
        int rc;
 
        /* Allocate descriptor ring */
        if ( ( rc = intelxl_alloc_ring ( intelxl, ring ) ) != 0 )
                goto err_alloc;
 
        /* Add transmit queue */
        if ( ( rc = ice_admin_add_txq ( intelxl, ring ) ) != 0 )
                goto err_add_txq;
 
        return 0;
 
 err_add_txq:
        intelxl_free_ring ( intelxl, ring );
 err_alloc:
        return rc;
}

References ice_admin_add_txq(), intelxl_alloc_ring(), intelxl_free_ring(), and rc.

Referenced by ice_open().

ice_destroy_tx()

void ice_destroy_tx ( struct intelxl_nic * intelxl, struct intelxl_ring * ring )

static

Destroy transmit queue.

Parameters

intelxl	Intel device
ring	Descriptor ring

Return values

rc	Return status code

Definition at line 633 of file ice.c.

                                                         {
        int rc;
 
        /* Disable transmit queue */
        if ( ( rc = ice_admin_disable_txq ( intelxl ) ) != 0 ) {
                /* Leak memory; there's nothing else we can do */
                return;
        }
 
        /* Free descriptor ring */
        intelxl_free_ring ( intelxl, ring );
}

References ice_admin_disable_txq(), intelxl_free_ring(), and rc.

Referenced by ice_close(), and ice_open().

ice_context_rx()

int ice_context_rx ( struct intelxl_nic * intelxl, physaddr_t address )

static

Program receive queue context.

Parameters

intelxl	Intel device
address	Descriptor ring base address

Return values

rc	Return status code

Definition at line 654 of file ice.c.

                                                 {
        union {
                struct intelxl_context_rx rx;
                uint32_t raw[ sizeof ( struct intelxl_context_rx ) /
                              sizeof ( uint32_t ) ];
        } ctx;
        uint64_t base_count;
        unsigned int i;
 
        /* Initialise context */
        memset ( &ctx, 0, sizeof ( ctx ) );
        base_count = INTELXL_CTX_RX_BASE_COUNT ( address, INTELXL_RX_NUM_DESC );
        ctx.rx.base_count = cpu_to_le64 ( base_count );
        ctx.rx.len = cpu_to_le16 ( INTELXL_CTX_RX_LEN ( intelxl->mfs ) );
        ctx.rx.flags = ( INTELXL_CTX_RX_FL_DSIZE | INTELXL_CTX_RX_FL_CRCSTRIP );
        ctx.rx.mfs = cpu_to_le16 ( INTELXL_CTX_RX_MFS ( intelxl->mfs ) );
 
        /* Write context registers */
        for ( i = 0 ; i < ( sizeof ( ctx ) / sizeof ( ctx.raw[0] ) ) ; i++ ) {
                writel ( le32_to_cpu ( ctx.raw[i] ),
                         ( intelxl->regs + ICE_QRX_CONTEXT ( i ) ) );
        }
 
        return 0;
}

References address, intelxl_context_rx::base_count, cpu_to_le16, cpu_to_le64, ctx, ICE_QRX_CONTEXT, INTELXL_CTX_RX_BASE_COUNT, INTELXL_CTX_RX_FL_CRCSTRIP, INTELXL_CTX_RX_FL_DSIZE, INTELXL_CTX_RX_LEN, INTELXL_CTX_RX_MFS, INTELXL_RX_NUM_DESC, le32_to_cpu, memset(), intelxl_nic::mfs, raw, intelxl_nic::regs, rx, and writel.

Referenced by ice_probe().

ice_open()

int ice_open ( struct net_device * netdev )

static

Open network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 687 of file ice.c.

                                                  {
        struct intelxl_nic *intelxl = netdev->priv;
        int rc;
 
        /* Calculate maximum frame size */
        intelxl->mfs = ( ( ETH_HLEN + netdev->mtu + 4 /* CRC */ +
                           INTELXL_ALIGN - 1 ) & ~( INTELXL_ALIGN - 1 ) );
 
        /* Set MAC address */
        if ( ( rc = ice_admin_mac_write ( netdev ) ) != 0 )
                goto err_mac_write;
 
        /* Set maximum frame size */
        if ( ( rc = intelxl_admin_mac_config ( intelxl ) ) != 0 )
                goto err_mac_config;
 
        /* Create receive descriptor ring */
        if ( ( rc = intelxl_create_ring ( intelxl, &intelxl->rx ) ) != 0 )
                goto err_create_rx;
 
        /* Create transmit descriptor ring */
        if ( ( rc = ice_create_tx ( intelxl, &intelxl->tx ) ) != 0 )
                goto err_create_tx;
 
        /* Restart autonegotiation */
        ice_admin_autoneg ( intelxl );
 
        /* Update link state */
        ice_admin_link ( netdev );
 
        return 0;
 
        ice_destroy_tx ( intelxl, &intelxl->tx );
 err_create_tx:
        intelxl_destroy_ring ( intelxl, &intelxl->rx );
 err_create_rx:
 err_mac_config:
 err_mac_write:
        return rc;
}

References ETH_HLEN, ice_admin_autoneg(), ice_admin_link(), ice_admin_mac_write(), ice_create_tx(), ice_destroy_tx(), intelxl_admin_mac_config(), INTELXL_ALIGN, intelxl_create_ring(), intelxl_destroy_ring(), intelxl_nic::mfs, netdev, rc, intelxl_nic::rx, and intelxl_nic::tx.

ice_close()

void ice_close ( struct net_device * netdev )

static

Close network device.

Parameters

netdev

Network device

Definition at line 733 of file ice.c.

                                                    {
        struct intelxl_nic *intelxl = netdev->priv;
 
        /* Dump contexts (for debugging) */
        ice_dump_tx ( intelxl );
        ice_dump_rx ( intelxl );
 
        /* Destroy transmit descriptor ring */
        ice_destroy_tx ( intelxl, &intelxl->tx );
 
        /* Destroy receive descriptor ring */
        intelxl_destroy_ring ( intelxl, &intelxl->rx );
 
        /* Discard any unused receive buffers */
        intelxl_empty_rx ( intelxl );
}

References ice_destroy_tx(), ice_dump_rx(), ice_dump_tx(), intelxl_destroy_ring(), intelxl_empty_rx(), netdev, intelxl_nic::rx, and intelxl_nic::tx.

ice_probe()

int ice_probe ( struct pci_device * pci )

static

Probe PCI device.

Parameters

pci	PCI device

Return values

rc	Return status code

Definition at line 771 of file ice.c.

                                                {
        struct net_device *netdev;
        struct intelxl_nic *intelxl;
        uint32_t pffunc_rid;
        uint32_t pfgen_portnum;
        int rc;
 
        /* Allocate and initialise net device */
        netdev = alloc_etherdev ( sizeof ( *intelxl ) );
        if ( ! netdev ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        netdev_init ( netdev, &ice_operations );
        netdev->max_pkt_len = INTELXL_MAX_PKT_LEN;
        intelxl = netdev->priv;
        pci_set_drvdata ( pci, netdev );
        netdev->dev = &pci->dev;
        memset ( intelxl, 0, sizeof ( *intelxl ) );
        intelxl->intr = ICE_GLINT_DYN_CTL;
        intelxl->handle = ice_admin_event;
        intelxl_init_admin ( &intelxl->command, INTELXL_ADMIN_CMD,
                             &intelxl_admin_offsets );
        intelxl_init_admin ( &intelxl->event, INTELXL_ADMIN_EVT,
                             &intelxl_admin_offsets );
        intelxl_init_ring ( &intelxl->tx, INTELXL_TX_NUM_DESC,
                            sizeof ( intelxl->tx.desc.tx[0] ), NULL );
        intelxl_init_ring ( &intelxl->rx, INTELXL_RX_NUM_DESC,
                            sizeof ( intelxl->rx.desc.rx[0] ),
                            ice_context_rx );
 
        /* Fix up PCI device */
        adjust_pci_device ( pci );
 
        /* Map registers */
        intelxl->regs = pci_ioremap ( pci, pci->membase, ICE_BAR_SIZE );
        if ( ! intelxl->regs ) {
                rc = -ENODEV;
                goto err_ioremap;
        }
 
        /* Configure DMA */
        intelxl->dma = &pci->dma;
        dma_set_mask_64bit ( intelxl->dma );
        netdev->dma = intelxl->dma;
 
        /* Locate PCI Express capability */
        intelxl->exp = pci_find_capability ( pci, PCI_CAP_ID_EXP );
        if ( ! intelxl->exp ) {
                DBGC ( intelxl, "ICE %p missing PCIe capability\n",
                       intelxl );
                rc = -ENXIO;
                goto err_exp;
        }
 
        /* Reset the function via PCIe FLR */
        pci_reset ( pci, intelxl->exp );
 
        /* Get function and port number */
        pffunc_rid = readl ( intelxl->regs + ICE_PFFUNC_RID );
        intelxl->pf = ICE_PFFUNC_RID_FUNC_NUM ( pffunc_rid );
        pfgen_portnum = readl ( intelxl->regs + ICE_PFGEN_PORTNUM );
        intelxl->port = ICE_PFGEN_PORTNUM_PORT_NUM ( pfgen_portnum );
        DBGC ( intelxl, "ICE %p PF %d using port %d\n",
               intelxl, intelxl->pf, intelxl->port );
 
        /* Enable MSI-X dummy interrupt */
        if ( ( rc = intelxl_msix_enable ( intelxl, pci,
                                          INTELXL_MSIX_VECTOR ) ) != 0 )
                goto err_msix;
 
        /* Open admin queues */
        if ( ( rc = intelxl_open_admin ( intelxl ) ) != 0 )
                goto err_open_admin;
 
        /* Get firmware version */
        if ( ( rc = ice_admin_version ( intelxl ) ) != 0 )
                goto err_admin_version;
 
        /* Clear PXE mode */
        if ( ( rc = intelxl_admin_clear_pxe ( intelxl ) ) != 0 )
                goto err_admin_clear_pxe;
 
        /* Get switch configuration */
        if ( ( rc = ice_admin_switch ( intelxl ) ) != 0 )
                goto err_admin_switch;
 
        /* Add broadcast address */
        if ( ( rc = ice_admin_rules ( intelxl, eth_broadcast ) ) != 0 )
                goto err_admin_rules_broadcast;
 
        /* Add promiscuous unicast address */
        if ( ( rc = ice_admin_rules ( intelxl, ice_magic_mac ) ) != 0 )
                goto err_admin_rules_magic;
 
        /* Query scheduler topology */
        if ( ( rc = ice_admin_schedule ( intelxl ) ) != 0 )
                goto err_admin_schedule;
 
        /* Get MAC address */
        if ( ( rc = ice_admin_mac_read ( netdev ) ) != 0 )
                goto err_admin_mac_read;
 
        /* Configure queue register addresses */
        intelxl->tx.tail = ICE_QTX_COMM_DBELL;
        intelxl->rx.reg = ICE_QRX_CTRL;
        intelxl->rx.tail = ICE_QRX_TAIL;
 
        /* Configure interrupt causes */
        writel ( ( ICE_QINT_TQCTL_ITR_INDX_NONE | ICE_QINT_TQCTL_CAUSE_ENA ),
                 intelxl->regs + ICE_QINT_TQCTL );
        writel ( ( ICE_QINT_RQCTL_ITR_INDX_NONE | ICE_QINT_RQCTL_CAUSE_ENA ),
                 intelxl->regs + ICE_QINT_RQCTL );
 
        /* Set a default value for the queue context flex extension,
         * since this register erroneously retains its value across at
         * least a PCIe FLR.
         */
        writel ( ( ICE_QRX_FLXP_CNTXT_RXDID_IDX_LEGACY_32 |
                   ICE_QRX_FLXP_CNTXT_RXDID_PRIO_MAX ),
                 intelxl->regs + ICE_QRX_FLXP_CNTXT );
 
        /* Register network device */
        if ( ( rc = register_netdev ( netdev ) ) != 0 )
                goto err_register_netdev;
 
        /* Set initial link state */
        ice_admin_link ( netdev );
 
        return 0;
 
        unregister_netdev ( netdev );
 err_register_netdev:
 err_admin_mac_read:
 err_admin_schedule:
 err_admin_rules_magic:
 err_admin_rules_broadcast:
 err_admin_switch:
 err_admin_clear_pxe:
 err_admin_version:
        intelxl_close_admin ( intelxl );
 err_open_admin:
        intelxl_msix_disable ( intelxl, pci, INTELXL_MSIX_VECTOR );
 err_msix:
        pci_reset ( pci, intelxl->exp );
 err_exp:
        iounmap ( intelxl->regs );
 err_ioremap:
        netdev_nullify ( netdev );
        netdev_put ( netdev );
 err_alloc:
        return rc;
}

References adjust_pci_device(), alloc_etherdev(), intelxl_nic::command, DBGC, intelxl_ring::desc, pci_device::dev, intelxl_nic::dma, pci_device::dma, dma_set_mask_64bit(), ENODEV, ENOMEM, ENXIO, eth_broadcast, intelxl_nic::event, intelxl_nic::exp, intelxl_nic::handle, ice_admin_event(), ice_admin_link(), ice_admin_mac_read(), ice_admin_rules(), ice_admin_schedule(), ice_admin_switch(), ICE_BAR_SIZE, ice_context_rx(), ICE_GLINT_DYN_CTL, ice_magic_mac, ice_operations, ICE_PFFUNC_RID, ICE_PFFUNC_RID_FUNC_NUM, ICE_PFGEN_PORTNUM, ICE_PFGEN_PORTNUM_PORT_NUM, ICE_QINT_RQCTL, ICE_QINT_RQCTL_CAUSE_ENA, ICE_QINT_RQCTL_ITR_INDX_NONE, ICE_QINT_TQCTL, ICE_QINT_TQCTL_CAUSE_ENA, ICE_QINT_TQCTL_ITR_INDX_NONE, ICE_QRX_CTRL, ICE_QRX_FLXP_CNTXT, ICE_QRX_FLXP_CNTXT_RXDID_IDX_LEGACY_32, ICE_QRX_FLXP_CNTXT_RXDID_PRIO_MAX, ICE_QRX_TAIL, ICE_QTX_COMM_DBELL, intelxl_admin_clear_pxe(), INTELXL_ADMIN_CMD, INTELXL_ADMIN_EVT, intelxl_close_admin(), intelxl_init_admin(), intelxl_init_ring(), INTELXL_MAX_PKT_LEN, intelxl_msix_disable(), intelxl_msix_enable(), INTELXL_MSIX_VECTOR, intelxl_open_admin(), INTELXL_RX_NUM_DESC, INTELXL_TX_NUM_DESC, intelxl_nic::intr, iounmap(), pci_device::membase, memset(), netdev, netdev_init(), netdev_nullify(), netdev_put(), NULL, PCI_CAP_ID_EXP, pci_find_capability(), pci_ioremap(), pci_reset(), pci_set_drvdata(), intelxl_nic::pf, intelxl_nic::port, rc, readl, intelxl_ring::reg, register_netdev(), intelxl_nic::regs, intelxl_nic::rx, intelxl_ring::rx, intelxl_ring::tail, intelxl_nic::tx, intelxl_ring::tx, unregister_netdev(), and writel.

ice_remove()

void ice_remove ( struct pci_device * pci )

static

Remove PCI device.

Parameters

pci	PCI device

Definition at line 930 of file ice.c.

                                                  {
        struct net_device *netdev = pci_get_drvdata ( pci );
        struct intelxl_nic *intelxl = netdev->priv;
 
        /* Unregister network device */
        unregister_netdev ( netdev );
 
        /* Close admin queues */
        intelxl_close_admin ( intelxl );
 
        /* Disable MSI-X dummy interrupt */
        intelxl_msix_disable ( intelxl, pci, INTELXL_MSIX_VECTOR );
 
        /* Reset the NIC */
        pci_reset ( pci, intelxl->exp );
 
        /* Free network device */
        iounmap ( intelxl->regs );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
}

References intelxl_nic::exp, intelxl_close_admin(), intelxl_msix_disable(), INTELXL_MSIX_VECTOR, iounmap(), netdev, netdev_nullify(), netdev_put(), pci_get_drvdata(), pci_reset(), intelxl_nic::regs, and unregister_netdev().

Variable Documentation

ice_magic_mac

uint8_t ice_magic_mac[ETH_HLEN] = { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 }

static

Magic MAC address.

Used as the source address and promiscuous unicast destination address in the "add switch rules" command.

Definition at line 51 of file ice.c.

{ 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 };

Referenced by ice_admin_rules(), and ice_probe().

ice_operations

struct net_device_operations ice_operations

static

Initial value:

= {
        .open           = ice_open,
        .close          = ice_close,
        .transmit       = intelxl_transmit,
        .poll           = intelxl_poll,
}

Network device operations.

Definition at line 751 of file ice.c.

                                                     {
        .open           = ice_open,
        .close          = ice_close,
        .transmit       = intelxl_transmit,
        .poll           = intelxl_poll,
};

Referenced by ice_probe().

ice_nics

struct pci_device_id ice_nics[]

static

Initial value:

= {
        PCI_ROM ( 0x8086, 0x124c, "e823l-bp", "E823-L backplane", 0 ),
        PCI_ROM ( 0x8086, 0x124d, "e823l-sfp", "E823-L SFP", 0 ),
        PCI_ROM ( 0x8086, 0x124e, "e823l-10gt", "E823-L 10GBASE-T", 0 ),
        PCI_ROM ( 0x8086, 0x124f, "e823l-1g", "E823-L 1GbE", 0 ),
        PCI_ROM ( 0x8086, 0x151d, "e823l-qsfp", "E823-L QSFP", 0 ),
        PCI_ROM ( 0x8086, 0x1591, "e810c-bp", "E810-C backplane", 0 ),
        PCI_ROM ( 0x8086, 0x1592, "e810c-qsfp", "E810-C QSFP", 0 ),
        PCI_ROM ( 0x8086, 0x1593, "e810c-sfp", "E810-C SFP", 0 ),
        PCI_ROM ( 0x8086, 0x1599, "e810-xxv-bp", "E810-XXV backplane", 0 ),
        PCI_ROM ( 0x8086, 0x159a, "e810-xxv-qsfp", "E810-XXV QSFP", 0 ),
        PCI_ROM ( 0x8086, 0x159b, "e810-xxv-sfp", "E810-XXV SFP", 0 ),
        PCI_ROM ( 0x8086, 0x188a, "e823c-bp", "E823-C backplane", 0 ),
        PCI_ROM ( 0x8086, 0x188b, "e823c-qsfp", "E823-C QSFP", 0 ),
        PCI_ROM ( 0x8086, 0x188c, "e823c-sfp", "E823-C SFP", 0 ),
        PCI_ROM ( 0x8086, 0x188d, "e823c-10gt", "E823-C 10GBASE-T", 0 ),
        PCI_ROM ( 0x8086, 0x188e, "e823c-1g", "E823-C 1GbE", 0 ),
        PCI_ROM ( 0x8086, 0x1890, "e822c-bp", "E822-C backplane", 0 ),
        PCI_ROM ( 0x8086, 0x1891, "e822c-qsfp", "E822-C QSFP", 0 ),
        PCI_ROM ( 0x8086, 0x1892, "e822c-sfp", "E822-C SFP", 0 ),
        PCI_ROM ( 0x8086, 0x1893, "e822c-10gt", "E822-C 10GBASE-T", 0 ),
        PCI_ROM ( 0x8086, 0x1894, "e822c-1g", "E822-C 1GbE", 0 ),
        PCI_ROM ( 0x8086, 0x1897, "e822l-bp", "E822-L backplane", 0 ),
        PCI_ROM ( 0x8086, 0x1898, "e822l-sfp", "E822-L SFP", 0 ),
        PCI_ROM ( 0x8086, 0x1899, "e822l-10gt", "E822-L 10GBASE-T", 0 ),
        PCI_ROM ( 0x8086, 0x189a, "e822l-1g", "E822-L 1GbE", 0 ),
}

PCI device IDs.

Definition at line 953 of file ice.c.

                                         {
        PCI_ROM ( 0x8086, 0x124c, "e823l-bp", "E823-L backplane", 0 ),
        PCI_ROM ( 0x8086, 0x124d, "e823l-sfp", "E823-L SFP", 0 ),
        PCI_ROM ( 0x8086, 0x124e, "e823l-10gt", "E823-L 10GBASE-T", 0 ),
        PCI_ROM ( 0x8086, 0x124f, "e823l-1g", "E823-L 1GbE", 0 ),
        PCI_ROM ( 0x8086, 0x151d, "e823l-qsfp", "E823-L QSFP", 0 ),
        PCI_ROM ( 0x8086, 0x1591, "e810c-bp", "E810-C backplane", 0 ),
        PCI_ROM ( 0x8086, 0x1592, "e810c-qsfp", "E810-C QSFP", 0 ),
        PCI_ROM ( 0x8086, 0x1593, "e810c-sfp", "E810-C SFP", 0 ),
        PCI_ROM ( 0x8086, 0x1599, "e810-xxv-bp", "E810-XXV backplane", 0 ),
        PCI_ROM ( 0x8086, 0x159a, "e810-xxv-qsfp", "E810-XXV QSFP", 0 ),
        PCI_ROM ( 0x8086, 0x159b, "e810-xxv-sfp", "E810-XXV SFP", 0 ),
        PCI_ROM ( 0x8086, 0x188a, "e823c-bp", "E823-C backplane", 0 ),
        PCI_ROM ( 0x8086, 0x188b, "e823c-qsfp", "E823-C QSFP", 0 ),
        PCI_ROM ( 0x8086, 0x188c, "e823c-sfp", "E823-C SFP", 0 ),
        PCI_ROM ( 0x8086, 0x188d, "e823c-10gt", "E823-C 10GBASE-T", 0 ),
        PCI_ROM ( 0x8086, 0x188e, "e823c-1g", "E823-C 1GbE", 0 ),
        PCI_ROM ( 0x8086, 0x1890, "e822c-bp", "E822-C backplane", 0 ),
        PCI_ROM ( 0x8086, 0x1891, "e822c-qsfp", "E822-C QSFP", 0 ),
        PCI_ROM ( 0x8086, 0x1892, "e822c-sfp", "E822-C SFP", 0 ),
        PCI_ROM ( 0x8086, 0x1893, "e822c-10gt", "E822-C 10GBASE-T", 0 ),
        PCI_ROM ( 0x8086, 0x1894, "e822c-1g", "E822-C 1GbE", 0 ),
        PCI_ROM ( 0x8086, 0x1897, "e822l-bp", "E822-L backplane", 0 ),
        PCI_ROM ( 0x8086, 0x1898, "e822l-sfp", "E822-L SFP", 0 ),
        PCI_ROM ( 0x8086, 0x1899, "e822l-10gt", "E822-L 10GBASE-T", 0 ),
        PCI_ROM ( 0x8086, 0x189a, "e822l-1g", "E822-L 1GbE", 0 ),
};

__pci_driver

struct pci_driver ice_driver __pci_driver

Initial value:

= {
        .ids = ice_nics,
        .id_count = ( sizeof ( ice_nics ) / sizeof ( ice_nics[0] ) ),
        .probe = ice_probe,
        .remove = ice_remove,
}

PCI driver.

Definition at line 982 of file ice.c.

                                            {
        .ids = ice_nics,
        .id_count = ( sizeof ( ice_nics ) / sizeof ( ice_nics[0] ) ),
        .probe = ice_probe,
        .remove = ice_remove,
};