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