[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/module.h>
#include <linux/debugfs.h>
#include <linux/platform_device.h>

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