static int tegra_ion_probe(struct platform_device *pdev)
{
struct ion_platform_data *pdata = pdev->dev.platform_data;
int err;
int i;
num_heaps = pdata->nr;
heaps = devm_kzalloc(&pdev->dev,
sizeof(struct ion_heap *) * pdata->nr,
GFP_KERNEL);
idev = ion_device_create(NULL);
if (IS_ERR_OR_NULL(idev))
return PTR_ERR(idev);
/* create the heaps as specified in the board file */
for (i = 0; i < num_heaps; i++) {
struct ion_platform_heap *heap_data = &pdata->heaps[i];
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]);
}
platform_set_drvdata(pdev, idev);
return 0;
err:
for (i = 0; i < num_heaps; ++i)
ion_heap_destroy(heaps[i]);
return err;
}
int omap_ion_probe(struct platform_device *pdev)
{
printk(KERN_ERR "enter omap_ion_probe()\n");
struct ion_platform_data *pdata = pdev->dev.platform_data;
int err;
int i;
num_heaps = pdata->nr;
heaps = kzalloc(sizeof(struct ion_heap *) * pdata->nr, GFP_KERNEL);
omap_ion_device = ion_device_create(omap_ion_ioctl);
printk(KERN_ERR "Created ion device at %d\n", omap_ion_device);
if (IS_ERR_OR_NULL(omap_ion_device)) {
printk(KERN_ERR "Error creating ion_device!\n");
kfree(heaps);
return PTR_ERR(omap_ion_device);
}
/* create the heaps as specified in the board file */
for (i = 0; i < num_heaps; i++) {
struct ion_platform_heap *heap_data = &pdata->heaps[i];
if (heap_data->type == OMAP_ION_HEAP_TYPE_TILER) {
heaps[i] = omap_tiler_heap_create(heap_data);
if (heap_data->id == OMAP_ION_HEAP_NONSECURE_TILER)
nonsecure_tiler_heap = heaps[i];
else
tiler_heap = heaps[i];
} else if (heap_data->type ==
OMAP_ION_HEAP_TYPE_TILER_RESERVATION) {
heaps[i] = omap_tiler_heap_create(heap_data);
} else {
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(omap_ion_device, heaps[i]);
pr_info("%s: adding heap %s of type %d with %lx@%x\n",
__func__, heap_data->name, heap_data->type,
heap_data->base, heap_data->size);
}
platform_set_drvdata(pdev, omap_ion_device);
return 0;
err:
for (i = 0; i < num_heaps; i++) {
if (heaps[i]) {
if (heaps[i]->type == OMAP_ION_HEAP_TYPE_TILER)
omap_tiler_heap_destroy(heaps[i]);
else
ion_heap_destroy(heaps[i]);
}
}
kfree(heaps);
return err;
}
static int msm_ion_probe(struct platform_device *pdev)
{
struct ion_platform_data *pdata = pdev->dev.platform_data;
int err;
int i;
num_heaps = pdata->nr;
heaps = kcalloc(pdata->nr, sizeof(struct ion_heap *), GFP_KERNEL);
if (!heaps) {
err = -ENOMEM;
goto out;
}
idev = ion_device_create(NULL);
if (IS_ERR_OR_NULL(idev)) {
err = PTR_ERR(idev);
goto freeheaps;
}
/* create the heaps as specified in the board file */
for (i = 0; i < num_heaps; i++) {
struct ion_platform_heap *heap_data = &pdata->heaps[i];
if (heap_data->type == ION_HEAP_TYPE_CARVEOUT) {
heap_data->base = msm_ion_get_base(heap_data->size,
heap_data->memory_type);
if (!heap_data->base) {
pr_err("%s: could not get memory for heap %s"
" (id %x)\n", __func__, heap_data->name,
heap_data->id);
continue;
}
}
heaps[i] = ion_heap_create(heap_data);
if (IS_ERR_OR_NULL(heaps[i])) {
err = PTR_ERR(heaps[i]);
goto heapdestroy;
}
ion_device_add_heap(idev, heaps[i]);
}
platform_set_drvdata(pdev, idev);
return 0;
heapdestroy:
for (i = 0; i < num_heaps; i++) {
if (!IS_ERR_OR_NULL(heaps[i]))
ion_heap_destroy(heaps[i]);
}
freeheaps:
kfree(heaps);
out:
return err;
}
int dev_ion_remove(struct platform_device *pdev) {
struct ion_device *idev = platform_get_drvdata(pdev);
int i;
ion_device_destroy(idev);
for (i = 0; i < num_heaps; i++)
ion_heap_destroy(heaps[i]);
kfree(heaps);
return 0;
}
int sunxi_ion_remove(struct platform_device *pdev)
{
struct ion_device *dev = platform_get_drvdata(pdev);
while(num_heaps--)
ion_heap_destroy(pheap[num_heaps]);
kfree(pheap);
ion_device_destroy(dev);
return 0;
}
static int pxa_ion_probe(struct platform_device *pdev)
{
struct ion_platform_data *pdata = pdev->dev.platform_data;
struct pxa_ion_info *info;
int err, i;
if (!pdata)
return -EINVAL;
info = devm_kzalloc(&pdev->dev, sizeof(struct pxa_ion_info),
GFP_KERNEL);
if (!info)
return -ENOMEM;
info->heaps = devm_kzalloc(&pdev->dev,
sizeof(struct ion_heap *) * pdata->nr, GFP_KERNEL);
if (!info->heaps) {
devm_kfree(&pdev->dev, info);
return -ENOMEM;
}
info->heap_cnt = pdata->nr;
info->idev = ion_device_create(pxa_ion_ioctl);
if (IS_ERR_OR_NULL(info->idev)) {
devm_kfree(&pdev->dev, info->heaps);
devm_kfree(&pdev->dev, info);
return PTR_ERR(info->idev);
}
pxa_ion_dev = info->idev;
/* create the heaps as specified in the board file */
for (i = 0; i < pdata->nr; i++) {
struct ion_platform_heap *heap_data = &pdata->heaps[i];
info->heaps[i] = ion_heap_create(heap_data);
if (IS_ERR_OR_NULL(info->heaps[i])) {
err = PTR_ERR(info->heaps[i]);
goto err_heap;
}
ion_device_add_heap(info->idev, info->heaps[i]);
}
platform_set_drvdata(pdev, info);
return 0;
err_heap:
for (; i > 0; i--)
ion_heap_destroy(info->heaps[i]);
ion_device_destroy(info->idev);
devm_kfree(&pdev->dev, info->heaps);
devm_kfree(&pdev->dev, info);
return err;
}
static void __ion_heap_destroy(struct ion_heap *heap)
{
if (!heap)
return;
switch ((int)heap->type) {
case ION_HEAP_TYPE_CUSTOM:
ion_cma_heap_destroy(heap);
break;
default:
ion_heap_destroy(heap);
}
}
static int pxa_ion_remove(struct platform_device *pdev)
{
struct pxa_ion_info *info = platform_get_drvdata(pdev);
int i;
if (info) {
for (i = 0; i < info->heap_cnt; i++)
ion_heap_destroy(info->heaps[i]);
ion_device_destroy(info->idev);
platform_set_drvdata(pdev, NULL);
}
return 0;
}
IMG_VOID IonDeinit(IMG_VOID)
{
int uiHeapCount = generic_config.nr;
int i;
for (i = 0; i < uiHeapCount; i++) {
if (apsIonHeaps[i])
{
ion_heap_destroy(apsIonHeaps[i]);
}
}
kfree(apsIonHeaps);
ion_device_destroy(psIonDev);
}
int omap_ion_remove(struct platform_device *pdev)
{
struct ion_device *idev = platform_get_drvdata(pdev);
int i;
ion_device_destroy(idev);
for (i = 0; i < num_heaps; i++)
if (heaps[i]->type == OMAP_ION_HEAP_TYPE_TILER)
omap_tiler_heap_destroy(heaps[i]);
else
ion_heap_destroy(heaps[i]);
kfree(heaps);
return 0;
}
static int msm_ion_probe(struct platform_device *pdev)
{
struct ion_platform_data *pdata = pdev->dev.platform_data;
int err;
int i;
num_heaps = pdata->nr;
heaps = kcalloc(pdata->nr, sizeof(struct ion_heap *), GFP_KERNEL);
if (!heaps) {
err = -ENOMEM;
goto out;
}
idev = ion_device_create(NULL);
if (IS_ERR_OR_NULL(idev)) {
err = PTR_ERR(idev);
goto freeheaps;
}
msm_ion_heap_fixup(pdata->heaps, num_heaps);
/* create the heaps as specified in the board file */
for (i = 0; i < num_heaps; i++) {
struct ion_platform_heap *heap_data = &pdata->heaps[i];
msm_ion_allocate(heap_data);
heaps[i] = ion_heap_create(heap_data);
if (IS_ERR_OR_NULL(heaps[i])) {
err = PTR_ERR(heaps[i]);
goto heapdestroy;
}
ion_device_add_heap(idev, heaps[i]);
}
platform_set_drvdata(pdev, idev);
return 0;
heapdestroy:
for (i = 0; i < num_heaps; i++) {
if (!IS_ERR_OR_NULL(heaps[i]))
ion_heap_destroy(heaps[i]);
}
freeheaps:
kfree(heaps);
out:
return err;
}
PVRSRV_ERROR IonInit(void *phPrivateData)
{
int uiHeapCount = generic_config.nr;
int uiError;
int i;
PVR_UNREFERENCED_PARAMETER(phPrivateData);
g_apsIonHeaps = kzalloc(sizeof(struct ion_heap *) * uiHeapCount, GFP_KERNEL);
/* Create the ion devicenode */
g_psIonDev = ion_device_create(NULL);
if (IS_ERR_OR_NULL(g_psIonDev)) {
kfree(g_apsIonHeaps);
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Register all the heaps */
for (i = 0; i < generic_config.nr; i++)
{
struct ion_platform_heap *psPlatHeapData = &generic_config.heaps[i];
g_apsIonHeaps[i] = ion_heap_create(psPlatHeapData);
if (IS_ERR_OR_NULL(g_apsIonHeaps[i]))
{
uiError = PTR_ERR(g_apsIonHeaps[i]);
goto failHeapCreate;
}
ion_device_add_heap(g_psIonDev, g_apsIonHeaps[i]);
}
return PVRSRV_OK;
failHeapCreate:
for (i = 0; i < uiHeapCount; i++) {
if (g_apsIonHeaps[i])
{
ion_heap_destroy(g_apsIonHeaps[i]);
}
}
kfree(g_apsIonHeaps);
ion_device_destroy(g_psIonDev);
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
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;
}
}
PVRSRV_ERROR IonInit(IMG_VOID)
{
int uiHeapCount = gsGenericConfig.nr;
int uiError;
int i;
gapsIonHeaps = kzalloc(sizeof(struct ion_heap *) * uiHeapCount, GFP_KERNEL);
/* Create the ion devicenode */
gpsIonDev = ion_device_create(NULL);
if (IS_ERR_OR_NULL(gpsIonDev)) {
kfree(gapsIonHeaps);
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Register all the heaps */
for (i = 0; i < gsGenericConfig.nr; i++)
{
struct ion_platform_heap *psPlatHeapData = &gsGenericConfig.heaps[i];
gapsIonHeaps[i] = ion_heap_create(psPlatHeapData);
if (IS_ERR_OR_NULL(gapsIonHeaps[i]))
{
uiError = PTR_ERR(gapsIonHeaps[i]);
goto failHeapCreate;
}
ion_device_add_heap(gpsIonDev, gapsIonHeaps[i]);
}
return PVRSRV_OK;
failHeapCreate:
for (i = 0; i < uiHeapCount; i++)
{
if (gapsIonHeaps[i])
{
ion_heap_destroy(gapsIonHeaps[i]);
}
}
kfree(gapsIonHeaps);
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
int sunxi_ion_probe(struct platform_device *pdev)
{
struct ion_platform_data *pdata = pdev->dev.platform_data;
struct ion_platform_heap *heaps_desc;
int i, ret = 0;
pheap = kzalloc(sizeof(struct ion_heap *) * pdata->nr, GFP_KERNEL);
idev = ion_device_create(sunxi_ion_ioctl);
if(IS_ERR_OR_NULL(idev)) {
kfree(pheap);
return PTR_ERR(idev);
}
for(i = 0; i < pdata->nr; i++) {
heaps_desc = &pdata->heaps[i];
if(heaps_desc->type == ION_HEAP_TYPE_CARVEOUT) {
heaps_desc->base = ion_mem.start;
heaps_desc->size = ion_mem.size;
}
pheap[i] = ion_heap_create(heaps_desc);
if(IS_ERR_OR_NULL(pheap[i])) {
ret = PTR_ERR(pheap[i]);
goto err;
}
ion_device_add_heap(idev, pheap[i]);
if(heaps_desc->type == ION_HEAP_TYPE_CARVEOUT)
carveout_heap = pheap[i];
}
num_heaps = i;
platform_set_drvdata(pdev, idev);
return 0;
err:
while(i--)
ion_heap_destroy(pheap[i]);
ion_device_destroy(idev);
kfree(pheap);
return ret;
}
int tegra_ion_probe(struct platform_device *pdev)
{
struct ion_platform_data *pdata = pdev->dev.platform_data;
int err;
int i;
num_heaps = pdata->nr;
heaps = kzalloc(sizeof(struct ion_heap *) * pdata->nr, GFP_KERNEL);
idev = ion_device_create(NULL);
if (IS_ERR_OR_NULL(idev)) {
kfree(heaps);
return PTR_ERR(idev);
}
for (i = 0; i < num_heaps; i++) {
struct ion_platform_heap *heap_data = &pdata->heaps[i];
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]);
}
platform_set_drvdata(pdev, idev);
return 0;
err:
for (i = 0; i < num_heaps; i++) {
if (heaps[i])
ion_heap_destroy(heaps[i]);
}
kfree(heaps);
return err;
}
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 PTR_ERR(heaps);
/* 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;
}
int dev_ion_probe(struct platform_device *pdev) {
int err;
int i;
struct resource *res;
struct device_node *of_node = pdev->dev.of_node;
const void *name;
int offset,size;
num_heaps = 1;
my_ion_heap[0].type = ION_HEAP_TYPE_SYSTEM;
my_ion_heap[0].id = ION_HEAP_TYPE_SYSTEM;
my_ion_heap[0].name = "vmalloc_ion";
#if 0
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
#else
res = &memobj;
i = find_reserve_block(of_node->name,0);
if(i < 0){
name = of_get_property(of_node, "share-memory-name", NULL);
if(!name)
{
printk("\ndev_ion memory resource undefined1.\n");
return -EFAULT;
}
else
{
i= find_reserve_block_by_name((char *)name);
if(i<0)
{
printk("\ndev_ion memory resource undefined2.\n");
return -EFAULT;
}
name = of_get_property(of_node, "share-memory-offset", NULL);
if(name)
offset = of_read_ulong(name,1);
else
{
printk("\ndev_ion memory resource undefined3.\n");
return -EFAULT;
}
name = of_get_property(of_node, "share-memory-size", NULL);
if(name)
size = of_read_ulong(name,1);
else
{
printk("\ndev_ion memory resource undefined4.\n");
return -EFAULT;
}
res->start = (phys_addr_t)get_reserve_block_addr(i)+offset;
res->end = res->start+ size-1;
}
}
else
{
res->start = (phys_addr_t)get_reserve_block_addr(i);
res->end = res->start+ (phys_addr_t)get_reserve_block_size(i)-1;
}
#endif
if (res) {
num_heaps = 2;
my_ion_heap[1].type = ION_HEAP_TYPE_CARVEOUT;//ION_HEAP_TYPE_CHUNK;//ION_HEAP_TYPE_CARVEOUT;
my_ion_heap[1].id = ION_HEAP_TYPE_CARVEOUT;
my_ion_heap[1].name = "carveout_ion";
my_ion_heap[1].base = (ion_phys_addr_t) res->start;
my_ion_heap[1].size = res->end - res->start + 1;
}
heaps = kzalloc(sizeof(struct ion_heap *) * num_heaps, GFP_KERNEL);
idev = ion_device_create(NULL);
if (IS_ERR_OR_NULL(idev)) {
kfree(heaps);
panic(0);
return PTR_ERR(idev);
}
/* create the heaps as specified in the board file */
for (i = 0; i < num_heaps; i++) {
heaps[i] = ion_heap_create(&my_ion_heap[i]);
if (IS_ERR_OR_NULL(heaps[i])) {
err = PTR_ERR(heaps[i]);
goto err;
}
ion_device_add_heap(idev, heaps[i]);
dprintk(2, "add heap type:%d id:%d\n", my_ion_heap[i].type, my_ion_heap[i].id);
}
platform_set_drvdata(pdev, idev);
return 0;
err:
for (i = 0; i < num_heaps; i++) {
if (heaps[i])
ion_heap_destroy(heaps[i]);
}
kfree(heaps);
panic(0);
return err;
}
int godbox_ion_probe(struct platform_device *pdev)
{
struct ion_platform_data *pdata = pdev->dev.platform_data;
int err;
int i, previous_heaps_count = 0;
/* test if it is the first time we try to create ions heaps */
if (num_heaps == 0) {
num_heaps = pdata->nr;
godbox_ion_heaps =
kzalloc(sizeof(struct ion_heap *) * pdata->nr, GFP_KERNEL);
memset(godbox_ion_heaps, 0,
sizeof(struct ion_heap *) * pdata->nr);
godbox_ion_device = ion_device_create(NULL);
if (IS_ERR_OR_NULL(godbox_ion_device)) {
kfree(godbox_ion_heaps);
num_heaps = 0;
return PTR_ERR(godbox_ion_device);
}
} else {
struct ion_heap **new_godbox_ion_heaps;
previous_heaps_count = num_heaps;
num_heaps += pdata->nr;
/* allocate a bigger array of ion_heap */
new_godbox_ion_heaps =
kzalloc(sizeof(struct ion_heap *) * num_heaps, GFP_KERNEL);
memset(new_godbox_ion_heaps, 0,
sizeof(struct ion_heap *) * num_heaps);
/* copy old heap array info into the new one */
for (i = 0; i < previous_heaps_count; i++)
new_godbox_ion_heaps[i] = godbox_ion_heaps[i];
/* free old heap array and swap it with the new one */
kfree(godbox_ion_heaps);
godbox_ion_heaps = new_godbox_ion_heaps;
}
/* create the heaps as specified in the board file */
for (i = previous_heaps_count; i < num_heaps; i++) {
struct ion_platform_heap *heap_data =
&pdata->heaps[i - previous_heaps_count];
/* heap_data->priv = &pdev->dev; */
godbox_ion_heaps[i] = ion_heap_create(heap_data);
if (IS_ERR_OR_NULL(godbox_ion_heaps[i])) {
err = PTR_ERR(godbox_ion_heaps[i]);
godbox_ion_heaps[i] = NULL;
goto err;
}
ion_device_add_heap(godbox_ion_device, godbox_ion_heaps[i]);
}
platform_set_drvdata(pdev, godbox_ion_device);
return 0;
err:
for (i = 0; i < num_heaps; i++) {
if (godbox_ion_heaps[i])
ion_heap_destroy(godbox_ion_heaps[i]);
}
kfree(godbox_ion_heaps);
return err;
}
