mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-24 09:50:04 +00:00
Merge git://github.com/rustyrussell/linux
* git://github.com/rustyrussell/linux: virtio-blk: use ida to allocate disk index virtio: Add platform bus driver for memory mapped virtio device virtio: Dont add "config" to list for !per_vq_vector virtio: console: wait for first console port for early console output virtio: console: add port stats for bytes received, sent and discarded virtio: console: make discard_port_data() use get_inbuf() virtio: console: rename variable virtio: console: make get_inbuf() return port->inbuf if present virtio: console: Fix return type for get_inbuf() virtio: console: Use wait_event_freezable instead of _interruptible virtio: console: Ignore port name update request if name already set virtio: console: Fix indentation virtio: modify vring_init and vring_size to take account of the layout containing *_event_idx virtio.h: correct comment for struct virtio_driver virtio-net: Use virtio_config_val() for retrieving config virtio_config: Add virtio_config_val_len() virtio-console: Use virtio_config_val() for retrieving config
This commit is contained in:
Linus Torvalds
commit
80c2861672
12 changed files with 744 additions and 66 deletions
17
Documentation/devicetree/bindings/virtio/mmio.txt
Normal file
17
Documentation/devicetree/bindings/virtio/mmio.txt
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
* virtio memory mapped device
|
||||
|
||||
See http://ozlabs.org/~rusty/virtio-spec/ for more details.
|
||||
|
||||
Required properties:
|
||||
|
||||
- compatible: "virtio,mmio" compatibility string
|
||||
- reg: control registers base address and size including configuration space
|
||||
- interrupts: interrupt generated by the device
|
||||
|
||||
Example:
|
||||
|
||||
virtio_block@3000 {
|
||||
compatible = "virtio,mmio";
|
||||
reg = <0x3000 0x100>;
|
||||
interrupts = <41>;
|
||||
}
|
||||
|
|
@ -8,10 +8,13 @@
|
|||
#include <linux/scatterlist.h>
|
||||
#include <linux/string_helpers.h>
|
||||
#include <scsi/scsi_cmnd.h>
|
||||
#include <linux/idr.h>
|
||||
|
||||
#define PART_BITS 4
|
||||
|
||||
static int major, index;
|
||||
static int major;
|
||||
static DEFINE_IDA(vd_index_ida);
|
||||
|
||||
struct workqueue_struct *virtblk_wq;
|
||||
|
||||
struct virtio_blk
|
||||
|
|
@ -35,6 +38,9 @@ struct virtio_blk
|
|||
/* What host tells us, plus 2 for header & tailer. */
|
||||
unsigned int sg_elems;
|
||||
|
||||
/* Ida index - used to track minor number allocations. */
|
||||
int index;
|
||||
|
||||
/* Scatterlist: can be too big for stack. */
|
||||
struct scatterlist sg[/*sg_elems*/];
|
||||
};
|
||||
|
|
@ -276,6 +282,11 @@ static int index_to_minor(int index)
|
|||
return index << PART_BITS;
|
||||
}
|
||||
|
||||
static int minor_to_index(int minor)
|
||||
{
|
||||
return minor >> PART_BITS;
|
||||
}
|
||||
|
||||
static ssize_t virtblk_serial_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
|
|
@ -341,14 +352,17 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
|
|||
{
|
||||
struct virtio_blk *vblk;
|
||||
struct request_queue *q;
|
||||
int err;
|
||||
int err, index;
|
||||
u64 cap;
|
||||
u32 v, blk_size, sg_elems, opt_io_size;
|
||||
u16 min_io_size;
|
||||
u8 physical_block_exp, alignment_offset;
|
||||
|
||||
if (index_to_minor(index) >= 1 << MINORBITS)
|
||||
return -ENOSPC;
|
||||
err = ida_simple_get(&vd_index_ida, 0, minor_to_index(1 << MINORBITS),
|
||||
GFP_KERNEL);
|
||||
if (err < 0)
|
||||
goto out;
|
||||
index = err;
|
||||
|
||||
/* We need to know how many segments before we allocate. */
|
||||
err = virtio_config_val(vdev, VIRTIO_BLK_F_SEG_MAX,
|
||||
|
|
@ -365,7 +379,7 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
|
|||
sizeof(vblk->sg[0]) * sg_elems, GFP_KERNEL);
|
||||
if (!vblk) {
|
||||
err = -ENOMEM;
|
||||
goto out;
|
||||
goto out_free_index;
|
||||
}
|
||||
|
||||
INIT_LIST_HEAD(&vblk->reqs);
|
||||
|
|
@ -421,7 +435,7 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
|
|||
vblk->disk->private_data = vblk;
|
||||
vblk->disk->fops = &virtblk_fops;
|
||||
vblk->disk->driverfs_dev = &vdev->dev;
|
||||
index++;
|
||||
vblk->index = index;
|
||||
|
||||
/* configure queue flush support */
|
||||
if (virtio_has_feature(vdev, VIRTIO_BLK_F_FLUSH))
|
||||
|
|
@ -516,6 +530,8 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
|
|||
vdev->config->del_vqs(vdev);
|
||||
out_free_vblk:
|
||||
kfree(vblk);
|
||||
out_free_index:
|
||||
ida_simple_remove(&vd_index_ida, index);
|
||||
out:
|
||||
return err;
|
||||
}
|
||||
|
|
@ -523,6 +539,7 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
|
|||
static void __devexit virtblk_remove(struct virtio_device *vdev)
|
||||
{
|
||||
struct virtio_blk *vblk = vdev->priv;
|
||||
int index = vblk->index;
|
||||
|
||||
flush_work(&vblk->config_work);
|
||||
|
||||
|
|
@ -538,6 +555,7 @@ static void __devexit virtblk_remove(struct virtio_device *vdev)
|
|||
mempool_destroy(vblk->pool);
|
||||
vdev->config->del_vqs(vdev);
|
||||
kfree(vblk);
|
||||
ida_simple_remove(&vd_index_ida, index);
|
||||
}
|
||||
|
||||
static const struct virtio_device_id id_table[] = {
|
||||
|
|
|
|||
|
|
@ -19,8 +19,10 @@
|
|||
*/
|
||||
#include <linux/cdev.h>
|
||||
#include <linux/debugfs.h>
|
||||
#include <linux/completion.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/freezer.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/list.h>
|
||||
|
|
@ -73,6 +75,7 @@ struct ports_driver_data {
|
|||
static struct ports_driver_data pdrvdata;
|
||||
|
||||
DEFINE_SPINLOCK(pdrvdata_lock);
|
||||
DECLARE_COMPLETION(early_console_added);
|
||||
|
||||
/* This struct holds information that's relevant only for console ports */
|
||||
struct console {
|
||||
|
|
@ -151,6 +154,10 @@ struct ports_device {
|
|||
int chr_major;
|
||||
};
|
||||
|
||||
struct port_stats {
|
||||
unsigned long bytes_sent, bytes_received, bytes_discarded;
|
||||
};
|
||||
|
||||
/* This struct holds the per-port data */
|
||||
struct port {
|
||||
/* Next port in the list, head is in the ports_device */
|
||||
|
|
@ -178,6 +185,13 @@ struct port {
|
|||
/* File in the debugfs directory that exposes this port's information */
|
||||
struct dentry *debugfs_file;
|
||||
|
||||
/*
|
||||
* Keep count of the bytes sent, received and discarded for
|
||||
* this port for accounting and debugging purposes. These
|
||||
* counts are not reset across port open / close events.
|
||||
*/
|
||||
struct port_stats stats;
|
||||
|
||||
/*
|
||||
* The entries in this struct will be valid if this port is
|
||||
* hooked up to an hvc console
|
||||
|
|
@ -347,17 +361,19 @@ static struct port_buffer *alloc_buf(size_t buf_size)
|
|||
}
|
||||
|
||||
/* Callers should take appropriate locks */
|
||||
static void *get_inbuf(struct port *port)
|
||||
static struct port_buffer *get_inbuf(struct port *port)
|
||||
{
|
||||
struct port_buffer *buf;
|
||||
struct virtqueue *vq;
|
||||
unsigned int len;
|
||||
|
||||
vq = port->in_vq;
|
||||
buf = virtqueue_get_buf(vq, &len);
|
||||
if (port->inbuf)
|
||||
return port->inbuf;
|
||||
|
||||
buf = virtqueue_get_buf(port->in_vq, &len);
|
||||
if (buf) {
|
||||
buf->len = len;
|
||||
buf->offset = 0;
|
||||
port->stats.bytes_received += len;
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
|
@ -384,32 +400,27 @@ static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
|
|||
static void discard_port_data(struct port *port)
|
||||
{
|
||||
struct port_buffer *buf;
|
||||
struct virtqueue *vq;
|
||||
unsigned int len;
|
||||
int ret;
|
||||
unsigned int err;
|
||||
|
||||
if (!port->portdev) {
|
||||
/* Device has been unplugged. vqs are already gone. */
|
||||
return;
|
||||
}
|
||||
vq = port->in_vq;
|
||||
if (port->inbuf)
|
||||
buf = port->inbuf;
|
||||
else
|
||||
buf = virtqueue_get_buf(vq, &len);
|
||||
buf = get_inbuf(port);
|
||||
|
||||
ret = 0;
|
||||
err = 0;
|
||||
while (buf) {
|
||||
if (add_inbuf(vq, buf) < 0) {
|
||||
ret++;
|
||||
port->stats.bytes_discarded += buf->len - buf->offset;
|
||||
if (add_inbuf(port->in_vq, buf) < 0) {
|
||||
err++;
|
||||
free_buf(buf);
|
||||
}
|
||||
buf = virtqueue_get_buf(vq, &len);
|
||||
port->inbuf = NULL;
|
||||
buf = get_inbuf(port);
|
||||
}
|
||||
port->inbuf = NULL;
|
||||
if (ret)
|
||||
if (err)
|
||||
dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
|
||||
ret);
|
||||
err);
|
||||
}
|
||||
|
||||
static bool port_has_data(struct port *port)
|
||||
|
|
@ -417,18 +428,12 @@ static bool port_has_data(struct port *port)
|
|||
unsigned long flags;
|
||||
bool ret;
|
||||
|
||||
spin_lock_irqsave(&port->inbuf_lock, flags);
|
||||
if (port->inbuf) {
|
||||
ret = true;
|
||||
goto out;
|
||||
}
|
||||
port->inbuf = get_inbuf(port);
|
||||
if (port->inbuf) {
|
||||
ret = true;
|
||||
goto out;
|
||||
}
|
||||
ret = false;
|
||||
out:
|
||||
spin_lock_irqsave(&port->inbuf_lock, flags);
|
||||
port->inbuf = get_inbuf(port);
|
||||
if (port->inbuf)
|
||||
ret = true;
|
||||
|
||||
spin_unlock_irqrestore(&port->inbuf_lock, flags);
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -529,6 +534,8 @@ static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count,
|
|||
cpu_relax();
|
||||
done:
|
||||
spin_unlock_irqrestore(&port->outvq_lock, flags);
|
||||
|
||||
port->stats.bytes_sent += in_count;
|
||||
/*
|
||||
* We're expected to return the amount of data we wrote -- all
|
||||
* of it
|
||||
|
|
@ -633,8 +640,8 @@ static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
|
|||
if (filp->f_flags & O_NONBLOCK)
|
||||
return -EAGAIN;
|
||||
|
||||
ret = wait_event_interruptible(port->waitqueue,
|
||||
!will_read_block(port));
|
||||
ret = wait_event_freezable(port->waitqueue,
|
||||
!will_read_block(port));
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -677,8 +684,8 @@ static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
|
|||
if (nonblock)
|
||||
return -EAGAIN;
|
||||
|
||||
ret = wait_event_interruptible(port->waitqueue,
|
||||
!will_write_block(port));
|
||||
ret = wait_event_freezable(port->waitqueue,
|
||||
!will_write_block(port));
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -1058,6 +1065,14 @@ static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
|
|||
"host_connected: %d\n", port->host_connected);
|
||||
out_offset += snprintf(buf + out_offset, out_count - out_offset,
|
||||
"outvq_full: %d\n", port->outvq_full);
|
||||
out_offset += snprintf(buf + out_offset, out_count - out_offset,
|
||||
"bytes_sent: %lu\n", port->stats.bytes_sent);
|
||||
out_offset += snprintf(buf + out_offset, out_count - out_offset,
|
||||
"bytes_received: %lu\n",
|
||||
port->stats.bytes_received);
|
||||
out_offset += snprintf(buf + out_offset, out_count - out_offset,
|
||||
"bytes_discarded: %lu\n",
|
||||
port->stats.bytes_discarded);
|
||||
out_offset += snprintf(buf + out_offset, out_count - out_offset,
|
||||
"is_console: %s\n",
|
||||
is_console_port(port) ? "yes" : "no");
|
||||
|
|
@ -1143,6 +1158,7 @@ static int add_port(struct ports_device *portdev, u32 id)
|
|||
port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
|
||||
|
||||
port->host_connected = port->guest_connected = false;
|
||||
port->stats = (struct port_stats) { 0 };
|
||||
|
||||
port->outvq_full = false;
|
||||
|
||||
|
|
@ -1352,6 +1368,7 @@ static void handle_control_message(struct ports_device *portdev,
|
|||
break;
|
||||
|
||||
init_port_console(port);
|
||||
complete(&early_console_added);
|
||||
/*
|
||||
* Could remove the port here in case init fails - but
|
||||
* have to notify the host first.
|
||||
|
|
@ -1393,6 +1410,13 @@ static void handle_control_message(struct ports_device *portdev,
|
|||
send_sigio_to_port(port);
|
||||
break;
|
||||
case VIRTIO_CONSOLE_PORT_NAME:
|
||||
/*
|
||||
* If we woke up after hibernation, we can get this
|
||||
* again. Skip it in that case.
|
||||
*/
|
||||
if (port->name)
|
||||
break;
|
||||
|
||||
/*
|
||||
* Skip the size of the header and the cpkt to get the size
|
||||
* of the name that was sent
|
||||
|
|
@ -1481,8 +1505,7 @@ static void in_intr(struct virtqueue *vq)
|
|||
return;
|
||||
|
||||
spin_lock_irqsave(&port->inbuf_lock, flags);
|
||||
if (!port->inbuf)
|
||||
port->inbuf = get_inbuf(port);
|
||||
port->inbuf = get_inbuf(port);
|
||||
|
||||
/*
|
||||
* Don't queue up data when port is closed. This condition
|
||||
|
|
@ -1563,7 +1586,7 @@ static int init_vqs(struct ports_device *portdev)
|
|||
portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
|
||||
GFP_KERNEL);
|
||||
if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
|
||||
!portdev->out_vqs) {
|
||||
!portdev->out_vqs) {
|
||||
err = -ENOMEM;
|
||||
goto free;
|
||||
}
|
||||
|
|
@ -1648,6 +1671,10 @@ static int __devinit virtcons_probe(struct virtio_device *vdev)
|
|||
struct ports_device *portdev;
|
||||
int err;
|
||||
bool multiport;
|
||||
bool early = early_put_chars != NULL;
|
||||
|
||||
/* Ensure to read early_put_chars now */
|
||||
barrier();
|
||||
|
||||
portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
|
||||
if (!portdev) {
|
||||
|
|
@ -1675,13 +1702,11 @@ static int __devinit virtcons_probe(struct virtio_device *vdev)
|
|||
|
||||
multiport = false;
|
||||
portdev->config.max_nr_ports = 1;
|
||||
if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT)) {
|
||||
if (virtio_config_val(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
|
||||
offsetof(struct virtio_console_config,
|
||||
max_nr_ports),
|
||||
&portdev->config.max_nr_ports) == 0)
|
||||
multiport = true;
|
||||
vdev->config->get(vdev, offsetof(struct virtio_console_config,
|
||||
max_nr_ports),
|
||||
&portdev->config.max_nr_ports,
|
||||
sizeof(portdev->config.max_nr_ports));
|
||||
}
|
||||
|
||||
err = init_vqs(portdev);
|
||||
if (err < 0) {
|
||||
|
|
@ -1719,6 +1744,19 @@ static int __devinit virtcons_probe(struct virtio_device *vdev)
|
|||
|
||||
__send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
|
||||
VIRTIO_CONSOLE_DEVICE_READY, 1);
|
||||
|
||||
/*
|
||||
* If there was an early virtio console, assume that there are no
|
||||
* other consoles. We need to wait until the hvc_alloc matches the
|
||||
* hvc_instantiate, otherwise tty_open will complain, resulting in
|
||||
* a "Warning: unable to open an initial console" boot failure.
|
||||
* Without multiport this is done in add_port above. With multiport
|
||||
* this might take some host<->guest communication - thus we have to
|
||||
* wait.
|
||||
*/
|
||||
if (multiport && early)
|
||||
wait_for_completion(&early_console_added);
|
||||
|
||||
return 0;
|
||||
|
||||
free_vqs:
|
||||
|
|
|
|||
|
|
@ -925,12 +925,10 @@ static void virtnet_update_status(struct virtnet_info *vi)
|
|||
{
|
||||
u16 v;
|
||||
|
||||
if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_STATUS))
|
||||
return;
|
||||
|
||||
vi->vdev->config->get(vi->vdev,
|
||||
if (virtio_config_val(vi->vdev, VIRTIO_NET_F_STATUS,
|
||||
offsetof(struct virtio_net_config, status),
|
||||
&v, sizeof(v));
|
||||
&v) < 0)
|
||||
return;
|
||||
|
||||
/* Ignore unknown (future) status bits */
|
||||
v &= VIRTIO_NET_S_LINK_UP;
|
||||
|
|
@ -1006,11 +1004,9 @@ static int virtnet_probe(struct virtio_device *vdev)
|
|||
}
|
||||
|
||||
/* Configuration may specify what MAC to use. Otherwise random. */
|
||||
if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC)) {
|
||||
vdev->config->get(vdev,
|
||||
if (virtio_config_val_len(vdev, VIRTIO_NET_F_MAC,
|
||||
offsetof(struct virtio_net_config, mac),
|
||||
dev->dev_addr, dev->addr_len);
|
||||
} else
|
||||
dev->dev_addr, dev->addr_len) < 0)
|
||||
random_ether_addr(dev->dev_addr);
|
||||
|
||||
/* Set up our device-specific information */
|
||||
|
|
|
|||
|
|
@ -35,4 +35,15 @@ config VIRTIO_BALLOON
|
|||
|
||||
If unsure, say M.
|
||||
|
||||
config VIRTIO_MMIO
|
||||
tristate "Platform bus driver for memory mapped virtio devices (EXPERIMENTAL)"
|
||||
depends on EXPERIMENTAL
|
||||
select VIRTIO
|
||||
select VIRTIO_RING
|
||||
---help---
|
||||
This drivers provides support for memory mapped virtio
|
||||
platform device driver.
|
||||
|
||||
If unsure, say N.
|
||||
|
||||
endmenu
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
obj-$(CONFIG_VIRTIO) += virtio.o
|
||||
obj-$(CONFIG_VIRTIO_RING) += virtio_ring.o
|
||||
obj-$(CONFIG_VIRTIO_MMIO) += virtio_mmio.o
|
||||
obj-$(CONFIG_VIRTIO_PCI) += virtio_pci.o
|
||||
obj-$(CONFIG_VIRTIO_BALLOON) += virtio_balloon.o
|
||||
|
|
|
|||
479
drivers/virtio/virtio_mmio.c
Normal file
479
drivers/virtio/virtio_mmio.c
Normal file
|
|
@ -0,0 +1,479 @@
|
|||
/*
|
||||
* Virtio memory mapped device driver
|
||||
*
|
||||
* Copyright 2011, ARM Ltd.
|
||||
*
|
||||
* This module allows virtio devices to be used over a virtual, memory mapped
|
||||
* platform device.
|
||||
*
|
||||
* Registers layout (all 32-bit wide):
|
||||
*
|
||||
* offset d. name description
|
||||
* ------ -- ---------------- -----------------
|
||||
*
|
||||
* 0x000 R MagicValue Magic value "virt"
|
||||
* 0x004 R Version Device version (current max. 1)
|
||||
* 0x008 R DeviceID Virtio device ID
|
||||
* 0x00c R VendorID Virtio vendor ID
|
||||
*
|
||||
* 0x010 R HostFeatures Features supported by the host
|
||||
* 0x014 W HostFeaturesSel Set of host features to access via HostFeatures
|
||||
*
|
||||
* 0x020 W GuestFeatures Features activated by the guest
|
||||
* 0x024 W GuestFeaturesSel Set of activated features to set via GuestFeatures
|
||||
* 0x028 W GuestPageSize Size of guest's memory page in bytes
|
||||
*
|
||||
* 0x030 W QueueSel Queue selector
|
||||
* 0x034 R QueueNumMax Maximum size of the currently selected queue
|
||||
* 0x038 W QueueNum Queue size for the currently selected queue
|
||||
* 0x03c W QueueAlign Used Ring alignment for the current queue
|
||||
* 0x040 RW QueuePFN PFN for the currently selected queue
|
||||
*
|
||||
* 0x050 W QueueNotify Queue notifier
|
||||
* 0x060 R InterruptStatus Interrupt status register
|
||||
* 0x060 W InterruptACK Interrupt acknowledge register
|
||||
* 0x070 RW Status Device status register
|
||||
*
|
||||
* 0x100+ RW Device-specific configuration space
|
||||
*
|
||||
* Based on Virtio PCI driver by Anthony Liguori, copyright IBM Corp. 2007
|
||||
*
|
||||
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
||||
* See the COPYING file in the top-level directory.
|
||||
*/
|
||||
|
||||
#include <linux/highmem.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/virtio.h>
|
||||
#include <linux/virtio_config.h>
|
||||
#include <linux/virtio_mmio.h>
|
||||
#include <linux/virtio_ring.h>
|
||||
|
||||
|
||||
|
||||
/* The alignment to use between consumer and producer parts of vring.
|
||||
* Currently hardcoded to the page size. */
|
||||
#define VIRTIO_MMIO_VRING_ALIGN PAGE_SIZE
|
||||
|
||||
|
||||
|
||||
#define to_virtio_mmio_device(_plat_dev) \
|
||||
container_of(_plat_dev, struct virtio_mmio_device, vdev)
|
||||
|
||||
struct virtio_mmio_device {
|
||||
struct virtio_device vdev;
|
||||
struct platform_device *pdev;
|
||||
|
||||
void __iomem *base;
|
||||
unsigned long version;
|
||||
|
||||
/* a list of queues so we can dispatch IRQs */
|
||||
spinlock_t lock;
|
||||
struct list_head virtqueues;
|
||||
};
|
||||
|
||||
struct virtio_mmio_vq_info {
|
||||
/* the actual virtqueue */
|
||||
struct virtqueue *vq;
|
||||
|
||||
/* the number of entries in the queue */
|
||||
unsigned int num;
|
||||
|
||||
/* the index of the queue */
|
||||
int queue_index;
|
||||
|
||||
/* the virtual address of the ring queue */
|
||||
void *queue;
|
||||
|
||||
/* the list node for the virtqueues list */
|
||||
struct list_head node;
|
||||
};
|
||||
|
||||
|
||||
|
||||
/* Configuration interface */
|
||||
|
||||
static u32 vm_get_features(struct virtio_device *vdev)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
|
||||
|
||||
/* TODO: Features > 32 bits */
|
||||
writel(0, vm_dev->base + VIRTIO_MMIO_HOST_FEATURES_SEL);
|
||||
|
||||
return readl(vm_dev->base + VIRTIO_MMIO_HOST_FEATURES);
|
||||
}
|
||||
|
||||
static void vm_finalize_features(struct virtio_device *vdev)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
|
||||
int i;
|
||||
|
||||
/* Give virtio_ring a chance to accept features. */
|
||||
vring_transport_features(vdev);
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(vdev->features); i++) {
|
||||
writel(i, vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES_SET);
|
||||
writel(vdev->features[i],
|
||||
vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES);
|
||||
}
|
||||
}
|
||||
|
||||
static void vm_get(struct virtio_device *vdev, unsigned offset,
|
||||
void *buf, unsigned len)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
|
||||
u8 *ptr = buf;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < len; i++)
|
||||
ptr[i] = readb(vm_dev->base + VIRTIO_MMIO_CONFIG + offset + i);
|
||||
}
|
||||
|
||||
static void vm_set(struct virtio_device *vdev, unsigned offset,
|
||||
const void *buf, unsigned len)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
|
||||
const u8 *ptr = buf;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < len; i++)
|
||||
writeb(ptr[i], vm_dev->base + VIRTIO_MMIO_CONFIG + offset + i);
|
||||
}
|
||||
|
||||
static u8 vm_get_status(struct virtio_device *vdev)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
|
||||
|
||||
return readl(vm_dev->base + VIRTIO_MMIO_STATUS) & 0xff;
|
||||
}
|
||||
|
||||
static void vm_set_status(struct virtio_device *vdev, u8 status)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
|
||||
|
||||
/* We should never be setting status to 0. */
|
||||
BUG_ON(status == 0);
|
||||
|
||||
writel(status, vm_dev->base + VIRTIO_MMIO_STATUS);
|
||||
}
|
||||
|
||||
static void vm_reset(struct virtio_device *vdev)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
|
||||
|
||||
/* 0 status means a reset. */
|
||||
writel(0, vm_dev->base + VIRTIO_MMIO_STATUS);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Transport interface */
|
||||
|
||||
/* the notify function used when creating a virt queue */
|
||||
static void vm_notify(struct virtqueue *vq)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vq->vdev);
|
||||
struct virtio_mmio_vq_info *info = vq->priv;
|
||||
|
||||
/* We write the queue's selector into the notification register to
|
||||
* signal the other end */
|
||||
writel(info->queue_index, vm_dev->base + VIRTIO_MMIO_QUEUE_NOTIFY);
|
||||
}
|
||||
|
||||
/* Notify all virtqueues on an interrupt. */
|
||||
static irqreturn_t vm_interrupt(int irq, void *opaque)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = opaque;
|
||||
struct virtio_mmio_vq_info *info;
|
||||
struct virtio_driver *vdrv = container_of(vm_dev->vdev.dev.driver,
|
||||
struct virtio_driver, driver);
|
||||
unsigned long status;
|
||||
unsigned long flags;
|
||||
irqreturn_t ret = IRQ_NONE;
|
||||
|
||||
/* Read and acknowledge interrupts */
|
||||
status = readl(vm_dev->base + VIRTIO_MMIO_INTERRUPT_STATUS);
|
||||
writel(status, vm_dev->base + VIRTIO_MMIO_INTERRUPT_ACK);
|
||||
|
||||
if (unlikely(status & VIRTIO_MMIO_INT_CONFIG)
|
||||
&& vdrv && vdrv->config_changed) {
|
||||
vdrv->config_changed(&vm_dev->vdev);
|
||||
ret = IRQ_HANDLED;
|
||||
}
|
||||
|
||||
if (likely(status & VIRTIO_MMIO_INT_VRING)) {
|
||||
spin_lock_irqsave(&vm_dev->lock, flags);
|
||||
list_for_each_entry(info, &vm_dev->virtqueues, node)
|
||||
ret |= vring_interrupt(irq, info->vq);
|
||||
spin_unlock_irqrestore(&vm_dev->lock, flags);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void vm_del_vq(struct virtqueue *vq)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vq->vdev);
|
||||
struct virtio_mmio_vq_info *info = vq->priv;
|
||||
unsigned long flags, size;
|
||||
|
||||
spin_lock_irqsave(&vm_dev->lock, flags);
|
||||
list_del(&info->node);
|
||||
spin_unlock_irqrestore(&vm_dev->lock, flags);
|
||||
|
||||
vring_del_virtqueue(vq);
|
||||
|
||||
/* Select and deactivate the queue */
|
||||
writel(info->queue_index, vm_dev->base + VIRTIO_MMIO_QUEUE_SEL);
|
||||
writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
|
||||
|
||||
size = PAGE_ALIGN(vring_size(info->num, VIRTIO_MMIO_VRING_ALIGN));
|
||||
free_pages_exact(info->queue, size);
|
||||
kfree(info);
|
||||
}
|
||||
|
||||
static void vm_del_vqs(struct virtio_device *vdev)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
|
||||
struct virtqueue *vq, *n;
|
||||
|
||||
list_for_each_entry_safe(vq, n, &vdev->vqs, list)
|
||||
vm_del_vq(vq);
|
||||
|
||||
free_irq(platform_get_irq(vm_dev->pdev, 0), vm_dev);
|
||||
}
|
||||
|
||||
|
||||
|
||||
static struct virtqueue *vm_setup_vq(struct virtio_device *vdev, unsigned index,
|
||||
void (*callback)(struct virtqueue *vq),
|
||||
const char *name)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
|
||||
struct virtio_mmio_vq_info *info;
|
||||
struct virtqueue *vq;
|
||||
unsigned long flags, size;
|
||||
int err;
|
||||
|
||||
/* Select the queue we're interested in */
|
||||
writel(index, vm_dev->base + VIRTIO_MMIO_QUEUE_SEL);
|
||||
|
||||
/* Queue shouldn't already be set up. */
|
||||
if (readl(vm_dev->base + VIRTIO_MMIO_QUEUE_PFN)) {
|
||||
err = -ENOENT;
|
||||
goto error_available;
|
||||
}
|
||||
|
||||
/* Allocate and fill out our active queue description */
|
||||
info = kmalloc(sizeof(*info), GFP_KERNEL);
|
||||
if (!info) {
|
||||
err = -ENOMEM;
|
||||
goto error_kmalloc;
|
||||
}
|
||||
info->queue_index = index;
|
||||
|
||||
/* Allocate pages for the queue - start with a queue as big as
|
||||
* possible (limited by maximum size allowed by device), drop down
|
||||
* to a minimal size, just big enough to fit descriptor table
|
||||
* and two rings (which makes it "alignment_size * 2")
|
||||
*/
|
||||
info->num = readl(vm_dev->base + VIRTIO_MMIO_QUEUE_NUM_MAX);
|
||||
while (1) {
|
||||
size = PAGE_ALIGN(vring_size(info->num,
|
||||
VIRTIO_MMIO_VRING_ALIGN));
|
||||
/* Already smallest possible allocation? */
|
||||
if (size <= VIRTIO_MMIO_VRING_ALIGN * 2) {
|
||||
err = -ENOMEM;
|
||||
goto error_alloc_pages;
|
||||
}
|
||||
|
||||
info->queue = alloc_pages_exact(size, GFP_KERNEL | __GFP_ZERO);
|
||||
if (info->queue)
|
||||
break;
|
||||
|
||||
info->num /= 2;
|
||||
}
|
||||
|
||||
/* Activate the queue */
|
||||
writel(info->num, vm_dev->base + VIRTIO_MMIO_QUEUE_NUM);
|
||||
writel(VIRTIO_MMIO_VRING_ALIGN,
|
||||
vm_dev->base + VIRTIO_MMIO_QUEUE_ALIGN);
|
||||
writel(virt_to_phys(info->queue) >> PAGE_SHIFT,
|
||||
vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
|
||||
|
||||
/* Create the vring */
|
||||
vq = vring_new_virtqueue(info->num, VIRTIO_MMIO_VRING_ALIGN,
|
||||
vdev, info->queue, vm_notify, callback, name);
|
||||
if (!vq) {
|
||||
err = -ENOMEM;
|
||||
goto error_new_virtqueue;
|
||||
}
|
||||
|
||||
vq->priv = info;
|
||||
info->vq = vq;
|
||||
|
||||
spin_lock_irqsave(&vm_dev->lock, flags);
|
||||
list_add(&info->node, &vm_dev->virtqueues);
|
||||
spin_unlock_irqrestore(&vm_dev->lock, flags);
|
||||
|
||||
return vq;
|
||||
|
||||
error_new_virtqueue:
|
||||
writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
|
||||
free_pages_exact(info->queue, size);
|
||||
error_alloc_pages:
|
||||
kfree(info);
|
||||
error_kmalloc:
|
||||
error_available:
|
||||
return ERR_PTR(err);
|
||||
}
|
||||
|
||||
static int vm_find_vqs(struct virtio_device *vdev, unsigned nvqs,
|
||||
struct virtqueue *vqs[],
|
||||
vq_callback_t *callbacks[],
|
||||
const char *names[])
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
|
||||
unsigned int irq = platform_get_irq(vm_dev->pdev, 0);
|
||||
int i, err;
|
||||
|
||||
err = request_irq(irq, vm_interrupt, IRQF_SHARED,
|
||||
dev_name(&vdev->dev), vm_dev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
for (i = 0; i < nvqs; ++i) {
|
||||
vqs[i] = vm_setup_vq(vdev, i, callbacks[i], names[i]);
|
||||
if (IS_ERR(vqs[i])) {
|
||||
vm_del_vqs(vdev);
|
||||
return PTR_ERR(vqs[i]);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static struct virtio_config_ops virtio_mmio_config_ops = {
|
||||
.get = vm_get,
|
||||
.set = vm_set,
|
||||
.get_status = vm_get_status,
|
||||
.set_status = vm_set_status,
|
||||
.reset = vm_reset,
|
||||
.find_vqs = vm_find_vqs,
|
||||
.del_vqs = vm_del_vqs,
|
||||
.get_features = vm_get_features,
|
||||
.finalize_features = vm_finalize_features,
|
||||
};
|
||||
|
||||
|
||||
|
||||
/* Platform device */
|
||||
|
||||
static int __devinit virtio_mmio_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev;
|
||||
struct resource *mem;
|
||||
unsigned long magic;
|
||||
|
||||
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
if (!mem)
|
||||
return -EINVAL;
|
||||
|
||||
if (!devm_request_mem_region(&pdev->dev, mem->start,
|
||||
resource_size(mem), pdev->name))
|
||||
return -EBUSY;
|
||||
|
||||
vm_dev = devm_kzalloc(&pdev->dev, sizeof(*vm_dev), GFP_KERNEL);
|
||||
if (!vm_dev)
|
||||
return -ENOMEM;
|
||||
|
||||
vm_dev->vdev.dev.parent = &pdev->dev;
|
||||
vm_dev->vdev.config = &virtio_mmio_config_ops;
|
||||
vm_dev->pdev = pdev;
|
||||
INIT_LIST_HEAD(&vm_dev->virtqueues);
|
||||
spin_lock_init(&vm_dev->lock);
|
||||
|
||||
vm_dev->base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
|
||||
if (vm_dev->base == NULL)
|
||||
return -EFAULT;
|
||||
|
||||
/* Check magic value */
|
||||
magic = readl(vm_dev->base + VIRTIO_MMIO_MAGIC_VALUE);
|
||||
if (memcmp(&magic, "virt", 4) != 0) {
|
||||
dev_warn(&pdev->dev, "Wrong magic value 0x%08lx!\n", magic);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
/* Check device version */
|
||||
vm_dev->version = readl(vm_dev->base + VIRTIO_MMIO_VERSION);
|
||||
if (vm_dev->version != 1) {
|
||||
dev_err(&pdev->dev, "Version %ld not supported!\n",
|
||||
vm_dev->version);
|
||||
return -ENXIO;
|
||||
}
|
||||
|
||||
vm_dev->vdev.id.device = readl(vm_dev->base + VIRTIO_MMIO_DEVICE_ID);
|
||||
vm_dev->vdev.id.vendor = readl(vm_dev->base + VIRTIO_MMIO_VENDOR_ID);
|
||||
|
||||
writel(PAGE_SIZE, vm_dev->base + VIRTIO_MMIO_GUEST_PAGE_SIZE);
|
||||
|
||||
platform_set_drvdata(pdev, vm_dev);
|
||||
|
||||
return register_virtio_device(&vm_dev->vdev);
|
||||
}
|
||||
|
||||
static int __devexit virtio_mmio_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct virtio_mmio_device *vm_dev = platform_get_drvdata(pdev);
|
||||
|
||||
unregister_virtio_device(&vm_dev->vdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Platform driver */
|
||||
|
||||
static struct of_device_id virtio_mmio_match[] = {
|
||||
{ .compatible = "virtio,mmio", },
|
||||
{},
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, virtio_mmio_match);
|
||||
|
||||
static struct platform_driver virtio_mmio_driver = {
|
||||
.probe = virtio_mmio_probe,
|
||||
.remove = __devexit_p(virtio_mmio_remove),
|
||||
.driver = {
|
||||
.name = "virtio-mmio",
|
||||
.owner = THIS_MODULE,
|
||||
.of_match_table = virtio_mmio_match,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init virtio_mmio_init(void)
|
||||
{
|
||||
return platform_driver_register(&virtio_mmio_driver);
|
||||
}
|
||||
|
||||
static void __exit virtio_mmio_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&virtio_mmio_driver);
|
||||
}
|
||||
|
||||
module_init(virtio_mmio_init);
|
||||
module_exit(virtio_mmio_exit);
|
||||
|
||||
MODULE_AUTHOR("Pawel Moll <pawel.moll@arm.com>");
|
||||
MODULE_DESCRIPTION("Platform bus driver for memory mapped virtio devices");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
|
@ -415,9 +415,13 @@ static struct virtqueue *setup_vq(struct virtio_device *vdev, unsigned index,
|
|||
}
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&vp_dev->lock, flags);
|
||||
list_add(&info->node, &vp_dev->virtqueues);
|
||||
spin_unlock_irqrestore(&vp_dev->lock, flags);
|
||||
if (callback) {
|
||||
spin_lock_irqsave(&vp_dev->lock, flags);
|
||||
list_add(&info->node, &vp_dev->virtqueues);
|
||||
spin_unlock_irqrestore(&vp_dev->lock, flags);
|
||||
} else {
|
||||
INIT_LIST_HEAD(&info->node);
|
||||
}
|
||||
|
||||
return vq;
|
||||
|
||||
|
|
|
|||
|
|
@ -131,10 +131,10 @@ void unregister_virtio_device(struct virtio_device *dev);
|
|||
* virtio_driver - operations for a virtio I/O driver
|
||||
* @driver: underlying device driver (populate name and owner).
|
||||
* @id_table: the ids serviced by this driver.
|
||||
* @feature_table: an array of feature numbers supported by this device.
|
||||
* @feature_table: an array of feature numbers supported by this driver.
|
||||
* @feature_table_size: number of entries in the feature table array.
|
||||
* @probe: the function to call when a device is found. Returns 0 or -errno.
|
||||
* @remove: the function when a device is removed.
|
||||
* @remove: the function to call when a device is removed.
|
||||
* @config_changed: optional function to call when the device configuration
|
||||
* changes; may be called in interrupt context.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -155,6 +155,9 @@ static inline bool virtio_has_feature(const struct virtio_device *vdev,
|
|||
#define virtio_config_val(vdev, fbit, offset, v) \
|
||||
virtio_config_buf((vdev), (fbit), (offset), (v), sizeof(*v))
|
||||
|
||||
#define virtio_config_val_len(vdev, fbit, offset, v, len) \
|
||||
virtio_config_buf((vdev), (fbit), (offset), (v), (len))
|
||||
|
||||
static inline int virtio_config_buf(struct virtio_device *vdev,
|
||||
unsigned int fbit,
|
||||
unsigned int offset,
|
||||
|
|
|
|||
111
include/linux/virtio_mmio.h
Normal file
111
include/linux/virtio_mmio.h
Normal file
|
|
@ -0,0 +1,111 @@
|
|||
/*
|
||||
* Virtio platform device driver
|
||||
*
|
||||
* Copyright 2011, ARM Ltd.
|
||||
*
|
||||
* Based on Virtio PCI driver by Anthony Liguori, copyright IBM Corp. 2007
|
||||
*
|
||||
* This header is BSD licensed so anyone can use the definitions to implement
|
||||
* compatible drivers/servers.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. Neither the name of IBM nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef _LINUX_VIRTIO_MMIO_H
|
||||
#define _LINUX_VIRTIO_MMIO_H
|
||||
|
||||
/*
|
||||
* Control registers
|
||||
*/
|
||||
|
||||
/* Magic value ("virt" string) - Read Only */
|
||||
#define VIRTIO_MMIO_MAGIC_VALUE 0x000
|
||||
|
||||
/* Virtio device version - Read Only */
|
||||
#define VIRTIO_MMIO_VERSION 0x004
|
||||
|
||||
/* Virtio device ID - Read Only */
|
||||
#define VIRTIO_MMIO_DEVICE_ID 0x008
|
||||
|
||||
/* Virtio vendor ID - Read Only */
|
||||
#define VIRTIO_MMIO_VENDOR_ID 0x00c
|
||||
|
||||
/* Bitmask of the features supported by the host
|
||||
* (32 bits per set) - Read Only */
|
||||
#define VIRTIO_MMIO_HOST_FEATURES 0x010
|
||||
|
||||
/* Host features set selector - Write Only */
|
||||
#define VIRTIO_MMIO_HOST_FEATURES_SEL 0x014
|
||||
|
||||
/* Bitmask of features activated by the guest
|
||||
* (32 bits per set) - Write Only */
|
||||
#define VIRTIO_MMIO_GUEST_FEATURES 0x020
|
||||
|
||||
/* Activated features set selector - Write Only */
|
||||
#define VIRTIO_MMIO_GUEST_FEATURES_SET 0x024
|
||||
|
||||
/* Guest's memory page size in bytes - Write Only */
|
||||
#define VIRTIO_MMIO_GUEST_PAGE_SIZE 0x028
|
||||
|
||||
/* Queue selector - Write Only */
|
||||
#define VIRTIO_MMIO_QUEUE_SEL 0x030
|
||||
|
||||
/* Maximum size of the currently selected queue - Read Only */
|
||||
#define VIRTIO_MMIO_QUEUE_NUM_MAX 0x034
|
||||
|
||||
/* Queue size for the currently selected queue - Write Only */
|
||||
#define VIRTIO_MMIO_QUEUE_NUM 0x038
|
||||
|
||||
/* Used Ring alignment for the currently selected queue - Write Only */
|
||||
#define VIRTIO_MMIO_QUEUE_ALIGN 0x03c
|
||||
|
||||
/* Guest's PFN for the currently selected queue - Read Write */
|
||||
#define VIRTIO_MMIO_QUEUE_PFN 0x040
|
||||
|
||||
/* Queue notifier - Write Only */
|
||||
#define VIRTIO_MMIO_QUEUE_NOTIFY 0x050
|
||||
|
||||
/* Interrupt status - Read Only */
|
||||
#define VIRTIO_MMIO_INTERRUPT_STATUS 0x060
|
||||
|
||||
/* Interrupt acknowledge - Write Only */
|
||||
#define VIRTIO_MMIO_INTERRUPT_ACK 0x064
|
||||
|
||||
/* Device status register - Read Write */
|
||||
#define VIRTIO_MMIO_STATUS 0x070
|
||||
|
||||
/* The config space is defined by each driver as
|
||||
* the per-driver configuration space - Read Write */
|
||||
#define VIRTIO_MMIO_CONFIG 0x100
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Interrupt flags (re: interrupt status & acknowledge registers)
|
||||
*/
|
||||
|
||||
#define VIRTIO_MMIO_INT_VRING (1 << 0)
|
||||
#define VIRTIO_MMIO_INT_CONFIG (1 << 1)
|
||||
|
||||
#endif
|
||||
|
|
@ -135,13 +135,13 @@ static inline void vring_init(struct vring *vr, unsigned int num, void *p,
|
|||
vr->num = num;
|
||||
vr->desc = p;
|
||||
vr->avail = p + num*sizeof(struct vring_desc);
|
||||
vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + align-1)
|
||||
& ~(align - 1));
|
||||
vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + sizeof(__u16)
|
||||
+ align-1) & ~(align - 1));
|
||||
}
|
||||
|
||||
static inline unsigned vring_size(unsigned int num, unsigned long align)
|
||||
{
|
||||
return ((sizeof(struct vring_desc) * num + sizeof(__u16) * (2 + num)
|
||||
return ((sizeof(struct vring_desc) * num + sizeof(__u16) * (3 + num)
|
||||
+ align - 1) & ~(align - 1))
|
||||
+ sizeof(__u16) * 3 + sizeof(struct vring_used_elem) * num;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue