Virtual I/O device. More...

#include <stdint.h>
#include <byteswap.h>
#include <ipxe/dma.h>
#include <ipxe/pci.h>

Data Structures
struct	virtio_pci_capability
	A virtio PCI capability. More...
struct	virtio_desc
	A virtio buffer descriptor. More...
struct	virtio_sqe
	A virtio submission queue entry. More...
struct	virtio_sq
	A virtio submission ("available") queue. More...
struct	virtio_cqe
	A virtio completion queue entry. More...
struct	virtio_cq
	A virtio completion ("used") queue. More...
struct	virtio_queue
	A virtio queue. More...
struct	virtio_features
	A virtio feature set. More...
struct	virtio_device
	A virtio device. More...
struct	virtio_operations
	Virtio device operations. More...

Macros
#define	VIRTIO_PAGE 4096
	Virtio page alignment.
#define	VIRTIO_RESET_MAX_WAIT_MS 100
	Maximum time to wait for reset (in ms).
#define	VIRTIO_LEG_FEAT 0x00
	Legacy device supported features register.
#define	VIRTIO_LEG_USED 0x04
	Legacy negotiated in-use features register.
#define	VIRTIO_LEG_BASE 0x08
	Legacy queue base address register.
#define	VIRTIO_LEG_SIZE 0x0c
	Legacy queue size register.
#define	VIRTIO_LEG_SEL 0x0e
	Legacy queue select register.
#define	VIRTIO_LEG_DB 0x10
	Legacy queue doorbell notification register.
#define	VIRTIO_LEG_STAT 0x12
	Legacy driver status register.
#define	VIRTIO_STAT_ACKNOWLEDGE 0x0001
	Guest has found device.
#define	VIRTIO_STAT_DRIVER 0x0002
	Guest driver exists.
#define	VIRTIO_STAT_DRIVER_OK 0x0004
	Guest driver is ready.
#define	VIRTIO_STAT_FEATURES_OK 0x0008
	Guest driver has set features.
#define	VIRTIO_STAT_FAIL 0x0080
	Guest driver has failed.
#define	VIRTIO_LEG_DEV 0x14
	Legacy device-specific registers.
#define	VIRTIO_LEG_DEV_MSIX 0x18
	Legacy device-specific register (if MSI-X is enabled).
#define	VIRTIO_PCI_CAP_TYPE 0x03
	Capability type.
#define	VIRTIO_PCI_CAP_TYPE_COMMON 0x01
	Common registers.
#define	VIRTIO_PCI_CAP_TYPE_NOTIFY 0x02
	Notification doorbells.
#define	VIRTIO_PCI_CAP_TYPE_DEVICE 0x04
	Device-specific registers.
#define	VIRTIO_PCI_CAP_BAR 0x04
	Capability BAR index.
#define	VIRTIO_PCI_CAP_OFFSET 0x08
	Capability BAR offset.
#define	VIRTIO_PCI_CAP_END 0x10
	Capability minimum length.
#define	VIRTIO_PCI_CAP_NOTIFY_MULT 0x10
	Notification doorbell capability multiplier offset.
#define	VIRTIO_PCI_CAP_NOTIFY_END 0x14
	Notification doorbell capability minimum length.
#define	VIRTIO_PCI_FEAT_SEL 0x00
	PCI device supported features select register.
#define	VIRTIO_PCI_FEAT 0x04
	PCI device supported features register.
#define	VIRTIO_PCI_USED_SEL 0x08
	PCI negotiated in-use features select register.
#define	VIRTIO_PCI_USED 0x0c
	PCI negotiated in-use features register.
#define	VIRTIO_PCI_STAT 0x14
	PCI device status register.
#define	VIRTIO_PCI_GEN 0x15
	PCI configuration generation register.
#define	VIRTIO_PCI_SEL 0x16
	PCI queue select register.
#define	VIRTIO_PCI_SIZE 0x18
	PCI queue size register.
#define	VIRTIO_PCI_ENABLE 0x1c
	PCI queue enable register.
#define	VIRTIO_PCI_DBOFF 0x1e
	PCI queue doorbell notification offset register.
#define	VIRTIO_PCI_DESC 0x20
	PCI queue descriptor array base address register.
#define	VIRTIO_PCI_SQ 0x28
	PCI queue submission queue base address register.
#define	VIRTIO_PCI_CQ 0x30
	PCI queue completion queue base address register.
#define	VIRTIO_DESC_FL_NEXT 0x0001
	Next descriptor index is valid.
#define	VIRTIO_DESC_FL_WRITE 0x0002
	Buffer is write-only.
#define	VIRTIO_SQ_FL_NO_INTERRUPT 0x0001
	Do not generate interrupt.
#define	VIRTIO_FEATURE_WORDS 2
	Number of 32-bit feature words.
#define	VIRTIO_FEAT0_ANY_LAYOUT 0x08000000
	Arbitrary descriptor layouts may be used.
#define	VIRTIO_FEAT1_MODERN 0x00000001
	Virtio version 1.0 or above.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static void	virtio_queue_init (struct virtio_queue *queue, unsigned int index)
	Initialise virtio queue.
static size_t	virtio_align (size_t size)
	Calculate aligned size.
static size_t	virtio_desc_size (unsigned int count)
	Calculate (unaligned) descriptor array size.
static size_t	virtio_sq_size (unsigned int count)
	Calculate (unaligned) submission queue size.
static size_t	virtio_cq_size (unsigned int count)
	Calculate (unaligned) completion queue size.
static void	virtio_submit (struct virtio_queue *queue, unsigned int index)
	Submit descriptor(s) to queue.
static void	virtio_notify (struct virtio_queue *queue)
	Notify queue.
static unsigned int	virtio_completions (struct virtio_queue *queue)
	Check for completed descriptors.
static unsigned int	virtio_complete (struct virtio_queue queue, size_t len)
	Complete descriptor(s).
static int	virtio_is_legacy (struct virtio_device *virtio)
	Check if device is using the legacy interface.
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.
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.

Detailed Description

Virtual I/O device.

Definition in file virtio.h.

Macro Definition Documentation

◆ VIRTIO_PAGE

#define VIRTIO_PAGE 4096

Virtio page alignment.

Definition at line 19 of file virtio.h.

Referenced by virtio_align(), virtio_enable(), virtio_legacy_enable(), and virtio_pci_map_cap().

◆ VIRTIO_RESET_MAX_WAIT_MS

#define VIRTIO_RESET_MAX_WAIT_MS 100

Maximum time to wait for reset (in ms).

Definition at line 22 of file virtio.h.

Referenced by virtio_legacy_reset(), and virtio_pci_reset().

◆ VIRTIO_DESC_FL_NEXT

#define VIRTIO_DESC_FL_NEXT 0x0001

Next descriptor index is valid.

Definition at line 164 of file virtio.h.

Referenced by virtio_net_enable().

◆ VIRTIO_DESC_FL_WRITE

#define VIRTIO_DESC_FL_WRITE 0x0002

Buffer is write-only.

Definition at line 167 of file virtio.h.

Referenced by virtio_net_probe().

◆ VIRTIO_SQ_FL_NO_INTERRUPT

#define VIRTIO_SQ_FL_NO_INTERRUPT 0x0001

Do not generate interrupt.

Definition at line 186 of file virtio.h.

◆ VIRTIO_FEATURE_WORDS

#define VIRTIO_FEATURE_WORDS 2

Number of 32-bit feature words.

Definition at line 296 of file virtio.h.

Referenced by virtio_legacy_negotiate(), virtio_legacy_supported(), virtio_negotiate(), virtio_pci_negotiate(), and virtio_pci_supported().

◆ VIRTIO_FEAT0_ANY_LAYOUT

#define VIRTIO_FEAT0_ANY_LAYOUT 0x08000000

Arbitrary descriptor layouts may be used.

Definition at line 305 of file virtio.h.

◆ VIRTIO_FEAT1_MODERN

#define VIRTIO_FEAT1_MODERN 0x00000001

Virtio version 1.0 or above.

Definition at line 308 of file virtio.h.

Referenced by virtio_init(), and virtio_is_legacy().

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ FILE_SECBOOT()

FILE_SECBOOT ( PERMITTED )

◆ virtio_queue_init()

void virtio_queue_init	(	struct virtio_queue *	queue,
		unsigned int	index )

inlinestatic

Initialise virtio queue.

Parameters

queue	Virtio queue
index	Queue index

Definition at line 239 of file virtio.h.

                                                                     {
 
        queue->index = index;
}

References index, and queue.

◆ virtio_align()

size_t virtio_align ( size_t size )

inlinestatic

Calculate aligned size.

Parameters

size	Unaligned size

Return values

size	Aligned size

Definition at line 251 of file virtio.h.

                             {
 
        return ( ( size + VIRTIO_PAGE - 1 ) & ~( VIRTIO_PAGE - 1 ) );
}

References size, and VIRTIO_PAGE.

Referenced by virtio_legacy_enable(), virtio_legacy_size(), virtio_pci_enable(), and virtio_pci_size().

◆ virtio_desc_size()

size_t virtio_desc_size ( unsigned int count )

inlinestatic

Calculate (unaligned) descriptor array size.

Parameters

queue	Virtio queue
count	Queue size

Definition at line 263 of file virtio.h.

                                        {
        struct virtio_desc *desc;
 
        return ( count * sizeof ( desc[0] ) );
}

References count, and desc.

Referenced by virtio_enable(), virtio_legacy_enable(), virtio_legacy_size(), virtio_pci_enable(), and virtio_pci_size().

◆ virtio_sq_size()

size_t virtio_sq_size ( unsigned int count )

inlinestatic

Calculate (unaligned) submission queue size.

Parameters

queue	Virtio queue
count	Queue size

Definition at line 276 of file virtio.h.

                                      {
        struct virtio_sq *sq;
 
        return ( sizeof ( *sq ) + ( count * sizeof ( sq->sqe[0] ) ) );
}

References count, and virtio_sq::sqe.

Referenced by virtio_enable(), virtio_legacy_enable(), virtio_legacy_size(), virtio_pci_enable(), and virtio_pci_size().

◆ virtio_cq_size()

size_t virtio_cq_size ( unsigned int count )

inlinestatic

Calculate (unaligned) completion queue size.

Parameters

queue	Virtio queue
count	Queue size

Definition at line 289 of file virtio.h.

                                      {
        struct virtio_cq *cq;
 
        return ( sizeof ( *cq ) + ( count * sizeof ( cq->cqe[0] ) ) );
}

References count, and virtio_cq::cqe.

Referenced by virtio_enable(), virtio_legacy_enable(), virtio_legacy_size(), virtio_pci_enable(), and virtio_pci_size().

◆ virtio_submit()

void virtio_submit	(	struct virtio_queue *	queue,
		unsigned int	index )

inlinestatic

Submit descriptor(s) to queue.

Parameters

queue	Virtio queue
index	Starting descriptor index

Definition at line 388 of file virtio.h.

                                                                 {
        struct virtio_sqe *sqe;
 
        /* Get next submission queue entry */
        sqe = &queue->sq->sqe[ queue->prod++ & queue->mask ];
 
        /* Populate submission queue entry */
        sqe->index = cpu_to_le16 ( index );
}

References cpu_to_le16, index, queue, and sqe.

Referenced by virtio_net_submit().

◆ virtio_notify()

void virtio_notify ( struct virtio_queue * queue )

inlinestatic

Notify queue.

Parameters

queue Virtio queue

Definition at line 404 of file virtio.h.

                                             {
 
        /* Write producer index */
        wmb();
        queue->sq->prod = cpu_to_le16 ( queue->prod );
        wmb();
 
        /* Ring doorbell */
        iowrite16 ( queue->index, queue->db );
}

References cpu_to_le16, iowrite16, queue, and wmb.

Referenced by virtio_net_refill_rx(), and virtio_net_transmit().

◆ virtio_completions()

unsigned int virtio_completions ( struct virtio_queue * queue )

inlinestatic

Check for completed descriptors.

Parameters

queue	Virtio queue
completions	Number of pending completions

Definition at line 422 of file virtio.h.

                                                  {
        uint16_t completions;
 
        /* Get completion count */
        completions = ( le16_to_cpu ( queue->cq->prod ) - queue->cons );
        return completions;
}

References le16_to_cpu, and queue.

Referenced by virtio_net_poll_rx(), and virtio_net_poll_tx().

◆ virtio_complete()

unsigned int virtio_complete	(	struct virtio_queue *	queue,
		size_t *	len )

inlinestatic

Complete descriptor(s).

Parameters

queue	Virtio queue
len	Length to fill in, or NULL

Return values

index Starting descriptor index

Definition at line 438 of file virtio.h.

                                                            {
        struct virtio_cqe *cqe;
 
        /* Get next completion queue entry */
        cqe = &queue->cq->cqe[ queue->cons++ & queue->mask ];
 
        /* Parse completion queue entry */
        if ( len )
                *len = le32_to_cpu ( cqe->len );
        return le32_to_cpu ( cqe->index );
}

References virtio_cqe::index, le32_to_cpu, len, virtio_cqe::len, and queue.

Referenced by virtio_net_complete().

◆ virtio_is_legacy()

int virtio_is_legacy ( struct virtio_device * virtio )

inlinestatic

Check if device is using the legacy interface.

Parameters

virtio Virtio device

Return values

is_legacy Device is using the legacy interface

Definition at line 457 of file virtio.h.

                                                  {
 
        /* Check negotiation of version 1.0 or above */
        return ( ! ( virtio->features.word[1] & VIRTIO_FEAT1_MODERN ) );
}

References virtio_device::features, VIRTIO_FEAT1_MODERN, and virtio_features::word.

Referenced by virtio_net_open().

◆ virtio_pci_map()

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

extern

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 )

extern

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 )

extern

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_init()

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

extern

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 )

extern

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 )

extern

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 )

extern

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().

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ VIRTIO_PAGE

◆ VIRTIO_RESET_MAX_WAIT_MS

◆ VIRTIO_DESC_FL_NEXT

◆ VIRTIO_DESC_FL_WRITE

◆ VIRTIO_SQ_FL_NO_INTERRUPT

◆ VIRTIO_FEATURE_WORDS

◆ VIRTIO_FEAT0_ANY_LAYOUT

◆ VIRTIO_FEAT1_MODERN

Function Documentation

◆ FILE_LICENCE()

◆ FILE_SECBOOT()

◆ virtio_queue_init()

◆ virtio_align()

◆ virtio_desc_size()

◆ virtio_sq_size()

◆ virtio_cq_size()

◆ virtio_submit()

◆ virtio_notify()

◆ virtio_completions()

◆ virtio_complete()

◆ virtio_is_legacy()

◆ virtio_pci_map()

◆ virtio_reset()

◆ virtio_status()

◆ virtio_init()

◆ virtio_enable()

◆ virtio_free()

◆ virtio_unmap()