2009-01-26 06:13:40 -07:00
|
|
|
/*
|
|
|
|
* omap iommu: tlb and pagetable primitives
|
|
|
|
*
|
2010-02-15 11:03:32 -07:00
|
|
|
* Copyright (C) 2008-2010 Nokia Corporation
|
2009-01-26 06:13:40 -07:00
|
|
|
*
|
|
|
|
* Written by Hiroshi DOYU <Hiroshi.DOYU@nokia.com>,
|
|
|
|
* Paul Mundt and Toshihiro Kobayashi
|
|
|
|
*
|
|
|
|
* 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/err.h>
|
|
|
|
#include <linux/module.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2009-01-26 06:13:40 -07:00
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/platform_device.h>
|
2011-06-01 16:46:12 -06:00
|
|
|
#include <linux/iommu.h>
|
2012-11-02 13:24:03 -06:00
|
|
|
#include <linux/omap-iommu.h>
|
2011-06-01 16:46:12 -06:00
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/spinlock.h>
|
2012-11-02 13:24:06 -06:00
|
|
|
#include <linux/io.h>
|
2012-11-19 18:05:51 -07:00
|
|
|
#include <linux/pm_runtime.h>
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
#include <asm/cacheflush.h>
|
|
|
|
|
2012-11-02 13:24:14 -06:00
|
|
|
#include <linux/platform_data/iommu-omap.h>
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2012-11-02 13:24:00 -06:00
|
|
|
#include "omap-iopgtable.h"
|
2012-11-02 13:24:06 -06:00
|
|
|
#include "omap-iommu.h"
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2010-04-26 23:37:12 -06:00
|
|
|
#define for_each_iotlb_cr(obj, n, __i, cr) \
|
|
|
|
for (__i = 0; \
|
|
|
|
(__i < (n)) && (cr = __iotlb_read_cr((obj), __i), true); \
|
|
|
|
__i++)
|
|
|
|
|
2011-11-10 02:32:27 -07:00
|
|
|
/* bitmap of the page sizes currently supported */
|
|
|
|
#define OMAP_IOMMU_PGSIZES (SZ_4K | SZ_64K | SZ_1M | SZ_16M)
|
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
/**
|
|
|
|
* struct omap_iommu_domain - omap iommu domain
|
|
|
|
* @pgtable: the page table
|
|
|
|
* @iommu_dev: an omap iommu device attached to this domain. only a single
|
|
|
|
* iommu device can be attached for now.
|
2012-04-18 12:09:41 -06:00
|
|
|
* @dev: Device using this domain.
|
2011-06-01 16:46:12 -06:00
|
|
|
* @lock: domain lock, should be taken when attaching/detaching
|
|
|
|
*/
|
|
|
|
struct omap_iommu_domain {
|
|
|
|
u32 *pgtable;
|
2011-08-17 13:57:56 -06:00
|
|
|
struct omap_iommu *iommu_dev;
|
2012-04-18 12:09:41 -06:00
|
|
|
struct device *dev;
|
2011-06-01 16:46:12 -06:00
|
|
|
spinlock_t lock;
|
|
|
|
};
|
|
|
|
|
2012-11-02 13:24:09 -06:00
|
|
|
#define MMU_LOCK_BASE_SHIFT 10
|
|
|
|
#define MMU_LOCK_BASE_MASK (0x1f << MMU_LOCK_BASE_SHIFT)
|
|
|
|
#define MMU_LOCK_BASE(x) \
|
|
|
|
((x & MMU_LOCK_BASE_MASK) >> MMU_LOCK_BASE_SHIFT)
|
|
|
|
|
|
|
|
#define MMU_LOCK_VICT_SHIFT 4
|
|
|
|
#define MMU_LOCK_VICT_MASK (0x1f << MMU_LOCK_VICT_SHIFT)
|
|
|
|
#define MMU_LOCK_VICT(x) \
|
|
|
|
((x & MMU_LOCK_VICT_MASK) >> MMU_LOCK_VICT_SHIFT)
|
|
|
|
|
|
|
|
struct iotlb_lock {
|
|
|
|
short base;
|
|
|
|
short vict;
|
|
|
|
};
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
/* accommodate the difference between omap1 and omap2/3 */
|
|
|
|
static const struct iommu_functions *arch_iommu;
|
|
|
|
|
|
|
|
static struct platform_driver omap_iommu_driver;
|
|
|
|
static struct kmem_cache *iopte_cachep;
|
|
|
|
|
|
|
|
/**
|
2011-08-17 13:57:56 -06:00
|
|
|
* omap_install_iommu_arch - Install archtecure specific iommu functions
|
2009-01-26 06:13:40 -07:00
|
|
|
* @ops: a pointer to architecture specific iommu functions
|
|
|
|
*
|
|
|
|
* There are several kind of iommu algorithm(tlb, pagetable) among
|
|
|
|
* omap series. This interface installs such an iommu algorighm.
|
|
|
|
**/
|
2011-08-17 13:57:56 -06:00
|
|
|
int omap_install_iommu_arch(const struct iommu_functions *ops)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
if (arch_iommu)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
arch_iommu = ops;
|
|
|
|
return 0;
|
|
|
|
}
|
2011-08-17 13:57:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(omap_install_iommu_arch);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
/**
|
2011-08-17 13:57:56 -06:00
|
|
|
* omap_uninstall_iommu_arch - Uninstall archtecure specific iommu functions
|
2009-01-26 06:13:40 -07:00
|
|
|
* @ops: a pointer to architecture specific iommu functions
|
|
|
|
*
|
|
|
|
* This interface uninstalls the iommu algorighm installed previously.
|
|
|
|
**/
|
2011-08-17 13:57:56 -06:00
|
|
|
void omap_uninstall_iommu_arch(const struct iommu_functions *ops)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
if (arch_iommu != ops)
|
|
|
|
pr_err("%s: not your arch\n", __func__);
|
|
|
|
|
|
|
|
arch_iommu = NULL;
|
|
|
|
}
|
2011-08-17 13:57:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(omap_uninstall_iommu_arch);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
/**
|
2011-08-17 13:57:56 -06:00
|
|
|
* omap_iommu_save_ctx - Save registers for pm off-mode support
|
2011-10-10 16:18:33 -06:00
|
|
|
* @dev: client device
|
2009-01-26 06:13:40 -07:00
|
|
|
**/
|
2011-10-10 16:18:33 -06:00
|
|
|
void omap_iommu_save_ctx(struct device *dev)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
2011-10-10 16:18:33 -06:00
|
|
|
struct omap_iommu *obj = dev_to_omap_iommu(dev);
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
arch_iommu->save_ctx(obj);
|
|
|
|
}
|
2011-08-17 13:57:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(omap_iommu_save_ctx);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
/**
|
2011-08-17 13:57:56 -06:00
|
|
|
* omap_iommu_restore_ctx - Restore registers for pm off-mode support
|
2011-10-10 16:18:33 -06:00
|
|
|
* @dev: client device
|
2009-01-26 06:13:40 -07:00
|
|
|
**/
|
2011-10-10 16:18:33 -06:00
|
|
|
void omap_iommu_restore_ctx(struct device *dev)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
2011-10-10 16:18:33 -06:00
|
|
|
struct omap_iommu *obj = dev_to_omap_iommu(dev);
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
arch_iommu->restore_ctx(obj);
|
|
|
|
}
|
2011-08-17 13:57:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(omap_iommu_restore_ctx);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
/**
|
2011-08-17 13:57:56 -06:00
|
|
|
* omap_iommu_arch_version - Return running iommu arch version
|
2009-01-26 06:13:40 -07:00
|
|
|
**/
|
2011-08-17 13:57:56 -06:00
|
|
|
u32 omap_iommu_arch_version(void)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
return arch_iommu->version;
|
|
|
|
}
|
2011-08-17 13:57:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(omap_iommu_arch_version);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static int iommu_enable(struct omap_iommu *obj)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
int err;
|
2012-11-19 18:05:50 -07:00
|
|
|
struct platform_device *pdev = to_platform_device(obj->dev);
|
|
|
|
struct iommu_platform_data *pdata = pdev->dev.platform_data;
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2013-01-18 13:42:18 -07:00
|
|
|
if (!pdata)
|
2009-01-26 06:13:40 -07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2011-02-24 13:51:31 -07:00
|
|
|
if (!arch_iommu)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2012-11-19 18:05:50 -07:00
|
|
|
if (pdata->deassert_reset) {
|
|
|
|
err = pdata->deassert_reset(pdev, pdata->reset_name);
|
|
|
|
if (err) {
|
|
|
|
dev_err(obj->dev, "deassert_reset failed: %d\n", err);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_get_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
err = arch_iommu->enable(obj);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static void iommu_disable(struct omap_iommu *obj)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
2012-11-19 18:05:50 -07:00
|
|
|
struct platform_device *pdev = to_platform_device(obj->dev);
|
|
|
|
struct iommu_platform_data *pdata = pdev->dev.platform_data;
|
|
|
|
|
2013-01-18 13:42:18 -07:00
|
|
|
if (!pdata)
|
2009-01-26 06:13:40 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
arch_iommu->disable(obj);
|
|
|
|
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_put_sync(obj->dev);
|
2012-11-19 18:05:50 -07:00
|
|
|
|
|
|
|
if (pdata->assert_reset)
|
|
|
|
pdata->assert_reset(pdev, pdata->reset_name);
|
2009-01-26 06:13:40 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TLB operations
|
|
|
|
*/
|
2011-08-17 13:57:56 -06:00
|
|
|
void omap_iotlb_cr_to_e(struct cr_regs *cr, struct iotlb_entry *e)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
BUG_ON(!cr || !e);
|
|
|
|
|
|
|
|
arch_iommu->cr_to_e(cr, e);
|
|
|
|
}
|
2011-08-17 13:57:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(omap_iotlb_cr_to_e);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
static inline int iotlb_cr_valid(struct cr_regs *cr)
|
|
|
|
{
|
|
|
|
if (!cr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return arch_iommu->cr_valid(cr);
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static inline struct cr_regs *iotlb_alloc_cr(struct omap_iommu *obj,
|
2009-01-26 06:13:40 -07:00
|
|
|
struct iotlb_entry *e)
|
|
|
|
{
|
|
|
|
if (!e)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return arch_iommu->alloc_cr(obj, e);
|
|
|
|
}
|
|
|
|
|
2011-08-16 05:58:14 -06:00
|
|
|
static u32 iotlb_cr_to_virt(struct cr_regs *cr)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
return arch_iommu->cr_to_virt(cr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 get_iopte_attr(struct iotlb_entry *e)
|
|
|
|
{
|
|
|
|
return arch_iommu->get_pte_attr(e);
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static u32 iommu_report_fault(struct omap_iommu *obj, u32 *da)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
return arch_iommu->fault_isr(obj, da);
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static void iotlb_lock_get(struct omap_iommu *obj, struct iotlb_lock *l)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
val = iommu_read_reg(obj, MMU_LOCK);
|
|
|
|
|
|
|
|
l->base = MMU_LOCK_BASE(val);
|
|
|
|
l->vict = MMU_LOCK_VICT(val);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static void iotlb_lock_set(struct omap_iommu *obj, struct iotlb_lock *l)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
val = (l->base << MMU_LOCK_BASE_SHIFT);
|
|
|
|
val |= (l->vict << MMU_LOCK_VICT_SHIFT);
|
|
|
|
|
|
|
|
iommu_write_reg(obj, val, MMU_LOCK);
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static void iotlb_read_cr(struct omap_iommu *obj, struct cr_regs *cr)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
arch_iommu->tlb_read_cr(obj, cr);
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static void iotlb_load_cr(struct omap_iommu *obj, struct cr_regs *cr)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
arch_iommu->tlb_load_cr(obj, cr);
|
|
|
|
|
|
|
|
iommu_write_reg(obj, 1, MMU_FLUSH_ENTRY);
|
|
|
|
iommu_write_reg(obj, 1, MMU_LD_TLB);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iotlb_dump_cr - Dump an iommu tlb entry into buf
|
|
|
|
* @obj: target iommu
|
|
|
|
* @cr: contents of cam and ram register
|
|
|
|
* @buf: output buffer
|
|
|
|
**/
|
2011-08-17 13:57:56 -06:00
|
|
|
static inline ssize_t iotlb_dump_cr(struct omap_iommu *obj, struct cr_regs *cr,
|
2009-01-26 06:13:40 -07:00
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
BUG_ON(!cr || !buf);
|
|
|
|
|
|
|
|
return arch_iommu->dump_cr(obj, cr, buf);
|
|
|
|
}
|
|
|
|
|
2010-04-26 23:37:12 -06:00
|
|
|
/* only used in iotlb iteration for-loop */
|
2011-08-17 13:57:56 -06:00
|
|
|
static struct cr_regs __iotlb_read_cr(struct omap_iommu *obj, int n)
|
2010-04-26 23:37:12 -06:00
|
|
|
{
|
|
|
|
struct cr_regs cr;
|
|
|
|
struct iotlb_lock l;
|
|
|
|
|
|
|
|
iotlb_lock_get(obj, &l);
|
|
|
|
l.vict = n;
|
|
|
|
iotlb_lock_set(obj, &l);
|
|
|
|
iotlb_read_cr(obj, &cr);
|
|
|
|
|
|
|
|
return cr;
|
|
|
|
}
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
/**
|
|
|
|
* load_iotlb_entry - Set an iommu tlb entry
|
|
|
|
* @obj: target iommu
|
|
|
|
* @e: an iommu tlb entry info
|
|
|
|
**/
|
2011-08-16 06:19:10 -06:00
|
|
|
#ifdef PREFETCH_IOTLB
|
2011-08-17 13:57:56 -06:00
|
|
|
static int load_iotlb_entry(struct omap_iommu *obj, struct iotlb_entry *e)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
struct iotlb_lock l;
|
|
|
|
struct cr_regs *cr;
|
|
|
|
|
|
|
|
if (!obj || !obj->nr_tlb_entries || !e)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_get_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2010-04-22 17:26:11 -06:00
|
|
|
iotlb_lock_get(obj, &l);
|
|
|
|
if (l.base == obj->nr_tlb_entries) {
|
|
|
|
dev_warn(obj->dev, "%s: preserve entries full\n", __func__);
|
2009-01-26 06:13:40 -07:00
|
|
|
err = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-04-22 17:26:11 -06:00
|
|
|
if (!e->prsvd) {
|
2010-04-26 23:37:12 -06:00
|
|
|
int i;
|
|
|
|
struct cr_regs tmp;
|
2010-04-22 17:26:11 -06:00
|
|
|
|
2010-04-26 23:37:12 -06:00
|
|
|
for_each_iotlb_cr(obj, obj->nr_tlb_entries, i, tmp)
|
2010-04-22 17:26:11 -06:00
|
|
|
if (!iotlb_cr_valid(&tmp))
|
|
|
|
break;
|
2010-04-26 23:37:12 -06:00
|
|
|
|
2010-04-22 17:26:11 -06:00
|
|
|
if (i == obj->nr_tlb_entries) {
|
|
|
|
dev_dbg(obj->dev, "%s: full: no entry\n", __func__);
|
|
|
|
err = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-04-26 23:37:12 -06:00
|
|
|
|
|
|
|
iotlb_lock_get(obj, &l);
|
2010-04-22 17:26:11 -06:00
|
|
|
} else {
|
|
|
|
l.vict = l.base;
|
|
|
|
iotlb_lock_set(obj, &l);
|
|
|
|
}
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
cr = iotlb_alloc_cr(obj, e);
|
|
|
|
if (IS_ERR(cr)) {
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_put_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
return PTR_ERR(cr);
|
|
|
|
}
|
|
|
|
|
|
|
|
iotlb_load_cr(obj, cr);
|
|
|
|
kfree(cr);
|
|
|
|
|
2010-04-22 17:26:11 -06:00
|
|
|
if (e->prsvd)
|
|
|
|
l.base++;
|
2009-01-26 06:13:40 -07:00
|
|
|
/* increment victim for next tlb load */
|
|
|
|
if (++l.vict == obj->nr_tlb_entries)
|
2010-04-22 17:26:11 -06:00
|
|
|
l.vict = l.base;
|
2009-01-26 06:13:40 -07:00
|
|
|
iotlb_lock_set(obj, &l);
|
|
|
|
out:
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_put_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-08-16 06:19:10 -06:00
|
|
|
#else /* !PREFETCH_IOTLB */
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static int load_iotlb_entry(struct omap_iommu *obj, struct iotlb_entry *e)
|
2011-08-16 06:19:10 -06:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* !PREFETCH_IOTLB */
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static int prefetch_iotlb_entry(struct omap_iommu *obj, struct iotlb_entry *e)
|
2011-08-16 06:19:10 -06:00
|
|
|
{
|
|
|
|
return load_iotlb_entry(obj, e);
|
|
|
|
}
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* flush_iotlb_page - Clear an iommu tlb entry
|
|
|
|
* @obj: target iommu
|
|
|
|
* @da: iommu device virtual address
|
|
|
|
*
|
|
|
|
* Clear an iommu tlb entry which includes 'da' address.
|
|
|
|
**/
|
2011-08-17 13:57:56 -06:00
|
|
|
static void flush_iotlb_page(struct omap_iommu *obj, u32 da)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
int i;
|
2010-04-26 23:37:12 -06:00
|
|
|
struct cr_regs cr;
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_get_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2010-04-26 23:37:12 -06:00
|
|
|
for_each_iotlb_cr(obj, obj->nr_tlb_entries, i, cr) {
|
2009-01-26 06:13:40 -07:00
|
|
|
u32 start;
|
|
|
|
size_t bytes;
|
|
|
|
|
|
|
|
if (!iotlb_cr_valid(&cr))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
start = iotlb_cr_to_virt(&cr);
|
|
|
|
bytes = iopgsz_to_bytes(cr.cam & 3);
|
|
|
|
|
|
|
|
if ((start <= da) && (da < start + bytes)) {
|
|
|
|
dev_dbg(obj->dev, "%s: %08x<=%08x(%x)\n",
|
|
|
|
__func__, start, da, bytes);
|
2010-08-20 07:50:18 -06:00
|
|
|
iotlb_load_cr(obj, &cr);
|
2009-01-26 06:13:40 -07:00
|
|
|
iommu_write_reg(obj, 1, MMU_FLUSH_ENTRY);
|
|
|
|
}
|
|
|
|
}
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_put_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
if (i == obj->nr_tlb_entries)
|
|
|
|
dev_dbg(obj->dev, "%s: no page for %08x\n", __func__, da);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* flush_iotlb_all - Clear all iommu tlb entries
|
|
|
|
* @obj: target iommu
|
|
|
|
**/
|
2011-08-17 13:57:56 -06:00
|
|
|
static void flush_iotlb_all(struct omap_iommu *obj)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
struct iotlb_lock l;
|
|
|
|
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_get_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
l.base = 0;
|
|
|
|
l.vict = 0;
|
|
|
|
iotlb_lock_set(obj, &l);
|
|
|
|
|
|
|
|
iommu_write_reg(obj, 1, MMU_GFLUSH);
|
|
|
|
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_put_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
}
|
2010-05-23 20:01:51 -06:00
|
|
|
|
2011-10-02 12:34:05 -06:00
|
|
|
#if defined(CONFIG_OMAP_IOMMU_DEBUG) || defined(CONFIG_OMAP_IOMMU_DEBUG_MODULE)
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
ssize_t omap_iommu_dump_ctx(struct omap_iommu *obj, char *buf, ssize_t bytes)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
if (!obj || !buf)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_get_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2009-08-28 11:54:41 -06:00
|
|
|
bytes = arch_iommu->dump_ctx(obj, buf, bytes);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_put_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
return bytes;
|
|
|
|
}
|
2011-08-17 13:57:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(omap_iommu_dump_ctx);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static int
|
|
|
|
__dump_tlb_entries(struct omap_iommu *obj, struct cr_regs *crs, int num)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
int i;
|
2010-04-26 23:37:12 -06:00
|
|
|
struct iotlb_lock saved;
|
|
|
|
struct cr_regs tmp;
|
2009-01-26 06:13:40 -07:00
|
|
|
struct cr_regs *p = crs;
|
|
|
|
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_get_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
iotlb_lock_get(obj, &saved);
|
|
|
|
|
2010-04-26 23:37:12 -06:00
|
|
|
for_each_iotlb_cr(obj, num, i, tmp) {
|
2009-01-26 06:13:40 -07:00
|
|
|
if (!iotlb_cr_valid(&tmp))
|
|
|
|
continue;
|
|
|
|
*p++ = tmp;
|
|
|
|
}
|
2010-04-26 23:37:12 -06:00
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
iotlb_lock_set(obj, &saved);
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_put_sync(obj->dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
return p - crs;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-08-17 13:57:56 -06:00
|
|
|
* omap_dump_tlb_entries - dump cr arrays to given buffer
|
2009-01-26 06:13:40 -07:00
|
|
|
* @obj: target iommu
|
|
|
|
* @buf: output buffer
|
|
|
|
**/
|
2011-08-17 13:57:56 -06:00
|
|
|
size_t omap_dump_tlb_entries(struct omap_iommu *obj, char *buf, ssize_t bytes)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
2009-08-28 11:54:41 -06:00
|
|
|
int i, num;
|
2009-01-26 06:13:40 -07:00
|
|
|
struct cr_regs *cr;
|
|
|
|
char *p = buf;
|
|
|
|
|
2009-08-28 11:54:41 -06:00
|
|
|
num = bytes / sizeof(*cr);
|
|
|
|
num = min(obj->nr_tlb_entries, num);
|
|
|
|
|
|
|
|
cr = kcalloc(num, sizeof(*cr), GFP_KERNEL);
|
2009-01-26 06:13:40 -07:00
|
|
|
if (!cr)
|
|
|
|
return 0;
|
|
|
|
|
2009-08-28 11:54:41 -06:00
|
|
|
num = __dump_tlb_entries(obj, cr, num);
|
|
|
|
for (i = 0; i < num; i++)
|
2009-01-26 06:13:40 -07:00
|
|
|
p += iotlb_dump_cr(obj, cr + i, p);
|
|
|
|
kfree(cr);
|
|
|
|
|
|
|
|
return p - buf;
|
|
|
|
}
|
2011-08-17 13:57:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(omap_dump_tlb_entries);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
int omap_foreach_iommu_device(void *data, int (*fn)(struct device *, void *))
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
return driver_for_each_device(&omap_iommu_driver.driver,
|
|
|
|
NULL, data, fn);
|
|
|
|
}
|
2011-08-17 13:57:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(omap_foreach_iommu_device);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
#endif /* CONFIG_OMAP_IOMMU_DEBUG_MODULE */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* H/W pagetable operations
|
|
|
|
*/
|
|
|
|
static void flush_iopgd_range(u32 *first, u32 *last)
|
|
|
|
{
|
|
|
|
/* FIXME: L2 cache should be taken care of if it exists */
|
|
|
|
do {
|
|
|
|
asm("mcr p15, 0, %0, c7, c10, 1 @ flush_pgd"
|
|
|
|
: : "r" (first));
|
|
|
|
first += L1_CACHE_BYTES / sizeof(*first);
|
|
|
|
} while (first <= last);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void flush_iopte_range(u32 *first, u32 *last)
|
|
|
|
{
|
|
|
|
/* FIXME: L2 cache should be taken care of if it exists */
|
|
|
|
do {
|
|
|
|
asm("mcr p15, 0, %0, c7, c10, 1 @ flush_pte"
|
|
|
|
: : "r" (first));
|
|
|
|
first += L1_CACHE_BYTES / sizeof(*first);
|
|
|
|
} while (first <= last);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void iopte_free(u32 *iopte)
|
|
|
|
{
|
|
|
|
/* Note: freed iopte's must be clean ready for re-use */
|
|
|
|
kmem_cache_free(iopte_cachep, iopte);
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static u32 *iopte_alloc(struct omap_iommu *obj, u32 *iopgd, u32 da)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
u32 *iopte;
|
|
|
|
|
|
|
|
/* a table has already existed */
|
|
|
|
if (*iopgd)
|
|
|
|
goto pte_ready;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* do the allocation outside the page table lock
|
|
|
|
*/
|
|
|
|
spin_unlock(&obj->page_table_lock);
|
|
|
|
iopte = kmem_cache_zalloc(iopte_cachep, GFP_KERNEL);
|
|
|
|
spin_lock(&obj->page_table_lock);
|
|
|
|
|
|
|
|
if (!*iopgd) {
|
|
|
|
if (!iopte)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
*iopgd = virt_to_phys(iopte) | IOPGD_TABLE;
|
|
|
|
flush_iopgd_range(iopgd, iopgd);
|
|
|
|
|
|
|
|
dev_vdbg(obj->dev, "%s: a new pte:%p\n", __func__, iopte);
|
|
|
|
} else {
|
|
|
|
/* We raced, free the reduniovant table */
|
|
|
|
iopte_free(iopte);
|
|
|
|
}
|
|
|
|
|
|
|
|
pte_ready:
|
|
|
|
iopte = iopte_offset(iopgd, da);
|
|
|
|
|
|
|
|
dev_vdbg(obj->dev,
|
|
|
|
"%s: da:%08x pgd:%p *pgd:%08x pte:%p *pte:%08x\n",
|
|
|
|
__func__, da, iopgd, *iopgd, iopte, *iopte);
|
|
|
|
|
|
|
|
return iopte;
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static int iopgd_alloc_section(struct omap_iommu *obj, u32 da, u32 pa, u32 prot)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
u32 *iopgd = iopgd_offset(obj, da);
|
|
|
|
|
2010-05-06 09:24:04 -06:00
|
|
|
if ((da | pa) & ~IOSECTION_MASK) {
|
|
|
|
dev_err(obj->dev, "%s: %08x:%08x should aligned on %08lx\n",
|
|
|
|
__func__, da, pa, IOSECTION_SIZE);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
*iopgd = (pa & IOSECTION_MASK) | prot | IOPGD_SECTION;
|
|
|
|
flush_iopgd_range(iopgd, iopgd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static int iopgd_alloc_super(struct omap_iommu *obj, u32 da, u32 pa, u32 prot)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
u32 *iopgd = iopgd_offset(obj, da);
|
|
|
|
int i;
|
|
|
|
|
2010-05-06 09:24:04 -06:00
|
|
|
if ((da | pa) & ~IOSUPER_MASK) {
|
|
|
|
dev_err(obj->dev, "%s: %08x:%08x should aligned on %08lx\n",
|
|
|
|
__func__, da, pa, IOSUPER_SIZE);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
for (i = 0; i < 16; i++)
|
|
|
|
*(iopgd + i) = (pa & IOSUPER_MASK) | prot | IOPGD_SUPER;
|
|
|
|
flush_iopgd_range(iopgd, iopgd + 15);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static int iopte_alloc_page(struct omap_iommu *obj, u32 da, u32 pa, u32 prot)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
u32 *iopgd = iopgd_offset(obj, da);
|
|
|
|
u32 *iopte = iopte_alloc(obj, iopgd, da);
|
|
|
|
|
|
|
|
if (IS_ERR(iopte))
|
|
|
|
return PTR_ERR(iopte);
|
|
|
|
|
|
|
|
*iopte = (pa & IOPAGE_MASK) | prot | IOPTE_SMALL;
|
|
|
|
flush_iopte_range(iopte, iopte);
|
|
|
|
|
|
|
|
dev_vdbg(obj->dev, "%s: da:%08x pa:%08x pte:%p *pte:%08x\n",
|
|
|
|
__func__, da, pa, iopte, *iopte);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static int iopte_alloc_large(struct omap_iommu *obj, u32 da, u32 pa, u32 prot)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
u32 *iopgd = iopgd_offset(obj, da);
|
|
|
|
u32 *iopte = iopte_alloc(obj, iopgd, da);
|
|
|
|
int i;
|
|
|
|
|
2010-05-06 09:24:04 -06:00
|
|
|
if ((da | pa) & ~IOLARGE_MASK) {
|
|
|
|
dev_err(obj->dev, "%s: %08x:%08x should aligned on %08lx\n",
|
|
|
|
__func__, da, pa, IOLARGE_SIZE);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
if (IS_ERR(iopte))
|
|
|
|
return PTR_ERR(iopte);
|
|
|
|
|
|
|
|
for (i = 0; i < 16; i++)
|
|
|
|
*(iopte + i) = (pa & IOLARGE_MASK) | prot | IOPTE_LARGE;
|
|
|
|
flush_iopte_range(iopte, iopte + 15);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static int
|
|
|
|
iopgtable_store_entry_core(struct omap_iommu *obj, struct iotlb_entry *e)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
2011-08-17 13:57:56 -06:00
|
|
|
int (*fn)(struct omap_iommu *, u32, u32, u32);
|
2009-01-26 06:13:40 -07:00
|
|
|
u32 prot;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!obj || !e)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
switch (e->pgsz) {
|
|
|
|
case MMU_CAM_PGSZ_16M:
|
|
|
|
fn = iopgd_alloc_super;
|
|
|
|
break;
|
|
|
|
case MMU_CAM_PGSZ_1M:
|
|
|
|
fn = iopgd_alloc_section;
|
|
|
|
break;
|
|
|
|
case MMU_CAM_PGSZ_64K:
|
|
|
|
fn = iopte_alloc_large;
|
|
|
|
break;
|
|
|
|
case MMU_CAM_PGSZ_4K:
|
|
|
|
fn = iopte_alloc_page;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fn = NULL;
|
|
|
|
BUG();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
prot = get_iopte_attr(e);
|
|
|
|
|
|
|
|
spin_lock(&obj->page_table_lock);
|
|
|
|
err = fn(obj, e->da, e->pa, prot);
|
|
|
|
spin_unlock(&obj->page_table_lock);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-08-17 13:57:56 -06:00
|
|
|
* omap_iopgtable_store_entry - Make an iommu pte entry
|
2009-01-26 06:13:40 -07:00
|
|
|
* @obj: target iommu
|
|
|
|
* @e: an iommu tlb entry info
|
|
|
|
**/
|
2011-08-17 13:57:56 -06:00
|
|
|
int omap_iopgtable_store_entry(struct omap_iommu *obj, struct iotlb_entry *e)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
flush_iotlb_page(obj, e->da);
|
|
|
|
err = iopgtable_store_entry_core(obj, e);
|
|
|
|
if (!err)
|
2011-08-16 06:19:10 -06:00
|
|
|
prefetch_iotlb_entry(obj, e);
|
2009-01-26 06:13:40 -07:00
|
|
|
return err;
|
|
|
|
}
|
2011-08-17 13:57:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(omap_iopgtable_store_entry);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* iopgtable_lookup_entry - Lookup an iommu pte entry
|
|
|
|
* @obj: target iommu
|
|
|
|
* @da: iommu device virtual address
|
|
|
|
* @ppgd: iommu pgd entry pointer to be returned
|
|
|
|
* @ppte: iommu pte entry pointer to be returned
|
|
|
|
**/
|
2011-08-16 05:58:14 -06:00
|
|
|
static void
|
|
|
|
iopgtable_lookup_entry(struct omap_iommu *obj, u32 da, u32 **ppgd, u32 **ppte)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
u32 *iopgd, *iopte = NULL;
|
|
|
|
|
|
|
|
iopgd = iopgd_offset(obj, da);
|
|
|
|
if (!*iopgd)
|
|
|
|
goto out;
|
|
|
|
|
2010-05-13 00:45:35 -06:00
|
|
|
if (iopgd_is_table(*iopgd))
|
2009-01-26 06:13:40 -07:00
|
|
|
iopte = iopte_offset(iopgd, da);
|
|
|
|
out:
|
|
|
|
*ppgd = iopgd;
|
|
|
|
*ppte = iopte;
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static size_t iopgtable_clear_entry_core(struct omap_iommu *obj, u32 da)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
size_t bytes;
|
|
|
|
u32 *iopgd = iopgd_offset(obj, da);
|
|
|
|
int nent = 1;
|
|
|
|
|
|
|
|
if (!*iopgd)
|
|
|
|
return 0;
|
|
|
|
|
2010-05-13 00:45:35 -06:00
|
|
|
if (iopgd_is_table(*iopgd)) {
|
2009-01-26 06:13:40 -07:00
|
|
|
int i;
|
|
|
|
u32 *iopte = iopte_offset(iopgd, da);
|
|
|
|
|
|
|
|
bytes = IOPTE_SIZE;
|
|
|
|
if (*iopte & IOPTE_LARGE) {
|
|
|
|
nent *= 16;
|
|
|
|
/* rewind to the 1st entry */
|
2010-02-15 11:03:32 -07:00
|
|
|
iopte = iopte_offset(iopgd, (da & IOLARGE_MASK));
|
2009-01-26 06:13:40 -07:00
|
|
|
}
|
|
|
|
bytes *= nent;
|
|
|
|
memset(iopte, 0, nent * sizeof(*iopte));
|
|
|
|
flush_iopte_range(iopte, iopte + (nent - 1) * sizeof(*iopte));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* do table walk to check if this table is necessary or not
|
|
|
|
*/
|
|
|
|
iopte = iopte_offset(iopgd, 0);
|
|
|
|
for (i = 0; i < PTRS_PER_IOPTE; i++)
|
|
|
|
if (iopte[i])
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
iopte_free(iopte);
|
|
|
|
nent = 1; /* for the next L1 entry */
|
|
|
|
} else {
|
|
|
|
bytes = IOPGD_SIZE;
|
2009-10-22 15:46:32 -06:00
|
|
|
if ((*iopgd & IOPGD_SUPER) == IOPGD_SUPER) {
|
2009-01-26 06:13:40 -07:00
|
|
|
nent *= 16;
|
|
|
|
/* rewind to the 1st entry */
|
2010-02-15 11:03:32 -07:00
|
|
|
iopgd = iopgd_offset(obj, (da & IOSUPER_MASK));
|
2009-01-26 06:13:40 -07:00
|
|
|
}
|
|
|
|
bytes *= nent;
|
|
|
|
}
|
|
|
|
memset(iopgd, 0, nent * sizeof(*iopgd));
|
|
|
|
flush_iopgd_range(iopgd, iopgd + (nent - 1) * sizeof(*iopgd));
|
|
|
|
out:
|
|
|
|
return bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iopgtable_clear_entry - Remove an iommu pte entry
|
|
|
|
* @obj: target iommu
|
|
|
|
* @da: iommu device virtual address
|
|
|
|
**/
|
2011-08-17 13:57:56 -06:00
|
|
|
static size_t iopgtable_clear_entry(struct omap_iommu *obj, u32 da)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
size_t bytes;
|
|
|
|
|
|
|
|
spin_lock(&obj->page_table_lock);
|
|
|
|
|
|
|
|
bytes = iopgtable_clear_entry_core(obj, da);
|
|
|
|
flush_iotlb_page(obj, da);
|
|
|
|
|
|
|
|
spin_unlock(&obj->page_table_lock);
|
|
|
|
|
|
|
|
return bytes;
|
|
|
|
}
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
static void iopgtable_clear_entry_all(struct omap_iommu *obj)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
spin_lock(&obj->page_table_lock);
|
|
|
|
|
|
|
|
for (i = 0; i < PTRS_PER_IOPGD; i++) {
|
|
|
|
u32 da;
|
|
|
|
u32 *iopgd;
|
|
|
|
|
|
|
|
da = i << IOPGD_SHIFT;
|
|
|
|
iopgd = iopgd_offset(obj, da);
|
|
|
|
|
|
|
|
if (!*iopgd)
|
|
|
|
continue;
|
|
|
|
|
2010-05-13 00:45:35 -06:00
|
|
|
if (iopgd_is_table(*iopgd))
|
2009-01-26 06:13:40 -07:00
|
|
|
iopte_free(iopte_offset(iopgd, 0));
|
|
|
|
|
|
|
|
*iopgd = 0;
|
|
|
|
flush_iopgd_range(iopgd, iopgd);
|
|
|
|
}
|
|
|
|
|
|
|
|
flush_iotlb_all(obj);
|
|
|
|
|
|
|
|
spin_unlock(&obj->page_table_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Device IOMMU generic operations
|
|
|
|
*/
|
|
|
|
static irqreturn_t iommu_fault_handler(int irq, void *data)
|
|
|
|
{
|
2011-02-16 12:35:51 -07:00
|
|
|
u32 da, errs;
|
2009-01-26 06:13:40 -07:00
|
|
|
u32 *iopgd, *iopte;
|
2011-08-17 13:57:56 -06:00
|
|
|
struct omap_iommu *obj = data;
|
2011-09-13 13:26:29 -06:00
|
|
|
struct iommu_domain *domain = obj->domain;
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
if (!obj->refcount)
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
2011-02-16 12:35:51 -07:00
|
|
|
errs = iommu_report_fault(obj, &da);
|
2011-05-10 08:56:46 -06:00
|
|
|
if (errs == 0)
|
|
|
|
return IRQ_HANDLED;
|
2011-02-16 12:35:51 -07:00
|
|
|
|
|
|
|
/* Fault callback or TLB/PTE Dynamic loading */
|
2011-09-13 13:26:29 -06:00
|
|
|
if (!report_iommu_fault(domain, obj->dev, da, 0))
|
2009-01-26 06:13:40 -07:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
|
2010-05-23 20:01:52 -06:00
|
|
|
iommu_disable(obj);
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
iopgd = iopgd_offset(obj, da);
|
|
|
|
|
2010-05-13 00:45:35 -06:00
|
|
|
if (!iopgd_is_table(*iopgd)) {
|
2013-05-30 17:10:59 -06:00
|
|
|
dev_err(obj->dev, "%s: errs:0x%08x da:0x%08x pgd:0x%p *pgd:px%08x\n",
|
|
|
|
obj->name, errs, da, iopgd, *iopgd);
|
2009-01-26 06:13:40 -07:00
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
iopte = iopte_offset(iopgd, da);
|
|
|
|
|
2013-05-30 17:10:59 -06:00
|
|
|
dev_err(obj->dev, "%s: errs:0x%08x da:0x%08x pgd:0x%p *pgd:0x%08x pte:0x%p *pte:0x%08x\n",
|
|
|
|
obj->name, errs, da, iopgd, *iopgd, iopte, *iopte);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int device_match_by_alias(struct device *dev, void *data)
|
|
|
|
{
|
2011-08-17 13:57:56 -06:00
|
|
|
struct omap_iommu *obj = to_iommu(dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
const char *name = data;
|
|
|
|
|
|
|
|
pr_debug("%s: %s %s\n", __func__, obj->name, name);
|
|
|
|
|
|
|
|
return strcmp(obj->name, name) == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-06-01 16:46:12 -06:00
|
|
|
* omap_iommu_attach() - attach iommu device to an iommu domain
|
2011-10-10 16:18:33 -06:00
|
|
|
* @name: name of target omap iommu device
|
2011-06-01 16:46:12 -06:00
|
|
|
* @iopgd: page table
|
2009-01-26 06:13:40 -07:00
|
|
|
**/
|
2011-10-10 16:18:33 -06:00
|
|
|
static struct omap_iommu *omap_iommu_attach(const char *name, u32 *iopgd)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
int err = -ENOMEM;
|
2011-10-10 16:18:33 -06:00
|
|
|
struct device *dev;
|
|
|
|
struct omap_iommu *obj;
|
|
|
|
|
|
|
|
dev = driver_find_device(&omap_iommu_driver.driver, NULL,
|
|
|
|
(void *)name,
|
|
|
|
device_match_by_alias);
|
|
|
|
if (!dev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
obj = to_iommu(dev);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
spin_lock(&obj->iommu_lock);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
/* an iommu device can only be attached once */
|
|
|
|
if (++obj->refcount > 1) {
|
|
|
|
dev_err(dev, "%s: already attached!\n", obj->name);
|
|
|
|
err = -EBUSY;
|
|
|
|
goto err_enable;
|
2009-01-26 06:13:40 -07:00
|
|
|
}
|
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
obj->iopgd = iopgd;
|
|
|
|
err = iommu_enable(obj);
|
|
|
|
if (err)
|
|
|
|
goto err_enable;
|
|
|
|
flush_iotlb_all(obj);
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
if (!try_module_get(obj->owner))
|
|
|
|
goto err_module;
|
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
spin_unlock(&obj->iommu_lock);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
dev_dbg(obj->dev, "%s: %s\n", __func__, obj->name);
|
|
|
|
return obj;
|
|
|
|
|
|
|
|
err_module:
|
|
|
|
if (obj->refcount == 1)
|
|
|
|
iommu_disable(obj);
|
|
|
|
err_enable:
|
|
|
|
obj->refcount--;
|
2011-06-01 16:46:12 -06:00
|
|
|
spin_unlock(&obj->iommu_lock);
|
2009-01-26 06:13:40 -07:00
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-06-01 16:46:12 -06:00
|
|
|
* omap_iommu_detach - release iommu device
|
2009-01-26 06:13:40 -07:00
|
|
|
* @obj: target iommu
|
|
|
|
**/
|
2011-08-17 13:57:56 -06:00
|
|
|
static void omap_iommu_detach(struct omap_iommu *obj)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
2010-01-08 11:29:05 -07:00
|
|
|
if (!obj || IS_ERR(obj))
|
2009-01-26 06:13:40 -07:00
|
|
|
return;
|
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
spin_lock(&obj->iommu_lock);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
if (--obj->refcount == 0)
|
|
|
|
iommu_disable(obj);
|
|
|
|
|
|
|
|
module_put(obj->owner);
|
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
obj->iopgd = NULL;
|
2011-02-16 12:35:51 -07:00
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
spin_unlock(&obj->iommu_lock);
|
2011-02-16 12:35:51 -07:00
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
dev_dbg(obj->dev, "%s: %s\n", __func__, obj->name);
|
2011-02-16 12:35:51 -07:00
|
|
|
}
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
/*
|
|
|
|
* OMAP Device MMU(IOMMU) detection
|
|
|
|
*/
|
2012-12-21 16:05:21 -07:00
|
|
|
static int omap_iommu_probe(struct platform_device *pdev)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
int err = -ENODEV;
|
|
|
|
int irq;
|
2011-08-17 13:57:56 -06:00
|
|
|
struct omap_iommu *obj;
|
2009-01-26 06:13:40 -07:00
|
|
|
struct resource *res;
|
|
|
|
struct iommu_platform_data *pdata = pdev->dev.platform_data;
|
|
|
|
|
|
|
|
obj = kzalloc(sizeof(*obj) + MMU_REG_SIZE, GFP_KERNEL);
|
|
|
|
if (!obj)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
obj->nr_tlb_entries = pdata->nr_tlb_entries;
|
|
|
|
obj->name = pdata->name;
|
|
|
|
obj->dev = &pdev->dev;
|
|
|
|
obj->ctx = (void *)obj + sizeof(*obj);
|
2010-12-14 17:54:03 -07:00
|
|
|
obj->da_start = pdata->da_start;
|
|
|
|
obj->da_end = pdata->da_end;
|
2009-01-26 06:13:40 -07:00
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
spin_lock_init(&obj->iommu_lock);
|
2009-01-26 06:13:40 -07:00
|
|
|
mutex_init(&obj->mmap_lock);
|
|
|
|
spin_lock_init(&obj->page_table_lock);
|
|
|
|
INIT_LIST_HEAD(&obj->mmap);
|
|
|
|
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
if (!res) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto err_mem;
|
|
|
|
}
|
|
|
|
|
|
|
|
res = request_mem_region(res->start, resource_size(res),
|
|
|
|
dev_name(&pdev->dev));
|
|
|
|
if (!res) {
|
|
|
|
err = -EIO;
|
|
|
|
goto err_mem;
|
|
|
|
}
|
|
|
|
|
2011-03-14 06:28:32 -06:00
|
|
|
obj->regbase = ioremap(res->start, resource_size(res));
|
|
|
|
if (!obj->regbase) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err_ioremap;
|
|
|
|
}
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
|
|
if (irq < 0) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto err_irq;
|
|
|
|
}
|
|
|
|
err = request_irq(irq, iommu_fault_handler, IRQF_SHARED,
|
|
|
|
dev_name(&pdev->dev), obj);
|
|
|
|
if (err < 0)
|
|
|
|
goto err_irq;
|
|
|
|
platform_set_drvdata(pdev, obj);
|
|
|
|
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_irq_safe(obj->dev);
|
|
|
|
pm_runtime_enable(obj->dev);
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
dev_info(&pdev->dev, "%s registered\n", obj->name);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_irq:
|
|
|
|
iounmap(obj->regbase);
|
2011-03-14 06:28:32 -06:00
|
|
|
err_ioremap:
|
|
|
|
release_mem_region(res->start, resource_size(res));
|
2009-01-26 06:13:40 -07:00
|
|
|
err_mem:
|
|
|
|
kfree(obj);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-12-21 16:05:21 -07:00
|
|
|
static int omap_iommu_remove(struct platform_device *pdev)
|
2009-01-26 06:13:40 -07:00
|
|
|
{
|
|
|
|
int irq;
|
|
|
|
struct resource *res;
|
2011-08-17 13:57:56 -06:00
|
|
|
struct omap_iommu *obj = platform_get_drvdata(pdev);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
iopgtable_clear_entry_all(obj);
|
|
|
|
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
|
|
free_irq(irq, obj);
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
release_mem_region(res->start, resource_size(res));
|
|
|
|
iounmap(obj->regbase);
|
|
|
|
|
2012-11-19 18:05:51 -07:00
|
|
|
pm_runtime_disable(obj->dev);
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
dev_info(&pdev->dev, "%s removed\n", obj->name);
|
|
|
|
kfree(obj);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct platform_driver omap_iommu_driver = {
|
|
|
|
.probe = omap_iommu_probe,
|
2012-12-21 16:05:21 -07:00
|
|
|
.remove = omap_iommu_remove,
|
2009-01-26 06:13:40 -07:00
|
|
|
.driver = {
|
|
|
|
.name = "omap-iommu",
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static void iopte_cachep_ctor(void *iopte)
|
|
|
|
{
|
|
|
|
clean_dcache_area(iopte, IOPTE_TABLE_SIZE);
|
|
|
|
}
|
|
|
|
|
2012-11-02 13:24:06 -06:00
|
|
|
static u32 iotlb_init_entry(struct iotlb_entry *e, u32 da, u32 pa,
|
|
|
|
u32 flags)
|
|
|
|
{
|
|
|
|
memset(e, 0, sizeof(*e));
|
|
|
|
|
|
|
|
e->da = da;
|
|
|
|
e->pa = pa;
|
|
|
|
e->valid = 1;
|
|
|
|
/* FIXME: add OMAP1 support */
|
|
|
|
e->pgsz = flags & MMU_CAM_PGSZ_MASK;
|
|
|
|
e->endian = flags & MMU_RAM_ENDIAN_MASK;
|
|
|
|
e->elsz = flags & MMU_RAM_ELSZ_MASK;
|
|
|
|
e->mixed = flags & MMU_RAM_MIXED_MASK;
|
|
|
|
|
|
|
|
return iopgsz_to_bytes(e->pgsz);
|
|
|
|
}
|
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
static int omap_iommu_map(struct iommu_domain *domain, unsigned long da,
|
2011-11-10 02:32:25 -07:00
|
|
|
phys_addr_t pa, size_t bytes, int prot)
|
2011-06-01 16:46:12 -06:00
|
|
|
{
|
|
|
|
struct omap_iommu_domain *omap_domain = domain->priv;
|
2011-08-17 13:57:56 -06:00
|
|
|
struct omap_iommu *oiommu = omap_domain->iommu_dev;
|
2011-06-01 16:46:12 -06:00
|
|
|
struct device *dev = oiommu->dev;
|
|
|
|
struct iotlb_entry e;
|
|
|
|
int omap_pgsz;
|
|
|
|
u32 ret, flags;
|
|
|
|
|
|
|
|
/* we only support mapping a single iommu page for now */
|
|
|
|
omap_pgsz = bytes_to_iopgsz(bytes);
|
|
|
|
if (omap_pgsz < 0) {
|
|
|
|
dev_err(dev, "invalid size to map: %d\n", bytes);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(dev, "mapping da 0x%lx to pa 0x%x size 0x%x\n", da, pa, bytes);
|
|
|
|
|
|
|
|
flags = omap_pgsz | prot;
|
|
|
|
|
|
|
|
iotlb_init_entry(&e, da, pa, flags);
|
|
|
|
|
2011-08-17 13:57:56 -06:00
|
|
|
ret = omap_iopgtable_store_entry(oiommu, &e);
|
2011-09-02 11:32:31 -06:00
|
|
|
if (ret)
|
2011-08-17 13:57:56 -06:00
|
|
|
dev_err(dev, "omap_iopgtable_store_entry failed: %d\n", ret);
|
2011-06-01 16:46:12 -06:00
|
|
|
|
2011-09-02 11:32:31 -06:00
|
|
|
return ret;
|
2011-06-01 16:46:12 -06:00
|
|
|
}
|
|
|
|
|
2011-11-10 02:32:25 -07:00
|
|
|
static size_t omap_iommu_unmap(struct iommu_domain *domain, unsigned long da,
|
|
|
|
size_t size)
|
2011-06-01 16:46:12 -06:00
|
|
|
{
|
|
|
|
struct omap_iommu_domain *omap_domain = domain->priv;
|
2011-08-17 13:57:56 -06:00
|
|
|
struct omap_iommu *oiommu = omap_domain->iommu_dev;
|
2011-06-01 16:46:12 -06:00
|
|
|
struct device *dev = oiommu->dev;
|
|
|
|
|
2011-11-10 02:32:25 -07:00
|
|
|
dev_dbg(dev, "unmapping da 0x%lx size %u\n", da, size);
|
2011-06-01 16:46:12 -06:00
|
|
|
|
2011-11-10 02:32:25 -07:00
|
|
|
return iopgtable_clear_entry(oiommu, da);
|
2011-06-01 16:46:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
omap_iommu_attach_dev(struct iommu_domain *domain, struct device *dev)
|
|
|
|
{
|
|
|
|
struct omap_iommu_domain *omap_domain = domain->priv;
|
2011-08-17 13:57:56 -06:00
|
|
|
struct omap_iommu *oiommu;
|
2011-10-10 16:18:33 -06:00
|
|
|
struct omap_iommu_arch_data *arch_data = dev->archdata.iommu;
|
2011-06-01 16:46:12 -06:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
spin_lock(&omap_domain->lock);
|
|
|
|
|
|
|
|
/* only a single device is supported per domain for now */
|
|
|
|
if (omap_domain->iommu_dev) {
|
|
|
|
dev_err(dev, "iommu domain is already attached\n");
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get a handle to and enable the omap iommu */
|
2011-10-10 16:18:33 -06:00
|
|
|
oiommu = omap_iommu_attach(arch_data->name, omap_domain->pgtable);
|
2011-06-01 16:46:12 -06:00
|
|
|
if (IS_ERR(oiommu)) {
|
|
|
|
ret = PTR_ERR(oiommu);
|
|
|
|
dev_err(dev, "can't get omap iommu: %d\n", ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-10-10 16:18:33 -06:00
|
|
|
omap_domain->iommu_dev = arch_data->iommu_dev = oiommu;
|
2012-04-18 12:09:41 -06:00
|
|
|
omap_domain->dev = dev;
|
2011-09-13 13:26:29 -06:00
|
|
|
oiommu->domain = domain;
|
2011-06-01 16:46:12 -06:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock(&omap_domain->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-04-18 12:09:41 -06:00
|
|
|
static void _omap_iommu_detach_dev(struct omap_iommu_domain *omap_domain,
|
|
|
|
struct device *dev)
|
2011-06-01 16:46:12 -06:00
|
|
|
{
|
2011-10-10 16:18:33 -06:00
|
|
|
struct omap_iommu *oiommu = dev_to_omap_iommu(dev);
|
2012-04-18 12:09:41 -06:00
|
|
|
struct omap_iommu_arch_data *arch_data = dev->archdata.iommu;
|
2011-06-01 16:46:12 -06:00
|
|
|
|
|
|
|
/* only a single device is supported per domain for now */
|
|
|
|
if (omap_domain->iommu_dev != oiommu) {
|
|
|
|
dev_err(dev, "invalid iommu device\n");
|
2012-04-18 12:09:41 -06:00
|
|
|
return;
|
2011-06-01 16:46:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
iopgtable_clear_entry_all(oiommu);
|
|
|
|
|
|
|
|
omap_iommu_detach(oiommu);
|
|
|
|
|
2011-10-10 16:18:33 -06:00
|
|
|
omap_domain->iommu_dev = arch_data->iommu_dev = NULL;
|
2012-04-18 12:09:41 -06:00
|
|
|
omap_domain->dev = NULL;
|
|
|
|
}
|
2011-06-01 16:46:12 -06:00
|
|
|
|
2012-04-18 12:09:41 -06:00
|
|
|
static void omap_iommu_detach_dev(struct iommu_domain *domain,
|
|
|
|
struct device *dev)
|
|
|
|
{
|
|
|
|
struct omap_iommu_domain *omap_domain = domain->priv;
|
|
|
|
|
|
|
|
spin_lock(&omap_domain->lock);
|
|
|
|
_omap_iommu_detach_dev(omap_domain, dev);
|
2011-06-01 16:46:12 -06:00
|
|
|
spin_unlock(&omap_domain->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int omap_iommu_domain_init(struct iommu_domain *domain)
|
|
|
|
{
|
|
|
|
struct omap_iommu_domain *omap_domain;
|
|
|
|
|
|
|
|
omap_domain = kzalloc(sizeof(*omap_domain), GFP_KERNEL);
|
|
|
|
if (!omap_domain) {
|
|
|
|
pr_err("kzalloc failed\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
omap_domain->pgtable = kzalloc(IOPGD_TABLE_SIZE, GFP_KERNEL);
|
|
|
|
if (!omap_domain->pgtable) {
|
|
|
|
pr_err("kzalloc failed\n");
|
|
|
|
goto fail_nomem;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* should never fail, but please keep this around to ensure
|
|
|
|
* we keep the hardware happy
|
|
|
|
*/
|
|
|
|
BUG_ON(!IS_ALIGNED((long)omap_domain->pgtable, IOPGD_TABLE_SIZE));
|
|
|
|
|
|
|
|
clean_dcache_area(omap_domain->pgtable, IOPGD_TABLE_SIZE);
|
|
|
|
spin_lock_init(&omap_domain->lock);
|
|
|
|
|
|
|
|
domain->priv = omap_domain;
|
|
|
|
|
2012-01-26 11:40:55 -07:00
|
|
|
domain->geometry.aperture_start = 0;
|
|
|
|
domain->geometry.aperture_end = (1ULL << 32) - 1;
|
|
|
|
domain->geometry.force_aperture = true;
|
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail_nomem:
|
|
|
|
kfree(omap_domain);
|
|
|
|
out:
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_iommu_domain_destroy(struct iommu_domain *domain)
|
|
|
|
{
|
|
|
|
struct omap_iommu_domain *omap_domain = domain->priv;
|
|
|
|
|
|
|
|
domain->priv = NULL;
|
|
|
|
|
2012-04-18 12:09:41 -06:00
|
|
|
/*
|
|
|
|
* An iommu device is still attached
|
|
|
|
* (currently, only one device can be attached) ?
|
|
|
|
*/
|
|
|
|
if (omap_domain->iommu_dev)
|
|
|
|
_omap_iommu_detach_dev(omap_domain, omap_domain->dev);
|
|
|
|
|
2011-06-01 16:46:12 -06:00
|
|
|
kfree(omap_domain->pgtable);
|
|
|
|
kfree(omap_domain);
|
|
|
|
}
|
|
|
|
|
|
|
|
static phys_addr_t omap_iommu_iova_to_phys(struct iommu_domain *domain,
|
2013-03-28 13:53:58 -06:00
|
|
|
dma_addr_t da)
|
2011-06-01 16:46:12 -06:00
|
|
|
{
|
|
|
|
struct omap_iommu_domain *omap_domain = domain->priv;
|
2011-08-17 13:57:56 -06:00
|
|
|
struct omap_iommu *oiommu = omap_domain->iommu_dev;
|
2011-06-01 16:46:12 -06:00
|
|
|
struct device *dev = oiommu->dev;
|
|
|
|
u32 *pgd, *pte;
|
|
|
|
phys_addr_t ret = 0;
|
|
|
|
|
|
|
|
iopgtable_lookup_entry(oiommu, da, &pgd, &pte);
|
|
|
|
|
|
|
|
if (pte) {
|
|
|
|
if (iopte_is_small(*pte))
|
|
|
|
ret = omap_iommu_translate(*pte, da, IOPTE_MASK);
|
|
|
|
else if (iopte_is_large(*pte))
|
|
|
|
ret = omap_iommu_translate(*pte, da, IOLARGE_MASK);
|
|
|
|
else
|
2013-05-30 17:10:38 -06:00
|
|
|
dev_err(dev, "bogus pte 0x%x, da 0x%llx", *pte,
|
|
|
|
(unsigned long long)da);
|
2011-06-01 16:46:12 -06:00
|
|
|
} else {
|
|
|
|
if (iopgd_is_section(*pgd))
|
|
|
|
ret = omap_iommu_translate(*pgd, da, IOSECTION_MASK);
|
|
|
|
else if (iopgd_is_super(*pgd))
|
|
|
|
ret = omap_iommu_translate(*pgd, da, IOSUPER_MASK);
|
|
|
|
else
|
2013-05-30 17:10:38 -06:00
|
|
|
dev_err(dev, "bogus pgd 0x%x, da 0x%llx", *pgd,
|
|
|
|
(unsigned long long)da);
|
2011-06-01 16:46:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int omap_iommu_domain_has_cap(struct iommu_domain *domain,
|
|
|
|
unsigned long cap)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct iommu_ops omap_iommu_ops = {
|
|
|
|
.domain_init = omap_iommu_domain_init,
|
|
|
|
.domain_destroy = omap_iommu_domain_destroy,
|
|
|
|
.attach_dev = omap_iommu_attach_dev,
|
|
|
|
.detach_dev = omap_iommu_detach_dev,
|
|
|
|
.map = omap_iommu_map,
|
|
|
|
.unmap = omap_iommu_unmap,
|
|
|
|
.iova_to_phys = omap_iommu_iova_to_phys,
|
|
|
|
.domain_has_cap = omap_iommu_domain_has_cap,
|
2011-11-10 02:32:27 -07:00
|
|
|
.pgsize_bitmap = OMAP_IOMMU_PGSIZES,
|
2011-06-01 16:46:12 -06:00
|
|
|
};
|
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
static int __init omap_iommu_init(void)
|
|
|
|
{
|
|
|
|
struct kmem_cache *p;
|
|
|
|
const unsigned long flags = SLAB_HWCACHE_ALIGN;
|
|
|
|
size_t align = 1 << 10; /* L2 pagetable alignement */
|
|
|
|
|
|
|
|
p = kmem_cache_create("iopte_cache", IOPTE_TABLE_SIZE, align, flags,
|
|
|
|
iopte_cachep_ctor);
|
|
|
|
if (!p)
|
|
|
|
return -ENOMEM;
|
|
|
|
iopte_cachep = p;
|
|
|
|
|
2011-09-06 09:56:07 -06:00
|
|
|
bus_set_iommu(&platform_bus_type, &omap_iommu_ops);
|
2011-06-01 16:46:12 -06:00
|
|
|
|
2009-01-26 06:13:40 -07:00
|
|
|
return platform_driver_register(&omap_iommu_driver);
|
|
|
|
}
|
2012-02-26 03:14:14 -07:00
|
|
|
/* must be ready before omap3isp is probed */
|
|
|
|
subsys_initcall(omap_iommu_init);
|
2009-01-26 06:13:40 -07:00
|
|
|
|
|
|
|
static void __exit omap_iommu_exit(void)
|
|
|
|
{
|
|
|
|
kmem_cache_destroy(iopte_cachep);
|
|
|
|
|
|
|
|
platform_driver_unregister(&omap_iommu_driver);
|
|
|
|
}
|
|
|
|
module_exit(omap_iommu_exit);
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION("omap iommu: tlb and pagetable primitives");
|
|
|
|
MODULE_ALIAS("platform:omap-iommu");
|
|
|
|
MODULE_AUTHOR("Hiroshi DOYU, Paul Mundt and Toshihiro Kobayashi");
|
|
|
|
MODULE_LICENSE("GPL v2");
|