[deliverable/linux.git] / drivers / iommu / omap-iovmm.c

/*
 * omap iommu: simple virtual address space management
 *
 * Copyright (C) 2008-2009 Nokia Corporation
 *
 * Written by Hiroshi DOYU <Hiroshi.DOYU@nokia.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/module.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/device.h>
#include <linux/scatterlist.h>
#include <linux/iommu.h>

#include <asm/cacheflush.h>
#include <asm/mach/map.h>

#include <plat/iommu.h>
#include <plat/iovmm.h>

#include <plat/iopgtable.h>

static struct kmem_cache *iovm_area_cachep;

/* return the offset of the first scatterlist entry in a sg table */
static unsigned int sgtable_offset(const struct sg_table *sgt)
{
	if (!sgt || !sgt->nents)
		return 0;

	return sgt->sgl->offset;
}

/* return total bytes of sg buffers */
static size_t sgtable_len(const struct sg_table *sgt)
{
	unsigned int i, total = 0;
	struct scatterlist *sg;

	if (!sgt)
		return 0;

	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
		size_t bytes;

		bytes = sg->length + sg->offset;

		if (!iopgsz_ok(bytes)) {
			pr_err("%s: sg[%d] not iommu pagesize(%u %u)\n",
			       __func__, i, bytes, sg->offset);
			return 0;
		}

		if (i && sg->offset) {
			pr_err("%s: sg[%d] offset not allowed in internal "
					"entries\n", __func__, i);
			return 0;
		}

		total += bytes;
	}

	return total;
}
#define sgtable_ok(x)	(!!sgtable_len(x))

static unsigned max_alignment(u32 addr)
{
	int i;
	unsigned pagesize[] = { SZ_16M, SZ_1M, SZ_64K, SZ_4K, };
	for (i = 0; i < ARRAY_SIZE(pagesize) && addr & (pagesize[i] - 1); i++)
		;
	return (i < ARRAY_SIZE(pagesize)) ? pagesize[i] : 0;
}

/*
 * calculate the optimal number sg elements from total bytes based on
 * iommu superpages
 */
static unsigned sgtable_nents(size_t bytes, u32 da, u32 pa)
{
	unsigned nr_entries = 0, ent_sz;

	if (!IS_ALIGNED(bytes, PAGE_SIZE)) {
		pr_err("%s: wrong size %08x\n", __func__, bytes);
		return 0;
	}

	while (bytes) {
		ent_sz = max_alignment(da | pa);
		ent_sz = min_t(unsigned, ent_sz, iopgsz_max(bytes));
		nr_entries++;
		da += ent_sz;
		pa += ent_sz;
		bytes -= ent_sz;
	}

	return nr_entries;
}

/* allocate and initialize sg_table header(a kind of 'superblock') */
static struct sg_table *sgtable_alloc(const size_t bytes, u32 flags,
							u32 da, u32 pa)
{
	unsigned int nr_entries;
	int err;
	struct sg_table *sgt;

	if (!bytes)
		return ERR_PTR(-EINVAL);

	if (!IS_ALIGNED(bytes, PAGE_SIZE))
		return ERR_PTR(-EINVAL);

	if (flags & IOVMF_LINEAR) {
		nr_entries = sgtable_nents(bytes, da, pa);
		if (!nr_entries)
			return ERR_PTR(-EINVAL);
	} else
		nr_entries =  bytes / PAGE_SIZE;

	sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
	if (!sgt)
		return ERR_PTR(-ENOMEM);

	err = sg_alloc_table(sgt, nr_entries, GFP_KERNEL);
	if (err) {
		kfree(sgt);
		return ERR_PTR(err);
	}

	pr_debug("%s: sgt:%p(%d entries)\n", __func__, sgt, nr_entries);

	return sgt;
}

/* free sg_table header(a kind of superblock) */
static void sgtable_free(struct sg_table *sgt)
{
	if (!sgt)
		return;

	sg_free_table(sgt);
	kfree(sgt);

	pr_debug("%s: sgt:%p\n", __func__, sgt);
}

/* map 'sglist' to a contiguous mpu virtual area and return 'va' */
static void *vmap_sg(const struct sg_table *sgt)
{
	u32 va;
	size_t total;
	unsigned int i;
	struct scatterlist *sg;
	struct vm_struct *new;
	const struct mem_type *mtype;

	mtype = get_mem_type(MT_DEVICE);
	if (!mtype)
		return ERR_PTR(-EINVAL);

	total = sgtable_len(sgt);
	if (!total)
		return ERR_PTR(-EINVAL);

	new = __get_vm_area(total, VM_IOREMAP, VMALLOC_START, VMALLOC_END);
	if (!new)
		return ERR_PTR(-ENOMEM);
	va = (u32)new->addr;

	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
		size_t bytes;
		u32 pa;
		int err;

		pa = sg_phys(sg) - sg->offset;
		bytes = sg->length + sg->offset;

		BUG_ON(bytes != PAGE_SIZE);

		err = ioremap_page(va,  pa, mtype);
		if (err)
			goto err_out;

		va += bytes;
	}

	flush_cache_vmap((unsigned long)new->addr,
				(unsigned long)(new->addr + total));
	return new->addr;

err_out:
	WARN_ON(1); /* FIXME: cleanup some mpu mappings */
	vunmap(new->addr);
	return ERR_PTR(-EAGAIN);
}

static inline void vunmap_sg(const void *va)
{
	vunmap(va);
}

static struct iovm_struct *__find_iovm_area(struct omap_iommu *obj,
							const u32 da)
{
	struct iovm_struct *tmp;

	list_for_each_entry(tmp, &obj->mmap, list) {
		if ((da >= tmp->da_start) && (da < tmp->da_end)) {
			size_t len;

			len = tmp->da_end - tmp->da_start;

			dev_dbg(obj->dev, "%s: %08x-%08x-%08x(%x) %08x\n",
				__func__, tmp->da_start, da, tmp->da_end, len,
				tmp->flags);

			return tmp;
		}
	}

	return NULL;
}

/**
 * omap_find_iovm_area  -  find iovma which includes @da
 * @dev:	client device
 * @da:		iommu device virtual address
 *
 * Find the existing iovma starting at @da
 */
struct iovm_struct *omap_find_iovm_area(struct device *dev, u32 da)
{
	struct omap_iommu *obj = dev_to_omap_iommu(dev);
	struct iovm_struct *area;

	mutex_lock(&obj->mmap_lock);
	area = __find_iovm_area(obj, da);
	mutex_unlock(&obj->mmap_lock);

	return area;
}
EXPORT_SYMBOL_GPL(omap_find_iovm_area);

/*
 * This finds the hole(area) which fits the requested address and len
 * in iovmas mmap, and returns the new allocated iovma.
 */
static struct iovm_struct *alloc_iovm_area(struct omap_iommu *obj, u32 da,
					   size_t bytes, u32 flags)
{
	struct iovm_struct *new, *tmp;
	u32 start, prev_end, alignment;

	if (!obj || !bytes)
		return ERR_PTR(-EINVAL);

	start = da;
	alignment = PAGE_SIZE;

	if (~flags & IOVMF_DA_FIXED) {
		/* Don't map address 0 */
		start = obj->da_start ? obj->da_start : alignment;

		if (flags & IOVMF_LINEAR)
			alignment = iopgsz_max(bytes);
		start = roundup(start, alignment);
	} else if (start < obj->da_start || start > obj->da_end ||
					obj->da_end - start < bytes) {
		return ERR_PTR(-EINVAL);
	}

	tmp = NULL;
	if (list_empty(&obj->mmap))
		goto found;

	prev_end = 0;
	list_for_each_entry(tmp, &obj->mmap, list) {

		if (prev_end > start)
			break;

		if (tmp->da_start > start && (tmp->da_start - start) >= bytes)
			goto found;

		if (tmp->da_end >= start && ~flags & IOVMF_DA_FIXED)
			start = roundup(tmp->da_end + 1, alignment);

		prev_end = tmp->da_end;
	}

	if ((start >= prev_end) && (obj->da_end - start >= bytes))
		goto found;

	dev_dbg(obj->dev, "%s: no space to fit %08x(%x) flags: %08x\n",
		__func__, da, bytes, flags);

	return ERR_PTR(-EINVAL);

found:
	new = kmem_cache_zalloc(iovm_area_cachep, GFP_KERNEL);
	if (!new)
		return ERR_PTR(-ENOMEM);

	new->iommu = obj;
	new->da_start = start;
	new->da_end = start + bytes;
	new->flags = flags;

	/*
	 * keep ascending order of iovmas
	 */
	if (tmp)
		list_add_tail(&new->list, &tmp->list);
	else
		list_add(&new->list, &obj->mmap);

	dev_dbg(obj->dev, "%s: found %08x-%08x-%08x(%x) %08x\n",
		__func__, new->da_start, start, new->da_end, bytes, flags);

	return new;
}

static void free_iovm_area(struct omap_iommu *obj, struct iovm_struct *area)
{
	size_t bytes;

	BUG_ON(!obj || !area);

	bytes = area->da_end - area->da_start;

	dev_dbg(obj->dev, "%s: %08x-%08x(%x) %08x\n",
		__func__, area->da_start, area->da_end, bytes, area->flags);

	list_del(&area->list);
	kmem_cache_free(iovm_area_cachep, area);
}

/**
 * omap_da_to_va - convert (d) to (v)
 * @dev:	client device
 * @da:		iommu device virtual address
 * @va:		mpu virtual address
 *
 * Returns mpu virtual addr which corresponds to a given device virtual addr
 */
void *omap_da_to_va(struct device *dev, u32 da)
{
	struct omap_iommu *obj = dev_to_omap_iommu(dev);
	void *va = NULL;
	struct iovm_struct *area;

	mutex_lock(&obj->mmap_lock);

	area = __find_iovm_area(obj, da);
	if (!area) {
		dev_dbg(obj->dev, "%s: no da area(%08x)\n", __func__, da);
		goto out;
	}
	va = area->va;
out:
	mutex_unlock(&obj->mmap_lock);

	return va;
}
EXPORT_SYMBOL_GPL(omap_da_to_va);

static void sgtable_fill_vmalloc(struct sg_table *sgt, void *_va)
{
	unsigned int i;
	struct scatterlist *sg;
	void *va = _va;
	void *va_end;

	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
		struct page *pg;
		const size_t bytes = PAGE_SIZE;

		/*
		 * iommu 'superpage' isn't supported with 'omap_iommu_vmalloc()'
		 */
		pg = vmalloc_to_page(va);
		BUG_ON(!pg);
		sg_set_page(sg, pg, bytes, 0);

		va += bytes;
	}

	va_end = _va + PAGE_SIZE * i;
}

static inline void sgtable_drain_vmalloc(struct sg_table *sgt)
{
	/*
	 * Actually this is not necessary at all, just exists for
	 * consistency of the code readability.
	 */
	BUG_ON(!sgt);
}

/* create 'da' <-> 'pa' mapping from 'sgt' */
static int map_iovm_area(struct iommu_domain *domain, struct iovm_struct *new,
			const struct sg_table *sgt, u32 flags)
{
	int err;
	unsigned int i, j;
	struct scatterlist *sg;
	u32 da = new->da_start;

	if (!domain || !sgt)
		return -EINVAL;

	BUG_ON(!sgtable_ok(sgt));

	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
		u32 pa;
		size_t bytes;

		pa = sg_phys(sg) - sg->offset;
		bytes = sg->length + sg->offset;

		flags &= ~IOVMF_PGSZ_MASK;

		if (bytes_to_iopgsz(bytes) < 0)
			goto err_out;

		pr_debug("%s: [%d] %08x %08x(%x)\n", __func__,
			 i, da, pa, bytes);

		err = iommu_map(domain, da, pa, bytes, flags);
		if (err)
			goto err_out;

		da += bytes;
	}
	return 0;

err_out:
	da = new->da_start;

	for_each_sg(sgt->sgl, sg, i, j) {
		size_t bytes;

		bytes = sg->length + sg->offset;

		/* ignore failures.. we're already handling one */
		iommu_unmap(domain, da, bytes);

		da += bytes;
	}
	return err;
}

/* release 'da' <-> 'pa' mapping */
static void unmap_iovm_area(struct iommu_domain *domain, struct omap_iommu *obj,
						struct iovm_struct *area)
{
	u32 start;
	size_t total = area->da_end - area->da_start;
	const struct sg_table *sgt = area->sgt;
	struct scatterlist *sg;
	int i;
	size_t unmapped;

	BUG_ON(!sgtable_ok(sgt));
	BUG_ON((!total) || !IS_ALIGNED(total, PAGE_SIZE));

	start = area->da_start;
	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
		size_t bytes;

		bytes = sg->length + sg->offset;

		unmapped = iommu_unmap(domain, start, bytes);
		if (unmapped < bytes)
			break;

		dev_dbg(obj->dev, "%s: unmap %08x(%x) %08x\n",
				__func__, start, bytes, area->flags);

		BUG_ON(!IS_ALIGNED(bytes, PAGE_SIZE));

		total -= bytes;
		start += bytes;
	}
	BUG_ON(total);
}

/* template function for all unmapping */
static struct sg_table *unmap_vm_area(struct iommu_domain *domain,
				      struct omap_iommu *obj, const u32 da,
				      void (*fn)(const void *), u32 flags)
{
	struct sg_table *sgt = NULL;
	struct iovm_struct *area;

	if (!IS_ALIGNED(da, PAGE_SIZE)) {
		dev_err(obj->dev, "%s: alignment err(%08x)\n", __func__, da);
		return NULL;
	}

	mutex_lock(&obj->mmap_lock);

	area = __find_iovm_area(obj, da);
	if (!area) {
		dev_dbg(obj->dev, "%s: no da area(%08x)\n", __func__, da);
		goto out;
	}

	if ((area->flags & flags) != flags) {
		dev_err(obj->dev, "%s: wrong flags(%08x)\n", __func__,
			area->flags);
		goto out;
	}
	sgt = (struct sg_table *)area->sgt;

	unmap_iovm_area(domain, obj, area);

	fn(area->va);

	dev_dbg(obj->dev, "%s: %08x-%08x-%08x(%x) %08x\n", __func__,
		area->da_start, da, area->da_end,
		area->da_end - area->da_start, area->flags);

	free_iovm_area(obj, area);
out:
	mutex_unlock(&obj->mmap_lock);

	return sgt;
}

static u32 map_iommu_region(struct iommu_domain *domain, struct omap_iommu *obj,
				u32 da, const struct sg_table *sgt, void *va,
				size_t bytes, u32 flags)
{
	int err = -ENOMEM;
	struct iovm_struct *new;

	mutex_lock(&obj->mmap_lock);

	new = alloc_iovm_area(obj, da, bytes, flags);
	if (IS_ERR(new)) {
		err = PTR_ERR(new);
		goto err_alloc_iovma;
	}
	new->va = va;
	new->sgt = sgt;

	if (map_iovm_area(domain, new, sgt, new->flags))
		goto err_map;

	mutex_unlock(&obj->mmap_lock);

	dev_dbg(obj->dev, "%s: da:%08x(%x) flags:%08x va:%p\n",
		__func__, new->da_start, bytes, new->flags, va);

	return new->da_start;

err_map:
	free_iovm_area(obj, new);
err_alloc_iovma:
	mutex_unlock(&obj->mmap_lock);
	return err;
}

static inline u32
__iommu_vmap(struct iommu_domain *domain, struct omap_iommu *obj,
				u32 da, const struct sg_table *sgt,
				void *va, size_t bytes, u32 flags)
{
	return map_iommu_region(domain, obj, da, sgt, va, bytes, flags);
}

/**
 * omap_iommu_vmap  -  (d)-(p)-(v) address mapper
 * @domain:	iommu domain
 * @dev:	client device
 * @sgt:	address of scatter gather table
 * @flags:	iovma and page property
 *
 * Creates 1-n-1 mapping with given @sgt and returns @da.
 * All @sgt element must be io page size aligned.
 */
u32 omap_iommu_vmap(struct iommu_domain *domain, struct device *dev, u32 da,
		const struct sg_table *sgt, u32 flags)
{
	struct omap_iommu *obj = dev_to_omap_iommu(dev);
	size_t bytes;
	void *va = NULL;

	if (!obj || !obj->dev || !sgt)
		return -EINVAL;

	bytes = sgtable_len(sgt);
	if (!bytes)
		return -EINVAL;
	bytes = PAGE_ALIGN(bytes);

	if (flags & IOVMF_MMIO) {
		va = vmap_sg(sgt);
		if (IS_ERR(va))
			return PTR_ERR(va);
	}

	flags |= IOVMF_DISCONT;
	flags |= IOVMF_MMIO;

	da = __iommu_vmap(domain, obj, da, sgt, va, bytes, flags);
	if (IS_ERR_VALUE(da))
		vunmap_sg(va);

	return da + sgtable_offset(sgt);
}
EXPORT_SYMBOL_GPL(omap_iommu_vmap);

/**
 * omap_iommu_vunmap  -  release virtual mapping obtained by 'omap_iommu_vmap()'
 * @domain:	iommu domain
 * @dev:	client device
 * @da:		iommu device virtual address
 *
 * Free the iommu virtually contiguous memory area starting at
 * @da, which was returned by 'omap_iommu_vmap()'.
 */
struct sg_table *
omap_iommu_vunmap(struct iommu_domain *domain, struct device *dev, u32 da)
{
	struct omap_iommu *obj = dev_to_omap_iommu(dev);
	struct sg_table *sgt;
	/*
	 * 'sgt' is allocated before 'omap_iommu_vmalloc()' is called.
	 * Just returns 'sgt' to the caller to free
	 */
	da &= PAGE_MASK;
	sgt = unmap_vm_area(domain, obj, da, vunmap_sg,
					IOVMF_DISCONT | IOVMF_MMIO);
	if (!sgt)
		dev_dbg(obj->dev, "%s: No sgt\n", __func__);
	return sgt;
}
EXPORT_SYMBOL_GPL(omap_iommu_vunmap);

/**
 * omap_iommu_vmalloc  -  (d)-(p)-(v) address allocator and mapper
 * @dev:	client device
 * @da:		contiguous iommu virtual memory
 * @bytes:	allocation size
 * @flags:	iovma and page property
 *
 * Allocate @bytes linearly and creates 1-n-1 mapping and returns
 * @da again, which might be adjusted if 'IOVMF_DA_FIXED' is not set.
 */
u32
omap_iommu_vmalloc(struct iommu_domain *domain, struct device *dev, u32 da,
						size_t bytes, u32 flags)
{
	struct omap_iommu *obj = dev_to_omap_iommu(dev);
	void *va;
	struct sg_table *sgt;

	if (!obj || !obj->dev || !bytes)
		return -EINVAL;

	bytes = PAGE_ALIGN(bytes);

	va = vmalloc(bytes);
	if (!va)
		return -ENOMEM;

	flags |= IOVMF_DISCONT;
	flags |= IOVMF_ALLOC;

	sgt = sgtable_alloc(bytes, flags, da, 0);
	if (IS_ERR(sgt)) {
		da = PTR_ERR(sgt);
		goto err_sgt_alloc;
	}
	sgtable_fill_vmalloc(sgt, va);

	da = __iommu_vmap(domain, obj, da, sgt, va, bytes, flags);
	if (IS_ERR_VALUE(da))
		goto err_iommu_vmap;

	return da;

err_iommu_vmap:
	sgtable_drain_vmalloc(sgt);
	sgtable_free(sgt);
err_sgt_alloc:
	vfree(va);
	return da;
}
EXPORT_SYMBOL_GPL(omap_iommu_vmalloc);

/**
 * omap_iommu_vfree  -  release memory allocated by 'omap_iommu_vmalloc()'
 * @dev:	client device
 * @da:		iommu device virtual address
 *
 * Frees the iommu virtually continuous memory area starting at
 * @da, as obtained from 'omap_iommu_vmalloc()'.
 */
void omap_iommu_vfree(struct iommu_domain *domain, struct device *dev,
								const u32 da)
{
	struct omap_iommu *obj = dev_to_omap_iommu(dev);
	struct sg_table *sgt;

	sgt = unmap_vm_area(domain, obj, da, vfree,
						IOVMF_DISCONT | IOVMF_ALLOC);
	if (!sgt)
		dev_dbg(obj->dev, "%s: No sgt\n", __func__);
	sgtable_free(sgt);
}
EXPORT_SYMBOL_GPL(omap_iommu_vfree);

static int __init iovmm_init(void)
{
	const unsigned long flags = SLAB_HWCACHE_ALIGN;
	struct kmem_cache *p;

	p = kmem_cache_create("iovm_area_cache", sizeof(struct iovm_struct), 0,
			      flags, NULL);
	if (!p)
		return -ENOMEM;
	iovm_area_cachep = p;

	return 0;
}
module_init(iovmm_init);

static void __exit iovmm_exit(void)
{
	kmem_cache_destroy(iovm_area_cachep);
}
module_exit(iovmm_exit);

MODULE_DESCRIPTION("omap iommu: simple virtual address space management");
MODULE_AUTHOR("Hiroshi DOYU <Hiroshi.DOYU@nokia.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
69d3a84a HD	1	/*
	2	* omap iommu: simple virtual address space management
	3	*
	4	* Copyright (C) 2008-2009 Nokia Corporation
	5	*
	6	* Written by Hiroshi DOYU <Hiroshi.DOYU@nokia.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
08f2e631	13	#include <linux/module.h>
69d3a84a	14	#include <linux/err.h>
5a0e3ad6	15	#include <linux/slab.h>
69d3a84a HD	16	#include <linux/vmalloc.h>
	17	#include <linux/device.h>
	18	#include <linux/scatterlist.h>
f626b52d	19	#include <linux/iommu.h>
69d3a84a HD	20
	21	#include <asm/cacheflush.h>
	22	#include <asm/mach/map.h>
	23
ce491cf8 TL	24	#include <plat/iommu.h>
ce491cf8 TL	25	#include <plat/iovmm.h>
69d3a84a	26
fcf3a6ef	27	#include <plat/iopgtable.h>
69d3a84a	28
69d3a84a HD	29	static struct kmem_cache *iovm_area_cachep;
69d3a84a HD	30
329d8d3b LP	31	/* return the offset of the first scatterlist entry in a sg table */
	32	static unsigned int sgtable_offset(const struct sg_table *sgt)
	33	{
	34	if (!sgt \|\| !sgt->nents)
	35	return 0;
	36
	37	return sgt->sgl->offset;
	38	}
	39
69d3a84a HD	40	/* return total bytes of sg buffers */
	41	static size_t sgtable_len(const struct sg_table *sgt)
	42	{
	43	unsigned int i, total = 0;
	44	struct scatterlist *sg;
	45
	46	if (!sgt)
	47	return 0;
	48
	49	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
	50	size_t bytes;
	51
329d8d3b	52	bytes = sg->length + sg->offset;
69d3a84a HD	53
69d3a84a HD	54	if (!iopgsz_ok(bytes)) {
329d8d3b LP	55	pr_err("%s: sg[%d] not iommu pagesize(%u %u)\n",
	56	__func__, i, bytes, sg->offset);
	57	return 0;
	58	}
	59
	60	if (i && sg->offset) {
	61	pr_err("%s: sg[%d] offset not allowed in internal "
	62	"entries\n", __func__, i);
69d3a84a HD	63	return 0;
	64	}
	65
	66	total += bytes;
	67	}
	68
	69	return total;
	70	}
	71	#define sgtable_ok(x) (!!sgtable_len(x))
	72
ad108121 GLF	73	static unsigned max_alignment(u32 addr)
	74	{
	75	int i;
	76	unsigned pagesize[] = { SZ_16M, SZ_1M, SZ_64K, SZ_4K, };
	77	for (i = 0; i < ARRAY_SIZE(pagesize) && addr & (pagesize[i] - 1); i++)
	78	;
	79	return (i < ARRAY_SIZE(pagesize)) ? pagesize[i] : 0;
	80	}
	81
69d3a84a HD	82	/*
	83	* calculate the optimal number sg elements from total bytes based on
	84	* iommu superpages
	85	*/
ad108121	86	static unsigned sgtable_nents(size_t bytes, u32 da, u32 pa)
69d3a84a	87	{
ad108121	88	unsigned nr_entries = 0, ent_sz;
69d3a84a HD	89
	90	if (!IS_ALIGNED(bytes, PAGE_SIZE)) {
	91	pr_err("%s: wrong size %08x\n", __func__, bytes);
	92	return 0;
	93	}
	94
ad108121 GLF	95	while (bytes) {
	96	ent_sz = max_alignment(da \| pa);
	97	ent_sz = min_t(unsigned, ent_sz, iopgsz_max(bytes));
	98	nr_entries++;
	99	da += ent_sz;
	100	pa += ent_sz;
	101	bytes -= ent_sz;
69d3a84a	102	}
69d3a84a HD	103
	104	return nr_entries;
	105	}
	106
	107	/* allocate and initialize sg_table header(a kind of 'superblock') */
ad108121 GLF	108	static struct sg_table *sgtable_alloc(const size_t bytes, u32 flags,
ad108121 GLF	109	u32 da, u32 pa)
69d3a84a HD	110	{
	111	unsigned int nr_entries;
	112	int err;
	113	struct sg_table *sgt;
	114
	115	if (!bytes)
	116	return ERR_PTR(-EINVAL);
	117
	118	if (!IS_ALIGNED(bytes, PAGE_SIZE))
	119	return ERR_PTR(-EINVAL);
	120
ad108121 GLF	121	if (flags & IOVMF_LINEAR) {
ad108121 GLF	122	nr_entries = sgtable_nents(bytes, da, pa);
69d3a84a HD	123	if (!nr_entries)
	124	return ERR_PTR(-EINVAL);
	125	} else
	126	nr_entries = bytes / PAGE_SIZE;
	127
	128	sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
	129	if (!sgt)
	130	return ERR_PTR(-ENOMEM);
	131
	132	err = sg_alloc_table(sgt, nr_entries, GFP_KERNEL);
7f1225bd S	133	if (err) {
7f1225bd S	134	kfree(sgt);
69d3a84a	135	return ERR_PTR(err);
7f1225bd	136	}
69d3a84a HD	137
	138	pr_debug("%s: sgt:%p(%d entries)\n", __func__, sgt, nr_entries);
	139
	140	return sgt;
	141	}
	142
	143	/* free sg_table header(a kind of superblock) */
	144	static void sgtable_free(struct sg_table *sgt)
	145	{
	146	if (!sgt)
	147	return;
	148
	149	sg_free_table(sgt);
	150	kfree(sgt);
	151
	152	pr_debug("%s: sgt:%p\n", __func__, sgt);
	153	}
	154
	155	/* map 'sglist' to a contiguous mpu virtual area and return 'va' */
	156	static void vmap_sg(const struct sg_table sgt)
	157	{
	158	u32 va;
	159	size_t total;
	160	unsigned int i;
	161	struct scatterlist *sg;
	162	struct vm_struct *new;
	163	const struct mem_type *mtype;
	164
	165	mtype = get_mem_type(MT_DEVICE);
	166	if (!mtype)
	167	return ERR_PTR(-EINVAL);
	168
	169	total = sgtable_len(sgt);
	170	if (!total)
	171	return ERR_PTR(-EINVAL);
	172
	173	new = __get_vm_area(total, VM_IOREMAP, VMALLOC_START, VMALLOC_END);
	174	if (!new)
	175	return ERR_PTR(-ENOMEM);
	176	va = (u32)new->addr;
	177
	178	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
	179	size_t bytes;
	180	u32 pa;
	181	int err;
	182
329d8d3b LP	183	pa = sg_phys(sg) - sg->offset;
329d8d3b LP	184	bytes = sg->length + sg->offset;
69d3a84a HD	185
	186	BUG_ON(bytes != PAGE_SIZE);
	187
	188	err = ioremap_page(va, pa, mtype);
	189	if (err)
	190	goto err_out;
	191
	192	va += bytes;
	193	}
	194
6716bd06 SP	195	flush_cache_vmap((unsigned long)new->addr,
6716bd06 SP	196	(unsigned long)(new->addr + total));
69d3a84a HD	197	return new->addr;
	198
	199	err_out:
	200	WARN_ON(1); /* FIXME: cleanup some mpu mappings */
	201	vunmap(new->addr);
	202	return ERR_PTR(-EAGAIN);
	203	}
	204
	205	static inline void vunmap_sg(const void *va)
	206	{
	207	vunmap(va);
	208	}
	209
6c32df43 OBC	210	static struct iovm_struct __find_iovm_area(struct omap_iommu obj,
6c32df43 OBC	211	const u32 da)
69d3a84a HD	212	{
	213	struct iovm_struct *tmp;
	214
	215	list_for_each_entry(tmp, &obj->mmap, list) {
	216	if ((da >= tmp->da_start) && (da < tmp->da_end)) {
	217	size_t len;
	218
	219	len = tmp->da_end - tmp->da_start;
	220
	221	dev_dbg(obj->dev, "%s: %08x-%08x-%08x(%x) %08x\n",
	222	__func__, tmp->da_start, da, tmp->da_end, len,
	223	tmp->flags);
	224
	225	return tmp;
	226	}
	227	}
	228
	229	return NULL;
	230	}
	231
	232	/**
6c32df43	233	* omap_find_iovm_area - find iovma which includes @da
fabdbca8	234	* @dev: client device
69d3a84a HD	235	* @da: iommu device virtual address
	236	*
	237	* Find the existing iovma starting at @da
	238	*/
fabdbca8	239	struct iovm_struct omap_find_iovm_area(struct device dev, u32 da)
69d3a84a	240	{
fabdbca8	241	struct omap_iommu *obj = dev_to_omap_iommu(dev);
69d3a84a HD	242	struct iovm_struct *area;
	243
	244	mutex_lock(&obj->mmap_lock);
	245	area = __find_iovm_area(obj, da);
	246	mutex_unlock(&obj->mmap_lock);
	247
	248	return area;
	249	}
6c32df43	250	EXPORT_SYMBOL_GPL(omap_find_iovm_area);
69d3a84a HD	251
	252	/*
	253	* This finds the hole(area) which fits the requested address and len
	254	* in iovmas mmap, and returns the new allocated iovma.
	255	*/
6c32df43	256	static struct iovm_struct alloc_iovm_area(struct omap_iommu obj, u32 da,
69d3a84a HD	257	size_t bytes, u32 flags)
	258	{
	259	struct iovm_struct new, tmp;
4359d38d	260	u32 start, prev_end, alignment;
69d3a84a HD	261
	262	if (!obj \|\| !bytes)
	263	return ERR_PTR(-EINVAL);
	264
	265	start = da;
4359d38d	266	alignment = PAGE_SIZE;
69d3a84a	267
d038aee2	268	if (~flags & IOVMF_DA_FIXED) {
4359d38d MJ	269	/* Don't map address 0 */
4359d38d MJ	270	start = obj->da_start ? obj->da_start : alignment;
c7f4ab26	271
69d3a84a	272	if (flags & IOVMF_LINEAR)
4359d38d MJ	273	alignment = iopgsz_max(bytes);
4359d38d MJ	274	start = roundup(start, alignment);
c7f4ab26 GLF	275	} else if (start < obj->da_start \|\| start > obj->da_end \|\|
	276	obj->da_end - start < bytes) {
	277	return ERR_PTR(-EINVAL);
69d3a84a HD	278	}
	279
	280	tmp = NULL;
	281	if (list_empty(&obj->mmap))
	282	goto found;
	283
	284	prev_end = 0;
	285	list_for_each_entry(tmp, &obj->mmap, list) {
	286
ba6e1f4f	287	if (prev_end > start)
e0a42e4f HD	288	break;
e0a42e4f HD	289
c7f4ab26	290	if (tmp->da_start > start && (tmp->da_start - start) >= bytes)
69d3a84a HD	291	goto found;
69d3a84a HD	292
d038aee2	293	if (tmp->da_end >= start && ~flags & IOVMF_DA_FIXED)
4359d38d	294	start = roundup(tmp->da_end + 1, alignment);
69d3a84a HD	295
	296	prev_end = tmp->da_end;
	297	}
	298
c7f4ab26	299	if ((start >= prev_end) && (obj->da_end - start >= bytes))
69d3a84a HD	300	goto found;
	301
	302	dev_dbg(obj->dev, "%s: no space to fit %08x(%x) flags: %08x\n",
	303	__func__, da, bytes, flags);
	304
	305	return ERR_PTR(-EINVAL);
	306
	307	found:
	308	new = kmem_cache_zalloc(iovm_area_cachep, GFP_KERNEL);
	309	if (!new)
	310	return ERR_PTR(-ENOMEM);
	311
	312	new->iommu = obj;
	313	new->da_start = start;
	314	new->da_end = start + bytes;
	315	new->flags = flags;
	316
	317	/*
	318	* keep ascending order of iovmas
	319	*/
	320	if (tmp)
	321	list_add_tail(&new->list, &tmp->list);
	322	else
	323	list_add(&new->list, &obj->mmap);
	324
	325	dev_dbg(obj->dev, "%s: found %08x-%08x-%08x(%x) %08x\n",
	326	__func__, new->da_start, start, new->da_end, bytes, flags);
	327
	328	return new;
	329	}
	330
6c32df43	331	static void free_iovm_area(struct omap_iommu obj, struct iovm_struct area)
69d3a84a HD	332	{
	333	size_t bytes;
	334
	335	BUG_ON(!obj \|\| !area);
	336
	337	bytes = area->da_end - area->da_start;
	338
	339	dev_dbg(obj->dev, "%s: %08x-%08x(%x) %08x\n",
	340	__func__, area->da_start, area->da_end, bytes, area->flags);
	341
	342	list_del(&area->list);
	343	kmem_cache_free(iovm_area_cachep, area);
	344	}
	345
	346	/**
6c32df43	347	* omap_da_to_va - convert (d) to (v)
fabdbca8	348	* @dev: client device
69d3a84a HD	349	* @da: iommu device virtual address
	350	* @va: mpu virtual address
	351	*
	352	* Returns mpu virtual addr which corresponds to a given device virtual addr
	353	*/
fabdbca8	354	void omap_da_to_va(struct device dev, u32 da)
69d3a84a	355	{
fabdbca8	356	struct omap_iommu *obj = dev_to_omap_iommu(dev);
69d3a84a HD	357	void *va = NULL;
	358	struct iovm_struct *area;
	359
	360	mutex_lock(&obj->mmap_lock);
	361
	362	area = __find_iovm_area(obj, da);
	363	if (!area) {
	364	dev_dbg(obj->dev, "%s: no da area(%08x)\n", __func__, da);
	365	goto out;
	366	}
	367	va = area->va;
69d3a84a	368	out:
26548900 DW	369	mutex_unlock(&obj->mmap_lock);
26548900 DW	370
69d3a84a HD	371	return va;
69d3a84a HD	372	}
6c32df43	373	EXPORT_SYMBOL_GPL(omap_da_to_va);
69d3a84a HD	374
	375	static void sgtable_fill_vmalloc(struct sg_table sgt, void _va)
	376	{
	377	unsigned int i;
	378	struct scatterlist *sg;
	379	void *va = _va;
	380	void *va_end;
	381
	382	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
	383	struct page *pg;
	384	const size_t bytes = PAGE_SIZE;
	385
	386	/*
6c32df43	387	* iommu 'superpage' isn't supported with 'omap_iommu_vmalloc()'
69d3a84a HD	388	*/
	389	pg = vmalloc_to_page(va);
	390	BUG_ON(!pg);
	391	sg_set_page(sg, pg, bytes, 0);
	392
	393	va += bytes;
	394	}
	395
	396	va_end = _va + PAGE_SIZE * i;
69d3a84a HD	397	}
	398
	399	static inline void sgtable_drain_vmalloc(struct sg_table *sgt)
	400	{
	401	/*
	402	* Actually this is not necessary at all, just exists for
ba6a1179	403	* consistency of the code readability.
69d3a84a HD	404	*/
	405	BUG_ON(!sgt);
	406	}
	407
69d3a84a	408	/* create 'da' <-> 'pa' mapping from 'sgt' */
f626b52d OBC	409	static int map_iovm_area(struct iommu_domain domain, struct iovm_struct new,
f626b52d OBC	410	const struct sg_table *sgt, u32 flags)
69d3a84a HD	411	{
	412	int err;
	413	unsigned int i, j;
	414	struct scatterlist *sg;
	415	u32 da = new->da_start;
	416
f626b52d	417	if (!domain \|\| !sgt)
69d3a84a HD	418	return -EINVAL;
	419
	420	BUG_ON(!sgtable_ok(sgt));
	421
	422	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
	423	u32 pa;
69d3a84a	424	size_t bytes;
69d3a84a	425
329d8d3b LP	426	pa = sg_phys(sg) - sg->offset;
329d8d3b LP	427	bytes = sg->length + sg->offset;
69d3a84a HD	428
69d3a84a HD	429	flags &= ~IOVMF_PGSZ_MASK;
f626b52d OBC	430
f626b52d OBC	431	if (bytes_to_iopgsz(bytes) < 0)
69d3a84a	432	goto err_out;
f626b52d	433
69d3a84a HD	434	pr_debug("%s: [%d] %08x %08x(%x)\n", __func__,
	435	i, da, pa, bytes);
	436
7d3002cc	437	err = iommu_map(domain, da, pa, bytes, flags);
69d3a84a HD	438	if (err)
	439	goto err_out;
	440
	441	da += bytes;
	442	}
	443	return 0;
	444
	445	err_out:
	446	da = new->da_start;
	447
	448	for_each_sg(sgt->sgl, sg, i, j) {
	449	size_t bytes;
	450
329d8d3b	451	bytes = sg->length + sg->offset;
69d3a84a	452
f626b52d	453	/* ignore failures.. we're already handling one */
7d3002cc	454	iommu_unmap(domain, da, bytes);
69d3a84a HD	455
	456	da += bytes;
	457	}
	458	return err;
	459	}
	460
	461	/* release 'da' <-> 'pa' mapping */
6c32df43	462	static void unmap_iovm_area(struct iommu_domain domain, struct omap_iommu obj,
f626b52d	463	struct iovm_struct *area)
69d3a84a HD	464	{
	465	u32 start;
	466	size_t total = area->da_end - area->da_start;
f626b52d OBC	467	const struct sg_table *sgt = area->sgt;
f626b52d OBC	468	struct scatterlist *sg;
7d3002cc OBC	469	int i;
7d3002cc OBC	470	size_t unmapped;
69d3a84a	471
f626b52d	472	BUG_ON(!sgtable_ok(sgt));
69d3a84a HD	473	BUG_ON((!total) \|\| !IS_ALIGNED(total, PAGE_SIZE));
	474
	475	start = area->da_start;
f626b52d	476	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
69d3a84a	477	size_t bytes;
f626b52d	478
329d8d3b	479	bytes = sg->length + sg->offset;
f626b52d	480
7d3002cc OBC	481	unmapped = iommu_unmap(domain, start, bytes);
7d3002cc OBC	482	if (unmapped < bytes)
f626b52d	483	break;
69d3a84a	484
f626b52d	485	dev_dbg(obj->dev, "%s: unmap %08x(%x) %08x\n",
69d3a84a HD	486	__func__, start, bytes, area->flags);
	487
	488	BUG_ON(!IS_ALIGNED(bytes, PAGE_SIZE));
	489
	490	total -= bytes;
	491	start += bytes;
	492	}
	493	BUG_ON(total);
	494	}
	495
	496	/* template function for all unmapping */
f626b52d	497	static struct sg_table unmap_vm_area(struct iommu_domain domain,
6c32df43	498	struct omap_iommu *obj, const u32 da,
69d3a84a HD	499	void (fn)(const void ), u32 flags)
	500	{
	501	struct sg_table *sgt = NULL;
	502	struct iovm_struct *area;
	503
	504	if (!IS_ALIGNED(da, PAGE_SIZE)) {
	505	dev_err(obj->dev, "%s: alignment err(%08x)\n", __func__, da);
	506	return NULL;
	507	}
	508
	509	mutex_lock(&obj->mmap_lock);
	510
	511	area = __find_iovm_area(obj, da);
	512	if (!area) {
	513	dev_dbg(obj->dev, "%s: no da area(%08x)\n", __func__, da);
	514	goto out;
	515	}
	516
	517	if ((area->flags & flags) != flags) {
	518	dev_err(obj->dev, "%s: wrong flags(%08x)\n", __func__,
	519	area->flags);
	520	goto out;
	521	}
	522	sgt = (struct sg_table *)area->sgt;
	523
f626b52d	524	unmap_iovm_area(domain, obj, area);
69d3a84a HD	525
	526	fn(area->va);
	527
	528	dev_dbg(obj->dev, "%s: %08x-%08x-%08x(%x) %08x\n", __func__,
	529	area->da_start, da, area->da_end,
	530	area->da_end - area->da_start, area->flags);
	531
	532	free_iovm_area(obj, area);
	533	out:
	534	mutex_unlock(&obj->mmap_lock);
	535
	536	return sgt;
	537	}
	538
6c32df43	539	static u32 map_iommu_region(struct iommu_domain domain, struct omap_iommu obj,
f626b52d OBC	540	u32 da, const struct sg_table sgt, void va,
f626b52d OBC	541	size_t bytes, u32 flags)
69d3a84a HD	542	{
	543	int err = -ENOMEM;
	544	struct iovm_struct *new;
	545
	546	mutex_lock(&obj->mmap_lock);
	547
	548	new = alloc_iovm_area(obj, da, bytes, flags);
	549	if (IS_ERR(new)) {
	550	err = PTR_ERR(new);
	551	goto err_alloc_iovma;
	552	}
	553	new->va = va;
	554	new->sgt = sgt;
	555
f626b52d	556	if (map_iovm_area(domain, new, sgt, new->flags))
69d3a84a HD	557	goto err_map;
	558
	559	mutex_unlock(&obj->mmap_lock);
	560
	561	dev_dbg(obj->dev, "%s: da:%08x(%x) flags:%08x va:%p\n",
	562	__func__, new->da_start, bytes, new->flags, va);
	563
	564	return new->da_start;
	565
	566	err_map:
	567	free_iovm_area(obj, new);
	568	err_alloc_iovma:
	569	mutex_unlock(&obj->mmap_lock);
	570	return err;
	571	}
	572
6c32df43 OBC	573	static inline u32
6c32df43 OBC	574	__iommu_vmap(struct iommu_domain domain, struct omap_iommu obj,
f626b52d OBC	575	u32 da, const struct sg_table *sgt,
f626b52d OBC	576	void *va, size_t bytes, u32 flags)
69d3a84a	577	{
f626b52d	578	return map_iommu_region(domain, obj, da, sgt, va, bytes, flags);
69d3a84a HD	579	}
	580
	581	/**
6c32df43	582	* omap_iommu_vmap - (d)-(p)-(v) address mapper
fabdbca8 OBC	583	* @domain: iommu domain
fabdbca8 OBC	584	* @dev: client device
69d3a84a HD	585	* @sgt: address of scatter gather table
	586	* @flags: iovma and page property
	587	*
	588	* Creates 1-n-1 mapping with given @sgt and returns @da.
	589	* All @sgt element must be io page size aligned.
	590	*/
fabdbca8	591	u32 omap_iommu_vmap(struct iommu_domain domain, struct device dev, u32 da,
f626b52d	592	const struct sg_table *sgt, u32 flags)
69d3a84a	593	{
fabdbca8	594	struct omap_iommu *obj = dev_to_omap_iommu(dev);
69d3a84a	595	size_t bytes;
935e4739	596	void *va = NULL;
69d3a84a HD	597
	598	if (!obj \|\| !obj->dev \|\| !sgt)
	599	return -EINVAL;
	600
	601	bytes = sgtable_len(sgt);
	602	if (!bytes)
	603	return -EINVAL;
	604	bytes = PAGE_ALIGN(bytes);
	605
935e4739 HD	606	if (flags & IOVMF_MMIO) {
	607	va = vmap_sg(sgt);
	608	if (IS_ERR(va))
	609	return PTR_ERR(va);
	610	}
69d3a84a	611
69d3a84a HD	612	flags \|= IOVMF_DISCONT;
69d3a84a HD	613	flags \|= IOVMF_MMIO;
69d3a84a	614
f626b52d	615	da = __iommu_vmap(domain, obj, da, sgt, va, bytes, flags);
69d3a84a HD	616	if (IS_ERR_VALUE(da))
	617	vunmap_sg(va);
	618
329d8d3b	619	return da + sgtable_offset(sgt);
69d3a84a	620	}
6c32df43	621	EXPORT_SYMBOL_GPL(omap_iommu_vmap);
69d3a84a HD	622
69d3a84a HD	623	/**
6c32df43	624	* omap_iommu_vunmap - release virtual mapping obtained by 'omap_iommu_vmap()'
fabdbca8 OBC	625	* @domain: iommu domain
fabdbca8 OBC	626	* @dev: client device
69d3a84a HD	627	* @da: iommu device virtual address
	628	*
	629	* Free the iommu virtually contiguous memory area starting at
6c32df43	630	* @da, which was returned by 'omap_iommu_vmap()'.
69d3a84a	631	*/
f626b52d	632	struct sg_table *
fabdbca8	633	omap_iommu_vunmap(struct iommu_domain domain, struct device dev, u32 da)
69d3a84a	634	{
fabdbca8	635	struct omap_iommu *obj = dev_to_omap_iommu(dev);
69d3a84a HD	636	struct sg_table *sgt;
69d3a84a HD	637	/*
6c32df43	638	* 'sgt' is allocated before 'omap_iommu_vmalloc()' is called.
69d3a84a HD	639	* Just returns 'sgt' to the caller to free
69d3a84a HD	640	*/
329d8d3b	641	da &= PAGE_MASK;
f626b52d OBC	642	sgt = unmap_vm_area(domain, obj, da, vunmap_sg,
f626b52d OBC	643	IOVMF_DISCONT \| IOVMF_MMIO);
69d3a84a HD	644	if (!sgt)
	645	dev_dbg(obj->dev, "%s: No sgt\n", __func__);
	646	return sgt;
	647	}
6c32df43	648	EXPORT_SYMBOL_GPL(omap_iommu_vunmap);
69d3a84a HD	649
69d3a84a HD	650	/**
6c32df43	651	* omap_iommu_vmalloc - (d)-(p)-(v) address allocator and mapper
fabdbca8	652	* @dev: client device
69d3a84a HD	653	* @da: contiguous iommu virtual memory
	654	* @bytes: allocation size
	655	* @flags: iovma and page property
	656	*
	657	* Allocate @bytes linearly and creates 1-n-1 mapping and returns
d038aee2	658	* @da again, which might be adjusted if 'IOVMF_DA_FIXED' is not set.
69d3a84a	659	*/
6c32df43	660	u32
fabdbca8	661	omap_iommu_vmalloc(struct iommu_domain domain, struct device dev, u32 da,
f626b52d	662	size_t bytes, u32 flags)
69d3a84a	663	{
fabdbca8	664	struct omap_iommu *obj = dev_to_omap_iommu(dev);
69d3a84a HD	665	void *va;
	666	struct sg_table *sgt;
	667
	668	if (!obj \|\| !obj->dev \|\| !bytes)
	669	return -EINVAL;
	670
	671	bytes = PAGE_ALIGN(bytes);
	672
	673	va = vmalloc(bytes);
	674	if (!va)
	675	return -ENOMEM;
	676
ad108121 GLF	677	flags \|= IOVMF_DISCONT;
ad108121 GLF	678	flags \|= IOVMF_ALLOC;
ad108121 GLF	679
ad108121 GLF	680	sgt = sgtable_alloc(bytes, flags, da, 0);
69d3a84a HD	681	if (IS_ERR(sgt)) {
	682	da = PTR_ERR(sgt);
	683	goto err_sgt_alloc;
	684	}
	685	sgtable_fill_vmalloc(sgt, va);
	686
f626b52d	687	da = __iommu_vmap(domain, obj, da, sgt, va, bytes, flags);
69d3a84a HD	688	if (IS_ERR_VALUE(da))
	689	goto err_iommu_vmap;
	690
	691	return da;
	692
	693	err_iommu_vmap:
	694	sgtable_drain_vmalloc(sgt);
	695	sgtable_free(sgt);
	696	err_sgt_alloc:
	697	vfree(va);
	698	return da;
	699	}
6c32df43	700	EXPORT_SYMBOL_GPL(omap_iommu_vmalloc);
69d3a84a HD	701
69d3a84a HD	702	/**
6c32df43	703	* omap_iommu_vfree - release memory allocated by 'omap_iommu_vmalloc()'
fabdbca8	704	* @dev: client device
69d3a84a HD	705	* @da: iommu device virtual address
	706	*
	707	* Frees the iommu virtually continuous memory area starting at
6c32df43	708	* @da, as obtained from 'omap_iommu_vmalloc()'.
69d3a84a	709	*/
fabdbca8	710	void omap_iommu_vfree(struct iommu_domain domain, struct device dev,
6c32df43	711	const u32 da)
69d3a84a	712	{
fabdbca8	713	struct omap_iommu *obj = dev_to_omap_iommu(dev);
69d3a84a HD	714	struct sg_table *sgt;
69d3a84a HD	715
f626b52d OBC	716	sgt = unmap_vm_area(domain, obj, da, vfree,
f626b52d OBC	717	IOVMF_DISCONT \| IOVMF_ALLOC);
69d3a84a HD	718	if (!sgt)
	719	dev_dbg(obj->dev, "%s: No sgt\n", __func__);
	720	sgtable_free(sgt);
	721	}
6c32df43	722	EXPORT_SYMBOL_GPL(omap_iommu_vfree);
69d3a84a	723
69d3a84a HD	724	static int __init iovmm_init(void)
	725	{
	726	const unsigned long flags = SLAB_HWCACHE_ALIGN;
	727	struct kmem_cache *p;
	728
	729	p = kmem_cache_create("iovm_area_cache", sizeof(struct iovm_struct), 0,
	730	flags, NULL);
	731	if (!p)
	732	return -ENOMEM;
	733	iovm_area_cachep = p;
	734
	735	return 0;
	736	}
	737	module_init(iovmm_init);
	738
	739	static void __exit iovmm_exit(void)
	740	{
	741	kmem_cache_destroy(iovm_area_cachep);
	742	}
	743	module_exit(iovmm_exit);
	744
	745	MODULE_DESCRIPTION("omap iommu: simple virtual address space management");
	746	MODULE_AUTHOR("Hiroshi DOYU <Hiroshi.DOYU@nokia.com>");
	747	MODULE_LICENSE("GPL v2");