virtio.c File Reference

Virtual I/O device. More...

#include <string.h>
#include <assert.h>
#include <errno.h>
#include <unistd.h>
#include <ipxe/pci.h>
#include <ipxe/virtio.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static int	virtio_legacy_reset (struct virtio_device *virtio)
	Reset device.
static unsigned int	virtio_legacy_status (struct virtio_device *virtio)
	Report driver status.
static void	virtio_legacy_supported (struct virtio_device *virtio)
	Get supported features.
static void	virtio_legacy_negotiate (struct virtio_device *virtio)
	Negotiate device features.
static void	virtio_legacy_size (struct virtio_device *virtio, struct virtio_queue *queue, unsigned int count)
	Set queue size.
static void	virtio_legacy_enable (struct virtio_device *virtio, struct virtio_queue *queue)
	Enable queue.
static int	virtio_pci_reset (struct virtio_device *virtio)
	Reset device.
static unsigned int	virtio_pci_status (struct virtio_device *virtio)
	Report driver status.
static void	virtio_pci_supported (struct virtio_device *virtio)
	Get supported features.
static void	virtio_pci_negotiate (struct virtio_device *virtio)
	Negotiate device features.
static void	virtio_pci_size (struct virtio_device *virtio, struct virtio_queue *queue, unsigned int count)
	Set queue size.
static void	virtio_pci_address (struct virtio_device *virtio, struct virtio_queue *queue, void *addr, unsigned int offset)
	Program queue address.
static void	virtio_pci_enable (struct virtio_device *virtio, struct virtio_queue *queue)
	Enable queue.
static int	virtio_pci_cap (struct virtio_device *virtio, struct pci_device *pci, unsigned int type, struct virtio_pci_capability *cap)
	Find PCI capability.
static void *	virtio_pci_map_cap (struct virtio_device *virtio, struct pci_device *pci, struct virtio_pci_capability *cap)
	Map PCI capability.
int	virtio_pci_map (struct virtio_device *virtio, struct pci_device *pci)
	Map PCI device.
int	virtio_reset (struct virtio_device *virtio)
	Reset device.
unsigned int	virtio_status (struct virtio_device *virtio, unsigned int stat)
	Report driver status.
static void	virtio_negotiate (struct virtio_device *virtio, const struct virtio_features *driver)
	Negotiate features.
int	virtio_init (struct virtio_device *virtio, const struct virtio_features *driver)
	Initialise device.
int	virtio_enable (struct virtio_device *virtio, struct virtio_queue *queue, unsigned int count)
	Enable queue.
void	virtio_free (struct virtio_device *virtio, struct virtio_queue *queue)
	Free queue.
void	virtio_unmap (struct virtio_device *virtio)
	Unmap device.

Variables
static struct virtio_operations	virtio_legacy_operations
	Original ("legacy") device operations.
static struct virtio_operations	virtio_pci_operations
	PCI ("modern") device operations.

Detailed Description

Virtual I/O device.

Definition in file virtio.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

virtio_legacy_reset()

int virtio_legacy_reset ( struct virtio_device * virtio )

static

Reset device.

Parameters

virtio

Virtio device

Return values

rc	Return status code

Definition at line 53 of file virtio.c.

                                                                {
        uint8_t stat;
        unsigned int i;
 
        /* Reset device */
        iowrite8 ( 0, virtio->common + VIRTIO_LEG_STAT );
 
        /* Wait for reset to complete */
        for ( i = 0 ; i < VIRTIO_RESET_MAX_WAIT_MS ; i++ ) {
                stat = ioread8 ( virtio->common + VIRTIO_LEG_STAT );
                if ( ! stat )
                        return 0;
                mdelay ( 1 );
        }
 
        DBGC ( virtio, "VIRTIO %s could not reset device\n", virtio->name );
        return -ETIMEDOUT;
}

References virtio_device::common, DBGC, ETIMEDOUT, ioread8, iowrite8, mdelay(), virtio_device::name, stat, VIRTIO_LEG_STAT, and VIRTIO_RESET_MAX_WAIT_MS.

virtio_legacy_status()

unsigned int virtio_legacy_status ( struct virtio_device * virtio )

static

Report driver status.

Parameters

virtio

Virtio device

Return values

stat	Actual device status

Definition at line 78 of file virtio.c.

                                                                          {
 
        /* Report device status */
        iowrite8 ( virtio->stat, virtio->common + VIRTIO_LEG_STAT );
 
        /* Read back device status */
        return ioread8 ( virtio->common + VIRTIO_LEG_STAT );
}

References virtio_device::common, ioread8, iowrite8, virtio_device::stat, and VIRTIO_LEG_STAT.

virtio_legacy_supported()

void virtio_legacy_supported ( struct virtio_device * virtio )

static

Get supported features.

Parameters

virtio

Virtio device

Definition at line 92 of file virtio.c.

                                                                     {
        struct virtio_features *supported = &virtio->supported;
        unsigned int i;
 
        /* Get device supported features */
        supported->word[0] = ioread32 ( virtio->common + VIRTIO_LEG_FEAT );
 
        /* Legacy devices have only a single 32-bit feature register */
        for ( i = 1 ; i < VIRTIO_FEATURE_WORDS ; i++ )
                supported->word[i] = 0;
}

References virtio_device::common, ioread32, supported, virtio_device::supported, VIRTIO_FEATURE_WORDS, and VIRTIO_LEG_FEAT.

virtio_legacy_negotiate()

void virtio_legacy_negotiate ( struct virtio_device * virtio )

static

Negotiate device features.

Parameters

virtio

Virtio device

Definition at line 109 of file virtio.c.

                                                                     {
        struct virtio_features *features = &virtio->features;
        unsigned int i;
 
        /* Set in-use features */
        iowrite32 ( features->word[0], virtio->common + VIRTIO_LEG_USED );
 
        /* Legacy devices have only a single 32-bit feature register */
        for ( i = 1 ; i < VIRTIO_FEATURE_WORDS ; i++ )
                assert ( features->word[i] == 0 );
}

References assert, virtio_device::common, features, virtio_device::features, iowrite32, VIRTIO_FEATURE_WORDS, and VIRTIO_LEG_USED.

virtio_legacy_size()

void virtio_legacy_size ( struct virtio_device * virtio, struct virtio_queue * queue, unsigned int count )

static

Set queue size.

Parameters

virtio	Virtio device
queue	Virtio queue
count	Requested size

Definition at line 128 of file virtio.c.

                                                      {
        size_t len;
 
        /* Select queue */
        iowrite16 ( queue->index, virtio->common + VIRTIO_LEG_SEL );
 
        /* Get (fixed) queue size */
        count = ioread16 ( virtio->common + VIRTIO_LEG_SIZE );
 
        /* Calculate queue length */
        len = virtio_desc_size ( count );
        len = virtio_align ( len + virtio_sq_size ( count ) );
        len = virtio_align ( len + virtio_cq_size ( count ) );
 
        /* Record queue size */
        queue->count = count;
        queue->len = len;
}

References virtio_device::common, count, ioread16, iowrite16, len, queue, virtio_align(), virtio_cq_size(), virtio_desc_size(), VIRTIO_LEG_SEL, VIRTIO_LEG_SIZE, and virtio_sq_size().

virtio_legacy_enable()

void virtio_legacy_enable ( struct virtio_device * virtio, struct virtio_queue * queue )

static

Enable queue.

Parameters

virtio	Virtio device
queue	Virtio queue

Definition at line 155 of file virtio.c.

                                                                {
        unsigned int count = queue->count;
        void *base = queue->desc;
        size_t len;
 
        /* Select queue */
        iowrite16 ( queue->index, virtio->common + VIRTIO_LEG_SEL );
 
        /* Lay out queue regions */
        len = virtio_desc_size ( count );
        queue->sq = ( base + len );
        len = virtio_align ( len + virtio_sq_size ( count ) );
        queue->cq = ( base + len );
        len = virtio_align ( len + virtio_cq_size ( count ) );
        assert ( len == queue->len );
 
        /* Program queue base page address */
        iowrite32 ( ( dma ( &queue->map, queue->desc ) / VIRTIO_PAGE ),
                    virtio->common + VIRTIO_LEG_BASE );
}

References assert, base, virtio_device::common, count, dma(), iowrite16, iowrite32, len, queue, virtio_align(), virtio_cq_size(), virtio_desc_size(), VIRTIO_LEG_BASE, VIRTIO_LEG_SEL, VIRTIO_PAGE, and virtio_sq_size().

virtio_pci_reset()

int virtio_pci_reset ( struct virtio_device * virtio )

static

Reset device.

Parameters

virtio

Virtio device

Return values

rc	Return status code

Definition at line 200 of file virtio.c.

                                                             {
        uint8_t stat;
        unsigned int i;
 
        /* Reset device */
        iowrite8 ( 0, virtio->common + VIRTIO_PCI_STAT );
 
        /* Wait for reset to complete */
        for ( i = 0 ; i < VIRTIO_RESET_MAX_WAIT_MS ; i++ ) {
                stat = ioread8 ( virtio->common + VIRTIO_PCI_STAT );
                if ( ! stat )
                        return 0;
                mdelay ( 1 );
        }
 
        DBGC ( virtio, "VIRTIO %s could not reset device\n", virtio->name );
        return -ETIMEDOUT;
}

References virtio_device::common, DBGC, ETIMEDOUT, ioread8, iowrite8, mdelay(), virtio_device::name, stat, VIRTIO_PCI_STAT, and VIRTIO_RESET_MAX_WAIT_MS.

virtio_pci_status()

unsigned int virtio_pci_status ( struct virtio_device * virtio )

static

Report driver status.

Parameters

virtio

Virtio device

Return values

stat	Actual device status

Definition at line 225 of file virtio.c.

                                                                       {
 
        /* Report device status */
        iowrite8 ( virtio->stat, virtio->common + VIRTIO_PCI_STAT );
 
        /* Read back device status */
        return ioread8 ( virtio->common + VIRTIO_PCI_STAT );
}

References virtio_device::common, ioread8, iowrite8, virtio_device::stat, and VIRTIO_PCI_STAT.

virtio_pci_supported()

void virtio_pci_supported ( struct virtio_device * virtio )

static

Get supported features.

Parameters

virtio

Virtio device

Definition at line 239 of file virtio.c.

                                                                  {
        struct virtio_features *supported = &virtio->supported;
        unsigned int i;
 
        /* Get device supported features */
        for ( i = 0 ; i < VIRTIO_FEATURE_WORDS ; i++ ) {
                iowrite32 ( i, virtio->common + VIRTIO_PCI_FEAT_SEL );
                supported->word[i] =
                        ioread32 ( virtio->common + VIRTIO_PCI_FEAT );
        }
}

References virtio_device::common, ioread32, iowrite32, supported, virtio_device::supported, VIRTIO_FEATURE_WORDS, VIRTIO_PCI_FEAT, and VIRTIO_PCI_FEAT_SEL.

virtio_pci_negotiate()

void virtio_pci_negotiate ( struct virtio_device * virtio )

static

Negotiate device features.

Parameters

virtio

Virtio device

Definition at line 256 of file virtio.c.

                                                                  {
        struct virtio_features *features = &virtio->features;
        unsigned int i;
 
        /* Set in-use features */
        for ( i = 0 ; i < VIRTIO_FEATURE_WORDS ; i++ ) {
                iowrite32 ( i, virtio->common + VIRTIO_PCI_USED_SEL );
                iowrite32 ( features->word[i],
                            virtio->common + VIRTIO_PCI_USED );
        }
}

References virtio_device::common, features, virtio_device::features, iowrite32, VIRTIO_FEATURE_WORDS, VIRTIO_PCI_USED, and VIRTIO_PCI_USED_SEL.

virtio_pci_size()

void virtio_pci_size ( struct virtio_device * virtio, struct virtio_queue * queue, unsigned int count )

static

Set queue size.

Parameters

virtio	Virtio device
queue	Virtio queue
count	Requested size

Definition at line 275 of file virtio.c.

                                                   {
        unsigned int max;
        size_t len;
 
        /* Select queue */
        iowrite16 ( queue->index, virtio->common + VIRTIO_PCI_SEL );
 
        /* Set queue size */
        max = ioread16 ( virtio->common + VIRTIO_PCI_SIZE );
        if ( count > max )
                count = max;
        iowrite16 ( count, virtio->common + VIRTIO_PCI_SIZE );
 
        /* Calculate queue length */
        len = virtio_align ( virtio_desc_size ( count ) );
        len = virtio_align ( len + virtio_sq_size ( count ) );
        len = virtio_align ( len + virtio_cq_size ( count ) );
 
        /* Record queue size */
        queue->count = count;
        queue->len = len;
}

References virtio_device::common, count, ioread16, iowrite16, len, max, queue, virtio_align(), virtio_cq_size(), virtio_desc_size(), VIRTIO_PCI_SEL, VIRTIO_PCI_SIZE, and virtio_sq_size().

virtio_pci_address()

void virtio_pci_address ( struct virtio_device * virtio, struct virtio_queue * queue, void * addr, unsigned int offset )

static

Program queue address.

Parameters

virtio	Virtio device
queue	Virtio queue
addr	Address
offset	Register offset

Definition at line 308 of file virtio.c.

                                                                   {
        physaddr_t phys;
 
        /* Program address */
        phys = dma ( &queue->map, addr );
        iowrite32 ( ( phys & 0xffffffffUL ), ( virtio->common + offset + 0 ) );
        if ( sizeof ( physaddr_t ) > sizeof ( uint32_t ) ) {
                iowrite32 ( ( ( ( uint64_t ) phys ) >> 32 ),
                            ( virtio->common + offset + 4 ) );
        } else {
                iowrite32 ( 0, ( virtio->common + offset + 4 ) );
        }
}

References addr, virtio_device::common, dma(), iowrite32, offset, phys, and queue.

Referenced by virtio_pci_enable().

virtio_pci_enable()

void virtio_pci_enable ( struct virtio_device * virtio, struct virtio_queue * queue )

static

Enable queue.

Parameters

virtio	Virtio device
queue	Virtio queue

Definition at line 330 of file virtio.c.

                                                             {
        unsigned int count = queue->count;
        void *base = queue->desc;
        size_t len;
 
        /* Select queue */
        iowrite16 ( queue->index, virtio->common + VIRTIO_PCI_SEL );
 
        /* Lay out queue regions */
        len = virtio_align ( virtio_desc_size ( count ) );
        queue->sq = ( base + len );
        len = virtio_align ( len + virtio_sq_size ( count ) );
        queue->cq = ( base + len );
        len = virtio_align ( len + virtio_cq_size ( count ) );
        assert ( len == queue->len );
 
        /* Program queue addresses */
        virtio_pci_address ( virtio, queue, queue->desc, VIRTIO_PCI_DESC );
        virtio_pci_address ( virtio, queue, queue->sq, VIRTIO_PCI_SQ );
        virtio_pci_address ( virtio, queue, queue->cq, VIRTIO_PCI_CQ );
 
        /* Enable queue */
        iowrite16 ( 1, virtio->common + VIRTIO_PCI_ENABLE );
}

References assert, base, virtio_device::common, count, iowrite16, len, queue, virtio_align(), virtio_cq_size(), virtio_desc_size(), virtio_pci_address(), VIRTIO_PCI_CQ, VIRTIO_PCI_DESC, VIRTIO_PCI_ENABLE, VIRTIO_PCI_SEL, VIRTIO_PCI_SQ, and virtio_sq_size().

virtio_pci_cap()

int virtio_pci_cap ( struct virtio_device * virtio, struct pci_device * pci, unsigned int type, struct virtio_pci_capability * cap )

static

Find PCI capability.

Parameters

virtio	Virtio device
pci	PCI device
type	Capability type
cap	Virtio PCI capability to fill in

Return values

rc	Return status code

Definition at line 375 of file virtio.c.

                                                                {
        unsigned int reg;
        int pos;
 
        /* Scan through vendor capabilities */
        for ( pos = pci_find_capability ( pci, PCI_CAP_ID_VNDR ) ; pos > 0 ;
              pos = pci_find_next_capability ( pci, pos, PCI_CAP_ID_VNDR ) ) {
 
                /* Check length */
                pci_read_config_byte ( pci, ( pos + PCI_CAP_LEN ), &cap->len );
                if ( cap->len < VIRTIO_PCI_CAP_END ) {
                        DBGC ( virtio, "VIRTIO %s capability +%#02x too short "
                               "(%d bytes)\n", virtio->name, pos, cap->len );
                        continue;
                }
 
                /* Read values */
                pci_read_config_byte ( pci, ( pos + VIRTIO_PCI_CAP_TYPE ),
                                       &cap->type );
                pci_read_config_byte ( pci, ( pos + VIRTIO_PCI_CAP_BAR ),
                                       &cap->bar );
                pci_read_config_dword ( pci, ( pos + VIRTIO_PCI_CAP_OFFSET ),
                                        &cap->offset );
 
                /* Check type */
                if ( cap->type != type )
                        continue;
                DBGC2 ( virtio, "VIRTIO %s capability type %d BAR%d+%#04x\n",
                        virtio->name, type, cap->bar, cap->offset );
 
                /* Check BAR */
                reg = PCI_BASE_ADDRESS ( cap->bar );
                if ( reg > PCI_BASE_ADDRESS_5 )
                        continue;
 
                /* Check BAR accessibility */
                if ( ! pci_bar_start ( pci, reg ) ) {
                        DBGC ( virtio, "VIRTIO %s capability type %d BAR%d is "
                               "not usable\n", virtio->name, type, cap->bar );
                        continue;
                }
 
                /* Success */
                cap->pos = pos;
                return 0;
        }
 
        DBGC ( virtio, "VIRTIO %s has no usable capability type %d\n",
               virtio->name, type );
        cap->pos = 0;
        return -ENOENT;
}

References virtio_pci_capability::bar, DBGC, DBGC2, ENOENT, virtio_pci_capability::len, virtio_device::name, virtio_pci_capability::offset, pci_bar_start(), PCI_BASE_ADDRESS, PCI_BASE_ADDRESS_5, PCI_CAP_ID_VNDR, PCI_CAP_LEN, pci_find_capability(), pci_find_next_capability(), pci_read_config_byte(), pci_read_config_dword(), virtio_pci_capability::pos, reg, type, virtio_pci_capability::type, VIRTIO_PCI_CAP_BAR, VIRTIO_PCI_CAP_END, VIRTIO_PCI_CAP_OFFSET, and VIRTIO_PCI_CAP_TYPE.

Referenced by virtio_pci_map().

virtio_pci_map_cap()

void * virtio_pci_map_cap ( struct virtio_device * virtio, struct pci_device * pci, struct virtio_pci_capability * cap )

static

Map PCI capability.

Parameters

virtio	Virtio device
pci	PCI device
cap	Virtio PCI capability

Return values

io_addr

I/O address, or NULL on error

Definition at line 438 of file virtio.c.

                                                                       {
        unsigned long addr;
        unsigned int reg;
        int is_io_bar;
        void *io_addr;
 
        /* Get BAR start address and type */
        reg = PCI_BASE_ADDRESS ( cap->bar );
        addr = pci_bar_start ( pci, reg );
        if ( ! addr ) {
                DBGC ( virtio, "VIRTIO %s BAR%d is not usable\n",
                       virtio->name, cap->bar );
                return NULL;
        }
 
        /* Map memory or I/O BAR */
        addr += cap->offset;
        is_io_bar = pci_bar_is_io ( pci, reg );
        io_addr = ( is_io_bar ? ( ( void * ) addr ) :
                    pci_ioremap ( pci, addr, VIRTIO_PAGE ) );
        if ( ! io_addr ) {
                DBGC ( virtio, "VIRTIO %s could not map BAR%d+%#04x\n",
                       virtio->name, cap->bar, cap->offset );
                return NULL;
        }
 
        DBGC2 ( virtio, "VIRTIO %s mapped BAR%d+%#04x (%s %#08lx)\n",
                virtio->name, cap->bar, cap->offset,
                ( is_io_bar ? "IO" : "MEM" ), addr );
        return io_addr;
}

References addr, virtio_pci_capability::bar, DBGC, DBGC2, virtio_device::name, NULL, virtio_pci_capability::offset, pci_bar_is_io(), pci_bar_start(), PCI_BASE_ADDRESS, pci_ioremap(), reg, and VIRTIO_PAGE.

Referenced by virtio_pci_map().

virtio_pci_map()

int virtio_pci_map	(	struct virtio_device *	virtio,
		struct pci_device *	pci )

Map PCI device.

Parameters

virtio	Virtio device
pci	PCI device

Return values

rc	Return status code

Definition at line 479 of file virtio.c.

                                                                            {
        struct virtio_pci_capability common;
        struct virtio_pci_capability notify;
        struct virtio_pci_capability device;
        unsigned int msix;
        uint32_t mult;
        uint16_t ctrl;
        int rc;
 
        /* Initialise device */
        virtio->name = pci->dev.name;
        virtio->dma = &pci->dma;
 
        /* Fix up PCI device */
        adjust_pci_device ( pci );
 
        /* Check if MSI-X is enabled */
        msix = pci_find_capability ( pci, PCI_CAP_ID_MSIX );
        if ( msix ) {
                pci_read_config_word ( pci, msix, &ctrl );
                if ( ! ( ctrl & PCI_MSIX_CTRL_ENABLE ) )
                        msix = 0;
        }
 
        /* Locate virtio capabilities */
        virtio_pci_cap ( virtio, pci, VIRTIO_PCI_CAP_TYPE_COMMON, &common );
        virtio_pci_cap ( virtio, pci, VIRTIO_PCI_CAP_TYPE_NOTIFY, &notify );
        virtio_pci_cap ( virtio, pci, VIRTIO_PCI_CAP_TYPE_DEVICE, &device );
 
        /* Use modern interface if available */
        if ( common.pos && notify.pos && device.pos &&
             ( notify.len >= VIRTIO_PCI_CAP_NOTIFY_END ) ) {
 
                /* Use modern interface */
                virtio->op = &virtio_pci_operations;
                dma_set_mask_64bit ( virtio->dma );
 
                /* Read notification doorbell multiplier */
                pci_read_config_dword ( pci, ( notify.pos +
                                               VIRTIO_PCI_CAP_NOTIFY_MULT ),
                                        &mult );
                virtio->multiplier = mult;
                DBGC ( virtio, "VIRTIO %s using modern interface (mult x%d)\n",
                       virtio->name, virtio->multiplier );
 
        } else {
 
                /* Use legacy interface */
                virtio->op = &virtio_legacy_operations;
                common.bar = 0;
                common.offset = 0;
                notify.bar = 0;
                notify.offset = VIRTIO_LEG_DB;
                device.bar = 0;
                device.offset = ( msix ? VIRTIO_LEG_DEV_MSIX :
                                  VIRTIO_LEG_DEV );
                DBGC ( virtio, "VIRTIO %s using legacy interface (MSI-X "
                       "%sabled)\n", virtio->name, ( msix ? "en" : "dis" ) );
        }
 
        /* Map registers */
        virtio->common = virtio_pci_map_cap ( virtio, pci, &common );
        if ( ! virtio->common ) {
                rc = -ENODEV;
                goto err_common;
        }
        virtio->notify = virtio_pci_map_cap ( virtio, pci, &notify );
        if ( ! virtio->notify ) {
                rc = -ENODEV;
                goto err_notify;
        }
        virtio->device = virtio_pci_map_cap ( virtio, pci, &device );
        if ( ! virtio->device ) {
                rc = -ENODEV;
                goto err_device;
        }
 
        return 0;
 
        iounmap ( virtio->device );
 err_device:
        iounmap ( virtio->notify );
 err_notify:
        iounmap ( virtio->common );
 err_common:
        return rc;
}

References adjust_pci_device(), virtio_pci_capability::bar, common, virtio_device::common, ctrl, DBGC, pci_device::dev, virtio_device::device, pci_device::dma, virtio_device::dma, dma_set_mask_64bit(), ENODEV, iounmap(), virtio_pci_capability::len, virtio_device::multiplier, device::name, virtio_device::name, virtio_device::notify, virtio_pci_capability::offset, virtio_device::op, PCI_CAP_ID_MSIX, pci_find_capability(), PCI_MSIX_CTRL_ENABLE, pci_read_config_dword(), pci_read_config_word(), virtio_pci_capability::pos, rc, VIRTIO_LEG_DB, VIRTIO_LEG_DEV, VIRTIO_LEG_DEV_MSIX, virtio_legacy_operations, virtio_pci_cap(), VIRTIO_PCI_CAP_NOTIFY_END, VIRTIO_PCI_CAP_NOTIFY_MULT, VIRTIO_PCI_CAP_TYPE_COMMON, VIRTIO_PCI_CAP_TYPE_DEVICE, VIRTIO_PCI_CAP_TYPE_NOTIFY, virtio_pci_map_cap(), and virtio_pci_operations.

Referenced by virtio_net_probe().

virtio_reset()

int virtio_reset

(

struct virtio_device *

virtio

)

Reset device.

Parameters

virtio

Virtio device

Return values

rc	Return status code

Definition at line 580 of file virtio.c.

                                                  {
        int rc;
 
        /* Clear driver status */
        virtio->stat = 0;
 
        /* Reset device */
        if ( ( rc = virtio->op->reset ( virtio ) ) != 0 ) {
                DBGC ( virtio, "VIRTIO %s could not reset: %s\n",
                       virtio->name, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, virtio_device::name, virtio_device::op, rc, virtio_operations::reset, virtio_device::stat, and strerror().

Referenced by virtio_init(), virtio_net_close(), virtio_net_open(), virtio_net_probe(), and virtio_net_remove().

virtio_status()

unsigned int virtio_status	(	struct virtio_device *	virtio,
		unsigned int	stat )

Report driver status.

Parameters

virtio	Virtio device
stat	Additional driver status bits

Return values

stat	Actual device status

Definition at line 603 of file virtio.c.

                                                 {
 
        /* Set new driver status bits */
        virtio->stat |= stat;
 
        /* Report driver status */
        return virtio->op->status ( virtio );
}

References virtio_device::op, stat, virtio_device::stat, and virtio_operations::status.

Referenced by virtio_init(), and virtio_net_open().

virtio_negotiate()

void virtio_negotiate ( struct virtio_device * virtio, const struct virtio_features * driver )

static

Negotiate features.

Parameters

virtio	Virtio device
driver	Driver supported features

Definition at line 619 of file virtio.c.

                                                                      {
        struct virtio_features *device = &virtio->supported;
        struct virtio_features *features = &virtio->features;
        unsigned int i;
 
        /* Get device supported features */
        virtio->op->supported ( virtio );
 
        /* Negotiate mutually supported features */
        for ( i = 0 ; i < VIRTIO_FEATURE_WORDS ; i++ )
                features->word[i] = ( device->word[i] & driver->word[i] );
        virtio->op->negotiate ( virtio );
 
        /* Show features */
        DBGC ( virtio, "VIRTIO %s features", virtio->name );
        for ( i = 0 ; i < VIRTIO_FEATURE_WORDS ; i++ )
                DBGC ( virtio, "%s%08x", ( i ? ":" : " " ), device->word[i] );
        DBGC ( virtio, " /" );
        for ( i = 0 ; i < VIRTIO_FEATURE_WORDS ; i++ )
                DBGC ( virtio, "%s%08x", ( i ? ":" : " " ), features->word[i] );
        DBGC ( virtio, "\n" );
}

References DBGC, features, virtio_device::features, virtio_device::name, virtio_operations::negotiate, virtio_device::op, virtio_device::supported, virtio_operations::supported, VIRTIO_FEATURE_WORDS, and virtio_features::word.

Referenced by virtio_init().

virtio_init()

int virtio_init	(	struct virtio_device *	virtio,
		const struct virtio_features *	driver )

Initialise device.

Parameters

virtio	Virtio device
driver	Driver supported features

Return values

rc	Return status code

Definition at line 650 of file virtio.c.

                                                         {
        unsigned int stat;
        int rc;
 
        /* Reset device */
        if ( ( rc = virtio_reset ( virtio ) ) != 0 )
                goto err_reset;
 
        /* Acknowledge device existence */
        virtio_status ( virtio, VIRTIO_STAT_ACKNOWLEDGE );
 
        /* Report driver existence */
        virtio_status ( virtio, VIRTIO_STAT_DRIVER );
 
        /* Negotiate features */
        virtio_negotiate ( virtio, driver );
 
        /* Report feature negotiation completion, if applicable */
        if ( virtio->features.word[1] & VIRTIO_FEAT1_MODERN ) {
                stat = virtio_status ( virtio, VIRTIO_STAT_FEATURES_OK );
                if ( ! ( stat & VIRTIO_STAT_FEATURES_OK ) ) {
                        DBGC ( virtio, "VIRTIO %s did not accept features\n",
                               virtio->name );
                        rc = -ENOTSUP;
                        goto err_features;
                }
        }
 
        return 0;
 
 err_features:
        virtio_reset ( virtio );
 err_reset:
        virtio_status ( virtio, VIRTIO_STAT_FAIL );
        return rc;
}

References DBGC, ENOTSUP, virtio_device::features, virtio_device::name, rc, stat, VIRTIO_FEAT1_MODERN, virtio_negotiate(), virtio_reset(), VIRTIO_STAT_ACKNOWLEDGE, VIRTIO_STAT_DRIVER, VIRTIO_STAT_FAIL, VIRTIO_STAT_FEATURES_OK, virtio_status(), and virtio_features::word.

Referenced by virtio_net_open(), and virtio_net_probe().

virtio_enable()

int virtio_enable	(	struct virtio_device *	virtio,
		struct virtio_queue *	queue,
		unsigned int	count )

Enable queue.

Parameters

virtio	Virtio device
queue	Virtio queue
count	Requested queue size

Return values

rc	Return status code

Definition at line 696 of file virtio.c.

                                         {
        unsigned int offset;
        int rc;
 
        /* Reset counters */
        queue->prod = 0;
        queue->cons = 0;
 
        /* Determine queue size */
        virtio->op->size ( virtio, queue, count );
        if ( ( queue->count == 0 ) ||
             ( queue->count & ( queue->count - 1 ) ) ) {
                DBGC ( virtio, "VIRTIO %s Q%d invalid size %d\n",
                       virtio->name, queue->index, queue->count );
                rc = -ENODEV;
                goto err_count;
        }
        queue->mask = ( queue->count - 1 );
 
        /* Allocate and initialise queue */
        queue->desc = dma_alloc ( virtio->dma, &queue->map, queue->len,
                                  VIRTIO_PAGE );
        if ( ! queue->desc ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        memset ( queue->desc, 0, queue->len );
 
        /* Enable queue */
        virtio->op->enable ( virtio, queue );
        DBGC ( virtio, "VIRTIO %s Q%d %dx descriptors at [%#08lx,%#08lx)\n",
               virtio->name, queue->index, queue->count,
               virt_to_phys ( queue->desc ),
               ( virt_to_phys ( queue->desc ) +
                 virtio_desc_size ( queue->count ) ) );
        DBGC ( virtio, "VIRTIO %s Q%d %dx submissions at [%#08lx,%#08lx)\n",
               virtio->name, queue->index, queue->count,
               virt_to_phys ( queue->sq ),
               ( virt_to_phys ( queue->sq ) +
                 virtio_sq_size ( queue->count ) ) );
        DBGC ( virtio, "VIRTIO %s Q%d %dx completions at [%#08lx,%#08lx)\n",
               virtio->name, queue->index, queue->count,
               virt_to_phys ( queue->cq ),
               ( virt_to_phys ( queue->cq ) +
                 virtio_cq_size ( queue->count ) ) );
 
        /* Calculate doorbell register address */
        offset = ( queue->index * virtio->multiplier );
        queue->db = ( virtio->notify + offset );
        DBGC ( virtio, "VIRTIO %s Q%d doorbell at +%#04x\n",
               virtio->name, queue->index, offset );
 
        return 0;
 
        dma_free ( &queue->map, queue->desc, queue->len );
        queue->desc = NULL;
 err_alloc:
 err_count:
        return rc;
}

References count, DBGC, virtio_device::dma, dma_alloc(), dma_free(), virtio_operations::enable, ENODEV, ENOMEM, memset(), virtio_device::multiplier, virtio_device::name, virtio_device::notify, NULL, offset, virtio_device::op, queue, rc, virtio_operations::size, virtio_cq_size(), virtio_desc_size(), VIRTIO_PAGE, and virtio_sq_size().

Referenced by virtio_net_enable().

virtio_free()

void virtio_free	(	struct virtio_device *	virtio,
		struct virtio_queue *	queue )

Free queue.

Parameters

virtio	Virtio device
queue	Virtio queue

Definition at line 764 of file virtio.c.

                                                                              {
 
        /* Free queue */
        if ( queue->desc ) {
                dma_free ( &queue->map, queue->desc, queue->len );
                queue->desc = NULL;
                DBGC ( virtio, "VIRTIO %s Q%d freed\n",
                       virtio->name, queue->index );
        }
}

References DBGC, dma_free(), virtio_device::name, NULL, and queue.

Referenced by virtio_net_close(), and virtio_net_open().

virtio_unmap()

void virtio_unmap

(

struct virtio_device *

virtio

)

Unmap device.

Parameters

virtio

Virtio device

Definition at line 780 of file virtio.c.

                                                   {
 
        /* Unmap device-specific registers */
        iounmap ( virtio->device );
 
        /* Unmap notification doorbells */
        iounmap ( virtio->notify );
 
        /* Unmap common registers */
        iounmap ( virtio->common );
}

References virtio_device::common, virtio_device::device, iounmap(), and virtio_device::notify.

Referenced by virtio_net_probe(), and virtio_net_remove().

Variable Documentation

virtio_legacy_operations

struct virtio_operations virtio_legacy_operations

static

Initial value:

                              = {
        .reset = virtio_legacy_reset,
        .status = virtio_legacy_status,
        .supported = virtio_legacy_supported,
        .negotiate = virtio_legacy_negotiate,
        .size = virtio_legacy_size,
        .enable = virtio_legacy_enable,
}

Original ("legacy") device operations.

Definition at line 178 of file virtio.c.

                                                         {
        .reset = virtio_legacy_reset,
        .status = virtio_legacy_status,
        .supported = virtio_legacy_supported,
        .negotiate = virtio_legacy_negotiate,
        .size = virtio_legacy_size,
        .enable = virtio_legacy_enable,
};

Referenced by virtio_pci_map().

virtio_pci_operations

struct virtio_operations virtio_pci_operations

static

Initial value:

                              = {
        .reset = virtio_pci_reset,
        .status = virtio_pci_status,
        .supported = virtio_pci_supported,
        .negotiate = virtio_pci_negotiate,
        .size = virtio_pci_size,
        .enable = virtio_pci_enable,
}

PCI ("modern") device operations.

Definition at line 357 of file virtio.c.

                                                      {
        .reset = virtio_pci_reset,
        .status = virtio_pci_status,
        .supported = virtio_pci_supported,
        .negotiate = virtio_pci_negotiate,
        .size = virtio_pci_size,
        .enable = virtio_pci_enable,
};

Referenced by virtio_pci_map().