virtio-net.c File Reference

Virtual I/O network device. 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/malloc.h>
#include <ipxe/pci.h>
#include "virtio-net.h"

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static void	virtio_net_mac (struct net_device *netdev)
	Get MAC address.
static void	virtio_net_mtu (struct net_device *netdev)
	Get MTU.
static int	virtio_net_enable (struct virtio_net *vnet, struct virtio_net_queue *queue)
	Enable queue.
static void	virtio_net_submit (struct virtio_net *vnet, struct virtio_net_queue *queue, struct io_buffer *iobuf, size_t len)
	Submit I/O buffer to queue.
static struct io_buffer *	virtio_net_complete (struct virtio_net *vnet, struct virtio_net_queue *queue, size_t *len)
	Complete I/O buffer.
static void	virtio_net_refill_rx (struct virtio_net *vnet)
	Refill receive queue.
static int	virtio_net_open (struct net_device *netdev)
	Open network device.
static void	virtio_net_close (struct net_device *netdev)
	Close network device.
static int	virtio_net_transmit (struct net_device *netdev, struct io_buffer *iobuf)
	Transmit packet.
static void	virtio_net_poll_tx (struct net_device *netdev)
	Poll for completed packets.
static void	virtio_net_poll_rx (struct net_device *netdev)
	Poll for received packets.
static void	virtio_net_poll (struct net_device *netdev)
	Poll for completed and received packets.
static int	virtio_net_probe (struct pci_device *pci)
	Probe PCI device.
static void	virtio_net_remove (struct pci_device *pci)
	Remove PCI device.

Variables
const struct virtio_features	virtio_net_features
	Supported features.
static struct net_device_operations	virtio_net_operations
	Virtio network device operations.
static struct pci_device_id	virtio_net_ids []
	Virtio network PCI device IDs.
struct pci_driver virtio_net_driver	__pci_driver
	Virtio network PCI driver.

Detailed Description

Virtual I/O network device.

Definition in file virtio-net.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

virtio_net_mac()

void virtio_net_mac ( struct net_device * netdev )

static

Get MAC address.

Parameters

netdev

Network device

Definition at line 68 of file virtio-net.c.

                                                         {
        struct virtio_net *vnet = netdev->priv;
        struct virtio_device *virtio = &vnet->virtio;
        uint32_t has_mac;
        unsigned int i;
 
        /* Read MAC address from device registers */
        for ( i = 0 ; i < ETH_ALEN ; i++ ) {
                netdev->hw_addr[i] = ioread8 ( virtio->device +
                                               VIRTIO_NET_MAC + i );
        }
 
        /* Use random MAC address if undefined or invalid */
        has_mac = ( virtio->features.word[0] & VIRTIO_FEAT0_NET_MAC );
        if ( ! ( has_mac && is_valid_ether_addr ( netdev->hw_addr ) ) ) {
                DBGC ( vnet, "VNET %s has %s MAC address\n",
                       virtio->name, ( has_mac ? "invalid" : "no" ) );
                eth_random_addr ( netdev->hw_addr );
        }
}

References DBGC, virtio_device::device, ETH_ALEN, eth_random_addr(), virtio_device::features, ioread8, is_valid_ether_addr(), virtio_device::name, netdev, virtio_net::virtio, VIRTIO_FEAT0_NET_MAC, VIRTIO_NET_MAC, and virtio_features::word.

Referenced by virtio_net_probe().

virtio_net_mtu()

void virtio_net_mtu ( struct net_device * netdev )

static

Get MTU.

Parameters

netdev

Network device

Definition at line 94 of file virtio-net.c.

                                                         {
        struct virtio_net *vnet = netdev->priv;
        struct virtio_device *virtio = &vnet->virtio;
        uint32_t has_mtu;
 
        /* Read MTU from device registers, if available */
        has_mtu = ( virtio->features.word[0] & VIRTIO_FEAT0_NET_MTU );
        if ( has_mtu ) {
                netdev->mtu = ioread16 ( virtio->device + VIRTIO_NET_MTU );
                netdev->max_pkt_len = ( netdev->mtu + ETH_HLEN );
                DBGC ( vnet, "VNET %s has MTU %zd\n",
                       virtio->name, netdev->mtu );
        }
}

References DBGC, virtio_device::device, ETH_HLEN, virtio_device::features, ioread16, virtio_device::name, netdev, virtio_net::virtio, VIRTIO_FEAT0_NET_MTU, VIRTIO_NET_MTU, and virtio_features::word.

Referenced by virtio_net_probe().

virtio_net_enable()

int virtio_net_enable ( struct virtio_net * vnet, struct virtio_net_queue * queue )

static

Enable queue.

Parameters

vnet	Virtio network device
queue	Virtio network queue

Return values

rc	Return status code

Definition at line 123 of file virtio-net.c.

                                                                {
        struct virtio_device *virtio = &vnet->virtio;
        struct virtio_desc *desc;
        unsigned int count;
        unsigned int max;
        unsigned int fill;
        unsigned int slot;
        unsigned int index;
        unsigned int write;
        int rc;
 
        /* Map packet header */
        if ( ( rc = dma_map ( virtio->dma, &queue->map, &queue->hdr,
                              sizeof ( queue->hdr ), queue->dma ) ) != 0 ) {
                DBGC ( vnet, "VNET %s Q%d could not map header: %s\n",
                       virtio->name, queue->queue.index, strerror ( rc ) );
                goto err_map;
        }
 
        /* Enable queue */
        count = ( queue->count * VIRTIO_NET_DESCS );
        if ( ( rc = virtio_enable ( virtio, &queue->queue, count ) ) != 0 ) {
                DBGC ( vnet, "VNET %s Q%d could not initialise: %s\n",
                       virtio->name, queue->queue.index, strerror ( rc ) );
                goto err_enable;
        }
 
        /* Calculate mask */
        max = ( queue->queue.count / VIRTIO_NET_DESCS );
        fill = queue->max;
        if ( fill > max )
                fill = max;
        queue->fill = fill;
        queue->mask = ( fill - 1 );
 
        /* Initialise descriptors and slot ring */
        write = queue->write;
        for ( slot = 0 ; slot < fill ; slot++ ) {
                queue->slots[slot] = slot;
                queue->iobufs[slot] = NULL;
                index = ( slot * VIRTIO_NET_DESCS );
                desc = &queue->queue.desc[index];
                desc[0].addr = cpu_to_le64 ( dma ( &queue->map, &queue->hdr ));
                desc[0].len = cpu_to_le32 ( vnet->hlen );
                desc[0].flags = cpu_to_le16 ( VIRTIO_DESC_FL_NEXT | write );
                desc[0].next = cpu_to_le16 ( index + 1 );
                desc[1].flags = cpu_to_le16 ( write );
        }
 
        DBGC ( vnet, "VNET %s Q%d using %d/%d descriptor pairs\n",
               virtio->name, queue->queue.index, queue->fill, max );
        return 0;
 
        /* There may be no way to disable individual queues: the
         * caller must reset the whole device to recover from a
         * failure.
         */
 err_enable:
        dma_unmap ( &queue->map, sizeof ( queue->hdr ) );
 err_map:
        return rc;
}

References count, cpu_to_le16, cpu_to_le32, cpu_to_le64, DBGC, desc, dma(), virtio_device::dma, dma_unmap(), fill, virtio_net::hlen, index, max, virtio_device::name, NULL, queue, rc, slot, strerror(), virtio_net::virtio, VIRTIO_DESC_FL_NEXT, virtio_enable(), VIRTIO_NET_DESCS, and write.

Referenced by virtio_net_open().

virtio_net_submit()

void virtio_net_submit ( struct virtio_net * vnet, struct virtio_net_queue * queue, struct io_buffer * iobuf, size_t len )

static

Submit I/O buffer to queue.

Parameters

vnet	Virtio network device
queue	Virtio network queue
iobuf	I/O buffer
len	Submitted length

Definition at line 195 of file virtio-net.c.

                                                                      {
        struct virtio_device *virtio = &vnet->virtio;
        struct virtio_desc *desc;
        unsigned int prod;
        unsigned int slot;
        unsigned int index;
 
        /* Get next descriptor pair and consume slot */
        prod = queue->queue.prod;
        slot = queue->slots[ prod & queue->mask ];
        index = ( slot * VIRTIO_NET_DESCS );
        desc = &queue->queue.desc[index];
 
        /* Populate descriptors */
        desc[1].addr = cpu_to_le64 ( iob_dma ( iobuf ) );
        desc[1].len = cpu_to_le32 ( len );
        DBGC2 ( vnet, "VNET %s Q%d [%02x-%02x] is [%lx,%lx)\n",
                virtio->name, queue->queue.index, index, ( index + 1 ),
                virt_to_phys ( iobuf->data ),
                ( virt_to_phys ( iobuf->data ) + len ) );
 
        /* Record I/O buffer */
        assert ( queue->iobufs[slot] == NULL );
        queue->iobufs[slot] = iobuf;
 
        /* Submit descriptors */
        virtio_submit ( &queue->queue, index );
}

References assert, cpu_to_le32, cpu_to_le64, io_buffer::data, DBGC2, desc, index, iob_dma(), len, virtio_device::name, NULL, queue, slot, virtio_net::virtio, VIRTIO_NET_DESCS, and virtio_submit().

Referenced by virtio_net_refill_rx(), and virtio_net_transmit().

virtio_net_complete()

struct io_buffer * virtio_net_complete ( struct virtio_net * vnet, struct virtio_net_queue * queue, size_t * len )

static

Complete I/O buffer.

Parameters

vnet	Virtio network device
queue	Virtio network queue
len	Length to fill in (or NULL to ignore)

Return values

iobuf

I/O buffer

Definition at line 234 of file virtio-net.c.

                                                              {
        struct virtio_device *virtio = &vnet->virtio;
        struct io_buffer *iobuf;
        unsigned int cons;
        unsigned int slot;
        unsigned int index;
 
        /* Complete descriptor pair and recycle slot */
        cons = queue->queue.cons;
        index = virtio_complete ( &queue->queue, len );
        slot = ( index / VIRTIO_NET_DESCS );
        queue->slots[ cons & queue->mask ] = slot;
 
        /* Complete I/O buffer */
        iobuf = queue->iobufs[slot];
        assert ( iobuf != NULL );
        queue->iobufs[slot] = NULL;
        DBGC2 ( vnet, "VNET %s Q%d [%02x-%02x] complete",
                virtio->name, queue->queue.index, index, ( index + 1 ) );
        if ( len )
                DBGC2 ( vnet, " len %#zx\n", *len );
        DBGC2 ( vnet, "\n" );
 
        return iobuf;
}

References assert, cons, DBGC2, index, len, virtio_device::name, NULL, queue, slot, virtio_net::virtio, virtio_complete(), and VIRTIO_NET_DESCS.

Referenced by virtio_net_poll_rx(), and virtio_net_poll_tx().

virtio_net_refill_rx()

void virtio_net_refill_rx ( struct virtio_net * vnet )

static

Refill receive queue.

Parameters

vnet	Virtio network device

Definition at line 274 of file virtio-net.c.

                                                             {
        struct virtio_device *virtio = &vnet->virtio;
        struct virtio_net_queue *queue = &vnet->rx;
        struct io_buffer *iobuf;
        size_t len = vnet->mfs;
        unsigned int refilled = 0;
 
        /* Refill queue */
        while ( ( queue->queue.prod - queue->queue.cons ) < queue->fill ) {
 
                /* Allocate I/O buffer */
                iobuf = alloc_rx_iob ( len, virtio->dma );
                if ( ! iobuf ) {
                        /* Wait for next refill */
                        break;
                }
 
                /* Submit I/O buffer */
                virtio_net_submit ( vnet, queue, iobuf, len );
                refilled++;
        }
 
        /* Notify queue, if applicable */
        if ( refilled )
                virtio_notify ( &queue->queue );
}

References alloc_rx_iob(), virtio_device::dma, len, virtio_net::mfs, queue, virtio_net::rx, virtio_net::virtio, virtio_net_submit(), and virtio_notify().

Referenced by virtio_net_open(), and virtio_net_poll().

virtio_net_open()

int virtio_net_open ( struct net_device * netdev )

static

Open network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 307 of file virtio-net.c.

                                                         {
        struct virtio_net *vnet = netdev->priv;
        struct virtio_device *virtio = &vnet->virtio;
        union virtio_net_header hdr;
        int rc;
 
        /* (Re)initialise device */
        if ( ( rc = virtio_init ( virtio, &virtio_net_features ) ) != 0 ) {
                DBGC ( vnet, "VNET %s could not initialise: %s\n",
                       virtio->name, strerror ( rc ) );
                goto err_init;
        }
 
        /* Calculate header length */
        vnet->hlen = ( virtio_is_legacy ( virtio ) ?
                       sizeof ( hdr.legacy ) : sizeof ( hdr.modern ) );
 
        /* Calculate maximum frame size */
        vnet->mfs = ( ETH_HLEN + 4 /* possible VLAN */ + netdev->mtu );
 
        /* Enable receive queue */
        if ( ( rc = virtio_net_enable ( vnet, &vnet->rx ) ) != 0 ) {
                DBGC ( vnet, "VNET %s could not enable RX: %s\n",
                       virtio->name, strerror ( rc ) );
                goto err_rx;
        }
 
        /* Enable transmit queue */
        if ( ( rc = virtio_net_enable ( vnet, &vnet->tx ) ) != 0 ) {
                DBGC ( vnet, "VNET %s could not enable TX: %s\n",
                       virtio->name, strerror ( rc ) );
                goto err_tx;
        }
 
        /* Report driver readiness */
        virtio_status ( virtio, VIRTIO_STAT_DRIVER_OK );
 
        /* Refill receive queue */
        virtio_net_refill_rx ( vnet );
 
        return 0;
 
        dma_unmap ( &vnet->tx.map, sizeof ( vnet->tx.hdr ) );
 err_tx:
        dma_unmap ( &vnet->rx.map, sizeof ( vnet->rx.hdr ) );
 err_rx:
        /* There may be no way to disable individual queues: we must
         * reset the whole device instead and then free the queues.
         */
        virtio_reset ( virtio );
        virtio_free ( virtio, &vnet->rx.queue );
        virtio_free ( virtio, &vnet->tx.queue );
 err_init:
        return rc;
}

References DBGC, dma_unmap(), ETH_HLEN, hdr, virtio_net_queue::hdr, virtio_net::hlen, virtio_net_queue::map, virtio_net::mfs, virtio_device::name, netdev, virtio_net_queue::queue, rc, virtio_net::rx, strerror(), virtio_net::tx, virtio_net::virtio, virtio_free(), virtio_init(), virtio_is_legacy(), virtio_net_enable(), virtio_net_features, virtio_net_refill_rx(), virtio_reset(), VIRTIO_STAT_DRIVER_OK, and virtio_status().

virtio_net_close()

void virtio_net_close ( struct net_device * netdev )

static

Close network device.

Parameters

netdev

Network device

Definition at line 368 of file virtio-net.c.

                                                           {
        struct virtio_net *vnet = netdev->priv;
        struct virtio_device *virtio = &vnet->virtio;
        unsigned int i;
 
        /* Reset device */
        virtio_reset ( virtio );
 
        /* Unmap headers (now that device is guaranteed idle) */
        dma_unmap ( &vnet->rx.map, sizeof ( vnet->rx.hdr ) );
        dma_unmap ( &vnet->tx.map, sizeof ( vnet->tx.hdr ) );
 
        /* Free queues */
        virtio_free ( virtio, &vnet->rx.queue );
        virtio_free ( virtio, &vnet->tx.queue );
 
        /* Discard any incomplete RX buffers */
        for ( i = 0 ; i < VIRTIO_NET_RX_MAX ; i++ )
                free_rx_iob ( vnet->rx_iobufs[i] );
}

References dma_unmap(), free_rx_iob(), virtio_net_queue::hdr, virtio_net_queue::map, netdev, virtio_net_queue::queue, virtio_net::rx, virtio_net::rx_iobufs, virtio_net::tx, virtio_net::virtio, virtio_free(), VIRTIO_NET_RX_MAX, and virtio_reset().

virtio_net_transmit()

int virtio_net_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 396 of file virtio-net.c.

                                                           {
        struct virtio_net *vnet = netdev->priv;
        struct virtio_net_queue *queue = &vnet->tx;
 
        /* Defer packet if there are no available transmit descriptors */
        if ( ( queue->queue.prod - queue->queue.cons ) >= queue->fill ) {
                netdev_tx_defer ( netdev, iobuf );
                return 0;
        }
 
        /* Submit I/O buffer */
        virtio_net_submit ( vnet, queue, iobuf, iob_len ( iobuf ) );
 
        /* Notify queue */
        virtio_notify ( &queue->queue );
 
        return 0;
}

References iob_len(), netdev, netdev_tx_defer(), queue, virtio_net::tx, virtio_net_submit(), and virtio_notify().

virtio_net_poll_tx()

void virtio_net_poll_tx ( struct net_device * netdev )

static

Poll for completed packets.

Parameters

netdev

Network device

Definition at line 421 of file virtio-net.c.

                                                             {
        struct virtio_net *vnet = netdev->priv;
        struct virtio_net_queue *queue = &vnet->tx;
        struct io_buffer *iobuf;
 
        /* Poll for completed descriptors */
        while ( virtio_completions ( &queue->queue ) ) {
 
                /* Complete I/O buffer */
                iobuf = virtio_net_complete ( vnet, queue, NULL );
                netdev_tx_complete ( netdev, iobuf );
        }
}

References netdev, netdev_tx_complete(), NULL, queue, virtio_net::tx, virtio_completions(), and virtio_net_complete().

Referenced by virtio_net_poll().

virtio_net_poll_rx()

void virtio_net_poll_rx ( struct net_device * netdev )

static

Poll for received packets.

Parameters

netdev

Network device

Definition at line 440 of file virtio-net.c.

                                                             {
        struct virtio_net *vnet = netdev->priv;
        struct virtio_net_queue *queue = &vnet->rx;
        struct io_buffer *iobuf;
        size_t len;
 
        /* Poll for completed descriptors */
        while ( virtio_completions ( &queue->queue ) > 0 ) {
 
                /* Complete I/O buffer */
                iobuf = virtio_net_complete ( vnet, queue, &len );
                iob_put ( iobuf, ( len - vnet->hlen ) );
                netdev_rx ( netdev, iobuf );
        }
}

References virtio_net::hlen, iob_put, len, netdev, netdev_rx(), queue, virtio_net::rx, virtio_completions(), and virtio_net_complete().

Referenced by virtio_net_poll().

virtio_net_poll()

void virtio_net_poll ( struct net_device * netdev )

static

Poll for completed and received packets.

Parameters

netdev

Network device

Definition at line 461 of file virtio-net.c.

                                                          {
        struct virtio_net *vnet = netdev->priv;
 
        /* Poll for completed packets */
        virtio_net_poll_tx ( netdev );
 
        /* Poll for received packets */
        virtio_net_poll_rx ( netdev );
 
        /* Refill receive queue */
        virtio_net_refill_rx ( vnet );
}

References netdev, virtio_net_poll_rx(), virtio_net_poll_tx(), and virtio_net_refill_rx().

virtio_net_probe()

int virtio_net_probe ( struct pci_device * pci )

static

Probe PCI device.

Parameters

pci	PCI device

Return values

rc	Return status code

Definition at line 495 of file virtio-net.c.

                                                       {
        struct net_device *netdev;
        struct virtio_net *vnet;
        struct virtio_device *virtio;
        int rc;
 
        /* Allocate and initialise net device */
        netdev = alloc_etherdev ( sizeof ( *vnet ) );
        if ( ! netdev ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        netdev_init ( netdev, &virtio_net_operations );
        vnet = netdev->priv;
        pci_set_drvdata ( pci, netdev );
        netdev->dev = &pci->dev;
        netdev->dma = &pci->dma;
        memset ( vnet, 0, sizeof ( *vnet ) );
        virtio = &vnet->virtio;
        virtio_net_queue_init ( &vnet->rx, vnet->rx_iobufs, vnet->rx_slots,
                                VIRTIO_NET_RX_INDEX, VIRTIO_NET_RX_COUNT,
                                VIRTIO_NET_RX_MAX, DMA_RX,
                                VIRTIO_DESC_FL_WRITE );
        virtio_net_queue_init ( &vnet->tx, vnet->tx_iobufs, vnet->tx_slots,
                                VIRTIO_NET_TX_INDEX, VIRTIO_NET_TX_COUNT,
                                VIRTIO_NET_TX_MAX, DMA_TX, 0 );
 
        /* Map PCI device */
        if ( ( rc = virtio_pci_map ( virtio, pci ) ) != 0 ) {
                DBGC ( vnet, "VNET %s could not map: %s\n",
                       virtio->name, strerror ( rc ) );
                goto err_pci_map;
        }
 
        /* Initialise device */
        if ( ( rc = virtio_init ( virtio, &virtio_net_features ) ) != 0 ) {
                DBGC ( vnet, "VNET %s could not initialise: %s\n",
                       virtio->name, strerror ( rc ) );
                goto err_init;
        }
 
        /* Get MAC address */
        virtio_net_mac ( netdev );
 
        /* Set MTU */
        virtio_net_mtu ( netdev );
 
        /* Register network device */
        if ( ( rc = register_netdev ( netdev ) ) != 0 )
                goto err_register;
 
        /* Mark as link up, since we have no way to test link state changes */
        netdev_link_up ( netdev );
 
        return 0;
 
        unregister_netdev ( netdev );
 err_register:
        virtio_reset ( virtio );
 err_init:
        virtio_unmap ( virtio );
 err_pci_map:
        netdev_nullify ( netdev );
        netdev_put ( netdev );
 err_alloc:
        return rc;
}

References alloc_etherdev(), DBGC, pci_device::dev, pci_device::dma, DMA_RX, DMA_TX, ENOMEM, memset(), virtio_device::name, netdev, netdev_init(), netdev_link_up(), netdev_nullify(), netdev_put(), pci_set_drvdata(), rc, register_netdev(), virtio_net::rx, virtio_net::rx_iobufs, virtio_net::rx_slots, strerror(), virtio_net::tx, virtio_net::tx_iobufs, virtio_net::tx_slots, unregister_netdev(), virtio_net::virtio, VIRTIO_DESC_FL_WRITE, virtio_init(), virtio_net_features, virtio_net_mac(), virtio_net_mtu(), virtio_net_operations, virtio_net_queue_init(), VIRTIO_NET_RX_COUNT, VIRTIO_NET_RX_INDEX, VIRTIO_NET_RX_MAX, VIRTIO_NET_TX_COUNT, VIRTIO_NET_TX_INDEX, VIRTIO_NET_TX_MAX, virtio_pci_map(), virtio_reset(), and virtio_unmap().

virtio_net_remove()

void virtio_net_remove ( struct pci_device * pci )

static

Remove PCI device.

Parameters

pci	PCI device

Definition at line 568 of file virtio-net.c.

                                                         {
        struct net_device *netdev = pci_get_drvdata ( pci );
        struct virtio_net *vnet = netdev->priv;
        struct virtio_device *virtio = &vnet->virtio;
 
        /* Unregister network device */
        unregister_netdev ( netdev );
 
        /* Reset device */
        virtio_reset ( virtio );
 
        /* Free network device */
        virtio_unmap ( virtio );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
}

References netdev, netdev_nullify(), netdev_put(), pci_get_drvdata(), unregister_netdev(), virtio_net::virtio, virtio_reset(), and virtio_unmap().

Variable Documentation

virtio_net_features

const struct virtio_features virtio_net_features

Initial value:

                           = {
        .word = {
                ( VIRTIO_FEAT0_ANY_LAYOUT |
                  VIRTIO_FEAT0_NET_MTU |
                  VIRTIO_FEAT0_NET_MAC ),
                ( VIRTIO_FEAT1_MODERN ),
        },
}

Supported features.

Definition at line 47 of file virtio-net.c.

                                                 {
        .word = {
                ( VIRTIO_FEAT0_ANY_LAYOUT |
                  VIRTIO_FEAT0_NET_MTU |
                  VIRTIO_FEAT0_NET_MAC ),
                ( VIRTIO_FEAT1_MODERN ),
        },
};

Referenced by virtio_net_open(), and virtio_net_probe().

virtio_net_operations

struct net_device_operations virtio_net_operations

static

Initial value:

                                  = {
        .open           = virtio_net_open,
        .close          = virtio_net_close,
        .transmit       = virtio_net_transmit,
        .poll           = virtio_net_poll,
}

Virtio network device operations.

Definition at line 475 of file virtio-net.c.

                                                          {
        .open           = virtio_net_open,
        .close          = virtio_net_close,
        .transmit       = virtio_net_transmit,
        .poll           = virtio_net_poll,
};

Referenced by virtio_net_probe().

virtio_net_ids

struct pci_device_id virtio_net_ids[]

static

Initial value:

                           = {
        PCI_ROM ( 0x1af4, 0x1000, "virtio-net", "Virtio (legacy)", 0 ),
        PCI_ROM ( 0x1af4, 0x1041, "virtio-net", "Virtio (modern)", 0 ),
}

Virtio network PCI device IDs.

Definition at line 586 of file virtio-net.c.

                                             {
        PCI_ROM ( 0x1af4, 0x1000, "virtio-net", "Virtio (legacy)", 0 ),
        PCI_ROM ( 0x1af4, 0x1041, "virtio-net", "Virtio (modern)", 0 ),
};

__pci_driver

struct pci_driver virtio_net_driver __pci_driver

Initial value:

                = {
        .ids = virtio_net_ids,
        .id_count = ( sizeof ( virtio_net_ids ) /
                      sizeof ( virtio_net_ids[0] ) ),
        .probe = virtio_net_probe,
        .remove = virtio_net_remove,
}

Virtio network PCI driver.

Definition at line 592 of file virtio-net.c.

                                                 {
        .ids = virtio_net_ids,
        .id_count = ( sizeof ( virtio_net_ids ) /
                      sizeof ( virtio_net_ids[0] ) ),
        .probe = virtio_net_probe,
        .remove = virtio_net_remove,
};