Loading...
1/*
2 * file.c - part of debugfs, a tiny little debug file system
3 *
4 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
5 * Copyright (C) 2004 IBM Inc.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License version
9 * 2 as published by the Free Software Foundation.
10 *
11 * debugfs is for people to use instead of /proc or /sys.
12 * See Documentation/DocBook/filesystems for more details.
13 *
14 */
15
16#include <linux/module.h>
17#include <linux/fs.h>
18#include <linux/seq_file.h>
19#include <linux/pagemap.h>
20#include <linux/debugfs.h>
21#include <linux/io.h>
22#include <linux/slab.h>
23#include <linux/atomic.h>
24#include <linux/device.h>
25
26static ssize_t default_read_file(struct file *file, char __user *buf,
27 size_t count, loff_t *ppos)
28{
29 return 0;
30}
31
32static ssize_t default_write_file(struct file *file, const char __user *buf,
33 size_t count, loff_t *ppos)
34{
35 return count;
36}
37
38const struct file_operations debugfs_file_operations = {
39 .read = default_read_file,
40 .write = default_write_file,
41 .open = simple_open,
42 .llseek = noop_llseek,
43};
44
45static struct dentry *debugfs_create_mode(const char *name, umode_t mode,
46 struct dentry *parent, void *value,
47 const struct file_operations *fops,
48 const struct file_operations *fops_ro,
49 const struct file_operations *fops_wo)
50{
51 /* if there are no write bits set, make read only */
52 if (!(mode & S_IWUGO))
53 return debugfs_create_file(name, mode, parent, value, fops_ro);
54 /* if there are no read bits set, make write only */
55 if (!(mode & S_IRUGO))
56 return debugfs_create_file(name, mode, parent, value, fops_wo);
57
58 return debugfs_create_file(name, mode, parent, value, fops);
59}
60
61static int debugfs_u8_set(void *data, u64 val)
62{
63 *(u8 *)data = val;
64 return 0;
65}
66static int debugfs_u8_get(void *data, u64 *val)
67{
68 *val = *(u8 *)data;
69 return 0;
70}
71DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
72DEFINE_SIMPLE_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
73DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
74
75/**
76 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
77 * @name: a pointer to a string containing the name of the file to create.
78 * @mode: the permission that the file should have
79 * @parent: a pointer to the parent dentry for this file. This should be a
80 * directory dentry if set. If this parameter is %NULL, then the
81 * file will be created in the root of the debugfs filesystem.
82 * @value: a pointer to the variable that the file should read to and write
83 * from.
84 *
85 * This function creates a file in debugfs with the given name that
86 * contains the value of the variable @value. If the @mode variable is so
87 * set, it can be read from, and written to.
88 *
89 * This function will return a pointer to a dentry if it succeeds. This
90 * pointer must be passed to the debugfs_remove() function when the file is
91 * to be removed (no automatic cleanup happens if your module is unloaded,
92 * you are responsible here.) If an error occurs, %NULL will be returned.
93 *
94 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
95 * returned. It is not wise to check for this value, but rather, check for
96 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
97 * code.
98 */
99struct dentry *debugfs_create_u8(const char *name, umode_t mode,
100 struct dentry *parent, u8 *value)
101{
102 return debugfs_create_mode(name, mode, parent, value, &fops_u8,
103 &fops_u8_ro, &fops_u8_wo);
104}
105EXPORT_SYMBOL_GPL(debugfs_create_u8);
106
107static int debugfs_u16_set(void *data, u64 val)
108{
109 *(u16 *)data = val;
110 return 0;
111}
112static int debugfs_u16_get(void *data, u64 *val)
113{
114 *val = *(u16 *)data;
115 return 0;
116}
117DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
118DEFINE_SIMPLE_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
119DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
120
121/**
122 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
123 * @name: a pointer to a string containing the name of the file to create.
124 * @mode: the permission that the file should have
125 * @parent: a pointer to the parent dentry for this file. This should be a
126 * directory dentry if set. If this parameter is %NULL, then the
127 * file will be created in the root of the debugfs filesystem.
128 * @value: a pointer to the variable that the file should read to and write
129 * from.
130 *
131 * This function creates a file in debugfs with the given name that
132 * contains the value of the variable @value. If the @mode variable is so
133 * set, it can be read from, and written to.
134 *
135 * This function will return a pointer to a dentry if it succeeds. This
136 * pointer must be passed to the debugfs_remove() function when the file is
137 * to be removed (no automatic cleanup happens if your module is unloaded,
138 * you are responsible here.) If an error occurs, %NULL will be returned.
139 *
140 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
141 * returned. It is not wise to check for this value, but rather, check for
142 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
143 * code.
144 */
145struct dentry *debugfs_create_u16(const char *name, umode_t mode,
146 struct dentry *parent, u16 *value)
147{
148 return debugfs_create_mode(name, mode, parent, value, &fops_u16,
149 &fops_u16_ro, &fops_u16_wo);
150}
151EXPORT_SYMBOL_GPL(debugfs_create_u16);
152
153static int debugfs_u32_set(void *data, u64 val)
154{
155 *(u32 *)data = val;
156 return 0;
157}
158static int debugfs_u32_get(void *data, u64 *val)
159{
160 *val = *(u32 *)data;
161 return 0;
162}
163DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
164DEFINE_SIMPLE_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
165DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
166
167/**
168 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
169 * @name: a pointer to a string containing the name of the file to create.
170 * @mode: the permission that the file should have
171 * @parent: a pointer to the parent dentry for this file. This should be a
172 * directory dentry if set. If this parameter is %NULL, then the
173 * file will be created in the root of the debugfs filesystem.
174 * @value: a pointer to the variable that the file should read to and write
175 * from.
176 *
177 * This function creates a file in debugfs with the given name that
178 * contains the value of the variable @value. If the @mode variable is so
179 * set, it can be read from, and written to.
180 *
181 * This function will return a pointer to a dentry if it succeeds. This
182 * pointer must be passed to the debugfs_remove() function when the file is
183 * to be removed (no automatic cleanup happens if your module is unloaded,
184 * you are responsible here.) If an error occurs, %NULL will be returned.
185 *
186 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
187 * returned. It is not wise to check for this value, but rather, check for
188 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
189 * code.
190 */
191struct dentry *debugfs_create_u32(const char *name, umode_t mode,
192 struct dentry *parent, u32 *value)
193{
194 return debugfs_create_mode(name, mode, parent, value, &fops_u32,
195 &fops_u32_ro, &fops_u32_wo);
196}
197EXPORT_SYMBOL_GPL(debugfs_create_u32);
198
199static int debugfs_u64_set(void *data, u64 val)
200{
201 *(u64 *)data = val;
202 return 0;
203}
204
205static int debugfs_u64_get(void *data, u64 *val)
206{
207 *val = *(u64 *)data;
208 return 0;
209}
210DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
211DEFINE_SIMPLE_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
212DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
213
214/**
215 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
216 * @name: a pointer to a string containing the name of the file to create.
217 * @mode: the permission that the file should have
218 * @parent: a pointer to the parent dentry for this file. This should be a
219 * directory dentry if set. If this parameter is %NULL, then the
220 * file will be created in the root of the debugfs filesystem.
221 * @value: a pointer to the variable that the file should read to and write
222 * from.
223 *
224 * This function creates a file in debugfs with the given name that
225 * contains the value of the variable @value. If the @mode variable is so
226 * set, it can be read from, and written to.
227 *
228 * This function will return a pointer to a dentry if it succeeds. This
229 * pointer must be passed to the debugfs_remove() function when the file is
230 * to be removed (no automatic cleanup happens if your module is unloaded,
231 * you are responsible here.) If an error occurs, %NULL will be returned.
232 *
233 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
234 * returned. It is not wise to check for this value, but rather, check for
235 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
236 * code.
237 */
238struct dentry *debugfs_create_u64(const char *name, umode_t mode,
239 struct dentry *parent, u64 *value)
240{
241 return debugfs_create_mode(name, mode, parent, value, &fops_u64,
242 &fops_u64_ro, &fops_u64_wo);
243}
244EXPORT_SYMBOL_GPL(debugfs_create_u64);
245
246static int debugfs_ulong_set(void *data, u64 val)
247{
248 *(unsigned long *)data = val;
249 return 0;
250}
251
252static int debugfs_ulong_get(void *data, u64 *val)
253{
254 *val = *(unsigned long *)data;
255 return 0;
256}
257DEFINE_SIMPLE_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set, "%llu\n");
258DEFINE_SIMPLE_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
259DEFINE_SIMPLE_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
260
261/**
262 * debugfs_create_ulong - create a debugfs file that is used to read and write
263 * an unsigned long value.
264 * @name: a pointer to a string containing the name of the file to create.
265 * @mode: the permission that the file should have
266 * @parent: a pointer to the parent dentry for this file. This should be a
267 * directory dentry if set. If this parameter is %NULL, then the
268 * file will be created in the root of the debugfs filesystem.
269 * @value: a pointer to the variable that the file should read to and write
270 * from.
271 *
272 * This function creates a file in debugfs with the given name that
273 * contains the value of the variable @value. If the @mode variable is so
274 * set, it can be read from, and written to.
275 *
276 * This function will return a pointer to a dentry if it succeeds. This
277 * pointer must be passed to the debugfs_remove() function when the file is
278 * to be removed (no automatic cleanup happens if your module is unloaded,
279 * you are responsible here.) If an error occurs, %NULL will be returned.
280 *
281 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
282 * returned. It is not wise to check for this value, but rather, check for
283 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
284 * code.
285 */
286struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
287 struct dentry *parent, unsigned long *value)
288{
289 return debugfs_create_mode(name, mode, parent, value, &fops_ulong,
290 &fops_ulong_ro, &fops_ulong_wo);
291}
292EXPORT_SYMBOL_GPL(debugfs_create_ulong);
293
294DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
295DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
296DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
297
298DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n");
299DEFINE_SIMPLE_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
300DEFINE_SIMPLE_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
301
302DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n");
303DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
304DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
305
306DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n");
307DEFINE_SIMPLE_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
308DEFINE_SIMPLE_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
309
310/*
311 * debugfs_create_x{8,16,32,64} - create a debugfs file that is used to read and write an unsigned {8,16,32,64}-bit value
312 *
313 * These functions are exactly the same as the above functions (but use a hex
314 * output for the decimal challenged). For details look at the above unsigned
315 * decimal functions.
316 */
317
318/**
319 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
320 * @name: a pointer to a string containing the name of the file to create.
321 * @mode: the permission that the file should have
322 * @parent: a pointer to the parent dentry for this file. This should be a
323 * directory dentry if set. If this parameter is %NULL, then the
324 * file will be created in the root of the debugfs filesystem.
325 * @value: a pointer to the variable that the file should read to and write
326 * from.
327 */
328struct dentry *debugfs_create_x8(const char *name, umode_t mode,
329 struct dentry *parent, u8 *value)
330{
331 return debugfs_create_mode(name, mode, parent, value, &fops_x8,
332 &fops_x8_ro, &fops_x8_wo);
333}
334EXPORT_SYMBOL_GPL(debugfs_create_x8);
335
336/**
337 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
338 * @name: a pointer to a string containing the name of the file to create.
339 * @mode: the permission that the file should have
340 * @parent: a pointer to the parent dentry for this file. This should be a
341 * directory dentry if set. If this parameter is %NULL, then the
342 * file will be created in the root of the debugfs filesystem.
343 * @value: a pointer to the variable that the file should read to and write
344 * from.
345 */
346struct dentry *debugfs_create_x16(const char *name, umode_t mode,
347 struct dentry *parent, u16 *value)
348{
349 return debugfs_create_mode(name, mode, parent, value, &fops_x16,
350 &fops_x16_ro, &fops_x16_wo);
351}
352EXPORT_SYMBOL_GPL(debugfs_create_x16);
353
354/**
355 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
356 * @name: a pointer to a string containing the name of the file to create.
357 * @mode: the permission that the file should have
358 * @parent: a pointer to the parent dentry for this file. This should be a
359 * directory dentry if set. If this parameter is %NULL, then the
360 * file will be created in the root of the debugfs filesystem.
361 * @value: a pointer to the variable that the file should read to and write
362 * from.
363 */
364struct dentry *debugfs_create_x32(const char *name, umode_t mode,
365 struct dentry *parent, u32 *value)
366{
367 return debugfs_create_mode(name, mode, parent, value, &fops_x32,
368 &fops_x32_ro, &fops_x32_wo);
369}
370EXPORT_SYMBOL_GPL(debugfs_create_x32);
371
372/**
373 * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
374 * @name: a pointer to a string containing the name of the file to create.
375 * @mode: the permission that the file should have
376 * @parent: a pointer to the parent dentry for this file. This should be a
377 * directory dentry if set. If this parameter is %NULL, then the
378 * file will be created in the root of the debugfs filesystem.
379 * @value: a pointer to the variable that the file should read to and write
380 * from.
381 */
382struct dentry *debugfs_create_x64(const char *name, umode_t mode,
383 struct dentry *parent, u64 *value)
384{
385 return debugfs_create_mode(name, mode, parent, value, &fops_x64,
386 &fops_x64_ro, &fops_x64_wo);
387}
388EXPORT_SYMBOL_GPL(debugfs_create_x64);
389
390
391static int debugfs_size_t_set(void *data, u64 val)
392{
393 *(size_t *)data = val;
394 return 0;
395}
396static int debugfs_size_t_get(void *data, u64 *val)
397{
398 *val = *(size_t *)data;
399 return 0;
400}
401DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
402 "%llu\n"); /* %llu and %zu are more or less the same */
403DEFINE_SIMPLE_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
404DEFINE_SIMPLE_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
405
406/**
407 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
408 * @name: a pointer to a string containing the name of the file to create.
409 * @mode: the permission that the file should have
410 * @parent: a pointer to the parent dentry for this file. This should be a
411 * directory dentry if set. If this parameter is %NULL, then the
412 * file will be created in the root of the debugfs filesystem.
413 * @value: a pointer to the variable that the file should read to and write
414 * from.
415 */
416struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
417 struct dentry *parent, size_t *value)
418{
419 return debugfs_create_mode(name, mode, parent, value, &fops_size_t,
420 &fops_size_t_ro, &fops_size_t_wo);
421}
422EXPORT_SYMBOL_GPL(debugfs_create_size_t);
423
424static int debugfs_atomic_t_set(void *data, u64 val)
425{
426 atomic_set((atomic_t *)data, val);
427 return 0;
428}
429static int debugfs_atomic_t_get(void *data, u64 *val)
430{
431 *val = atomic_read((atomic_t *)data);
432 return 0;
433}
434DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
435 debugfs_atomic_t_set, "%lld\n");
436DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL, "%lld\n");
437DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set, "%lld\n");
438
439/**
440 * debugfs_create_atomic_t - create a debugfs file that is used to read and
441 * write an atomic_t value
442 * @name: a pointer to a string containing the name of the file to create.
443 * @mode: the permission that the file should have
444 * @parent: a pointer to the parent dentry for this file. This should be a
445 * directory dentry if set. If this parameter is %NULL, then the
446 * file will be created in the root of the debugfs filesystem.
447 * @value: a pointer to the variable that the file should read to and write
448 * from.
449 */
450struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
451 struct dentry *parent, atomic_t *value)
452{
453 return debugfs_create_mode(name, mode, parent, value, &fops_atomic_t,
454 &fops_atomic_t_ro, &fops_atomic_t_wo);
455}
456EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
457
458ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
459 size_t count, loff_t *ppos)
460{
461 char buf[3];
462 bool *val = file->private_data;
463
464 if (*val)
465 buf[0] = 'Y';
466 else
467 buf[0] = 'N';
468 buf[1] = '\n';
469 buf[2] = 0x00;
470 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
471}
472EXPORT_SYMBOL_GPL(debugfs_read_file_bool);
473
474ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
475 size_t count, loff_t *ppos)
476{
477 char buf[32];
478 size_t buf_size;
479 bool bv;
480 bool *val = file->private_data;
481
482 buf_size = min(count, (sizeof(buf)-1));
483 if (copy_from_user(buf, user_buf, buf_size))
484 return -EFAULT;
485
486 buf[buf_size] = '\0';
487 if (strtobool(buf, &bv) == 0)
488 *val = bv;
489
490 return count;
491}
492EXPORT_SYMBOL_GPL(debugfs_write_file_bool);
493
494static const struct file_operations fops_bool = {
495 .read = debugfs_read_file_bool,
496 .write = debugfs_write_file_bool,
497 .open = simple_open,
498 .llseek = default_llseek,
499};
500
501static const struct file_operations fops_bool_ro = {
502 .read = debugfs_read_file_bool,
503 .open = simple_open,
504 .llseek = default_llseek,
505};
506
507static const struct file_operations fops_bool_wo = {
508 .write = debugfs_write_file_bool,
509 .open = simple_open,
510 .llseek = default_llseek,
511};
512
513/**
514 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
515 * @name: a pointer to a string containing the name of the file to create.
516 * @mode: the permission that the file should have
517 * @parent: a pointer to the parent dentry for this file. This should be a
518 * directory dentry if set. If this parameter is %NULL, then the
519 * file will be created in the root of the debugfs filesystem.
520 * @value: a pointer to the variable that the file should read to and write
521 * from.
522 *
523 * This function creates a file in debugfs with the given name that
524 * contains the value of the variable @value. If the @mode variable is so
525 * set, it can be read from, and written to.
526 *
527 * This function will return a pointer to a dentry if it succeeds. This
528 * pointer must be passed to the debugfs_remove() function when the file is
529 * to be removed (no automatic cleanup happens if your module is unloaded,
530 * you are responsible here.) If an error occurs, %NULL will be returned.
531 *
532 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
533 * returned. It is not wise to check for this value, but rather, check for
534 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
535 * code.
536 */
537struct dentry *debugfs_create_bool(const char *name, umode_t mode,
538 struct dentry *parent, bool *value)
539{
540 return debugfs_create_mode(name, mode, parent, value, &fops_bool,
541 &fops_bool_ro, &fops_bool_wo);
542}
543EXPORT_SYMBOL_GPL(debugfs_create_bool);
544
545static ssize_t read_file_blob(struct file *file, char __user *user_buf,
546 size_t count, loff_t *ppos)
547{
548 struct debugfs_blob_wrapper *blob = file->private_data;
549 return simple_read_from_buffer(user_buf, count, ppos, blob->data,
550 blob->size);
551}
552
553static const struct file_operations fops_blob = {
554 .read = read_file_blob,
555 .open = simple_open,
556 .llseek = default_llseek,
557};
558
559/**
560 * debugfs_create_blob - create a debugfs file that is used to read a binary blob
561 * @name: a pointer to a string containing the name of the file to create.
562 * @mode: the permission that the file should have
563 * @parent: a pointer to the parent dentry for this file. This should be a
564 * directory dentry if set. If this parameter is %NULL, then the
565 * file will be created in the root of the debugfs filesystem.
566 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
567 * to the blob data and the size of the data.
568 *
569 * This function creates a file in debugfs with the given name that exports
570 * @blob->data as a binary blob. If the @mode variable is so set it can be
571 * read from. Writing is not supported.
572 *
573 * This function will return a pointer to a dentry if it succeeds. This
574 * pointer must be passed to the debugfs_remove() function when the file is
575 * to be removed (no automatic cleanup happens if your module is unloaded,
576 * you are responsible here.) If an error occurs, %NULL will be returned.
577 *
578 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
579 * returned. It is not wise to check for this value, but rather, check for
580 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
581 * code.
582 */
583struct dentry *debugfs_create_blob(const char *name, umode_t mode,
584 struct dentry *parent,
585 struct debugfs_blob_wrapper *blob)
586{
587 return debugfs_create_file(name, mode, parent, blob, &fops_blob);
588}
589EXPORT_SYMBOL_GPL(debugfs_create_blob);
590
591struct array_data {
592 void *array;
593 u32 elements;
594};
595
596static size_t u32_format_array(char *buf, size_t bufsize,
597 u32 *array, int array_size)
598{
599 size_t ret = 0;
600
601 while (--array_size >= 0) {
602 size_t len;
603 char term = array_size ? ' ' : '\n';
604
605 len = snprintf(buf, bufsize, "%u%c", *array++, term);
606 ret += len;
607
608 buf += len;
609 bufsize -= len;
610 }
611 return ret;
612}
613
614static int u32_array_open(struct inode *inode, struct file *file)
615{
616 struct array_data *data = inode->i_private;
617 int size, elements = data->elements;
618 char *buf;
619
620 /*
621 * Max size:
622 * - 10 digits + ' '/'\n' = 11 bytes per number
623 * - terminating NUL character
624 */
625 size = elements*11;
626 buf = kmalloc(size+1, GFP_KERNEL);
627 if (!buf)
628 return -ENOMEM;
629 buf[size] = 0;
630
631 file->private_data = buf;
632 u32_format_array(buf, size, data->array, data->elements);
633
634 return nonseekable_open(inode, file);
635}
636
637static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
638 loff_t *ppos)
639{
640 size_t size = strlen(file->private_data);
641
642 return simple_read_from_buffer(buf, len, ppos,
643 file->private_data, size);
644}
645
646static int u32_array_release(struct inode *inode, struct file *file)
647{
648 kfree(file->private_data);
649
650 return 0;
651}
652
653static const struct file_operations u32_array_fops = {
654 .owner = THIS_MODULE,
655 .open = u32_array_open,
656 .release = u32_array_release,
657 .read = u32_array_read,
658 .llseek = no_llseek,
659};
660
661/**
662 * debugfs_create_u32_array - create a debugfs file that is used to read u32
663 * array.
664 * @name: a pointer to a string containing the name of the file to create.
665 * @mode: the permission that the file should have.
666 * @parent: a pointer to the parent dentry for this file. This should be a
667 * directory dentry if set. If this parameter is %NULL, then the
668 * file will be created in the root of the debugfs filesystem.
669 * @array: u32 array that provides data.
670 * @elements: total number of elements in the array.
671 *
672 * This function creates a file in debugfs with the given name that exports
673 * @array as data. If the @mode variable is so set it can be read from.
674 * Writing is not supported. Seek within the file is also not supported.
675 * Once array is created its size can not be changed.
676 *
677 * The function returns a pointer to dentry on success. If debugfs is not
678 * enabled in the kernel, the value -%ENODEV will be returned.
679 */
680struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
681 struct dentry *parent,
682 u32 *array, u32 elements)
683{
684 struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
685
686 if (data == NULL)
687 return NULL;
688
689 data->array = array;
690 data->elements = elements;
691
692 return debugfs_create_file(name, mode, parent, data, &u32_array_fops);
693}
694EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
695
696#ifdef CONFIG_HAS_IOMEM
697
698/*
699 * The regset32 stuff is used to print 32-bit registers using the
700 * seq_file utilities. We offer printing a register set in an already-opened
701 * sequential file or create a debugfs file that only prints a regset32.
702 */
703
704/**
705 * debugfs_print_regs32 - use seq_print to describe a set of registers
706 * @s: the seq_file structure being used to generate output
707 * @regs: an array if struct debugfs_reg32 structures
708 * @nregs: the length of the above array
709 * @base: the base address to be used in reading the registers
710 * @prefix: a string to be prefixed to every output line
711 *
712 * This function outputs a text block describing the current values of
713 * some 32-bit hardware registers. It is meant to be used within debugfs
714 * files based on seq_file that need to show registers, intermixed with other
715 * information. The prefix argument may be used to specify a leading string,
716 * because some peripherals have several blocks of identical registers,
717 * for example configuration of dma channels
718 */
719void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
720 int nregs, void __iomem *base, char *prefix)
721{
722 int i;
723
724 for (i = 0; i < nregs; i++, regs++) {
725 if (prefix)
726 seq_printf(s, "%s", prefix);
727 seq_printf(s, "%s = 0x%08x\n", regs->name,
728 readl(base + regs->offset));
729 if (seq_has_overflowed(s))
730 break;
731 }
732}
733EXPORT_SYMBOL_GPL(debugfs_print_regs32);
734
735static int debugfs_show_regset32(struct seq_file *s, void *data)
736{
737 struct debugfs_regset32 *regset = s->private;
738
739 debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
740 return 0;
741}
742
743static int debugfs_open_regset32(struct inode *inode, struct file *file)
744{
745 return single_open(file, debugfs_show_regset32, inode->i_private);
746}
747
748static const struct file_operations fops_regset32 = {
749 .open = debugfs_open_regset32,
750 .read = seq_read,
751 .llseek = seq_lseek,
752 .release = single_release,
753};
754
755/**
756 * debugfs_create_regset32 - create a debugfs file that returns register values
757 * @name: a pointer to a string containing the name of the file to create.
758 * @mode: the permission that the file should have
759 * @parent: a pointer to the parent dentry for this file. This should be a
760 * directory dentry if set. If this parameter is %NULL, then the
761 * file will be created in the root of the debugfs filesystem.
762 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
763 * to an array of register definitions, the array size and the base
764 * address where the register bank is to be found.
765 *
766 * This function creates a file in debugfs with the given name that reports
767 * the names and values of a set of 32-bit registers. If the @mode variable
768 * is so set it can be read from. Writing is not supported.
769 *
770 * This function will return a pointer to a dentry if it succeeds. This
771 * pointer must be passed to the debugfs_remove() function when the file is
772 * to be removed (no automatic cleanup happens if your module is unloaded,
773 * you are responsible here.) If an error occurs, %NULL will be returned.
774 *
775 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
776 * returned. It is not wise to check for this value, but rather, check for
777 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
778 * code.
779 */
780struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
781 struct dentry *parent,
782 struct debugfs_regset32 *regset)
783{
784 return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
785}
786EXPORT_SYMBOL_GPL(debugfs_create_regset32);
787
788#endif /* CONFIG_HAS_IOMEM */
789
790struct debugfs_devm_entry {
791 int (*read)(struct seq_file *seq, void *data);
792 struct device *dev;
793};
794
795static int debugfs_devm_entry_open(struct inode *inode, struct file *f)
796{
797 struct debugfs_devm_entry *entry = inode->i_private;
798
799 return single_open(f, entry->read, entry->dev);
800}
801
802static const struct file_operations debugfs_devm_entry_ops = {
803 .owner = THIS_MODULE,
804 .open = debugfs_devm_entry_open,
805 .release = single_release,
806 .read = seq_read,
807 .llseek = seq_lseek
808};
809
810/**
811 * debugfs_create_devm_seqfile - create a debugfs file that is bound to device.
812 *
813 * @dev: device related to this debugfs file.
814 * @name: name of the debugfs file.
815 * @parent: a pointer to the parent dentry for this file. This should be a
816 * directory dentry if set. If this parameter is %NULL, then the
817 * file will be created in the root of the debugfs filesystem.
818 * @read_fn: function pointer called to print the seq_file content.
819 */
820struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name,
821 struct dentry *parent,
822 int (*read_fn)(struct seq_file *s,
823 void *data))
824{
825 struct debugfs_devm_entry *entry;
826
827 if (IS_ERR(parent))
828 return ERR_PTR(-ENOENT);
829
830 entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);
831 if (!entry)
832 return ERR_PTR(-ENOMEM);
833
834 entry->read = read_fn;
835 entry->dev = dev;
836
837 return debugfs_create_file(name, S_IRUGO, parent, entry,
838 &debugfs_devm_entry_ops);
839}
840EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile);
841
1/*
2 * file.c - part of debugfs, a tiny little debug file system
3 *
4 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
5 * Copyright (C) 2004 IBM Inc.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License version
9 * 2 as published by the Free Software Foundation.
10 *
11 * debugfs is for people to use instead of /proc or /sys.
12 * See Documentation/DocBook/filesystems for more details.
13 *
14 */
15
16#include <linux/module.h>
17#include <linux/fs.h>
18#include <linux/seq_file.h>
19#include <linux/pagemap.h>
20#include <linux/namei.h>
21#include <linux/debugfs.h>
22#include <linux/io.h>
23#include <linux/slab.h>
24
25static ssize_t default_read_file(struct file *file, char __user *buf,
26 size_t count, loff_t *ppos)
27{
28 return 0;
29}
30
31static ssize_t default_write_file(struct file *file, const char __user *buf,
32 size_t count, loff_t *ppos)
33{
34 return count;
35}
36
37const struct file_operations debugfs_file_operations = {
38 .read = default_read_file,
39 .write = default_write_file,
40 .open = simple_open,
41 .llseek = noop_llseek,
42};
43
44static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
45{
46 nd_set_link(nd, dentry->d_inode->i_private);
47 return NULL;
48}
49
50const struct inode_operations debugfs_link_operations = {
51 .readlink = generic_readlink,
52 .follow_link = debugfs_follow_link,
53};
54
55static int debugfs_u8_set(void *data, u64 val)
56{
57 *(u8 *)data = val;
58 return 0;
59}
60static int debugfs_u8_get(void *data, u64 *val)
61{
62 *val = *(u8 *)data;
63 return 0;
64}
65DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
66DEFINE_SIMPLE_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
67DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
68
69/**
70 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
71 * @name: a pointer to a string containing the name of the file to create.
72 * @mode: the permission that the file should have
73 * @parent: a pointer to the parent dentry for this file. This should be a
74 * directory dentry if set. If this parameter is %NULL, then the
75 * file will be created in the root of the debugfs filesystem.
76 * @value: a pointer to the variable that the file should read to and write
77 * from.
78 *
79 * This function creates a file in debugfs with the given name that
80 * contains the value of the variable @value. If the @mode variable is so
81 * set, it can be read from, and written to.
82 *
83 * This function will return a pointer to a dentry if it succeeds. This
84 * pointer must be passed to the debugfs_remove() function when the file is
85 * to be removed (no automatic cleanup happens if your module is unloaded,
86 * you are responsible here.) If an error occurs, %NULL will be returned.
87 *
88 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
89 * returned. It is not wise to check for this value, but rather, check for
90 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
91 * code.
92 */
93struct dentry *debugfs_create_u8(const char *name, umode_t mode,
94 struct dentry *parent, u8 *value)
95{
96 /* if there are no write bits set, make read only */
97 if (!(mode & S_IWUGO))
98 return debugfs_create_file(name, mode, parent, value, &fops_u8_ro);
99 /* if there are no read bits set, make write only */
100 if (!(mode & S_IRUGO))
101 return debugfs_create_file(name, mode, parent, value, &fops_u8_wo);
102
103 return debugfs_create_file(name, mode, parent, value, &fops_u8);
104}
105EXPORT_SYMBOL_GPL(debugfs_create_u8);
106
107static int debugfs_u16_set(void *data, u64 val)
108{
109 *(u16 *)data = val;
110 return 0;
111}
112static int debugfs_u16_get(void *data, u64 *val)
113{
114 *val = *(u16 *)data;
115 return 0;
116}
117DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
118DEFINE_SIMPLE_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
119DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
120
121/**
122 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
123 * @name: a pointer to a string containing the name of the file to create.
124 * @mode: the permission that the file should have
125 * @parent: a pointer to the parent dentry for this file. This should be a
126 * directory dentry if set. If this parameter is %NULL, then the
127 * file will be created in the root of the debugfs filesystem.
128 * @value: a pointer to the variable that the file should read to and write
129 * from.
130 *
131 * This function creates a file in debugfs with the given name that
132 * contains the value of the variable @value. If the @mode variable is so
133 * set, it can be read from, and written to.
134 *
135 * This function will return a pointer to a dentry if it succeeds. This
136 * pointer must be passed to the debugfs_remove() function when the file is
137 * to be removed (no automatic cleanup happens if your module is unloaded,
138 * you are responsible here.) If an error occurs, %NULL will be returned.
139 *
140 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
141 * returned. It is not wise to check for this value, but rather, check for
142 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
143 * code.
144 */
145struct dentry *debugfs_create_u16(const char *name, umode_t mode,
146 struct dentry *parent, u16 *value)
147{
148 /* if there are no write bits set, make read only */
149 if (!(mode & S_IWUGO))
150 return debugfs_create_file(name, mode, parent, value, &fops_u16_ro);
151 /* if there are no read bits set, make write only */
152 if (!(mode & S_IRUGO))
153 return debugfs_create_file(name, mode, parent, value, &fops_u16_wo);
154
155 return debugfs_create_file(name, mode, parent, value, &fops_u16);
156}
157EXPORT_SYMBOL_GPL(debugfs_create_u16);
158
159static int debugfs_u32_set(void *data, u64 val)
160{
161 *(u32 *)data = val;
162 return 0;
163}
164static int debugfs_u32_get(void *data, u64 *val)
165{
166 *val = *(u32 *)data;
167 return 0;
168}
169DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
170DEFINE_SIMPLE_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
171DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
172
173/**
174 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
175 * @name: a pointer to a string containing the name of the file to create.
176 * @mode: the permission that the file should have
177 * @parent: a pointer to the parent dentry for this file. This should be a
178 * directory dentry if set. If this parameter is %NULL, then the
179 * file will be created in the root of the debugfs filesystem.
180 * @value: a pointer to the variable that the file should read to and write
181 * from.
182 *
183 * This function creates a file in debugfs with the given name that
184 * contains the value of the variable @value. If the @mode variable is so
185 * set, it can be read from, and written to.
186 *
187 * This function will return a pointer to a dentry if it succeeds. This
188 * pointer must be passed to the debugfs_remove() function when the file is
189 * to be removed (no automatic cleanup happens if your module is unloaded,
190 * you are responsible here.) If an error occurs, %NULL will be returned.
191 *
192 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
193 * returned. It is not wise to check for this value, but rather, check for
194 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
195 * code.
196 */
197struct dentry *debugfs_create_u32(const char *name, umode_t mode,
198 struct dentry *parent, u32 *value)
199{
200 /* if there are no write bits set, make read only */
201 if (!(mode & S_IWUGO))
202 return debugfs_create_file(name, mode, parent, value, &fops_u32_ro);
203 /* if there are no read bits set, make write only */
204 if (!(mode & S_IRUGO))
205 return debugfs_create_file(name, mode, parent, value, &fops_u32_wo);
206
207 return debugfs_create_file(name, mode, parent, value, &fops_u32);
208}
209EXPORT_SYMBOL_GPL(debugfs_create_u32);
210
211static int debugfs_u64_set(void *data, u64 val)
212{
213 *(u64 *)data = val;
214 return 0;
215}
216
217static int debugfs_u64_get(void *data, u64 *val)
218{
219 *val = *(u64 *)data;
220 return 0;
221}
222DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
223DEFINE_SIMPLE_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
224DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
225
226/**
227 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
228 * @name: a pointer to a string containing the name of the file to create.
229 * @mode: the permission that the file should have
230 * @parent: a pointer to the parent dentry for this file. This should be a
231 * directory dentry if set. If this parameter is %NULL, then the
232 * file will be created in the root of the debugfs filesystem.
233 * @value: a pointer to the variable that the file should read to and write
234 * from.
235 *
236 * This function creates a file in debugfs with the given name that
237 * contains the value of the variable @value. If the @mode variable is so
238 * set, it can be read from, and written to.
239 *
240 * This function will return a pointer to a dentry if it succeeds. This
241 * pointer must be passed to the debugfs_remove() function when the file is
242 * to be removed (no automatic cleanup happens if your module is unloaded,
243 * you are responsible here.) If an error occurs, %NULL will be returned.
244 *
245 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
246 * returned. It is not wise to check for this value, but rather, check for
247 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
248 * code.
249 */
250struct dentry *debugfs_create_u64(const char *name, umode_t mode,
251 struct dentry *parent, u64 *value)
252{
253 /* if there are no write bits set, make read only */
254 if (!(mode & S_IWUGO))
255 return debugfs_create_file(name, mode, parent, value, &fops_u64_ro);
256 /* if there are no read bits set, make write only */
257 if (!(mode & S_IRUGO))
258 return debugfs_create_file(name, mode, parent, value, &fops_u64_wo);
259
260 return debugfs_create_file(name, mode, parent, value, &fops_u64);
261}
262EXPORT_SYMBOL_GPL(debugfs_create_u64);
263
264DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
265DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
266DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
267
268DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n");
269DEFINE_SIMPLE_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
270DEFINE_SIMPLE_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
271
272DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n");
273DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
274DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
275
276DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n");
277
278/*
279 * debugfs_create_x{8,16,32,64} - create a debugfs file that is used to read and write an unsigned {8,16,32,64}-bit value
280 *
281 * These functions are exactly the same as the above functions (but use a hex
282 * output for the decimal challenged). For details look at the above unsigned
283 * decimal functions.
284 */
285
286/**
287 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
288 * @name: a pointer to a string containing the name of the file to create.
289 * @mode: the permission that the file should have
290 * @parent: a pointer to the parent dentry for this file. This should be a
291 * directory dentry if set. If this parameter is %NULL, then the
292 * file will be created in the root of the debugfs filesystem.
293 * @value: a pointer to the variable that the file should read to and write
294 * from.
295 */
296struct dentry *debugfs_create_x8(const char *name, umode_t mode,
297 struct dentry *parent, u8 *value)
298{
299 /* if there are no write bits set, make read only */
300 if (!(mode & S_IWUGO))
301 return debugfs_create_file(name, mode, parent, value, &fops_x8_ro);
302 /* if there are no read bits set, make write only */
303 if (!(mode & S_IRUGO))
304 return debugfs_create_file(name, mode, parent, value, &fops_x8_wo);
305
306 return debugfs_create_file(name, mode, parent, value, &fops_x8);
307}
308EXPORT_SYMBOL_GPL(debugfs_create_x8);
309
310/**
311 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
312 * @name: a pointer to a string containing the name of the file to create.
313 * @mode: the permission that the file should have
314 * @parent: a pointer to the parent dentry for this file. This should be a
315 * directory dentry if set. If this parameter is %NULL, then the
316 * file will be created in the root of the debugfs filesystem.
317 * @value: a pointer to the variable that the file should read to and write
318 * from.
319 */
320struct dentry *debugfs_create_x16(const char *name, umode_t mode,
321 struct dentry *parent, u16 *value)
322{
323 /* if there are no write bits set, make read only */
324 if (!(mode & S_IWUGO))
325 return debugfs_create_file(name, mode, parent, value, &fops_x16_ro);
326 /* if there are no read bits set, make write only */
327 if (!(mode & S_IRUGO))
328 return debugfs_create_file(name, mode, parent, value, &fops_x16_wo);
329
330 return debugfs_create_file(name, mode, parent, value, &fops_x16);
331}
332EXPORT_SYMBOL_GPL(debugfs_create_x16);
333
334/**
335 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
336 * @name: a pointer to a string containing the name of the file to create.
337 * @mode: the permission that the file should have
338 * @parent: a pointer to the parent dentry for this file. This should be a
339 * directory dentry if set. If this parameter is %NULL, then the
340 * file will be created in the root of the debugfs filesystem.
341 * @value: a pointer to the variable that the file should read to and write
342 * from.
343 */
344struct dentry *debugfs_create_x32(const char *name, umode_t mode,
345 struct dentry *parent, u32 *value)
346{
347 /* if there are no write bits set, make read only */
348 if (!(mode & S_IWUGO))
349 return debugfs_create_file(name, mode, parent, value, &fops_x32_ro);
350 /* if there are no read bits set, make write only */
351 if (!(mode & S_IRUGO))
352 return debugfs_create_file(name, mode, parent, value, &fops_x32_wo);
353
354 return debugfs_create_file(name, mode, parent, value, &fops_x32);
355}
356EXPORT_SYMBOL_GPL(debugfs_create_x32);
357
358/**
359 * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
360 * @name: a pointer to a string containing the name of the file to create.
361 * @mode: the permission that the file should have
362 * @parent: a pointer to the parent dentry for this file. This should be a
363 * directory dentry if set. If this parameter is %NULL, then the
364 * file will be created in the root of the debugfs filesystem.
365 * @value: a pointer to the variable that the file should read to and write
366 * from.
367 */
368struct dentry *debugfs_create_x64(const char *name, umode_t mode,
369 struct dentry *parent, u64 *value)
370{
371 return debugfs_create_file(name, mode, parent, value, &fops_x64);
372}
373EXPORT_SYMBOL_GPL(debugfs_create_x64);
374
375
376static int debugfs_size_t_set(void *data, u64 val)
377{
378 *(size_t *)data = val;
379 return 0;
380}
381static int debugfs_size_t_get(void *data, u64 *val)
382{
383 *val = *(size_t *)data;
384 return 0;
385}
386DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
387 "%llu\n"); /* %llu and %zu are more or less the same */
388
389/**
390 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
391 * @name: a pointer to a string containing the name of the file to create.
392 * @mode: the permission that the file should have
393 * @parent: a pointer to the parent dentry for this file. This should be a
394 * directory dentry if set. If this parameter is %NULL, then the
395 * file will be created in the root of the debugfs filesystem.
396 * @value: a pointer to the variable that the file should read to and write
397 * from.
398 */
399struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
400 struct dentry *parent, size_t *value)
401{
402 return debugfs_create_file(name, mode, parent, value, &fops_size_t);
403}
404EXPORT_SYMBOL_GPL(debugfs_create_size_t);
405
406
407static ssize_t read_file_bool(struct file *file, char __user *user_buf,
408 size_t count, loff_t *ppos)
409{
410 char buf[3];
411 u32 *val = file->private_data;
412
413 if (*val)
414 buf[0] = 'Y';
415 else
416 buf[0] = 'N';
417 buf[1] = '\n';
418 buf[2] = 0x00;
419 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
420}
421
422static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
423 size_t count, loff_t *ppos)
424{
425 char buf[32];
426 size_t buf_size;
427 bool bv;
428 u32 *val = file->private_data;
429
430 buf_size = min(count, (sizeof(buf)-1));
431 if (copy_from_user(buf, user_buf, buf_size))
432 return -EFAULT;
433
434 if (strtobool(buf, &bv) == 0)
435 *val = bv;
436
437 return count;
438}
439
440static const struct file_operations fops_bool = {
441 .read = read_file_bool,
442 .write = write_file_bool,
443 .open = simple_open,
444 .llseek = default_llseek,
445};
446
447/**
448 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
449 * @name: a pointer to a string containing the name of the file to create.
450 * @mode: the permission that the file should have
451 * @parent: a pointer to the parent dentry for this file. This should be a
452 * directory dentry if set. If this parameter is %NULL, then the
453 * file will be created in the root of the debugfs filesystem.
454 * @value: a pointer to the variable that the file should read to and write
455 * from.
456 *
457 * This function creates a file in debugfs with the given name that
458 * contains the value of the variable @value. If the @mode variable is so
459 * set, it can be read from, and written to.
460 *
461 * This function will return a pointer to a dentry if it succeeds. This
462 * pointer must be passed to the debugfs_remove() function when the file is
463 * to be removed (no automatic cleanup happens if your module is unloaded,
464 * you are responsible here.) If an error occurs, %NULL will be returned.
465 *
466 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
467 * returned. It is not wise to check for this value, but rather, check for
468 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
469 * code.
470 */
471struct dentry *debugfs_create_bool(const char *name, umode_t mode,
472 struct dentry *parent, u32 *value)
473{
474 return debugfs_create_file(name, mode, parent, value, &fops_bool);
475}
476EXPORT_SYMBOL_GPL(debugfs_create_bool);
477
478static ssize_t read_file_blob(struct file *file, char __user *user_buf,
479 size_t count, loff_t *ppos)
480{
481 struct debugfs_blob_wrapper *blob = file->private_data;
482 return simple_read_from_buffer(user_buf, count, ppos, blob->data,
483 blob->size);
484}
485
486static const struct file_operations fops_blob = {
487 .read = read_file_blob,
488 .open = simple_open,
489 .llseek = default_llseek,
490};
491
492/**
493 * debugfs_create_blob - create a debugfs file that is used to read a binary blob
494 * @name: a pointer to a string containing the name of the file to create.
495 * @mode: the permission that the file should have
496 * @parent: a pointer to the parent dentry for this file. This should be a
497 * directory dentry if set. If this parameter is %NULL, then the
498 * file will be created in the root of the debugfs filesystem.
499 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
500 * to the blob data and the size of the data.
501 *
502 * This function creates a file in debugfs with the given name that exports
503 * @blob->data as a binary blob. If the @mode variable is so set it can be
504 * read from. Writing is not supported.
505 *
506 * This function will return a pointer to a dentry if it succeeds. This
507 * pointer must be passed to the debugfs_remove() function when the file is
508 * to be removed (no automatic cleanup happens if your module is unloaded,
509 * you are responsible here.) If an error occurs, %NULL will be returned.
510 *
511 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
512 * returned. It is not wise to check for this value, but rather, check for
513 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
514 * code.
515 */
516struct dentry *debugfs_create_blob(const char *name, umode_t mode,
517 struct dentry *parent,
518 struct debugfs_blob_wrapper *blob)
519{
520 return debugfs_create_file(name, mode, parent, blob, &fops_blob);
521}
522EXPORT_SYMBOL_GPL(debugfs_create_blob);
523
524struct array_data {
525 void *array;
526 u32 elements;
527};
528
529static int u32_array_open(struct inode *inode, struct file *file)
530{
531 file->private_data = NULL;
532 return nonseekable_open(inode, file);
533}
534
535static size_t format_array(char *buf, size_t bufsize, const char *fmt,
536 u32 *array, u32 array_size)
537{
538 size_t ret = 0;
539 u32 i;
540
541 for (i = 0; i < array_size; i++) {
542 size_t len;
543
544 len = snprintf(buf, bufsize, fmt, array[i]);
545 len++; /* ' ' or '\n' */
546 ret += len;
547
548 if (buf) {
549 buf += len;
550 bufsize -= len;
551 buf[-1] = (i == array_size-1) ? '\n' : ' ';
552 }
553 }
554
555 ret++; /* \0 */
556 if (buf)
557 *buf = '\0';
558
559 return ret;
560}
561
562static char *format_array_alloc(const char *fmt, u32 *array,
563 u32 array_size)
564{
565 size_t len = format_array(NULL, 0, fmt, array, array_size);
566 char *ret;
567
568 ret = kmalloc(len, GFP_KERNEL);
569 if (ret == NULL)
570 return NULL;
571
572 format_array(ret, len, fmt, array, array_size);
573 return ret;
574}
575
576static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
577 loff_t *ppos)
578{
579 struct inode *inode = file->f_path.dentry->d_inode;
580 struct array_data *data = inode->i_private;
581 size_t size;
582
583 if (*ppos == 0) {
584 if (file->private_data) {
585 kfree(file->private_data);
586 file->private_data = NULL;
587 }
588
589 file->private_data = format_array_alloc("%u", data->array,
590 data->elements);
591 }
592
593 size = 0;
594 if (file->private_data)
595 size = strlen(file->private_data);
596
597 return simple_read_from_buffer(buf, len, ppos,
598 file->private_data, size);
599}
600
601static int u32_array_release(struct inode *inode, struct file *file)
602{
603 kfree(file->private_data);
604
605 return 0;
606}
607
608static const struct file_operations u32_array_fops = {
609 .owner = THIS_MODULE,
610 .open = u32_array_open,
611 .release = u32_array_release,
612 .read = u32_array_read,
613 .llseek = no_llseek,
614};
615
616/**
617 * debugfs_create_u32_array - create a debugfs file that is used to read u32
618 * array.
619 * @name: a pointer to a string containing the name of the file to create.
620 * @mode: the permission that the file should have.
621 * @parent: a pointer to the parent dentry for this file. This should be a
622 * directory dentry if set. If this parameter is %NULL, then the
623 * file will be created in the root of the debugfs filesystem.
624 * @array: u32 array that provides data.
625 * @elements: total number of elements in the array.
626 *
627 * This function creates a file in debugfs with the given name that exports
628 * @array as data. If the @mode variable is so set it can be read from.
629 * Writing is not supported. Seek within the file is also not supported.
630 * Once array is created its size can not be changed.
631 *
632 * The function returns a pointer to dentry on success. If debugfs is not
633 * enabled in the kernel, the value -%ENODEV will be returned.
634 */
635struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
636 struct dentry *parent,
637 u32 *array, u32 elements)
638{
639 struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
640
641 if (data == NULL)
642 return NULL;
643
644 data->array = array;
645 data->elements = elements;
646
647 return debugfs_create_file(name, mode, parent, data, &u32_array_fops);
648}
649EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
650
651#ifdef CONFIG_HAS_IOMEM
652
653/*
654 * The regset32 stuff is used to print 32-bit registers using the
655 * seq_file utilities. We offer printing a register set in an already-opened
656 * sequential file or create a debugfs file that only prints a regset32.
657 */
658
659/**
660 * debugfs_print_regs32 - use seq_print to describe a set of registers
661 * @s: the seq_file structure being used to generate output
662 * @regs: an array if struct debugfs_reg32 structures
663 * @nregs: the length of the above array
664 * @base: the base address to be used in reading the registers
665 * @prefix: a string to be prefixed to every output line
666 *
667 * This function outputs a text block describing the current values of
668 * some 32-bit hardware registers. It is meant to be used within debugfs
669 * files based on seq_file that need to show registers, intermixed with other
670 * information. The prefix argument may be used to specify a leading string,
671 * because some peripherals have several blocks of identical registers,
672 * for example configuration of dma channels
673 */
674int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
675 int nregs, void __iomem *base, char *prefix)
676{
677 int i, ret = 0;
678
679 for (i = 0; i < nregs; i++, regs++) {
680 if (prefix)
681 ret += seq_printf(s, "%s", prefix);
682 ret += seq_printf(s, "%s = 0x%08x\n", regs->name,
683 readl(base + regs->offset));
684 }
685 return ret;
686}
687EXPORT_SYMBOL_GPL(debugfs_print_regs32);
688
689static int debugfs_show_regset32(struct seq_file *s, void *data)
690{
691 struct debugfs_regset32 *regset = s->private;
692
693 debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
694 return 0;
695}
696
697static int debugfs_open_regset32(struct inode *inode, struct file *file)
698{
699 return single_open(file, debugfs_show_regset32, inode->i_private);
700}
701
702static const struct file_operations fops_regset32 = {
703 .open = debugfs_open_regset32,
704 .read = seq_read,
705 .llseek = seq_lseek,
706 .release = single_release,
707};
708
709/**
710 * debugfs_create_regset32 - create a debugfs file that returns register values
711 * @name: a pointer to a string containing the name of the file to create.
712 * @mode: the permission that the file should have
713 * @parent: a pointer to the parent dentry for this file. This should be a
714 * directory dentry if set. If this parameter is %NULL, then the
715 * file will be created in the root of the debugfs filesystem.
716 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
717 * to an array of register definitions, the array size and the base
718 * address where the register bank is to be found.
719 *
720 * This function creates a file in debugfs with the given name that reports
721 * the names and values of a set of 32-bit registers. If the @mode variable
722 * is so set it can be read from. Writing is not supported.
723 *
724 * This function will return a pointer to a dentry if it succeeds. This
725 * pointer must be passed to the debugfs_remove() function when the file is
726 * to be removed (no automatic cleanup happens if your module is unloaded,
727 * you are responsible here.) If an error occurs, %NULL will be returned.
728 *
729 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
730 * returned. It is not wise to check for this value, but rather, check for
731 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
732 * code.
733 */
734struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
735 struct dentry *parent,
736 struct debugfs_regset32 *regset)
737{
738 return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
739}
740EXPORT_SYMBOL_GPL(debugfs_create_regset32);
741
742#endif /* CONFIG_HAS_IOMEM */