Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

8 files changed, 381 insertions, 112 deletions

diff --git a/drivers/uio/Kconfig b/drivers/uio/Kconfig
index 1da73ecd9799..6f3ea9bbc818 100644
--- a/drivers/uio/Kconfig
+++ b/drivers/uio/Kconfig
@@ -17,9 +17,9 @@ config UIO_CIF
         depends on PCI
         help
           Driver for Hilscher CIF DeviceNet and Profibus cards.  This
-          driver requires a userspace component that handles all of the
-          heavy lifting and can be found at:
-                http://www.osadl.org/projects/downloads/UIO/user/cif-*
+          driver requires a userspace component called cif that handles
+          all of the heavy lifting and can be found at:
+                <http://www.osadl.org/projects/downloads/UIO/user/>
 
           To compile this driver as a module, choose M here: the module
           will be called uio_cif.
@@ -94,4 +94,21 @@ config UIO_NETX
           To compile this driver as a module, choose M here; the module
           will be called uio_netx.
 
+config UIO_PRUSS
+        tristate "Texas Instruments PRUSS driver"
+        depends on ARCH_DAVINCI_DA850
+        help
+          PRUSS driver for OMAPL138/DA850/AM18XX devices
+          PRUSS driver requires user space components, examples and user space
+          driver is available from below SVN repo - you may use anonymous login
+
+          https://gforge.ti.com/gf/project/pru_sw/
+
+          More info on API is available at below wiki
+
+          http://processors.wiki.ti.com/index.php/PRU_Linux_Application_Loader
+
+          To compile this driver as a module, choose M here: the module
+          will be called uio_pruss.
+
 endif
diff --git a/drivers/uio/Makefile b/drivers/uio/Makefile
index 18fd818c5b97..d4dd9a5552f8 100644
--- a/drivers/uio/Makefile
+++ b/drivers/uio/Makefile
@@ -6,3 +6,4 @@ obj-$(CONFIG_UIO_AEC)	+= uio_aec.o
 obj-$(CONFIG_UIO_SERCOS3)       += uio_sercos3.o
 obj-$(CONFIG_UIO_PCI_GENERIC)   += uio_pci_generic.o
 obj-$(CONFIG_UIO_NETX)  += uio_netx.o
+obj-$(CONFIG_UIO_PRUSS)         += uio_pruss.o
diff --git a/drivers/uio/uio.c b/drivers/uio/uio.c
index bff1afbde5a4..d2efe823c20d 100644
--- a/drivers/uio/uio.c
+++ b/drivers/uio/uio.c
@@ -3,7 +3,7 @@
  *
  * Copyright(C) 2005, Benedikt Spranger <b.spranger@linutronix.de>
  * Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de>
- * Copyright(C) 2006, Hans J. Koch <hjk@linutronix.de>
+ * Copyright(C) 2006, Hans J. Koch <hjk@hansjkoch.de>
  * Copyright(C) 2006, Greg Kroah-Hartman <greg@kroah.com>
  *
  * Userspace IO
@@ -23,9 +23,10 @@
 #include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/kobject.h>
+#include <linux/cdev.h>
 #include <linux/uio_driver.h>
 
-#define UIO_MAX_DEVICES 255
+#define UIO_MAX_DEVICES         (1U << MINORBITS)
 
 struct uio_device {
         struct module           *owner;
@@ -41,15 +42,10 @@ struct uio_device {
 };
 
 static int uio_major;
+static struct cdev *uio_cdev;
 static DEFINE_IDR(uio_idr);
 static const struct file_operations uio_fops;
 
-/* UIO class infrastructure */
-static struct uio_class {
-        struct kref kref;
-        struct class *class;
-} *uio_class;
-
 /* Protect idr accesses */
 static DEFINE_MUTEX(minor_lock);
 
@@ -232,45 +228,34 @@ static ssize_t show_name(struct device *dev,
                          struct device_attribute *attr, char *buf)
 {
         struct uio_device *idev = dev_get_drvdata(dev);
-        if (idev)
-                return sprintf(buf, "%s\n", idev->info->name);
-        else
-                return -ENODEV;
+        return sprintf(buf, "%s\n", idev->info->name);
 }
-static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 
 static ssize_t show_version(struct device *dev,
                             struct device_attribute *attr, char *buf)
 {
         struct uio_device *idev = dev_get_drvdata(dev);
-        if (idev)
-                return sprintf(buf, "%s\n", idev->info->version);
-        else
-                return -ENODEV;
+        return sprintf(buf, "%s\n", idev->info->version);
 }
-static DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
 
 static ssize_t show_event(struct device *dev,
                           struct device_attribute *attr, char *buf)
 {
         struct uio_device *idev = dev_get_drvdata(dev);
-        if (idev)
-                return sprintf(buf, "%u\n",
-                                (unsigned int)atomic_read(&idev->event));
-        else
-                return -ENODEV;
+        return sprintf(buf, "%u\n", (unsigned int)atomic_read(&idev->event));
 }
-static DEVICE_ATTR(event, S_IRUGO, show_event, NULL);
 
-static struct attribute *uio_attrs[] = {
-        &dev_attr_name.attr,
-        &dev_attr_version.attr,
-        &dev_attr_event.attr,
-        NULL,
+static struct device_attribute uio_class_attributes[] = {
+        __ATTR(name, S_IRUGO, show_name, NULL),
+        __ATTR(version, S_IRUGO, show_version, NULL),
+        __ATTR(event, S_IRUGO, show_event, NULL),
+        {}
 };
 
-static struct attribute_group uio_attr_grp = {
-        .attrs = uio_attrs,
+/* UIO class infrastructure */
+static struct class uio_class = {
+        .name = "uio",
+        .dev_attrs = uio_class_attributes,
 };
 
 /*
@@ -287,10 +272,6 @@ static int uio_dev_add_attributes(struct uio_device *idev)
         struct uio_port *port;
         struct uio_portio *portio;
 
-        ret = sysfs_create_group(&idev->dev->kobj, &uio_attr_grp);
-        if (ret)
-                goto err_group;
-
         for (mi = 0; mi < MAX_UIO_MAPS; mi++) {
                 mem = &idev->info->mem[mi];
                 if (mem->size == 0)
@@ -358,8 +339,6 @@ err_map:
                 kobject_put(&map->kobj);
         }
         kobject_put(idev->map_dir);
-        sysfs_remove_group(&idev->dev->kobj, &uio_attr_grp);
-err_group:
         dev_err(idev->dev, "error creating sysfs files (%d)\n", ret);
         return ret;
 }
@@ -385,8 +364,6 @@ static void uio_dev_del_attributes(struct uio_device *idev)
                 kobject_put(&port->portio->kobj);
         }
         kobject_put(idev->portio_dir);
-
-        sysfs_remove_group(&idev->dev->kobj, &uio_attr_grp);
 }
 
 static int uio_get_minor(struct uio_device *idev)
@@ -404,7 +381,13 @@ static int uio_get_minor(struct uio_device *idev)
                         retval = -ENOMEM;
                 goto exit;
         }
-        idev->minor = id & MAX_ID_MASK;
+        if (id < UIO_MAX_DEVICES) {
+                idev->minor = id;
+        } else {
+                dev_err(idev->dev, "too many uio devices\n");
+                retval = -EINVAL;
+                idr_remove(&uio_idr, id);
+        }
 exit:
         mutex_unlock(&minor_lock);
         return retval;
@@ -525,7 +508,7 @@ static unsigned int uio_poll(struct file *filep, poll_table *wait)
         struct uio_listener *listener = filep->private_data;
         struct uio_device *idev = listener->dev;
 
-        if (idev->info->irq == UIO_IRQ_NONE)
+        if (!idev->info->irq)
                 return -EIO;
 
         poll_wait(filep, &idev->wait, wait);
@@ -543,7 +526,7 @@ static ssize_t uio_read(struct file *filep, char __user *buf,
         ssize_t retval;
         s32 event_count;
 
-        if (idev->info->irq == UIO_IRQ_NONE)
+        if (!idev->info->irq)
                 return -EIO;
 
         if (count != sizeof(s32))
@@ -591,7 +574,7 @@ static ssize_t uio_write(struct file *filep, const char __user *buf,
         ssize_t retval;
         s32 irq_on;
 
-        if (idev->info->irq == UIO_IRQ_NONE)
+        if (!idev->info->irq)
                 return -EIO;
 
         if (count != sizeof(s32))
@@ -610,14 +593,12 @@ static ssize_t uio_write(struct file *filep, const char __user *buf,
 
 static int uio_find_mem_index(struct vm_area_struct *vma)
 {
-        int mi;
         struct uio_device *idev = vma->vm_private_data;
 
-        for (mi = 0; mi < MAX_UIO_MAPS; mi++) {
-                if (idev->info->mem[mi].size == 0)
+        if (vma->vm_pgoff < MAX_UIO_MAPS) {
+                if (idev->info->mem[vma->vm_pgoff].size == 0)
                         return -1;
-                if (vma->vm_pgoff == mi)
-                        return mi;
+                return (int)vma->vm_pgoff;
         }
         return -1;
 }
@@ -740,72 +721,77 @@ static const struct file_operations uio_fops = {
         .mmap           = uio_mmap,
         .poll           = uio_poll,
         .fasync         = uio_fasync,
+        .llseek         = noop_llseek,
 };
 
 static int uio_major_init(void)
 {
-        uio_major = register_chrdev(0, "uio", &uio_fops);
-        if (uio_major < 0)
-                return uio_major;
-        return 0;
+        static const char name[] = "uio";
+        struct cdev *cdev = NULL;
+        dev_t uio_dev = 0;
+        int result;
+
+        result = alloc_chrdev_region(&uio_dev, 0, UIO_MAX_DEVICES, name);
+        if (result)
+                goto out;
+
+        result = -ENOMEM;
+        cdev = cdev_alloc();
+        if (!cdev)
+                goto out_unregister;
+
+        cdev->owner = THIS_MODULE;
+        cdev->ops = &uio_fops;
+        kobject_set_name(&cdev->kobj, "%s", name);
+
+        result = cdev_add(cdev, uio_dev, UIO_MAX_DEVICES);
+        if (result)
+                goto out_put;
+
+        uio_major = MAJOR(uio_dev);
+        uio_cdev = cdev;
+        result = 0;
+out:
+        return result;
+out_put:
+        kobject_put(&cdev->kobj);
+out_unregister:
+        unregister_chrdev_region(uio_dev, UIO_MAX_DEVICES);
+        goto out;
 }
 
 static void uio_major_cleanup(void)
 {
-        unregister_chrdev(uio_major, "uio");
+        unregister_chrdev_region(MKDEV(uio_major, 0), UIO_MAX_DEVICES);
+        cdev_del(uio_cdev);
 }
 
 static int init_uio_class(void)
 {
-        int ret = 0;
-
-        if (uio_class != NULL) {
-                kref_get(&uio_class->kref);
-                goto exit;
-        }
+        int ret;
 
         /* This is the first time in here, set everything up properly */
         ret = uio_major_init();
         if (ret)
                 goto exit;
 
-        uio_class = kzalloc(sizeof(*uio_class), GFP_KERNEL);
-        if (!uio_class) {
-                ret = -ENOMEM;
-                goto err_kzalloc;
-        }
-
-        kref_init(&uio_class->kref);
-        uio_class->class = class_create(THIS_MODULE, "uio");
-        if (IS_ERR(uio_class->class)) {
-                ret = IS_ERR(uio_class->class);
-                printk(KERN_ERR "class_create failed for uio\n");
-                goto err_class_create;
+        ret = class_register(&uio_class);
+        if (ret) {
+                printk(KERN_ERR "class_register failed for uio\n");
+                goto err_class_register;
         }
         return 0;
 
-err_class_create:
-        kfree(uio_class);
-        uio_class = NULL;
-err_kzalloc:
+err_class_register:
         uio_major_cleanup();
 exit:
         return ret;
 }
 
-static void release_uio_class(struct kref *kref)
+static void release_uio_class(void)
 {
-        /* Ok, we cheat as we know we only have one uio_class */
-        class_destroy(uio_class->class);
-        kfree(uio_class);
+        class_unregister(&uio_class);
         uio_major_cleanup();
-        uio_class = NULL;
-}
-
-static void uio_class_destroy(void)
-{
-        if (uio_class)
-                kref_put(&uio_class->kref, release_uio_class);
 }
 
 /**
@@ -828,10 +814,6 @@ int __uio_register_device(struct module *owner,
 
         info->uio_dev = NULL;
 
-        ret = init_uio_class();
-        if (ret)
-                return ret;
-
         idev = kzalloc(sizeof(*idev), GFP_KERNEL);
         if (!idev) {
                 ret = -ENOMEM;
@@ -847,7 +829,7 @@ int __uio_register_device(struct module *owner,
         if (ret)
                 goto err_get_minor;
 
-        idev->dev = device_create(uio_class->class, parent,
+        idev->dev = device_create(&uio_class, parent,
                                   MKDEV(uio_major, idev->minor), idev,
                                   "uio%d", idev->minor);
         if (IS_ERR(idev->dev)) {
@@ -862,9 +844,9 @@ int __uio_register_device(struct module *owner,
 
         info->uio_dev = idev;
 
-        if (idev->info->irq >= 0) {
-                ret = request_irq(idev->info->irq, uio_interrupt,
-                                  idev->info->irq_flags, idev->info->name, idev);
+        if (info->irq && (info->irq != UIO_IRQ_CUSTOM)) {
+                ret = request_irq(info->irq, uio_interrupt,
+                                  info->irq_flags, info->name, idev);
                 if (ret)
                         goto err_request_irq;
         }
@@ -874,13 +856,12 @@ int __uio_register_device(struct module *owner,
 err_request_irq:
         uio_dev_del_attributes(idev);
 err_uio_dev_add_attributes:
-        device_destroy(uio_class->class, MKDEV(uio_major, idev->minor));
+        device_destroy(&uio_class, MKDEV(uio_major, idev->minor));
 err_device_create:
         uio_free_minor(idev);
 err_get_minor:
         kfree(idev);
 err_kzalloc:
-        uio_class_destroy();
         return ret;
 }
 EXPORT_SYMBOL_GPL(__uio_register_device);
@@ -901,15 +882,13 @@ void uio_unregister_device(struct uio_info *info)
 
         uio_free_minor(idev);
 
-        if (info->irq >= 0)
+        if (info->irq && (info->irq != UIO_IRQ_CUSTOM))
                 free_irq(info->irq, idev);
 
         uio_dev_del_attributes(idev);
 
-        dev_set_drvdata(idev->dev, NULL);
-        device_destroy(uio_class->class, MKDEV(uio_major, idev->minor));
+        device_destroy(&uio_class, MKDEV(uio_major, idev->minor));
         kfree(idev);
-        uio_class_destroy();
 
         return;
 }
@@ -917,11 +896,12 @@ EXPORT_SYMBOL_GPL(uio_unregister_device);
 
 static int __init uio_init(void)
 {
-        return 0;
+        return init_uio_class();
 }
 
 static void __exit uio_exit(void)
 {
+        release_uio_class();
 }
 
 module_init(uio_init)
diff --git a/drivers/uio/uio_cif.c b/drivers/uio/uio_cif.c
index a8ea2f19a0cc..a84a451159ed 100644
--- a/drivers/uio/uio_cif.c
+++ b/drivers/uio/uio_cif.c
@@ -1,7 +1,7 @@
 /*
  * UIO Hilscher CIF card driver
  *
- * (C) 2007 Hans J. Koch <hjk@linutronix.de>
+ * (C) 2007 Hans J. Koch <hjk@hansjkoch.de>
  * Original code (C) 2005 Benedikt Spranger <b.spranger@linutronix.de>
  *
  * Licensed under GPL version 2 only.
diff --git a/drivers/uio/uio_netx.c b/drivers/uio/uio_netx.c
index 5a18e9f7b836..a879fd5741f8 100644
--- a/drivers/uio/uio_netx.c
+++ b/drivers/uio/uio_netx.c
@@ -2,7 +2,7 @@
  * UIO driver for Hilscher NetX based fieldbus cards (cifX, comX).
  * See http://www.hilscher.com for details.
  *
- * (C) 2007 Hans J. Koch <hjk@linutronix.de>
+ * (C) 2007 Hans J. Koch <hjk@hansjkoch.de>
  * (C) 2008 Manuel Traut <manut@linutronix.de>
  *
  * Licensed under GPL version 2 only.
@@ -18,6 +18,9 @@
 
 #define PCI_VENDOR_ID_HILSCHER          0x15CF
 #define PCI_DEVICE_ID_HILSCHER_NETX     0x0000
+#define PCI_DEVICE_ID_HILSCHER_NETPLC   0x0010
+#define PCI_SUBDEVICE_ID_NETPLC_RAM     0x0000
+#define PCI_SUBDEVICE_ID_NETPLC_FLASH   0x0001
 #define PCI_SUBDEVICE_ID_NXSB_PCA       0x3235
 #define PCI_SUBDEVICE_ID_NXPCA          0x3335
 
@@ -66,6 +69,10 @@ static int __devinit netx_pci_probe(struct pci_dev *dev,
                 bar = 0;
                 info->name = "netx";
                 break;
+        case PCI_DEVICE_ID_HILSCHER_NETPLC:
+                bar = 0;
+                info->name = "netplc";
+                break;
         default:
                 bar = 2;
                 info->name = "netx_plx";
@@ -134,6 +141,18 @@ static struct pci_device_id netx_pci_ids[] = {
                 .subdevice =    0,
         },
         {
+                .vendor =       PCI_VENDOR_ID_HILSCHER,
+                .device =       PCI_DEVICE_ID_HILSCHER_NETPLC,
+                .subvendor =    PCI_VENDOR_ID_HILSCHER,
+                .subdevice =    PCI_SUBDEVICE_ID_NETPLC_RAM,
+        },
+        {
+                .vendor =       PCI_VENDOR_ID_HILSCHER,
+                .device =       PCI_DEVICE_ID_HILSCHER_NETPLC,
+                .subvendor =    PCI_VENDOR_ID_HILSCHER,
+                .subdevice =    PCI_SUBDEVICE_ID_NETPLC_FLASH,
+        },
+        {
                 .vendor =       PCI_VENDOR_ID_PLX,
                 .device =       PCI_DEVICE_ID_PLX_9030,
                 .subvendor =    PCI_VENDOR_ID_PLX,
diff --git a/drivers/uio/uio_pci_generic.c b/drivers/uio/uio_pci_generic.c
index 85c9884a67fd..fc22e1e6f215 100644
--- a/drivers/uio/uio_pci_generic.c
+++ b/drivers/uio/uio_pci_generic.c
@@ -128,12 +128,6 @@ static int __devinit probe(struct pci_dev *pdev,
         struct uio_pci_generic_dev *gdev;
         int err;
 
-        if (!pdev->irq) {
-                dev_warn(&pdev->dev, "No IRQ assigned to device: "
-                         "no support for interrupts?\n");
-                return -ENODEV;
-        }
-
         err = pci_enable_device(pdev);
         if (err) {
                 dev_err(&pdev->dev, "%s: pci_enable_device failed: %d\n",
@@ -141,6 +135,13 @@ static int __devinit probe(struct pci_dev *pdev,
                 return err;
         }
 
+        if (!pdev->irq) {
+                dev_warn(&pdev->dev, "No IRQ assigned to device: "
+                         "no support for interrupts?\n");
+                pci_disable_device(pdev);
+                return -ENODEV;
+        }
+
         err = verify_pci_2_3(pdev);
         if (err)
                 goto err_verify;
diff --git a/drivers/uio/uio_pdrv_genirq.c b/drivers/uio/uio_pdrv_genirq.c
index 7174d518b8a6..0f424af7f109 100644
--- a/drivers/uio/uio_pdrv_genirq.c
+++ b/drivers/uio/uio_pdrv_genirq.c
@@ -189,6 +189,10 @@ static int uio_pdrv_genirq_remove(struct platform_device *pdev)
 
         uio_unregister_device(priv->uioinfo);
         pm_runtime_disable(&pdev->dev);
+
+        priv->uioinfo->handler = NULL;
+        priv->uioinfo->irqcontrol = NULL;
+
         kfree(priv);
         return 0;
 }
diff --git a/drivers/uio/uio_pruss.c b/drivers/uio/uio_pruss.c
new file mode 100644
index 000000000000..e67b566e7aa3
--- /dev/null
+++ b/drivers/uio/uio_pruss.c
@@ -0,0 +1,247 @@
+/*
+ * Programmable Real-Time Unit Sub System (PRUSS) UIO driver (uio_pruss)
+ *
+ * This driver exports PRUSS host event out interrupts and PRUSS, L3 RAM,
+ * and DDR RAM to user space for applications interacting with PRUSS firmware
+ *
+ * Copyright (C) 2010-11 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/platform_device.h>
+#include <linux/uio_driver.h>
+#include <linux/platform_data/uio_pruss.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/dma-mapping.h>
+#include <linux/slab.h>
+#include <mach/sram.h>
+
+#define DRV_NAME "pruss_uio"
+#define DRV_VERSION "1.0"
+
+static int sram_pool_sz = SZ_16K;
+module_param(sram_pool_sz, int, 0);
+MODULE_PARM_DESC(sram_pool_sz, "sram pool size to allocate ");
+
+static int extram_pool_sz = SZ_256K;
+module_param(extram_pool_sz, int, 0);
+MODULE_PARM_DESC(extram_pool_sz, "external ram pool size to allocate");
+
+/*
+ * Host event IRQ numbers from PRUSS - PRUSS can generate up to 8 interrupt
+ * events to AINTC of ARM host processor - which can be used for IPC b/w PRUSS
+ * firmware and user space application, async notification from PRU firmware
+ * to user space application
+ * 3    PRU_EVTOUT0
+ * 4    PRU_EVTOUT1
+ * 5    PRU_EVTOUT2
+ * 6    PRU_EVTOUT3
+ * 7    PRU_EVTOUT4
+ * 8    PRU_EVTOUT5
+ * 9    PRU_EVTOUT6
+ * 10   PRU_EVTOUT7
+*/
+#define MAX_PRUSS_EVT   8
+
+#define PINTC_HIDISR    0x0038
+#define PINTC_HIPIR     0x0900
+#define HIPIR_NOPEND    0x80000000
+#define PINTC_HIER      0x1500
+
+struct uio_pruss_dev {
+        struct uio_info *info;
+        struct clk *pruss_clk;
+        dma_addr_t sram_paddr;
+        dma_addr_t ddr_paddr;
+        void __iomem *prussio_vaddr;
+        void *sram_vaddr;
+        void *ddr_vaddr;
+        unsigned int hostirq_start;
+        unsigned int pintc_base;
+};
+
+static irqreturn_t pruss_handler(int irq, struct uio_info *info)
+{
+        struct uio_pruss_dev *gdev = info->priv;
+        int intr_bit = (irq - gdev->hostirq_start + 2);
+        int val, intr_mask = (1 << intr_bit);
+        void __iomem *base = gdev->prussio_vaddr + gdev->pintc_base;
+        void __iomem *intren_reg = base + PINTC_HIER;
+        void __iomem *intrdis_reg = base + PINTC_HIDISR;
+        void __iomem *intrstat_reg = base + PINTC_HIPIR + (intr_bit << 2);
+
+        val = ioread32(intren_reg);
+        /* Is interrupt enabled and active ? */
+        if (!(val & intr_mask) && (ioread32(intrstat_reg) & HIPIR_NOPEND))
+                return IRQ_NONE;
+        /* Disable interrupt */
+        iowrite32(intr_bit, intrdis_reg);
+        return IRQ_HANDLED;
+}
+
+static void pruss_cleanup(struct platform_device *dev,
+                        struct uio_pruss_dev *gdev)
+{
+        int cnt;
+        struct uio_info *p = gdev->info;
+
+        for (cnt = 0; cnt < MAX_PRUSS_EVT; cnt++, p++) {
+                uio_unregister_device(p);
+                kfree(p->name);
+        }
+        iounmap(gdev->prussio_vaddr);
+        if (gdev->ddr_vaddr) {
+                dma_free_coherent(&dev->dev, extram_pool_sz, gdev->ddr_vaddr,
+                        gdev->ddr_paddr);
+        }
+        if (gdev->sram_vaddr)
+                sram_free(gdev->sram_vaddr, sram_pool_sz);
+        kfree(gdev->info);
+        clk_put(gdev->pruss_clk);
+        kfree(gdev);
+}
+
+static int __devinit pruss_probe(struct platform_device *dev)
+{
+        struct uio_info *p;
+        struct uio_pruss_dev *gdev;
+        struct resource *regs_prussio;
+        int ret = -ENODEV, cnt = 0, len;
+        struct uio_pruss_pdata *pdata = dev->dev.platform_data;
+
+        gdev = kzalloc(sizeof(struct uio_pruss_dev), GFP_KERNEL);
+        if (!gdev)
+                return -ENOMEM;
+
+        gdev->info = kzalloc(sizeof(*p) * MAX_PRUSS_EVT, GFP_KERNEL);
+        if (!gdev->info) {
+                kfree(gdev);
+                return -ENOMEM;
+        }
+        /* Power on PRU in case its not done as part of boot-loader */
+        gdev->pruss_clk = clk_get(&dev->dev, "pruss");
+        if (IS_ERR(gdev->pruss_clk)) {
+                dev_err(&dev->dev, "Failed to get clock\n");
+                kfree(gdev->info);
+                kfree(gdev);
+                ret = PTR_ERR(gdev->pruss_clk);
+                return ret;
+        } else {
+                clk_enable(gdev->pruss_clk);
+        }
+
+        regs_prussio = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!regs_prussio) {
+                dev_err(&dev->dev, "No PRUSS I/O resource specified\n");
+                goto out_free;
+        }
+
+        if (!regs_prussio->start) {
+                dev_err(&dev->dev, "Invalid memory resource\n");
+                goto out_free;
+        }
+
+        gdev->sram_vaddr = sram_alloc(sram_pool_sz, &(gdev->sram_paddr));
+        if (!gdev->sram_vaddr) {
+                dev_err(&dev->dev, "Could not allocate SRAM pool\n");
+                goto out_free;
+        }
+
+        gdev->ddr_vaddr = dma_alloc_coherent(&dev->dev, extram_pool_sz,
+                                &(gdev->ddr_paddr), GFP_KERNEL | GFP_DMA);
+        if (!gdev->ddr_vaddr) {
+                dev_err(&dev->dev, "Could not allocate external memory\n");
+                goto out_free;
+        }
+
+        len = resource_size(regs_prussio);
+        gdev->prussio_vaddr = ioremap(regs_prussio->start, len);
+        if (!gdev->prussio_vaddr) {
+                dev_err(&dev->dev, "Can't remap PRUSS I/O  address range\n");
+                goto out_free;
+        }
+
+        gdev->pintc_base = pdata->pintc_base;
+        gdev->hostirq_start = platform_get_irq(dev, 0);
+
+        for (cnt = 0, p = gdev->info; cnt < MAX_PRUSS_EVT; cnt++, p++) {
+                p->mem[0].addr = regs_prussio->start;
+                p->mem[0].size = resource_size(regs_prussio);
+                p->mem[0].memtype = UIO_MEM_PHYS;
+
+                p->mem[1].addr = gdev->sram_paddr;
+                p->mem[1].size = sram_pool_sz;
+                p->mem[1].memtype = UIO_MEM_PHYS;
+
+                p->mem[2].addr = gdev->ddr_paddr;
+                p->mem[2].size = extram_pool_sz;
+                p->mem[2].memtype = UIO_MEM_PHYS;
+
+                p->name = kasprintf(GFP_KERNEL, "pruss_evt%d", cnt);
+                p->version = DRV_VERSION;
+
+                /* Register PRUSS IRQ lines */
+                p->irq = gdev->hostirq_start + cnt;
+                p->handler = pruss_handler;
+                p->priv = gdev;
+
+                ret = uio_register_device(&dev->dev, p);
+                if (ret < 0)
+                        goto out_free;
+        }
+
+        platform_set_drvdata(dev, gdev);
+        return 0;
+
+out_free:
+        pruss_cleanup(dev, gdev);
+        return ret;
+}
+
+static int __devexit pruss_remove(struct platform_device *dev)
+{
+        struct uio_pruss_dev *gdev = platform_get_drvdata(dev);
+
+        pruss_cleanup(dev, gdev);
+        platform_set_drvdata(dev, NULL);
+        return 0;
+}
+
+static struct platform_driver pruss_driver = {
+        .probe = pruss_probe,
+        .remove = __devexit_p(pruss_remove),
+        .driver = {
+                   .name = DRV_NAME,
+                   .owner = THIS_MODULE,
+                   },
+};
+
+static int __init pruss_init_module(void)
+{
+        return platform_driver_register(&pruss_driver);
+}
+
+module_init(pruss_init_module);
+
+static void __exit pruss_exit_module(void)
+{
+        platform_driver_unregister(&pruss_driver);
+}
+
+module_exit(pruss_exit_module);
+
+MODULE_LICENSE("GPL v2");
+MODULE_VERSION(DRV_VERSION);
+MODULE_AUTHOR("Amit Chatterjee <amit.chatterjee@ti.com>");
+MODULE_AUTHOR("Pratheesh Gangadhar <pratheesh@ti.com>");