1 /* 2 * sysfs.c - ACPI sysfs interface to userspace. 3 */ 4 5 #include <linux/init.h> 6 #include <linux/kernel.h> 7 #include <linux/moduleparam.h> 8 #include <acpi/acpi_drivers.h> 9 10 #define _COMPONENT ACPI_SYSTEM_COMPONENT 11 ACPI_MODULE_NAME("sysfs"); 12 13 #define PREFIX "ACPI: " 14 15 #ifdef CONFIG_ACPI_DEBUG 16 /* 17 * ACPI debug sysfs I/F, including: 18 * /sys/modules/acpi/parameters/debug_layer 19 * /sys/modules/acpi/parameters/debug_level 20 * /sys/modules/acpi/parameters/trace_method_name 21 * /sys/modules/acpi/parameters/trace_state 22 * /sys/modules/acpi/parameters/trace_debug_layer 23 * /sys/modules/acpi/parameters/trace_debug_level 24 */ 25 26 struct acpi_dlayer { 27 const char *name; 28 unsigned long value; 29 }; 30 struct acpi_dlevel { 31 const char *name; 32 unsigned long value; 33 }; 34 #define ACPI_DEBUG_INIT(v) { .name = #v, .value = v } 35 36 static const struct acpi_dlayer acpi_debug_layers[] = { 37 ACPI_DEBUG_INIT(ACPI_UTILITIES), 38 ACPI_DEBUG_INIT(ACPI_HARDWARE), 39 ACPI_DEBUG_INIT(ACPI_EVENTS), 40 ACPI_DEBUG_INIT(ACPI_TABLES), 41 ACPI_DEBUG_INIT(ACPI_NAMESPACE), 42 ACPI_DEBUG_INIT(ACPI_PARSER), 43 ACPI_DEBUG_INIT(ACPI_DISPATCHER), 44 ACPI_DEBUG_INIT(ACPI_EXECUTER), 45 ACPI_DEBUG_INIT(ACPI_RESOURCES), 46 ACPI_DEBUG_INIT(ACPI_CA_DEBUGGER), 47 ACPI_DEBUG_INIT(ACPI_OS_SERVICES), 48 ACPI_DEBUG_INIT(ACPI_CA_DISASSEMBLER), 49 ACPI_DEBUG_INIT(ACPI_COMPILER), 50 ACPI_DEBUG_INIT(ACPI_TOOLS), 51 52 ACPI_DEBUG_INIT(ACPI_BUS_COMPONENT), 53 ACPI_DEBUG_INIT(ACPI_AC_COMPONENT), 54 ACPI_DEBUG_INIT(ACPI_BATTERY_COMPONENT), 55 ACPI_DEBUG_INIT(ACPI_BUTTON_COMPONENT), 56 ACPI_DEBUG_INIT(ACPI_SBS_COMPONENT), 57 ACPI_DEBUG_INIT(ACPI_FAN_COMPONENT), 58 ACPI_DEBUG_INIT(ACPI_PCI_COMPONENT), 59 ACPI_DEBUG_INIT(ACPI_POWER_COMPONENT), 60 ACPI_DEBUG_INIT(ACPI_CONTAINER_COMPONENT), 61 ACPI_DEBUG_INIT(ACPI_SYSTEM_COMPONENT), 62 ACPI_DEBUG_INIT(ACPI_THERMAL_COMPONENT), 63 ACPI_DEBUG_INIT(ACPI_MEMORY_DEVICE_COMPONENT), 64 ACPI_DEBUG_INIT(ACPI_VIDEO_COMPONENT), 65 ACPI_DEBUG_INIT(ACPI_PROCESSOR_COMPONENT), 66 }; 67 68 static const struct acpi_dlevel acpi_debug_levels[] = { 69 ACPI_DEBUG_INIT(ACPI_LV_INIT), 70 ACPI_DEBUG_INIT(ACPI_LV_DEBUG_OBJECT), 71 ACPI_DEBUG_INIT(ACPI_LV_INFO), 72 73 ACPI_DEBUG_INIT(ACPI_LV_INIT_NAMES), 74 ACPI_DEBUG_INIT(ACPI_LV_PARSE), 75 ACPI_DEBUG_INIT(ACPI_LV_LOAD), 76 ACPI_DEBUG_INIT(ACPI_LV_DISPATCH), 77 ACPI_DEBUG_INIT(ACPI_LV_EXEC), 78 ACPI_DEBUG_INIT(ACPI_LV_NAMES), 79 ACPI_DEBUG_INIT(ACPI_LV_OPREGION), 80 ACPI_DEBUG_INIT(ACPI_LV_BFIELD), 81 ACPI_DEBUG_INIT(ACPI_LV_TABLES), 82 ACPI_DEBUG_INIT(ACPI_LV_VALUES), 83 ACPI_DEBUG_INIT(ACPI_LV_OBJECTS), 84 ACPI_DEBUG_INIT(ACPI_LV_RESOURCES), 85 ACPI_DEBUG_INIT(ACPI_LV_USER_REQUESTS), 86 ACPI_DEBUG_INIT(ACPI_LV_PACKAGE), 87 88 ACPI_DEBUG_INIT(ACPI_LV_ALLOCATIONS), 89 ACPI_DEBUG_INIT(ACPI_LV_FUNCTIONS), 90 ACPI_DEBUG_INIT(ACPI_LV_OPTIMIZATIONS), 91 92 ACPI_DEBUG_INIT(ACPI_LV_MUTEX), 93 ACPI_DEBUG_INIT(ACPI_LV_THREADS), 94 ACPI_DEBUG_INIT(ACPI_LV_IO), 95 ACPI_DEBUG_INIT(ACPI_LV_INTERRUPTS), 96 97 ACPI_DEBUG_INIT(ACPI_LV_AML_DISASSEMBLE), 98 ACPI_DEBUG_INIT(ACPI_LV_VERBOSE_INFO), 99 ACPI_DEBUG_INIT(ACPI_LV_FULL_TABLES), 100 ACPI_DEBUG_INIT(ACPI_LV_EVENTS), 101 }; 102 103 static int param_get_debug_layer(char *buffer, const struct kernel_param *kp) 104 { 105 int result = 0; 106 int i; 107 108 result = sprintf(buffer, "%-25s\tHex SET\n", "Description"); 109 110 for (i = 0; i < ARRAY_SIZE(acpi_debug_layers); i++) { 111 result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n", 112 acpi_debug_layers[i].name, 113 acpi_debug_layers[i].value, 114 (acpi_dbg_layer & acpi_debug_layers[i].value) 115 ? '*' : ' '); 116 } 117 result += 118 sprintf(buffer + result, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS", 119 ACPI_ALL_DRIVERS, 120 (acpi_dbg_layer & ACPI_ALL_DRIVERS) == 121 ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer & ACPI_ALL_DRIVERS) 122 == 0 ? ' ' : '-'); 123 result += 124 sprintf(buffer + result, 125 "--\ndebug_layer = 0x%08X ( * = enabled)\n", 126 acpi_dbg_layer); 127 128 return result; 129 } 130 131 static int param_get_debug_level(char *buffer, const struct kernel_param *kp) 132 { 133 int result = 0; 134 int i; 135 136 result = sprintf(buffer, "%-25s\tHex SET\n", "Description"); 137 138 for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) { 139 result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n", 140 acpi_debug_levels[i].name, 141 acpi_debug_levels[i].value, 142 (acpi_dbg_level & acpi_debug_levels[i].value) 143 ? '*' : ' '); 144 } 145 result += 146 sprintf(buffer + result, "--\ndebug_level = 0x%08X (* = enabled)\n", 147 acpi_dbg_level); 148 149 return result; 150 } 151 152 static struct kernel_param_ops param_ops_debug_layer = { 153 .set = param_set_uint, 154 .get = param_get_debug_layer, 155 }; 156 157 static struct kernel_param_ops param_ops_debug_level = { 158 .set = param_set_uint, 159 .get = param_get_debug_level, 160 }; 161 162 module_param_cb(debug_layer, ¶m_ops_debug_layer, &acpi_dbg_layer, 0644); 163 module_param_cb(debug_level, ¶m_ops_debug_level, &acpi_dbg_level, 0644); 164 165 static char trace_method_name[6]; 166 module_param_string(trace_method_name, trace_method_name, 6, 0644); 167 static unsigned int trace_debug_layer; 168 module_param(trace_debug_layer, uint, 0644); 169 static unsigned int trace_debug_level; 170 module_param(trace_debug_level, uint, 0644); 171 172 static int param_set_trace_state(const char *val, struct kernel_param *kp) 173 { 174 int result = 0; 175 176 if (!strncmp(val, "enable", strlen("enable") - 1)) { 177 result = acpi_debug_trace(trace_method_name, trace_debug_level, 178 trace_debug_layer, 0); 179 if (result) 180 result = -EBUSY; 181 goto exit; 182 } 183 184 if (!strncmp(val, "disable", strlen("disable") - 1)) { 185 int name = 0; 186 result = acpi_debug_trace((char *)&name, trace_debug_level, 187 trace_debug_layer, 0); 188 if (result) 189 result = -EBUSY; 190 goto exit; 191 } 192 193 if (!strncmp(val, "1", 1)) { 194 result = acpi_debug_trace(trace_method_name, trace_debug_level, 195 trace_debug_layer, 1); 196 if (result) 197 result = -EBUSY; 198 goto exit; 199 } 200 201 result = -EINVAL; 202 exit: 203 return result; 204 } 205 206 static int param_get_trace_state(char *buffer, struct kernel_param *kp) 207 { 208 if (!acpi_gbl_trace_method_name) 209 return sprintf(buffer, "disable"); 210 else { 211 if (acpi_gbl_trace_flags & 1) 212 return sprintf(buffer, "1"); 213 else 214 return sprintf(buffer, "enable"); 215 } 216 return 0; 217 } 218 219 module_param_call(trace_state, param_set_trace_state, param_get_trace_state, 220 NULL, 0644); 221 #endif /* CONFIG_ACPI_DEBUG */ 222 223 /* /sys/module/acpi/parameters/acpica_version */ 224 static int param_get_acpica_version(char *buffer, struct kernel_param *kp) 225 { 226 int result; 227 228 result = sprintf(buffer, "%x", ACPI_CA_VERSION); 229 230 return result; 231 } 232 233 module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444); 234 235 /* 236 * ACPI table sysfs I/F: 237 * /sys/firmware/acpi/tables/ 238 * /sys/firmware/acpi/tables/dynamic/ 239 */ 240 241 static LIST_HEAD(acpi_table_attr_list); 242 static struct kobject *tables_kobj; 243 static struct kobject *dynamic_tables_kobj; 244 245 struct acpi_table_attr { 246 struct bin_attribute attr; 247 char name[8]; 248 int instance; 249 struct list_head node; 250 }; 251 252 static ssize_t acpi_table_show(struct file *filp, struct kobject *kobj, 253 struct bin_attribute *bin_attr, char *buf, 254 loff_t offset, size_t count) 255 { 256 struct acpi_table_attr *table_attr = 257 container_of(bin_attr, struct acpi_table_attr, attr); 258 struct acpi_table_header *table_header = NULL; 259 acpi_status status; 260 char name[ACPI_NAME_SIZE]; 261 262 if (strncmp(table_attr->name, "NULL", 4)) 263 memcpy(name, table_attr->name, ACPI_NAME_SIZE); 264 else 265 memcpy(name, "\0\0\0\0", 4); 266 267 status = acpi_get_table(name, table_attr->instance, &table_header); 268 if (ACPI_FAILURE(status)) 269 return -ENODEV; 270 271 return memory_read_from_buffer(buf, count, &offset, 272 table_header, table_header->length); 273 } 274 275 static void acpi_table_attr_init(struct acpi_table_attr *table_attr, 276 struct acpi_table_header *table_header) 277 { 278 struct acpi_table_header *header = NULL; 279 struct acpi_table_attr *attr = NULL; 280 281 sysfs_attr_init(&table_attr->attr.attr); 282 if (table_header->signature[0] != '\0') 283 memcpy(table_attr->name, table_header->signature, 284 ACPI_NAME_SIZE); 285 else 286 memcpy(table_attr->name, "NULL", 4); 287 288 list_for_each_entry(attr, &acpi_table_attr_list, node) { 289 if (!memcmp(table_attr->name, attr->name, ACPI_NAME_SIZE)) 290 if (table_attr->instance < attr->instance) 291 table_attr->instance = attr->instance; 292 } 293 table_attr->instance++; 294 295 if (table_attr->instance > 1 || (table_attr->instance == 1 && 296 !acpi_get_table 297 (table_header->signature, 2, &header))) 298 sprintf(table_attr->name + ACPI_NAME_SIZE, "%d", 299 table_attr->instance); 300 301 table_attr->attr.size = 0; 302 table_attr->attr.read = acpi_table_show; 303 table_attr->attr.attr.name = table_attr->name; 304 table_attr->attr.attr.mode = 0400; 305 306 return; 307 } 308 309 static acpi_status 310 acpi_sysfs_table_handler(u32 event, void *table, void *context) 311 { 312 struct acpi_table_attr *table_attr; 313 314 switch (event) { 315 case ACPI_TABLE_EVENT_LOAD: 316 table_attr = 317 kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL); 318 if (!table_attr) 319 return AE_NO_MEMORY; 320 321 acpi_table_attr_init(table_attr, table); 322 if (sysfs_create_bin_file(dynamic_tables_kobj, 323 &table_attr->attr)) { 324 kfree(table_attr); 325 return AE_ERROR; 326 } else 327 list_add_tail(&table_attr->node, &acpi_table_attr_list); 328 break; 329 case ACPI_TABLE_EVENT_UNLOAD: 330 /* 331 * we do not need to do anything right now 332 * because the table is not deleted from the 333 * global table list when unloading it. 334 */ 335 break; 336 default: 337 return AE_BAD_PARAMETER; 338 } 339 return AE_OK; 340 } 341 342 static int acpi_tables_sysfs_init(void) 343 { 344 struct acpi_table_attr *table_attr; 345 struct acpi_table_header *table_header = NULL; 346 int table_index = 0; 347 int result; 348 349 tables_kobj = kobject_create_and_add("tables", acpi_kobj); 350 if (!tables_kobj) 351 goto err; 352 353 dynamic_tables_kobj = kobject_create_and_add("dynamic", tables_kobj); 354 if (!dynamic_tables_kobj) 355 goto err_dynamic_tables; 356 357 do { 358 result = acpi_get_table_by_index(table_index, &table_header); 359 if (!result) { 360 table_index++; 361 table_attr = NULL; 362 table_attr = 363 kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL); 364 if (!table_attr) 365 return -ENOMEM; 366 367 acpi_table_attr_init(table_attr, table_header); 368 result = 369 sysfs_create_bin_file(tables_kobj, 370 &table_attr->attr); 371 if (result) { 372 kfree(table_attr); 373 return result; 374 } else 375 list_add_tail(&table_attr->node, 376 &acpi_table_attr_list); 377 } 378 } while (!result); 379 kobject_uevent(tables_kobj, KOBJ_ADD); 380 kobject_uevent(dynamic_tables_kobj, KOBJ_ADD); 381 result = acpi_install_table_handler(acpi_sysfs_table_handler, NULL); 382 383 return result == AE_OK ? 0 : -EINVAL; 384 err_dynamic_tables: 385 kobject_put(tables_kobj); 386 err: 387 return -ENOMEM; 388 } 389 390 /* 391 * Detailed ACPI IRQ counters: 392 * /sys/firmware/acpi/interrupts/ 393 */ 394 395 u32 acpi_irq_handled; 396 u32 acpi_irq_not_handled; 397 398 #define COUNT_GPE 0 399 #define COUNT_SCI 1 /* acpi_irq_handled */ 400 #define COUNT_SCI_NOT 2 /* acpi_irq_not_handled */ 401 #define COUNT_ERROR 3 /* other */ 402 #define NUM_COUNTERS_EXTRA 4 403 404 struct event_counter { 405 u32 count; 406 u32 flags; 407 }; 408 409 static struct event_counter *all_counters; 410 static u32 num_gpes; 411 static u32 num_counters; 412 static struct attribute **all_attrs; 413 static u32 acpi_gpe_count; 414 415 static struct attribute_group interrupt_stats_attr_group = { 416 .name = "interrupts", 417 }; 418 419 static struct kobj_attribute *counter_attrs; 420 421 static void delete_gpe_attr_array(void) 422 { 423 struct event_counter *tmp = all_counters; 424 425 all_counters = NULL; 426 kfree(tmp); 427 428 if (counter_attrs) { 429 int i; 430 431 for (i = 0; i < num_gpes; i++) 432 kfree(counter_attrs[i].attr.name); 433 434 kfree(counter_attrs); 435 } 436 kfree(all_attrs); 437 438 return; 439 } 440 441 static void gpe_count(u32 gpe_number) 442 { 443 acpi_gpe_count++; 444 445 if (!all_counters) 446 return; 447 448 if (gpe_number < num_gpes) 449 all_counters[gpe_number].count++; 450 else 451 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + 452 COUNT_ERROR].count++; 453 454 return; 455 } 456 457 static void fixed_event_count(u32 event_number) 458 { 459 if (!all_counters) 460 return; 461 462 if (event_number < ACPI_NUM_FIXED_EVENTS) 463 all_counters[num_gpes + event_number].count++; 464 else 465 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + 466 COUNT_ERROR].count++; 467 468 return; 469 } 470 471 static void acpi_gbl_event_handler(u32 event_type, acpi_handle device, 472 u32 event_number, void *context) 473 { 474 if (event_type == ACPI_EVENT_TYPE_GPE) 475 gpe_count(event_number); 476 477 if (event_type == ACPI_EVENT_TYPE_FIXED) 478 fixed_event_count(event_number); 479 } 480 481 static int get_status(u32 index, acpi_event_status *status, 482 acpi_handle *handle) 483 { 484 int result = 0; 485 486 if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS) 487 goto end; 488 489 if (index < num_gpes) { 490 result = acpi_get_gpe_device(index, handle); 491 if (result) { 492 ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND, 493 "Invalid GPE 0x%x\n", index)); 494 goto end; 495 } 496 result = acpi_get_gpe_status(*handle, index, status); 497 } else if (index < (num_gpes + ACPI_NUM_FIXED_EVENTS)) 498 result = acpi_get_event_status(index - num_gpes, status); 499 500 end: 501 return result; 502 } 503 504 static ssize_t counter_show(struct kobject *kobj, 505 struct kobj_attribute *attr, char *buf) 506 { 507 int index = attr - counter_attrs; 508 int size; 509 acpi_handle handle; 510 acpi_event_status status; 511 int result = 0; 512 513 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI].count = 514 acpi_irq_handled; 515 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT].count = 516 acpi_irq_not_handled; 517 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE].count = 518 acpi_gpe_count; 519 size = sprintf(buf, "%8d", all_counters[index].count); 520 521 /* "gpe_all" or "sci" */ 522 if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS) 523 goto end; 524 525 result = get_status(index, &status, &handle); 526 if (result) 527 goto end; 528 529 if (!(status & ACPI_EVENT_FLAG_HANDLE)) 530 size += sprintf(buf + size, " invalid"); 531 else if (status & ACPI_EVENT_FLAG_ENABLED) 532 size += sprintf(buf + size, " enabled"); 533 else if (status & ACPI_EVENT_FLAG_WAKE_ENABLED) 534 size += sprintf(buf + size, " wake_enabled"); 535 else 536 size += sprintf(buf + size, " disabled"); 537 538 end: 539 size += sprintf(buf + size, "\n"); 540 return result ? result : size; 541 } 542 543 /* 544 * counter_set() sets the specified counter. 545 * setting the total "sci" file to any value clears all counters. 546 * enable/disable/clear a gpe/fixed event in user space. 547 */ 548 static ssize_t counter_set(struct kobject *kobj, 549 struct kobj_attribute *attr, const char *buf, 550 size_t size) 551 { 552 int index = attr - counter_attrs; 553 acpi_event_status status; 554 acpi_handle handle; 555 int result = 0; 556 557 if (index == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) { 558 int i; 559 for (i = 0; i < num_counters; ++i) 560 all_counters[i].count = 0; 561 acpi_gpe_count = 0; 562 acpi_irq_handled = 0; 563 acpi_irq_not_handled = 0; 564 goto end; 565 } 566 567 /* show the event status for both GPEs and Fixed Events */ 568 result = get_status(index, &status, &handle); 569 if (result) 570 goto end; 571 572 if (!(status & ACPI_EVENT_FLAG_HANDLE)) { 573 printk(KERN_WARNING PREFIX 574 "Can not change Invalid GPE/Fixed Event status\n"); 575 return -EINVAL; 576 } 577 578 if (index < num_gpes) { 579 if (!strcmp(buf, "disable\n") && 580 (status & ACPI_EVENT_FLAG_ENABLED)) 581 result = acpi_disable_gpe(handle, index); 582 else if (!strcmp(buf, "enable\n") && 583 !(status & ACPI_EVENT_FLAG_ENABLED)) 584 result = acpi_enable_gpe(handle, index); 585 else if (!strcmp(buf, "clear\n") && 586 (status & ACPI_EVENT_FLAG_SET)) 587 result = acpi_clear_gpe(handle, index); 588 else 589 all_counters[index].count = strtoul(buf, NULL, 0); 590 } else if (index < num_gpes + ACPI_NUM_FIXED_EVENTS) { 591 int event = index - num_gpes; 592 if (!strcmp(buf, "disable\n") && 593 (status & ACPI_EVENT_FLAG_ENABLED)) 594 result = acpi_disable_event(event, ACPI_NOT_ISR); 595 else if (!strcmp(buf, "enable\n") && 596 !(status & ACPI_EVENT_FLAG_ENABLED)) 597 result = acpi_enable_event(event, ACPI_NOT_ISR); 598 else if (!strcmp(buf, "clear\n") && 599 (status & ACPI_EVENT_FLAG_SET)) 600 result = acpi_clear_event(event); 601 else 602 all_counters[index].count = strtoul(buf, NULL, 0); 603 } else 604 all_counters[index].count = strtoul(buf, NULL, 0); 605 606 if (ACPI_FAILURE(result)) 607 result = -EINVAL; 608 end: 609 return result ? result : size; 610 } 611 612 void acpi_irq_stats_init(void) 613 { 614 acpi_status status; 615 int i; 616 617 if (all_counters) 618 return; 619 620 num_gpes = acpi_current_gpe_count; 621 num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA; 622 623 all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1), 624 GFP_KERNEL); 625 if (all_attrs == NULL) 626 return; 627 628 all_counters = kzalloc(sizeof(struct event_counter) * (num_counters), 629 GFP_KERNEL); 630 if (all_counters == NULL) 631 goto fail; 632 633 status = acpi_install_global_event_handler(acpi_gbl_event_handler, NULL); 634 if (ACPI_FAILURE(status)) 635 goto fail; 636 637 counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters), 638 GFP_KERNEL); 639 if (counter_attrs == NULL) 640 goto fail; 641 642 for (i = 0; i < num_counters; ++i) { 643 char buffer[12]; 644 char *name; 645 646 if (i < num_gpes) 647 sprintf(buffer, "gpe%02X", i); 648 else if (i == num_gpes + ACPI_EVENT_PMTIMER) 649 sprintf(buffer, "ff_pmtimer"); 650 else if (i == num_gpes + ACPI_EVENT_GLOBAL) 651 sprintf(buffer, "ff_gbl_lock"); 652 else if (i == num_gpes + ACPI_EVENT_POWER_BUTTON) 653 sprintf(buffer, "ff_pwr_btn"); 654 else if (i == num_gpes + ACPI_EVENT_SLEEP_BUTTON) 655 sprintf(buffer, "ff_slp_btn"); 656 else if (i == num_gpes + ACPI_EVENT_RTC) 657 sprintf(buffer, "ff_rt_clk"); 658 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE) 659 sprintf(buffer, "gpe_all"); 660 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) 661 sprintf(buffer, "sci"); 662 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT) 663 sprintf(buffer, "sci_not"); 664 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR) 665 sprintf(buffer, "error"); 666 else 667 sprintf(buffer, "bug%02X", i); 668 669 name = kzalloc(strlen(buffer) + 1, GFP_KERNEL); 670 if (name == NULL) 671 goto fail; 672 strncpy(name, buffer, strlen(buffer) + 1); 673 674 sysfs_attr_init(&counter_attrs[i].attr); 675 counter_attrs[i].attr.name = name; 676 counter_attrs[i].attr.mode = 0644; 677 counter_attrs[i].show = counter_show; 678 counter_attrs[i].store = counter_set; 679 680 all_attrs[i] = &counter_attrs[i].attr; 681 } 682 683 interrupt_stats_attr_group.attrs = all_attrs; 684 if (!sysfs_create_group(acpi_kobj, &interrupt_stats_attr_group)) 685 return; 686 687 fail: 688 delete_gpe_attr_array(); 689 return; 690 } 691 692 static void __exit interrupt_stats_exit(void) 693 { 694 sysfs_remove_group(acpi_kobj, &interrupt_stats_attr_group); 695 696 delete_gpe_attr_array(); 697 698 return; 699 } 700 701 int __init acpi_sysfs_init(void) 702 { 703 int result; 704 705 result = acpi_tables_sysfs_init(); 706 707 return result; 708 } 709