1 /*
2  * Register map access API - debugfs
3  *
4  * Copyright 2011 Wolfson Microelectronics plc
5  *
6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.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 
13 #include <linux/slab.h>
14 #include <linux/mutex.h>
15 #include <linux/debugfs.h>
16 #include <linux/uaccess.h>
17 #include <linux/device.h>
18 
19 #include "internal.h"
20 
21 static struct dentry *regmap_debugfs_root;
22 
23 /* Calculate the length of a fixed format  */
24 static size_t regmap_calc_reg_len(int max_val, char *buf, size_t buf_size)
25 {
26 	snprintf(buf, buf_size, "%x", max_val);
27 	return strlen(buf);
28 }
29 
30 static ssize_t regmap_name_read_file(struct file *file,
31 				     char __user *user_buf, size_t count,
32 				     loff_t *ppos)
33 {
34 	struct regmap *map = file->private_data;
35 	int ret;
36 	char *buf;
37 
38 	buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
39 	if (!buf)
40 		return -ENOMEM;
41 
42 	ret = snprintf(buf, PAGE_SIZE, "%s\n", map->dev->driver->name);
43 	if (ret < 0) {
44 		kfree(buf);
45 		return ret;
46 	}
47 
48 	ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
49 	kfree(buf);
50 	return ret;
51 }
52 
53 static const struct file_operations regmap_name_fops = {
54 	.open = simple_open,
55 	.read = regmap_name_read_file,
56 	.llseek = default_llseek,
57 };
58 
59 static void regmap_debugfs_free_dump_cache(struct regmap *map)
60 {
61 	struct regmap_debugfs_off_cache *c;
62 
63 	while (!list_empty(&map->debugfs_off_cache)) {
64 		c = list_first_entry(&map->debugfs_off_cache,
65 				     struct regmap_debugfs_off_cache,
66 				     list);
67 		list_del(&c->list);
68 		kfree(c);
69 	}
70 }
71 
72 /*
73  * Work out where the start offset maps into register numbers, bearing
74  * in mind that we suppress hidden registers.
75  */
76 static unsigned int regmap_debugfs_get_dump_start(struct regmap *map,
77 						  unsigned int base,
78 						  loff_t from,
79 						  loff_t *pos)
80 {
81 	struct regmap_debugfs_off_cache *c = NULL;
82 	loff_t p = 0;
83 	unsigned int i, ret;
84 	unsigned int fpos_offset;
85 	unsigned int reg_offset;
86 
87 	/*
88 	 * If we don't have a cache build one so we don't have to do a
89 	 * linear scan each time.
90 	 */
91 	mutex_lock(&map->cache_lock);
92 	i = base;
93 	if (list_empty(&map->debugfs_off_cache)) {
94 		for (; i <= map->max_register; i += map->reg_stride) {
95 			/* Skip unprinted registers, closing off cache entry */
96 			if (!regmap_readable(map, i) ||
97 			    regmap_precious(map, i)) {
98 				if (c) {
99 					c->max = p - 1;
100 					c->max_reg = i - map->reg_stride;
101 					list_add_tail(&c->list,
102 						      &map->debugfs_off_cache);
103 					c = NULL;
104 				}
105 
106 				continue;
107 			}
108 
109 			/* No cache entry?  Start a new one */
110 			if (!c) {
111 				c = kzalloc(sizeof(*c), GFP_KERNEL);
112 				if (!c) {
113 					regmap_debugfs_free_dump_cache(map);
114 					mutex_unlock(&map->cache_lock);
115 					return base;
116 				}
117 				c->min = p;
118 				c->base_reg = i;
119 			}
120 
121 			p += map->debugfs_tot_len;
122 		}
123 	}
124 
125 	/* Close the last entry off if we didn't scan beyond it */
126 	if (c) {
127 		c->max = p - 1;
128 		c->max_reg = i - map->reg_stride;
129 		list_add_tail(&c->list,
130 			      &map->debugfs_off_cache);
131 	}
132 
133 	/*
134 	 * This should never happen; we return above if we fail to
135 	 * allocate and we should never be in this code if there are
136 	 * no registers at all.
137 	 */
138 	WARN_ON(list_empty(&map->debugfs_off_cache));
139 	ret = base;
140 
141 	/* Find the relevant block:offset */
142 	list_for_each_entry(c, &map->debugfs_off_cache, list) {
143 		if (from >= c->min && from <= c->max) {
144 			fpos_offset = from - c->min;
145 			reg_offset = fpos_offset / map->debugfs_tot_len;
146 			*pos = c->min + (reg_offset * map->debugfs_tot_len);
147 			mutex_unlock(&map->cache_lock);
148 			return c->base_reg + reg_offset;
149 		}
150 
151 		*pos = c->max;
152 		ret = c->max_reg;
153 	}
154 	mutex_unlock(&map->cache_lock);
155 
156 	return ret;
157 }
158 
159 static inline void regmap_calc_tot_len(struct regmap *map,
160 				       void *buf, size_t count)
161 {
162 	/* Calculate the length of a fixed format  */
163 	if (!map->debugfs_tot_len) {
164 		map->debugfs_reg_len = regmap_calc_reg_len(map->max_register,
165 							   buf, count);
166 		map->debugfs_val_len = 2 * map->format.val_bytes;
167 		map->debugfs_tot_len = map->debugfs_reg_len +
168 			map->debugfs_val_len + 3;      /* : \n */
169 	}
170 }
171 
172 static ssize_t regmap_read_debugfs(struct regmap *map, unsigned int from,
173 				   unsigned int to, char __user *user_buf,
174 				   size_t count, loff_t *ppos)
175 {
176 	size_t buf_pos = 0;
177 	loff_t p = *ppos;
178 	ssize_t ret;
179 	int i;
180 	char *buf;
181 	unsigned int val, start_reg;
182 
183 	if (*ppos < 0 || !count)
184 		return -EINVAL;
185 
186 	buf = kmalloc(count, GFP_KERNEL);
187 	if (!buf)
188 		return -ENOMEM;
189 
190 	regmap_calc_tot_len(map, buf, count);
191 
192 	/* Work out which register we're starting at */
193 	start_reg = regmap_debugfs_get_dump_start(map, from, *ppos, &p);
194 
195 	for (i = start_reg; i <= to; i += map->reg_stride) {
196 		if (!regmap_readable(map, i))
197 			continue;
198 
199 		if (regmap_precious(map, i))
200 			continue;
201 
202 		/* If we're in the region the user is trying to read */
203 		if (p >= *ppos) {
204 			/* ...but not beyond it */
205 			if (buf_pos + map->debugfs_tot_len > count)
206 				break;
207 
208 			/* Format the register */
209 			snprintf(buf + buf_pos, count - buf_pos, "%.*x: ",
210 				 map->debugfs_reg_len, i - from);
211 			buf_pos += map->debugfs_reg_len + 2;
212 
213 			/* Format the value, write all X if we can't read */
214 			ret = regmap_read(map, i, &val);
215 			if (ret == 0)
216 				snprintf(buf + buf_pos, count - buf_pos,
217 					 "%.*x", map->debugfs_val_len, val);
218 			else
219 				memset(buf + buf_pos, 'X',
220 				       map->debugfs_val_len);
221 			buf_pos += 2 * map->format.val_bytes;
222 
223 			buf[buf_pos++] = '\n';
224 		}
225 		p += map->debugfs_tot_len;
226 	}
227 
228 	ret = buf_pos;
229 
230 	if (copy_to_user(user_buf, buf, buf_pos)) {
231 		ret = -EFAULT;
232 		goto out;
233 	}
234 
235 	*ppos += buf_pos;
236 
237 out:
238 	kfree(buf);
239 	return ret;
240 }
241 
242 static ssize_t regmap_map_read_file(struct file *file, char __user *user_buf,
243 				    size_t count, loff_t *ppos)
244 {
245 	struct regmap *map = file->private_data;
246 
247 	return regmap_read_debugfs(map, 0, map->max_register, user_buf,
248 				   count, ppos);
249 }
250 
251 #undef REGMAP_ALLOW_WRITE_DEBUGFS
252 #ifdef REGMAP_ALLOW_WRITE_DEBUGFS
253 /*
254  * This can be dangerous especially when we have clients such as
255  * PMICs, therefore don't provide any real compile time configuration option
256  * for this feature, people who want to use this will need to modify
257  * the source code directly.
258  */
259 static ssize_t regmap_map_write_file(struct file *file,
260 				     const char __user *user_buf,
261 				     size_t count, loff_t *ppos)
262 {
263 	char buf[32];
264 	size_t buf_size;
265 	char *start = buf;
266 	unsigned long reg, value;
267 	struct regmap *map = file->private_data;
268 
269 	buf_size = min(count, (sizeof(buf)-1));
270 	if (copy_from_user(buf, user_buf, buf_size))
271 		return -EFAULT;
272 	buf[buf_size] = 0;
273 
274 	while (*start == ' ')
275 		start++;
276 	reg = simple_strtoul(start, &start, 16);
277 	while (*start == ' ')
278 		start++;
279 	if (strict_strtoul(start, 16, &value))
280 		return -EINVAL;
281 
282 	/* Userspace has been fiddling around behind the kernel's back */
283 	add_taint(TAINT_USER, LOCKDEP_NOW_UNRELIABLE);
284 
285 	regmap_write(map, reg, value);
286 	return buf_size;
287 }
288 #else
289 #define regmap_map_write_file NULL
290 #endif
291 
292 static const struct file_operations regmap_map_fops = {
293 	.open = simple_open,
294 	.read = regmap_map_read_file,
295 	.write = regmap_map_write_file,
296 	.llseek = default_llseek,
297 };
298 
299 static ssize_t regmap_range_read_file(struct file *file, char __user *user_buf,
300 				      size_t count, loff_t *ppos)
301 {
302 	struct regmap_range_node *range = file->private_data;
303 	struct regmap *map = range->map;
304 
305 	return regmap_read_debugfs(map, range->range_min, range->range_max,
306 				   user_buf, count, ppos);
307 }
308 
309 static const struct file_operations regmap_range_fops = {
310 	.open = simple_open,
311 	.read = regmap_range_read_file,
312 	.llseek = default_llseek,
313 };
314 
315 static ssize_t regmap_reg_ranges_read_file(struct file *file,
316 					   char __user *user_buf, size_t count,
317 					   loff_t *ppos)
318 {
319 	struct regmap *map = file->private_data;
320 	struct regmap_debugfs_off_cache *c;
321 	loff_t p = 0;
322 	size_t buf_pos = 0;
323 	char *buf;
324 	char *entry;
325 	int ret;
326 
327 	if (*ppos < 0 || !count)
328 		return -EINVAL;
329 
330 	buf = kmalloc(count, GFP_KERNEL);
331 	if (!buf)
332 		return -ENOMEM;
333 
334 	entry = kmalloc(PAGE_SIZE, GFP_KERNEL);
335 	if (!entry) {
336 		kfree(buf);
337 		return -ENOMEM;
338 	}
339 
340 	/* While we are at it, build the register dump cache
341 	 * now so the read() operation on the `registers' file
342 	 * can benefit from using the cache.  We do not care
343 	 * about the file position information that is contained
344 	 * in the cache, just about the actual register blocks */
345 	regmap_calc_tot_len(map, buf, count);
346 	regmap_debugfs_get_dump_start(map, 0, *ppos, &p);
347 
348 	/* Reset file pointer as the fixed-format of the `registers'
349 	 * file is not compatible with the `range' file */
350 	p = 0;
351 	mutex_lock(&map->cache_lock);
352 	list_for_each_entry(c, &map->debugfs_off_cache, list) {
353 		snprintf(entry, PAGE_SIZE, "%x-%x",
354 			 c->base_reg, c->max_reg);
355 		if (p >= *ppos) {
356 			if (buf_pos + 1 + strlen(entry) > count)
357 				break;
358 			snprintf(buf + buf_pos, count - buf_pos,
359 				 "%s", entry);
360 			buf_pos += strlen(entry);
361 			buf[buf_pos] = '\n';
362 			buf_pos++;
363 		}
364 		p += strlen(entry) + 1;
365 	}
366 	mutex_unlock(&map->cache_lock);
367 
368 	kfree(entry);
369 	ret = buf_pos;
370 
371 	if (copy_to_user(user_buf, buf, buf_pos)) {
372 		ret = -EFAULT;
373 		goto out_buf;
374 	}
375 
376 	*ppos += buf_pos;
377 out_buf:
378 	kfree(buf);
379 	return ret;
380 }
381 
382 static const struct file_operations regmap_reg_ranges_fops = {
383 	.open = simple_open,
384 	.read = regmap_reg_ranges_read_file,
385 	.llseek = default_llseek,
386 };
387 
388 static ssize_t regmap_access_read_file(struct file *file,
389 				       char __user *user_buf, size_t count,
390 				       loff_t *ppos)
391 {
392 	int reg_len, tot_len;
393 	size_t buf_pos = 0;
394 	loff_t p = 0;
395 	ssize_t ret;
396 	int i;
397 	struct regmap *map = file->private_data;
398 	char *buf;
399 
400 	if (*ppos < 0 || !count)
401 		return -EINVAL;
402 
403 	buf = kmalloc(count, GFP_KERNEL);
404 	if (!buf)
405 		return -ENOMEM;
406 
407 	/* Calculate the length of a fixed format  */
408 	reg_len = regmap_calc_reg_len(map->max_register, buf, count);
409 	tot_len = reg_len + 10; /* ': R W V P\n' */
410 
411 	for (i = 0; i <= map->max_register; i += map->reg_stride) {
412 		/* Ignore registers which are neither readable nor writable */
413 		if (!regmap_readable(map, i) && !regmap_writeable(map, i))
414 			continue;
415 
416 		/* If we're in the region the user is trying to read */
417 		if (p >= *ppos) {
418 			/* ...but not beyond it */
419 			if (buf_pos >= count - 1 - tot_len)
420 				break;
421 
422 			/* Format the register */
423 			snprintf(buf + buf_pos, count - buf_pos,
424 				 "%.*x: %c %c %c %c\n",
425 				 reg_len, i,
426 				 regmap_readable(map, i) ? 'y' : 'n',
427 				 regmap_writeable(map, i) ? 'y' : 'n',
428 				 regmap_volatile(map, i) ? 'y' : 'n',
429 				 regmap_precious(map, i) ? 'y' : 'n');
430 
431 			buf_pos += tot_len;
432 		}
433 		p += tot_len;
434 	}
435 
436 	ret = buf_pos;
437 
438 	if (copy_to_user(user_buf, buf, buf_pos)) {
439 		ret = -EFAULT;
440 		goto out;
441 	}
442 
443 	*ppos += buf_pos;
444 
445 out:
446 	kfree(buf);
447 	return ret;
448 }
449 
450 static const struct file_operations regmap_access_fops = {
451 	.open = simple_open,
452 	.read = regmap_access_read_file,
453 	.llseek = default_llseek,
454 };
455 
456 void regmap_debugfs_init(struct regmap *map, const char *name)
457 {
458 	struct rb_node *next;
459 	struct regmap_range_node *range_node;
460 
461 	INIT_LIST_HEAD(&map->debugfs_off_cache);
462 	mutex_init(&map->cache_lock);
463 
464 	if (name) {
465 		map->debugfs_name = kasprintf(GFP_KERNEL, "%s-%s",
466 					      dev_name(map->dev), name);
467 		name = map->debugfs_name;
468 	} else {
469 		name = dev_name(map->dev);
470 	}
471 
472 	map->debugfs = debugfs_create_dir(name, regmap_debugfs_root);
473 	if (!map->debugfs) {
474 		dev_warn(map->dev, "Failed to create debugfs directory\n");
475 		return;
476 	}
477 
478 	debugfs_create_file("name", 0400, map->debugfs,
479 			    map, &regmap_name_fops);
480 
481 	debugfs_create_file("range", 0400, map->debugfs,
482 			    map, &regmap_reg_ranges_fops);
483 
484 	if (map->max_register) {
485 		debugfs_create_file("registers", 0400, map->debugfs,
486 				    map, &regmap_map_fops);
487 		debugfs_create_file("access", 0400, map->debugfs,
488 				    map, &regmap_access_fops);
489 	}
490 
491 	if (map->cache_type) {
492 		debugfs_create_bool("cache_only", 0400, map->debugfs,
493 				    &map->cache_only);
494 		debugfs_create_bool("cache_dirty", 0400, map->debugfs,
495 				    &map->cache_dirty);
496 		debugfs_create_bool("cache_bypass", 0400, map->debugfs,
497 				    &map->cache_bypass);
498 	}
499 
500 	next = rb_first(&map->range_tree);
501 	while (next) {
502 		range_node = rb_entry(next, struct regmap_range_node, node);
503 
504 		if (range_node->name)
505 			debugfs_create_file(range_node->name, 0400,
506 					    map->debugfs, range_node,
507 					    &regmap_range_fops);
508 
509 		next = rb_next(&range_node->node);
510 	}
511 }
512 
513 void regmap_debugfs_exit(struct regmap *map)
514 {
515 	debugfs_remove_recursive(map->debugfs);
516 	mutex_lock(&map->cache_lock);
517 	regmap_debugfs_free_dump_cache(map);
518 	mutex_unlock(&map->cache_lock);
519 	kfree(map->debugfs_name);
520 }
521 
522 void regmap_debugfs_initcall(void)
523 {
524 	regmap_debugfs_root = debugfs_create_dir("regmap", NULL);
525 	if (!regmap_debugfs_root) {
526 		pr_warn("regmap: Failed to create debugfs root\n");
527 		return;
528 	}
529 }
530