[linux.git] / drivers / mfd / ab8500-debugfs.c

/*
 * Copyright (C) ST-Ericsson SA 2010
 *
 * Author: Mattias Wallin <[email protected]> for ST-Ericsson.
 * License Terms: GNU General Public License v2
 */

#include <linux/seq_file.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/debugfs.h>
#include <linux/platform_device.h>

#include <linux/mfd/abx500.h>
#include <linux/mfd/ab8500.h>

static u32 debug_bank;
static u32 debug_address;

/**
 * struct ab8500_reg_range
 * @first: the first address of the range
 * @last: the last address of the range
 * @perm: access permissions for the range
 */
struct ab8500_reg_range {
	u8 first;
	u8 last;
	u8 perm;
};

/**
 * struct ab8500_i2c_ranges
 * @num_ranges: the number of ranges in the list
 * @bankid: bank identifier
 * @range: the list of register ranges
 */
struct ab8500_i2c_ranges {
	u8 num_ranges;
	u8 bankid;
	const struct ab8500_reg_range *range;
};

#define AB8500_NAME_STRING "ab8500"
#define AB8500_NUM_BANKS 22

#define AB8500_REV_REG 0x80

static struct ab8500_i2c_ranges debug_ranges[AB8500_NUM_BANKS] = {
	[0x0] = {
		.num_ranges = 0,
		.range = 0,
	},
	[AB8500_SYS_CTRL1_BLOCK] = {
		.num_ranges = 3,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x02,
			},
			{
				.first = 0x42,
				.last = 0x42,
			},
			{
				.first = 0x80,
				.last = 0x81,
			},
		},
	},
	[AB8500_SYS_CTRL2_BLOCK] = {
		.num_ranges = 4,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x0D,
			},
			{
				.first = 0x0F,
				.last = 0x17,
			},
			{
				.first = 0x30,
				.last = 0x30,
			},
			{
				.first = 0x32,
				.last = 0x33,
			},
		},
	},
	[AB8500_REGU_CTRL1] = {
		.num_ranges = 3,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x00,
			},
			{
				.first = 0x03,
				.last = 0x10,
			},
			{
				.first = 0x80,
				.last = 0x84,
			},
		},
	},
	[AB8500_REGU_CTRL2] = {
		.num_ranges = 5,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x15,
			},
			{
				.first = 0x17,
				.last = 0x19,
			},
			{
				.first = 0x1B,
				.last = 0x1D,
			},
			{
				.first = 0x1F,
				.last = 0x22,
			},
			{
				.first = 0x40,
				.last = 0x44,
			},
			/* 0x80-0x8B is SIM registers and should
			 * not be accessed from here */
		},
	},
	[AB8500_USB] = {
		.num_ranges = 2,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x80,
				.last = 0x83,
			},
			{
				.first = 0x87,
				.last = 0x8A,
			},
		},
	},
	[AB8500_TVOUT] = {
		.num_ranges = 9,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x12,
			},
			{
				.first = 0x15,
				.last = 0x17,
			},
			{
				.first = 0x19,
				.last = 0x21,
			},
			{
				.first = 0x27,
				.last = 0x2C,
			},
			{
				.first = 0x41,
				.last = 0x41,
			},
			{
				.first = 0x45,
				.last = 0x5B,
			},
			{
				.first = 0x5D,
				.last = 0x5D,
			},
			{
				.first = 0x69,
				.last = 0x69,
			},
			{
				.first = 0x80,
				.last = 0x81,
			},
		},
	},
	[AB8500_DBI] = {
		.num_ranges = 0,
		.range = NULL,
	},
	[AB8500_ECI_AV_ACC] = {
		.num_ranges = 1,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x80,
				.last = 0x82,
			},
		},
	},
	[0x9] = {
		.num_ranges = 0,
		.range = NULL,
	},
	[AB8500_GPADC] = {
		.num_ranges = 1,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x08,
			},
		},
	},
	[AB8500_CHARGER] = {
		.num_ranges = 8,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x03,
			},
			{
				.first = 0x05,
				.last = 0x05,
			},
			{
				.first = 0x40,
				.last = 0x40,
			},
			{
				.first = 0x42,
				.last = 0x42,
			},
			{
				.first = 0x44,
				.last = 0x44,
			},
			{
				.first = 0x50,
				.last = 0x55,
			},
			{
				.first = 0x80,
				.last = 0x82,
			},
			{
				.first = 0xC0,
				.last = 0xC2,
			},
		},
	},
	[AB8500_GAS_GAUGE] = {
		.num_ranges = 3,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x00,
			},
			{
				.first = 0x07,
				.last = 0x0A,
			},
			{
				.first = 0x10,
				.last = 0x14,
			},
		},
	},
	[AB8500_AUDIO] = {
		.num_ranges = 1,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x6F,
			},
		},
	},
	[AB8500_INTERRUPT] = {
		.num_ranges = 0,
		.range = NULL,
	},
	[AB8500_RTC] = {
		.num_ranges = 1,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x0F,
			},
		},
	},
	[AB8500_MISC] = {
		.num_ranges = 8,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x00,
				.last = 0x05,
			},
			{
				.first = 0x10,
				.last = 0x15,
			},
			{
				.first = 0x20,
				.last = 0x25,
			},
			{
				.first = 0x30,
				.last = 0x35,
			},
			{
				.first = 0x40,
				.last = 0x45,
			},
			{
				.first = 0x50,
				.last = 0x50,
			},
			{
				.first = 0x60,
				.last = 0x67,
			},
			{
				.first = 0x80,
				.last = 0x80,
			},
		},
	},
	[0x11] = {
		.num_ranges = 0,
		.range = NULL,
	},
	[0x12] = {
		.num_ranges = 0,
		.range = NULL,
	},
	[0x13] = {
		.num_ranges = 0,
		.range = NULL,
	},
	[0x14] = {
		.num_ranges = 0,
		.range = NULL,
	},
	[AB8500_OTP_EMUL] = {
		.num_ranges = 1,
		.range = (struct ab8500_reg_range[]) {
			{
				.first = 0x01,
				.last = 0x0F,
			},
		},
	},
};

static int ab8500_registers_print(struct seq_file *s, void *p)
{
	struct device *dev = s->private;
	unsigned int i;
	u32 bank = debug_bank;

	seq_printf(s, AB8500_NAME_STRING " register values:\n");

	seq_printf(s, " bank %u:\n", bank);
	for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
		u32 reg;

		for (reg = debug_ranges[bank].range[i].first;
			reg <= debug_ranges[bank].range[i].last;
			reg++) {
			u8 value;
			int err;

			err = abx500_get_register_interruptible(dev,
				(u8)bank, (u8)reg, &value);
			if (err < 0) {
				dev_err(dev, "ab->read fail %d\n", err);
				return err;
			}

			err = seq_printf(s, "  [%u/0x%02X]: 0x%02X\n", bank,
				reg, value);
			if (err < 0) {
				dev_err(dev, "seq_printf overflow\n");
				/* Error is not returned here since
				 * the output is wanted in any case */
				return 0;
			}
		}
	}
	return 0;
}

static int ab8500_registers_open(struct inode *inode, struct file *file)
{
	return single_open(file, ab8500_registers_print, inode->i_private);
}

static const struct file_operations ab8500_registers_fops = {
	.open = ab8500_registers_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

static int ab8500_bank_print(struct seq_file *s, void *p)
{
	return seq_printf(s, "%d\n", debug_bank);
}

static int ab8500_bank_open(struct inode *inode, struct file *file)
{
	return single_open(file, ab8500_bank_print, inode->i_private);
}

static ssize_t ab8500_bank_write(struct file *file,
	const char __user *user_buf,
	size_t count, loff_t *ppos)
{
	struct device *dev = ((struct seq_file *)(file->private_data))->private;
	unsigned long user_bank;
	int err;

	/* Get userspace string and assure termination */
	err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
	if (err)
		return err;

	if (user_bank >= AB8500_NUM_BANKS) {
		dev_err(dev, "debugfs error input > number of banks\n");
		return -EINVAL;
	}

	debug_bank = user_bank;

	return count;
}

static int ab8500_address_print(struct seq_file *s, void *p)
{
	return seq_printf(s, "0x%02X\n", debug_address);
}

static int ab8500_address_open(struct inode *inode, struct file *file)
{
	return single_open(file, ab8500_address_print, inode->i_private);
}

static ssize_t ab8500_address_write(struct file *file,
	const char __user *user_buf,
	size_t count, loff_t *ppos)
{
	struct device *dev = ((struct seq_file *)(file->private_data))->private;
	unsigned long user_address;
	int err;

	/* Get userspace string and assure termination */
	err = kstrtoul_from_user(user_buf, count, 0, &user_address);
	if (err)
		return err;

	if (user_address > 0xff) {
		dev_err(dev, "debugfs error input > 0xff\n");
		return -EINVAL;
	}
	debug_address = user_address;
	return count;
}

static int ab8500_val_print(struct seq_file *s, void *p)
{
	struct device *dev = s->private;
	int ret;
	u8 regvalue;

	ret = abx500_get_register_interruptible(dev,
		(u8)debug_bank, (u8)debug_address, &regvalue);
	if (ret < 0) {
		dev_err(dev, "abx500_get_reg fail %d, %d\n",
			ret, __LINE__);
		return -EINVAL;
	}
	seq_printf(s, "0x%02X\n", regvalue);

	return 0;
}

static int ab8500_val_open(struct inode *inode, struct file *file)
{
	return single_open(file, ab8500_val_print, inode->i_private);
}

static ssize_t ab8500_val_write(struct file *file,
	const char __user *user_buf,
	size_t count, loff_t *ppos)
{
	struct device *dev = ((struct seq_file *)(file->private_data))->private;
	unsigned long user_val;
	int err;

	/* Get userspace string and assure termination */
	err = kstrtoul_from_user(user_buf, count, 0, &user_val);
	if (err)
		return err;

	if (user_val > 0xff) {
		dev_err(dev, "debugfs error input > 0xff\n");
		return -EINVAL;
	}
	err = abx500_set_register_interruptible(dev,
		(u8)debug_bank, debug_address, (u8)user_val);
	if (err < 0) {
		printk(KERN_ERR "abx500_set_reg failed %d, %d", err, __LINE__);
		return -EINVAL;
	}

	return count;
}

static const struct file_operations ab8500_bank_fops = {
	.open = ab8500_bank_open,
	.write = ab8500_bank_write,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

static const struct file_operations ab8500_address_fops = {
	.open = ab8500_address_open,
	.write = ab8500_address_write,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

static const struct file_operations ab8500_val_fops = {
	.open = ab8500_val_open,
	.write = ab8500_val_write,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

static struct dentry *ab8500_dir;
static struct dentry *ab8500_reg_file;
static struct dentry *ab8500_bank_file;
static struct dentry *ab8500_address_file;
static struct dentry *ab8500_val_file;

static int __devinit ab8500_debug_probe(struct platform_device *plf)
{
	debug_bank = AB8500_MISC;
	debug_address = AB8500_REV_REG & 0x00FF;

	ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
	if (!ab8500_dir)
		goto exit_no_debugfs;

	ab8500_reg_file = debugfs_create_file("all-bank-registers",
		S_IRUGO, ab8500_dir, &plf->dev, &ab8500_registers_fops);
	if (!ab8500_reg_file)
		goto exit_destroy_dir;

	ab8500_bank_file = debugfs_create_file("register-bank",
		(S_IRUGO | S_IWUSR), ab8500_dir, &plf->dev, &ab8500_bank_fops);
	if (!ab8500_bank_file)
		goto exit_destroy_reg;

	ab8500_address_file = debugfs_create_file("register-address",
		(S_IRUGO | S_IWUSR), ab8500_dir, &plf->dev,
		&ab8500_address_fops);
	if (!ab8500_address_file)
		goto exit_destroy_bank;

	ab8500_val_file = debugfs_create_file("register-value",
		(S_IRUGO | S_IWUSR), ab8500_dir, &plf->dev, &ab8500_val_fops);
	if (!ab8500_val_file)
		goto exit_destroy_address;

	return 0;

exit_destroy_address:
	debugfs_remove(ab8500_address_file);
exit_destroy_bank:
	debugfs_remove(ab8500_bank_file);
exit_destroy_reg:
	debugfs_remove(ab8500_reg_file);
exit_destroy_dir:
	debugfs_remove(ab8500_dir);
exit_no_debugfs:
	dev_err(&plf->dev, "failed to create debugfs entries.\n");
	return -ENOMEM;
}

static int __devexit ab8500_debug_remove(struct platform_device *plf)
{
	debugfs_remove(ab8500_val_file);
	debugfs_remove(ab8500_address_file);
	debugfs_remove(ab8500_bank_file);
	debugfs_remove(ab8500_reg_file);
	debugfs_remove(ab8500_dir);

	return 0;
}

static struct platform_driver ab8500_debug_driver = {
	.driver = {
		.name = "ab8500-debug",
		.owner = THIS_MODULE,
	},
	.probe  = ab8500_debug_probe,
	.remove = __devexit_p(ab8500_debug_remove)
};

static int __init ab8500_debug_init(void)
{
	return platform_driver_register(&ab8500_debug_driver);
}

static void __exit ab8500_debug_exit(void)
{
	platform_driver_unregister(&ab8500_debug_driver);
}
subsys_initcall(ab8500_debug_init);
module_exit(ab8500_debug_exit);

MODULE_AUTHOR("Mattias WALLIN <[email protected]");
MODULE_DESCRIPTION("AB8500 DEBUG");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
5814fc35 MW	1	/*
	2	* Copyright (C) ST-Ericsson SA 2010
	3	*
	4	* Author: Mattias Wallin <[email protected]> for ST-Ericsson.
	5	* License Terms: GNU General Public License v2
	6	*/
	7
	8	#include <linux/seq_file.h>
	9	#include <linux/uaccess.h>
	10	#include <linux/fs.h>
	11	#include <linux/debugfs.h>
	12	#include <linux/platform_device.h>
	13
	14	#include <linux/mfd/abx500.h>
	15	#include <linux/mfd/ab8500.h>
	16
	17	static u32 debug_bank;
	18	static u32 debug_address;
	19
	20	/**
	21	* struct ab8500_reg_range
	22	* @first: the first address of the range
	23	* @last: the last address of the range
	24	* @perm: access permissions for the range
	25	*/
	26	struct ab8500_reg_range {
d7b9f322 MW	27	u8 first;
	28	u8 last;
	29	u8 perm;
5814fc35 MW	30	};
	31
	32	/**
	33	* struct ab8500_i2c_ranges
	34	* @num_ranges: the number of ranges in the list
	35	* @bankid: bank identifier
	36	* @range: the list of register ranges
	37	*/
	38	struct ab8500_i2c_ranges {
d7b9f322 MW	39	u8 num_ranges;
	40	u8 bankid;
	41	const struct ab8500_reg_range *range;
5814fc35 MW	42	};
	43
	44	#define AB8500_NAME_STRING "ab8500"
	45	#define AB8500_NUM_BANKS 22
	46
	47	#define AB8500_REV_REG 0x80
	48
	49	static struct ab8500_i2c_ranges debug_ranges[AB8500_NUM_BANKS] = {
d7b9f322 MW	50	[0x0] = {
	51	.num_ranges = 0,
	52	.range = 0,
	53	},
	54	[AB8500_SYS_CTRL1_BLOCK] = {
	55	.num_ranges = 3,
	56	.range = (struct ab8500_reg_range[]) {
	57	{
	58	.first = 0x00,
	59	.last = 0x02,
	60	},
	61	{
	62	.first = 0x42,
	63	.last = 0x42,
	64	},
	65	{
	66	.first = 0x80,
	67	.last = 0x81,
	68	},
	69	},
	70	},
	71	[AB8500_SYS_CTRL2_BLOCK] = {
	72	.num_ranges = 4,
	73	.range = (struct ab8500_reg_range[]) {
	74	{
	75	.first = 0x00,
	76	.last = 0x0D,
	77	},
	78	{
	79	.first = 0x0F,
	80	.last = 0x17,
	81	},
	82	{
	83	.first = 0x30,
	84	.last = 0x30,
	85	},
	86	{
	87	.first = 0x32,
	88	.last = 0x33,
	89	},
	90	},
	91	},
	92	[AB8500_REGU_CTRL1] = {
	93	.num_ranges = 3,
	94	.range = (struct ab8500_reg_range[]) {
	95	{
	96	.first = 0x00,
	97	.last = 0x00,
	98	},
	99	{
	100	.first = 0x03,
	101	.last = 0x10,
	102	},
	103	{
	104	.first = 0x80,
	105	.last = 0x84,
	106	},
	107	},
	108	},
	109	[AB8500_REGU_CTRL2] = {
	110	.num_ranges = 5,
	111	.range = (struct ab8500_reg_range[]) {
	112	{
	113	.first = 0x00,
114	.last = 0x15,
115	},
116	{
117	.first = 0x17,
118	.last = 0x19,
119	},
120	{
121	.first = 0x1B,
122	.last = 0x1D,
123	},
124	{
125	.first = 0x1F,
126	.last = 0x22,
127	},
128	{
129	.first = 0x40,
130	.last = 0x44,
131	},
132	/* 0x80-0x8B is SIM registers and should
133	* not be accessed from here */
134	},
135	},
136	[AB8500_USB] = {
137	.num_ranges = 2,
138	.range = (struct ab8500_reg_range[]) {
139	{
140	.first = 0x80,
141	.last = 0x83,
142	},
143	{
144	.first = 0x87,
145	.last = 0x8A,
146	},
147	},
148	},
149	[AB8500_TVOUT] = {
150	.num_ranges = 9,
151	.range = (struct ab8500_reg_range[]) {
152	{
153	.first = 0x00,
154	.last = 0x12,
155	},
156	{
157	.first = 0x15,
158	.last = 0x17,
159	},
160	{
161	.first = 0x19,
162	.last = 0x21,
163	},
164	{
165	.first = 0x27,
166	.last = 0x2C,
167	},
168	{
169	.first = 0x41,
170	.last = 0x41,
171	},
172	{
173	.first = 0x45,
174	.last = 0x5B,
175	},
176	{
177	.first = 0x5D,
178	.last = 0x5D,
179	},
180	{
181	.first = 0x69,
182	.last = 0x69,
183	},
184	{
185	.first = 0x80,
186	.last = 0x81,
187	},
188	},
189	},
190	[AB8500_DBI] = {
191	.num_ranges = 0,
87fff232	192	.range = NULL,
d7b9f322 MW	193	},
	194	[AB8500_ECI_AV_ACC] = {
	195	.num_ranges = 1,
	196	.range = (struct ab8500_reg_range[]) {
	197	{
	198	.first = 0x80,
	199	.last = 0x82,
	200	},
	201	},
	202	},
	203	[0x9] = {
	204	.num_ranges = 0,
87fff232	205	.range = NULL,
d7b9f322 MW	206	},
	207	[AB8500_GPADC] = {
	208	.num_ranges = 1,
	209	.range = (struct ab8500_reg_range[]) {
	210	{
	211	.first = 0x00,
	212	.last = 0x08,
	213	},
	214	},
	215	},
	216	[AB8500_CHARGER] = {
	217	.num_ranges = 8,
	218	.range = (struct ab8500_reg_range[]) {
	219	{
	220	.first = 0x00,
	221	.last = 0x03,
	222	},
	223	{
	224	.first = 0x05,
	225	.last = 0x05,
	226	},
	227	{
	228	.first = 0x40,
	229	.last = 0x40,
	230	},
	231	{
	232	.first = 0x42,
	233	.last = 0x42,
	234	},
	235	{
	236	.first = 0x44,
	237	.last = 0x44,
	238	},
	239	{
	240	.first = 0x50,
	241	.last = 0x55,
	242	},
	243	{
	244	.first = 0x80,
	245	.last = 0x82,
	246	},
	247	{
	248	.first = 0xC0,
	249	.last = 0xC2,
	250	},
	251	},
	252	},
	253	[AB8500_GAS_GAUGE] = {
	254	.num_ranges = 3,
	255	.range = (struct ab8500_reg_range[]) {
	256	{
	257	.first = 0x00,
	258	.last = 0x00,
	259	},
	260	{
	261	.first = 0x07,
	262	.last = 0x0A,
	263	},
	264	{
	265	.first = 0x10,
	266	.last = 0x14,
	267	},
	268	},
	269	},
270	[AB8500_AUDIO] = {
271	.num_ranges = 1,
272	.range = (struct ab8500_reg_range[]) {
273	{
274	.first = 0x00,
275	.last = 0x6F,
276	},
277	},
278	},
279	[AB8500_INTERRUPT] = {
280	.num_ranges = 0,
87fff232	281	.range = NULL,
d7b9f322 MW	282	},
	283	[AB8500_RTC] = {
	284	.num_ranges = 1,
	285	.range = (struct ab8500_reg_range[]) {
	286	{
	287	.first = 0x00,
	288	.last = 0x0F,
	289	},
	290	},
	291	},
	292	[AB8500_MISC] = {
	293	.num_ranges = 8,
	294	.range = (struct ab8500_reg_range[]) {
	295	{
	296	.first = 0x00,
	297	.last = 0x05,
	298	},
	299	{
	300	.first = 0x10,
	301	.last = 0x15,
	302	},
	303	{
	304	.first = 0x20,
	305	.last = 0x25,
	306	},
	307	{
	308	.first = 0x30,
	309	.last = 0x35,
	310	},
	311	{
	312	.first = 0x40,
	313	.last = 0x45,
	314	},
	315	{
	316	.first = 0x50,
	317	.last = 0x50,
	318	},
	319	{
	320	.first = 0x60,
	321	.last = 0x67,
	322	},
	323	{
	324	.first = 0x80,
	325	.last = 0x80,
	326	},
	327	},
	328	},
	329	[0x11] = {
	330	.num_ranges = 0,
87fff232	331	.range = NULL,
d7b9f322 MW	332	},
	333	[0x12] = {
	334	.num_ranges = 0,
87fff232	335	.range = NULL,
d7b9f322 MW	336	},
	337	[0x13] = {
	338	.num_ranges = 0,
87fff232	339	.range = NULL,
d7b9f322 MW	340	},
	341	[0x14] = {
	342	.num_ranges = 0,
87fff232	343	.range = NULL,
d7b9f322 MW	344	},
	345	[AB8500_OTP_EMUL] = {
	346	.num_ranges = 1,
	347	.range = (struct ab8500_reg_range[]) {
	348	{
	349	.first = 0x01,
	350	.last = 0x0F,
	351	},
	352	},
	353	},
5814fc35 MW	354	};
	355
	356	static int ab8500_registers_print(struct seq_file s, void p)
	357	{
d7b9f322 MW	358	struct device *dev = s->private;
	359	unsigned int i;
	360	u32 bank = debug_bank;
	361
	362	seq_printf(s, AB8500_NAME_STRING " register values:\n");
	363
	364	seq_printf(s, " bank %u:\n", bank);
	365	for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
	366	u32 reg;
	367
	368	for (reg = debug_ranges[bank].range[i].first;
	369	reg <= debug_ranges[bank].range[i].last;
	370	reg++) {
	371	u8 value;
	372	int err;
	373
	374	err = abx500_get_register_interruptible(dev,
	375	(u8)bank, (u8)reg, &value);
	376	if (err < 0) {
	377	dev_err(dev, "ab->read fail %d\n", err);
	378	return err;
	379	}
	380
	381	err = seq_printf(s, " [%u/0x%02X]: 0x%02X\n", bank,
	382	reg, value);
	383	if (err < 0) {
	384	dev_err(dev, "seq_printf overflow\n");
	385	/* Error is not returned here since
	386	* the output is wanted in any case */
	387	return 0;
	388	}
	389	}
	390	}
	391	return 0;
5814fc35 MW	392	}
	393
	394	static int ab8500_registers_open(struct inode inode, struct file file)
	395	{
d7b9f322	396	return single_open(file, ab8500_registers_print, inode->i_private);
5814fc35 MW	397	}
	398
	399	static const struct file_operations ab8500_registers_fops = {
d7b9f322 MW	400	.open = ab8500_registers_open,
	401	.read = seq_read,
	402	.llseek = seq_lseek,
	403	.release = single_release,
	404	.owner = THIS_MODULE,
5814fc35 MW	405	};
	406
	407	static int ab8500_bank_print(struct seq_file s, void p)
	408	{
d7b9f322	409	return seq_printf(s, "%d\n", debug_bank);
5814fc35 MW	410	}
	411
	412	static int ab8500_bank_open(struct inode inode, struct file file)
	413	{
d7b9f322	414	return single_open(file, ab8500_bank_print, inode->i_private);
5814fc35 MW	415	}
	416
	417	static ssize_t ab8500_bank_write(struct file *file,
d7b9f322 MW	418	const char __user *user_buf,
d7b9f322 MW	419	size_t count, loff_t *ppos)
5814fc35	420	{
d7b9f322	421	struct device dev = ((struct seq_file )(file->private_data))->private;
d7b9f322 MW	422	unsigned long user_bank;
	423	int err;
	424
	425	/* Get userspace string and assure termination */
8504d638	426	err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
d7b9f322	427	if (err)
8504d638	428	return err;
d7b9f322 MW	429
	430	if (user_bank >= AB8500_NUM_BANKS) {
	431	dev_err(dev, "debugfs error input > number of banks\n");
	432	return -EINVAL;
	433	}
	434
	435	debug_bank = user_bank;
	436
8504d638	437	return count;
5814fc35 MW	438	}
	439
	440	static int ab8500_address_print(struct seq_file s, void p)
	441	{
d7b9f322	442	return seq_printf(s, "0x%02X\n", debug_address);
5814fc35 MW	443	}
	444
	445	static int ab8500_address_open(struct inode inode, struct file file)
	446	{
d7b9f322	447	return single_open(file, ab8500_address_print, inode->i_private);
5814fc35 MW	448	}
	449
	450	static ssize_t ab8500_address_write(struct file *file,
d7b9f322 MW	451	const char __user *user_buf,
d7b9f322 MW	452	size_t count, loff_t *ppos)
5814fc35	453	{
d7b9f322	454	struct device dev = ((struct seq_file )(file->private_data))->private;
d7b9f322 MW	455	unsigned long user_address;
	456	int err;
	457
	458	/* Get userspace string and assure termination */
8504d638	459	err = kstrtoul_from_user(user_buf, count, 0, &user_address);
d7b9f322	460	if (err)
8504d638 PH	461	return err;
8504d638 PH	462
d7b9f322 MW	463	if (user_address > 0xff) {
	464	dev_err(dev, "debugfs error input > 0xff\n");
	465	return -EINVAL;
	466	}
	467	debug_address = user_address;
8504d638	468	return count;
5814fc35 MW	469	}
	470
	471	static int ab8500_val_print(struct seq_file s, void p)
	472	{
d7b9f322 MW	473	struct device *dev = s->private;
	474	int ret;
	475	u8 regvalue;
	476
	477	ret = abx500_get_register_interruptible(dev,
	478	(u8)debug_bank, (u8)debug_address, &regvalue);
	479	if (ret < 0) {
	480	dev_err(dev, "abx500_get_reg fail %d, %d\n",
	481	ret, __LINE__);
	482	return -EINVAL;
	483	}
	484	seq_printf(s, "0x%02X\n", regvalue);
	485
	486	return 0;
5814fc35 MW	487	}
	488
	489	static int ab8500_val_open(struct inode inode, struct file file)
	490	{
d7b9f322	491	return single_open(file, ab8500_val_print, inode->i_private);
5814fc35 MW	492	}
	493
	494	static ssize_t ab8500_val_write(struct file *file,
d7b9f322 MW	495	const char __user *user_buf,
d7b9f322 MW	496	size_t count, loff_t *ppos)
5814fc35	497	{
d7b9f322	498	struct device dev = ((struct seq_file )(file->private_data))->private;
d7b9f322 MW	499	unsigned long user_val;
	500	int err;
	501
	502	/* Get userspace string and assure termination */
8504d638	503	err = kstrtoul_from_user(user_buf, count, 0, &user_val);
d7b9f322	504	if (err)
8504d638 PH	505	return err;
8504d638 PH	506
d7b9f322 MW	507	if (user_val > 0xff) {
	508	dev_err(dev, "debugfs error input > 0xff\n");
	509	return -EINVAL;
	510	}
	511	err = abx500_set_register_interruptible(dev,
	512	(u8)debug_bank, debug_address, (u8)user_val);
	513	if (err < 0) {
	514	printk(KERN_ERR "abx500_set_reg failed %d, %d", err, __LINE__);
	515	return -EINVAL;
	516	}
	517
8504d638	518	return count;
5814fc35 MW	519	}
	520
	521	static const struct file_operations ab8500_bank_fops = {
d7b9f322 MW	522	.open = ab8500_bank_open,
	523	.write = ab8500_bank_write,
	524	.read = seq_read,
	525	.llseek = seq_lseek,
	526	.release = single_release,
	527	.owner = THIS_MODULE,
5814fc35 MW	528	};
	529
	530	static const struct file_operations ab8500_address_fops = {
d7b9f322 MW	531	.open = ab8500_address_open,
	532	.write = ab8500_address_write,
	533	.read = seq_read,
	534	.llseek = seq_lseek,
	535	.release = single_release,
	536	.owner = THIS_MODULE,
5814fc35 MW	537	};
	538
	539	static const struct file_operations ab8500_val_fops = {
d7b9f322 MW	540	.open = ab8500_val_open,
	541	.write = ab8500_val_write,
	542	.read = seq_read,
	543	.llseek = seq_lseek,
	544	.release = single_release,
	545	.owner = THIS_MODULE,
5814fc35 MW	546	};
	547
	548	static struct dentry *ab8500_dir;
	549	static struct dentry *ab8500_reg_file;
	550	static struct dentry *ab8500_bank_file;
	551	static struct dentry *ab8500_address_file;
	552	static struct dentry *ab8500_val_file;
	553
	554	static int __devinit ab8500_debug_probe(struct platform_device *plf)
	555	{
d7b9f322 MW	556	debug_bank = AB8500_MISC;
d7b9f322 MW	557	debug_address = AB8500_REV_REG & 0x00FF;
5814fc35	558
d7b9f322 MW	559	ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
	560	if (!ab8500_dir)
	561	goto exit_no_debugfs;
5814fc35	562
d7b9f322 MW	563	ab8500_reg_file = debugfs_create_file("all-bank-registers",
	564	S_IRUGO, ab8500_dir, &plf->dev, &ab8500_registers_fops);
	565	if (!ab8500_reg_file)
	566	goto exit_destroy_dir;
5814fc35	567
d7b9f322	568	ab8500_bank_file = debugfs_create_file("register-bank",
44bdcb54	569	(S_IRUGO \| S_IWUSR), ab8500_dir, &plf->dev, &ab8500_bank_fops);
d7b9f322 MW	570	if (!ab8500_bank_file)
d7b9f322 MW	571	goto exit_destroy_reg;
5814fc35	572
d7b9f322	573	ab8500_address_file = debugfs_create_file("register-address",
44bdcb54	574	(S_IRUGO \| S_IWUSR), ab8500_dir, &plf->dev,
d7b9f322 MW	575	&ab8500_address_fops);
	576	if (!ab8500_address_file)
	577	goto exit_destroy_bank;
5814fc35	578
d7b9f322	579	ab8500_val_file = debugfs_create_file("register-value",
44bdcb54	580	(S_IRUGO \| S_IWUSR), ab8500_dir, &plf->dev, &ab8500_val_fops);
d7b9f322 MW	581	if (!ab8500_val_file)
d7b9f322 MW	582	goto exit_destroy_address;
5814fc35	583
d7b9f322	584	return 0;
5814fc35 MW	585
5814fc35 MW	586	exit_destroy_address:
d7b9f322	587	debugfs_remove(ab8500_address_file);
5814fc35	588	exit_destroy_bank:
d7b9f322	589	debugfs_remove(ab8500_bank_file);
5814fc35	590	exit_destroy_reg:
d7b9f322	591	debugfs_remove(ab8500_reg_file);
5814fc35	592	exit_destroy_dir:
d7b9f322	593	debugfs_remove(ab8500_dir);
5814fc35	594	exit_no_debugfs:
d7b9f322 MW	595	dev_err(&plf->dev, "failed to create debugfs entries.\n");
d7b9f322 MW	596	return -ENOMEM;
5814fc35 MW	597	}
	598
	599	static int __devexit ab8500_debug_remove(struct platform_device *plf)
	600	{
d7b9f322 MW	601	debugfs_remove(ab8500_val_file);
	602	debugfs_remove(ab8500_address_file);
	603	debugfs_remove(ab8500_bank_file);
	604	debugfs_remove(ab8500_reg_file);
	605	debugfs_remove(ab8500_dir);
5814fc35	606
d7b9f322	607	return 0;
5814fc35 MW	608	}
	609
	610	static struct platform_driver ab8500_debug_driver = {
d7b9f322 MW	611	.driver = {
	612	.name = "ab8500-debug",
	613	.owner = THIS_MODULE,
	614	},
	615	.probe = ab8500_debug_probe,
	616	.remove = __devexit_p(ab8500_debug_remove)
5814fc35 MW	617	};
	618
	619	static int __init ab8500_debug_init(void)
	620	{
d7b9f322	621	return platform_driver_register(&ab8500_debug_driver);
5814fc35 MW	622	}
	623
	624	static void __exit ab8500_debug_exit(void)
	625	{
d7b9f322	626	platform_driver_unregister(&ab8500_debug_driver);
5814fc35 MW	627	}
	628	subsys_initcall(ab8500_debug_init);
	629	module_exit(ab8500_debug_exit);
	630
	631	MODULE_AUTHOR("Mattias WALLIN <[email protected]");
	632	MODULE_DESCRIPTION("AB8500 DEBUG");
	633	MODULE_LICENSE("GPL v2");