drivers/gpu/ion/ion_iommu_heap.c

/*
 * Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */
#include <linux/err.h>
#include <linux/io.h>
#include <linux/msm_ion.h>
#include <linux/mm.h>
#include <linux/highmem.h>
#include <linux/scatterlist.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/iommu.h>
#include <linux/pfn.h>
#include <linux/dma-mapping.h>
#include "ion_priv.h"

#include <asm/mach/map.h>
#include <asm/page.h>
#include <asm/cacheflush.h>
#include <mach/iommu_domains.h>
#include <trace/events/kmem.h>

struct ion_iommu_heap {
	struct ion_heap heap;
	struct ion_page_pool **cached_pools;
	struct ion_page_pool **uncached_pools;
};

/*
 * We will attempt to allocate high-order pages and store those in an
 * sg_list. However, some APIs expect an array of struct page * where
 * each page is of size PAGE_SIZE. We use this extra structure to
 * carry around an array of such pages (derived from the high-order
 * pages with nth_page).
 */
struct ion_iommu_priv_data {
	struct page **pages;
	unsigned int pages_uses_vmalloc;
	int nrpages;
	unsigned long size;
};

#define MAX_VMAP_RETRIES 10
#define BAD_ORDER	-1

static const unsigned int orders[] = {9, 8, 4, 0};
static const int num_orders = ARRAY_SIZE(orders);
static unsigned int low_gfp_flags = __GFP_HIGHMEM | GFP_KERNEL | __GFP_ZERO;
static unsigned int high_gfp_flags = (__GFP_HIGHMEM | __GFP_NORETRY
				| __GFP_NO_KSWAPD | __GFP_NOWARN |
				 __GFP_IO | __GFP_FS | __GFP_ZERO);

struct page_info {
	struct page *page;
	unsigned int order;
	struct list_head list;
};

static int order_to_index(unsigned int order)
{
	int i;
	for (i = 0; i < num_orders; i++)
		if (order == orders[i])
			return i;
	BUG();
	return BAD_ORDER;
}

static unsigned int order_to_size(int order)
{
	return PAGE_SIZE << order;
}

static struct page_info *alloc_largest_available(struct ion_iommu_heap *heap,
						unsigned long size,
						unsigned int max_order,
						unsigned long flags)
{
	struct page *page;
	struct page_info *info;
	int i;

	for (i = 0; i < num_orders; i++) {
		gfp_t gfp;
		int idx = order_to_index(orders[i]);
		struct ion_page_pool *pool;

		if (idx == BAD_ORDER)
			continue;

		if (ION_IS_CACHED(flags)) {
			pool = heap->cached_pools[idx];
			BUG_ON(!pool);
		} else {
			pool = heap->uncached_pools[idx];
			BUG_ON(!pool);
		}

		if (size < order_to_size(orders[i]))
			continue;
		if (max_order < orders[i])
			continue;

		if (orders[i]) {
			gfp = high_gfp_flags;
		} else {
			gfp = low_gfp_flags;
		}
		trace_alloc_pages_iommu_start(gfp, orders[i]);
		if (flags & ION_FLAG_POOL_FORCE_ALLOC)
			page = alloc_pages(gfp, orders[i]);
		else
			page = ion_page_pool_alloc(pool);
		trace_alloc_pages_iommu_end(gfp, orders[i]);
		if (!page) {
			trace_alloc_pages_iommu_fail(gfp, orders[i]);
			continue;
		}

		info = kmalloc(sizeof(struct page_info), GFP_KERNEL);
		if (info) {
			info->page = page;
			info->order = orders[i];
		}
		return info;
	}
	return NULL;
}

static int ion_iommu_buffer_zero(struct ion_iommu_priv_data *data,
				bool is_cached)
{
	int i, j, k;
	unsigned int npages_to_vmap;
	unsigned int total_pages;
	void *ptr = NULL;
	/*
	 * It's cheaper just to use writecombine memory and skip the
	 * cache vs. using a cache memory and trying to flush it afterwards
	 */
	pgprot_t pgprot = pgprot_writecombine(pgprot_kernel);

	/*
	 * As an optimization, we manually zero out all of the
	 * pages in one fell swoop here. To safeguard against
	 * insufficient vmalloc space, we only vmap
	 * `npages_to_vmap' at a time, starting with a
	 * conservative estimate of 1/8 of the total number of
	 * vmalloc pages available. Note that the `pages'
	 * array is composed of all 4K pages, irrespective of
	 * the size of the pages on the sg list.
	 */
	npages_to_vmap = ((VMALLOC_END - VMALLOC_START)/8)
			>> PAGE_SHIFT;
	total_pages = data->nrpages;
	for (i = 0; i < total_pages; i += npages_to_vmap) {
		npages_to_vmap = min(npages_to_vmap, total_pages - i);
		for (j = 0; j < MAX_VMAP_RETRIES && npages_to_vmap;
			++j) {
			ptr = vmap(&data->pages[i], npages_to_vmap,
					VM_IOREMAP, pgprot);
			if (ptr)
				break;
			else
				npages_to_vmap >>= 1;
		}
		if (!ptr)
			return -ENOMEM;

		memset(ptr, 0, npages_to_vmap * PAGE_SIZE);
		if (is_cached) {
			/*
			 * invalidate the cache to pick up the zeroing
			 */
			for (k = 0; k < npages_to_vmap; k++) {
				void *p = kmap_atomic(data->pages[i + k]);
				phys_addr_t phys = page_to_phys(
							data->pages[i + k]);

				dmac_inv_range(p, p + PAGE_SIZE);
				outer_inv_range(phys, phys + PAGE_SIZE);
				kunmap_atomic(p);
			}
		}
		vunmap(ptr);
	}

	return 0;
}

static int ion_iommu_heap_allocate(struct ion_heap *heap,
				      struct ion_buffer *buffer,
				      unsigned long size, unsigned long align,
				      unsigned long flags)
{
	int ret, i;
	struct list_head pages_list;
	struct page_info *info, *tmp_info;
	struct ion_iommu_priv_data *data = NULL;
	struct ion_iommu_heap *iommu_heap =
		container_of(heap, struct ion_iommu_heap, heap);

	if (msm_use_iommu()) {
		struct scatterlist *sg;
		struct sg_table *table;
		int j;
		unsigned int num_large_pages = 0;
		unsigned long size_remaining = PAGE_ALIGN(size);
		unsigned int max_order = ION_IS_CACHED(flags) ? 0 : orders[0];
		unsigned int page_tbl_size;

		data = kmalloc(sizeof(*data), GFP_KERNEL);
		if (!data)
			return -ENOMEM;

		INIT_LIST_HEAD(&pages_list);
		while (size_remaining > 0) {
			info = alloc_largest_available(iommu_heap,
						size_remaining,
						max_order,
						flags);
			if (!info) {
				ret = -ENOMEM;
				goto err_free_data;
			}
			list_add_tail(&info->list, &pages_list);
			size_remaining -= order_to_size(info->order);
			max_order = info->order;
			num_large_pages++;
		}

		data->size = PFN_ALIGN(size);
		data->nrpages = data->size >> PAGE_SHIFT;
		data->pages_uses_vmalloc = 0;
		page_tbl_size = sizeof(struct page *) * data->nrpages;

		if (page_tbl_size > SZ_8K) {
			/*
			 * Do fallback to ensure we have a balance between
			 * performance and availability.
			 */
			data->pages = kmalloc(page_tbl_size,
					      __GFP_COMP | __GFP_NORETRY |
					      __GFP_NO_KSWAPD | __GFP_NOWARN);
			if (!data->pages) {
				data->pages = vmalloc(page_tbl_size);
				data->pages_uses_vmalloc = 1;
			}
		} else {
			data->pages = kmalloc(page_tbl_size, GFP_KERNEL);
		}
		if (!data->pages) {
			ret = -ENOMEM;
			goto err_free_data;
		}

		table = buffer->sg_table =
				kzalloc(sizeof(struct sg_table), GFP_KERNEL);

		if (!table) {
			ret = -ENOMEM;
			goto err1;
		}
		ret = sg_alloc_table(table, num_large_pages, GFP_KERNEL);
		if (ret)
			goto err2;

		i = 0;
		sg = table->sgl;
		list_for_each_entry_safe(info, tmp_info, &pages_list, list) {
			struct page *page = info->page;
			sg_set_page(sg, page, order_to_size(info->order), 0);
			sg_dma_address(sg) = sg_phys(sg);
			sg = sg_next(sg);
			for (j = 0; j < (1 << info->order); ++j)
				data->pages[i++] = nth_page(page, j);
			list_del(&info->list);
			kfree(info);
		}


		if (flags & ION_FLAG_POOL_FORCE_ALLOC) {
			ret = ion_iommu_buffer_zero(data, ION_IS_CACHED(flags));
			if (ret) {
				pr_err("Couldn't vmap the pages for zeroing\n");
				goto err3;
			}


			if (!ION_IS_CACHED(flags))
				dma_sync_sg_for_device(NULL, table->sgl,
						table->nents,
						DMA_BIDIRECTIONAL);

		}
		buffer->priv_virt = data;
		return 0;

	} else {
		return -ENOMEM;
	}


err3:
	sg_free_table(buffer->sg_table);
err2:
	kfree(buffer->sg_table);
	buffer->sg_table = 0;
err1:
	if (data->pages_uses_vmalloc)
		vfree(data->pages);
	else
		kfree(data->pages);
err_free_data:
	kfree(data);

	list_for_each_entry_safe(info, tmp_info, &pages_list, list) {
		if (info->page)
			__free_pages(info->page, info->order);
		list_del(&info->list);
		kfree(info);
	}
	return ret;
}

static void ion_iommu_heap_free(struct ion_buffer *buffer)
{
	int i;
	struct scatterlist *sg;
	struct sg_table *table = buffer->sg_table;
	struct ion_iommu_priv_data *data = buffer->priv_virt;
	bool cached = ion_buffer_cached(buffer);
	struct ion_iommu_heap *iommu_heap =
	     container_of(buffer->heap, struct	ion_iommu_heap, heap);

	if (!table)
		return;
	if (!data)
		return;

	if (!(buffer->flags & ION_FLAG_POOL_FORCE_ALLOC))
		ion_iommu_buffer_zero(data, ION_IS_CACHED(buffer->flags));

	for_each_sg(table->sgl, sg, table->nents, i) {
		int order = get_order(sg_dma_len(sg));
		int idx = order_to_index(order);
		struct ion_page_pool *pool;

		if (idx == BAD_ORDER) {
			WARN_ON(1);
			continue;
		}

		if (cached)
			pool = iommu_heap->cached_pools[idx];
		else
			pool = iommu_heap->uncached_pools[idx];

		if (buffer->flags & ION_FLAG_POOL_FORCE_ALLOC)
			__free_pages(sg_page(sg), order);
		else
			ion_page_pool_free(pool, sg_page(sg));
	}

	sg_free_table(table);
	kfree(table);
	table = 0;
	if (data->pages_uses_vmalloc)
		vfree(data->pages);
	else
		kfree(data->pages);
	kfree(data);
}

void *ion_iommu_heap_map_kernel(struct ion_heap *heap,
				struct ion_buffer *buffer)
{
	struct ion_iommu_priv_data *data = buffer->priv_virt;
	pgprot_t page_prot = PAGE_KERNEL;

	if (!data)
		return NULL;

	if (!ION_IS_CACHED(buffer->flags))
		page_prot = pgprot_writecombine(page_prot);

	buffer->vaddr = vmap(data->pages, data->nrpages, VM_IOREMAP, page_prot);

	return buffer->vaddr;
}

void ion_iommu_heap_unmap_kernel(struct ion_heap *heap,
				    struct ion_buffer *buffer)
{
	if (!buffer->vaddr)
		return;

	vunmap(buffer->vaddr);
	buffer->vaddr = NULL;
}

int ion_iommu_heap_map_user(struct ion_heap *heap, struct ion_buffer *buffer,
			       struct vm_area_struct *vma)
{
	struct sg_table *table = buffer->sg_table;
	unsigned long addr = vma->vm_start;
	unsigned long offset = vma->vm_pgoff * PAGE_SIZE;
	struct scatterlist *sg;
	int i;

	if (!ION_IS_CACHED(buffer->flags))
		vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);

	for_each_sg(table->sgl, sg, table->nents, i) {
		struct page *page = sg_page(sg);
		unsigned long remainder = vma->vm_end - addr;
		unsigned long len = sg_dma_len(sg);

		if (offset >= sg_dma_len(sg)) {
			offset -= sg_dma_len(sg);
			continue;
		} else if (offset) {
			page += offset / PAGE_SIZE;
			len = sg_dma_len(sg) - offset;
			offset = 0;
		}
		len = min(len, remainder);
		remap_pfn_range(vma, addr, page_to_pfn(page), len,
				vma->vm_page_prot);
		addr += len;
		if (addr >= vma->vm_end)
			return 0;
	}
	return 0;
}

static struct sg_table *ion_iommu_heap_map_dma(struct ion_heap *heap,
					      struct ion_buffer *buffer)
{
	return buffer->sg_table;
}

static void ion_iommu_heap_unmap_dma(struct ion_heap *heap,
				 struct ion_buffer *buffer)
{
}

static int ion_iommu_heap_debug_show(struct ion_heap *heap, struct seq_file *s,
					void *unused)
{

	struct ion_iommu_heap *iommu_heap = container_of(heap,
							struct ion_iommu_heap,
							heap);
	int i;
	unsigned long total = 0;

	seq_printf(s, "Cached Pools:\n");
	for (i = 0; i < num_orders; i++) {
		struct ion_page_pool *pool = iommu_heap->cached_pools[i];
		seq_printf(s, "%d order %u highmem pages in pool = %lx total\n",
			   pool->high_count, pool->order,
			   (1 << pool->order) * PAGE_SIZE * pool->high_count);
		seq_printf(s, "%d order %u lowmem pages in pool = %lx total\n",
			   pool->low_count, pool->order,
			   (1 << pool->order) * PAGE_SIZE * pool->low_count);

		total += (1 << pool->order) * PAGE_SIZE *
			  (pool->low_count + pool->high_count);
	}

	seq_printf(s, "Uncached Pools:\n");
	for (i = 0; i < num_orders; i++) {
		struct ion_page_pool *pool = iommu_heap->uncached_pools[i];
		seq_printf(s, "%d order %u highmem pages in pool = %lx total\n",
			   pool->high_count, pool->order,
			   (1 << pool->order) * PAGE_SIZE * pool->high_count);
		seq_printf(s, "%d order %u lowmem pages in pool = %lx total\n",
			   pool->low_count, pool->order,
			   (1 << pool->order) * PAGE_SIZE * pool->low_count);

		total += (1 << pool->order) * PAGE_SIZE *
			  (pool->low_count + pool->high_count);
	}
	seq_printf(s, "Total bytes in pool: %lx\n", total);
	return 0;
}

static struct ion_heap_ops iommu_heap_ops = {
	.allocate = ion_iommu_heap_allocate,
	.free = ion_iommu_heap_free,
	.map_user = ion_iommu_heap_map_user,
	.map_kernel = ion_iommu_heap_map_kernel,
	.unmap_kernel = ion_iommu_heap_unmap_kernel,
	.map_dma = ion_iommu_heap_map_dma,
	.unmap_dma = ion_iommu_heap_unmap_dma,
};

struct ion_heap *ion_iommu_heap_create(struct ion_platform_heap *heap_data)
{
	struct ion_iommu_heap *iommu_heap;
	int i;

	iommu_heap = kzalloc(sizeof(struct ion_iommu_heap), GFP_KERNEL);
	if (!iommu_heap)
		return ERR_PTR(-ENOMEM);

	iommu_heap->heap.ops = &iommu_heap_ops;
	iommu_heap->heap.type = ION_HEAP_TYPE_IOMMU;
	iommu_heap->uncached_pools = kzalloc(
			      sizeof(struct ion_page_pool *) * num_orders,
			      GFP_KERNEL);
	if (!iommu_heap->uncached_pools)
		goto err_alloc_uncached_pools;

	iommu_heap->cached_pools = kzalloc(
			      sizeof(struct ion_page_pool *) * num_orders,
			      GFP_KERNEL);

	if (!iommu_heap->cached_pools)
		goto err_alloc_cached_pools;

	for (i = 0; i < num_orders; i++) {
		struct ion_page_pool *pool;
		gfp_t gfp_flags;

		if (orders[i])
			gfp_flags = high_gfp_flags | __GFP_ZERO;
		else
			gfp_flags = low_gfp_flags | __GFP_ZERO;
		pool = ion_page_pool_create(gfp_flags, orders[i]);
		if (!pool)
			goto err_create_cached_pool;
		iommu_heap->cached_pools[i] = pool;
	}

	for (i = 0; i < num_orders; i++) {
		struct ion_page_pool *pool;
		gfp_t gfp_flags;

		if (orders[i])
			gfp_flags = high_gfp_flags | __GFP_ZERO;
		else
			gfp_flags = low_gfp_flags | __GFP_ZERO;
		pool = ion_page_pool_create(gfp_flags, orders[i]);
		if (!pool)
			goto err_create_uncached_pool;
		iommu_heap->uncached_pools[i] = pool;
	}
	iommu_heap->heap.debug_show = ion_iommu_heap_debug_show;
	return &iommu_heap->heap;

err_create_uncached_pool:
	for (i = 0; i < num_orders; i++)
		if (iommu_heap->cached_pools[i])
			ion_page_pool_destroy(iommu_heap->uncached_pools[i]);


err_create_cached_pool:
	for (i = 0; i < num_orders; i++)
		if (iommu_heap->uncached_pools[i])
			ion_page_pool_destroy(iommu_heap->cached_pools[i]);

	kfree(iommu_heap->cached_pools);
err_alloc_cached_pools:
	kfree(iommu_heap->uncached_pools);
err_alloc_uncached_pools:
	kfree(iommu_heap);
	return ERR_PTR(-ENOMEM);
}

void ion_iommu_heap_destroy(struct ion_heap *heap)
{
	struct ion_iommu_heap *iommu_heap =
	     container_of(heap, struct  ion_iommu_heap, heap);

	kfree(iommu_heap);
	iommu_heap = NULL;
}