]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/acpi/sysfs.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'firmware_removal-4.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel...
[mirror_ubuntu-bionic-kernel.git] / drivers / acpi / sysfs.c
CommitLineData
1c8fce27
ZR		 1/*
2 * sysfs.c - ACPI sysfs interface to userspace.
3 */
4
7db8d1d9
RW		 5#define pr_fmt(fmt) "ACPI: " fmt
6
1c8fce27
ZR		 7#include <linux/init.h>
8#include <linux/kernel.h>
9#include <linux/moduleparam.h>
8b48463f 10#include <linux/acpi.h>
1c8fce27 11
3f8055c3
RW		 12#include "internal.h"
13
1c8fce27
ZR		 14#define _COMPONENT ACPI_SYSTEM_COMPONENT
15ACPI_MODULE_NAME("sysfs");
16
1c8fce27
ZR		 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
28struct acpi_dlayer {
29 const char *name;
30 unsigned long value;
31};
32struct acpi_dlevel {
33 const char *name;
34 unsigned long value;
35};
36#define ACPI_DEBUG_INIT(v) { .name = #v, .value = v }
37
38static 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
70static 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),
93d98831 74 ACPI_DEBUG_INIT(ACPI_LV_REPAIR),
7901a052 75 ACPI_DEBUG_INIT(ACPI_LV_TRACE_POINT),
1c8fce27
ZR		 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
ec652b35 107static int param_get_debug_layer(char *buffer, const struct kernel_param *kp)
1c8fce27
ZR		 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
ec652b35 135static int param_get_debug_level(char *buffer, const struct kernel_param *kp)
1c8fce27
ZR		 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
9c8b04be 156static const struct kernel_param_ops param_ops_debug_layer = {
ec652b35
ZR		 157 .set = param_set_uint,
158 .get = param_get_debug_layer,
159};
160
9c8b04be 161static const struct kernel_param_ops param_ops_debug_level = {
ec652b35
ZR		 162 .set = param_set_uint,
163 .get = param_get_debug_level,
164};
165
166module_param_cb(debug_layer, &param_ops_debug_layer, &acpi_dbg_layer, 0644);
167module_param_cb(debug_level, &param_ops_debug_level, &acpi_dbg_level, 0644);
1c8fce27 168
a0186bcf 169static char trace_method_name[1024];
1c8fce27 170
7901a052 171int param_set_trace_method_name(const char *val, const struct kernel_param *kp)
1c8fce27 172{
7901a052 173 u32 saved_flags = 0;
a0186bcf 174 bool is_abs_path = true;
1c8fce27 175
a0186bcf
LZ		 176 if (*val != '\\')
177 is_abs_path = false;
178
179 if ((is_abs_path && strlen(val) > 1023) ||
180 (!is_abs_path && strlen(val) > 1022)) {
7901a052
LZ		 181 pr_err("%s: string parameter too long\n", kp->name);
182 return -ENOSPC;
1c8fce27
ZR		 183 }
184
7901a052
LZ		 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
7901a052 196 /* This is a hack. We can't kmalloc in early boot. */
a0186bcf
LZ		 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 }
7901a052
LZ		 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);
1c8fce27 209
7901a052
LZ		 210 return 0;
211}
1c8fce27 212
7901a052
LZ		 213static 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
218static 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
223static const struct kernel_param_ops param_ops_trace_attrib = {
224 .set = param_set_uint,
225 .get = param_get_uint,
226};
227
228module_param_cb(trace_method_name, &param_ops_trace_method, &trace_method_name, 0644);
229module_param_cb(trace_debug_layer, &param_ops_trace_attrib, &acpi_gbl_trace_dbg_layer, 0644);
230module_param_cb(trace_debug_level, &param_ops_trace_attrib, &acpi_gbl_trace_dbg_level, 0644);
231
232static 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;
1c8fce27
ZR		 266}
267
268static int param_get_trace_state(char *buffer, struct kernel_param *kp)
269{
7901a052 270 if (!(acpi_gbl_trace_flags & ACPI_TRACE_ENABLED))
1c8fce27
ZR		 271 return sprintf(buffer, "disable");
272 else {
7901a052
LZ		 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
1c8fce27
ZR		 279 return sprintf(buffer, "enable");
280 }
281 return 0;
282}
283
284module_param_call(trace_state, param_set_trace_state, param_get_trace_state,
285 NULL, 0644);
286#endif /* CONFIG_ACPI_DEBUG */
287
aecad432
TR		 288
289/* /sys/modules/acpi/parameters/aml_debug_output */
290
291module_param_named(aml_debug_output, acpi_gbl_enable_aml_debug_object,
481c1381 292 byte, 0644);
aecad432
TR		 293MODULE_PARM_DESC(aml_debug_output,
294 "To enable/disable the ACPI Debug Object output.");
295
1c8fce27
ZR		 296/* /sys/module/acpi/parameters/acpica_version */
297static 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
306module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);
307
308/*
309 * ACPI table sysfs I/F:
310 * /sys/firmware/acpi/tables/
7dae6326 311 * /sys/firmware/acpi/tables/data/
1c8fce27
ZR		 312 * /sys/firmware/acpi/tables/dynamic/
313 */
314
315static LIST_HEAD(acpi_table_attr_list);
316static struct kobject *tables_kobj;
7dae6326 317static struct kobject *tables_data_kobj;
1c8fce27 318static struct kobject *dynamic_tables_kobj;
3f8055c3 319static struct kobject *hotplug_kobj;
1c8fce27 320
914c6194
LZ		 321#define ACPI_MAX_TABLE_INSTANCES 999
322#define ACPI_INST_SIZE 4 /* including trailing 0 */
323
1c8fce27
ZR		 324struct acpi_table_attr {
325 struct bin_attribute attr;
914c6194 326 char name[ACPI_NAME_SIZE];
1c8fce27 327 int instance;
914c6194 328 char filename[ACPI_NAME_SIZE+ACPI_INST_SIZE];
1c8fce27
ZR		 329 struct list_head node;
330};
331
7dae6326
TL		 332struct acpi_data_attr {
333 struct bin_attribute attr;
334 u64 addr;
335};
336
1c8fce27
ZR		 337static 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;
0de0e198 345 ssize_t rc;
1c8fce27 346
914c6194
LZ		 347 status = acpi_get_table(table_attr->name, table_attr->instance,
348 &table_header);
1c8fce27
ZR		 349 if (ACPI_FAILURE(status))
350 return -ENODEV;
351
0de0e198
DW		 352 rc = memory_read_from_buffer(buf, count, &offset, table_header,
353 table_header->length);
354 acpi_put_table(table_header);
355 return rc;
1c8fce27
ZR		 356}
357
914c6194
LZ		 358static int acpi_table_attr_init(struct kobject *tables_obj,
359 struct acpi_table_attr *table_attr,
360 struct acpi_table_header *table_header)
1c8fce27
ZR		 361{
362 struct acpi_table_header *header = NULL;
363 struct acpi_table_attr *attr = NULL;
914c6194 364 char instance_str[ACPI_INST_SIZE];
1c8fce27
ZR		 365
366 sysfs_attr_init(&table_attr->attr.attr);
914c6194 367 ACPI_MOVE_NAME(table_attr->name, table_header->signature);
1c8fce27
ZR		 368
369 list_for_each_entry(attr, &acpi_table_attr_list, node) {
914c6194 370 if (ACPI_COMPARE_NAME(table_attr->name, attr->name))
1c8fce27
ZR		 371 if (table_attr->instance < attr->instance)
372 table_attr->instance = attr->instance;
373 }
374 table_attr->instance++;
914c6194
LZ		 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 }
1c8fce27 380
914c6194
LZ		 381 ACPI_MOVE_NAME(table_attr->filename, table_header->signature);
382 table_attr->filename[ACPI_NAME_SIZE] = '\0';
1c8fce27
ZR		 383 if (table_attr->instance > 1 || (table_attr->instance == 1 &&
384 !acpi_get_table
914c6194
LZ		 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 }
1c8fce27 390
083ca8c4 391 table_attr->attr.size = table_header->length;
1c8fce27 392 table_attr->attr.read = acpi_table_show;
914c6194 393 table_attr->attr.attr.name = table_attr->filename;
1c8fce27
ZR		 394 table_attr->attr.attr.mode = 0400;
395
914c6194 396 return sysfs_create_bin_file(tables_obj, &table_attr->attr);
1c8fce27
ZR		 397}
398
68bdb677 399acpi_status acpi_sysfs_table_handler(u32 event, void *table, void *context)
1c8fce27
ZR		 400{
401 struct acpi_table_attr *table_attr;
402
403 switch (event) {
307ecb0a 404 case ACPI_TABLE_EVENT_INSTALL:
1c8fce27
ZR		 405 table_attr =
406 kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
407 if (!table_attr)
408 return AE_NO_MEMORY;
409
914c6194
LZ		 410 if (acpi_table_attr_init(dynamic_tables_kobj,
411 table_attr, table)) {
1c8fce27
ZR		 412 kfree(table_attr);
413 return AE_ERROR;
914c6194
LZ		 414 }
415 list_add_tail(&table_attr->node, &acpi_table_attr_list);
1c8fce27 416 break;
307ecb0a 417 case ACPI_TABLE_EVENT_LOAD:
1c8fce27 418 case ACPI_TABLE_EVENT_UNLOAD:
307ecb0a 419 case ACPI_TABLE_EVENT_UNINSTALL:
1c8fce27
ZR		 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
7dae6326
TL		 432static 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
452static 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
468static 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
477static 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
1c8fce27
ZR		 496static int acpi_tables_sysfs_init(void)
497{
498 struct acpi_table_attr *table_attr;
499 struct acpi_table_header *table_header = NULL;
de03beed
JC		 500 int table_index;
501 acpi_status status;
502 int ret;
1c8fce27
ZR		 503
504 tables_kobj = kobject_create_and_add("tables", acpi_kobj);
505 if (!tables_kobj)
506 goto err;
507
7dae6326
TL		 508 tables_data_kobj = kobject_create_and_add("data", tables_kobj);
509 if (!tables_data_kobj)
510 goto err_tables_data;
511
1c8fce27
ZR		 512 dynamic_tables_kobj = kobject_create_and_add("dynamic", tables_kobj);
513 if (!dynamic_tables_kobj)
514 goto err_dynamic_tables;
515
de03beed
JC		 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
de03beed
JC		 525 table_attr = kzalloc(sizeof(*table_attr), GFP_KERNEL);
526 if (!table_attr)
527 return -ENOMEM;
528
914c6194
LZ		 529 ret = acpi_table_attr_init(tables_kobj,
530 table_attr, table_header);
de03beed
JC		 531 if (ret) {
532 kfree(table_attr);
533 return ret;
1c8fce27 534 }
de03beed 535 list_add_tail(&table_attr->node, &acpi_table_attr_list);
7dae6326 536 acpi_table_data_init(table_header);
de03beed
JC		 537 }
538
1c8fce27 539 kobject_uevent(tables_kobj, KOBJ_ADD);
7dae6326 540 kobject_uevent(tables_data_kobj, KOBJ_ADD);
1c8fce27 541 kobject_uevent(dynamic_tables_kobj, KOBJ_ADD);
1c8fce27 542
68bdb677 543 return 0;
1c8fce27 544err_dynamic_tables:
7dae6326
TL		 545 kobject_put(tables_data_kobj);
546err_tables_data:
1c8fce27
ZR		 547 kobject_put(tables_kobj);
548err:
549 return -ENOMEM;
550}
551
552/*
553 * Detailed ACPI IRQ counters:
554 * /sys/firmware/acpi/interrupts/
555 */
556
557u32 acpi_irq_handled;
558u32 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
566struct event_counter {
567 u32 count;
568 u32 flags;
569};
570
571static struct event_counter *all_counters;
572static u32 num_gpes;
573static u32 num_counters;
574static struct attribute **all_attrs;
575static u32 acpi_gpe_count;
576
577static struct attribute_group interrupt_stats_attr_group = {
578 .name = "interrupts",
579};
580
581static struct kobj_attribute *counter_attrs;
582
583static 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
a0fcdb23 603static void gpe_count(u32 gpe_number)
1c8fce27
ZR		 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
a0fcdb23 619static void fixed_event_count(u32 event_number)
1c8fce27
ZR		 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
644ef74e 633static void acpi_global_event_handler(u32 event_type, acpi_handle device,
a0fcdb23
LM		 634 u32 event_number, void *context)
635{
7db8d1d9 636 if (event_type == ACPI_EVENT_TYPE_GPE) {
a0fcdb23 637 gpe_count(event_number);
7db8d1d9
RW		 638 pr_debug("GPE event 0x%02x\n", event_number);
639 } else if (event_type == ACPI_EVENT_TYPE_FIXED) {
a0fcdb23 640 fixed_event_count(event_number);
7db8d1d9
RW		 641 pr_debug("Fixed event 0x%02x\n", event_number);
642 } else {
643 pr_debug("Other event 0x%02x\n", event_number);
644 }
a0fcdb23
LM		 645}
646
1c8fce27
ZR		 647static int get_status(u32 index, acpi_event_status *status,
648 acpi_handle *handle)
649{
f18ebc21 650 int result;
1c8fce27
ZR		 651
652 if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
f18ebc21 653 return -EINVAL;
1c8fce27
ZR		 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,
c6284237 659 "Invalid GPE 0x%x", index));
f18ebc21 660 return result;
1c8fce27
ZR		 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
1c8fce27
ZR		 666 return result;
667}
668
669static 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;
7b1a1322 684 size = sprintf(buf, "%8u", all_counters[index].count);
1c8fce27
ZR		 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
18864cc4
LZ		 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
2f857234 703 if (!(status & ACPI_EVENT_FLAG_HAS_HANDLER))
18864cc4 704 size += sprintf(buf + size, " invalid ");
1c8fce27 705 else if (status & ACPI_EVENT_FLAG_ENABLED)
18864cc4 706 size += sprintf(buf + size, " enabled ");
1c8fce27 707 else if (status & ACPI_EVENT_FLAG_WAKE_ENABLED)
18864cc4 708 size += sprintf(buf + size, " wake_enabled");
1c8fce27 709 else
18864cc4
LZ		 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");
1c8fce27
ZR		 715
716end:
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 */
726static 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;
c48b1565 734 unsigned long tmp;
1c8fce27
ZR		 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
2f857234 751 if (!(status & ACPI_EVENT_FLAG_HAS_HANDLER)) {
1c8fce27
ZR		 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") &&
18864cc4 765 (status & ACPI_EVENT_FLAG_STATUS_SET))
1c8fce27 766 result = acpi_clear_gpe(handle, index);
18864cc4
LZ		 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);
c48b1565
LT		 771 else if (!kstrtoul(buf, 0, &tmp))
772 all_counters[index].count = tmp;
1c8fce27 773 else
c48b1565 774 result = -EINVAL;
1c8fce27
ZR		 775 } else if (index < num_gpes + ACPI_NUM_FIXED_EVENTS) {
776 int event = index - num_gpes;
777 if (!strcmp(buf, "disable\n") &&
18864cc4 778 (status & ACPI_EVENT_FLAG_ENABLE_SET))
1c8fce27
ZR		 779 result = acpi_disable_event(event, ACPI_NOT_ISR);
780 else if (!strcmp(buf, "enable\n") &&
18864cc4 781 !(status & ACPI_EVENT_FLAG_ENABLE_SET))
1c8fce27
ZR		 782 result = acpi_enable_event(event, ACPI_NOT_ISR);
783 else if (!strcmp(buf, "clear\n") &&
18864cc4 784 (status & ACPI_EVENT_FLAG_STATUS_SET))
1c8fce27 785 result = acpi_clear_event(event);
c48b1565
LT		 786 else if (!kstrtoul(buf, 0, &tmp))
787 all_counters[index].count = tmp;
1c8fce27 788 else
c48b1565 789 result = -EINVAL;
1c8fce27
ZR		 790 } else
791 all_counters[index].count = strtoul(buf, NULL, 0);
792
793 if (ACPI_FAILURE(result))
794 result = -EINVAL;
795end:
796 return result ? result : size;
797}
798
9c4aa1ee
LZ		 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
822static u64 __initdata acpi_masked_gpes;
823
824static 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
836void __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
1c8fce27
ZR		 855void acpi_irq_stats_init(void)
856{
a0fcdb23 857 acpi_status status;
1c8fce27
ZR		 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
644ef74e 876 status = acpi_install_global_event_handler(acpi_global_event_handler, NULL);
a0fcdb23
LM		 877 if (ACPI_FAILURE(status))
878 goto fail;
879
1c8fce27
ZR		 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
096a8aac 912 name = kstrdup(buffer, GFP_KERNEL);
1c8fce27
ZR		 913 if (name == NULL)
914 goto fail;
1c8fce27
ZR		 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
929fail:
930 delete_gpe_attr_array();
931 return;
932}
933
934static 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
362b6460
TR		 943static ssize_t
944acpi_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
950static const struct device_attribute pm_profile_attr =
951 __ATTR(pm_profile, S_IRUGO, acpi_show_profile, NULL);
952
3f8055c3
RW		 953static 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
961static 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
975static struct kobj_attribute hotplug_enabled_attr =
976 __ATTR(enabled, S_IRUGO | S_IWUSR, hotplug_enabled_show,
977 hotplug_enabled_store);
978
979static struct attribute *hotplug_profile_attrs[] = {
980 &hotplug_enabled_attr.attr,
981 NULL
982};
983
b09753ec 984static struct kobj_type acpi_hotplug_profile_ktype = {
3f8055c3
RW		 985 .sysfs_ops = &kobj_sysfs_ops,
986 .default_attrs = hotplug_profile_attrs,
987};
988
989void 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
acd3e2c9
BH		 997 error = kobject_init_and_add(&hotplug->kobj,
998 &acpi_hotplug_profile_ktype, hotplug_kobj, "%s", name);
3f8055c3
RW		 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
683058e3
RW		 1009static ssize_t force_remove_show(struct kobject *kobj,
1010 struct kobj_attribute *attr, char *buf)
1011{
ffc10d82 1012 return sprintf(buf, "%d\n", 0);
683058e3
RW		 1013}
1014
1015static 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
ffc10d82
MH		 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 }
683058e3
RW		 1030 return size;
1031}
1032
1033static const struct kobj_attribute force_remove_attr =
1034 __ATTR(force_remove, S_IRUGO | S_IWUSR, force_remove_show,
1035 force_remove_store);
1036
1c8fce27
ZR		 1037int __init acpi_sysfs_init(void)
1038{
1039 int result;
1040
1041 result = acpi_tables_sysfs_init();
362b6460
TR		 1042 if (result)
1043 return result;
3f8055c3
RW		 1044
1045 hotplug_kobj = kobject_create_and_add("hotplug", acpi_kobj);
bc1e49df
IY		 1046 if (!hotplug_kobj)
1047 return -ENOMEM;
1048
683058e3
RW		 1049 result = sysfs_create_file(hotplug_kobj, &force_remove_attr.attr);
1050 if (result)
1051 return result;
1052
362b6460 1053 result = sysfs_create_file(acpi_kobj, &pm_profile_attr.attr);
1c8fce27
ZR		 1054 return result;
1055}
ubuntu-bionic-kernel mirror