drivers/acpi/sysfs.c

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