2 * sysfs.c - ACPI sysfs interface to userspace.
5 #define pr_fmt(fmt) "ACPI: " fmt
7 #include <linux/init.h>
8 #include <linux/kernel.h>
9 #include <linux/moduleparam.h>
10 #include <linux/acpi.h>
14 #define _COMPONENT ACPI_SYSTEM_COMPONENT
15 ACPI_MODULE_NAME("sysfs");
17 #ifdef CONFIG_ACPI_DEBUG
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
36 #define ACPI_DEBUG_INIT(v) { .name = #v, .value = v }
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
),
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
),
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
),
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
),
92 ACPI_DEBUG_INIT(ACPI_LV_ALLOCATIONS
),
93 ACPI_DEBUG_INIT(ACPI_LV_FUNCTIONS
),
94 ACPI_DEBUG_INIT(ACPI_LV_OPTIMIZATIONS
),
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
),
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
),
107 static int param_get_debug_layer(char *buffer
, const struct kernel_param
*kp
)
112 result
= sprintf(buffer
, "%-25s\tHex SET\n", "Description");
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
)
122 sprintf(buffer
+ result
, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
124 (acpi_dbg_layer
& ACPI_ALL_DRIVERS
) ==
125 ACPI_ALL_DRIVERS
? '*' : (acpi_dbg_layer
& ACPI_ALL_DRIVERS
)
128 sprintf(buffer
+ result
,
129 "--\ndebug_layer = 0x%08X ( * = enabled)\n",
135 static int param_get_debug_level(char *buffer
, const struct kernel_param
*kp
)
140 result
= sprintf(buffer
, "%-25s\tHex SET\n", "Description");
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
)
150 sprintf(buffer
+ result
, "--\ndebug_level = 0x%08X (* = enabled)\n",
156 static const struct kernel_param_ops param_ops_debug_layer
= {
157 .set
= param_set_uint
,
158 .get
= param_get_debug_layer
,
161 static const struct kernel_param_ops param_ops_debug_level
= {
162 .set
= param_set_uint
,
163 .get
= param_get_debug_level
,
166 module_param_cb(debug_layer
, ¶m_ops_debug_layer
, &acpi_dbg_layer
, 0644);
167 module_param_cb(debug_level
, ¶m_ops_debug_level
, &acpi_dbg_level
, 0644);
169 static char trace_method_name
[1024];
171 int param_set_trace_method_name(const char *val
, const struct kernel_param
*kp
)
174 bool is_abs_path
= true;
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
);
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.
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
,
196 /* This is a hack. We can't kmalloc in early boot. */
198 strcpy(trace_method_name
, val
);
200 trace_method_name
[0] = '\\';
201 strcpy(trace_method_name
+1, val
);
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
,
213 static int param_get_trace_method_name(char *buffer
, const struct kernel_param
*kp
)
215 return scnprintf(buffer
, PAGE_SIZE
, "%s", acpi_gbl_trace_method_name
);
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
,
223 static const struct kernel_param_ops param_ops_trace_attrib
= {
224 .set
= param_set_uint
,
225 .get
= param_get_uint
,
228 module_param_cb(trace_method_name
, ¶m_ops_trace_method
, &trace_method_name
, 0644);
229 module_param_cb(trace_debug_layer
, ¶m_ops_trace_attrib
, &acpi_gbl_trace_dbg_layer
, 0644);
230 module_param_cb(trace_debug_level
, ¶m_ops_trace_attrib
, &acpi_gbl_trace_dbg_level
, 0644);
232 static int param_set_trace_state(const char *val
, struct kernel_param
*kp
)
235 const char *method
= trace_method_name
;
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)
242 if (!acpi_compare_param(val
, "enable")) {
244 flags
= ACPI_TRACE_ENABLED
;
245 } else if (!acpi_compare_param(val
, "disable"))
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
;
258 status
= acpi_debug_trace(method
,
259 acpi_gbl_trace_dbg_level
,
260 acpi_gbl_trace_dbg_layer
,
262 if (ACPI_FAILURE(status
))
268 static int param_get_trace_state(char *buffer
, struct kernel_param
*kp
)
270 if (!(acpi_gbl_trace_flags
& ACPI_TRACE_ENABLED
))
271 return sprintf(buffer
, "disable");
273 if (acpi_gbl_trace_method_name
) {
274 if (acpi_gbl_trace_flags
& ACPI_TRACE_ONESHOT
)
275 return sprintf(buffer
, "method-once");
277 return sprintf(buffer
, "method");
279 return sprintf(buffer
, "enable");
284 module_param_call(trace_state
, param_set_trace_state
, param_get_trace_state
,
286 #endif /* CONFIG_ACPI_DEBUG */
289 /* /sys/modules/acpi/parameters/aml_debug_output */
291 module_param_named(aml_debug_output
, acpi_gbl_enable_aml_debug_object
,
293 MODULE_PARM_DESC(aml_debug_output
,
294 "To enable/disable the ACPI Debug Object output.");
296 /* /sys/module/acpi/parameters/acpica_version */
297 static int param_get_acpica_version(char *buffer
, struct kernel_param
*kp
)
301 result
= sprintf(buffer
, "%x", ACPI_CA_VERSION
);
306 module_param_call(acpica_version
, NULL
, param_get_acpica_version
, NULL
, 0444);
309 * ACPI table sysfs I/F:
310 * /sys/firmware/acpi/tables/
311 * /sys/firmware/acpi/tables/data/
312 * /sys/firmware/acpi/tables/dynamic/
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
;
321 #define ACPI_MAX_TABLE_INSTANCES 999
322 #define ACPI_INST_SIZE 4 /* including trailing 0 */
324 struct acpi_table_attr
{
325 struct bin_attribute attr
;
326 char name
[ACPI_NAME_SIZE
];
328 char filename
[ACPI_NAME_SIZE
+ACPI_INST_SIZE
];
329 struct list_head node
;
332 struct acpi_data_attr
{
333 struct bin_attribute attr
;
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
)
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
;
347 status
= acpi_get_table(table_attr
->name
, table_attr
->instance
,
349 if (ACPI_FAILURE(status
))
352 rc
= memory_read_from_buffer(buf
, count
, &offset
, table_header
,
353 table_header
->length
);
354 acpi_put_table(table_header
);
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
)
362 struct acpi_table_header
*header
= NULL
;
363 struct acpi_table_attr
*attr
= NULL
;
364 char instance_str
[ACPI_INST_SIZE
];
366 sysfs_attr_init(&table_attr
->attr
.attr
);
367 ACPI_MOVE_NAME(table_attr
->name
, table_header
->signature
);
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
;
374 table_attr
->instance
++;
375 if (table_attr
->instance
> ACPI_MAX_TABLE_INSTANCES
) {
376 pr_warn("%4.4s: too many table instances\n",
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 &&
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
);
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;
396 return sysfs_create_bin_file(tables_obj
, &table_attr
->attr
);
399 acpi_status
acpi_sysfs_table_handler(u32 event
, void *table
, void *context
)
401 struct acpi_table_attr
*table_attr
;
404 case ACPI_TABLE_EVENT_INSTALL
:
406 kzalloc(sizeof(struct acpi_table_attr
), GFP_KERNEL
);
410 if (acpi_table_attr_init(dynamic_tables_kobj
,
411 table_attr
, table
)) {
415 list_add_tail(&table_attr
->node
, &acpi_table_attr_list
);
417 case ACPI_TABLE_EVENT_LOAD
:
418 case ACPI_TABLE_EVENT_UNLOAD
:
419 case ACPI_TABLE_EVENT_UNINSTALL
:
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.
427 return AE_BAD_PARAMETER
;
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
)
436 struct acpi_data_attr
*data_attr
;
440 data_attr
= container_of(bin_attr
, struct acpi_data_attr
, attr
);
442 base
= acpi_os_map_memory(data_attr
->addr
, data_attr
->attr
.size
);
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
);
452 static int acpi_bert_data_init(void *th
, struct acpi_data_attr
*data_attr
)
454 struct acpi_table_bert
*bert
= th
;
456 if (bert
->header
.length
< sizeof(struct acpi_table_bert
) ||
457 bert
->region_length
< sizeof(struct acpi_hest_generic_status
)) {
461 data_attr
->addr
= bert
->address
;
462 data_attr
->attr
.size
= bert
->region_length
;
463 data_attr
->attr
.attr
.name
= "BERT";
465 return sysfs_create_bin_file(tables_data_kobj
, &data_attr
->attr
);
468 static struct acpi_data_obj
{
470 int (*fn
)(void *, struct acpi_data_attr
*);
471 } acpi_data_objs
[] = {
472 { ACPI_SIG_BERT
, acpi_bert_data_init
},
475 #define NUM_ACPI_DATA_OBJS ARRAY_SIZE(acpi_data_objs)
477 static int acpi_table_data_init(struct acpi_table_header
*th
)
479 struct acpi_data_attr
*data_attr
;
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
);
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
);
496 static int acpi_tables_sysfs_init(void)
498 struct acpi_table_attr
*table_attr
;
499 struct acpi_table_header
*table_header
= NULL
;
504 tables_kobj
= kobject_create_and_add("tables", acpi_kobj
);
508 tables_data_kobj
= kobject_create_and_add("data", tables_kobj
);
509 if (!tables_data_kobj
)
510 goto err_tables_data
;
512 dynamic_tables_kobj
= kobject_create_and_add("dynamic", tables_kobj
);
513 if (!dynamic_tables_kobj
)
514 goto err_dynamic_tables
;
516 for (table_index
= 0;; table_index
++) {
517 status
= acpi_get_table_by_index(table_index
, &table_header
);
519 if (status
== AE_BAD_PARAMETER
)
522 if (ACPI_FAILURE(status
))
525 table_attr
= kzalloc(sizeof(*table_attr
), GFP_KERNEL
);
529 ret
= acpi_table_attr_init(tables_kobj
,
530 table_attr
, table_header
);
535 list_add_tail(&table_attr
->node
, &acpi_table_attr_list
);
536 acpi_table_data_init(table_header
);
539 kobject_uevent(tables_kobj
, KOBJ_ADD
);
540 kobject_uevent(tables_data_kobj
, KOBJ_ADD
);
541 kobject_uevent(dynamic_tables_kobj
, KOBJ_ADD
);
545 kobject_put(tables_data_kobj
);
547 kobject_put(tables_kobj
);
553 * Detailed ACPI IRQ counters:
554 * /sys/firmware/acpi/interrupts/
557 u32 acpi_irq_handled
;
558 u32 acpi_irq_not_handled
;
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
566 struct event_counter
{
571 static struct event_counter
*all_counters
;
573 static u32 num_counters
;
574 static struct attribute
**all_attrs
;
575 static u32 acpi_gpe_count
;
577 static struct attribute_group interrupt_stats_attr_group
= {
578 .name
= "interrupts",
581 static struct kobj_attribute
*counter_attrs
;
583 static void delete_gpe_attr_array(void)
585 struct event_counter
*tmp
= all_counters
;
593 for (i
= 0; i
< num_gpes
; i
++)
594 kfree(counter_attrs
[i
].attr
.name
);
596 kfree(counter_attrs
);
603 static void gpe_count(u32 gpe_number
)
610 if (gpe_number
< num_gpes
)
611 all_counters
[gpe_number
].count
++;
613 all_counters
[num_gpes
+ ACPI_NUM_FIXED_EVENTS
+
614 COUNT_ERROR
].count
++;
619 static void fixed_event_count(u32 event_number
)
624 if (event_number
< ACPI_NUM_FIXED_EVENTS
)
625 all_counters
[num_gpes
+ event_number
].count
++;
627 all_counters
[num_gpes
+ ACPI_NUM_FIXED_EVENTS
+
628 COUNT_ERROR
].count
++;
633 static void acpi_global_event_handler(u32 event_type
, acpi_handle device
,
634 u32 event_number
, void *context
)
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
);
643 pr_debug("Other event 0x%02x\n", event_number
);
647 static int get_status(u32 index
, acpi_event_status
*status
,
652 if (index
>= num_gpes
+ ACPI_NUM_FIXED_EVENTS
)
655 if (index
< num_gpes
) {
656 result
= acpi_get_gpe_device(index
, handle
);
658 ACPI_EXCEPTION((AE_INFO
, AE_NOT_FOUND
,
659 "Invalid GPE 0x%x", index
));
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
);
669 static ssize_t
counter_show(struct kobject
*kobj
,
670 struct kobj_attribute
*attr
, char *buf
)
672 int index
= attr
- counter_attrs
;
675 acpi_event_status status
;
678 all_counters
[num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ COUNT_SCI
].count
=
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
=
684 size
= sprintf(buf
, "%8u", all_counters
[index
].count
);
686 /* "gpe_all" or "sci" */
687 if (index
>= num_gpes
+ ACPI_NUM_FIXED_EVENTS
)
690 result
= get_status(index
, &status
, &handle
);
694 if (status
& ACPI_EVENT_FLAG_ENABLE_SET
)
695 size
+= sprintf(buf
+ size
, " EN");
697 size
+= sprintf(buf
+ size
, " ");
698 if (status
& ACPI_EVENT_FLAG_STATUS_SET
)
699 size
+= sprintf(buf
+ size
, " STS");
701 size
+= sprintf(buf
+ size
, " ");
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");
710 size
+= sprintf(buf
+ size
, " disabled ");
711 if (status
& ACPI_EVENT_FLAG_MASKED
)
712 size
+= sprintf(buf
+ size
, " masked ");
714 size
+= sprintf(buf
+ size
, " unmasked");
717 size
+= sprintf(buf
+ size
, "\n");
718 return result
? result
: size
;
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.
726 static ssize_t
counter_set(struct kobject
*kobj
,
727 struct kobj_attribute
*attr
, const char *buf
,
730 int index
= attr
- counter_attrs
;
731 acpi_event_status status
;
736 if (index
== num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ COUNT_SCI
) {
738 for (i
= 0; i
< num_counters
; ++i
)
739 all_counters
[i
].count
= 0;
741 acpi_irq_handled
= 0;
742 acpi_irq_not_handled
= 0;
746 /* show the event status for both GPEs and Fixed Events */
747 result
= get_status(index
, &status
, &handle
);
751 if (!(status
& ACPI_EVENT_FLAG_HAS_HANDLER
)) {
752 printk(KERN_WARNING PREFIX
753 "Can not change Invalid GPE/Fixed Event status\n");
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
;
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
;
791 all_counters
[index
].count
= strtoul(buf
, NULL
, 0);
793 if (ACPI_FAILURE(result
))
796 return result
? result
: size
;
800 * A Quirk Mechanism for GPE Flooding Prevention:
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
811 * The masking status can be modified by the following runtime controlling
813 * echo unmask > /sys/firmware/acpi/interrupts/gpe00
817 * Currently, the GPE flooding prevention only supports to mask the GPEs
818 * numbered from 00 to 7f.
820 #define ACPI_MASKABLE_GPE_MAX 0x80
822 static u64 __initdata acpi_masked_gpes
;
824 static int __init
acpi_gpe_set_masked_gpes(char *val
)
828 if (kstrtou8(val
, 0, &gpe
) || gpe
> ACPI_MASKABLE_GPE_MAX
)
830 acpi_masked_gpes
|= ((u64
)1<<gpe
);
834 __setup("acpi_mask_gpe=", acpi_gpe_set_masked_gpes
);
836 void __init
acpi_gpe_apply_masked_gpes(void)
843 gpe
< min_t(u8
, ACPI_MASKABLE_GPE_MAX
, acpi_current_gpe_count
);
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
);
855 void acpi_irq_stats_init(void)
863 num_gpes
= acpi_current_gpe_count
;
864 num_counters
= num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ NUM_COUNTERS_EXTRA
;
866 all_attrs
= kzalloc(sizeof(struct attribute
*) * (num_counters
+ 1),
868 if (all_attrs
== NULL
)
871 all_counters
= kzalloc(sizeof(struct event_counter
) * (num_counters
),
873 if (all_counters
== NULL
)
876 status
= acpi_install_global_event_handler(acpi_global_event_handler
, NULL
);
877 if (ACPI_FAILURE(status
))
880 counter_attrs
= kzalloc(sizeof(struct kobj_attribute
) * (num_counters
),
882 if (counter_attrs
== NULL
)
885 for (i
= 0; i
< num_counters
; ++i
) {
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");
910 sprintf(buffer
, "bug%02X", i
);
912 name
= kstrdup(buffer
, GFP_KERNEL
);
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
;
922 all_attrs
[i
] = &counter_attrs
[i
].attr
;
925 interrupt_stats_attr_group
.attrs
= all_attrs
;
926 if (!sysfs_create_group(acpi_kobj
, &interrupt_stats_attr_group
))
930 delete_gpe_attr_array();
934 static void __exit
interrupt_stats_exit(void)
936 sysfs_remove_group(acpi_kobj
, &interrupt_stats_attr_group
);
938 delete_gpe_attr_array();
944 acpi_show_profile(struct device
*dev
, struct device_attribute
*attr
,
947 return sprintf(buf
, "%d\n", acpi_gbl_FADT
.preferred_profile
);
950 static const struct device_attribute pm_profile_attr
=
951 __ATTR(pm_profile
, S_IRUGO
, acpi_show_profile
, NULL
);
953 static ssize_t
hotplug_enabled_show(struct kobject
*kobj
,
954 struct kobj_attribute
*attr
, char *buf
)
956 struct acpi_hotplug_profile
*hotplug
= to_acpi_hotplug_profile(kobj
);
958 return sprintf(buf
, "%d\n", hotplug
->enabled
);
961 static ssize_t
hotplug_enabled_store(struct kobject
*kobj
,
962 struct kobj_attribute
*attr
,
963 const char *buf
, size_t size
)
965 struct acpi_hotplug_profile
*hotplug
= to_acpi_hotplug_profile(kobj
);
968 if (kstrtouint(buf
, 10, &val
) || val
> 1)
971 acpi_scan_hotplug_enabled(hotplug
, val
);
975 static struct kobj_attribute hotplug_enabled_attr
=
976 __ATTR(enabled
, S_IRUGO
| S_IWUSR
, hotplug_enabled_show
,
977 hotplug_enabled_store
);
979 static struct attribute
*hotplug_profile_attrs
[] = {
980 &hotplug_enabled_attr
.attr
,
984 static struct kobj_type acpi_hotplug_profile_ktype
= {
985 .sysfs_ops
= &kobj_sysfs_ops
,
986 .default_attrs
= hotplug_profile_attrs
,
989 void acpi_sysfs_add_hotplug_profile(struct acpi_hotplug_profile
*hotplug
,
997 error
= kobject_init_and_add(&hotplug
->kobj
,
998 &acpi_hotplug_profile_ktype
, hotplug_kobj
, "%s", name
);
1002 kobject_uevent(&hotplug
->kobj
, KOBJ_ADD
);
1006 pr_err(PREFIX
"Unable to add hotplug profile '%s'\n", name
);
1009 static ssize_t
force_remove_show(struct kobject
*kobj
,
1010 struct kobj_attribute
*attr
, char *buf
)
1012 return sprintf(buf
, "%d\n", 0);
1015 static ssize_t
force_remove_store(struct kobject
*kobj
,
1016 struct kobj_attribute
*attr
,
1017 const char *buf
, size_t size
)
1022 ret
= strtobool(buf
, &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");
1033 static const struct kobj_attribute force_remove_attr
=
1034 __ATTR(force_remove
, S_IRUGO
| S_IWUSR
, force_remove_show
,
1035 force_remove_store
);
1037 int __init
acpi_sysfs_init(void)
1041 result
= acpi_tables_sysfs_init();
1045 hotplug_kobj
= kobject_create_and_add("hotplug", acpi_kobj
);
1049 result
= sysfs_create_file(hotplug_kobj
, &force_remove_attr
.attr
);
1053 result
= sysfs_create_file(acpi_kobj
, &pm_profile_attr
.attr
);