Pileus Git - ~andy/linux/blob - 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         for (i = 0; i < num_orders; i++)
  38                 if (order == orders[i])
  39                         return i;
  40         BUG();
  41         return -1;
  42 }
  43
  44 static unsigned int order_to_size(int order)
  45 {
  46         return PAGE_SIZE << order;
  47 }
  48
  49 struct ion_system_heap {
  50         struct ion_heap heap;
  51         struct ion_page_pool **pools;
  52 };
  53
  54 struct page_info {
  55         struct page *page;
  56         unsigned int order;
  57         struct list_head list;
  58 };
  59
  60 static struct page *alloc_buffer_page(struct ion_system_heap *heap,
  61                                       struct ion_buffer *buffer,
  62                                       unsigned long order)
  63 {
  64         bool cached = ion_buffer_cached(buffer);
  65         struct ion_page_pool *pool = heap->pools[order_to_index(order)];
  66         struct page *page;
  67
  68         if (!cached) {
  69                 page = ion_page_pool_alloc(pool);
  70         } else {
  71                 gfp_t gfp_flags = low_order_gfp_flags;
  72
  73                 if (order > 4)
  74                         gfp_flags = high_order_gfp_flags;
  75                 page = alloc_pages(gfp_flags, order);
  76                 if (!page)
  77                         return NULL;
  78                 ion_pages_sync_for_device(NULL, page, PAGE_SIZE << order,
  79                                                 DMA_BIDIRECTIONAL);
  80         }
  81         if (!page)
  82                 return NULL;
  83
  84         return page;
  85 }
  86
  87 static void free_buffer_page(struct ion_system_heap *heap,
  88                              struct ion_buffer *buffer, struct page *page,
  89                              unsigned int order)
  90 {
  91         bool cached = ion_buffer_cached(buffer);
  92
  93         if (!cached) {
  94                 struct ion_page_pool *pool = heap->pools[order_to_index(order)];
  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         for (i = 0; i < num_orders; i++) {
 112                 if (size < order_to_size(orders[i]))
 113                         continue;
 114                 if (max_order < orders[i])
 115                         continue;
 116
 117                 page = alloc_buffer_page(heap, buffer, orders[i]);
 118                 if (!page)
 119                         continue;
 120
 121                 info = kmalloc(sizeof(struct page_info), GFP_KERNEL);
 122                 info->page = page;
 123                 info->order = orders[i];
 124                 return info;
 125         }
 126         return NULL;
 127 }
 128
 129 static int ion_system_heap_allocate(struct ion_heap *heap,
 130                                      struct ion_buffer *buffer,
 131                                      unsigned long size, unsigned long align,
 132                                      unsigned long flags)
 133 {
 134         struct ion_system_heap *sys_heap = container_of(heap,
 135                                                         struct ion_system_heap,
 136                                                         heap);
 137         struct sg_table *table;
 138         struct scatterlist *sg;
 139         int ret;
 140         struct list_head pages;
 141         struct page_info *info, *tmp_info;
 142         int i = 0;
 143         long size_remaining = PAGE_ALIGN(size);
 144         unsigned int max_order = orders[0];
 145
 146         if (align > PAGE_SIZE)
 147                 return -EINVAL;
 148
 149         INIT_LIST_HEAD(&pages);
 150         while (size_remaining > 0) {
 151                 info = alloc_largest_available(sys_heap, buffer, size_remaining,
 152                                                 max_order);
 153                 if (!info)
 154                         goto err;
 155                 list_add_tail(&info->list, &pages);
 156                 size_remaining -= (1 << info->order) * PAGE_SIZE;
 157                 max_order = info->order;
 158                 i++;
 159         }
 160         table = kzalloc(sizeof(struct sg_table), GFP_KERNEL);
 161         if (!table)
 162                 goto err;
 163
 164         ret = sg_alloc_table(table, i, GFP_KERNEL);
 165         if (ret)
 166                 goto err1;
 167
 168         sg = table->sgl;
 169         list_for_each_entry_safe(info, tmp_info, &pages, list) {
 170                 struct page *page = info->page;
 171                 sg_set_page(sg, page, (1 << info->order) * PAGE_SIZE, 0);
 172                 sg = sg_next(sg);
 173                 list_del(&info->list);
 174                 kfree(info);
 175         }
 176
 177         buffer->priv_virt = table;
 178         return 0;
 179 err1:
 180         kfree(table);
 181 err:
 182         list_for_each_entry_safe(info, tmp_info, &pages, list) {
 183                 free_buffer_page(sys_heap, buffer, info->page, info->order);
 184                 kfree(info);
 185         }
 186         return -ENOMEM;
 187 }
 188
 189 static void ion_system_heap_free(struct ion_buffer *buffer)
 190 {
 191         struct ion_heap *heap = buffer->heap;
 192         struct ion_system_heap *sys_heap = container_of(heap,
 193                                                         struct ion_system_heap,
 194                                                         heap);
 195         struct sg_table *table = buffer->sg_table;
 196         bool cached = ion_buffer_cached(buffer);
 197         struct scatterlist *sg;
 198         LIST_HEAD(pages);
 199         int i;
 200
 201         /* uncached pages come from the page pools, zero them before returning
 202            for security purposes (other allocations are zerod at alloc time */
 203         if (!cached)
 204                 ion_heap_buffer_zero(buffer);
 205
 206         for_each_sg(table->sgl, sg, table->nents, i)
 207                 free_buffer_page(sys_heap, buffer, sg_page(sg),
 208                                 get_order(sg->length));
 209         sg_free_table(table);
 210         kfree(table);
 211 }
 212
 213 static struct sg_table *ion_system_heap_map_dma(struct ion_heap *heap,
 214                                                 struct ion_buffer *buffer)
 215 {
 216         return buffer->priv_virt;
 217 }
 218
 219 static void ion_system_heap_unmap_dma(struct ion_heap *heap,
 220                                       struct ion_buffer *buffer)
 221 {
 222         return;
 223 }
 224
 225 static struct ion_heap_ops system_heap_ops = {
 226         .allocate = ion_system_heap_allocate,
 227         .free = ion_system_heap_free,
 228         .map_dma = ion_system_heap_map_dma,
 229         .unmap_dma = ion_system_heap_unmap_dma,
 230         .map_kernel = ion_heap_map_kernel,
 231         .unmap_kernel = ion_heap_unmap_kernel,
 232         .map_user = ion_heap_map_user,
 233 };
 234
 235 static unsigned long ion_system_heap_shrink_count(struct shrinker *shrinker,
 236                                   struct shrink_control *sc)
 237 {
 238         struct ion_heap *heap = container_of(shrinker, struct ion_heap,
 239                                              shrinker);
 240         struct ion_system_heap *sys_heap = container_of(heap,
 241                                                         struct ion_system_heap,
 242                                                         heap);
 243         int nr_total = 0;
 244         int i;
 245
 246         /* total number of items is whatever the page pools are holding
 247            plus whatever's in the freelist */
 248         for (i = 0; i < num_orders; i++) {
 249                 struct ion_page_pool *pool = sys_heap->pools[i];
 250                 nr_total += ion_page_pool_shrink(pool, sc->gfp_mask, 0);
 251         }
 252         nr_total += ion_heap_freelist_size(heap) / PAGE_SIZE;
 253         return nr_total;
 254
 255 }
 256
 257 static unsigned long ion_system_heap_shrink_scan(struct shrinker *shrinker,
 258                                   struct shrink_control *sc)
 259 {
 260
 261         struct ion_heap *heap = container_of(shrinker, struct ion_heap,
 262                                              shrinker);
 263         struct ion_system_heap *sys_heap = container_of(heap,
 264                                                         struct ion_system_heap,
 265                                                         heap);
 266         int nr_freed = 0;
 267         int i;
 268
 269         if (sc->nr_to_scan == 0)
 270                 goto end;
 271
 272         /* shrink the free list first, no point in zeroing the memory if
 273            we're just going to reclaim it */
 274         nr_freed += ion_heap_freelist_drain(heap, sc->nr_to_scan * PAGE_SIZE) /
 275                 PAGE_SIZE;
 276
 277         if (nr_freed >= sc->nr_to_scan)
 278                 goto end;
 279
 280         for (i = 0; i < num_orders; i++) {
 281                 struct ion_page_pool *pool = sys_heap->pools[i];
 282
 283                 nr_freed += ion_page_pool_shrink(pool, sc->gfp_mask,
 284                                                  sc->nr_to_scan);
 285                 if (nr_freed >= sc->nr_to_scan)
 286                         break;
 287         }
 288
 289 end:
 290         return nr_freed;
 291
 292 }
 293
 294 static int ion_system_heap_debug_show(struct ion_heap *heap, struct seq_file *s,
 295                                       void *unused)
 296 {
 297
 298         struct ion_system_heap *sys_heap = container_of(heap,
 299                                                         struct ion_system_heap,
 300                                                         heap);
 301         int i;
 302         for (i = 0; i < num_orders; i++) {
 303                 struct ion_page_pool *pool = sys_heap->pools[i];
 304                 seq_printf(s, "%d order %u highmem pages in pool = %lu total\n",
 305                            pool->high_count, pool->order,
 306                            (1 << pool->order) * PAGE_SIZE * pool->high_count);
 307                 seq_printf(s, "%d order %u lowmem pages in pool = %lu total\n",
 308                            pool->low_count, pool->order,
 309                            (1 << pool->order) * PAGE_SIZE * pool->low_count);
 310         }
 311         return 0;
 312 }
 313
 314 struct ion_heap *ion_system_heap_create(struct ion_platform_heap *unused)
 315 {
 316         struct ion_system_heap *heap;
 317         int i;
 318
 319         heap = kzalloc(sizeof(struct ion_system_heap), GFP_KERNEL);
 320         if (!heap)
 321                 return ERR_PTR(-ENOMEM);
 322         heap->heap.ops = &system_heap_ops;
 323         heap->heap.type = ION_HEAP_TYPE_SYSTEM;
 324         heap->heap.flags = ION_HEAP_FLAG_DEFER_FREE;
 325         heap->pools = kzalloc(sizeof(struct ion_page_pool *) * num_orders,
 326                               GFP_KERNEL);
 327         if (!heap->pools)
 328                 goto err_alloc_pools;
 329         for (i = 0; i < num_orders; i++) {
 330                 struct ion_page_pool *pool;
 331                 gfp_t gfp_flags = low_order_gfp_flags;
 332
 333                 if (orders[i] > 4)
 334                         gfp_flags = high_order_gfp_flags;
 335                 pool = ion_page_pool_create(gfp_flags, orders[i]);
 336                 if (!pool)
 337                         goto err_create_pool;
 338                 heap->pools[i] = pool;
 339         }
 340
 341         heap->heap.shrinker.scan_objects = ion_system_heap_shrink_scan;
 342         heap->heap.shrinker.count_objects = ion_system_heap_shrink_count;
 343         heap->heap.shrinker.seeks = DEFAULT_SEEKS;
 344         heap->heap.shrinker.batch = 0;
 345         register_shrinker(&heap->heap.shrinker);
 346         heap->heap.debug_show = ion_system_heap_debug_show;
 347         return &heap->heap;
 348 err_create_pool:
 349         for (i = 0; i < num_orders; i++)
 350                 if (heap->pools[i])
 351                         ion_page_pool_destroy(heap->pools[i]);
 352         kfree(heap->pools);
 353 err_alloc_pools:
 354         kfree(heap);
 355         return ERR_PTR(-ENOMEM);
 356 }
 357
 358 void ion_system_heap_destroy(struct ion_heap *heap)
 359 {
 360         struct ion_system_heap *sys_heap = container_of(heap,
 361                                                         struct ion_system_heap,
 362                                                         heap);
 363         int i;
 364
 365         for (i = 0; i < num_orders; i++)
 366                 ion_page_pool_destroy(sys_heap->pools[i]);
 367         kfree(sys_heap->pools);
 368         kfree(sys_heap);
 369 }
 370
 371 static int ion_system_contig_heap_allocate(struct ion_heap *heap,
 372                                            struct ion_buffer *buffer,
 373                                            unsigned long len,
 374                                            unsigned long align,
 375                                            unsigned long flags)
 376 {
 377         int order = get_order(len);
 378         struct page *page;
 379         struct sg_table *table;
 380         unsigned long i;
 381         int ret;
 382
 383         if (align > (PAGE_SIZE << order))
 384                 return -EINVAL;
 385
 386         page = alloc_pages(low_order_gfp_flags, order);
 387         if (!page)
 388                 return -ENOMEM;
 389
 390         split_page(page, order);
 391
 392         len = PAGE_ALIGN(len);
 393         for (i = len >> PAGE_SHIFT; i < (1 << order); i++)
 394                 __free_page(page + i);
 395
 396         table = kzalloc(sizeof(struct sg_table), GFP_KERNEL);
 397         if (!table) {
 398                 ret = -ENOMEM;
 399                 goto out;
 400         }
 401
 402         ret = sg_alloc_table(table, 1, GFP_KERNEL);
 403         if (ret)
 404                 goto out;
 405
 406         sg_set_page(table->sgl, page, len, 0);
 407
 408         buffer->priv_virt = table;
 409
 410         ion_pages_sync_for_device(NULL, page, len, DMA_BIDIRECTIONAL);
 411
 412         return 0;
 413
 414 out:
 415         for (i = 0; i < len >> PAGE_SHIFT; i++)
 416                 __free_page(page + i);
 417         kfree(table);
 418         return ret;
 419 }
 420
 421 static void ion_system_contig_heap_free(struct ion_buffer *buffer)
 422 {
 423         struct sg_table *table = buffer->priv_virt;
 424         struct page *page = sg_page(table->sgl);
 425         unsigned long pages = PAGE_ALIGN(buffer->size) >> PAGE_SHIFT;
 426         unsigned long i;
 427
 428         for (i = 0; i < pages; i++)
 429                 __free_page(page + i);
 430         sg_free_table(table);
 431         kfree(table);
 432 }
 433
 434 static int ion_system_contig_heap_phys(struct ion_heap *heap,
 435                                        struct ion_buffer *buffer,
 436                                        ion_phys_addr_t *addr, size_t *len)
 437 {
 438         struct sg_table *table = buffer->priv_virt;
 439         struct page *page = sg_page(table->sgl);
 440         *addr = page_to_phys(page);
 441         *len = buffer->size;
 442         return 0;
 443 }
 444
 445 static struct sg_table *ion_system_contig_heap_map_dma(struct ion_heap *heap,
 446                                                 struct ion_buffer *buffer)
 447 {
 448         return buffer->priv_virt;
 449 }
 450
 451 static void ion_system_contig_heap_unmap_dma(struct ion_heap *heap,
 452                                              struct ion_buffer *buffer)
 453 {
 454 }
 455
 456 static struct ion_heap_ops kmalloc_ops = {
 457         .allocate = ion_system_contig_heap_allocate,
 458         .free = ion_system_contig_heap_free,
 459         .phys = ion_system_contig_heap_phys,
 460         .map_dma = ion_system_contig_heap_map_dma,
 461         .unmap_dma = ion_system_contig_heap_unmap_dma,
 462         .map_kernel = ion_heap_map_kernel,
 463         .unmap_kernel = ion_heap_unmap_kernel,
 464         .map_user = ion_heap_map_user,
 465 };
 466
 467 struct ion_heap *ion_system_contig_heap_create(struct ion_platform_heap *unused)
 468 {
 469         struct ion_heap *heap;
 470
 471         heap = kzalloc(sizeof(struct ion_heap), GFP_KERNEL);
 472         if (!heap)
 473                 return ERR_PTR(-ENOMEM);
 474         heap->ops = &kmalloc_ops;
 475         heap->type = ION_HEAP_TYPE_SYSTEM_CONTIG;
 476         return heap;
 477 }
 478
 479 void ion_system_contig_heap_destroy(struct ion_heap *heap)
 480 {
 481         kfree(heap);
 482 }
 483