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 */ 615