drivers/virt: introduce Freescale hypervisor management driver

Add the drivers/virt directory, which houses drivers that support
virtualization environments, and add the Freescale hypervisor management
driver.

The Freescale hypervisor management driver provides several services to
drivers and applications related to the Freescale hypervisor:

1. An ioctl interface for querying and managing partitions

2. A file interface to reading incoming doorbells

3. An interrupt handler for shutting down the partition upon receiving the
   shutdown doorbell from a manager partition

4. A kernel interface for receiving callbacks when a managed partition
   shuts down.

Signed-off-by: Timur Tabi <timur@freescale.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>

8 files changed, 1222 insertions, 0 deletions

diff --git a/Documentation/ioctl/ioctl-number.txt b/Documentation/ioctl/ioctl-number.txt
index 3a46e360496d..72ba8d51dbc1 100644
--- a/Documentation/ioctl/ioctl-number.txt
+++ b/Documentation/ioctl/ioctl-number.txt
@@ -301,6 +301,7 @@ Code  Seq#(hex)	Include File		Comments
                                         <mailto:rusty@rustcorp.com.au>
 0xAE    all     linux/kvm.h             Kernel-based Virtual Machine
                                         <mailto:kvm@vger.kernel.org>
+0xAF    00-1F   linux/fsl_hypervisor.h  Freescale hypervisor
 0xB0    all     RATIO devices           in development:
                                         <mailto:vgo@ratio.de>
 0xB1    00-1F   PPPoX                   <mailto:mostrows@styx.uwaterloo.ca>
diff --git a/drivers/Kconfig b/drivers/Kconfig
index 3bb154d8c8cc..3c1d4a59a864 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -126,4 +126,6 @@ source "drivers/hwspinlock/Kconfig"
 
 source "drivers/clocksource/Kconfig"
 
+source "drivers/virt/Kconfig"
+
 endmenu
diff --git a/drivers/Makefile b/drivers/Makefile
index 09f3232bcdcd..cd546ebab9a7 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -122,3 +122,6 @@ obj-y				+= ieee802154/
 obj-y                           += clk/
 
 obj-$(CONFIG_HWSPINLOCK)        += hwspinlock/
+
+# Virtualization drivers
+obj-$(CONFIG_VIRT_DRIVERS)      += virt/
diff --git a/drivers/virt/Kconfig b/drivers/virt/Kconfig
new file mode 100644
index 000000000000..2dcdbc9364d8
--- /dev/null
+++ b/drivers/virt/Kconfig
@@ -0,0 +1,32 @@
+#
+# Virtualization support drivers
+#
+
+menuconfig VIRT_DRIVERS
+        bool "Virtualization drivers"
+        ---help---
+          Say Y here to get to see options for device drivers that support
+          virtualization environments.
+
+          If you say N, all options in this submenu will be skipped and disabled.
+
+if VIRT_DRIVERS
+
+config FSL_HV_MANAGER
+        tristate "Freescale hypervisor management driver"
+        depends on FSL_SOC
+        help
+          The Freescale hypervisor management driver provides several services
+          to drivers and applications related to the Freescale hypervisor:
+
+          1) An ioctl interface for querying and managing partitions.
+
+          2) A file interface to reading incoming doorbells.
+
+          3) An interrupt handler for shutting down the partition upon
+             receiving the shutdown doorbell from a manager partition.
+
+          4) A kernel interface for receiving callbacks when a managed
+             partition shuts down.
+
+endif
diff --git a/drivers/virt/Makefile b/drivers/virt/Makefile
new file mode 100644
index 000000000000..c47f04dd343b
--- /dev/null
+++ b/drivers/virt/Makefile
@@ -0,0 +1,5 @@
+#
+# Makefile for drivers that support virtualization
+#
+
+obj-$(CONFIG_FSL_HV_MANAGER)    += fsl_hypervisor.o
diff --git a/drivers/virt/fsl_hypervisor.c b/drivers/virt/fsl_hypervisor.c
new file mode 100644
index 000000000000..1d3b8ebb3141
--- /dev/null
+++ b/drivers/virt/fsl_hypervisor.c
@@ -0,0 +1,937 @@
+/*
+ * Freescale Hypervisor Management Driver
+
+ * Copyright (C) 2008-2011 Freescale Semiconductor, Inc.
+ * Author: Timur Tabi <timur@freescale.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2.  This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ *
+ * The Freescale hypervisor management driver provides several services to
+ * drivers and applications related to the Freescale hypervisor:
+ *
+ * 1. An ioctl interface for querying and managing partitions.
+ *
+ * 2. A file interface to reading incoming doorbells.
+ *
+ * 3. An interrupt handler for shutting down the partition upon receiving the
+ *    shutdown doorbell from a manager partition.
+ *
+ * 4. A kernel interface for receiving callbacks when a managed partition
+ *    shuts down.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/err.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+#include <linux/slab.h>
+#include <linux/poll.h>
+#include <linux/of.h>
+#include <linux/reboot.h>
+#include <linux/uaccess.h>
+#include <linux/notifier.h>
+
+#include <linux/io.h>
+#include <asm/fsl_hcalls.h>
+
+#include <linux/fsl_hypervisor.h>
+
+static BLOCKING_NOTIFIER_HEAD(failover_subscribers);
+
+/*
+ * Ioctl interface for FSL_HV_IOCTL_PARTITION_RESTART
+ *
+ * Restart a running partition
+ */
+static long ioctl_restart(struct fsl_hv_ioctl_restart __user *p)
+{
+        struct fsl_hv_ioctl_restart param;
+
+        /* Get the parameters from the user */
+        if (copy_from_user(&param, p, sizeof(struct fsl_hv_ioctl_restart)))
+                return -EFAULT;
+
+        param.ret = fh_partition_restart(param.partition);
+
+        if (copy_to_user(&p->ret, &param.ret, sizeof(__u32)))
+                return -EFAULT;
+
+        return 0;
+}
+
+/*
+ * Ioctl interface for FSL_HV_IOCTL_PARTITION_STATUS
+ *
+ * Query the status of a partition
+ */
+static long ioctl_status(struct fsl_hv_ioctl_status __user *p)
+{
+        struct fsl_hv_ioctl_status param;
+        u32 status;
+
+        /* Get the parameters from the user */
+        if (copy_from_user(&param, p, sizeof(struct fsl_hv_ioctl_status)))
+                return -EFAULT;
+
+        param.ret = fh_partition_get_status(param.partition, &status);
+        if (!param.ret)
+                param.status = status;
+
+        if (copy_to_user(p, &param, sizeof(struct fsl_hv_ioctl_status)))
+                return -EFAULT;
+
+        return 0;
+}
+
+/*
+ * Ioctl interface for FSL_HV_IOCTL_PARTITION_START
+ *
+ * Start a stopped partition.
+ */
+static long ioctl_start(struct fsl_hv_ioctl_start __user *p)
+{
+        struct fsl_hv_ioctl_start param;
+
+        /* Get the parameters from the user */
+        if (copy_from_user(&param, p, sizeof(struct fsl_hv_ioctl_start)))
+                return -EFAULT;
+
+        param.ret = fh_partition_start(param.partition, param.entry_point,
+                                       param.load);
+
+        if (copy_to_user(&p->ret, &param.ret, sizeof(__u32)))
+                return -EFAULT;
+
+        return 0;
+}
+
+/*
+ * Ioctl interface for FSL_HV_IOCTL_PARTITION_STOP
+ *
+ * Stop a running partition
+ */
+static long ioctl_stop(struct fsl_hv_ioctl_stop __user *p)
+{
+        struct fsl_hv_ioctl_stop param;
+
+        /* Get the parameters from the user */
+        if (copy_from_user(&param, p, sizeof(struct fsl_hv_ioctl_stop)))
+                return -EFAULT;
+
+        param.ret = fh_partition_stop(param.partition);
+
+        if (copy_to_user(&p->ret, &param.ret, sizeof(__u32)))
+                return -EFAULT;
+
+        return 0;
+}
+
+/*
+ * Ioctl interface for FSL_HV_IOCTL_MEMCPY
+ *
+ * The FH_MEMCPY hypercall takes an array of address/address/size structures
+ * to represent the data being copied.  As a convenience to the user, this
+ * ioctl takes a user-create buffer and a pointer to a guest physically
+ * contiguous buffer in the remote partition, and creates the
+ * address/address/size array for the hypercall.
+ */
+static long ioctl_memcpy(struct fsl_hv_ioctl_memcpy __user *p)
+{
+        struct fsl_hv_ioctl_memcpy param;
+
+        struct page **pages = NULL;
+        void *sg_list_unaligned = NULL;
+        struct fh_sg_list *sg_list = NULL;
+
+        unsigned int num_pages;
+        unsigned long lb_offset; /* Offset within a page of the local buffer */
+
+        unsigned int i;
+        long ret = 0;
+        int num_pinned; /* return value from get_user_pages() */
+        phys_addr_t remote_paddr; /* The next address in the remote buffer */
+        uint32_t count; /* The number of bytes left to copy */
+
+        /* Get the parameters from the user */
+        if (copy_from_user(&param, p, sizeof(struct fsl_hv_ioctl_memcpy)))
+                return -EFAULT;
+
+        /*
+         * One partition must be local, the other must be remote.  In other
+         * words, if source and target are both -1, or are both not -1, then
+         * return an error.
+         */
+        if ((param.source == -1) == (param.target == -1))
+                return -EINVAL;
+
+        /*
+         * The array of pages returned by get_user_pages() covers only
+         * page-aligned memory.  Since the user buffer is probably not
+         * page-aligned, we need to handle the discrepancy.
+         *
+         * We calculate the offset within a page of the S/G list, and make
+         * adjustments accordingly.  This will result in a page list that looks
+         * like this:
+         *
+         *      ----    <-- first page starts before the buffer
+         *     |    |
+         *     |////|-> ----
+         *     |////|  |    |
+         *      ----   |    |
+         *             |    |
+         *      ----   |    |
+         *     |////|  |    |
+         *     |////|  |    |
+         *     |////|  |    |
+         *      ----   |    |
+         *             |    |
+         *      ----   |    |
+         *     |////|  |    |
+         *     |////|  |    |
+         *     |////|  |    |
+         *      ----   |    |
+         *             |    |
+         *      ----   |    |
+         *     |////|  |    |
+         *     |////|-> ----
+         *     |    |   <-- last page ends after the buffer
+         *      ----
+         *
+         * The distance between the start of the first page and the start of the
+         * buffer is lb_offset.  The hashed (///) areas are the parts of the
+         * page list that contain the actual buffer.
+         *
+         * The advantage of this approach is that the number of pages is
+         * equal to the number of entries in the S/G list that we give to the
+         * hypervisor.
+         */
+        lb_offset = param.local_vaddr & (PAGE_SIZE - 1);
+        num_pages = (param.count + lb_offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
+
+        /* Allocate the buffers we need */
+
+        /*
+         * 'pages' is an array of struct page pointers that's initialized by
+         * get_user_pages().
+         */
+        pages = kzalloc(num_pages * sizeof(struct page *), GFP_KERNEL);
+        if (!pages) {
+                pr_debug("fsl-hv: could not allocate page list\n");
+                return -ENOMEM;
+        }
+
+        /*
+         * sg_list is the list of fh_sg_list objects that we pass to the
+         * hypervisor.
+         */
+        sg_list_unaligned = kmalloc(num_pages * sizeof(struct fh_sg_list) +
+                sizeof(struct fh_sg_list) - 1, GFP_KERNEL);
+        if (!sg_list_unaligned) {
+                pr_debug("fsl-hv: could not allocate S/G list\n");
+                ret = -ENOMEM;
+                goto exit;
+        }
+        sg_list = PTR_ALIGN(sg_list_unaligned, sizeof(struct fh_sg_list));
+
+        /* Get the physical addresses of the source buffer */
+        down_read(&current->mm->mmap_sem);
+        num_pinned = get_user_pages(current, current->mm,
+                param.local_vaddr - lb_offset, num_pages,
+                (param.source == -1) ? READ : WRITE,
+                0, pages, NULL);
+        up_read(&current->mm->mmap_sem);
+
+        if (num_pinned != num_pages) {
+                /* get_user_pages() failed */
+                pr_debug("fsl-hv: could not lock source buffer\n");
+                ret = (num_pinned < 0) ? num_pinned : -EFAULT;
+                goto exit;
+        }
+
+        /*
+         * Build the fh_sg_list[] array.  The first page is special
+         * because it's misaligned.
+         */
+        if (param.source == -1) {
+                sg_list[0].source = page_to_phys(pages[0]) + lb_offset;
+                sg_list[0].target = param.remote_paddr;
+        } else {
+                sg_list[0].source = param.remote_paddr;
+                sg_list[0].target = page_to_phys(pages[0]) + lb_offset;
+        }
+        sg_list[0].size = min_t(uint64_t, param.count, PAGE_SIZE - lb_offset);
+
+        remote_paddr = param.remote_paddr + sg_list[0].size;
+        count = param.count - sg_list[0].size;
+
+        for (i = 1; i < num_pages; i++) {
+                if (param.source == -1) {
+                        /* local to remote */
+                        sg_list[i].source = page_to_phys(pages[i]);
+                        sg_list[i].target = remote_paddr;
+                } else {
+                        /* remote to local */
+                        sg_list[i].source = remote_paddr;
+                        sg_list[i].target = page_to_phys(pages[i]);
+                }
+                sg_list[i].size = min_t(uint64_t, count, PAGE_SIZE);
+
+                remote_paddr += sg_list[i].size;
+                count -= sg_list[i].size;
+        }
+
+        param.ret = fh_partition_memcpy(param.source, param.target,
+                virt_to_phys(sg_list), num_pages);
+
+exit:
+        if (pages) {
+                for (i = 0; i < num_pages; i++)
+                        if (pages[i])
+                                put_page(pages[i]);
+        }
+
+        kfree(sg_list_unaligned);
+        kfree(pages);
+
+        if (!ret)
+                if (copy_to_user(&p->ret, &param.ret, sizeof(__u32)))
+                        return -EFAULT;
+
+        return ret;
+}
+
+/*
+ * Ioctl interface for FSL_HV_IOCTL_DOORBELL
+ *
+ * Ring a doorbell
+ */
+static long ioctl_doorbell(struct fsl_hv_ioctl_doorbell __user *p)
+{
+        struct fsl_hv_ioctl_doorbell param;
+
+        /* Get the parameters from the user. */
+        if (copy_from_user(&param, p, sizeof(struct fsl_hv_ioctl_doorbell)))
+                return -EFAULT;
+
+        param.ret = ev_doorbell_send(param.doorbell);
+
+        if (copy_to_user(&p->ret, &param.ret, sizeof(__u32)))
+                return -EFAULT;
+
+        return 0;
+}
+
+static long ioctl_dtprop(struct fsl_hv_ioctl_prop __user *p, int set)
+{
+        struct fsl_hv_ioctl_prop param;
+        char __user *upath, *upropname;
+        void __user *upropval;
+        char *path = NULL, *propname = NULL;
+        void *propval = NULL;
+        int ret = 0;
+
+        /* Get the parameters from the user. */
+        if (copy_from_user(&param, p, sizeof(struct fsl_hv_ioctl_prop)))
+                return -EFAULT;
+
+        upath = (char __user *)(uintptr_t)param.path;
+        upropname = (char __user *)(uintptr_t)param.propname;
+        upropval = (void __user *)(uintptr_t)param.propval;
+
+        path = strndup_user(upath, FH_DTPROP_MAX_PATHLEN);
+        if (IS_ERR(path)) {
+                ret = PTR_ERR(path);
+                goto out;
+        }
+
+        propname = strndup_user(upropname, FH_DTPROP_MAX_PATHLEN);
+        if (IS_ERR(propname)) {
+                ret = PTR_ERR(propname);
+                goto out;
+        }
+
+        if (param.proplen > FH_DTPROP_MAX_PROPLEN) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        propval = kmalloc(param.proplen, GFP_KERNEL);
+        if (!propval) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        if (set) {
+                if (copy_from_user(propval, upropval, param.proplen)) {
+                        ret = -EFAULT;
+                        goto out;
+                }
+
+                param.ret = fh_partition_set_dtprop(param.handle,
+                                                    virt_to_phys(path),
+                                                    virt_to_phys(propname),
+                                                    virt_to_phys(propval),
+                                                    param.proplen);
+        } else {
+                param.ret = fh_partition_get_dtprop(param.handle,
+                                                    virt_to_phys(path),
+                                                    virt_to_phys(propname),
+                                                    virt_to_phys(propval),
+                                                    &param.proplen);
+
+                if (param.ret == 0) {
+                        if (copy_to_user(upropval, propval, param.proplen) ||
+                            put_user(param.proplen, &p->proplen)) {
+                                ret = -EFAULT;
+                                goto out;
+                        }
+                }
+        }
+
+        if (put_user(param.ret, &p->ret))
+                ret = -EFAULT;
+
+out:
+        kfree(path);
+        kfree(propval);
+        kfree(propname);
+
+        return ret;
+}
+
+/*
+ * Ioctl main entry point
+ */
+static long fsl_hv_ioctl(struct file *file, unsigned int cmd,
+                         unsigned long argaddr)
+{
+        void __user *arg = (void __user *)argaddr;
+        long ret;
+
+        switch (cmd) {
+        case FSL_HV_IOCTL_PARTITION_RESTART:
+                ret = ioctl_restart(arg);
+                break;
+        case FSL_HV_IOCTL_PARTITION_GET_STATUS:
+                ret = ioctl_status(arg);
+                break;
+        case FSL_HV_IOCTL_PARTITION_START:
+                ret = ioctl_start(arg);
+                break;
+        case FSL_HV_IOCTL_PARTITION_STOP:
+                ret = ioctl_stop(arg);
+                break;
+        case FSL_HV_IOCTL_MEMCPY:
+                ret = ioctl_memcpy(arg);
+                break;
+        case FSL_HV_IOCTL_DOORBELL:
+                ret = ioctl_doorbell(arg);
+                break;
+        case FSL_HV_IOCTL_GETPROP:
+                ret = ioctl_dtprop(arg, 0);
+                break;
+        case FSL_HV_IOCTL_SETPROP:
+                ret = ioctl_dtprop(arg, 1);
+                break;
+        default:
+                pr_debug("fsl-hv: bad ioctl dir=%u type=%u cmd=%u size=%u\n",
+                         _IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd),
+                         _IOC_SIZE(cmd));
+                return -ENOTTY;
+        }
+
+        return ret;
+}
+
+/* Linked list of processes that have us open */
+static struct list_head db_list;
+
+/* spinlock for db_list */
+static DEFINE_SPINLOCK(db_list_lock);
+
+/* The size of the doorbell event queue.  This must be a power of two. */
+#define QSIZE   16
+
+/* Returns the next head/tail pointer, wrapping around the queue if necessary */
+#define nextp(x) (((x) + 1) & (QSIZE - 1))
+
+/* Per-open data structure */
+struct doorbell_queue {
+        struct list_head list;
+        spinlock_t lock;
+        wait_queue_head_t wait;
+        unsigned int head;
+        unsigned int tail;
+        uint32_t q[QSIZE];
+};
+
+/* Linked list of ISRs that we registered */
+struct list_head isr_list;
+
+/* Per-ISR data structure */
+struct doorbell_isr {
+        struct list_head list;
+        unsigned int irq;
+        uint32_t doorbell;      /* The doorbell handle */
+        uint32_t partition;     /* The partition handle, if used */
+};
+
+/*
+ * Add a doorbell to all of the doorbell queues
+ */
+static void fsl_hv_queue_doorbell(uint32_t doorbell)
+{
+        struct doorbell_queue *dbq;
+        unsigned long flags;
+
+        /* Prevent another core from modifying db_list */
+        spin_lock_irqsave(&db_list_lock, flags);
+
+        list_for_each_entry(dbq, &db_list, list) {
+                if (dbq->head != nextp(dbq->tail)) {
+                        dbq->q[dbq->tail] = doorbell;
+                        /*
+                         * This memory barrier eliminates the need to grab
+                         * the spinlock for dbq.
+                         */
+                        smp_wmb();
+                        dbq->tail = nextp(dbq->tail);
+                        wake_up_interruptible(&dbq->wait);
+                }
+        }
+
+        spin_unlock_irqrestore(&db_list_lock, flags);
+}
+
+/*
+ * Interrupt handler for all doorbells
+ *
+ * We use the same interrupt handler for all doorbells.  Whenever a doorbell
+ * is rung, and we receive an interrupt, we just put the handle for that
+ * doorbell (passed to us as *data) into all of the queues.
+ */
+static irqreturn_t fsl_hv_isr(int irq, void *data)
+{
+        fsl_hv_queue_doorbell((uintptr_t) data);
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * State change thread function
+ *
+ * The state change notification arrives in an interrupt, but we can't call
+ * blocking_notifier_call_chain() in an interrupt handler.  We could call
+ * atomic_notifier_call_chain(), but that would require the clients' call-back
+ * function to run in interrupt context.  Since we don't want to impose that
+ * restriction on the clients, we use a threaded IRQ to process the
+ * notification in kernel context.
+ */
+static irqreturn_t fsl_hv_state_change_thread(int irq, void *data)
+{
+        struct doorbell_isr *dbisr = data;
+
+        blocking_notifier_call_chain(&failover_subscribers, dbisr->partition,
+                                     NULL);
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * Interrupt handler for state-change doorbells
+ */
+static irqreturn_t fsl_hv_state_change_isr(int irq, void *data)
+{
+        unsigned int status;
+        struct doorbell_isr *dbisr = data;
+        int ret;
+
+        /* It's still a doorbell, so add it to all the queues. */
+        fsl_hv_queue_doorbell(dbisr->doorbell);
+
+        /* Determine the new state, and if it's stopped, notify the clients. */
+        ret = fh_partition_get_status(dbisr->partition, &status);
+        if (!ret && (status == FH_PARTITION_STOPPED))
+                return IRQ_WAKE_THREAD;
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * Returns a bitmask indicating whether a read will block
+ */
+static unsigned int fsl_hv_poll(struct file *filp, struct poll_table_struct *p)
+{
+        struct doorbell_queue *dbq = filp->private_data;
+        unsigned long flags;
+        unsigned int mask;
+
+        spin_lock_irqsave(&dbq->lock, flags);
+
+        poll_wait(filp, &dbq->wait, p);
+        mask = (dbq->head == dbq->tail) ? 0 : (POLLIN | POLLRDNORM);
+
+        spin_unlock_irqrestore(&dbq->lock, flags);
+
+        return mask;
+}
+
+/*
+ * Return the handles for any incoming doorbells
+ *
+ * If there are doorbell handles in the queue for this open instance, then
+ * return them to the caller as an array of 32-bit integers.  Otherwise,
+ * block until there is at least one handle to return.
+ */
+static ssize_t fsl_hv_read(struct file *filp, char __user *buf, size_t len,
+                           loff_t *off)
+{
+        struct doorbell_queue *dbq = filp->private_data;
+        uint32_t __user *p = (uint32_t __user *) buf; /* for put_user() */
+        unsigned long flags;
+        ssize_t count = 0;
+
+        /* Make sure we stop when the user buffer is full. */
+        while (len >= sizeof(uint32_t)) {
+                uint32_t dbell; /* Local copy of doorbell queue data */
+
+                spin_lock_irqsave(&dbq->lock, flags);
+
+                /*
+                 * If the queue is empty, then either we're done or we need
+                 * to block.  If the application specified O_NONBLOCK, then
+                 * we return the appropriate error code.
+                 */
+                if (dbq->head == dbq->tail) {
+                        spin_unlock_irqrestore(&dbq->lock, flags);
+                        if (count)
+                                break;
+                        if (filp->f_flags & O_NONBLOCK)
+                                return -EAGAIN;
+                        if (wait_event_interruptible(dbq->wait,
+                                                     dbq->head != dbq->tail))
+                                return -ERESTARTSYS;
+                        continue;
+                }
+
+                /*
+                 * Even though we have an smp_wmb() in the ISR, the core
+                 * might speculatively execute the "dbell = ..." below while
+                 * it's evaluating the if-statement above.  In that case, the
+                 * value put into dbell could be stale if the core accepts the
+                 * speculation. To prevent that, we need a read memory barrier
+                 * here as well.
+                 */
+                smp_rmb();
+
+                /* Copy the data to a temporary local buffer, because
+                 * we can't call copy_to_user() from inside a spinlock
+                 */
+                dbell = dbq->q[dbq->head];
+                dbq->head = nextp(dbq->head);
+
+                spin_unlock_irqrestore(&dbq->lock, flags);
+
+                if (put_user(dbell, p))
+                        return -EFAULT;
+                p++;
+                count += sizeof(uint32_t);
+                len -= sizeof(uint32_t);
+        }
+
+        return count;
+}
+
+/*
+ * Open the driver and prepare for reading doorbells.
+ *
+ * Every time an application opens the driver, we create a doorbell queue
+ * for that file handle.  This queue is used for any incoming doorbells.
+ */
+static int fsl_hv_open(struct inode *inode, struct file *filp)
+{
+        struct doorbell_queue *dbq;
+        unsigned long flags;
+        int ret = 0;
+
+        dbq = kzalloc(sizeof(struct doorbell_queue), GFP_KERNEL);
+        if (!dbq) {
+                pr_err("fsl-hv: out of memory\n");
+                return -ENOMEM;
+        }
+
+        spin_lock_init(&dbq->lock);
+        init_waitqueue_head(&dbq->wait);
+
+        spin_lock_irqsave(&db_list_lock, flags);
+        list_add(&dbq->list, &db_list);
+        spin_unlock_irqrestore(&db_list_lock, flags);
+
+        filp->private_data = dbq;
+
+        return ret;
+}
+
+/*
+ * Close the driver
+ */
+static int fsl_hv_close(struct inode *inode, struct file *filp)
+{
+        struct doorbell_queue *dbq = filp->private_data;
+        unsigned long flags;
+
+        int ret = 0;
+
+        spin_lock_irqsave(&db_list_lock, flags);
+        list_del(&dbq->list);
+        spin_unlock_irqrestore(&db_list_lock, flags);
+
+        kfree(dbq);
+
+        return ret;
+}
+
+static const struct file_operations fsl_hv_fops = {
+        .owner = THIS_MODULE,
+        .open = fsl_hv_open,
+        .release = fsl_hv_close,
+        .poll = fsl_hv_poll,
+        .read = fsl_hv_read,
+        .unlocked_ioctl = fsl_hv_ioctl,
+};
+
+static struct miscdevice fsl_hv_misc_dev = {
+        MISC_DYNAMIC_MINOR,
+        "fsl-hv",
+        &fsl_hv_fops
+};
+
+static irqreturn_t fsl_hv_shutdown_isr(int irq, void *data)
+{
+        orderly_poweroff(false);
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * Returns the handle of the parent of the given node
+ *
+ * The handle is the value of the 'hv-handle' property
+ */
+static int get_parent_handle(struct device_node *np)
+{
+        struct device_node *parent;
+        const uint32_t *prop;
+        uint32_t handle;
+        int len;
+
+        parent = of_get_parent(np);
+        if (!parent)
+                /* It's not really possible for this to fail */
+                return -ENODEV;
+
+        /*
+         * The proper name for the handle property is "hv-handle", but some
+         * older versions of the hypervisor used "reg".
+         */
+        prop = of_get_property(parent, "hv-handle", &len);
+        if (!prop)
+                prop = of_get_property(parent, "reg", &len);
+
+        if (!prop || (len != sizeof(uint32_t))) {
+                /* This can happen only if the node is malformed */
+                of_node_put(parent);
+                return -ENODEV;
+        }
+
+        handle = be32_to_cpup(prop);
+        of_node_put(parent);
+
+        return handle;
+}
+
+/*
+ * Register a callback for failover events
+ *
+ * This function is called by device drivers to register their callback
+ * functions for fail-over events.
+ */
+int fsl_hv_failover_register(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&failover_subscribers, nb);
+}
+EXPORT_SYMBOL(fsl_hv_failover_register);
+
+/*
+ * Unregister a callback for failover events
+ */
+int fsl_hv_failover_unregister(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_unregister(&failover_subscribers, nb);
+}
+EXPORT_SYMBOL(fsl_hv_failover_unregister);
+
+/*
+ * Return TRUE if we're running under FSL hypervisor
+ *
+ * This function checks to see if we're running under the Freescale
+ * hypervisor, and returns zero if we're not, or non-zero if we are.
+ *
+ * First, it checks if MSR[GS]==1, which means we're running under some
+ * hypervisor.  Then it checks if there is a hypervisor node in the device
+ * tree.  Currently, that means there needs to be a node in the root called
+ * "hypervisor" and which has a property named "fsl,hv-version".
+ */
+static int has_fsl_hypervisor(void)
+{
+        struct device_node *node;
+        int ret;
+
+        if (!(mfmsr() & MSR_GS))
+                return 0;
+
+        node = of_find_node_by_path("/hypervisor");
+        if (!node)
+                return 0;
+
+        ret = of_find_property(node, "fsl,hv-version", NULL) != NULL;
+
+        of_node_put(node);
+
+        return ret;
+}
+
+/*
+ * Freescale hypervisor management driver init
+ *
+ * This function is called when this module is loaded.
+ *
+ * Register ourselves as a miscellaneous driver.  This will register the
+ * fops structure and create the right sysfs entries for udev.
+ */
+static int __init fsl_hypervisor_init(void)
+{
+        struct device_node *np;
+        struct doorbell_isr *dbisr, *n;
+        int ret;
+
+        pr_info("Freescale hypervisor management driver\n");
+
+        if (!has_fsl_hypervisor()) {
+                pr_info("fsl-hv: no hypervisor found\n");
+                return -ENODEV;
+        }
+
+        ret = misc_register(&fsl_hv_misc_dev);
+        if (ret) {
+                pr_err("fsl-hv: cannot register device\n");
+                return ret;
+        }
+
+        INIT_LIST_HEAD(&db_list);
+        INIT_LIST_HEAD(&isr_list);
+
+        for_each_compatible_node(np, NULL, "epapr,hv-receive-doorbell") {
+                unsigned int irq;
+                const uint32_t *handle;
+
+                handle = of_get_property(np, "interrupts", NULL);
+                irq = irq_of_parse_and_map(np, 0);
+                if (!handle || (irq == NO_IRQ)) {
+                        pr_err("fsl-hv: no 'interrupts' property in %s node\n",
+                                np->full_name);
+                        continue;
+                }
+
+                dbisr = kzalloc(sizeof(*dbisr), GFP_KERNEL);
+                if (!dbisr)
+                        goto out_of_memory;
+
+                dbisr->irq = irq;
+                dbisr->doorbell = be32_to_cpup(handle);
+
+                if (of_device_is_compatible(np, "fsl,hv-shutdown-doorbell")) {
+                        /* The shutdown doorbell gets its own ISR */
+                        ret = request_irq(irq, fsl_hv_shutdown_isr, 0,
+                                          np->name, NULL);
+                } else if (of_device_is_compatible(np,
+                        "fsl,hv-state-change-doorbell")) {
+                        /*
+                         * The state change doorbell triggers a notification if
+                         * the state of the managed partition changes to
+                         * "stopped". We need a separate interrupt handler for
+                         * that, and we also need to know the handle of the
+                         * target partition, not just the handle of the
+                         * doorbell.
+                         */
+                        dbisr->partition = ret = get_parent_handle(np);
+                        if (ret < 0) {
+                                pr_err("fsl-hv: node %s has missing or "
+                                       "malformed parent\n", np->full_name);
+                                kfree(dbisr);
+                                continue;
+                        }
+                        ret = request_threaded_irq(irq, fsl_hv_state_change_isr,
+                                                   fsl_hv_state_change_thread,
+                                                   0, np->name, dbisr);
+                } else
+                        ret = request_irq(irq, fsl_hv_isr, 0, np->name, dbisr);
+
+                if (ret < 0) {
+                        pr_err("fsl-hv: could not request irq %u for node %s\n",
+                               irq, np->full_name);
+                        kfree(dbisr);
+                        continue;
+                }
+
+                list_add(&dbisr->list, &isr_list);
+
+                pr_info("fsl-hv: registered handler for doorbell %u\n",
+                        dbisr->doorbell);
+        }
+
+        return 0;
+
+out_of_memory:
+        list_for_each_entry_safe(dbisr, n, &isr_list, list) {
+                free_irq(dbisr->irq, dbisr);
+                list_del(&dbisr->list);
+                kfree(dbisr);
+        }
+
+        misc_deregister(&fsl_hv_misc_dev);
+
+        return -ENOMEM;
+}
+
+/*
+ * Freescale hypervisor management driver termination
+ *
+ * This function is called when this driver is unloaded.
+ */
+static void __exit fsl_hypervisor_exit(void)
+{
+        struct doorbell_isr *dbisr, *n;
+
+        list_for_each_entry_safe(dbisr, n, &isr_list, list) {
+                free_irq(dbisr->irq, dbisr);
+                list_del(&dbisr->list);
+                kfree(dbisr);
+        }
+
+        misc_deregister(&fsl_hv_misc_dev);
+}
+
+module_init(fsl_hypervisor_init);
+module_exit(fsl_hypervisor_exit);
+
+MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
+MODULE_DESCRIPTION("Freescale hypervisor management driver");
+MODULE_LICENSE("GPL v2");
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 01f636275057..619b5657af77 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -135,6 +135,7 @@ header-y += firewire-cdev.h
 header-y += firewire-constants.h
 header-y += flat.h
 header-y += fs.h
+header-y += fsl_hypervisor.h
 header-y += fuse.h
 header-y += futex.h
 header-y += gameport.h
diff --git a/include/linux/fsl_hypervisor.h b/include/linux/fsl_hypervisor.h
new file mode 100644
index 000000000000..1cebaeeeef57
--- /dev/null
+++ b/include/linux/fsl_hypervisor.h
@@ -0,0 +1,241 @@
+/*
+ * Freescale hypervisor ioctl and kernel interface
+ *
+ * Copyright (C) 2008-2011 Freescale Semiconductor, Inc.
+ * Author: Timur Tabi <timur@freescale.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Freescale Semiconductor nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ *
+ * ALTERNATIVELY, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") as published by the Free Software
+ * Foundation, either version 2 of that License or (at your option) any
+ * later version.
+ *
+ * This software is provided by Freescale Semiconductor "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 Freescale Semiconductor 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.
+ *
+ * This file is used by the Freescale hypervisor management driver.  It can
+ * also be included by applications that need to communicate with the driver
+ * via the ioctl interface.
+ */
+
+#ifndef FSL_HYPERVISOR_H
+#define FSL_HYPERVISOR_H
+
+#include <linux/types.h>
+
+/**
+ * struct fsl_hv_ioctl_restart - restart a partition
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to restart, or -1 for the
+ *             calling partition
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_RESTART
+ */
+struct fsl_hv_ioctl_restart {
+        __u32 ret;
+        __u32 partition;
+};
+
+/**
+ * struct fsl_hv_ioctl_status - get a partition's status
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to query, or -1 for the
+ *             calling partition
+ * @status: The returned status of the partition
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_GET_STATUS
+ *
+ * Values of 'status':
+ *    0 = Stopped
+ *    1 = Running
+ *    2 = Starting
+ *    3 = Stopping
+ */
+struct fsl_hv_ioctl_status {
+        __u32 ret;
+        __u32 partition;
+        __u32 status;
+};
+
+/**
+ * struct fsl_hv_ioctl_start - start a partition
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to control
+ * @entry_point: The offset within the guest IMA to start execution
+ * @load: If non-zero, reload the partition's images before starting
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_START
+ */
+struct fsl_hv_ioctl_start {
+        __u32 ret;
+        __u32 partition;
+        __u32 entry_point;
+        __u32 load;
+};
+
+/**
+ * struct fsl_hv_ioctl_stop - stop a partition
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to stop, or -1 for the calling
+ *             partition
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_STOP
+ */
+struct fsl_hv_ioctl_stop {
+        __u32 ret;
+        __u32 partition;
+};
+
+/**
+ * struct fsl_hv_ioctl_memcpy - copy memory between partitions
+ * @ret: return error code from the hypervisor
+ * @source: the partition ID of the source partition, or -1 for this
+ *          partition
+ * @target: the partition ID of the target partition, or -1 for this
+ *          partition
+ * @reserved: reserved, must be set to 0
+ * @local_addr: user-space virtual address of a buffer in the local
+ *              partition
+ * @remote_addr: guest physical address of a buffer in the
+ *           remote partition
+ * @count: the number of bytes to copy.  Both the local and remote
+ *         buffers must be at least 'count' bytes long
+ *
+ * Used by FSL_HV_IOCTL_MEMCPY
+ *
+ * The 'local' partition is the partition that calls this ioctl.  The
+ * 'remote' partition is a different partition.  The data is copied from
+ * the 'source' paritition' to the 'target' partition.
+ *
+ * The buffer in the remote partition must be guest physically
+ * contiguous.
+ *
+ * This ioctl does not support copying memory between two remote
+ * partitions or within the same partition, so either 'source' or
+ * 'target' (but not both) must be -1.  In other words, either
+ *
+ *      source == local and target == remote
+ * or
+ *      source == remote and target == local
+ */
+struct fsl_hv_ioctl_memcpy {
+        __u32 ret;
+        __u32 source;
+        __u32 target;
+        __u32 reserved; /* padding to ensure local_vaddr is aligned */
+        __u64 local_vaddr;
+        __u64 remote_paddr;
+        __u64 count;
+};
+
+/**
+ * struct fsl_hv_ioctl_doorbell - ring a doorbell
+ * @ret: return error code from the hypervisor
+ * @doorbell: the handle of the doorbell to ring doorbell
+ *
+ * Used by FSL_HV_IOCTL_DOORBELL
+ */
+struct fsl_hv_ioctl_doorbell {
+        __u32 ret;
+        __u32 doorbell;
+};
+
+/**
+ * struct fsl_hv_ioctl_prop - get/set a device tree property
+ * @ret: return error code from the hypervisor
+ * @handle: handle of partition whose tree to access
+ * @path: virtual address of path name of node to access
+ * @propname: virtual address of name of property to access
+ * @propval: virtual address of property data buffer
+ * @proplen: Size of property data buffer
+ * @reserved: reserved, must be set to 0
+ *
+ * Used by FSL_HV_IOCTL_DOORBELL
+ */
+struct fsl_hv_ioctl_prop {
+        __u32 ret;
+        __u32 handle;
+        __u64 path;
+        __u64 propname;
+        __u64 propval;
+        __u32 proplen;
+        __u32 reserved; /* padding to ensure structure is aligned */
+};
+
+/* The ioctl type, documented in ioctl-number.txt */
+#define FSL_HV_IOCTL_TYPE       0xAF
+
+/* Restart another partition */
+#define FSL_HV_IOCTL_PARTITION_RESTART \
+        _IOWR(FSL_HV_IOCTL_TYPE, 1, struct fsl_hv_ioctl_restart)
+
+/* Get a partition's status */
+#define FSL_HV_IOCTL_PARTITION_GET_STATUS \
+        _IOWR(FSL_HV_IOCTL_TYPE, 2, struct fsl_hv_ioctl_status)
+
+/* Boot another partition */
+#define FSL_HV_IOCTL_PARTITION_START \
+        _IOWR(FSL_HV_IOCTL_TYPE, 3, struct fsl_hv_ioctl_start)
+
+/* Stop this or another partition */
+#define FSL_HV_IOCTL_PARTITION_STOP \
+        _IOWR(FSL_HV_IOCTL_TYPE, 4, struct fsl_hv_ioctl_stop)
+
+/* Copy data from one partition to another */
+#define FSL_HV_IOCTL_MEMCPY \
+        _IOWR(FSL_HV_IOCTL_TYPE, 5, struct fsl_hv_ioctl_memcpy)
+
+/* Ring a doorbell */
+#define FSL_HV_IOCTL_DOORBELL \
+        _IOWR(FSL_HV_IOCTL_TYPE, 6, struct fsl_hv_ioctl_doorbell)
+
+/* Get a property from another guest's device tree */
+#define FSL_HV_IOCTL_GETPROP \
+        _IOWR(FSL_HV_IOCTL_TYPE, 7, struct fsl_hv_ioctl_prop)
+
+/* Set a property in another guest's device tree */
+#define FSL_HV_IOCTL_SETPROP \
+        _IOWR(FSL_HV_IOCTL_TYPE, 8, struct fsl_hv_ioctl_prop)
+
+#ifdef __KERNEL__
+
+/**
+ * fsl_hv_event_register() - register a callback for failover events
+ * @nb: pointer to caller-supplied notifier_block structure
+ *
+ * This function is called by device drivers to register their callback
+ * functions for fail-over events.
+ *
+ * The caller should allocate a notifier_block object and initialize the
+ * 'priority' and 'notifier_call' fields.
+ */
+int fsl_hv_failover_register(struct notifier_block *nb);
+
+/**
+ * fsl_hv_event_unregister() - unregister a callback for failover events
+ * @nb: the same 'nb' used in previous fsl_hv_failover_register call
+ */
+int fsl_hv_failover_unregister(struct notifier_block *nb);
+
+#endif
+
+#endif