drivers/acpi/sysfs.c

   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, &param_ops_debug_layer, &acpi_dbg_layer, 0644);
 167 module_param_cb(debug_level, &param_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, &param_ops_trace_method, &trace_method_name, 0644);
 229 module_param_cb(trace_debug_layer, &param_ops_trace_attrib, &acpi_gbl_trace_dbg_layer, 0644);
 230 module_param_cb(trace_debug_level, &param_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 }