5 files changed, 207 insertions, 32 deletions

diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 0d39f2f4294a..693187df7601 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -29,9 +29,6 @@ struct virtio_blk
         /* The disk structure for the kernel. */
         struct gendisk *disk;
 
-        /* Request tracking. */
-        struct list_head reqs;
-
         mempool_t *pool;
 
         /* Process context for config space updates */
@@ -55,7 +52,6 @@ struct virtio_blk
 
 struct virtblk_req
 {
-        struct list_head list;
         struct request *req;
         struct virtio_blk_outhdr out_hdr;
         struct virtio_scsi_inhdr in_hdr;
@@ -99,7 +95,6 @@ static void blk_done(struct virtqueue *vq)
                 }
 
                 __blk_end_request_all(vbr->req, error);
-                list_del(&vbr->list);
                 mempool_free(vbr, vblk->pool);
         }
         /* In case queue is stopped waiting for more buffers. */
@@ -184,7 +179,6 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
                 return false;
         }
 
-        list_add_tail(&vbr->list, &vblk->reqs);
         return true;
 }
 
@@ -437,7 +431,6 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
                 goto out_free_index;
         }
 
-        INIT_LIST_HEAD(&vblk->reqs);
         spin_lock_init(&vblk->lock);
         vblk->vdev = vdev;
         vblk->sg_elems = sg_elems;
@@ -583,21 +576,29 @@ static void __devexit virtblk_remove(struct virtio_device *vdev)
 {
         struct virtio_blk *vblk = vdev->priv;
         int index = vblk->index;
+        struct virtblk_req *vbr;
+        unsigned long flags;
 
         /* Prevent config work handler from accessing the device. */
         mutex_lock(&vblk->config_lock);
         vblk->config_enable = false;
         mutex_unlock(&vblk->config_lock);
 
-        /* Nothing should be pending. */
-        BUG_ON(!list_empty(&vblk->reqs));
-
         /* Stop all the virtqueues. */
         vdev->config->reset(vdev);
 
         flush_work(&vblk->config_work);
 
         del_gendisk(vblk->disk);
+
+        /* Abort requests dispatched to driver. */
+        spin_lock_irqsave(&vblk->lock, flags);
+        while ((vbr = virtqueue_detach_unused_buf(vblk->vq))) {
+                __blk_end_request_all(vbr->req, -EIO);
+                mempool_free(vbr, vblk->pool);
+        }
+        spin_unlock_irqrestore(&vblk->lock, flags);
+
         blk_cleanup_queue(vblk->disk->queue);
         put_disk(vblk->disk);
         mempool_destroy(vblk->pool);
diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig
index 1a61939b85fc..f38b17a86c35 100644
--- a/drivers/virtio/Kconfig
+++ b/drivers/virtio/Kconfig
@@ -46,4 +46,15 @@ config VIRTIO_BALLOON
 
          If unsure, say N.
 
+config VIRTIO_MMIO_CMDLINE_DEVICES
+        bool "Memory mapped virtio devices parameter parsing"
+        depends on VIRTIO_MMIO
+        ---help---
+         Allow virtio-mmio devices instantiation via the kernel command line
+         or module parameters. Be aware that using incorrect parameters (base
+         address in particular) can crash your system - you have been warned.
+         See Documentation/kernel-parameters.txt for details.
+
+         If unsure, say 'N'.
+
 endmenu
diff --git a/drivers/virtio/virtio.c b/drivers/virtio/virtio.c
index 984c501c258f..f3558070e375 100644
--- a/drivers/virtio/virtio.c
+++ b/drivers/virtio/virtio.c
@@ -2,9 +2,10 @@
 #include <linux/spinlock.h>
 #include <linux/virtio_config.h>
 #include <linux/module.h>
+#include <linux/idr.h>
 
 /* Unique numbering for virtio devices. */
-static unsigned int dev_index;
+static DEFINE_IDA(virtio_index_ida);
 
 static ssize_t device_show(struct device *_d,
                            struct device_attribute *attr, char *buf)
@@ -193,7 +194,11 @@ int register_virtio_device(struct virtio_device *dev)
         dev->dev.bus = &virtio_bus;
 
         /* Assign a unique device index and hence name. */
-        dev->index = dev_index++;
+        err = ida_simple_get(&virtio_index_ida, 0, 0, GFP_KERNEL);
+        if (err < 0)
+                goto out;
+
+        dev->index = err;
         dev_set_name(&dev->dev, "virtio%u", dev->index);
 
         /* We always start by resetting the device, in case a previous
@@ -208,6 +213,7 @@ int register_virtio_device(struct virtio_device *dev)
         /* device_register() causes the bus infrastructure to look for a
          * matching driver. */
         err = device_register(&dev->dev);
+out:
         if (err)
                 add_status(dev, VIRTIO_CONFIG_S_FAILED);
         return err;
@@ -217,6 +223,7 @@ EXPORT_SYMBOL_GPL(register_virtio_device);
 void unregister_virtio_device(struct virtio_device *dev)
 {
         device_unregister(&dev->dev);
+        ida_simple_remove(&virtio_index_ida, dev->index);
 }
 EXPORT_SYMBOL_GPL(unregister_virtio_device);
 
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index 8807fe501d20..bfbc15ca38dd 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -381,21 +381,25 @@ out:
         return err;
 }
 
-static void __devexit virtballoon_remove(struct virtio_device *vdev)
+static void remove_common(struct virtio_balloon *vb)
 {
-        struct virtio_balloon *vb = vdev->priv;
-
-        kthread_stop(vb->thread);
-
         /* There might be pages left in the balloon: free them. */
         while (vb->num_pages)
                 leak_balloon(vb, vb->num_pages);
         update_balloon_size(vb);
 
         /* Now we reset the device so we can clean up the queues. */
-        vdev->config->reset(vdev);
+        vb->vdev->config->reset(vb->vdev);
 
-        vdev->config->del_vqs(vdev);
+        vb->vdev->config->del_vqs(vb->vdev);
+}
+
+static void __devexit virtballoon_remove(struct virtio_device *vdev)
+{
+        struct virtio_balloon *vb = vdev->priv;
+
+        kthread_stop(vb->thread);
+        remove_common(vb);
         kfree(vb);
 }
 
@@ -409,17 +413,11 @@ static int virtballoon_freeze(struct virtio_device *vdev)
          * function is called.
          */
 
-        while (vb->num_pages)
-                leak_balloon(vb, vb->num_pages);
-        update_balloon_size(vb);
-
-        /* Ensure we don't get any more requests from the host */
-        vdev->config->reset(vdev);
-        vdev->config->del_vqs(vdev);
+        remove_common(vb);
         return 0;
 }
 
-static int restore_common(struct virtio_device *vdev)
+static int virtballoon_restore(struct virtio_device *vdev)
 {
         struct virtio_balloon *vb = vdev->priv;
         int ret;
@@ -432,11 +430,6 @@ static int restore_common(struct virtio_device *vdev)
         update_balloon_size(vb);
         return 0;
 }
-
-static int virtballoon_restore(struct virtio_device *vdev)
-{
-        return restore_common(vdev);
-}
 #endif
 
 static unsigned int features[] = {
diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
index 01d6dc250d5c..453db0c403d8 100644
--- a/drivers/virtio/virtio_mmio.c
+++ b/drivers/virtio/virtio_mmio.c
@@ -6,6 +6,50 @@
  * This module allows virtio devices to be used over a virtual, memory mapped
  * platform device.
  *
+ * The guest device(s) may be instantiated in one of three equivalent ways:
+ *
+ * 1. Static platform device in board's code, eg.:
+ *
+ *      static struct platform_device v2m_virtio_device = {
+ *              .name = "virtio-mmio",
+ *              .id = -1,
+ *              .num_resources = 2,
+ *              .resource = (struct resource []) {
+ *                      {
+ *                              .start = 0x1001e000,
+ *                              .end = 0x1001e0ff,
+ *                              .flags = IORESOURCE_MEM,
+ *                      }, {
+ *                              .start = 42 + 32,
+ *                              .end = 42 + 32,
+ *                              .flags = IORESOURCE_IRQ,
+ *                      },
+ *              }
+ *      };
+ *
+ * 2. Device Tree node, eg.:
+ *
+ *              virtio_block@1e000 {
+ *                      compatible = "virtio,mmio";
+ *                      reg = <0x1e000 0x100>;
+ *                      interrupts = <42>;
+ *              }
+ *
+ * 3. Kernel module (or command line) parameter. Can be used more than once -
+ *    one device will be created for each one. Syntax:
+ *
+ *              [virtio_mmio.]device=<size>@<baseaddr>:<irq>[:<id>]
+ *    where:
+ *              <size>     := size (can use standard suffixes like K, M or G)
+ *              <baseaddr> := physical base address
+ *              <irq>      := interrupt number (as passed to request_irq())
+ *              <id>       := (optional) platform device id
+ *    eg.:
+ *              virtio_mmio.device=0x100@0x100b0000:48 \
+ *                              virtio_mmio.device=1K@0x1001e000:74
+ *
+ *
+ *
  * Registers layout (all 32-bit wide):
  *
  * offset d. name             description
@@ -42,6 +86,8 @@
  * See the COPYING file in the top-level directory.
  */
 
+#define pr_fmt(fmt) "virtio-mmio: " fmt
+
 #include <linux/highmem.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
@@ -449,6 +495,122 @@ static int __devexit virtio_mmio_remove(struct platform_device *pdev)
 
 
 
+/* Devices list parameter */
+
+#if defined(CONFIG_VIRTIO_MMIO_CMDLINE_DEVICES)
+
+static struct device vm_cmdline_parent = {
+        .init_name = "virtio-mmio-cmdline",
+};
+
+static int vm_cmdline_parent_registered;
+static int vm_cmdline_id;
+
+static int vm_cmdline_set(const char *device,
+                const struct kernel_param *kp)
+{
+        int err;
+        struct resource resources[2] = {};
+        char *str;
+        long long int base;
+        int processed, consumed = 0;
+        struct platform_device *pdev;
+
+        resources[0].flags = IORESOURCE_MEM;
+        resources[1].flags = IORESOURCE_IRQ;
+
+        resources[0].end = memparse(device, &str) - 1;
+
+        processed = sscanf(str, "@%lli:%u%n:%d%n",
+                        &base, &resources[1].start, &consumed,
+                        &vm_cmdline_id, &consumed);
+
+        if (processed < 2 || processed > 3 || str[consumed])
+                return -EINVAL;
+
+        resources[0].start = base;
+        resources[0].end += base;
+        resources[1].end = resources[1].start;
+
+        if (!vm_cmdline_parent_registered) {
+                err = device_register(&vm_cmdline_parent);
+                if (err) {
+                        pr_err("Failed to register parent device!\n");
+                        return err;
+                }
+                vm_cmdline_parent_registered = 1;
+        }
+
+        pr_info("Registering device virtio-mmio.%d at 0x%llx-0x%llx, IRQ %d.\n",
+                       vm_cmdline_id,
+                       (unsigned long long)resources[0].start,
+                       (unsigned long long)resources[0].end,
+                       (int)resources[1].start);
+
+        pdev = platform_device_register_resndata(&vm_cmdline_parent,
+                        "virtio-mmio", vm_cmdline_id++,
+                        resources, ARRAY_SIZE(resources), NULL, 0);
+        if (IS_ERR(pdev))
+                return PTR_ERR(pdev);
+
+        return 0;
+}
+
+static int vm_cmdline_get_device(struct device *dev, void *data)
+{
+        char *buffer = data;
+        unsigned int len = strlen(buffer);
+        struct platform_device *pdev = to_platform_device(dev);
+
+        snprintf(buffer + len, PAGE_SIZE - len, "0x%llx@0x%llx:%llu:%d\n",
+                        pdev->resource[0].end - pdev->resource[0].start + 1ULL,
+                        (unsigned long long)pdev->resource[0].start,
+                        (unsigned long long)pdev->resource[1].start,
+                        pdev->id);
+        return 0;
+}
+
+static int vm_cmdline_get(char *buffer, const struct kernel_param *kp)
+{
+        buffer[0] = '\0';
+        device_for_each_child(&vm_cmdline_parent, buffer,
+                        vm_cmdline_get_device);
+        return strlen(buffer) + 1;
+}
+
+static struct kernel_param_ops vm_cmdline_param_ops = {
+        .set = vm_cmdline_set,
+        .get = vm_cmdline_get,
+};
+
+device_param_cb(device, &vm_cmdline_param_ops, NULL, S_IRUSR);
+
+static int vm_unregister_cmdline_device(struct device *dev,
+                void *data)
+{
+        platform_device_unregister(to_platform_device(dev));
+
+        return 0;
+}
+
+static void vm_unregister_cmdline_devices(void)
+{
+        if (vm_cmdline_parent_registered) {
+                device_for_each_child(&vm_cmdline_parent, NULL,
+                                vm_unregister_cmdline_device);
+                device_unregister(&vm_cmdline_parent);
+                vm_cmdline_parent_registered = 0;
+        }
+}
+
+#else
+
+static void vm_unregister_cmdline_devices(void)
+{
+}
+
+#endif
+
 /* Platform driver */
 
 static struct of_device_id virtio_mmio_match[] = {
@@ -475,6 +637,7 @@ static int __init virtio_mmio_init(void)
 static void __exit virtio_mmio_exit(void)
 {
         platform_driver_unregister(&virtio_mmio_driver);
+        vm_unregister_cmdline_devices();
 }
 
 module_init(virtio_mmio_init);