1 /* 2 * sysfs.c - ACPI sysfs interface to userspace. 3 */ 4 5 #define pr_fmt(fmt) "ACPI: " fmt 6 7 #include <linux/init.h> 8 #include <linux/kernel.h> 9 #include <linux/moduleparam.h> 10 #include <linux/acpi.h> 11 12 #include "internal.h" 13 14 #define _COMPONENT ACPI_SYSTEM_COMPONENT 15 ACPI_MODULE_NAME("sysfs"); 16 17 #ifdef CONFIG_ACPI_DEBUG 18 /* 19 * ACPI debug sysfs I/F, including: 20 * /sys/modules/acpi/parameters/debug_layer 21 * /sys/modules/acpi/parameters/debug_level 22 * /sys/modules/acpi/parameters/trace_method_name 23 * /sys/modules/acpi/parameters/trace_state 24 * /sys/modules/acpi/parameters/trace_debug_layer 25 * /sys/modules/acpi/parameters/trace_debug_level 26 */ 27 28 struct acpi_dlayer { 29 const char *name; 30 unsigned long value; 31 }; 32 struct acpi_dlevel { 33 const char *name; 34 unsigned long value; 35 }; 36 #define ACPI_DEBUG_INIT(v) { .name = #v, .value = v } 37 38 static const struct acpi_dlayer acpi_debug_layers[] = { 39 ACPI_DEBUG_INIT(ACPI_UTILITIES), 40 ACPI_DEBUG_INIT(ACPI_HARDWARE), 41 ACPI_DEBUG_INIT(ACPI_EVENTS), 42 ACPI_DEBUG_INIT(ACPI_TABLES), 43 ACPI_DEBUG_INIT(ACPI_NAMESPACE), 44 ACPI_DEBUG_INIT(ACPI_PARSER), 45 ACPI_DEBUG_INIT(ACPI_DISPATCHER), 46 ACPI_DEBUG_INIT(ACPI_EXECUTER), 47 ACPI_DEBUG_INIT(ACPI_RESOURCES), 48 ACPI_DEBUG_INIT(ACPI_CA_DEBUGGER), 49 ACPI_DEBUG_INIT(ACPI_OS_SERVICES), 50 ACPI_DEBUG_INIT(ACPI_CA_DISASSEMBLER), 51 ACPI_DEBUG_INIT(ACPI_COMPILER), 52 ACPI_DEBUG_INIT(ACPI_TOOLS), 53 54 ACPI_DEBUG_INIT(ACPI_BUS_COMPONENT), 55 ACPI_DEBUG_INIT(ACPI_AC_COMPONENT), 56 ACPI_DEBUG_INIT(ACPI_BATTERY_COMPONENT), 57 ACPI_DEBUG_INIT(ACPI_BUTTON_COMPONENT), 58 ACPI_DEBUG_INIT(ACPI_SBS_COMPONENT), 59 ACPI_DEBUG_INIT(ACPI_FAN_COMPONENT), 60 ACPI_DEBUG_INIT(ACPI_PCI_COMPONENT), 61 ACPI_DEBUG_INIT(ACPI_POWER_COMPONENT), 62 ACPI_DEBUG_INIT(ACPI_CONTAINER_COMPONENT), 63 ACPI_DEBUG_INIT(ACPI_SYSTEM_COMPONENT), 64 ACPI_DEBUG_INIT(ACPI_THERMAL_COMPONENT), 65 ACPI_DEBUG_INIT(ACPI_MEMORY_DEVICE_COMPONENT), 66 ACPI_DEBUG_INIT(ACPI_VIDEO_COMPONENT), 67 ACPI_DEBUG_INIT(ACPI_PROCESSOR_COMPONENT), 68 }; 69 70 static const struct acpi_dlevel acpi_debug_levels[] = { 71 ACPI_DEBUG_INIT(ACPI_LV_INIT), 72 ACPI_DEBUG_INIT(ACPI_LV_DEBUG_OBJECT), 73 ACPI_DEBUG_INIT(ACPI_LV_INFO), 74 ACPI_DEBUG_INIT(ACPI_LV_REPAIR), 75 ACPI_DEBUG_INIT(ACPI_LV_TRACE_POINT), 76 77 ACPI_DEBUG_INIT(ACPI_LV_INIT_NAMES), 78 ACPI_DEBUG_INIT(ACPI_LV_PARSE), 79 ACPI_DEBUG_INIT(ACPI_LV_LOAD), 80 ACPI_DEBUG_INIT(ACPI_LV_DISPATCH), 81 ACPI_DEBUG_INIT(ACPI_LV_EXEC), 82 ACPI_DEBUG_INIT(ACPI_LV_NAMES), 83 ACPI_DEBUG_INIT(ACPI_LV_OPREGION), 84 ACPI_DEBUG_INIT(ACPI_LV_BFIELD), 85 ACPI_DEBUG_INIT(ACPI_LV_TABLES), 86 ACPI_DEBUG_INIT(ACPI_LV_VALUES), 87 ACPI_DEBUG_INIT(ACPI_LV_OBJECTS), 88 ACPI_DEBUG_INIT(ACPI_LV_RESOURCES), 89 ACPI_DEBUG_INIT(ACPI_LV_USER_REQUESTS), 90 ACPI_DEBUG_INIT(ACPI_LV_PACKAGE), 91 92 ACPI_DEBUG_INIT(ACPI_LV_ALLOCATIONS), 93 ACPI_DEBUG_INIT(ACPI_LV_FUNCTIONS), 94 ACPI_DEBUG_INIT(ACPI_LV_OPTIMIZATIONS), 95 96 ACPI_DEBUG_INIT(ACPI_LV_MUTEX), 97 ACPI_DEBUG_INIT(ACPI_LV_THREADS), 98 ACPI_DEBUG_INIT(ACPI_LV_IO), 99 ACPI_DEBUG_INIT(ACPI_LV_INTERRUPTS), 100 101 ACPI_DEBUG_INIT(ACPI_LV_AML_DISASSEMBLE), 102 ACPI_DEBUG_INIT(ACPI_LV_VERBOSE_INFO), 103 ACPI_DEBUG_INIT(ACPI_LV_FULL_TABLES), 104 ACPI_DEBUG_INIT(ACPI_LV_EVENTS), 105 }; 106 107 static int param_get_debug_layer(char *buffer, const struct kernel_param *kp) 108 { 109 int result = 0; 110 int i; 111 112 result = sprintf(buffer, "%-25s\tHex SET\n", "Description"); 113 114 for (i = 0; i < ARRAY_SIZE(acpi_debug_layers); i++) { 115 result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n", 116 acpi_debug_layers[i].name, 117 acpi_debug_layers[i].value, 118 (acpi_dbg_layer & acpi_debug_layers[i].value) 119 ? '*' : ' '); 120 } 121 result += 122 sprintf(buffer + result, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS", 123 ACPI_ALL_DRIVERS, 124 (acpi_dbg_layer & ACPI_ALL_DRIVERS) == 125 ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer & ACPI_ALL_DRIVERS) 126 == 0 ? ' ' : '-'); 127 result += 128 sprintf(buffer + result, 129 "--\ndebug_layer = 0x%08X ( * = enabled)\n", 130 acpi_dbg_layer); 131 132 return result; 133 } 134 135 static int param_get_debug_level(char *buffer, const struct kernel_param *kp) 136 { 137 int result = 0; 138 int i; 139 140 result = sprintf(buffer, "%-25s\tHex SET\n", "Description"); 141 142 for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) { 143 result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n", 144 acpi_debug_levels[i].name, 145 acpi_debug_levels[i].value, 146 (acpi_dbg_level & acpi_debug_levels[i].value) 147 ? '*' : ' '); 148 } 149 result += 150 sprintf(buffer + result, "--\ndebug_level = 0x%08X (* = enabled)\n", 151 acpi_dbg_level); 152 153 return result; 154 } 155 156 static const struct kernel_param_ops param_ops_debug_layer = { 157 .set = param_set_uint, 158 .get = param_get_debug_layer, 159 }; 160 161 static const struct kernel_param_ops param_ops_debug_level = { 162 .set = param_set_uint, 163 .get = param_get_debug_level, 164 }; 165 166 module_param_cb(debug_layer, ¶m_ops_debug_layer, &acpi_dbg_layer, 0644); 167 module_param_cb(debug_level, ¶m_ops_debug_level, &acpi_dbg_level, 0644); 168 169 static char trace_method_name[1024]; 170 171 int param_set_trace_method_name(const char *val, const struct kernel_param *kp) 172 { 173 u32 saved_flags = 0; 174 bool is_abs_path = true; 175 176 if (*val != '\\') 177 is_abs_path = false; 178 179 if ((is_abs_path && strlen(val) > 1023) || 180 (!is_abs_path && strlen(val) > 1022)) { 181 pr_err("%s: string parameter too long\n", kp->name); 182 return -ENOSPC; 183 } 184 185 /* 186 * It's not safe to update acpi_gbl_trace_method_name without 187 * having the tracer stopped, so we save the original tracer 188 * state and disable it. 189 */ 190 saved_flags = acpi_gbl_trace_flags; 191 (void)acpi_debug_trace(NULL, 192 acpi_gbl_trace_dbg_level, 193 acpi_gbl_trace_dbg_layer, 194 0); 195 196 /* This is a hack. We can't kmalloc in early boot. */ 197 if (is_abs_path) 198 strcpy(trace_method_name, val); 199 else { 200 trace_method_name[0] = '\\'; 201 strcpy(trace_method_name+1, val); 202 } 203 204 /* Restore the original tracer state */ 205 (void)acpi_debug_trace(trace_method_name, 206 acpi_gbl_trace_dbg_level, 207 acpi_gbl_trace_dbg_layer, 208 saved_flags); 209 210 return 0; 211 } 212 213 static int param_get_trace_method_name(char *buffer, const struct kernel_param *kp) 214 { 215 return scnprintf(buffer, PAGE_SIZE, "%s", acpi_gbl_trace_method_name); 216 } 217 218 static const struct kernel_param_ops param_ops_trace_method = { 219 .set = param_set_trace_method_name, 220 .get = param_get_trace_method_name, 221 }; 222 223 static const struct kernel_param_ops param_ops_trace_attrib = { 224 .set = param_set_uint, 225 .get = param_get_uint, 226 }; 227 228 module_param_cb(trace_method_name, ¶m_ops_trace_method, &trace_method_name, 0644); 229 module_param_cb(trace_debug_layer, ¶m_ops_trace_attrib, &acpi_gbl_trace_dbg_layer, 0644); 230 module_param_cb(trace_debug_level, ¶m_ops_trace_attrib, &acpi_gbl_trace_dbg_level, 0644); 231 232 static int param_set_trace_state(const char *val, struct kernel_param *kp) 233 { 234 acpi_status status; 235 const char *method = trace_method_name; 236 u32 flags = 0; 237 238 /* So "xxx-once" comparison should go prior than "xxx" comparison */ 239 #define acpi_compare_param(val, key) \ 240 strncmp((val), (key), sizeof(key) - 1) 241 242 if (!acpi_compare_param(val, "enable")) { 243 method = NULL; 244 flags = ACPI_TRACE_ENABLED; 245 } else if (!acpi_compare_param(val, "disable")) 246 method = NULL; 247 else if (!acpi_compare_param(val, "method-once")) 248 flags = ACPI_TRACE_ENABLED | ACPI_TRACE_ONESHOT; 249 else if (!acpi_compare_param(val, "method")) 250 flags = ACPI_TRACE_ENABLED; 251 else if (!acpi_compare_param(val, "opcode-once")) 252 flags = ACPI_TRACE_ENABLED | ACPI_TRACE_ONESHOT | ACPI_TRACE_OPCODE; 253 else if (!acpi_compare_param(val, "opcode")) 254 flags = ACPI_TRACE_ENABLED | ACPI_TRACE_OPCODE; 255 else 256 return -EINVAL; 257 258 status = acpi_debug_trace(method, 259 acpi_gbl_trace_dbg_level, 260 acpi_gbl_trace_dbg_layer, 261 flags); 262 if (ACPI_FAILURE(status)) 263 return -EBUSY; 264 265 return 0; 266 } 267 268 static int param_get_trace_state(char *buffer, struct kernel_param *kp) 269 { 270 if (!(acpi_gbl_trace_flags & ACPI_TRACE_ENABLED)) 271 return sprintf(buffer, "disable"); 272 else { 273 if (acpi_gbl_trace_method_name) { 274 if (acpi_gbl_trace_flags & ACPI_TRACE_ONESHOT) 275 return sprintf(buffer, "method-once"); 276 else 277 return sprintf(buffer, "method"); 278 } else 279 return sprintf(buffer, "enable"); 280 } 281 return 0; 282 } 283 284 module_param_call(trace_state, param_set_trace_state, param_get_trace_state, 285 NULL, 0644); 286 #endif /* CONFIG_ACPI_DEBUG */ 287 288 289 /* /sys/modules/acpi/parameters/aml_debug_output */ 290 291 module_param_named(aml_debug_output, acpi_gbl_enable_aml_debug_object, 292 byte, 0644); 293 MODULE_PARM_DESC(aml_debug_output, 294 "To enable/disable the ACPI Debug Object output."); 295 296 /* /sys/module/acpi/parameters/acpica_version */ 297 static int param_get_acpica_version(char *buffer, struct kernel_param *kp) 298 { 299 int result; 300 301 result = sprintf(buffer, "%x", ACPI_CA_VERSION); 302 303 return result; 304 } 305 306 module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444); 307 308 /* 309 * ACPI table sysfs I/F: 310 * /sys/firmware/acpi/tables/ 311 * /sys/firmware/acpi/tables/data/ 312 * /sys/firmware/acpi/tables/dynamic/ 313 */ 314 315 static LIST_HEAD(acpi_table_attr_list); 316 static struct kobject *tables_kobj; 317 static struct kobject *tables_data_kobj; 318 static struct kobject *dynamic_tables_kobj; 319 static struct kobject *hotplug_kobj; 320 321 #define ACPI_MAX_TABLE_INSTANCES 999 322 #define ACPI_INST_SIZE 4 /* including trailing 0 */ 323 324 struct acpi_table_attr { 325 struct bin_attribute attr; 326 char name[ACPI_NAME_SIZE]; 327 int instance; 328 char filename[ACPI_NAME_SIZE+ACPI_INST_SIZE]; 329 struct list_head node; 330 }; 331 332 struct acpi_data_attr { 333 struct bin_attribute attr; 334 u64 addr; 335 }; 336 337 static ssize_t acpi_table_show(struct file *filp, struct kobject *kobj, 338 struct bin_attribute *bin_attr, char *buf, 339 loff_t offset, size_t count) 340 { 341 struct acpi_table_attr *table_attr = 342 container_of(bin_attr, struct acpi_table_attr, attr); 343 struct acpi_table_header *table_header = NULL; 344 acpi_status status; 345 ssize_t rc; 346 347 status = acpi_get_table(table_attr->name, table_attr->instance, 348 &table_header); 349 if (ACPI_FAILURE(status)) 350 return -ENODEV; 351 352 rc = memory_read_from_buffer(buf, count, &offset, table_header, 353 table_header->length); 354 acpi_put_table(table_header); 355 return rc; 356 } 357 358 static int acpi_table_attr_init(struct kobject *tables_obj, 359 struct acpi_table_attr *table_attr, 360 struct acpi_table_header *table_header) 361 { 362 struct acpi_table_header *header = NULL; 363 struct acpi_table_attr *attr = NULL; 364 char instance_str[ACPI_INST_SIZE]; 365 366 sysfs_attr_init(&table_attr->attr.attr); 367 ACPI_MOVE_NAME(table_attr->name, table_header->signature); 368 369 list_for_each_entry(attr, &acpi_table_attr_list, node) { 370 if (ACPI_COMPARE_NAME(table_attr->name, attr->name)) 371 if (table_attr->instance < attr->instance) 372 table_attr->instance = attr->instance; 373 } 374 table_attr->instance++; 375 if (table_attr->instance > ACPI_MAX_TABLE_INSTANCES) { 376 pr_warn("%4.4s: too many table instances\n", 377 table_attr->name); 378 return -ERANGE; 379 } 380 381 ACPI_MOVE_NAME(table_attr->filename, table_header->signature); 382 table_attr->filename[ACPI_NAME_SIZE] = '\0'; 383 if (table_attr->instance > 1 || (table_attr->instance == 1 && 384 !acpi_get_table 385 (table_header->signature, 2, &header))) { 386 snprintf(instance_str, sizeof(instance_str), "%u", 387 table_attr->instance); 388 strcat(table_attr->filename, instance_str); 389 } 390 391 table_attr->attr.size = table_header->length; 392 table_attr->attr.read = acpi_table_show; 393 table_attr->attr.attr.name = table_attr->filename; 394 table_attr->attr.attr.mode = 0400; 395 396 return sysfs_create_bin_file(tables_obj, &table_attr->attr); 397 } 398 399 acpi_status acpi_sysfs_table_handler(u32 event, void *table, void *context) 400 { 401 struct acpi_table_attr *table_attr; 402 403 switch (event) { 404 case ACPI_TABLE_EVENT_INSTALL: 405 table_attr = 406 kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL); 407 if (!table_attr) 408 return AE_NO_MEMORY; 409 410 if (acpi_table_attr_init(dynamic_tables_kobj, 411 table_attr, table)) { 412 kfree(table_attr); 413 return AE_ERROR; 414 } 415 list_add_tail(&table_attr->node, &acpi_table_attr_list); 416 break; 417 case ACPI_TABLE_EVENT_LOAD: 418 case ACPI_TABLE_EVENT_UNLOAD: 419 case ACPI_TABLE_EVENT_UNINSTALL: 420 /* 421 * we do not need to do anything right now 422 * because the table is not deleted from the 423 * global table list when unloading it. 424 */ 425 break; 426 default: 427 return AE_BAD_PARAMETER; 428 } 429 return AE_OK; 430 } 431 432 static ssize_t acpi_data_show(struct file *filp, struct kobject *kobj, 433 struct bin_attribute *bin_attr, char *buf, 434 loff_t offset, size_t count) 435 { 436 struct acpi_data_attr *data_attr; 437 void __iomem *base; 438 ssize_t rc; 439 440 data_attr = container_of(bin_attr, struct acpi_data_attr, attr); 441 442 base = acpi_os_map_memory(data_attr->addr, data_attr->attr.size); 443 if (!base) 444 return -ENOMEM; 445 rc = memory_read_from_buffer(buf, count, &offset, base, 446 data_attr->attr.size); 447 acpi_os_unmap_memory(base, data_attr->attr.size); 448 449 return rc; 450 } 451 452 static int acpi_bert_data_init(void *th, struct acpi_data_attr *data_attr) 453 { 454 struct acpi_table_bert *bert = th; 455 456 if (bert->header.length < sizeof(struct acpi_table_bert) || 457 bert->region_length < sizeof(struct acpi_hest_generic_status)) { 458 kfree(data_attr); 459 return -EINVAL; 460 } 461 data_attr->addr = bert->address; 462 data_attr->attr.size = bert->region_length; 463 data_attr->attr.attr.name = "BERT"; 464 465 return sysfs_create_bin_file(tables_data_kobj, &data_attr->attr); 466 } 467 468 static struct acpi_data_obj { 469 char *name; 470 int (*fn)(void *, struct acpi_data_attr *); 471 } acpi_data_objs[] = { 472 { ACPI_SIG_BERT, acpi_bert_data_init }, 473 }; 474 475 #define NUM_ACPI_DATA_OBJS ARRAY_SIZE(acpi_data_objs) 476 477 static int acpi_table_data_init(struct acpi_table_header *th) 478 { 479 struct acpi_data_attr *data_attr; 480 int i; 481 482 for (i = 0; i < NUM_ACPI_DATA_OBJS; i++) { 483 if (ACPI_COMPARE_NAME(th->signature, acpi_data_objs[i].name)) { 484 data_attr = kzalloc(sizeof(*data_attr), GFP_KERNEL); 485 if (!data_attr) 486 return -ENOMEM; 487 sysfs_attr_init(&data_attr->attr.attr); 488 data_attr->attr.read = acpi_data_show; 489 data_attr->attr.attr.mode = 0400; 490 return acpi_data_objs[i].fn(th, data_attr); 491 } 492 } 493 return 0; 494 } 495 496 static int acpi_tables_sysfs_init(void) 497 { 498 struct acpi_table_attr *table_attr; 499 struct acpi_table_header *table_header = NULL; 500 int table_index; 501 acpi_status status; 502 int ret; 503 504 tables_kobj = kobject_create_and_add("tables", acpi_kobj); 505 if (!tables_kobj) 506 goto err; 507 508 tables_data_kobj = kobject_create_and_add("data", tables_kobj); 509 if (!tables_data_kobj) 510 goto err_tables_data; 511 512 dynamic_tables_kobj = kobject_create_and_add("dynamic", tables_kobj); 513 if (!dynamic_tables_kobj) 514 goto err_dynamic_tables; 515 516 for (table_index = 0;; table_index++) { 517 status = acpi_get_table_by_index(table_index, &table_header); 518 519 if (status == AE_BAD_PARAMETER) 520 break; 521 522 if (ACPI_FAILURE(status)) 523 continue; 524 525 table_attr = kzalloc(sizeof(*table_attr), GFP_KERNEL); 526 if (!table_attr) 527 return -ENOMEM; 528 529 ret = acpi_table_attr_init(tables_kobj, 530 table_attr, table_header); 531 if (ret) { 532 kfree(table_attr); 533 return ret; 534 } 535 list_add_tail(&table_attr->node, &acpi_table_attr_list); 536 acpi_table_data_init(table_header); 537 } 538 539 kobject_uevent(tables_kobj, KOBJ_ADD); 540 kobject_uevent(tables_data_kobj, KOBJ_ADD); 541 kobject_uevent(dynamic_tables_kobj, KOBJ_ADD); 542 543 return 0; 544 err_dynamic_tables: 545 kobject_put(tables_data_kobj); 546 err_tables_data: 547 kobject_put(tables_kobj); 548 err: 549 return -ENOMEM; 550 } 551 552 /* 553 * Detailed ACPI IRQ counters: 554 * /sys/firmware/acpi/interrupts/ 555 */ 556 557 u32 acpi_irq_handled; 558 u32 acpi_irq_not_handled; 559 560 #define COUNT_GPE 0 561 #define COUNT_SCI 1 /* acpi_irq_handled */ 562 #define COUNT_SCI_NOT 2 /* acpi_irq_not_handled */ 563 #define COUNT_ERROR 3 /* other */ 564 #define NUM_COUNTERS_EXTRA 4 565 566 struct event_counter { 567 u32 count; 568 u32 flags; 569 }; 570 571 static struct event_counter *all_counters; 572 static u32 num_gpes; 573 static u32 num_counters; 574 static struct attribute **all_attrs; 575 static u32 acpi_gpe_count; 576 577 static struct attribute_group interrupt_stats_attr_group = { 578 .name = "interrupts", 579 }; 580 581 static struct kobj_attribute *counter_attrs; 582 583 static void delete_gpe_attr_array(void) 584 { 585 struct event_counter *tmp = all_counters; 586 587 all_counters = NULL; 588 kfree(tmp); 589 590 if (counter_attrs) { 591 int i; 592 593 for (i = 0; i < num_gpes; i++) 594 kfree(counter_attrs[i].attr.name); 595 596 kfree(counter_attrs); 597 } 598 kfree(all_attrs); 599 600 return; 601 } 602 603 static void gpe_count(u32 gpe_number) 604 { 605 acpi_gpe_count++; 606 607 if (!all_counters) 608 return; 609 610 if (gpe_number < num_gpes) 611 all_counters[gpe_number].count++; 612 else 613 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + 614 COUNT_ERROR].count++; 615 616 return; 617 } 618 619 static void fixed_event_count(u32 event_number) 620 { 621 if (!all_counters) 622 return; 623 624 if (event_number < ACPI_NUM_FIXED_EVENTS) 625 all_counters[num_gpes + event_number].count++; 626 else 627 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + 628 COUNT_ERROR].count++; 629 630 return; 631 } 632 633 static void acpi_global_event_handler(u32 event_type, acpi_handle device, 634 u32 event_number, void *context) 635 { 636 if (event_type == ACPI_EVENT_TYPE_GPE) { 637 gpe_count(event_number); 638 pr_debug("GPE event 0x%02x\n", event_number); 639 } else if (event_type == ACPI_EVENT_TYPE_FIXED) { 640 fixed_event_count(event_number); 641 pr_debug("Fixed event 0x%02x\n", event_number); 642 } else { 643 pr_debug("Other event 0x%02x\n", event_number); 644 } 645 } 646 647 static int get_status(u32 index, acpi_event_status *status, 648 acpi_handle *handle) 649 { 650 int result; 651 652 if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS) 653 return -EINVAL; 654 655 if (index < num_gpes) { 656 result = acpi_get_gpe_device(index, handle); 657 if (result) { 658 ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND, 659 "Invalid GPE 0x%x", index)); 660 return result; 661 } 662 result = acpi_get_gpe_status(*handle, index, status); 663 } else if (index < (num_gpes + ACPI_NUM_FIXED_EVENTS)) 664 result = acpi_get_event_status(index - num_gpes, status); 665 666 return result; 667 } 668 669 static ssize_t counter_show(struct kobject *kobj, 670 struct kobj_attribute *attr, char *buf) 671 { 672 int index = attr - counter_attrs; 673 int size; 674 acpi_handle handle; 675 acpi_event_status status; 676 int result = 0; 677 678 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI].count = 679 acpi_irq_handled; 680 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT].count = 681 acpi_irq_not_handled; 682 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE].count = 683 acpi_gpe_count; 684 size = sprintf(buf, "%8u", all_counters[index].count); 685 686 /* "gpe_all" or "sci" */ 687 if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS) 688 goto end; 689 690 result = get_status(index, &status, &handle); 691 if (result) 692 goto end; 693 694 if (status & ACPI_EVENT_FLAG_ENABLE_SET) 695 size += sprintf(buf + size, " EN"); 696 else 697 size += sprintf(buf + size, " "); 698 if (status & ACPI_EVENT_FLAG_STATUS_SET) 699 size += sprintf(buf + size, " STS"); 700 else 701 size += sprintf(buf + size, " "); 702 703 if (!(status & ACPI_EVENT_FLAG_HAS_HANDLER)) 704 size += sprintf(buf + size, " invalid "); 705 else if (status & ACPI_EVENT_FLAG_ENABLED) 706 size += sprintf(buf + size, " enabled "); 707 else if (status & ACPI_EVENT_FLAG_WAKE_ENABLED) 708 size += sprintf(buf + size, " wake_enabled"); 709 else 710 size += sprintf(buf + size, " disabled "); 711 if (status & ACPI_EVENT_FLAG_MASKED) 712 size += sprintf(buf + size, " masked "); 713 else 714 size += sprintf(buf + size, " unmasked"); 715 716 end: 717 size += sprintf(buf + size, "\n"); 718 return result ? result : size; 719 } 720 721 /* 722 * counter_set() sets the specified counter. 723 * setting the total "sci" file to any value clears all counters. 724 * enable/disable/clear a gpe/fixed event in user space. 725 */ 726 static ssize_t counter_set(struct kobject *kobj, 727 struct kobj_attribute *attr, const char *buf, 728 size_t size) 729 { 730 int index = attr - counter_attrs; 731 acpi_event_status status; 732 acpi_handle handle; 733 int result = 0; 734 unsigned long tmp; 735 736 if (index == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) { 737 int i; 738 for (i = 0; i < num_counters; ++i) 739 all_counters[i].count = 0; 740 acpi_gpe_count = 0; 741 acpi_irq_handled = 0; 742 acpi_irq_not_handled = 0; 743 goto end; 744 } 745 746 /* show the event status for both GPEs and Fixed Events */ 747 result = get_status(index, &status, &handle); 748 if (result) 749 goto end; 750 751 if (!(status & ACPI_EVENT_FLAG_HAS_HANDLER)) { 752 printk(KERN_WARNING PREFIX 753 "Can not change Invalid GPE/Fixed Event status\n"); 754 return -EINVAL; 755 } 756 757 if (index < num_gpes) { 758 if (!strcmp(buf, "disable\n") && 759 (status & ACPI_EVENT_FLAG_ENABLED)) 760 result = acpi_disable_gpe(handle, index); 761 else if (!strcmp(buf, "enable\n") && 762 !(status & ACPI_EVENT_FLAG_ENABLED)) 763 result = acpi_enable_gpe(handle, index); 764 else if (!strcmp(buf, "clear\n") && 765 (status & ACPI_EVENT_FLAG_STATUS_SET)) 766 result = acpi_clear_gpe(handle, index); 767 else if (!strcmp(buf, "mask\n")) 768 result = acpi_mask_gpe(handle, index, TRUE); 769 else if (!strcmp(buf, "unmask\n")) 770 result = acpi_mask_gpe(handle, index, FALSE); 771 else if (!kstrtoul(buf, 0, &tmp)) 772 all_counters[index].count = tmp; 773 else 774 result = -EINVAL; 775 } else if (index < num_gpes + ACPI_NUM_FIXED_EVENTS) { 776 int event = index - num_gpes; 777 if (!strcmp(buf, "disable\n") && 778 (status & ACPI_EVENT_FLAG_ENABLE_SET)) 779 result = acpi_disable_event(event, ACPI_NOT_ISR); 780 else if (!strcmp(buf, "enable\n") && 781 !(status & ACPI_EVENT_FLAG_ENABLE_SET)) 782 result = acpi_enable_event(event, ACPI_NOT_ISR); 783 else if (!strcmp(buf, "clear\n") && 784 (status & ACPI_EVENT_FLAG_STATUS_SET)) 785 result = acpi_clear_event(event); 786 else if (!kstrtoul(buf, 0, &tmp)) 787 all_counters[index].count = tmp; 788 else 789 result = -EINVAL; 790 } else 791 all_counters[index].count = strtoul(buf, NULL, 0); 792 793 if (ACPI_FAILURE(result)) 794 result = -EINVAL; 795 end: 796 return result ? result : size; 797 } 798 799 /* 800 * A Quirk Mechanism for GPE Flooding Prevention: 801 * 802 * Quirks may be needed to prevent GPE flooding on a specific GPE. The 803 * flooding typically cannot be detected and automatically prevented by 804 * ACPI_GPE_DISPATCH_NONE check because there is a _Lxx/_Exx prepared in 805 * the AML tables. This normally indicates a feature gap in Linux, thus 806 * instead of providing endless quirk tables, we provide a boot parameter 807 * for those who want this quirk. For example, if the users want to prevent 808 * the GPE flooding for GPE 00, they need to specify the following boot 809 * parameter: 810 * acpi_mask_gpe=0x00 811 * The masking status can be modified by the following runtime controlling 812 * interface: 813 * echo unmask > /sys/firmware/acpi/interrupts/gpe00 814 */ 815 816 /* 817 * Currently, the GPE flooding prevention only supports to mask the GPEs 818 * numbered from 00 to 7f. 819 */ 820 #define ACPI_MASKABLE_GPE_MAX 0x80 821 822 static u64 __initdata acpi_masked_gpes; 823 824 static int __init acpi_gpe_set_masked_gpes(char *val) 825 { 826 u8 gpe; 827 828 if (kstrtou8(val, 0, &gpe) || gpe > ACPI_MASKABLE_GPE_MAX) 829 return -EINVAL; 830 acpi_masked_gpes |= ((u64)1<<gpe); 831 832 return 1; 833 } 834 __setup("acpi_mask_gpe=", acpi_gpe_set_masked_gpes); 835 836 void __init acpi_gpe_apply_masked_gpes(void) 837 { 838 acpi_handle handle; 839 acpi_status status; 840 u8 gpe; 841 842 for (gpe = 0; 843 gpe < min_t(u8, ACPI_MASKABLE_GPE_MAX, acpi_current_gpe_count); 844 gpe++) { 845 if (acpi_masked_gpes & ((u64)1<<gpe)) { 846 status = acpi_get_gpe_device(gpe, &handle); 847 if (ACPI_SUCCESS(status)) { 848 pr_info("Masking GPE 0x%x.\n", gpe); 849 (void)acpi_mask_gpe(handle, gpe, TRUE); 850 } 851 } 852 } 853 } 854 855 void acpi_irq_stats_init(void) 856 { 857 acpi_status status; 858 int i; 859 860 if (all_counters) 861 return; 862 863 num_gpes = acpi_current_gpe_count; 864 num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA; 865 866 all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1), 867 GFP_KERNEL); 868 if (all_attrs == NULL) 869 return; 870 871 all_counters = kzalloc(sizeof(struct event_counter) * (num_counters), 872 GFP_KERNEL); 873 if (all_counters == NULL) 874 goto fail; 875 876 status = acpi_install_global_event_handler(acpi_global_event_handler, NULL); 877 if (ACPI_FAILURE(status)) 878 goto fail; 879 880 counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters), 881 GFP_KERNEL); 882 if (counter_attrs == NULL) 883 goto fail; 884 885 for (i = 0; i < num_counters; ++i) { 886 char buffer[12]; 887 char *name; 888 889 if (i < num_gpes) 890 sprintf(buffer, "gpe%02X", i); 891 else if (i == num_gpes + ACPI_EVENT_PMTIMER) 892 sprintf(buffer, "ff_pmtimer"); 893 else if (i == num_gpes + ACPI_EVENT_GLOBAL) 894 sprintf(buffer, "ff_gbl_lock"); 895 else if (i == num_gpes + ACPI_EVENT_POWER_BUTTON) 896 sprintf(buffer, "ff_pwr_btn"); 897 else if (i == num_gpes + ACPI_EVENT_SLEEP_BUTTON) 898 sprintf(buffer, "ff_slp_btn"); 899 else if (i == num_gpes + ACPI_EVENT_RTC) 900 sprintf(buffer, "ff_rt_clk"); 901 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE) 902 sprintf(buffer, "gpe_all"); 903 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) 904 sprintf(buffer, "sci"); 905 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT) 906 sprintf(buffer, "sci_not"); 907 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR) 908 sprintf(buffer, "error"); 909 else 910 sprintf(buffer, "bug%02X", i); 911 912 name = kstrdup(buffer, GFP_KERNEL); 913 if (name == NULL) 914 goto fail; 915 916 sysfs_attr_init(&counter_attrs[i].attr); 917 counter_attrs[i].attr.name = name; 918 counter_attrs[i].attr.mode = 0644; 919 counter_attrs[i].show = counter_show; 920 counter_attrs[i].store = counter_set; 921 922 all_attrs[i] = &counter_attrs[i].attr; 923 } 924 925 interrupt_stats_attr_group.attrs = all_attrs; 926 if (!sysfs_create_group(acpi_kobj, &interrupt_stats_attr_group)) 927 return; 928 929 fail: 930 delete_gpe_attr_array(); 931 return; 932 } 933 934 static void __exit interrupt_stats_exit(void) 935 { 936 sysfs_remove_group(acpi_kobj, &interrupt_stats_attr_group); 937 938 delete_gpe_attr_array(); 939 940 return; 941 } 942 943 static ssize_t 944 acpi_show_profile(struct device *dev, struct device_attribute *attr, 945 char *buf) 946 { 947 return sprintf(buf, "%d\n", acpi_gbl_FADT.preferred_profile); 948 } 949 950 static const struct device_attribute pm_profile_attr = 951 __ATTR(pm_profile, S_IRUGO, acpi_show_profile, NULL); 952 953 static ssize_t hotplug_enabled_show(struct kobject *kobj, 954 struct kobj_attribute *attr, char *buf) 955 { 956 struct acpi_hotplug_profile *hotplug = to_acpi_hotplug_profile(kobj); 957 958 return sprintf(buf, "%d\n", hotplug->enabled); 959 } 960 961 static ssize_t hotplug_enabled_store(struct kobject *kobj, 962 struct kobj_attribute *attr, 963 const char *buf, size_t size) 964 { 965 struct acpi_hotplug_profile *hotplug = to_acpi_hotplug_profile(kobj); 966 unsigned int val; 967 968 if (kstrtouint(buf, 10, &val) || val > 1) 969 return -EINVAL; 970 971 acpi_scan_hotplug_enabled(hotplug, val); 972 return size; 973 } 974 975 static struct kobj_attribute hotplug_enabled_attr = 976 __ATTR(enabled, S_IRUGO | S_IWUSR, hotplug_enabled_show, 977 hotplug_enabled_store); 978 979 static struct attribute *hotplug_profile_attrs[] = { 980 &hotplug_enabled_attr.attr, 981 NULL 982 }; 983 984 static struct kobj_type acpi_hotplug_profile_ktype = { 985 .sysfs_ops = &kobj_sysfs_ops, 986 .default_attrs = hotplug_profile_attrs, 987 }; 988 989 void acpi_sysfs_add_hotplug_profile(struct acpi_hotplug_profile *hotplug, 990 const char *name) 991 { 992 int error; 993 994 if (!hotplug_kobj) 995 goto err_out; 996 997 error = kobject_init_and_add(&hotplug->kobj, 998 &acpi_hotplug_profile_ktype, hotplug_kobj, "%s", name); 999 if (error) 1000 goto err_out; 1001 1002 kobject_uevent(&hotplug->kobj, KOBJ_ADD); 1003 return; 1004 1005 err_out: 1006 pr_err(PREFIX "Unable to add hotplug profile '%s'\n", name); 1007 } 1008 1009 static ssize_t force_remove_show(struct kobject *kobj, 1010 struct kobj_attribute *attr, char *buf) 1011 { 1012 return sprintf(buf, "%d\n", 0); 1013 } 1014 1015 static ssize_t force_remove_store(struct kobject *kobj, 1016 struct kobj_attribute *attr, 1017 const char *buf, size_t size) 1018 { 1019 bool val; 1020 int ret; 1021 1022 ret = strtobool(buf, &val); 1023 if (ret < 0) 1024 return ret; 1025 1026 if (val) { 1027 pr_err("Enabling force_remove is not supported anymore. Please report to linux-acpi@vger.kernel.org if you depend on this functionality\n"); 1028 return -EINVAL; 1029 } 1030 return size; 1031 } 1032 1033 static const struct kobj_attribute force_remove_attr = 1034 __ATTR(force_remove, S_IRUGO | S_IWUSR, force_remove_show, 1035 force_remove_store); 1036 1037 int __init acpi_sysfs_init(void) 1038 { 1039 int result; 1040 1041 result = acpi_tables_sysfs_init(); 1042 if (result) 1043 return result; 1044 1045 hotplug_kobj = kobject_create_and_add("hotplug", acpi_kobj); 1046 if (!hotplug_kobj) 1047 return -ENOMEM; 1048 1049 result = sysfs_create_file(hotplug_kobj, &force_remove_attr.attr); 1050 if (result) 1051 return result; 1052 1053 result = sysfs_create_file(acpi_kobj, &pm_profile_attr.attr); 1054 return result; 1055 } 1056