[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / iommu / omap-iommu-debug.c

/*
 * omap iommu: debugfs interface
 *
 * 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/clk.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/platform_device.h>
#include <linux/debugfs.h>
#include <linux/omap-iommu.h>
#include <linux/platform_data/iommu-omap.h>

#include "omap-iopgtable.h"
#include "omap-iommu.h"

#define MAXCOLUMN 100 /* for short messages */

static DEFINE_MUTEX(iommu_debug_lock);

static struct dentry *iommu_debug_root;

static ssize_t debug_read_ver(struct file *file, char __user *userbuf,
			      size_t count, loff_t *ppos)
{
	u32 ver = omap_iommu_arch_version();
	char buf[MAXCOLUMN], *p = buf;

	p += sprintf(p, "H/W version: %d.%d\n", (ver >> 4) & 0xf , ver & 0xf);

	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
}

static ssize_t debug_read_regs(struct file *file, char __user *userbuf,
			       size_t count, loff_t *ppos)
{
	struct device *dev = file->private_data;
	struct omap_iommu *obj = dev_to_omap_iommu(dev);
	char *p, *buf;
	ssize_t bytes;

	buf = kmalloc(count, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;
	p = buf;

	mutex_lock(&iommu_debug_lock);

	bytes = omap_iommu_dump_ctx(obj, p, count);
	bytes = simple_read_from_buffer(userbuf, count, ppos, buf, bytes);

	mutex_unlock(&iommu_debug_lock);
	kfree(buf);

	return bytes;
}

static ssize_t debug_read_tlb(struct file *file, char __user *userbuf,
			      size_t count, loff_t *ppos)
{
	struct device *dev = file->private_data;
	struct omap_iommu *obj = dev_to_omap_iommu(dev);
	char *p, *buf;
	ssize_t bytes, rest;

	buf = kmalloc(count, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;
	p = buf;

	mutex_lock(&iommu_debug_lock);

	p += sprintf(p, "%8s %8s\n", "cam:", "ram:");
	p += sprintf(p, "-----------------------------------------\n");
	rest = count - (p - buf);
	p += omap_dump_tlb_entries(obj, p, rest);

	bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);

	mutex_unlock(&iommu_debug_lock);
	kfree(buf);

	return bytes;
}

static ssize_t debug_write_pagetable(struct file *file,
		     const char __user *userbuf, size_t count, loff_t *ppos)
{
	struct iotlb_entry e;
	struct cr_regs cr;
	int err;
	struct device *dev = file->private_data;
	struct omap_iommu *obj = dev_to_omap_iommu(dev);
	char buf[MAXCOLUMN], *p = buf;

	count = min(count, sizeof(buf));

	mutex_lock(&iommu_debug_lock);
	if (copy_from_user(p, userbuf, count)) {
		mutex_unlock(&iommu_debug_lock);
		return -EFAULT;
	}

	sscanf(p, "%x %x", &cr.cam, &cr.ram);
	if (!cr.cam || !cr.ram) {
		mutex_unlock(&iommu_debug_lock);
		return -EINVAL;
	}

	omap_iotlb_cr_to_e(&cr, &e);
	err = omap_iopgtable_store_entry(obj, &e);
	if (err)
		dev_err(obj->dev, "%s: fail to store cr\n", __func__);

	mutex_unlock(&iommu_debug_lock);
	return count;
}

#define dump_ioptable_entry_one(lv, da, val)			\
	({							\
		int __err = 0;					\
		ssize_t bytes;					\
		const int maxcol = 22;				\
		const char *str = "%d: %08x %08x\n";		\
		bytes = snprintf(p, maxcol, str, lv, da, val);	\
		p += bytes;					\
		len -= bytes;					\
		if (len < maxcol)				\
			__err = -ENOMEM;			\
		__err;						\
	})

static ssize_t dump_ioptable(struct omap_iommu *obj, char *buf, ssize_t len)
{
	int i;
	u32 *iopgd;
	char *p = buf;

	spin_lock(&obj->page_table_lock);

	iopgd = iopgd_offset(obj, 0);
	for (i = 0; i < PTRS_PER_IOPGD; i++, iopgd++) {
		int j, err;
		u32 *iopte;
		u32 da;

		if (!*iopgd)
			continue;

		if (!(*iopgd & IOPGD_TABLE)) {
			da = i << IOPGD_SHIFT;

			err = dump_ioptable_entry_one(1, da, *iopgd);
			if (err)
				goto out;
			continue;
		}

		iopte = iopte_offset(iopgd, 0);

		for (j = 0; j < PTRS_PER_IOPTE; j++, iopte++) {
			if (!*iopte)
				continue;

			da = (i << IOPGD_SHIFT) + (j << IOPTE_SHIFT);
			err = dump_ioptable_entry_one(2, da, *iopgd);
			if (err)
				goto out;
		}
	}
out:
	spin_unlock(&obj->page_table_lock);

	return p - buf;
}

static ssize_t debug_read_pagetable(struct file *file, char __user *userbuf,
				    size_t count, loff_t *ppos)
{
	struct device *dev = file->private_data;
	struct omap_iommu *obj = dev_to_omap_iommu(dev);
	char *p, *buf;
	size_t bytes;

	buf = (char *)__get_free_page(GFP_KERNEL);
	if (!buf)
		return -ENOMEM;
	p = buf;

	p += sprintf(p, "L: %8s %8s\n", "da:", "pa:");
	p += sprintf(p, "-----------------------------------------\n");

	mutex_lock(&iommu_debug_lock);

	bytes = PAGE_SIZE - (p - buf);
	p += dump_ioptable(obj, p, bytes);

	bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);

	mutex_unlock(&iommu_debug_lock);
	free_page((unsigned long)buf);

	return bytes;
}

static ssize_t debug_read_mmap(struct file *file, char __user *userbuf,
			       size_t count, loff_t *ppos)
{
	struct device *dev = file->private_data;
	struct omap_iommu *obj = dev_to_omap_iommu(dev);
	char *p, *buf;
	struct iovm_struct *tmp;
	int uninitialized_var(i);
	ssize_t bytes;

	buf = (char *)__get_free_page(GFP_KERNEL);
	if (!buf)
		return -ENOMEM;
	p = buf;

	p += sprintf(p, "%-3s %-8s %-8s %6s %8s\n",
		     "No", "start", "end", "size", "flags");
	p += sprintf(p, "-------------------------------------------------\n");

	mutex_lock(&iommu_debug_lock);

	list_for_each_entry(tmp, &obj->mmap, list) {
		size_t len;
		const char *str = "%3d %08x-%08x %6x %8x\n";
		const int maxcol = 39;

		len = tmp->da_end - tmp->da_start;
		p += snprintf(p, maxcol, str,
			      i, tmp->da_start, tmp->da_end, len, tmp->flags);

		if (PAGE_SIZE - (p - buf) < maxcol)
			break;
		i++;
	}

	bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);

	mutex_unlock(&iommu_debug_lock);
	free_page((unsigned long)buf);

	return bytes;
}

static ssize_t debug_read_mem(struct file *file, char __user *userbuf,
			      size_t count, loff_t *ppos)
{
	struct device *dev = file->private_data;
	char *p, *buf;
	struct iovm_struct *area;
	ssize_t bytes;

	count = min_t(ssize_t, count, PAGE_SIZE);

	buf = (char *)__get_free_page(GFP_KERNEL);
	if (!buf)
		return -ENOMEM;
	p = buf;

	mutex_lock(&iommu_debug_lock);

	area = omap_find_iovm_area(dev, (u32)ppos);
	if (!area) {
		bytes = -EINVAL;
		goto err_out;
	}
	memcpy(p, area->va, count);
	p += count;

	bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
err_out:
	mutex_unlock(&iommu_debug_lock);
	free_page((unsigned long)buf);

	return bytes;
}

static ssize_t debug_write_mem(struct file *file, const char __user *userbuf,
			       size_t count, loff_t *ppos)
{
	struct device *dev = file->private_data;
	struct iovm_struct *area;
	char *p, *buf;

	count = min_t(size_t, count, PAGE_SIZE);

	buf = (char *)__get_free_page(GFP_KERNEL);
	if (!buf)
		return -ENOMEM;
	p = buf;

	mutex_lock(&iommu_debug_lock);

	if (copy_from_user(p, userbuf, count)) {
		count =  -EFAULT;
		goto err_out;
	}

	area = omap_find_iovm_area(dev, (u32)ppos);
	if (!area) {
		count = -EINVAL;
		goto err_out;
	}
	memcpy(area->va, p, count);
err_out:
	mutex_unlock(&iommu_debug_lock);
	free_page((unsigned long)buf);

	return count;
}

#define DEBUG_FOPS(name)						\
	static const struct file_operations debug_##name##_fops = {	\
		.open = simple_open,					\
		.read = debug_read_##name,				\
		.write = debug_write_##name,				\
		.llseek = generic_file_llseek,				\
	};

#define DEBUG_FOPS_RO(name)						\
	static const struct file_operations debug_##name##_fops = {	\
		.open = simple_open,					\
		.read = debug_read_##name,				\
		.llseek = generic_file_llseek,				\
	};

DEBUG_FOPS_RO(ver);
DEBUG_FOPS_RO(regs);
DEBUG_FOPS_RO(tlb);
DEBUG_FOPS(pagetable);
DEBUG_FOPS_RO(mmap);
DEBUG_FOPS(mem);

#define __DEBUG_ADD_FILE(attr, mode)					\
	{								\
		struct dentry *dent;					\
		dent = debugfs_create_file(#attr, mode, parent,		\
					   dev, &debug_##attr##_fops);	\
		if (!dent)						\
			return -ENOMEM;					\
	}

#define DEBUG_ADD_FILE(name) __DEBUG_ADD_FILE(name, 600)
#define DEBUG_ADD_FILE_RO(name) __DEBUG_ADD_FILE(name, 400)

static int iommu_debug_register(struct device *dev, void *data)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct omap_iommu *obj = platform_get_drvdata(pdev);
	struct omap_iommu_arch_data *arch_data;
	struct dentry *d, *parent;

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

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

	arch_data->iommu_dev = obj;

	dev->archdata.iommu = arch_data;

	d = debugfs_create_dir(obj->name, iommu_debug_root);
	if (!d)
		goto nomem;
	parent = d;

	d = debugfs_create_u8("nr_tlb_entries", 400, parent,
			      (u8 *)&obj->nr_tlb_entries);
	if (!d)
		goto nomem;

	DEBUG_ADD_FILE_RO(ver);
	DEBUG_ADD_FILE_RO(regs);
	DEBUG_ADD_FILE_RO(tlb);
	DEBUG_ADD_FILE(pagetable);
	DEBUG_ADD_FILE_RO(mmap);
	DEBUG_ADD_FILE(mem);

	return 0;

nomem:
	kfree(arch_data);
	return -ENOMEM;
}

static int iommu_debug_unregister(struct device *dev, void *data)
{
	if (!dev->archdata.iommu)
		return 0;

	kfree(dev->archdata.iommu);

	dev->archdata.iommu = NULL;

	return 0;
}

static int __init iommu_debug_init(void)
{
	struct dentry *d;
	int err;

	d = debugfs_create_dir("iommu", NULL);
	if (!d)
		return -ENOMEM;
	iommu_debug_root = d;

	err = omap_foreach_iommu_device(d, iommu_debug_register);
	if (err)
		goto err_out;
	return 0;

err_out:
	debugfs_remove_recursive(iommu_debug_root);
	return err;
}
module_init(iommu_debug_init)

static void __exit iommu_debugfs_exit(void)
{
	debugfs_remove_recursive(iommu_debug_root);
	omap_foreach_iommu_device(NULL, iommu_debug_unregister);
}
module_exit(iommu_debugfs_exit)

MODULE_DESCRIPTION("omap iommu: debugfs interface");
MODULE_AUTHOR("Hiroshi DOYU <Hiroshi.DOYU@nokia.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
14e0e679 HD	1	/*
	2	* omap iommu: debugfs interface
	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>
14e0e679 HD	14	#include <linux/err.h>
	15	#include <linux/clk.h>
	16	#include <linux/io.h>
5a0e3ad6	17	#include <linux/slab.h>
14e0e679 HD	18	#include <linux/uaccess.h>
	19	#include <linux/platform_device.h>
	20	#include <linux/debugfs.h>
c8d35c84	21	#include <linux/omap-iommu.h>
2ab7c848	22	#include <linux/platform_data/iommu-omap.h>
14e0e679	23
2f7702af	24	#include "omap-iopgtable.h"
ed1c7de2	25	#include "omap-iommu.h"
14e0e679 HD	26
	27	#define MAXCOLUMN 100 /* for short messages */
	28
	29	static DEFINE_MUTEX(iommu_debug_lock);
	30
	31	static struct dentry *iommu_debug_root;
	32
	33	static ssize_t debug_read_ver(struct file file, char __user userbuf,
	34	size_t count, loff_t *ppos)
	35	{
6c32df43	36	u32 ver = omap_iommu_arch_version();
14e0e679 HD	37	char buf[MAXCOLUMN], *p = buf;
	38
	39	p += sprintf(p, "H/W version: %d.%d\n", (ver >> 4) & 0xf , ver & 0xf);
	40
	41	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
	42	}
	43
	44	static ssize_t debug_read_regs(struct file file, char __user userbuf,
	45	size_t count, loff_t *ppos)
	46	{
46451d62 OBC	47	struct device *dev = file->private_data;
46451d62 OBC	48	struct omap_iommu *obj = dev_to_omap_iommu(dev);
14e0e679 HD	49	char p, buf;
	50	ssize_t bytes;
	51
	52	buf = kmalloc(count, GFP_KERNEL);
	53	if (!buf)
	54	return -ENOMEM;
	55	p = buf;
	56
	57	mutex_lock(&iommu_debug_lock);
	58
6c32df43	59	bytes = omap_iommu_dump_ctx(obj, p, count);
14e0e679 HD	60	bytes = simple_read_from_buffer(userbuf, count, ppos, buf, bytes);
	61
	62	mutex_unlock(&iommu_debug_lock);
	63	kfree(buf);
	64
	65	return bytes;
	66	}
	67
	68	static ssize_t debug_read_tlb(struct file file, char __user userbuf,
	69	size_t count, loff_t *ppos)
	70	{
46451d62 OBC	71	struct device *dev = file->private_data;
46451d62 OBC	72	struct omap_iommu *obj = dev_to_omap_iommu(dev);
14e0e679 HD	73	char p, buf;
	74	ssize_t bytes, rest;
	75
	76	buf = kmalloc(count, GFP_KERNEL);
	77	if (!buf)
	78	return -ENOMEM;
	79	p = buf;
	80
	81	mutex_lock(&iommu_debug_lock);
	82
	83	p += sprintf(p, "%8s %8s\n", "cam:", "ram:");
	84	p += sprintf(p, "-----------------------------------------\n");
	85	rest = count - (p - buf);
6c32df43	86	p += omap_dump_tlb_entries(obj, p, rest);
14e0e679 HD	87
	88	bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
	89
	90	mutex_unlock(&iommu_debug_lock);
	91	kfree(buf);
	92
	93	return bytes;
	94	}
	95
	96	static ssize_t debug_write_pagetable(struct file *file,
	97	const char __user userbuf, size_t count, loff_t ppos)
	98	{
	99	struct iotlb_entry e;
	100	struct cr_regs cr;
	101	int err;
46451d62 OBC	102	struct device *dev = file->private_data;
46451d62 OBC	103	struct omap_iommu *obj = dev_to_omap_iommu(dev);
14e0e679 HD	104	char buf[MAXCOLUMN], *p = buf;
	105
	106	count = min(count, sizeof(buf));
	107
	108	mutex_lock(&iommu_debug_lock);
	109	if (copy_from_user(p, userbuf, count)) {
	110	mutex_unlock(&iommu_debug_lock);
	111	return -EFAULT;
	112	}
	113
	114	sscanf(p, "%x %x", &cr.cam, &cr.ram);
	115	if (!cr.cam \|\| !cr.ram) {
	116	mutex_unlock(&iommu_debug_lock);
	117	return -EINVAL;
	118	}
	119
6c32df43 OBC	120	omap_iotlb_cr_to_e(&cr, &e);
6c32df43 OBC	121	err = omap_iopgtable_store_entry(obj, &e);
14e0e679 HD	122	if (err)
	123	dev_err(obj->dev, "%s: fail to store cr\n", __func__);
	124
	125	mutex_unlock(&iommu_debug_lock);
	126	return count;
	127	}
	128
	129	#define dump_ioptable_entry_one(lv, da, val) \
	130	({ \
	131	int __err = 0; \
	132	ssize_t bytes; \
	133	const int maxcol = 22; \
	134	const char *str = "%d: %08x %08x\n"; \
	135	bytes = snprintf(p, maxcol, str, lv, da, val); \
	136	p += bytes; \
	137	len -= bytes; \
	138	if (len < maxcol) \
	139	__err = -ENOMEM; \
	140	__err; \
	141	})
	142
6c32df43	143	static ssize_t dump_ioptable(struct omap_iommu obj, char buf, ssize_t len)
14e0e679 HD	144	{
	145	int i;
	146	u32 *iopgd;
	147	char *p = buf;
	148
	149	spin_lock(&obj->page_table_lock);
	150
	151	iopgd = iopgd_offset(obj, 0);
	152	for (i = 0; i < PTRS_PER_IOPGD; i++, iopgd++) {
	153	int j, err;
	154	u32 *iopte;
	155	u32 da;
	156
	157	if (!*iopgd)
	158	continue;
	159
	160	if (!(*iopgd & IOPGD_TABLE)) {
	161	da = i << IOPGD_SHIFT;
	162
	163	err = dump_ioptable_entry_one(1, da, *iopgd);
	164	if (err)
	165	goto out;
	166	continue;
	167	}
	168
	169	iopte = iopte_offset(iopgd, 0);
	170
	171	for (j = 0; j < PTRS_PER_IOPTE; j++, iopte++) {
	172	if (!*iopte)
	173	continue;
	174
	175	da = (i << IOPGD_SHIFT) + (j << IOPTE_SHIFT);
	176	err = dump_ioptable_entry_one(2, da, *iopgd);
	177	if (err)
	178	goto out;
	179	}
	180	}
	181	out:
	182	spin_unlock(&obj->page_table_lock);
	183
	184	return p - buf;
	185	}
	186
	187	static ssize_t debug_read_pagetable(struct file file, char __user userbuf,
	188	size_t count, loff_t *ppos)
	189	{
46451d62 OBC	190	struct device *dev = file->private_data;
46451d62 OBC	191	struct omap_iommu *obj = dev_to_omap_iommu(dev);
14e0e679 HD	192	char p, buf;
	193	size_t bytes;
	194
	195	buf = (char *)__get_free_page(GFP_KERNEL);
	196	if (!buf)
	197	return -ENOMEM;
	198	p = buf;
	199
	200	p += sprintf(p, "L: %8s %8s\n", "da:", "pa:");
	201	p += sprintf(p, "-----------------------------------------\n");
	202
	203	mutex_lock(&iommu_debug_lock);
	204
	205	bytes = PAGE_SIZE - (p - buf);
	206	p += dump_ioptable(obj, p, bytes);
	207
	208	bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
	209
	210	mutex_unlock(&iommu_debug_lock);
	211	free_page((unsigned long)buf);
	212
	213	return bytes;
	214	}
	215
	216	static ssize_t debug_read_mmap(struct file file, char __user userbuf,
	217	size_t count, loff_t *ppos)
	218	{
46451d62 OBC	219	struct device *dev = file->private_data;
46451d62 OBC	220	struct omap_iommu *obj = dev_to_omap_iommu(dev);
14e0e679 HD	221	char p, buf;
	222	struct iovm_struct *tmp;
	223	int uninitialized_var(i);
	224	ssize_t bytes;
	225
	226	buf = (char *)__get_free_page(GFP_KERNEL);
	227	if (!buf)
	228	return -ENOMEM;
	229	p = buf;
	230
	231	p += sprintf(p, "%-3s %-8s %-8s %6s %8s\n",
	232	"No", "start", "end", "size", "flags");
	233	p += sprintf(p, "-------------------------------------------------\n");
	234
	235	mutex_lock(&iommu_debug_lock);
	236
	237	list_for_each_entry(tmp, &obj->mmap, list) {
	238	size_t len;
	239	const char *str = "%3d %08x-%08x %6x %8x\n";
	240	const int maxcol = 39;
	241
	242	len = tmp->da_end - tmp->da_start;
	243	p += snprintf(p, maxcol, str,
	244	i, tmp->da_start, tmp->da_end, len, tmp->flags);
	245
	246	if (PAGE_SIZE - (p - buf) < maxcol)
	247	break;
	248	i++;
	249	}
	250
	251	bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
	252
	253	mutex_unlock(&iommu_debug_lock);
	254	free_page((unsigned long)buf);
	255
	256	return bytes;
	257	}
	258
	259	static ssize_t debug_read_mem(struct file file, char __user userbuf,
	260	size_t count, loff_t *ppos)
	261	{
46451d62	262	struct device *dev = file->private_data;
14e0e679 HD	263	char p, buf;
	264	struct iovm_struct *area;
	265	ssize_t bytes;
	266
	267	count = min_t(ssize_t, count, PAGE_SIZE);
	268
	269	buf = (char *)__get_free_page(GFP_KERNEL);
	270	if (!buf)
	271	return -ENOMEM;
	272	p = buf;
	273
	274	mutex_lock(&iommu_debug_lock);
	275
46451d62	276	area = omap_find_iovm_area(dev, (u32)ppos);
87997aaa	277	if (!area) {
14e0e679 HD	278	bytes = -EINVAL;
	279	goto err_out;
	280	}
	281	memcpy(p, area->va, count);
	282	p += count;
	283
	284	bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
	285	err_out:
	286	mutex_unlock(&iommu_debug_lock);
	287	free_page((unsigned long)buf);
	288
	289	return bytes;
	290	}
	291
	292	static ssize_t debug_write_mem(struct file file, const char __user userbuf,
	293	size_t count, loff_t *ppos)
	294	{
46451d62	295	struct device *dev = file->private_data;
14e0e679 HD	296	struct iovm_struct *area;
	297	char p, buf;
	298
	299	count = min_t(size_t, count, PAGE_SIZE);
	300
	301	buf = (char *)__get_free_page(GFP_KERNEL);
	302	if (!buf)
	303	return -ENOMEM;
	304	p = buf;
	305
	306	mutex_lock(&iommu_debug_lock);
	307
	308	if (copy_from_user(p, userbuf, count)) {
	309	count = -EFAULT;
	310	goto err_out;
	311	}
	312
46451d62	313	area = omap_find_iovm_area(dev, (u32)ppos);
87997aaa	314	if (!area) {
14e0e679 HD	315	count = -EINVAL;
	316	goto err_out;
	317	}
	318	memcpy(area->va, p, count);
	319	err_out:
	320	mutex_unlock(&iommu_debug_lock);
	321	free_page((unsigned long)buf);
	322
	323	return count;
	324	}
	325
14e0e679 HD	326	#define DEBUG_FOPS(name) \
14e0e679 HD	327	static const struct file_operations debug_##name##_fops = { \
234e3405	328	.open = simple_open, \
14e0e679 HD	329	.read = debug_read_##name, \
14e0e679 HD	330	.write = debug_write_##name, \
c0b0aca0	331	.llseek = generic_file_llseek, \
14e0e679 HD	332	};
	333
	334	#define DEBUG_FOPS_RO(name) \
	335	static const struct file_operations debug_##name##_fops = { \
234e3405	336	.open = simple_open, \
14e0e679	337	.read = debug_read_##name, \
c0b0aca0	338	.llseek = generic_file_llseek, \
14e0e679 HD	339	};
	340
	341	DEBUG_FOPS_RO(ver);
	342	DEBUG_FOPS_RO(regs);
	343	DEBUG_FOPS_RO(tlb);
	344	DEBUG_FOPS(pagetable);
	345	DEBUG_FOPS_RO(mmap);
	346	DEBUG_FOPS(mem);
	347
	348	#define __DEBUG_ADD_FILE(attr, mode) \
	349	{ \
	350	struct dentry *dent; \
	351	dent = debugfs_create_file(#attr, mode, parent, \
46451d62	352	dev, &debug_##attr##_fops); \
14e0e679 HD	353	if (!dent) \
	354	return -ENOMEM; \
	355	}
	356
	357	#define DEBUG_ADD_FILE(name) __DEBUG_ADD_FILE(name, 600)
	358	#define DEBUG_ADD_FILE_RO(name) __DEBUG_ADD_FILE(name, 400)
	359
	360	static int iommu_debug_register(struct device dev, void data)
	361	{
	362	struct platform_device *pdev = to_platform_device(dev);
6c32df43	363	struct omap_iommu *obj = platform_get_drvdata(pdev);
46451d62	364	struct omap_iommu_arch_data *arch_data;
14e0e679 HD	365	struct dentry d, parent;
	366
	367	if (!obj \|\| !obj->dev)
	368	return -EINVAL;
	369
46451d62 OBC	370	arch_data = kzalloc(sizeof(*arch_data), GFP_KERNEL);
	371	if (!arch_data)
	372	return -ENOMEM;
	373
	374	arch_data->iommu_dev = obj;
	375
	376	dev->archdata.iommu = arch_data;
	377
14e0e679 HD	378	d = debugfs_create_dir(obj->name, iommu_debug_root);
14e0e679 HD	379	if (!d)
46451d62	380	goto nomem;
14e0e679 HD	381	parent = d;
	382
	383	d = debugfs_create_u8("nr_tlb_entries", 400, parent,
	384	(u8 *)&obj->nr_tlb_entries);
	385	if (!d)
46451d62	386	goto nomem;
14e0e679 HD	387
	388	DEBUG_ADD_FILE_RO(ver);
	389	DEBUG_ADD_FILE_RO(regs);
	390	DEBUG_ADD_FILE_RO(tlb);
	391	DEBUG_ADD_FILE(pagetable);
	392	DEBUG_ADD_FILE_RO(mmap);
	393	DEBUG_ADD_FILE(mem);
	394
46451d62 OBC	395	return 0;
	396
	397	nomem:
	398	kfree(arch_data);
	399	return -ENOMEM;
	400	}
	401
	402	static int iommu_debug_unregister(struct device dev, void data)
	403	{
	404	if (!dev->archdata.iommu)
	405	return 0;
	406
	407	kfree(dev->archdata.iommu);
	408
	409	dev->archdata.iommu = NULL;
	410
14e0e679 HD	411	return 0;
	412	}
	413
	414	static int __init iommu_debug_init(void)
	415	{
	416	struct dentry *d;
	417	int err;
	418
	419	d = debugfs_create_dir("iommu", NULL);
	420	if (!d)
	421	return -ENOMEM;
	422	iommu_debug_root = d;
	423
6c32df43	424	err = omap_foreach_iommu_device(d, iommu_debug_register);
14e0e679 HD	425	if (err)
	426	goto err_out;
	427	return 0;
	428
	429	err_out:
	430	debugfs_remove_recursive(iommu_debug_root);
	431	return err;
	432	}
	433	module_init(iommu_debug_init)
	434
	435	static void __exit iommu_debugfs_exit(void)
	436	{
	437	debugfs_remove_recursive(iommu_debug_root);
46451d62	438	omap_foreach_iommu_device(NULL, iommu_debug_unregister);
14e0e679 HD	439	}
	440	module_exit(iommu_debugfs_exit)
	441
	442	MODULE_DESCRIPTION("omap iommu: debugfs interface");
	443	MODULE_AUTHOR("Hiroshi DOYU <Hiroshi.DOYU@nokia.com>");
	444	MODULE_LICENSE("GPL v2");