drivers/staging/android/ion/ion_system_heap.c

   1 /*
   2  * drivers/staging/android/ion/ion_system_heap.c
   3  *
   4  * Copyright (C) 2011 Google, 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 <asm/page.h>
  18 #include <linux/dma-mapping.h>
  19 #include <linux/err.h>
  20 #include <linux/highmem.h>
  21 #include <linux/mm.h>
  22 #include <linux/scatterlist.h>
  23 #include <linux/seq_file.h>
  24 #include <linux/slab.h>
  25 #include <linux/vmalloc.h>
  26 #include "ion.h"
  27 #include "ion_priv.h"
  28
  29 static gfp_t high_order_gfp_flags = (GFP_HIGHUSER | __GFP_ZERO | __GFP_NOWARN |
  30                                      __GFP_NORETRY) & ~__GFP_WAIT;
  31 static gfp_t low_order_gfp_flags  = (GFP_HIGHUSER | __GFP_ZERO | __GFP_NOWARN);
  32 static const unsigned int orders[] = {8, 4, 0};
  33 static const int num_orders = ARRAY_SIZE(orders);
  34 static int order_to_index(unsigned int order)
  35 {
  36         int i;
  37
  38         for (i = 0; i < num_orders; i++)
  39                 if (order == orders[i])
  40                         return i;
  41         BUG();
  42         return -1;
  43 }
  44
  45 static inline unsigned int order_to_size(int order)
  46 {
  47         return PAGE_SIZE << order;
  48 }
  49
  50 struct ion_system_heap {
  51         struct ion_heap heap;
  52         struct ion_page_pool **pools;
  53 };
  54
  55 struct page_info {
  56         struct page *page;
  57         unsigned int order;
  58         struct list_head list;
  59 };
  60
  61 static struct page *alloc_buffer_page(struct ion_system_heap *heap,
  62                                       struct ion_buffer *buffer,
  63                                       unsigned long order)
  64 {
  65         bool cached = ion_buffer_cached(buffer);
  66         struct ion_page_pool *pool = heap->pools[order_to_index(order)];
  67         struct page *page;
  68
  69         if (!cached) {
  70                 page = ion_page_pool_alloc(pool);
  71         } else {
  72                 gfp_t gfp_flags = low_order_gfp_flags;
  73
  74                 if (order > 4)
  75                         gfp_flags = high_order_gfp_flags;
  76                 page = alloc_pages(gfp_flags | __GFP_COMP, order);
  77                 if (!page)
  78                         return NULL;
  79                 ion_pages_sync_for_device(NULL, page, PAGE_SIZE << order,
  80                                                 DMA_BIDIRECTIONAL);
  81         }
  82
  83         return page;
  84 }
  85
  86 static void free_buffer_page(struct ion_system_heap *heap,
  87                              struct ion_buffer *buffer, struct page *page,
  88                              unsigned int order)
  89 {
  90         bool cached = ion_buffer_cached(buffer);
  91
  92         if (!cached && !(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE)) {
  93                 struct ion_page_pool *pool = heap->pools[order_to_index(order)];
  94
  95                 ion_page_pool_free(pool, page);
  96         } else {
  97                 __free_pages(page, order);
  98         }
  99 }
 100
 101
 102 static struct page_info *alloc_largest_available(struct ion_system_heap *heap,
 103                                                  struct ion_buffer *buffer,
 104                                                  unsigned long size,
 105                                                  unsigned int max_order)
 106 {
 107         struct page *page;
 108         struct page_info *info;
 109         int i;
 110
 111         info = kmalloc(sizeof(struct page_info), GFP_KERNEL);
 112         if (!info)
 113                 return NULL;
 114
 115         for (i = 0; i < num_orders; i++) {
 116                 if (size < order_to_size(orders[i]))
 117                         continue;
 118                 if (max_order < orders[i])
 119                         continue;
 120
 121                 page = alloc_buffer_page(heap, buffer, orders[i]);
 122                 if (!page)
 123                         continue;
 124
 125                 info->page = page;
 126                 info->order = orders[i];
 127                 return info;
 128         }
 129         kfree(info);
 130
 131         return NULL;
 132 }
 133
 134 static int ion_system_heap_allocate(struct ion_heap *heap,
 135                                      struct ion_buffer *buffer,
 136                                      unsigned long size, unsigned long align,
 137                                      unsigned long flags)
 138 {
 139         struct ion_system_heap *sys_heap = container_of(heap,
 140                                                         struct ion_system_heap,
 141                                                         heap);
 142         struct sg_table *table;
 143         struct scatterlist *sg;
 144         struct list_head pages;
 145         struct page_info *info, *tmp_info;
 146         int i = 0;
 147         unsigned long size_remaining = PAGE_ALIGN(size);
 148         unsigned int max_order = orders[0];
 149
 150         if (align > PAGE_SIZE)
 151                 return -EINVAL;
 152
 153         if (size / PAGE_SIZE > totalram_pages / 2)
 154                 return -ENOMEM;
 155
 156         INIT_LIST_HEAD(&pages);
 157         while (size_remaining > 0) {
 158                 info = alloc_largest_available(sys_heap, buffer, size_remaining,
 159                                                 max_order);
 160                 if (!info)
 161                         goto free_pages;
 162                 list_add_tail(&info->list, &pages);
 163                 size_remaining -= PAGE_SIZE << info->order;
 164                 max_order = info->order;
 165                 i++;
 166         }
 167         table = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
 168         if (!table)
 169                 goto free_pages;
 170
 171         if (sg_alloc_table(table, i, GFP_KERNEL))
 172                 goto free_table;
 173
 174         sg = table->sgl;
 175         list_for_each_entry_safe(info, tmp_info, &pages, list) {
 176                 struct page *page = info->page;
 177                 sg_set_page(sg, page, PAGE_SIZE << info->order, 0);
 178                 sg = sg_next(sg);
 179                 list_del(&info->list);
 180                 kfree(info);
 181         }
 182
 183         buffer->priv_virt = table;
 184         return 0;
 185
 186 free_table:
 187         kfree(table);
 188 free_pages:
 189         list_for_each_entry_safe(info, tmp_info, &pages, list) {
 190                 free_buffer_page(sys_heap, buffer, info->page, info->order);
 191                 kfree(info);
 192         }
 193         return -ENOMEM;
 194 }
 195
 196 static void ion_system_heap_free(struct ion_buffer *buffer)
 197 {
 198         struct ion_system_heap *sys_heap = container_of(buffer->heap,
 199                                                         struct ion_system_heap,
 200                                                         heap);
 201         struct sg_table *table = buffer->sg_table;
 202         bool cached = ion_buffer_cached(buffer);
 203         struct scatterlist *sg;
 204         int i;
 205
 206         /* uncached pages come from the page pools, zero them before returning
 207            for security purposes (other allocations are zerod at alloc time */
 208         if (!cached && !(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE))
 209                 ion_heap_buffer_zero(buffer);
 210
 211         for_each_sg(table->sgl, sg, table->nents, i)
 212                 free_buffer_page(sys_heap, buffer, sg_page(sg),
 213                                 get_order(sg->length));
 214         sg_free_table(table);
 215         kfree(table);
 216 }
 217
 218 static struct sg_table *ion_system_heap_map_dma(struct ion_heap *heap,
 219                                                 struct ion_buffer *buffer)
 220 {
 221         return buffer->priv_virt;
 222 }
 223
 224 static void ion_system_heap_unmap_dma(struct ion_heap *heap,
 225                                       struct ion_buffer *buffer)
 226 {
 227         return;
 228 }
 229
 230 static int ion_system_heap_shrink(struct ion_heap *heap, gfp_t gfp_mask,
 231                                         int nr_to_scan)
 232 {
 233         struct ion_system_heap *sys_heap;
 234         int nr_total = 0;
 235         int i;
 236
 237         sys_heap = container_of(heap, struct ion_system_heap, heap);
 238
 239         for (i = 0; i < num_orders; i++) {
 240                 struct ion_page_pool *pool = sys_heap->pools[i];
 241
 242                 nr_total += ion_page_pool_shrink(pool, gfp_mask, nr_to_scan);
 243         }
 244
 245         return nr_total;
 246 }
 247
 248 static struct ion_heap_ops system_heap_ops = {
 249         .allocate = ion_system_heap_allocate,
 250         .free = ion_system_heap_free,
 251         .map_dma = ion_system_heap_map_dma,
 252         .unmap_dma = ion_system_heap_unmap_dma,
 253         .map_kernel = ion_heap_map_kernel,
 254         .unmap_kernel = ion_heap_unmap_kernel,
 255         .map_user = ion_heap_map_user,
 256         .shrink = ion_system_heap_shrink,
 257 };
 258
 259 static int ion_system_heap_debug_show(struct ion_heap *heap, struct seq_file *s,
 260                                       void *unused)
 261 {
 262
 263         struct ion_system_heap *sys_heap = container_of(heap,
 264                                                         struct ion_system_heap,
 265                                                         heap);
 266         int i;
 267
 268         for (i = 0; i < num_orders; i++) {
 269                 struct ion_page_pool *pool = sys_heap->pools[i];
 270
 271                 seq_printf(s, "%d order %u highmem pages in pool = %lu total\n",
 272                            pool->high_count, pool->order,
 273                            (PAGE_SIZE << pool->order) * pool->high_count);
 274                 seq_printf(s, "%d order %u lowmem pages in pool = %lu total\n",
 275                            pool->low_count, pool->order,
 276                            (PAGE_SIZE << pool->order) * pool->low_count);
 277         }
 278         return 0;
 279 }
 280
 281 struct ion_heap *ion_system_heap_create(struct ion_platform_heap *unused)
 282 {
 283         struct ion_system_heap *heap;
 284         int i;
 285
 286         heap = kzalloc(sizeof(struct ion_system_heap), GFP_KERNEL);
 287         if (!heap)
 288                 return ERR_PTR(-ENOMEM);
 289         heap->heap.ops = &system_heap_ops;
 290         heap->heap.type = ION_HEAP_TYPE_SYSTEM;
 291         heap->heap.flags = ION_HEAP_FLAG_DEFER_FREE;
 292         heap->pools = kzalloc(sizeof(struct ion_page_pool *) * num_orders,
 293                               GFP_KERNEL);
 294         if (!heap->pools)
 295                 goto free_heap;
 296         for (i = 0; i < num_orders; i++) {
 297                 struct ion_page_pool *pool;
 298                 gfp_t gfp_flags = low_order_gfp_flags;
 299
 300                 if (orders[i] > 4)
 301                         gfp_flags = high_order_gfp_flags;
 302                 pool = ion_page_pool_create(gfp_flags, orders[i]);
 303                 if (!pool)
 304                         goto destroy_pools;
 305                 heap->pools[i] = pool;
 306         }
 307
 308         heap->heap.debug_show = ion_system_heap_debug_show;
 309         return &heap->heap;
 310
 311 destroy_pools:
 312         while (i--)
 313                 ion_page_pool_destroy(heap->pools[i]);
 314         kfree(heap->pools);
 315 free_heap:
 316         kfree(heap);
 317         return ERR_PTR(-ENOMEM);
 318 }
 319
 320 void ion_system_heap_destroy(struct ion_heap *heap)
 321 {
 322         struct ion_system_heap *sys_heap = container_of(heap,
 323                                                         struct ion_system_heap,
 324                                                         heap);
 325         int i;
 326
 327         for (i = 0; i < num_orders; i++)
 328                 ion_page_pool_destroy(sys_heap->pools[i]);
 329         kfree(sys_heap->pools);
 330         kfree(sys_heap);
 331 }
 332
 333 static int ion_system_contig_heap_allocate(struct ion_heap *heap,
 334                                            struct ion_buffer *buffer,
 335                                            unsigned long len,
 336                                            unsigned long align,
 337                                            unsigned long flags)
 338 {
 339         int order = get_order(len);
 340         struct page *page;
 341         struct sg_table *table;
 342         unsigned long i;
 343         int ret;
 344
 345         if (align > (PAGE_SIZE << order))
 346                 return -EINVAL;
 347
 348         page = alloc_pages(low_order_gfp_flags, order);
 349         if (!page)
 350                 return -ENOMEM;
 351
 352         split_page(page, order);
 353
 354         len = PAGE_ALIGN(len);
 355         for (i = len >> PAGE_SHIFT; i < (1 << order); i++)
 356                 __free_page(page + i);
 357
 358         table = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
 359         if (!table) {
 360                 ret = -ENOMEM;
 361                 goto free_pages;
 362         }
 363
 364         ret = sg_alloc_table(table, 1, GFP_KERNEL);
 365         if (ret)
 366                 goto free_table;
 367
 368         sg_set_page(table->sgl, page, len, 0);
 369
 370         buffer->priv_virt = table;
 371
 372         ion_pages_sync_for_device(NULL, page, len, DMA_BIDIRECTIONAL);
 373
 374         return 0;
 375
 376 free_table:
 377         kfree(table);
 378 free_pages:
 379         for (i = 0; i < len >> PAGE_SHIFT; i++)
 380                 __free_page(page + i);
 381
 382         return ret;
 383 }
 384
 385 static void ion_system_contig_heap_free(struct ion_buffer *buffer)
 386 {
 387         struct sg_table *table = buffer->priv_virt;
 388         struct page *page = sg_page(table->sgl);
 389         unsigned long pages = PAGE_ALIGN(buffer->size) >> PAGE_SHIFT;
 390         unsigned long i;
 391
 392         for (i = 0; i < pages; i++)
 393                 __free_page(page + i);
 394         sg_free_table(table);
 395         kfree(table);
 396 }
 397
 398 static int ion_system_contig_heap_phys(struct ion_heap *heap,
 399                                        struct ion_buffer *buffer,
 400                                        ion_phys_addr_t *addr, size_t *len)
 401 {
 402         struct sg_table *table = buffer->priv_virt;
 403         struct page *page = sg_page(table->sgl);
 404         *addr = page_to_phys(page);
 405         *len = buffer->size;
 406         return 0;
 407 }
 408
 409 static struct sg_table *ion_system_contig_heap_map_dma(struct ion_heap *heap,
 410                                                 struct ion_buffer *buffer)
 411 {
 412         return buffer->priv_virt;
 413 }
 414
 415 static void ion_system_contig_heap_unmap_dma(struct ion_heap *heap,
 416                                              struct ion_buffer *buffer)
 417 {
 418 }
 419
 420 static struct ion_heap_ops kmalloc_ops = {
 421         .allocate = ion_system_contig_heap_allocate,
 422         .free = ion_system_contig_heap_free,
 423         .phys = ion_system_contig_heap_phys,
 424         .map_dma = ion_system_contig_heap_map_dma,
 425         .unmap_dma = ion_system_contig_heap_unmap_dma,
 426         .map_kernel = ion_heap_map_kernel,
 427         .unmap_kernel = ion_heap_unmap_kernel,
 428         .map_user = ion_heap_map_user,
 429 };
 430
 431 struct ion_heap *ion_system_contig_heap_create(struct ion_platform_heap *unused)
 432 {
 433         struct ion_heap *heap;
 434
 435         heap = kzalloc(sizeof(struct ion_heap), GFP_KERNEL);
 436         if (!heap)
 437                 return ERR_PTR(-ENOMEM);
 438         heap->ops = &kmalloc_ops;
 439         heap->type = ION_HEAP_TYPE_SYSTEM_CONTIG;
 440         return heap;
 441 }
 442
 443 void ion_system_contig_heap_destroy(struct ion_heap *heap)
 444 {
 445         kfree(heap);
 446 }