Commit 13439479 authored by Laura Abbott's avatar Laura Abbott Committed by Greg Kroah-Hartman
Browse files

staging: ion: Add files for parsing the devicetree 



Devicetree is the preferred mechanism for platform definition
these days. Add a set of files for supporting Ion with devicetree.
This includes a set of bindings for heaps common across all
devices and parsing methods. Clients may use the standard
bindings or they can call the parsing functions along with
their own parsing for platform specific heaps.

Signed-off-by: default avatarLaura Abbott <labbott@redhat.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 76a96d86

drivers/staging/android/ion/Kconfig

+11 −0
Original line number Diff line number Diff line
@@ -40,3 +40,14 @@ config ION_HISI 
	  Choose this option if you wish to use ion on Hisilicon Platform.



source "drivers/staging/android/ion/hisilicon/Kconfig"



config ION_OF

	bool "Devicetree support for Ion"

	depends on ION && OF

	help

	  Provides base support for defining Ion heaps in devicetree

	  and setting them up. Also includes functions for platforms

	  to parse the devicetree and expand for their own custom

	  extensions



	  If using Ion and devicetree, you should say Y here

drivers/staging/android/ion/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -9,4 +9,5 @@ endif 
obj-$(CONFIG_ION_DUMMY) += ion_dummy_driver.o

obj-$(CONFIG_ION_TEGRA) += tegra/

obj-$(CONFIG_ION_HISI) += hisilicon/

obj-$(CONFIG_ION_OF) += ion_of.o

drivers/staging/android/ion/ion_of.c

0 → 100644
+185 −0
Original line number Diff line number Diff line 
/*

 * Based on work from:

 *   Andrew Andrianov <andrew@ncrmnt.org>

 *   Google

 *   The Linux Foundation

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



#include <linux/init.h>

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/of.h>

#include <linux/of_platform.h>

#include <linux/of_address.h>

#include <linux/clk.h>

#include <linux/dma-mapping.h>

#include <linux/cma.h>

#include <linux/dma-contiguous.h>

#include <linux/io.h>

#include <linux/of_reserved_mem.h>

#include "ion.h"

#include "ion_priv.h"

#include "ion_of.h"



int ion_parse_dt_heap_common(struct device_node *heap_node,

			struct ion_platform_heap *heap,

			struct ion_of_heap *compatible)

{

	int i;



	for (i = 0; compatible[i].name != NULL; i++) {

		if (of_device_is_compatible(heap_node, compatible[i].compat))

			break;

	}



	if (compatible[i].name == NULL)

		return -ENODEV;



	heap->id = compatible[i].heap_id;

	heap->type = compatible[i].type;

	heap->name = compatible[i].name;

	heap->align = compatible[i].align;



	/* Some kind of callback function pointer? */



	pr_info("%s: id %d type %d name %s align %lx\n", __func__,

			heap->id, heap->type, heap->name, heap->align);

	return 0;

}



int ion_setup_heap_common(struct platform_device *parent,

			struct device_node *heap_node,

			struct ion_platform_heap *heap)

{

	int ret = 0;



	switch (heap->type) {

		case ION_HEAP_TYPE_CARVEOUT:

		case ION_HEAP_TYPE_CHUNK:

			if (heap->base && heap->size)

				return 0;



			ret = of_reserved_mem_device_init(heap->priv);

			break;

		default:

			break;

	}



	return ret;

}



struct ion_platform_data *ion_parse_dt(struct platform_device *pdev,

					struct ion_of_heap *compatible)

{

	int num_heaps, ret;

	const struct device_node *dt_node = pdev->dev.of_node;

	struct device_node *node;

	struct ion_platform_heap *heaps;

	struct ion_platform_data *data;

	int i = 0;



	num_heaps = of_get_available_child_count(dt_node);



	if (!num_heaps)

		return ERR_PTR(-EINVAL);



	heaps = devm_kzalloc(&pdev->dev,

				sizeof(struct ion_platform_heap)*num_heaps,

				GFP_KERNEL);

	if (!heaps)

		return ERR_PTR(-ENOMEM);



	data = devm_kzalloc(&pdev->dev, sizeof(struct ion_platform_data),

				GFP_KERNEL);

	if (!data)

		return ERR_PTR(-ENOMEM);



	for_each_available_child_of_node(dt_node, node) {

		struct platform_device *heap_pdev;



		ret = ion_parse_dt_heap_common(node, &heaps[i], compatible);

		if (ret)

			return ERR_PTR(ret);



		heap_pdev = of_platform_device_create(node, heaps[i].name,

							&pdev->dev);

		if (!pdev)

			return ERR_PTR(-ENOMEM);

		heap_pdev->dev.platform_data = &heaps[i];



		heaps[i].priv = &heap_pdev->dev;



		ret = ion_setup_heap_common(pdev, node, &heaps[i]);

		if (ret)

			goto out_err;

		i++;

	}





	data->heaps = heaps;

	data->nr = num_heaps;

	return data;



out_err:

	for ( ; i >= 0; i--)

		if (heaps[i].priv)

			of_device_unregister(to_platform_device(heaps[i].priv));



	return ERR_PTR(ret);

}



void ion_destroy_platform_data(struct ion_platform_data *data)

{

	int i;



	for (i = 0; i < data->nr; i++)

		if (data->heaps[i].priv)

			of_device_unregister(to_platform_device(

				data->heaps[i].priv));

}



#ifdef CONFIG_OF_RESERVED_MEM

#include <linux/of.h>

#include <linux/of_fdt.h>

#include <linux/of_reserved_mem.h>



static int rmem_ion_device_init(struct reserved_mem *rmem, struct device *dev)

{

	struct platform_device *pdev = to_platform_device(dev);

	struct ion_platform_heap *heap = pdev->dev.platform_data;



	heap->base = rmem->base;

	heap->base = rmem->size;

	pr_debug("%s: heap %s base %pa size %pa dev %p\n", __func__,

			heap->name, &rmem->base, &rmem->size, dev);

	return 0;

}



static void rmem_ion_device_release(struct reserved_mem *rmem,

					struct device *dev)

{

	return;

}



static const struct reserved_mem_ops rmem_dma_ops = {

	.device_init	= rmem_ion_device_init,

	.device_release	= rmem_ion_device_release,

};



static int __init rmem_ion_setup(struct reserved_mem *rmem)

{

	phys_addr_t size = rmem->size;



	size = size / 1024;



	pr_info("Ion memory setup at %pa size %pa MiB\n",

		&rmem->base, &size);

	rmem->ops = &rmem_dma_ops;

	return 0;

}

RESERVEDMEM_OF_DECLARE(ion, "ion-region", rmem_ion_setup);

#endif

drivers/staging/android/ion/ion_of.h

0 → 100644
+37 −0
Original line number Diff line number Diff line 
/*

 * Based on work from:

 *   Andrew Andrianov <andrew@ncrmnt.org>

 *   Google

 *   The Linux Foundation

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



#ifndef _ION_OF_H

#define _ION_OF_H



struct ion_of_heap {

	const char *compat;

	int heap_id;

	int type;

	const char *name;

	int align;

};



#define PLATFORM_HEAP(_compat, _id, _type, _name) \

{ \

	.compat = _compat, \

	.heap_id = _id, \

	.type = _type, \

	.name = _name, \

	.align = PAGE_SIZE, \

}



struct ion_platform_data *ion_parse_dt(struct platform_device *pdev,

					struct ion_of_heap *compatible);



void ion_destroy_platform_data(struct ion_platform_data *data);



#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE