drivers/staging/android/ion/ion_dummy_driver.c

   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>
  20 #include <linux/bootmem.h>
  21 #include <linux/memblock.h>
  22 #include <linux/sizes.h>
  23 #include <linux/io.h>
  24 #include "ion.h"
  25 #include "ion_priv.h"
  26
  27 struct ion_device *idev;
  28 struct ion_heap **heaps;
  29
  30 void *carveout_ptr;
  31 void *chunk_ptr;
  32
  33 struct ion_platform_heap dummy_heaps[] = {
  34                 {
  35                         .id     = ION_HEAP_TYPE_SYSTEM,
  36                         .type   = ION_HEAP_TYPE_SYSTEM,
  37                         .name   = "system",
  38                 },
  39                 {
  40                         .id     = ION_HEAP_TYPE_SYSTEM_CONTIG,
  41                         .type   = ION_HEAP_TYPE_SYSTEM_CONTIG,
  42                         .name   = "system contig",
  43                 },
  44                 {
  45                         .id     = ION_HEAP_TYPE_CARVEOUT,
  46                         .type   = ION_HEAP_TYPE_CARVEOUT,
  47                         .name   = "carveout",
  48                         .size   = SZ_4M,
  49                 },
  50                 {
  51                         .id     = ION_HEAP_TYPE_CHUNK,
  52                         .type   = ION_HEAP_TYPE_CHUNK,
  53                         .name   = "chunk",
  54                         .size   = SZ_4M,
  55                         .align  = SZ_16K,
  56                         .priv   = (void *)(SZ_16K),
  57                 },
  58 };
  59
  60 struct ion_platform_data dummy_ion_pdata = {
  61         .nr = ARRAY_SIZE(dummy_heaps),
  62         .heaps = dummy_heaps,
  63 };
  64
  65 static int __init ion_dummy_init(void)
  66 {
  67         int i, err;
  68
  69         idev = ion_device_create(NULL);
  70         heaps = kzalloc(sizeof(struct ion_heap *) * dummy_ion_pdata.nr,
  71                         GFP_KERNEL);
  72         if (!heaps)
  73                 return PTR_ERR(heaps);
  74
  75
  76         /* Allocate a dummy carveout heap */
  77         carveout_ptr = alloc_pages_exact(
  78                                 dummy_heaps[ION_HEAP_TYPE_CARVEOUT].size,
  79                                 GFP_KERNEL);
  80         if (carveout_ptr)
  81                 dummy_heaps[ION_HEAP_TYPE_CARVEOUT].base =
  82                                                 virt_to_phys(carveout_ptr);
  83         else
  84                 pr_err("ion_dummy: Could not allocate carveout\n");
  85
  86         /* Allocate a dummy chunk heap */
  87         chunk_ptr = alloc_pages_exact(
  88                                 dummy_heaps[ION_HEAP_TYPE_CHUNK].size,
  89                                 GFP_KERNEL);
  90         if (chunk_ptr)
  91                 dummy_heaps[ION_HEAP_TYPE_CHUNK].base = virt_to_phys(chunk_ptr);
  92         else
  93                 pr_err("ion_dummy: Could not allocate chunk\n");
  94
  95         for (i = 0; i < dummy_ion_pdata.nr; i++) {
  96                 struct ion_platform_heap *heap_data = &dummy_ion_pdata.heaps[i];
  97
  98                 if (heap_data->type == ION_HEAP_TYPE_CARVEOUT &&
  99                                                         !heap_data->base)
 100                         continue;
 101
 102                 if (heap_data->type == ION_HEAP_TYPE_CHUNK && !heap_data->base)
 103                         continue;
 104
 105                 heaps[i] = ion_heap_create(heap_data);
 106                 if (IS_ERR_OR_NULL(heaps[i])) {
 107                         err = PTR_ERR(heaps[i]);
 108                         goto err;
 109                 }
 110                 ion_device_add_heap(idev, heaps[i]);
 111         }
 112         return 0;
 113 err:
 114         for (i = 0; i < dummy_ion_pdata.nr; i++) {
 115                 if (heaps[i])
 116                         ion_heap_destroy(heaps[i]);
 117         }
 118         kfree(heaps);
 119
 120         if (carveout_ptr) {
 121                 free_pages_exact(carveout_ptr,
 122                                 dummy_heaps[ION_HEAP_TYPE_CARVEOUT].size);
 123                 carveout_ptr = NULL;
 124         }
 125         if (chunk_ptr) {
 126                 free_pages_exact(chunk_ptr,
 127                                 dummy_heaps[ION_HEAP_TYPE_CHUNK].size);
 128                 chunk_ptr = NULL;
 129         }
 130         return err;
 131 }
 132
 133 static void __exit ion_dummy_exit(void)
 134 {
 135         int i;
 136
 137         ion_device_destroy(idev);
 138
 139         for (i = 0; i < dummy_ion_pdata.nr; i++)
 140                 ion_heap_destroy(heaps[i]);
 141         kfree(heaps);
 142
 143         if (carveout_ptr) {
 144                 free_pages_exact(carveout_ptr,
 145                                 dummy_heaps[ION_HEAP_TYPE_CARVEOUT].size);
 146                 carveout_ptr = NULL;
 147         }
 148         if (chunk_ptr) {
 149                 free_pages_exact(chunk_ptr,
 150                                 dummy_heaps[ION_HEAP_TYPE_CHUNK].size);
 151                 chunk_ptr = NULL;
 152         }
 153
 154         return;
 155 }
 156
 157 module_init(ion_dummy_init);
 158 module_exit(ion_dummy_exit);
 159