[deliverable/linux.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;
}

#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);

#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, 0600)
#define DEBUG_ADD_FILE_RO(name) __DEBUG_ADD_FILE(name, 0400)

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);

	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
14e0e679 HD	216	#define DEBUG_FOPS(name) \
14e0e679 HD	217	static const struct file_operations debug_##name##_fops = { \
234e3405	218	.open = simple_open, \
14e0e679 HD	219	.read = debug_read_##name, \
14e0e679 HD	220	.write = debug_write_##name, \
c0b0aca0	221	.llseek = generic_file_llseek, \
14e0e679 HD	222	};
	223
	224	#define DEBUG_FOPS_RO(name) \
	225	static const struct file_operations debug_##name##_fops = { \
234e3405	226	.open = simple_open, \
14e0e679	227	.read = debug_read_##name, \
c0b0aca0	228	.llseek = generic_file_llseek, \
14e0e679 HD	229	};
	230
	231	DEBUG_FOPS_RO(ver);
	232	DEBUG_FOPS_RO(regs);
	233	DEBUG_FOPS_RO(tlb);
	234	DEBUG_FOPS(pagetable);
14e0e679 HD	235
	236	#define __DEBUG_ADD_FILE(attr, mode) \
	237	{ \
	238	struct dentry *dent; \
	239	dent = debugfs_create_file(#attr, mode, parent, \
46451d62	240	dev, &debug_##attr##_fops); \
14e0e679 HD	241	if (!dent) \
	242	return -ENOMEM; \
	243	}
	244
ff3a2b73 JP	245	#define DEBUG_ADD_FILE(name) __DEBUG_ADD_FILE(name, 0600)
ff3a2b73 JP	246	#define DEBUG_ADD_FILE_RO(name) __DEBUG_ADD_FILE(name, 0400)
14e0e679 HD	247
	248	static int iommu_debug_register(struct device dev, void data)
	249	{
	250	struct platform_device *pdev = to_platform_device(dev);
6c32df43	251	struct omap_iommu *obj = platform_get_drvdata(pdev);
46451d62	252	struct omap_iommu_arch_data *arch_data;
14e0e679 HD	253	struct dentry d, parent;
	254
	255	if (!obj \|\| !obj->dev)
	256	return -EINVAL;
	257
46451d62 OBC	258	arch_data = kzalloc(sizeof(*arch_data), GFP_KERNEL);
	259	if (!arch_data)
	260	return -ENOMEM;
	261
	262	arch_data->iommu_dev = obj;
	263
	264	dev->archdata.iommu = arch_data;
	265
14e0e679 HD	266	d = debugfs_create_dir(obj->name, iommu_debug_root);
14e0e679 HD	267	if (!d)
46451d62	268	goto nomem;
14e0e679 HD	269	parent = d;
	270
	271	d = debugfs_create_u8("nr_tlb_entries", 400, parent,
	272	(u8 *)&obj->nr_tlb_entries);
	273	if (!d)
46451d62	274	goto nomem;
14e0e679 HD	275
	276	DEBUG_ADD_FILE_RO(ver);
	277	DEBUG_ADD_FILE_RO(regs);
	278	DEBUG_ADD_FILE_RO(tlb);
	279	DEBUG_ADD_FILE(pagetable);
14e0e679	280
46451d62 OBC	281	return 0;
	282
	283	nomem:
	284	kfree(arch_data);
	285	return -ENOMEM;
	286	}
	287
	288	static int iommu_debug_unregister(struct device dev, void data)
	289	{
	290	if (!dev->archdata.iommu)
	291	return 0;
	292
	293	kfree(dev->archdata.iommu);
	294
	295	dev->archdata.iommu = NULL;
	296
14e0e679 HD	297	return 0;
	298	}
	299
	300	static int __init iommu_debug_init(void)
	301	{
	302	struct dentry *d;
	303	int err;
	304
	305	d = debugfs_create_dir("iommu", NULL);
	306	if (!d)
	307	return -ENOMEM;
	308	iommu_debug_root = d;
	309
6c32df43	310	err = omap_foreach_iommu_device(d, iommu_debug_register);
14e0e679 HD	311	if (err)
	312	goto err_out;
	313	return 0;
	314
	315	err_out:
	316	debugfs_remove_recursive(iommu_debug_root);
	317	return err;
	318	}
	319	module_init(iommu_debug_init)
	320
	321	static void __exit iommu_debugfs_exit(void)
	322	{
	323	debugfs_remove_recursive(iommu_debug_root);
46451d62	324	omap_foreach_iommu_device(NULL, iommu_debug_unregister);
14e0e679 HD	325	}
	326	module_exit(iommu_debugfs_exit)
	327
	328	MODULE_DESCRIPTION("omap iommu: debugfs interface");
	329	MODULE_AUTHOR("Hiroshi DOYU <Hiroshi.DOYU@nokia.com>");
	330	MODULE_LICENSE("GPL v2");