1 files changed, 109 insertions, 4 deletions

diff --git a/drivers/dma/qcom/hidma_mgmt.c b/drivers/dma/qcom/hidma_mgmt.c
index ef491b893f40..c0e365321310 100644
--- a/drivers/dma/qcom/hidma_mgmt.c
+++ b/drivers/dma/qcom/hidma_mgmt.c
@@ -1,7 +1,7 @@
 /*
  * Qualcomm Technologies HIDMA DMA engine Management interface
  *
- * Copyright (c) 2015, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
@@ -17,13 +17,14 @@
 #include <linux/acpi.h>
 #include <linux/of.h>
 #include <linux/property.h>
-#include <linux/interrupt.h>
-#include <linux/platform_device.h>
+#include <linux/of_irq.h>
+#include <linux/of_platform.h>
 #include <linux/module.h>
 #include <linux/uaccess.h>
 #include <linux/slab.h>
 #include <linux/pm_runtime.h>
 #include <linux/bitops.h>
+#include <linux/dma-mapping.h>
 
 #include "hidma_mgmt.h"
 
@@ -298,5 +299,109 @@ static struct platform_driver hidma_mgmt_driver = {
         },
 };
 
-module_platform_driver(hidma_mgmt_driver);
+#if defined(CONFIG_OF) && defined(CONFIG_OF_IRQ)
+static int object_counter;
+
+static int __init hidma_mgmt_of_populate_channels(struct device_node *np)
+{
+        struct platform_device *pdev_parent = of_find_device_by_node(np);
+        struct platform_device_info pdevinfo;
+        struct of_phandle_args out_irq;
+        struct device_node *child;
+        struct resource *res;
+        const __be32 *cell;
+        int ret = 0, size, i, num;
+        u64 addr, addr_size;
+
+        for_each_available_child_of_node(np, child) {
+                struct resource *res_iter;
+                struct platform_device *new_pdev;
+
+                cell = of_get_property(child, "reg", &size);
+                if (!cell) {
+                        ret = -EINVAL;
+                        goto out;
+                }
+
+                size /= sizeof(*cell);
+                num = size /
+                        (of_n_addr_cells(child) + of_n_size_cells(child)) + 1;
+
+                /* allocate a resource array */
+                res = kcalloc(num, sizeof(*res), GFP_KERNEL);
+                if (!res) {
+                        ret = -ENOMEM;
+                        goto out;
+                }
+
+                /* read each reg value */
+                i = 0;
+                res_iter = res;
+                while (i < size) {
+                        addr = of_read_number(&cell[i],
+                                              of_n_addr_cells(child));
+                        i += of_n_addr_cells(child);
+
+                        addr_size = of_read_number(&cell[i],
+                                                   of_n_size_cells(child));
+                        i += of_n_size_cells(child);
+
+                        res_iter->start = addr;
+                        res_iter->end = res_iter->start + addr_size - 1;
+                        res_iter->flags = IORESOURCE_MEM;
+                        res_iter++;
+                }
+
+                ret = of_irq_parse_one(child, 0, &out_irq);
+                if (ret)
+                        goto out;
+
+                res_iter->start = irq_create_of_mapping(&out_irq);
+                res_iter->name = "hidma event irq";
+                res_iter->flags = IORESOURCE_IRQ;
+
+                memset(&pdevinfo, 0, sizeof(pdevinfo));
+                pdevinfo.fwnode = &child->fwnode;
+                pdevinfo.parent = pdev_parent ? &pdev_parent->dev : NULL;
+                pdevinfo.name = child->name;
+                pdevinfo.id = object_counter++;
+                pdevinfo.res = res;
+                pdevinfo.num_res = num;
+                pdevinfo.data = NULL;
+                pdevinfo.size_data = 0;
+                pdevinfo.dma_mask = DMA_BIT_MASK(64);
+                new_pdev = platform_device_register_full(&pdevinfo);
+                if (!new_pdev) {
+                        ret = -ENODEV;
+                        goto out;
+                }
+                of_dma_configure(&new_pdev->dev, child);
+
+                kfree(res);
+                res = NULL;
+        }
+out:
+        kfree(res);
+
+        return ret;
+}
+#endif
+
+static int __init hidma_mgmt_init(void)
+{
+#if defined(CONFIG_OF) && defined(CONFIG_OF_IRQ)
+        struct device_node *child;
+
+        for (child = of_find_matching_node(NULL, hidma_mgmt_match); child;
+             child = of_find_matching_node(child, hidma_mgmt_match)) {
+                /* device tree based firmware here */
+                hidma_mgmt_of_populate_channels(child);
+                of_node_put(child);
+        }
+#endif
+        platform_driver_register(&hidma_mgmt_driver);
+
+        return 0;
+}
+module_init(hidma_mgmt_init);
 MODULE_LICENSE("GPL v2");