virtio: Add platform bus driver for memory mapped virtio device
Pawel Moll [Mon, 24 Oct 2011 13:07:03 +0000 (14:07 +0100)]
This patch, based on virtio PCI driver, adds support for memory
mapped (platform) virtio device. This should allow environments
like qemu to use virtio-based block & network devices even on
platforms without PCI support.

One can define and register a platform device which resources
will describe memory mapped control registers and "mailbox"
interrupt. Such device can be also instantiated using the Device
Tree node with compatible property equal "virtio,mmio".

Cc: Anthony Liguori <aliguori@us.ibm.com>
Cc: Michael S.Tsirkin <mst@redhat.com>
Signed-off-by: Pawel Moll <pawel.moll@arm.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

Documentation/devicetree/bindings/virtio/mmio.txt [new file with mode: 0644]
drivers/virtio/Kconfig
drivers/virtio/Makefile
drivers/virtio/virtio_mmio.c [new file with mode: 0644]
include/linux/virtio_mmio.h [new file with mode: 0644]

diff --git a/Documentation/devicetree/bindings/virtio/mmio.txt b/Documentation/devicetree/bindings/virtio/mmio.txt
new file mode 100644 (file)
index 0000000..5069c1b
--- /dev/null
@@ -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>;
+       }
index 57e493b..816ed08 100644 (file)
@@ -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
index 6738c44..5a4c63c 100644 (file)
@@ -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
diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
new file mode 100644 (file)
index 0000000..acc5e43
--- /dev/null
@@ -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");
diff --git a/include/linux/virtio_mmio.h b/include/linux/virtio_mmio.h
new file mode 100644 (file)
index 0000000..27c7ede
--- /dev/null
@@ -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