// SPDX-License-Identifier: GPL-2.0-only
|
/*
|
* Copyright (c) 2021 Rockchip Electronics Co. Ltd.
|
*/
|
|
#include <asm/page.h>
|
#include <linux/err.h>
|
#include <linux/module.h>
|
#include <linux/of_address.h>
|
#include <linux/of_device.h>
|
#include <linux/of_reserved_mem.h>
|
#include <linux/genalloc.h>
|
#include <linux/dma-mapping.h>
|
#include <linux/highmem.h>
|
#include <linux/mm.h>
|
#include <linux/scatterlist.h>
|
#include <linux/seq_file.h>
|
#include <linux/slab.h>
|
#include <linux/vmalloc.h>
|
#include "ion.h"
|
|
#define ION_HEAP_TYPE_PROTECTED (ION_HEAP_TYPE_CUSTOM + 1)
|
|
#define NUM_ORDERS ARRAY_SIZE(orders)
|
|
static unsigned int orders[] = {8, 4, 0};
|
|
static struct reserved_mem *protected_reserved_memory;
|
|
#ifdef CONFIG_OF_RESERVED_MEM
|
static int __init protected_dma_setup(struct reserved_mem *rmem)
|
{
|
protected_reserved_memory = rmem;
|
|
pr_info("ION: created protected pool at %pa, size %ld MiB\n",
|
&rmem->base, (unsigned long)rmem->size / SZ_1M);
|
|
return 0;
|
}
|
|
RESERVEDMEM_OF_DECLARE(protected, "protected-dma-pool", protected_dma_setup);
|
#endif
|
|
static int order_to_index(unsigned int order)
|
{
|
int i;
|
|
for (i = 0; i < NUM_ORDERS; i++)
|
if (order == orders[i])
|
return i;
|
|
return 0;
|
}
|
|
static inline unsigned int order_to_size(int order)
|
{
|
return PAGE_SIZE << order;
|
}
|
|
static void protected_pool_add(struct ion_page_pool *pool, struct page *page)
|
{
|
mutex_lock(&pool->mutex);
|
if (PageHighMem(page)) {
|
list_add_tail(&page->lru, &pool->high_items);
|
pool->high_count++;
|
} else {
|
list_add_tail(&page->lru, &pool->low_items);
|
pool->low_count++;
|
}
|
mutex_unlock(&pool->mutex);
|
}
|
|
static struct page *protected_pool_remove(struct ion_page_pool *pool,
|
bool high)
|
{
|
struct page *page;
|
|
if (high) {
|
page = list_first_entry(&pool->high_items, struct page, lru);
|
pool->high_count--;
|
} else {
|
page = list_first_entry(&pool->low_items, struct page, lru);
|
pool->low_count--;
|
}
|
list_del(&page->lru);
|
|
return page;
|
}
|
|
static struct page *protected_pool_alloc(struct ion_page_pool *pool)
|
{
|
struct page *page = NULL;
|
|
mutex_lock(&pool->mutex);
|
if (pool->high_count)
|
page = protected_pool_remove(pool, true);
|
else if (pool->low_count)
|
page = protected_pool_remove(pool, false);
|
mutex_unlock(&pool->mutex);
|
|
return page;
|
}
|
|
static void protected_pool_free(struct ion_page_pool *pool,
|
struct page *page)
|
{
|
protected_pool_add(pool, page);
|
}
|
|
static int protected_pool_total(struct ion_page_pool *pool)
|
{
|
return (pool->low_count + pool->high_count) << pool->order;
|
}
|
|
static int protected_pool_shrink(struct ion_page_pool *pool,
|
struct gen_pool *rmem,
|
int nr_to_scan)
|
{
|
int freed = 0;
|
|
if (nr_to_scan == 0)
|
return protected_pool_total(pool);
|
|
while (freed < nr_to_scan) {
|
struct page *page;
|
|
mutex_lock(&pool->mutex);
|
if (pool->low_count) {
|
page = protected_pool_remove(pool, false);
|
} else if (pool->high_count) {
|
page = protected_pool_remove(pool, true);
|
} else {
|
mutex_unlock(&pool->mutex);
|
break;
|
}
|
mutex_unlock(&pool->mutex);
|
gen_pool_free(rmem, page_to_phys(page),
|
order_to_size(pool->order));
|
freed += (1 << pool->order);
|
}
|
|
return freed;
|
}
|
|
static struct ion_page_pool *protected_pool_create(unsigned int order)
|
{
|
struct ion_page_pool *pool = kzalloc(sizeof(*pool), GFP_KERNEL);
|
|
if (!pool)
|
return NULL;
|
|
pool->high_count = 0;
|
pool->low_count = 0;
|
INIT_LIST_HEAD(&pool->low_items);
|
INIT_LIST_HEAD(&pool->high_items);
|
pool->order = order;
|
mutex_init(&pool->mutex);
|
plist_node_init(&pool->list, order);
|
|
return pool;
|
}
|
|
static void protected_pool_destroy(struct ion_page_pool *pool)
|
{
|
kfree(pool);
|
}
|
|
struct ion_protected_heap {
|
struct ion_heap heap;
|
struct gen_pool *rmem;
|
struct ion_page_pool *pools[NUM_ORDERS];
|
};
|
|
struct page_info {
|
struct page *page;
|
struct list_head list;
|
unsigned long order;
|
};
|
|
static void free_buffer_page(struct ion_heap *heap,
|
struct ion_buffer *buffer,
|
struct page *page,
|
unsigned long order)
|
{
|
struct ion_page_pool *pool;
|
struct ion_protected_heap *pheap;
|
|
pheap = container_of(heap, struct ion_protected_heap, heap);
|
if (buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE) {
|
gen_pool_free(pheap->rmem, page_to_phys(page),
|
order_to_size(order));
|
return;
|
}
|
|
pool = pheap->pools[order_to_index(order)];
|
protected_pool_free(pool, page);
|
}
|
|
static struct page *alloc_buffer_page(struct ion_heap *heap,
|
struct ion_buffer *buffer,
|
unsigned long order)
|
{
|
struct ion_page_pool *pool;
|
struct ion_protected_heap *pheap;
|
struct page *page;
|
unsigned long paddr;
|
|
pheap = container_of(heap, struct ion_protected_heap, heap);
|
pool = pheap->pools[order_to_index(order)];
|
page = protected_pool_alloc(pool);
|
if (!page) {
|
paddr = gen_pool_alloc(pheap->rmem, order_to_size(order));
|
if (WARN_ON(!paddr))
|
return NULL;
|
page = phys_to_page(paddr);
|
}
|
|
return page;
|
}
|
|
static struct page_info *alloc_largest_available(struct ion_heap *heap,
|
struct ion_buffer *buffer,
|
unsigned long size,
|
unsigned int max_order)
|
{
|
struct page_info *info;
|
struct page *page;
|
int i;
|
|
info = kmalloc(sizeof(*info), GFP_KERNEL);
|
if (!info)
|
return NULL;
|
|
for (i = 0; i < NUM_ORDERS; i++) {
|
if (size < order_to_size(orders[i]))
|
continue;
|
if (max_order < orders[i])
|
continue;
|
|
page = alloc_buffer_page(heap, buffer, orders[i]);
|
if (IS_ERR(page))
|
continue;
|
|
info->page = page;
|
info->order = orders[i];
|
INIT_LIST_HEAD(&info->list);
|
return info;
|
}
|
kfree(info);
|
|
return NULL;
|
}
|
|
static int ion_protected_heap_allocate(struct ion_heap *heap,
|
struct ion_buffer *buffer,
|
unsigned long size,
|
unsigned long flags)
|
{
|
struct list_head pages;
|
struct list_head lists[8];
|
struct page_info *info, *tmp;
|
struct scatterlist *sg;
|
struct sg_table *table;
|
unsigned int block_index[8] = {0};
|
unsigned int max_order = orders[0], maximum;
|
unsigned long size_remaining = PAGE_ALIGN(size);
|
int i, j;
|
|
if (size / PAGE_SIZE > totalram_pages / 2)
|
return -ENOMEM;
|
|
INIT_LIST_HEAD(&pages);
|
for (i = 0; i < 8; i++)
|
INIT_LIST_HEAD(&lists[i]);
|
|
i = 0;
|
while (size_remaining > 0) {
|
info = alloc_largest_available(heap, buffer, size_remaining,
|
max_order);
|
if (!info)
|
goto free_pages;
|
|
size_remaining -= PAGE_SIZE << info->order;
|
max_order = info->order;
|
if (max_order) {
|
list_add_tail(&info->list, &pages);
|
} else {
|
dma_addr_t phys = page_to_phys(info->page);
|
unsigned int bit12_14 = (phys >> 12) & 0x7;
|
|
list_add_tail(&info->list, &lists[bit12_14]);
|
block_index[bit12_14]++;
|
}
|
|
i++;
|
}
|
|
table = kmalloc(sizeof(*table), GFP_KERNEL);
|
if (!table)
|
goto free_pages;
|
|
if (sg_alloc_table(table, i, GFP_KERNEL))
|
goto free_table;
|
|
maximum = block_index[0];
|
for (i = 1; i < 8; i++)
|
maximum = max(maximum, block_index[i]);
|
|
sg = table->sgl;
|
list_for_each_entry_safe(info, tmp, &pages, list) {
|
sg_set_page(sg, info->page, PAGE_SIZE << info->order, 0);
|
sg = sg_next(sg);
|
list_del(&info->list);
|
}
|
|
for (i = 0; i < maximum; i++) {
|
for (j = 0; j < 8; j++) {
|
if (list_empty(&lists[j]))
|
continue;
|
|
info = list_first_entry(&lists[j], struct page_info,
|
list);
|
sg_set_page(sg, info->page, PAGE_SIZE, 0);
|
sg = sg_next(sg);
|
list_del(&info->list);
|
}
|
}
|
buffer->sg_table = table;
|
|
return 0;
|
free_table:
|
kfree(table);
|
free_pages:
|
list_for_each_entry_safe(info, tmp, &pages, list)
|
free_buffer_page(heap, buffer, info->page, info->order);
|
|
for (i = 0; i < 8; i++) {
|
list_for_each_entry_safe(info, tmp, &lists[i], list)
|
free_buffer_page(heap, buffer, info->page, info->order);
|
}
|
|
return -ENOMEM;
|
}
|
|
static void ion_protected_heap_free(struct ion_buffer *buffer)
|
{
|
struct sg_table *table = buffer->sg_table;
|
struct scatterlist *sg;
|
int i;
|
|
/* zero the buffer before goto page pool */
|
if (!(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE))
|
ion_heap_buffer_zero(buffer);
|
|
for_each_sg(table->sgl, sg, table->nents, i)
|
free_buffer_page(buffer->heap, buffer, sg_page(sg),
|
get_order(sg->length));
|
sg_free_table(table);
|
kfree(table);
|
}
|
|
static int ion_protected_heap_shrink(struct ion_heap *heap, gfp_t gfp_mask,
|
int nr_to_scan)
|
{
|
struct ion_page_pool *pool;
|
struct ion_protected_heap *pheap;
|
int nr_total = 0;
|
int i, nr_freed;
|
int only_scan = 0;
|
|
pheap = container_of(heap, struct ion_protected_heap, heap);
|
if (!nr_to_scan)
|
only_scan = 1;
|
|
for (i = 0; i < NUM_ORDERS; i++) {
|
pool = pheap->pools[i];
|
|
if (only_scan) {
|
nr_total += protected_pool_shrink(pool,
|
pheap->rmem,
|
nr_to_scan);
|
|
} else {
|
nr_freed = protected_pool_shrink(pool,
|
pheap->rmem,
|
nr_to_scan);
|
nr_to_scan -= nr_freed;
|
nr_total += nr_freed;
|
if (nr_to_scan <= 0)
|
break;
|
}
|
}
|
|
return nr_total;
|
}
|
|
static struct ion_heap_ops protected_heap_ops = {
|
.allocate = ion_protected_heap_allocate,
|
.free = ion_protected_heap_free,
|
.map_kernel = ion_heap_map_kernel,
|
.unmap_kernel = ion_heap_unmap_kernel,
|
.map_user = ion_heap_map_user,
|
.shrink = ion_protected_heap_shrink,
|
};
|
|
static int ion_protected_heap_debug_show(struct ion_heap *heap,
|
struct seq_file *s,
|
void *unused)
|
{
|
struct ion_protected_heap *pheap;
|
struct ion_page_pool *pool;
|
int i;
|
|
pheap = container_of(heap, struct ion_protected_heap, heap);
|
for (i = 0; i < NUM_ORDERS; i++) {
|
pool = pheap->pools[i];
|
|
seq_printf(s, "%d order %u highmem pages %lu total\n",
|
pool->high_count, pool->order,
|
(PAGE_SIZE << pool->order) * pool->high_count);
|
seq_printf(s, "%d order %u lowmem pages %lu total\n",
|
pool->low_count, pool->order,
|
(PAGE_SIZE << pool->order) * pool->low_count);
|
}
|
|
return 0;
|
}
|
|
static void ion_protected_heap_destroy_pools(struct ion_page_pool **pools)
|
{
|
int i;
|
|
for (i = 0; i < NUM_ORDERS; i++)
|
if (pools[i])
|
protected_pool_destroy(pools[i]);
|
}
|
|
static int ion_protected_heap_create_pools(struct ion_page_pool **pools)
|
{
|
struct ion_page_pool *pool;
|
int i;
|
|
for (i = 0; i < NUM_ORDERS; i++) {
|
pool = protected_pool_create(orders[i]);
|
if (!pool)
|
goto err_create_pool;
|
|
pools[i] = pool;
|
}
|
|
return 0;
|
err_create_pool:
|
ion_protected_heap_destroy_pools(pools);
|
|
return -ENOMEM;
|
}
|
|
static int ion_protected_heap_create_rmem(struct gen_pool **pool)
|
{
|
struct gen_pool *mpool;
|
struct reserved_mem *rmem = protected_reserved_memory;
|
int ret;
|
|
if (!rmem)
|
return -ENOENT;
|
|
mpool = gen_pool_create(PAGE_SHIFT, -1);
|
if (!mpool)
|
return -ENOMEM;
|
|
ret = gen_pool_add(mpool, rmem->base, rmem->size, -1);
|
if (ret) {
|
gen_pool_destroy(mpool);
|
return ret;
|
}
|
*pool = mpool;
|
|
return 0;
|
}
|
|
static struct ion_heap *__ion_protected_heap_create(void)
|
{
|
struct ion_protected_heap *heap;
|
|
heap = kzalloc(sizeof(*heap), GFP_KERNEL);
|
if (!heap)
|
return ERR_PTR(-ENOMEM);
|
|
heap->heap.ops = &protected_heap_ops;
|
heap->heap.type = ION_HEAP_TYPE_PROTECTED;
|
heap->heap.flags = ION_HEAP_FLAG_DEFER_FREE;
|
heap->heap.name = "ion_protected_heap";
|
|
if (ion_protected_heap_create_pools(heap->pools))
|
goto free_heap;
|
|
if (ion_protected_heap_create_rmem(&heap->rmem))
|
goto destroy_pool;
|
|
heap->heap.debug_show = ion_protected_heap_debug_show;
|
|
return &heap->heap;
|
destroy_pool:
|
ion_protected_heap_destroy_pools(heap->pools);
|
free_heap:
|
kfree(heap);
|
|
return ERR_PTR(-ENOMEM);
|
}
|
|
int ion_protected_heap_create(void)
|
{
|
struct ion_heap *heap;
|
|
heap = __ion_protected_heap_create();
|
if (IS_ERR(heap))
|
return PTR_ERR(heap);
|
|
ion_device_add_heap(heap);
|
|
return 0;
|
}
|
|
#ifndef CONFIG_ION_MODULE
|
device_initcall(ion_protected_heap_create);
|
#endif
|
