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 25 static ssize_t default_read_file(struct file *file, char __user *buf, 26 size_t count, loff_t *ppos) 27 { 28 return 0; 29 } 30 31 static 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 37 const 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 44 static 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 50 const struct inode_operations debugfs_link_operations = { 51 .readlink = generic_readlink, 52 .follow_link = debugfs_follow_link, 53 }; 54 55 static int debugfs_u8_set(void *data, u64 val) 56 { 57 *(u8 *)data = val; 58 return 0; 59 } 60 static int debugfs_u8_get(void *data, u64 *val) 61 { 62 *val = *(u8 *)data; 63 return 0; 64 } 65 DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n"); 66 DEFINE_SIMPLE_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n"); 67 DEFINE_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 */ 93 struct 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 } 105 EXPORT_SYMBOL_GPL(debugfs_create_u8); 106 107 static int debugfs_u16_set(void *data, u64 val) 108 { 109 *(u16 *)data = val; 110 return 0; 111 } 112 static int debugfs_u16_get(void *data, u64 *val) 113 { 114 *val = *(u16 *)data; 115 return 0; 116 } 117 DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n"); 118 DEFINE_SIMPLE_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n"); 119 DEFINE_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 */ 145 struct 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 } 157 EXPORT_SYMBOL_GPL(debugfs_create_u16); 158 159 static int debugfs_u32_set(void *data, u64 val) 160 { 161 *(u32 *)data = val; 162 return 0; 163 } 164 static int debugfs_u32_get(void *data, u64 *val) 165 { 166 *val = *(u32 *)data; 167 return 0; 168 } 169 DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n"); 170 DEFINE_SIMPLE_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n"); 171 DEFINE_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 */ 197 struct 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 } 209 EXPORT_SYMBOL_GPL(debugfs_create_u32); 210 211 static int debugfs_u64_set(void *data, u64 val) 212 { 213 *(u64 *)data = val; 214 return 0; 215 } 216 217 static int debugfs_u64_get(void *data, u64 *val) 218 { 219 *val = *(u64 *)data; 220 return 0; 221 } 222 DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n"); 223 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n"); 224 DEFINE_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 */ 250 struct 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 } 262 EXPORT_SYMBOL_GPL(debugfs_create_u64); 263 264 DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n"); 265 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n"); 266 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n"); 267 268 DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n"); 269 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n"); 270 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n"); 271 272 DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n"); 273 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n"); 274 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n"); 275 276 DEFINE_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 */ 296 struct 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 } 308 EXPORT_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 */ 320 struct 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 } 332 EXPORT_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 */ 344 struct 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 } 356 EXPORT_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 */ 368 struct 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 } 373 EXPORT_SYMBOL_GPL(debugfs_create_x64); 374 375 376 static int debugfs_size_t_set(void *data, u64 val) 377 { 378 *(size_t *)data = val; 379 return 0; 380 } 381 static int debugfs_size_t_get(void *data, u64 *val) 382 { 383 *val = *(size_t *)data; 384 return 0; 385 } 386 DEFINE_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 */ 399 struct 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 } 404 EXPORT_SYMBOL_GPL(debugfs_create_size_t); 405 406 407 static 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 422 static 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 440 static 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 */ 471 struct 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 } 476 EXPORT_SYMBOL_GPL(debugfs_create_bool); 477 478 static 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 486 static 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 */ 516 struct 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 } 522 EXPORT_SYMBOL_GPL(debugfs_create_blob); 523 524 struct array_data { 525 void *array; 526 u32 elements; 527 }; 528 529 static size_t u32_format_array(char *buf, size_t bufsize, 530 u32 *array, int array_size) 531 { 532 size_t ret = 0; 533 534 while (--array_size >= 0) { 535 size_t len; 536 char term = array_size ? ' ' : '\n'; 537 538 len = snprintf(buf, bufsize, "%u%c", *array++, term); 539 ret += len; 540 541 buf += len; 542 bufsize -= len; 543 } 544 return ret; 545 } 546 547 static int u32_array_open(struct inode *inode, struct file *file) 548 { 549 struct array_data *data = inode->i_private; 550 int size, elements = data->elements; 551 char *buf; 552 553 /* 554 * Max size: 555 * - 10 digits + ' '/'\n' = 11 bytes per number 556 * - terminating NUL character 557 */ 558 size = elements*11; 559 buf = kmalloc(size+1, GFP_KERNEL); 560 if (!buf) 561 return -ENOMEM; 562 buf[size] = 0; 563 564 file->private_data = buf; 565 u32_format_array(buf, size, data->array, data->elements); 566 567 return nonseekable_open(inode, file); 568 } 569 570 static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len, 571 loff_t *ppos) 572 { 573 size_t size = strlen(file->private_data); 574 575 return simple_read_from_buffer(buf, len, ppos, 576 file->private_data, size); 577 } 578 579 static int u32_array_release(struct inode *inode, struct file *file) 580 { 581 kfree(file->private_data); 582 583 return 0; 584 } 585 586 static const struct file_operations u32_array_fops = { 587 .owner = THIS_MODULE, 588 .open = u32_array_open, 589 .release = u32_array_release, 590 .read = u32_array_read, 591 .llseek = no_llseek, 592 }; 593 594 /** 595 * debugfs_create_u32_array - create a debugfs file that is used to read u32 596 * array. 597 * @name: a pointer to a string containing the name of the file to create. 598 * @mode: the permission that the file should have. 599 * @parent: a pointer to the parent dentry for this file. This should be a 600 * directory dentry if set. If this parameter is %NULL, then the 601 * file will be created in the root of the debugfs filesystem. 602 * @array: u32 array that provides data. 603 * @elements: total number of elements in the array. 604 * 605 * This function creates a file in debugfs with the given name that exports 606 * @array as data. If the @mode variable is so set it can be read from. 607 * Writing is not supported. Seek within the file is also not supported. 608 * Once array is created its size can not be changed. 609 * 610 * The function returns a pointer to dentry on success. If debugfs is not 611 * enabled in the kernel, the value -%ENODEV will be returned. 612 */ 613 struct dentry *debugfs_create_u32_array(const char *name, umode_t mode, 614 struct dentry *parent, 615 u32 *array, u32 elements) 616 { 617 struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL); 618 619 if (data == NULL) 620 return NULL; 621 622 data->array = array; 623 data->elements = elements; 624 625 return debugfs_create_file(name, mode, parent, data, &u32_array_fops); 626 } 627 EXPORT_SYMBOL_GPL(debugfs_create_u32_array); 628 629 #ifdef CONFIG_HAS_IOMEM 630 631 /* 632 * The regset32 stuff is used to print 32-bit registers using the 633 * seq_file utilities. We offer printing a register set in an already-opened 634 * sequential file or create a debugfs file that only prints a regset32. 635 */ 636 637 /** 638 * debugfs_print_regs32 - use seq_print to describe a set of registers 639 * @s: the seq_file structure being used to generate output 640 * @regs: an array if struct debugfs_reg32 structures 641 * @nregs: the length of the above array 642 * @base: the base address to be used in reading the registers 643 * @prefix: a string to be prefixed to every output line 644 * 645 * This function outputs a text block describing the current values of 646 * some 32-bit hardware registers. It is meant to be used within debugfs 647 * files based on seq_file that need to show registers, intermixed with other 648 * information. The prefix argument may be used to specify a leading string, 649 * because some peripherals have several blocks of identical registers, 650 * for example configuration of dma channels 651 */ 652 int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs, 653 int nregs, void __iomem *base, char *prefix) 654 { 655 int i, ret = 0; 656 657 for (i = 0; i < nregs; i++, regs++) { 658 if (prefix) 659 ret += seq_printf(s, "%s", prefix); 660 ret += seq_printf(s, "%s = 0x%08x\n", regs->name, 661 readl(base + regs->offset)); 662 } 663 return ret; 664 } 665 EXPORT_SYMBOL_GPL(debugfs_print_regs32); 666 667 static int debugfs_show_regset32(struct seq_file *s, void *data) 668 { 669 struct debugfs_regset32 *regset = s->private; 670 671 debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, ""); 672 return 0; 673 } 674 675 static int debugfs_open_regset32(struct inode *inode, struct file *file) 676 { 677 return single_open(file, debugfs_show_regset32, inode->i_private); 678 } 679 680 static const struct file_operations fops_regset32 = { 681 .open = debugfs_open_regset32, 682 .read = seq_read, 683 .llseek = seq_lseek, 684 .release = single_release, 685 }; 686 687 /** 688 * debugfs_create_regset32 - create a debugfs file that returns register values 689 * @name: a pointer to a string containing the name of the file to create. 690 * @mode: the permission that the file should have 691 * @parent: a pointer to the parent dentry for this file. This should be a 692 * directory dentry if set. If this parameter is %NULL, then the 693 * file will be created in the root of the debugfs filesystem. 694 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer 695 * to an array of register definitions, the array size and the base 696 * address where the register bank is to be found. 697 * 698 * This function creates a file in debugfs with the given name that reports 699 * the names and values of a set of 32-bit registers. If the @mode variable 700 * is so set it can be read from. Writing is not supported. 701 * 702 * This function will return a pointer to a dentry if it succeeds. This 703 * pointer must be passed to the debugfs_remove() function when the file is 704 * to be removed (no automatic cleanup happens if your module is unloaded, 705 * you are responsible here.) If an error occurs, %NULL will be returned. 706 * 707 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 708 * returned. It is not wise to check for this value, but rather, check for 709 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling 710 * code. 711 */ 712 struct dentry *debugfs_create_regset32(const char *name, umode_t mode, 713 struct dentry *parent, 714 struct debugfs_regset32 *regset) 715 { 716 return debugfs_create_file(name, mode, parent, regset, &fops_regset32); 717 } 718 EXPORT_SYMBOL_GPL(debugfs_create_regset32); 719 720 #endif /* CONFIG_HAS_IOMEM */ 721