Merge commit 'origin/master' into next

12 files changed, 330 insertions, 54 deletions

diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 02ecfd5fa61c..30bae6de6a0d 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -692,7 +692,7 @@ config HVCS
           this driver.
 
           To compile this driver as a module, choose M here: the
-          module will be called hvcs.ko.  Additionally, this module
+          module will be called hvcs.  Additionally, this module
           will depend on arch specific APIs exported from hvcserver.ko
           which will also be compiled when this driver is built as a
           module.
@@ -906,7 +906,7 @@ config DTLK
 
 config XILINX_HWICAP
         tristate "Xilinx HWICAP Support"
-        depends on XILINX_VIRTEX
+        depends on XILINX_VIRTEX || MICROBLAZE
         help
           This option enables support for Xilinx Internal Configuration
           Access Port (ICAP) driver.  The ICAP is used on Xilinx Virtex
diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c
index 3686912427ba..7a748fa0dfce 100644
--- a/drivers/char/agp/intel-agp.c
+++ b/drivers/char/agp/intel-agp.c
@@ -46,6 +46,10 @@
 #define PCI_DEVICE_ID_INTEL_G45_IG          0x2E22
 #define PCI_DEVICE_ID_INTEL_G41_HB          0x2E30
 #define PCI_DEVICE_ID_INTEL_G41_IG          0x2E32
+#define PCI_DEVICE_ID_INTEL_IGDNG_D_HB      0x0040
+#define PCI_DEVICE_ID_INTEL_IGDNG_D_IG      0x0042
+#define PCI_DEVICE_ID_INTEL_IGDNG_M_HB      0x0044
+#define PCI_DEVICE_ID_INTEL_IGDNG_M_IG      0x0046
 
 /* cover 915 and 945 variants */
 #define IS_I915 (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_E7221_HB || \
@@ -75,7 +79,9 @@
                 agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_Q45_HB || \
                 agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_G45_HB || \
                 agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_GM45_HB || \
-                agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_G41_HB)
+                agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_G41_HB || \
+                agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_IGDNG_D_HB || \
+                agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_IGDNG_M_HB)
 
 extern int agp_memory_reserved;
 
@@ -1211,6 +1217,8 @@ static void intel_i965_get_gtt_range(int *gtt_offset, int *gtt_size)
         case PCI_DEVICE_ID_INTEL_Q45_HB:
         case PCI_DEVICE_ID_INTEL_G45_HB:
         case PCI_DEVICE_ID_INTEL_G41_HB:
+        case PCI_DEVICE_ID_INTEL_IGDNG_D_HB:
+        case PCI_DEVICE_ID_INTEL_IGDNG_M_HB:
                 *gtt_offset = *gtt_size = MB(2);
                 break;
         default:
@@ -2186,6 +2194,10 @@ static const struct intel_driver_description {
             "G45/G43", NULL, &intel_i965_driver },
         { PCI_DEVICE_ID_INTEL_G41_HB, PCI_DEVICE_ID_INTEL_G41_IG, 0,
             "G41", NULL, &intel_i965_driver },
+        { PCI_DEVICE_ID_INTEL_IGDNG_D_HB, PCI_DEVICE_ID_INTEL_IGDNG_D_IG, 0,
+            "IGDNG/D", NULL, &intel_i965_driver },
+        { PCI_DEVICE_ID_INTEL_IGDNG_M_HB, PCI_DEVICE_ID_INTEL_IGDNG_M_IG, 0,
+            "IGDNG/M", NULL, &intel_i965_driver },
         { 0, 0, 0, NULL, NULL, NULL }
 };
 
@@ -2387,6 +2399,8 @@ static struct pci_device_id agp_intel_pci_table[] = {
         ID(PCI_DEVICE_ID_INTEL_Q45_HB),
         ID(PCI_DEVICE_ID_INTEL_G45_HB),
         ID(PCI_DEVICE_ID_INTEL_G41_HB),
+        ID(PCI_DEVICE_ID_INTEL_IGDNG_D_HB),
+        ID(PCI_DEVICE_ID_INTEL_IGDNG_M_HB),
         { }
 };
 
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index fd3ebd1be570..72429b6b2fa8 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -779,7 +779,7 @@ static void change_speed(struct async_struct *info,
                 info->IER |= UART_IER_MSI;
         }
         /* TBD:
-         * Does clearing IER_MSI imply that we should disbale the VBL interrupt ?
+         * Does clearing IER_MSI imply that we should disable the VBL interrupt ?
          */
 
         /*
diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index 5fab6470f4b2..f4b3f7293feb 100644
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -88,7 +88,7 @@ config HW_RANDOM_N2RNG
 
 config HW_RANDOM_VIA
         tristate "VIA HW Random Number Generator support"
-        depends on HW_RANDOM && X86_32
+        depends on HW_RANDOM && X86
         default HW_RANDOM
         ---help---
           This driver provides kernel-side support for the Random Number
@@ -148,3 +148,15 @@ config HW_RANDOM_VIRTIO
 
           To compile this driver as a module, choose M here: the
           module will be called virtio-rng.  If unsure, say N.
+
+config HW_RANDOM_MXC_RNGA
+        tristate "Freescale i.MX RNGA Random Number Generator"
+        depends on HW_RANDOM && ARCH_HAS_RNGA
+        ---help---
+          This driver provides kernel-side support for the Random Number
+          Generator hardware found on Freescale i.MX processors.
+
+          To compile this driver as a module, choose M here: the
+          module will be called mxc-rnga.
+
+          If unsure, say Y.
diff --git a/drivers/char/hw_random/Makefile b/drivers/char/hw_random/Makefile
index e81d21a5f28f..fd1ecd2f6731 100644
--- a/drivers/char/hw_random/Makefile
+++ b/drivers/char/hw_random/Makefile
@@ -15,3 +15,4 @@ obj-$(CONFIG_HW_RANDOM_IXP4XX) += ixp4xx-rng.o
 obj-$(CONFIG_HW_RANDOM_OMAP) += omap-rng.o
 obj-$(CONFIG_HW_RANDOM_PASEMI) += pasemi-rng.o
 obj-$(CONFIG_HW_RANDOM_VIRTIO) += virtio-rng.o
+obj-$(CONFIG_HW_RANDOM_MXC_RNGA) += mxc-rnga.o
diff --git a/drivers/char/hw_random/mxc-rnga.c b/drivers/char/hw_random/mxc-rnga.c
new file mode 100644
index 000000000000..187c6be80f43
--- /dev/null
+++ b/drivers/char/hw_random/mxc-rnga.c
@@ -0,0 +1,247 @@
+/*
+ * RNG driver for Freescale RNGA
+ *
+ * Copyright 2008-2009 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Author: Alan Carvalho de Assis <acassis@gmail.com>
+ */
+
+/*
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ * This driver is based on other RNG drivers.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/ioport.h>
+#include <linux/platform_device.h>
+#include <linux/hw_random.h>
+#include <linux/io.h>
+
+/* RNGA Registers */
+#define RNGA_CONTROL                    0x00
+#define RNGA_STATUS                     0x04
+#define RNGA_ENTROPY                    0x08
+#define RNGA_OUTPUT_FIFO                0x0c
+#define RNGA_MODE                       0x10
+#define RNGA_VERIFICATION_CONTROL       0x14
+#define RNGA_OSC_CONTROL_COUNTER        0x18
+#define RNGA_OSC1_COUNTER               0x1c
+#define RNGA_OSC2_COUNTER               0x20
+#define RNGA_OSC_COUNTER_STATUS         0x24
+
+/* RNGA Registers Range */
+#define RNG_ADDR_RANGE                  0x28
+
+/* RNGA Control Register */
+#define RNGA_CONTROL_SLEEP              0x00000010
+#define RNGA_CONTROL_CLEAR_INT          0x00000008
+#define RNGA_CONTROL_MASK_INTS          0x00000004
+#define RNGA_CONTROL_HIGH_ASSURANCE     0x00000002
+#define RNGA_CONTROL_GO                 0x00000001
+
+#define RNGA_STATUS_LEVEL_MASK          0x0000ff00
+
+/* RNGA Status Register */
+#define RNGA_STATUS_OSC_DEAD            0x80000000
+#define RNGA_STATUS_SLEEP               0x00000010
+#define RNGA_STATUS_ERROR_INT           0x00000008
+#define RNGA_STATUS_FIFO_UNDERFLOW      0x00000004
+#define RNGA_STATUS_LAST_READ_STATUS    0x00000002
+#define RNGA_STATUS_SECURITY_VIOLATION  0x00000001
+
+static struct platform_device *rng_dev;
+
+static int mxc_rnga_data_present(struct hwrng *rng)
+{
+        int level;
+        void __iomem *rng_base = (void __iomem *)rng->priv;
+
+        /* how many random numbers is in FIFO? [0-16] */
+        level = ((__raw_readl(rng_base + RNGA_STATUS) &
+                        RNGA_STATUS_LEVEL_MASK) >> 8);
+
+        return level > 0 ? 1 : 0;
+}
+
+static int mxc_rnga_data_read(struct hwrng *rng, u32 * data)
+{
+        int err;
+        u32 ctrl;
+        void __iomem *rng_base = (void __iomem *)rng->priv;
+
+        /* retrieve a random number from FIFO */
+        *data = __raw_readl(rng_base + RNGA_OUTPUT_FIFO);
+
+        /* some error while reading this random number? */
+        err = __raw_readl(rng_base + RNGA_STATUS) & RNGA_STATUS_ERROR_INT;
+
+        /* if error: clear error interrupt, but doesn't return random number */
+        if (err) {
+                dev_dbg(&rng_dev->dev, "Error while reading random number!\n");
+                ctrl = __raw_readl(rng_base + RNGA_CONTROL);
+                __raw_writel(ctrl | RNGA_CONTROL_CLEAR_INT,
+                                        rng_base + RNGA_CONTROL);
+                return 0;
+        } else
+                return 4;
+}
+
+static int mxc_rnga_init(struct hwrng *rng)
+{
+        u32 ctrl, osc;
+        void __iomem *rng_base = (void __iomem *)rng->priv;
+
+        /* wake up */
+        ctrl = __raw_readl(rng_base + RNGA_CONTROL);
+        __raw_writel(ctrl & ~RNGA_CONTROL_SLEEP, rng_base + RNGA_CONTROL);
+
+        /* verify if oscillator is working */
+        osc = __raw_readl(rng_base + RNGA_STATUS);
+        if (osc & RNGA_STATUS_OSC_DEAD) {
+                dev_err(&rng_dev->dev, "RNGA Oscillator is dead!\n");
+                return -ENODEV;
+        }
+
+        /* go running */
+        ctrl = __raw_readl(rng_base + RNGA_CONTROL);
+        __raw_writel(ctrl | RNGA_CONTROL_GO, rng_base + RNGA_CONTROL);
+
+        return 0;
+}
+
+static void mxc_rnga_cleanup(struct hwrng *rng)
+{
+        u32 ctrl;
+        void __iomem *rng_base = (void __iomem *)rng->priv;
+
+        ctrl = __raw_readl(rng_base + RNGA_CONTROL);
+
+        /* stop rnga */
+        __raw_writel(ctrl & ~RNGA_CONTROL_GO, rng_base + RNGA_CONTROL);
+}
+
+static struct hwrng mxc_rnga = {
+        .name = "mxc-rnga",
+        .init = mxc_rnga_init,
+        .cleanup = mxc_rnga_cleanup,
+        .data_present = mxc_rnga_data_present,
+        .data_read = mxc_rnga_data_read
+};
+
+static int __init mxc_rnga_probe(struct platform_device *pdev)
+{
+        int err = -ENODEV;
+        struct clk *clk;
+        struct resource *res, *mem;
+        void __iomem *rng_base = NULL;
+
+        if (rng_dev)
+                return -EBUSY;
+
+        clk = clk_get(&pdev->dev, "rng");
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "Could not get rng_clk!\n");
+                err = PTR_ERR(clk);
+                goto out;
+        }
+
+        clk_enable(clk);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                err = -ENOENT;
+                goto err_region;
+        }
+
+        mem = request_mem_region(res->start, resource_size(res), pdev->name);
+        if (mem == NULL) {
+                err = -EBUSY;
+                goto err_region;
+        }
+
+        rng_base = ioremap(res->start, resource_size(res));
+        if (!rng_base) {
+                err = -ENOMEM;
+                goto err_ioremap;
+        }
+
+        mxc_rnga.priv = (unsigned long)rng_base;
+
+        err = hwrng_register(&mxc_rnga);
+        if (err) {
+                dev_err(&pdev->dev, "MXC RNGA registering failed (%d)\n", err);
+                goto err_register;
+        }
+
+        rng_dev = pdev;
+
+        dev_info(&pdev->dev, "MXC RNGA Registered.\n");
+
+        return 0;
+
+err_register:
+        iounmap(rng_base);
+        rng_base = NULL;
+
+err_ioremap:
+        release_mem_region(res->start, resource_size(res));
+
+err_region:
+        clk_disable(clk);
+        clk_put(clk);
+
+out:
+        return err;
+}
+
+static int __exit mxc_rnga_remove(struct platform_device *pdev)
+{
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        void __iomem *rng_base = (void __iomem *)mxc_rnga.priv;
+        struct clk *clk = clk_get(&pdev->dev, "rng");
+
+        hwrng_unregister(&mxc_rnga);
+
+        iounmap(rng_base);
+
+        release_mem_region(res->start, resource_size(res));
+
+        clk_disable(clk);
+        clk_put(clk);
+
+        return 0;
+}
+
+static struct platform_driver mxc_rnga_driver = {
+        .driver = {
+                   .name = "mxc_rnga",
+                   .owner = THIS_MODULE,
+                   },
+        .remove = __exit_p(mxc_rnga_remove),
+};
+
+static int __init mod_init(void)
+{
+        return platform_driver_probe(&mxc_rnga_driver, mxc_rnga_probe);
+}
+
+static void __exit mod_exit(void)
+{
+        platform_driver_unregister(&mxc_rnga_driver);
+}
+
+module_init(mod_init);
+module_exit(mod_exit);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc.");
+MODULE_DESCRIPTION("H/W RNGA driver for i.MX");
+MODULE_LICENSE("GPL");
diff --git a/drivers/char/hw_random/omap-rng.c b/drivers/char/hw_random/omap-rng.c
index 538313f9e7ac..00dd3de1be51 100644
--- a/drivers/char/hw_random/omap-rng.c
+++ b/drivers/char/hw_random/omap-rng.c
@@ -89,7 +89,7 @@ static struct hwrng omap_rng_ops = {
         .data_read      = omap_rng_data_read,
 };
 
-static int __init omap_rng_probe(struct platform_device *pdev)
+static int __devinit omap_rng_probe(struct platform_device *pdev)
 {
         struct resource *res, *mem;
         int ret;
diff --git a/drivers/char/hw_random/timeriomem-rng.c b/drivers/char/hw_random/timeriomem-rng.c
index dcd352ad0e7f..a94e930575f2 100644
--- a/drivers/char/hw_random/timeriomem-rng.c
+++ b/drivers/char/hw_random/timeriomem-rng.c
@@ -88,9 +88,9 @@ static struct hwrng timeriomem_rng_ops = {
         .priv           = 0,
 };
 
-static int __init timeriomem_rng_probe(struct platform_device *pdev)
+static int __devinit timeriomem_rng_probe(struct platform_device *pdev)
 {
-        struct resource *res, *mem;
+        struct resource *res;
         int ret;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -98,21 +98,12 @@ static int __init timeriomem_rng_probe(struct platform_device *pdev)
         if (!res)
                 return -ENOENT;
 
-        mem = request_mem_region(res->start, res->end - res->start + 1,
-                                 pdev->name);
-        if (mem == NULL)
-                return -EBUSY;
-
-        dev_set_drvdata(&pdev->dev, mem);
-
         timeriomem_rng_data = pdev->dev.platform_data;
 
         timeriomem_rng_data->address = ioremap(res->start,
                                                 res->end - res->start + 1);
-        if (!timeriomem_rng_data->address) {
-                ret = -ENOMEM;
-                goto err_ioremap;
-        }
+        if (!timeriomem_rng_data->address)
+                return -EIO;
 
         if (timeriomem_rng_data->period != 0
                 && usecs_to_jiffies(timeriomem_rng_data->period) > 0) {
@@ -125,7 +116,7 @@ static int __init timeriomem_rng_probe(struct platform_device *pdev)
 
         ret = hwrng_register(&timeriomem_rng_ops);
         if (ret)
-                goto err_register;
+                goto failed;
 
         dev_info(&pdev->dev, "32bits from 0x%p @ %dus\n",
                         timeriomem_rng_data->address,
@@ -133,24 +124,19 @@ static int __init timeriomem_rng_probe(struct platform_device *pdev)
 
         return 0;
 
-err_register:
+failed:
         dev_err(&pdev->dev, "problem registering\n");
         iounmap(timeriomem_rng_data->address);
-err_ioremap:
-        release_resource(mem);
 
         return ret;
 }
 
 static int __devexit timeriomem_rng_remove(struct platform_device *pdev)
 {
-        struct resource *mem = dev_get_drvdata(&pdev->dev);
-
         del_timer_sync(&timeriomem_rng_timer);
         hwrng_unregister(&timeriomem_rng_ops);
 
         iounmap(timeriomem_rng_data->address);
-        release_resource(mem);
 
         return 0;
 }
diff --git a/drivers/char/hw_random/via-rng.c b/drivers/char/hw_random/via-rng.c
index 4e9573c1d39e..794aacb715c1 100644
--- a/drivers/char/hw_random/via-rng.c
+++ b/drivers/char/hw_random/via-rng.c
@@ -132,6 +132,19 @@ static int via_rng_init(struct hwrng *rng)
         struct cpuinfo_x86 *c = &cpu_data(0);
         u32 lo, hi, old_lo;
 
+        /* VIA Nano CPUs don't have the MSR_VIA_RNG anymore.  The RNG
+         * is always enabled if CPUID rng_en is set.  There is no
+         * RNG configuration like it used to be the case in this
+         * register */
+        if ((c->x86 == 6) && (c->x86_model >= 0x0f)) {
+                if (!cpu_has_xstore_enabled) {
+                        printk(KERN_ERR PFX "can't enable hardware RNG "
+                                "if XSTORE is not enabled\n");
+                        return -ENODEV;
+                }
+                return 0;
+        }
+
         /* Control the RNG via MSR.  Tread lightly and pay very close
          * close attention to values written, as the reserved fields
          * are documented to be "undefined and unpredictable"; but it
@@ -205,5 +218,5 @@ static void __exit mod_exit(void)
 module_init(mod_init);
 module_exit(mod_exit);
 
-MODULE_DESCRIPTION("H/W RNG driver for VIA chipsets");
+MODULE_DESCRIPTION("H/W RNG driver for VIA CPU with PadLock");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/hw_random/virtio-rng.c b/drivers/char/hw_random/virtio-rng.c
index 86e83f883139..32216b623248 100644
--- a/drivers/char/hw_random/virtio-rng.c
+++ b/drivers/char/hw_random/virtio-rng.c
@@ -35,13 +35,13 @@ static DECLARE_COMPLETION(have_data);
 
 static void random_recv_done(struct virtqueue *vq)
 {
-        int len;
+        unsigned int len;
 
         /* We can get spurious callbacks, e.g. shared IRQs + virtio_pci. */
         if (!vq->vq_ops->get_buf(vq, &len))
                 return;
 
-        data_left = len / sizeof(random_data[0]);
+        data_left += len;
         complete(&have_data);
 }
 
@@ -49,7 +49,7 @@ static void register_buffer(void)
 {
         struct scatterlist sg;
 
-        sg_init_one(&sg, random_data, RANDOM_DATA_SIZE);
+        sg_init_one(&sg, random_data+data_left, RANDOM_DATA_SIZE-data_left);
         /* There should always be room for one buffer. */
         if (vq->vq_ops->add_buf(vq, &sg, 0, 1, random_data) != 0)
                 BUG();
@@ -59,24 +59,32 @@ static void register_buffer(void)
 /* At least we don't udelay() in a loop like some other drivers. */
 static int virtio_data_present(struct hwrng *rng, int wait)
 {
-        if (data_left)
+        if (data_left >= sizeof(u32))
                 return 1;
 
+again:
         if (!wait)
                 return 0;
 
         wait_for_completion(&have_data);
+
+        /* Not enough?  Re-register. */
+        if (unlikely(data_left < sizeof(u32))) {
+                register_buffer();
+                goto again;
+        }
+
         return 1;
 }
 
 /* virtio_data_present() must have succeeded before this is called. */
 static int virtio_data_read(struct hwrng *rng, u32 *data)
 {
-        BUG_ON(!data_left);
-
-        *data = random_data[--data_left];
+        BUG_ON(data_left < sizeof(u32));
+        data_left -= sizeof(u32);
+        *data = random_data[data_left / 4];
 
-        if (!data_left) {
+        if (data_left < sizeof(u32)) {
                 init_completion(&have_data);
                 register_buffer();
         }
@@ -94,13 +102,13 @@ static int virtrng_probe(struct virtio_device *vdev)
         int err;
 
         /* We expect a single virtqueue. */
-        vq = vdev->config->find_vq(vdev, 0, random_recv_done);
+        vq = virtio_find_single_vq(vdev, random_recv_done, "input");
         if (IS_ERR(vq))
                 return PTR_ERR(vq);
 
         err = hwrng_register(&virtio_hwrng);
         if (err) {
-                vdev->config->del_vq(vq);
+                vdev->config->del_vqs(vdev);
                 return err;
         }
 
@@ -112,7 +120,7 @@ static void virtrng_remove(struct virtio_device *vdev)
 {
         vdev->config->reset(vdev);
         hwrng_unregister(&virtio_hwrng);
-        vdev->config->del_vq(vq);
+        vdev->config->del_vqs(vdev);
 }
 
 static struct virtio_device_id id_table[] = {
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index ff6f5a4b58fb..c74dacfa6795 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -188,6 +188,9 @@ static void hvc_handle_input(struct virtqueue *vq)
  * Finally we put our input buffer in the input queue, ready to receive. */
 static int __devinit virtcons_probe(struct virtio_device *dev)
 {
+        vq_callback_t *callbacks[] = { hvc_handle_input, NULL};
+        const char *names[] = { "input", "output" };
+        struct virtqueue *vqs[2];
         int err;
 
         vdev = dev;
@@ -199,20 +202,15 @@ static int __devinit virtcons_probe(struct virtio_device *dev)
                 goto fail;
         }
 
-        /* Find the input queue. */
+        /* Find the queues. */
         /* FIXME: This is why we want to wean off hvc: we do nothing
          * when input comes in. */
-        in_vq = vdev->config->find_vq(vdev, 0, hvc_handle_input);
-        if (IS_ERR(in_vq)) {
-                err = PTR_ERR(in_vq);
+        err = vdev->config->find_vqs(vdev, 2, vqs, callbacks, names);
+        if (err)
                 goto free;
-        }
 
-        out_vq = vdev->config->find_vq(vdev, 1, NULL);
-        if (IS_ERR(out_vq)) {
-                err = PTR_ERR(out_vq);
-                goto free_in_vq;
-        }
+        in_vq = vqs[0];
+        out_vq = vqs[1];
 
         /* Start using the new console output. */
         virtio_cons.get_chars = get_chars;
@@ -233,17 +231,15 @@ static int __devinit virtcons_probe(struct virtio_device *dev)
         hvc = hvc_alloc(0, 0, &virtio_cons, PAGE_SIZE);
         if (IS_ERR(hvc)) {
                 err = PTR_ERR(hvc);
-                goto free_out_vq;
+                goto free_vqs;
         }
 
         /* Register the input buffer the first time. */
         add_inbuf();
         return 0;
 
-free_out_vq:
-        vdev->config->del_vq(out_vq);
-free_in_vq:
-        vdev->config->del_vq(in_vq);
+free_vqs:
+        vdev->config->del_vqs(vdev);
 free:
         kfree(inbuf);
 fail:
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index de9ebee8657b..c796a86ab7f3 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -103,7 +103,6 @@
 #include <linux/io.h>
 #include <asm/system.h>
 #include <linux/uaccess.h>
-#include <linux/kmemleak.h>
 
 #define MAX_NR_CON_DRIVER 16