simple_open: automatically convert to simple_open()
[linux-2.6.git] / fs / debugfs / file.c
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
24 static ssize_t default_read_file(struct file *file, char __user *buf,
25                                  size_t count, loff_t *ppos)
26 {
27         return 0;
28 }
29
30 static ssize_t default_write_file(struct file *file, const char __user *buf,
31                                    size_t count, loff_t *ppos)
32 {
33         return count;
34 }
35
36 const struct file_operations debugfs_file_operations = {
37         .read =         default_read_file,
38         .write =        default_write_file,
39         .open =         simple_open,
40         .llseek =       noop_llseek,
41 };
42
43 static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
44 {
45         nd_set_link(nd, dentry->d_inode->i_private);
46         return NULL;
47 }
48
49 const struct inode_operations debugfs_link_operations = {
50         .readlink       = generic_readlink,
51         .follow_link    = debugfs_follow_link,
52 };
53
54 static int debugfs_u8_set(void *data, u64 val)
55 {
56         *(u8 *)data = val;
57         return 0;
58 }
59 static int debugfs_u8_get(void *data, u64 *val)
60 {
61         *val = *(u8 *)data;
62         return 0;
63 }
64 DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
65 DEFINE_SIMPLE_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
66 DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
67
68 /**
69  * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
70  * @name: a pointer to a string containing the name of the file to create.
71  * @mode: the permission that the file should have
72  * @parent: a pointer to the parent dentry for this file.  This should be a
73  *          directory dentry if set.  If this parameter is %NULL, then the
74  *          file will be created in the root of the debugfs filesystem.
75  * @value: a pointer to the variable that the file should read to and write
76  *         from.
77  *
78  * This function creates a file in debugfs with the given name that
79  * contains the value of the variable @value.  If the @mode variable is so
80  * set, it can be read from, and written to.
81  *
82  * This function will return a pointer to a dentry if it succeeds.  This
83  * pointer must be passed to the debugfs_remove() function when the file is
84  * to be removed (no automatic cleanup happens if your module is unloaded,
85  * you are responsible here.)  If an error occurs, %NULL will be returned.
86  *
87  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
88  * returned.  It is not wise to check for this value, but rather, check for
89  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
90  * code.
91  */
92 struct dentry *debugfs_create_u8(const char *name, umode_t mode,
93                                  struct dentry *parent, u8 *value)
94 {
95         /* if there are no write bits set, make read only */
96         if (!(mode & S_IWUGO))
97                 return debugfs_create_file(name, mode, parent, value, &fops_u8_ro);
98         /* if there are no read bits set, make write only */
99         if (!(mode & S_IRUGO))
100                 return debugfs_create_file(name, mode, parent, value, &fops_u8_wo);
101
102         return debugfs_create_file(name, mode, parent, value, &fops_u8);
103 }
104 EXPORT_SYMBOL_GPL(debugfs_create_u8);
105
106 static int debugfs_u16_set(void *data, u64 val)
107 {
108         *(u16 *)data = val;
109         return 0;
110 }
111 static int debugfs_u16_get(void *data, u64 *val)
112 {
113         *val = *(u16 *)data;
114         return 0;
115 }
116 DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
117 DEFINE_SIMPLE_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
118 DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
119
120 /**
121  * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
122  * @name: a pointer to a string containing the name of the file to create.
123  * @mode: the permission that the file should have
124  * @parent: a pointer to the parent dentry for this file.  This should be a
125  *          directory dentry if set.  If this parameter is %NULL, then the
126  *          file will be created in the root of the debugfs filesystem.
127  * @value: a pointer to the variable that the file should read to and write
128  *         from.
129  *
130  * This function creates a file in debugfs with the given name that
131  * contains the value of the variable @value.  If the @mode variable is so
132  * set, it can be read from, and written to.
133  *
134  * This function will return a pointer to a dentry if it succeeds.  This
135  * pointer must be passed to the debugfs_remove() function when the file is
136  * to be removed (no automatic cleanup happens if your module is unloaded,
137  * you are responsible here.)  If an error occurs, %NULL will be returned.
138  *
139  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
140  * returned.  It is not wise to check for this value, but rather, check for
141  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
142  * code.
143  */
144 struct dentry *debugfs_create_u16(const char *name, umode_t mode,
145                                   struct dentry *parent, u16 *value)
146 {
147         /* if there are no write bits set, make read only */
148         if (!(mode & S_IWUGO))
149                 return debugfs_create_file(name, mode, parent, value, &fops_u16_ro);
150         /* if there are no read bits set, make write only */
151         if (!(mode & S_IRUGO))
152                 return debugfs_create_file(name, mode, parent, value, &fops_u16_wo);
153
154         return debugfs_create_file(name, mode, parent, value, &fops_u16);
155 }
156 EXPORT_SYMBOL_GPL(debugfs_create_u16);
157
158 static int debugfs_u32_set(void *data, u64 val)
159 {
160         *(u32 *)data = val;
161         return 0;
162 }
163 static int debugfs_u32_get(void *data, u64 *val)
164 {
165         *val = *(u32 *)data;
166         return 0;
167 }
168 DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
169 DEFINE_SIMPLE_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
170 DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
171
172 /**
173  * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
174  * @name: a pointer to a string containing the name of the file to create.
175  * @mode: the permission that the file should have
176  * @parent: a pointer to the parent dentry for this file.  This should be a
177  *          directory dentry if set.  If this parameter is %NULL, then the
178  *          file will be created in the root of the debugfs filesystem.
179  * @value: a pointer to the variable that the file should read to and write
180  *         from.
181  *
182  * This function creates a file in debugfs with the given name that
183  * contains the value of the variable @value.  If the @mode variable is so
184  * set, it can be read from, and written to.
185  *
186  * This function will return a pointer to a dentry if it succeeds.  This
187  * pointer must be passed to the debugfs_remove() function when the file is
188  * to be removed (no automatic cleanup happens if your module is unloaded,
189  * you are responsible here.)  If an error occurs, %NULL will be returned.
190  *
191  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
192  * returned.  It is not wise to check for this value, but rather, check for
193  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
194  * code.
195  */
196 struct dentry *debugfs_create_u32(const char *name, umode_t mode,
197                                  struct dentry *parent, u32 *value)
198 {
199         /* if there are no write bits set, make read only */
200         if (!(mode & S_IWUGO))
201                 return debugfs_create_file(name, mode, parent, value, &fops_u32_ro);
202         /* if there are no read bits set, make write only */
203         if (!(mode & S_IRUGO))
204                 return debugfs_create_file(name, mode, parent, value, &fops_u32_wo);
205
206         return debugfs_create_file(name, mode, parent, value, &fops_u32);
207 }
208 EXPORT_SYMBOL_GPL(debugfs_create_u32);
209
210 static int debugfs_u64_set(void *data, u64 val)
211 {
212         *(u64 *)data = val;
213         return 0;
214 }
215
216 static int debugfs_u64_get(void *data, u64 *val)
217 {
218         *val = *(u64 *)data;
219         return 0;
220 }
221 DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
222 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
223 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
224
225 /**
226  * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
227  * @name: a pointer to a string containing the name of the file to create.
228  * @mode: the permission that the file should have
229  * @parent: a pointer to the parent dentry for this file.  This should be a
230  *          directory dentry if set.  If this parameter is %NULL, then the
231  *          file will be created in the root of the debugfs filesystem.
232  * @value: a pointer to the variable that the file should read to and write
233  *         from.
234  *
235  * This function creates a file in debugfs with the given name that
236  * contains the value of the variable @value.  If the @mode variable is so
237  * set, it can be read from, and written to.
238  *
239  * This function will return a pointer to a dentry if it succeeds.  This
240  * pointer must be passed to the debugfs_remove() function when the file is
241  * to be removed (no automatic cleanup happens if your module is unloaded,
242  * you are responsible here.)  If an error occurs, %NULL will be returned.
243  *
244  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
245  * returned.  It is not wise to check for this value, but rather, check for
246  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
247  * code.
248  */
249 struct dentry *debugfs_create_u64(const char *name, umode_t mode,
250                                  struct dentry *parent, u64 *value)
251 {
252         /* if there are no write bits set, make read only */
253         if (!(mode & S_IWUGO))
254                 return debugfs_create_file(name, mode, parent, value, &fops_u64_ro);
255         /* if there are no read bits set, make write only */
256         if (!(mode & S_IRUGO))
257                 return debugfs_create_file(name, mode, parent, value, &fops_u64_wo);
258
259         return debugfs_create_file(name, mode, parent, value, &fops_u64);
260 }
261 EXPORT_SYMBOL_GPL(debugfs_create_u64);
262
263 DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
264 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
265 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
266
267 DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n");
268 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
269 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
270
271 DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n");
272 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
273 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
274
275 DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n");
276
277 /*
278  * 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
279  *
280  * These functions are exactly the same as the above functions (but use a hex
281  * output for the decimal challenged). For details look at the above unsigned
282  * decimal functions.
283  */
284
285 /**
286  * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
287  * @name: a pointer to a string containing the name of the file to create.
288  * @mode: the permission that the file should have
289  * @parent: a pointer to the parent dentry for this file.  This should be a
290  *          directory dentry if set.  If this parameter is %NULL, then the
291  *          file will be created in the root of the debugfs filesystem.
292  * @value: a pointer to the variable that the file should read to and write
293  *         from.
294  */
295 struct dentry *debugfs_create_x8(const char *name, umode_t mode,
296                                  struct dentry *parent, u8 *value)
297 {
298         /* if there are no write bits set, make read only */
299         if (!(mode & S_IWUGO))
300                 return debugfs_create_file(name, mode, parent, value, &fops_x8_ro);
301         /* if there are no read bits set, make write only */
302         if (!(mode & S_IRUGO))
303                 return debugfs_create_file(name, mode, parent, value, &fops_x8_wo);
304
305         return debugfs_create_file(name, mode, parent, value, &fops_x8);
306 }
307 EXPORT_SYMBOL_GPL(debugfs_create_x8);
308
309 /**
310  * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
311  * @name: a pointer to a string containing the name of the file to create.
312  * @mode: the permission that the file should have
313  * @parent: a pointer to the parent dentry for this file.  This should be a
314  *          directory dentry if set.  If this parameter is %NULL, then the
315  *          file will be created in the root of the debugfs filesystem.
316  * @value: a pointer to the variable that the file should read to and write
317  *         from.
318  */
319 struct dentry *debugfs_create_x16(const char *name, umode_t mode,
320                                  struct dentry *parent, u16 *value)
321 {
322         /* if there are no write bits set, make read only */
323         if (!(mode & S_IWUGO))
324                 return debugfs_create_file(name, mode, parent, value, &fops_x16_ro);
325         /* if there are no read bits set, make write only */
326         if (!(mode & S_IRUGO))
327                 return debugfs_create_file(name, mode, parent, value, &fops_x16_wo);
328
329         return debugfs_create_file(name, mode, parent, value, &fops_x16);
330 }
331 EXPORT_SYMBOL_GPL(debugfs_create_x16);
332
333 /**
334  * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
335  * @name: a pointer to a string containing the name of the file to create.
336  * @mode: the permission that the file should have
337  * @parent: a pointer to the parent dentry for this file.  This should be a
338  *          directory dentry if set.  If this parameter is %NULL, then the
339  *          file will be created in the root of the debugfs filesystem.
340  * @value: a pointer to the variable that the file should read to and write
341  *         from.
342  */
343 struct dentry *debugfs_create_x32(const char *name, umode_t mode,
344                                  struct dentry *parent, u32 *value)
345 {
346         /* if there are no write bits set, make read only */
347         if (!(mode & S_IWUGO))
348                 return debugfs_create_file(name, mode, parent, value, &fops_x32_ro);
349         /* if there are no read bits set, make write only */
350         if (!(mode & S_IRUGO))
351                 return debugfs_create_file(name, mode, parent, value, &fops_x32_wo);
352
353         return debugfs_create_file(name, mode, parent, value, &fops_x32);
354 }
355 EXPORT_SYMBOL_GPL(debugfs_create_x32);
356
357 /**
358  * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
359  * @name: a pointer to a string containing the name of the file to create.
360  * @mode: the permission that the file should have
361  * @parent: a pointer to the parent dentry for this file.  This should be a
362  *          directory dentry if set.  If this parameter is %NULL, then the
363  *          file will be created in the root of the debugfs filesystem.
364  * @value: a pointer to the variable that the file should read to and write
365  *         from.
366  */
367 struct dentry *debugfs_create_x64(const char *name, umode_t mode,
368                                  struct dentry *parent, u64 *value)
369 {
370         return debugfs_create_file(name, mode, parent, value, &fops_x64);
371 }
372 EXPORT_SYMBOL_GPL(debugfs_create_x64);
373
374
375 static int debugfs_size_t_set(void *data, u64 val)
376 {
377         *(size_t *)data = val;
378         return 0;
379 }
380 static int debugfs_size_t_get(void *data, u64 *val)
381 {
382         *val = *(size_t *)data;
383         return 0;
384 }
385 DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
386                         "%llu\n");      /* %llu and %zu are more or less the same */
387
388 /**
389  * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
390  * @name: a pointer to a string containing the name of the file to create.
391  * @mode: the permission that the file should have
392  * @parent: a pointer to the parent dentry for this file.  This should be a
393  *          directory dentry if set.  If this parameter is %NULL, then the
394  *          file will be created in the root of the debugfs filesystem.
395  * @value: a pointer to the variable that the file should read to and write
396  *         from.
397  */
398 struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
399                                      struct dentry *parent, size_t *value)
400 {
401         return debugfs_create_file(name, mode, parent, value, &fops_size_t);
402 }
403 EXPORT_SYMBOL_GPL(debugfs_create_size_t);
404
405
406 static ssize_t read_file_bool(struct file *file, char __user *user_buf,
407                               size_t count, loff_t *ppos)
408 {
409         char buf[3];
410         u32 *val = file->private_data;
411         
412         if (*val)
413                 buf[0] = 'Y';
414         else
415                 buf[0] = 'N';
416         buf[1] = '\n';
417         buf[2] = 0x00;
418         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
419 }
420
421 static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
422                                size_t count, loff_t *ppos)
423 {
424         char buf[32];
425         size_t buf_size;
426         bool bv;
427         u32 *val = file->private_data;
428
429         buf_size = min(count, (sizeof(buf)-1));
430         if (copy_from_user(buf, user_buf, buf_size))
431                 return -EFAULT;
432
433         if (strtobool(buf, &bv) == 0)
434                 *val = bv;
435
436         return count;
437 }
438
439 static const struct file_operations fops_bool = {
440         .read =         read_file_bool,
441         .write =        write_file_bool,
442         .open =         simple_open,
443         .llseek =       default_llseek,
444 };
445
446 /**
447  * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
448  * @name: a pointer to a string containing the name of the file to create.
449  * @mode: the permission that the file should have
450  * @parent: a pointer to the parent dentry for this file.  This should be a
451  *          directory dentry if set.  If this parameter is %NULL, then the
452  *          file will be created in the root of the debugfs filesystem.
453  * @value: a pointer to the variable that the file should read to and write
454  *         from.
455  *
456  * This function creates a file in debugfs with the given name that
457  * contains the value of the variable @value.  If the @mode variable is so
458  * set, it can be read from, and written to.
459  *
460  * This function will return a pointer to a dentry if it succeeds.  This
461  * pointer must be passed to the debugfs_remove() function when the file is
462  * to be removed (no automatic cleanup happens if your module is unloaded,
463  * you are responsible here.)  If an error occurs, %NULL will be returned.
464  *
465  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
466  * returned.  It is not wise to check for this value, but rather, check for
467  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
468  * code.
469  */
470 struct dentry *debugfs_create_bool(const char *name, umode_t mode,
471                                    struct dentry *parent, u32 *value)
472 {
473         return debugfs_create_file(name, mode, parent, value, &fops_bool);
474 }
475 EXPORT_SYMBOL_GPL(debugfs_create_bool);
476
477 static ssize_t read_file_blob(struct file *file, char __user *user_buf,
478                               size_t count, loff_t *ppos)
479 {
480         struct debugfs_blob_wrapper *blob = file->private_data;
481         return simple_read_from_buffer(user_buf, count, ppos, blob->data,
482                         blob->size);
483 }
484
485 static const struct file_operations fops_blob = {
486         .read =         read_file_blob,
487         .open =         simple_open,
488         .llseek =       default_llseek,
489 };
490
491 /**
492  * debugfs_create_blob - create a debugfs file that is used to read a binary blob
493  * @name: a pointer to a string containing the name of the file to create.
494  * @mode: the permission that the file should have
495  * @parent: a pointer to the parent dentry for this file.  This should be a
496  *          directory dentry if set.  If this parameter is %NULL, then the
497  *          file will be created in the root of the debugfs filesystem.
498  * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
499  *        to the blob data and the size of the data.
500  *
501  * This function creates a file in debugfs with the given name that exports
502  * @blob->data as a binary blob. If the @mode variable is so set it can be
503  * read from. Writing is not supported.
504  *
505  * This function will return a pointer to a dentry if it succeeds.  This
506  * pointer must be passed to the debugfs_remove() function when the file is
507  * to be removed (no automatic cleanup happens if your module is unloaded,
508  * you are responsible here.)  If an error occurs, %NULL will be returned.
509  *
510  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
511  * returned.  It is not wise to check for this value, but rather, check for
512  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
513  * code.
514  */
515 struct dentry *debugfs_create_blob(const char *name, umode_t mode,
516                                    struct dentry *parent,
517                                    struct debugfs_blob_wrapper *blob)
518 {
519         return debugfs_create_file(name, mode, parent, blob, &fops_blob);
520 }
521 EXPORT_SYMBOL_GPL(debugfs_create_blob);
522
523 #ifdef CONFIG_HAS_IOMEM
524
525 /*
526  * The regset32 stuff is used to print 32-bit registers using the
527  * seq_file utilities. We offer printing a register set in an already-opened
528  * sequential file or create a debugfs file that only prints a regset32.
529  */
530
531 /**
532  * debugfs_print_regs32 - use seq_print to describe a set of registers
533  * @s: the seq_file structure being used to generate output
534  * @regs: an array if struct debugfs_reg32 structures
535  * @nregs: the length of the above array
536  * @base: the base address to be used in reading the registers
537  * @prefix: a string to be prefixed to every output line
538  *
539  * This function outputs a text block describing the current values of
540  * some 32-bit hardware registers. It is meant to be used within debugfs
541  * files based on seq_file that need to show registers, intermixed with other
542  * information. The prefix argument may be used to specify a leading string,
543  * because some peripherals have several blocks of identical registers,
544  * for example configuration of dma channels
545  */
546 int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
547                            int nregs, void __iomem *base, char *prefix)
548 {
549         int i, ret = 0;
550
551         for (i = 0; i < nregs; i++, regs++) {
552                 if (prefix)
553                         ret += seq_printf(s, "%s", prefix);
554                 ret += seq_printf(s, "%s = 0x%08x\n", regs->name,
555                                   readl(base + regs->offset));
556         }
557         return ret;
558 }
559 EXPORT_SYMBOL_GPL(debugfs_print_regs32);
560
561 static int debugfs_show_regset32(struct seq_file *s, void *data)
562 {
563         struct debugfs_regset32 *regset = s->private;
564
565         debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
566         return 0;
567 }
568
569 static int debugfs_open_regset32(struct inode *inode, struct file *file)
570 {
571         return single_open(file, debugfs_show_regset32, inode->i_private);
572 }
573
574 static const struct file_operations fops_regset32 = {
575         .open =         debugfs_open_regset32,
576         .read =         seq_read,
577         .llseek =       seq_lseek,
578         .release =      single_release,
579 };
580
581 /**
582  * debugfs_create_regset32 - create a debugfs file that returns register values
583  * @name: a pointer to a string containing the name of the file to create.
584  * @mode: the permission that the file should have
585  * @parent: a pointer to the parent dentry for this file.  This should be a
586  *          directory dentry if set.  If this parameter is %NULL, then the
587  *          file will be created in the root of the debugfs filesystem.
588  * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
589  *          to an array of register definitions, the array size and the base
590  *          address where the register bank is to be found.
591  *
592  * This function creates a file in debugfs with the given name that reports
593  * the names and values of a set of 32-bit registers. If the @mode variable
594  * is so set it can be read from. Writing is not supported.
595  *
596  * This function will return a pointer to a dentry if it succeeds.  This
597  * pointer must be passed to the debugfs_remove() function when the file is
598  * to be removed (no automatic cleanup happens if your module is unloaded,
599  * you are responsible here.)  If an error occurs, %NULL will be returned.
600  *
601  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
602  * returned.  It is not wise to check for this value, but rather, check for
603  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
604  * code.
605  */
606 struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
607                                        struct dentry *parent,
608                                        struct debugfs_regset32 *regset)
609 {
610         return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
611 }
612 EXPORT_SYMBOL_GPL(debugfs_create_regset32);
613
614 #endif /* CONFIG_HAS_IOMEM */