[mirror_ubuntu-artful-kernel.git] / drivers / staging / android / ion / ion_dummy_driver.c

/*
 * drivers/gpu/ion/ion_dummy_driver.c
 *
 * Copyright (C) 2013 Linaro, Inc
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/bootmem.h>
#include <linux/memblock.h>
#include <linux/sizes.h>
#include <linux/io.h>
#include "ion.h"
#include "ion_priv.h"

struct ion_device *idev;
struct ion_heap **heaps;

void *carveout_ptr;
void *chunk_ptr;

struct ion_platform_heap dummy_heaps[] = {
		{
			.id	= ION_HEAP_TYPE_SYSTEM,
			.type	= ION_HEAP_TYPE_SYSTEM,
			.name	= "system",
		},
		{
			.id	= ION_HEAP_TYPE_SYSTEM_CONTIG,
			.type	= ION_HEAP_TYPE_SYSTEM_CONTIG,
			.name	= "system contig",
		},
		{
			.id	= ION_HEAP_TYPE_CARVEOUT,
			.type	= ION_HEAP_TYPE_CARVEOUT,
			.name	= "carveout",
			.size	= SZ_4M,
		},
		{
			.id	= ION_HEAP_TYPE_CHUNK,
			.type	= ION_HEAP_TYPE_CHUNK,
			.name	= "chunk",
			.size	= SZ_4M,
			.align	= SZ_16K,
			.priv	= (void *)(SZ_16K),
		},
};

struct ion_platform_data dummy_ion_pdata = {
	.nr = ARRAY_SIZE(dummy_heaps),
	.heaps = dummy_heaps,
};

static int __init ion_dummy_init(void)
{
	int i, err;

	idev = ion_device_create(NULL);
	heaps = kzalloc(sizeof(struct ion_heap *) * dummy_ion_pdata.nr,
			GFP_KERNEL);
	if (!heaps)
		return -ENOMEM;


	/* Allocate a dummy carveout heap */
	carveout_ptr = alloc_pages_exact(
				dummy_heaps[ION_HEAP_TYPE_CARVEOUT].size,
				GFP_KERNEL);
	if (carveout_ptr)
		dummy_heaps[ION_HEAP_TYPE_CARVEOUT].base =
						virt_to_phys(carveout_ptr);
	else
		pr_err("ion_dummy: Could not allocate carveout\n");

	/* Allocate a dummy chunk heap */
	chunk_ptr = alloc_pages_exact(
				dummy_heaps[ION_HEAP_TYPE_CHUNK].size,
				GFP_KERNEL);
	if (chunk_ptr)
		dummy_heaps[ION_HEAP_TYPE_CHUNK].base = virt_to_phys(chunk_ptr);
	else
		pr_err("ion_dummy: Could not allocate chunk\n");

	for (i = 0; i < dummy_ion_pdata.nr; i++) {
		struct ion_platform_heap *heap_data = &dummy_ion_pdata.heaps[i];

		if (heap_data->type == ION_HEAP_TYPE_CARVEOUT &&
							!heap_data->base)
			continue;

		if (heap_data->type == ION_HEAP_TYPE_CHUNK && !heap_data->base)
			continue;

		heaps[i] = ion_heap_create(heap_data);
		if (IS_ERR_OR_NULL(heaps[i])) {
			err = PTR_ERR(heaps[i]);
			goto err;
		}
		ion_device_add_heap(idev, heaps[i]);
	}
	return 0;
err:
	for (i = 0; i < dummy_ion_pdata.nr; i++) {
		if (heaps[i])
			ion_heap_destroy(heaps[i]);
	}
	kfree(heaps);

	if (carveout_ptr) {
		free_pages_exact(carveout_ptr,
				dummy_heaps[ION_HEAP_TYPE_CARVEOUT].size);
		carveout_ptr = NULL;
	}
	if (chunk_ptr) {
		free_pages_exact(chunk_ptr,
				dummy_heaps[ION_HEAP_TYPE_CHUNK].size);
		chunk_ptr = NULL;
	}
	return err;
}
device_initcall(ion_dummy_init);

static void __exit ion_dummy_exit(void)
{
	int i;

	ion_device_destroy(idev);

	for (i = 0; i < dummy_ion_pdata.nr; i++)
		ion_heap_destroy(heaps[i]);
	kfree(heaps);

	if (carveout_ptr) {
		free_pages_exact(carveout_ptr,
				dummy_heaps[ION_HEAP_TYPE_CARVEOUT].size);
		carveout_ptr = NULL;
	}
	if (chunk_ptr) {
		free_pages_exact(chunk_ptr,
				dummy_heaps[ION_HEAP_TYPE_CHUNK].size);
		chunk_ptr = NULL;
	}

	return;
}
__exitcall(ion_dummy_exit);
Commit	Line	Data
1184ead8 JS	1	/*
	2	* drivers/gpu/ion/ion_dummy_driver.c
	3	*
	4	* Copyright (C) 2013 Linaro, Inc
	5	*
	6	* This software is licensed under the terms of the GNU General Public
	7	* License version 2, as published by the Free Software Foundation, and
	8	* may be copied, distributed, and modified under those terms.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	*/
	16
	17	#include <linux/err.h>
	18	#include <linux/platform_device.h>
	19	#include <linux/slab.h>
102f1a2a	20	#include <linux/init.h>
1184ead8 JS	21	#include <linux/bootmem.h>
	22	#include <linux/memblock.h>
	23	#include <linux/sizes.h>
10f6f9c3	24	#include <linux/io.h>
1184ead8 JS	25	#include "ion.h"
	26	#include "ion_priv.h"
	27
	28	struct ion_device *idev;
	29	struct ion_heap **heaps;
	30
4c45b1a8 JS	31	void *carveout_ptr;
	32	void *chunk_ptr;
	33
1184ead8 JS	34	struct ion_platform_heap dummy_heaps[] = {
	35	{
	36	.id = ION_HEAP_TYPE_SYSTEM,
	37	.type = ION_HEAP_TYPE_SYSTEM,
	38	.name = "system",
	39	},
	40	{
	41	.id = ION_HEAP_TYPE_SYSTEM_CONTIG,
	42	.type = ION_HEAP_TYPE_SYSTEM_CONTIG,
	43	.name = "system contig",
	44	},
4c45b1a8 JS	45	{
	46	.id = ION_HEAP_TYPE_CARVEOUT,
	47	.type = ION_HEAP_TYPE_CARVEOUT,
	48	.name = "carveout",
	49	.size = SZ_4M,
	50	},
	51	{
	52	.id = ION_HEAP_TYPE_CHUNK,
	53	.type = ION_HEAP_TYPE_CHUNK,
	54	.name = "chunk",
	55	.size = SZ_4M,
	56	.align = SZ_16K,
	57	.priv = (void *)(SZ_16K),
	58	},
1184ead8 JS	59	};
	60
	61	struct ion_platform_data dummy_ion_pdata = {
18691f53	62	.nr = ARRAY_SIZE(dummy_heaps),
1184ead8 JS	63	.heaps = dummy_heaps,
	64	};
	65
	66	static int __init ion_dummy_init(void)
	67	{
	68	int i, err;
	69
	70	idev = ion_device_create(NULL);
	71	heaps = kzalloc(sizeof(struct ion_heap ) dummy_ion_pdata.nr,
	72	GFP_KERNEL);
	73	if (!heaps)
630127f3	74	return -ENOMEM;
1184ead8	75
4c45b1a8 JS	76
	77	/* Allocate a dummy carveout heap */
	78	carveout_ptr = alloc_pages_exact(
	79	dummy_heaps[ION_HEAP_TYPE_CARVEOUT].size,
	80	GFP_KERNEL);
	81	if (carveout_ptr)
	82	dummy_heaps[ION_HEAP_TYPE_CARVEOUT].base =
	83	virt_to_phys(carveout_ptr);
	84	else
	85	pr_err("ion_dummy: Could not allocate carveout\n");
	86
	87	/* Allocate a dummy chunk heap */
	88	chunk_ptr = alloc_pages_exact(
	89	dummy_heaps[ION_HEAP_TYPE_CHUNK].size,
	90	GFP_KERNEL);
	91	if (chunk_ptr)
	92	dummy_heaps[ION_HEAP_TYPE_CHUNK].base = virt_to_phys(chunk_ptr);
	93	else
	94	pr_err("ion_dummy: Could not allocate chunk\n");
	95
1184ead8 JS	96	for (i = 0; i < dummy_ion_pdata.nr; i++) {
	97	struct ion_platform_heap *heap_data = &dummy_ion_pdata.heaps[i];
	98
4c45b1a8 JS	99	if (heap_data->type == ION_HEAP_TYPE_CARVEOUT &&
	100	!heap_data->base)
	101	continue;
	102
	103	if (heap_data->type == ION_HEAP_TYPE_CHUNK && !heap_data->base)
	104	continue;
	105
1184ead8 JS	106	heaps[i] = ion_heap_create(heap_data);
	107	if (IS_ERR_OR_NULL(heaps[i])) {
	108	err = PTR_ERR(heaps[i]);
	109	goto err;
	110	}
	111	ion_device_add_heap(idev, heaps[i]);
	112	}
	113	return 0;
	114	err:
	115	for (i = 0; i < dummy_ion_pdata.nr; i++) {
	116	if (heaps[i])
	117	ion_heap_destroy(heaps[i]);
	118	}
	119	kfree(heaps);
	120
4c45b1a8 JS	121	if (carveout_ptr) {
	122	free_pages_exact(carveout_ptr,
	123	dummy_heaps[ION_HEAP_TYPE_CARVEOUT].size);
	124	carveout_ptr = NULL;
	125	}
	126	if (chunk_ptr) {
	127	free_pages_exact(chunk_ptr,
	128	dummy_heaps[ION_HEAP_TYPE_CHUNK].size);
	129	chunk_ptr = NULL;
	130	}
1184ead8 JS	131	return err;
1184ead8 JS	132	}
102f1a2a	133	device_initcall(ion_dummy_init);
1184ead8 JS	134
	135	static void __exit ion_dummy_exit(void)
	136	{
	137	int i;
	138
	139	ion_device_destroy(idev);
	140
	141	for (i = 0; i < dummy_ion_pdata.nr; i++)
	142	ion_heap_destroy(heaps[i]);
	143	kfree(heaps);
	144
4c45b1a8 JS	145	if (carveout_ptr) {
	146	free_pages_exact(carveout_ptr,
	147	dummy_heaps[ION_HEAP_TYPE_CARVEOUT].size);
	148	carveout_ptr = NULL;
	149	}
	150	if (chunk_ptr) {
	151	free_pages_exact(chunk_ptr,
	152	dummy_heaps[ION_HEAP_TYPE_CHUNK].size);
	153	chunk_ptr = NULL;
	154	}
	155
1184ead8 JS	156	return;
1184ead8 JS	157	}
102f1a2a	158	__exitcall(ion_dummy_exit);