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; }