From: Jianqun xu <jay.xu@rock-chips.com>
Date: Mon, 30 Nov 2015 06:16:53 +0000 (+0800)
Subject: staging: ion: rockchip-ion make codingstyle
X-Git-Tag: firefly_0821_release~3576
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=8f09cde6a2612a8f07b033a18f0579169e8a9c95;p=firefly-linux-kernel-4.4.55.git

staging: ion: rockchip-ion make codingstyle

Change-Id: I8f61b9af34c9acf82203dc188e8d19e09b007ad9
Signed-off-by: Jianqun xu <jay.xu@rock-chips.com>
---

diff --git a/drivers/staging/android/ion/rockchip/rockchip_ion.c b/drivers/staging/android/ion/rockchip/rockchip_ion.c
index 7df4d05e635e..c3e6da57de7f 100644
--- a/drivers/staging/android/ion/rockchip/rockchip_ion.c
+++ b/drivers/staging/android/ion/rockchip/rockchip_ion.c
@@ -1,7 +1,7 @@
 /*
- * drivers/gpu/rockchip/rockchip_ion.c
+ * drivers/staging/android/ion/rockchip/rockchip_ion.c
  *
- * Copyright (C) 2011 Google, Inc.
+ * Copyright (C) 2014 ROCKCHIP, Inc.
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
@@ -14,29 +14,20 @@
  *
  */
 
-#include <linux/err.h>
+#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
-#include <linux/rockchip_ion.h>
 #include <linux/uaccess.h>
-#include "../ion_priv.h"
+#include <linux/compat.h>
 #include <linux/dma-buf.h>
 #include <linux/dma-contiguous.h>
 #include <linux/memblock.h>
-
-#ifdef CONFIG_OF
-#include <linux/of.h>
 #include <linux/of_gpio.h>
-#include <video/of_display_timing.h>
-#include <linux/of_fdt.h>
-#endif
-
-#include <linux/compat.h>
+#include <linux/rockchip_ion.h>
 
-struct ion_device *rockchip_ion_dev;
-EXPORT_SYMBOL(rockchip_ion_dev);
+#include "../ion_priv.h"
 
-static int num_heaps;
+static struct ion_device *idev;
 static struct ion_heap **heaps;
 
 struct ion_heap_desc {
@@ -45,71 +36,22 @@ struct ion_heap_desc {
 	const char *name;
 };
 
-extern struct ion_handle *ion_handle_get_by_id(struct ion_client *client,
- 						int id);
-extern int ion_handle_put(struct ion_handle *handle);
-
-#define ION_CMA_HEAP_NAME		"cma"
-#define ION_VMALLOC_HEAP_NAME		"vmalloc"
-#define ION_CARVEOUT_HEAP_NAME		"carveout"
-
-#define MAX_ION_HEAP		10
-
-static struct ion_platform_heap ion_plat_heap[MAX_ION_HEAP];
-struct ion_platform_data ion_pdata = {
-	.nr = 0,
-	.heaps = ion_plat_heap,
-};
-
 static struct ion_heap_desc ion_heap_meta[] = {
 	{
-		.id	= ION_VMALLOC_HEAP_ID,
+		.id	= ION_HEAP_TYPE_SYSTEM,
 		.type	= ION_HEAP_TYPE_SYSTEM,
-		.name	= ION_VMALLOC_HEAP_NAME,
-	},
-	{
-		.id	= ION_CMA_HEAP_ID,
-		.type	= ION_HEAP_TYPE_DMA,
-		.name	= ION_CMA_HEAP_NAME,
-	},
-	{
-		.id 	= ION_CARVEOUT_HEAP_ID,
+		.name	= "system-heap",
+	}, {
+		.id	= ION_HEAP_TYPE_CARVEOUT,
 		.type	= ION_HEAP_TYPE_CARVEOUT,
-		.name	= ION_CARVEOUT_HEAP_NAME,
+		.name	= "carveout-heap",
+	}, {
+		.id	= ION_HEAP_TYPE_DMA,
+		.type	= ION_HEAP_TYPE_DMA,
+		.name	= "cma-heap",
 	},
 };
 
-struct device rockchip_ion_cma_dev = {
-	.coherent_dma_mask = DMA_BIT_MASK(32),
-	.init_name = "rockchip_ion_cma",
-};
-
-static int rockchip_ion_populate_heap(struct ion_platform_heap *heap)
-{
-	unsigned int i;
-	int ret = -EINVAL;
-	unsigned int len = ARRAY_SIZE(ion_heap_meta);
-	for (i = 0; i < len; ++i) {
-		if (ion_heap_meta[i].id == heap->id) {
-			heap->name = ion_heap_meta[i].name;
-			heap->type = ion_heap_meta[i].type;
-			if(heap->id == ION_CMA_HEAP_ID)
-				heap->priv = &rockchip_ion_cma_dev;
-			ret = 0;
-			break;
-		}
-	}
-	if (ret)
-		pr_err("%s: Unable to populate heap, error: %d", __func__, ret);
-	return ret;
-}
-
-struct ion_client *rockchip_ion_client_create(const char *name)
-{
-	return ion_client_create(rockchip_ion_dev, name);
-}
-EXPORT_SYMBOL(rockchip_ion_client_create);
-
 #ifdef CONFIG_COMPAT
 struct compat_ion_phys_data {
 	compat_int_t handle;
@@ -117,12 +59,12 @@ struct compat_ion_phys_data {
 	compat_ulong_t size;
 };
 
-#define COMPAT_ION_IOC_GET_PHYS	_IOWR(ION_IOC_ROCKCHIP_MAGIC, 0, \
-						struct compat_ion_phys_data)
+#define COMPAT_ION_IOC_GET_PHYS _IOWR(ION_IOC_ROCKCHIP_MAGIC, 0, \
+				struct compat_ion_phys_data)
 
 static int compat_get_ion_phys_data(
-			struct compat_ion_phys_data __user *data32,
-			struct ion_phys_data __user *data)
+		struct compat_ion_phys_data __user *data32,
+		struct ion_phys_data __user *data)
 {
 	compat_ulong_t l;
 	compat_int_t i;
@@ -139,8 +81,8 @@ static int compat_get_ion_phys_data(
 };
 
 static int compat_put_ion_phys_data(
-			struct compat_ion_phys_data __user *data32,
-			struct ion_phys_data __user *data)
+		struct compat_ion_phys_data __user *data32,
+		struct ion_phys_data __user *data)
 {
 	compat_ulong_t l;
 	compat_int_t i;
@@ -157,7 +99,8 @@ static int compat_put_ion_phys_data(
 };
 #endif
 
-static int rockchip_ion_get_phys(struct ion_client *client, unsigned long arg)
+static int rk_ion_get_phys(struct ion_client *client,
+			   unsigned long arg)
 {
 	struct ion_phys_data data;
 	struct ion_handle *handle;
@@ -171,8 +114,8 @@ static int rockchip_ion_get_phys(struct ion_client *client, unsigned long arg)
 	if (IS_ERR(handle))
 		return PTR_ERR(handle);
 
-	ret = ion_phys(client, handle, &data.phys, (size_t *)&data.size);
-	pr_debug("ret=%d, phys=0x%lX\n", ret, data.phys);
+	ret = ion_phys(client, handle, &data.phys,
+		       (size_t *)&data.size);
 	ion_handle_put(handle);
 	if (ret < 0)
 		return ret;
@@ -183,182 +126,204 @@ static int rockchip_ion_get_phys(struct ion_client *client, unsigned long arg)
 	return 0;
 }
 
-static long rockchip_custom_ioctl (struct ion_client *client, unsigned int cmd,
-			      unsigned long arg)
+#ifdef CONFIG_COMPAT
+static int compat_rk_ion_get_phys(struct ion_client *client,
+				  unsigned long arg)
 {
-	pr_debug("%s(%d): cmd=%x\n", __func__, __LINE__, cmd);
+	struct compat_ion_phys_data __user *data32;
+	struct ion_phys_data __user *data;
+	int err;
+	long ret;
+
+	data32 = compat_ptr(arg);
+	data = compat_alloc_user_space(sizeof(*data));
+	if (!data)
+		return -EFAULT;
+
+	err = compat_get_ion_phys_data(data32, data);
+	if (err)
+		return err;
 
-	if (is_compat_task()) {
+	ret = rk_ion_get_phys(client, (unsigned long)data);
+	err = compat_put_ion_phys_data(data32, data);
+
+	return ret ? ret : err;
+}
+#endif
+
+static long rk_custom_ioctl(struct ion_client *client,
+			    unsigned int cmd,
+			    unsigned long arg)
+{
+	int ret = 0;
+
+	switch (cmd) {
 #ifdef CONFIG_COMPAT
-		long ret;
-		switch (cmd) {
-		case COMPAT_ION_IOC_GET_PHYS: {
-			struct compat_ion_phys_data __user *data32;
-			struct ion_phys_data __user *data;
-			int err;
-
-			data32 = compat_ptr(arg);
-			data = compat_alloc_user_space(sizeof(*data));
-			if (data == NULL)
-				return -EFAULT;
-
-			err = compat_get_ion_phys_data(data32, data);
-			if (err)
-				return err;
-
-			ret = rockchip_ion_get_phys(client,
-						    (unsigned long)data);
-
-			err = compat_put_ion_phys_data(data32, data);
-			return ret ? ret : err;
-		}
-		default:
-			return -ENOTTY;
-		}
+	case COMPAT_ION_IOC_GET_PHYS:
+		ret = compat_rk_ion_get_phys(client, arg);
+		break;
 #endif
-	} else {
-		switch (cmd) {
-		case ION_IOC_GET_PHYS:
-			return rockchip_ion_get_phys(client, arg);
-		default:
-			return -ENOTTY;
+	case ION_IOC_GET_PHYS:
+		ret = rk_ion_get_phys(client, arg);
+		break;
+	default:
+		return -ENOTTY;
+	}
+
+	return ret;
+}
+
+/* Return result of step for heap array. */
+static int rk_ion_of_heap(struct ion_platform_heap *myheap,
+			  struct device_node *node)
+{
+	int itype;
+
+	for (itype = 0; itype < ARRAY_SIZE(ion_heap_meta); itype++) {
+		if (strcmp(ion_heap_meta[itype].name, node->name))
+			continue;
+
+		myheap->name = node->name;
+		myheap->align = SZ_1M;
+		myheap->id = ion_heap_meta[itype].id;
+		if (!strcmp("system-heap", node->name)) {
+			myheap->type = ION_HEAP_TYPE_SYSTEM;
+			return 1;
 		}
 	}
-	
+
 	return 0;
 }
 
-static int rockchip_ion_probe(struct platform_device *pdev)
+static struct ion_platform_data *rk_ion_of(struct device_node *node)
 {
 	struct ion_platform_data *pdata;
-	struct ion_device *idev;
-	int err;
-	int i;
+	int iheap = 0;
+	struct device_node *child;
+	struct ion_platform_heap *myheap;
+
+	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+	if (!pdata)
+		return NULL;
+
+	pdata->nr = of_get_child_count(node);
+again:
+	pdata->heaps = kcalloc(pdata->nr, sizeof(*myheap), GFP_KERNEL);
+	for_each_child_of_node(node, child) {
+		iheap += rk_ion_of_heap(&pdata->heaps[iheap], child);
+	}
 
-	err = device_register(&rockchip_ion_cma_dev);
-	if (err) {
-		pr_err("Could not register %s\n", dev_name(&rockchip_ion_cma_dev));
-		return err;
+	if (pdata->nr != iheap) {
+		pdata->nr = iheap;
+		iheap = 0;
+		kfree(pdata->heaps);
+		pr_err("%s: mismatch, repeating\n", __func__);
+		goto again;
 	}
 
-	if (pdev->dev.of_node) {
-		pdata = &ion_pdata;
-		if (IS_ERR(pdata)) {
-			return PTR_ERR(pdata);
-		}
-	} else {
-		pdata = pdev->dev.platform_data;
+	return pdata;
+}
+
+static int rk_ion_probe(struct platform_device *pdev)
+{
+	int err;
+	int i;
+	struct ion_platform_data *pdata = pdev->dev.platform_data;
+
+	if (!pdata) {
+		pdata = rk_ion_of(pdev->dev.of_node);
+		pdev->dev.platform_data = pdata;
 	}
 
-	num_heaps = pdata->nr;
-	heaps = kzalloc(sizeof(struct ion_heap *) * num_heaps, GFP_KERNEL);
+	heaps = kcalloc(pdata->nr, sizeof(*heaps), GFP_KERNEL);
 
-	idev = ion_device_create(rockchip_custom_ioctl);
+	idev = ion_device_create(rk_custom_ioctl);
 	if (IS_ERR_OR_NULL(idev)) {
 		kfree(heaps);
 		return PTR_ERR(idev);
 	}
-	rockchip_ion_dev = idev;
+
 	/* create the heaps as specified in the board file */
-	for (i = 0; i < num_heaps; i++) {
+	for (i = 0; i < pdata->nr; i++) {
 		struct ion_platform_heap *heap_data = &pdata->heaps[i];
 
+		heap_data->priv = &pdev->dev;
 		heaps[i] = ion_heap_create(heap_data);
 		if (IS_ERR_OR_NULL(heaps[i])) {
 			err = PTR_ERR(heaps[i]);
 			goto err;
 		}
+		pr_info("rockchip ion: success to create - %s\n",
+			heaps[i]->name);
 		ion_device_add_heap(idev, heaps[i]);
 	}
 	platform_set_drvdata(pdev, idev);
 
-	pr_info("Rockchip ion module is successfully loaded (%s)\n", ROCKCHIP_ION_VERSION);
 	return 0;
 err:
-	for (i = 0; i < num_heaps; i++) {
+	for (i = 0; i < pdata->nr; i++) {
 		if (heaps[i])
-		ion_heap_destroy(heaps[i]);
+			ion_heap_destroy(heaps[i]);
 	}
+
 	kfree(heaps);
 	return err;
 }
 
-static int rockchip_ion_remove(struct platform_device *pdev)
+static int rk_ion_remove(struct platform_device *pdev)
 {
+	struct ion_platform_data *pdata = pdev->dev.platform_data;
 	struct ion_device *idev = platform_get_drvdata(pdev);
 	int i;
 
 	ion_device_destroy(idev);
-	for (i = 0; i < num_heaps; i++)
+	for (i = 0; i < pdata->nr; i++)
 		ion_heap_destroy(heaps[i]);
+
 	kfree(heaps);
 	return 0;
 }
 
-int __init rockchip_ion_find_heap(unsigned long node, const char *uname,
-				int depth, void *data)
+struct ion_client *rockchip_ion_client_create(const char *name)
 {
-	const __be32 *prop;
-	int len;
-	struct ion_platform_heap* heap;
-	struct ion_platform_data* pdata = (struct ion_platform_data*)data;
-
-	if (pdata==NULL || pdata->nr >= MAX_ION_HEAP) {
-		// break now
-		pr_err("ion heap is too much!\n");
-		return 1;
+	if (!idev) {
+		pr_err("rockchip ion idev is NULL\n");
+		return NULL;
 	}
 
-	if (!of_flat_dt_is_compatible(node, "rockchip,ion-heap"))
-		return 0;
-
-	prop = of_get_flat_dt_prop(node, "rockchip,ion_heap", &len);
-	if (!prop || (len != sizeof(__be32)))
-		return 0;
-
-	heap = &pdata->heaps[pdata->nr++];
-	heap->base = heap->size = heap->align = 0;
-	heap->id = be32_to_cpu(prop[0]);
-	rockchip_ion_populate_heap(heap);
-
-	prop = of_get_flat_dt_prop(node, "reg", &len);
-	if (prop && (len >= 2*sizeof(__be32))) {
-		heap->base = be32_to_cpu(prop[0]);
-		heap->size = be32_to_cpu(prop[1]);
-		if (len==3*sizeof(__be32))
-			heap->align = be32_to_cpu(prop[2]);
-	}
-
-	pr_info("ion heap(%s): base(%lx) size(%zx) align(%lx)\n", heap->name,
-			heap->base, heap->size, heap->align);
-	return 0;
+	return ion_client_create(idev, name);
 }
+EXPORT_SYMBOL_GPL(rockchip_ion_client_create);
 
-static const struct of_device_id rockchip_ion_dt_ids[] = {
+static const struct of_device_id rk_ion_match[] = {
 	{ .compatible = "rockchip,ion", },
 	{}
 };
 
 static struct platform_driver ion_driver = {
-	.probe = rockchip_ion_probe,
-	.remove = rockchip_ion_remove,
+	.probe = rk_ion_probe,
+	.remove = rk_ion_remove,
 	.driver = {
-		.name = "ion-rockchip",
-		.owner	= THIS_MODULE,
-		.of_match_table = of_match_ptr(rockchip_ion_dt_ids),
+		.name = "ion-rk",
+		.owner = THIS_MODULE,
+		.of_match_table = of_match_ptr(rk_ion_match),
 	},
 };
 
-static int __init ion_init(void)
+static int __init rk_ion_init(void)
 {
 	return platform_driver_register(&ion_driver);
 }
 
-static void __exit ion_exit(void)
+static void __exit rk_ion_exit(void)
 {
 	platform_driver_unregister(&ion_driver);
 }
 
-subsys_initcall(ion_init);
-module_exit(ion_exit);
+subsys_initcall(rk_ion_init);
+module_exit(rk_ion_exit);
 
+MODULE_AUTHOR("Meiyou.chen <cmy@rock-chips.com>");
+MODULE_DESCRIPTION("ROCKCHIP Ion driver");
+MODULE_LICENSE("GPL v2");
+MODULE_DEVICE_TABLE(of, rk_ion_match);
diff --git a/include/linux/rockchip_ion.h b/include/linux/rockchip_ion.h
index 2961bae292ff..d8b8b67bf11f 100644
--- a/include/linux/rockchip_ion.h
+++ b/include/linux/rockchip_ion.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
+ * Copyright (C) 2014 ROCKCHIP, Inc.
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
@@ -22,19 +22,6 @@
 #include <linux/ion.h>
 #endif
 
-#define ROCKCHIP_ION_VERSION	"v1.1"
-
-/*
- * ion_heap_ids order by ion_heap_type
- */
-enum ion_heap_ids {
-       ION_VMALLOC_HEAP_ID = 0,
-       ION_CARVEOUT_HEAP_ID = 2,
-       ION_CMA_HEAP_ID = 4,
-};
-
-#define ION_HEAP(bit) (1 << (bit))
-
 struct ion_phys_data {
 	ion_user_handle_t handle;
 	unsigned long phys;
@@ -43,9 +30,10 @@ struct ion_phys_data {
 
 #define ION_IOC_ROCKCHIP_MAGIC 'R'
 
-/**
- * Get phys addr of the handle specified.
- */
+/* Get phys addr of the handle specified. */
 #define ION_IOC_GET_PHYS	_IOWR(ION_IOC_ROCKCHIP_MAGIC, 0, \
 						struct ion_phys_data)
+
+struct ion_client *rockchip_ion_client_create(const char *name);
+
 #endif