2 * sysfs.c - ACPI sysfs interface to userspace.
5 #include <linux/init.h>
6 #include <linux/kernel.h>
7 #include <linux/moduleparam.h>
8 #include <acpi/acpi_drivers.h>
12 #define _COMPONENT ACPI_SYSTEM_COMPONENT
13 ACPI_MODULE_NAME("sysfs");
15 #define PREFIX "ACPI: "
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
),
75 ACPI_DEBUG_INIT(ACPI_LV_INIT_NAMES
),
76 ACPI_DEBUG_INIT(ACPI_LV_PARSE
),
77 ACPI_DEBUG_INIT(ACPI_LV_LOAD
),
78 ACPI_DEBUG_INIT(ACPI_LV_DISPATCH
),
79 ACPI_DEBUG_INIT(ACPI_LV_EXEC
),
80 ACPI_DEBUG_INIT(ACPI_LV_NAMES
),
81 ACPI_DEBUG_INIT(ACPI_LV_OPREGION
),
82 ACPI_DEBUG_INIT(ACPI_LV_BFIELD
),
83 ACPI_DEBUG_INIT(ACPI_LV_TABLES
),
84 ACPI_DEBUG_INIT(ACPI_LV_VALUES
),
85 ACPI_DEBUG_INIT(ACPI_LV_OBJECTS
),
86 ACPI_DEBUG_INIT(ACPI_LV_RESOURCES
),
87 ACPI_DEBUG_INIT(ACPI_LV_USER_REQUESTS
),
88 ACPI_DEBUG_INIT(ACPI_LV_PACKAGE
),
90 ACPI_DEBUG_INIT(ACPI_LV_ALLOCATIONS
),
91 ACPI_DEBUG_INIT(ACPI_LV_FUNCTIONS
),
92 ACPI_DEBUG_INIT(ACPI_LV_OPTIMIZATIONS
),
94 ACPI_DEBUG_INIT(ACPI_LV_MUTEX
),
95 ACPI_DEBUG_INIT(ACPI_LV_THREADS
),
96 ACPI_DEBUG_INIT(ACPI_LV_IO
),
97 ACPI_DEBUG_INIT(ACPI_LV_INTERRUPTS
),
99 ACPI_DEBUG_INIT(ACPI_LV_AML_DISASSEMBLE
),
100 ACPI_DEBUG_INIT(ACPI_LV_VERBOSE_INFO
),
101 ACPI_DEBUG_INIT(ACPI_LV_FULL_TABLES
),
102 ACPI_DEBUG_INIT(ACPI_LV_EVENTS
),
105 static int param_get_debug_layer(char *buffer
, const struct kernel_param
*kp
)
110 result
= sprintf(buffer
, "%-25s\tHex SET\n", "Description");
112 for (i
= 0; i
< ARRAY_SIZE(acpi_debug_layers
); i
++) {
113 result
+= sprintf(buffer
+ result
, "%-25s\t0x%08lX [%c]\n",
114 acpi_debug_layers
[i
].name
,
115 acpi_debug_layers
[i
].value
,
116 (acpi_dbg_layer
& acpi_debug_layers
[i
].value
)
120 sprintf(buffer
+ result
, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
122 (acpi_dbg_layer
& ACPI_ALL_DRIVERS
) ==
123 ACPI_ALL_DRIVERS
? '*' : (acpi_dbg_layer
& ACPI_ALL_DRIVERS
)
126 sprintf(buffer
+ result
,
127 "--\ndebug_layer = 0x%08X ( * = enabled)\n",
133 static int param_get_debug_level(char *buffer
, const struct kernel_param
*kp
)
138 result
= sprintf(buffer
, "%-25s\tHex SET\n", "Description");
140 for (i
= 0; i
< ARRAY_SIZE(acpi_debug_levels
); i
++) {
141 result
+= sprintf(buffer
+ result
, "%-25s\t0x%08lX [%c]\n",
142 acpi_debug_levels
[i
].name
,
143 acpi_debug_levels
[i
].value
,
144 (acpi_dbg_level
& acpi_debug_levels
[i
].value
)
148 sprintf(buffer
+ result
, "--\ndebug_level = 0x%08X (* = enabled)\n",
154 static const struct kernel_param_ops param_ops_debug_layer
= {
155 .set
= param_set_uint
,
156 .get
= param_get_debug_layer
,
159 static const struct kernel_param_ops param_ops_debug_level
= {
160 .set
= param_set_uint
,
161 .get
= param_get_debug_level
,
164 module_param_cb(debug_layer
, ¶m_ops_debug_layer
, &acpi_dbg_layer
, 0644);
165 module_param_cb(debug_level
, ¶m_ops_debug_level
, &acpi_dbg_level
, 0644);
167 static char trace_method_name
[6];
168 module_param_string(trace_method_name
, trace_method_name
, 6, 0644);
169 static unsigned int trace_debug_layer
;
170 module_param(trace_debug_layer
, uint
, 0644);
171 static unsigned int trace_debug_level
;
172 module_param(trace_debug_level
, uint
, 0644);
174 static int param_set_trace_state(const char *val
, struct kernel_param
*kp
)
178 if (!strncmp(val
, "enable", sizeof("enable") - 1)) {
179 result
= acpi_debug_trace(trace_method_name
, trace_debug_level
,
180 trace_debug_layer
, 0);
186 if (!strncmp(val
, "disable", sizeof("disable") - 1)) {
188 result
= acpi_debug_trace((char *)&name
, trace_debug_level
,
189 trace_debug_layer
, 0);
195 if (!strncmp(val
, "1", 1)) {
196 result
= acpi_debug_trace(trace_method_name
, trace_debug_level
,
197 trace_debug_layer
, 1);
208 static int param_get_trace_state(char *buffer
, struct kernel_param
*kp
)
210 if (!acpi_gbl_trace_method_name
)
211 return sprintf(buffer
, "disable");
213 if (acpi_gbl_trace_flags
& 1)
214 return sprintf(buffer
, "1");
216 return sprintf(buffer
, "enable");
221 module_param_call(trace_state
, param_set_trace_state
, param_get_trace_state
,
223 #endif /* CONFIG_ACPI_DEBUG */
226 /* /sys/modules/acpi/parameters/aml_debug_output */
228 module_param_named(aml_debug_output
, acpi_gbl_enable_aml_debug_object
,
230 MODULE_PARM_DESC(aml_debug_output
,
231 "To enable/disable the ACPI Debug Object output.");
233 /* /sys/module/acpi/parameters/acpica_version */
234 static int param_get_acpica_version(char *buffer
, struct kernel_param
*kp
)
238 result
= sprintf(buffer
, "%x", ACPI_CA_VERSION
);
243 module_param_call(acpica_version
, NULL
, param_get_acpica_version
, NULL
, 0444);
246 * ACPI table sysfs I/F:
247 * /sys/firmware/acpi/tables/
248 * /sys/firmware/acpi/tables/dynamic/
251 static LIST_HEAD(acpi_table_attr_list
);
252 static struct kobject
*tables_kobj
;
253 static struct kobject
*dynamic_tables_kobj
;
254 static struct kobject
*hotplug_kobj
;
256 struct acpi_table_attr
{
257 struct bin_attribute attr
;
260 struct list_head node
;
263 static ssize_t
acpi_table_show(struct file
*filp
, struct kobject
*kobj
,
264 struct bin_attribute
*bin_attr
, char *buf
,
265 loff_t offset
, size_t count
)
267 struct acpi_table_attr
*table_attr
=
268 container_of(bin_attr
, struct acpi_table_attr
, attr
);
269 struct acpi_table_header
*table_header
= NULL
;
271 char name
[ACPI_NAME_SIZE
];
273 if (strncmp(table_attr
->name
, "NULL", 4))
274 memcpy(name
, table_attr
->name
, ACPI_NAME_SIZE
);
276 memcpy(name
, "\0\0\0\0", 4);
278 status
= acpi_get_table(name
, table_attr
->instance
, &table_header
);
279 if (ACPI_FAILURE(status
))
282 return memory_read_from_buffer(buf
, count
, &offset
,
283 table_header
, table_header
->length
);
286 static void acpi_table_attr_init(struct acpi_table_attr
*table_attr
,
287 struct acpi_table_header
*table_header
)
289 struct acpi_table_header
*header
= NULL
;
290 struct acpi_table_attr
*attr
= NULL
;
292 sysfs_attr_init(&table_attr
->attr
.attr
);
293 if (table_header
->signature
[0] != '\0')
294 memcpy(table_attr
->name
, table_header
->signature
,
297 memcpy(table_attr
->name
, "NULL", 4);
299 list_for_each_entry(attr
, &acpi_table_attr_list
, node
) {
300 if (!memcmp(table_attr
->name
, attr
->name
, ACPI_NAME_SIZE
))
301 if (table_attr
->instance
< attr
->instance
)
302 table_attr
->instance
= attr
->instance
;
304 table_attr
->instance
++;
306 if (table_attr
->instance
> 1 || (table_attr
->instance
== 1 &&
308 (table_header
->signature
, 2, &header
)))
309 sprintf(table_attr
->name
+ ACPI_NAME_SIZE
, "%d",
310 table_attr
->instance
);
312 table_attr
->attr
.size
= 0;
313 table_attr
->attr
.read
= acpi_table_show
;
314 table_attr
->attr
.attr
.name
= table_attr
->name
;
315 table_attr
->attr
.attr
.mode
= 0400;
321 acpi_sysfs_table_handler(u32 event
, void *table
, void *context
)
323 struct acpi_table_attr
*table_attr
;
326 case ACPI_TABLE_EVENT_LOAD
:
328 kzalloc(sizeof(struct acpi_table_attr
), GFP_KERNEL
);
332 acpi_table_attr_init(table_attr
, table
);
333 if (sysfs_create_bin_file(dynamic_tables_kobj
,
334 &table_attr
->attr
)) {
338 list_add_tail(&table_attr
->node
, &acpi_table_attr_list
);
340 case ACPI_TABLE_EVENT_UNLOAD
:
342 * we do not need to do anything right now
343 * because the table is not deleted from the
344 * global table list when unloading it.
348 return AE_BAD_PARAMETER
;
353 static int acpi_tables_sysfs_init(void)
355 struct acpi_table_attr
*table_attr
;
356 struct acpi_table_header
*table_header
= NULL
;
360 tables_kobj
= kobject_create_and_add("tables", acpi_kobj
);
364 dynamic_tables_kobj
= kobject_create_and_add("dynamic", tables_kobj
);
365 if (!dynamic_tables_kobj
)
366 goto err_dynamic_tables
;
369 result
= acpi_get_table_by_index(table_index
, &table_header
);
374 kzalloc(sizeof(struct acpi_table_attr
), GFP_KERNEL
);
378 acpi_table_attr_init(table_attr
, table_header
);
380 sysfs_create_bin_file(tables_kobj
,
386 list_add_tail(&table_attr
->node
,
387 &acpi_table_attr_list
);
390 kobject_uevent(tables_kobj
, KOBJ_ADD
);
391 kobject_uevent(dynamic_tables_kobj
, KOBJ_ADD
);
392 result
= acpi_install_table_handler(acpi_sysfs_table_handler
, NULL
);
394 return result
== AE_OK
? 0 : -EINVAL
;
396 kobject_put(tables_kobj
);
402 * Detailed ACPI IRQ counters:
403 * /sys/firmware/acpi/interrupts/
406 u32 acpi_irq_handled
;
407 u32 acpi_irq_not_handled
;
410 #define COUNT_SCI 1 /* acpi_irq_handled */
411 #define COUNT_SCI_NOT 2 /* acpi_irq_not_handled */
412 #define COUNT_ERROR 3 /* other */
413 #define NUM_COUNTERS_EXTRA 4
415 struct event_counter
{
420 static struct event_counter
*all_counters
;
422 static u32 num_counters
;
423 static struct attribute
**all_attrs
;
424 static u32 acpi_gpe_count
;
426 static struct attribute_group interrupt_stats_attr_group
= {
427 .name
= "interrupts",
430 static struct kobj_attribute
*counter_attrs
;
432 static void delete_gpe_attr_array(void)
434 struct event_counter
*tmp
= all_counters
;
442 for (i
= 0; i
< num_gpes
; i
++)
443 kfree(counter_attrs
[i
].attr
.name
);
445 kfree(counter_attrs
);
452 static void gpe_count(u32 gpe_number
)
459 if (gpe_number
< num_gpes
)
460 all_counters
[gpe_number
].count
++;
462 all_counters
[num_gpes
+ ACPI_NUM_FIXED_EVENTS
+
463 COUNT_ERROR
].count
++;
468 static void fixed_event_count(u32 event_number
)
473 if (event_number
< ACPI_NUM_FIXED_EVENTS
)
474 all_counters
[num_gpes
+ event_number
].count
++;
476 all_counters
[num_gpes
+ ACPI_NUM_FIXED_EVENTS
+
477 COUNT_ERROR
].count
++;
482 static void acpi_global_event_handler(u32 event_type
, acpi_handle device
,
483 u32 event_number
, void *context
)
485 if (event_type
== ACPI_EVENT_TYPE_GPE
)
486 gpe_count(event_number
);
488 if (event_type
== ACPI_EVENT_TYPE_FIXED
)
489 fixed_event_count(event_number
);
492 static int get_status(u32 index
, acpi_event_status
*status
,
497 if (index
>= num_gpes
+ ACPI_NUM_FIXED_EVENTS
)
500 if (index
< num_gpes
) {
501 result
= acpi_get_gpe_device(index
, handle
);
503 ACPI_EXCEPTION((AE_INFO
, AE_NOT_FOUND
,
504 "Invalid GPE 0x%x", index
));
507 result
= acpi_get_gpe_status(*handle
, index
, status
);
508 } else if (index
< (num_gpes
+ ACPI_NUM_FIXED_EVENTS
))
509 result
= acpi_get_event_status(index
- num_gpes
, status
);
515 static ssize_t
counter_show(struct kobject
*kobj
,
516 struct kobj_attribute
*attr
, char *buf
)
518 int index
= attr
- counter_attrs
;
521 acpi_event_status status
;
524 all_counters
[num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ COUNT_SCI
].count
=
526 all_counters
[num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ COUNT_SCI_NOT
].count
=
527 acpi_irq_not_handled
;
528 all_counters
[num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ COUNT_GPE
].count
=
530 size
= sprintf(buf
, "%8d", all_counters
[index
].count
);
532 /* "gpe_all" or "sci" */
533 if (index
>= num_gpes
+ ACPI_NUM_FIXED_EVENTS
)
536 result
= get_status(index
, &status
, &handle
);
540 if (!(status
& ACPI_EVENT_FLAG_HANDLE
))
541 size
+= sprintf(buf
+ size
, " invalid");
542 else if (status
& ACPI_EVENT_FLAG_ENABLED
)
543 size
+= sprintf(buf
+ size
, " enabled");
544 else if (status
& ACPI_EVENT_FLAG_WAKE_ENABLED
)
545 size
+= sprintf(buf
+ size
, " wake_enabled");
547 size
+= sprintf(buf
+ size
, " disabled");
550 size
+= sprintf(buf
+ size
, "\n");
551 return result
? result
: size
;
555 * counter_set() sets the specified counter.
556 * setting the total "sci" file to any value clears all counters.
557 * enable/disable/clear a gpe/fixed event in user space.
559 static ssize_t
counter_set(struct kobject
*kobj
,
560 struct kobj_attribute
*attr
, const char *buf
,
563 int index
= attr
- counter_attrs
;
564 acpi_event_status status
;
569 if (index
== num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ COUNT_SCI
) {
571 for (i
= 0; i
< num_counters
; ++i
)
572 all_counters
[i
].count
= 0;
574 acpi_irq_handled
= 0;
575 acpi_irq_not_handled
= 0;
579 /* show the event status for both GPEs and Fixed Events */
580 result
= get_status(index
, &status
, &handle
);
584 if (!(status
& ACPI_EVENT_FLAG_HANDLE
)) {
585 printk(KERN_WARNING PREFIX
586 "Can not change Invalid GPE/Fixed Event status\n");
590 if (index
< num_gpes
) {
591 if (!strcmp(buf
, "disable\n") &&
592 (status
& ACPI_EVENT_FLAG_ENABLED
))
593 result
= acpi_disable_gpe(handle
, index
);
594 else if (!strcmp(buf
, "enable\n") &&
595 !(status
& ACPI_EVENT_FLAG_ENABLED
))
596 result
= acpi_enable_gpe(handle
, index
);
597 else if (!strcmp(buf
, "clear\n") &&
598 (status
& ACPI_EVENT_FLAG_SET
))
599 result
= acpi_clear_gpe(handle
, index
);
600 else if (!kstrtoul(buf
, 0, &tmp
))
601 all_counters
[index
].count
= tmp
;
604 } else if (index
< num_gpes
+ ACPI_NUM_FIXED_EVENTS
) {
605 int event
= index
- num_gpes
;
606 if (!strcmp(buf
, "disable\n") &&
607 (status
& ACPI_EVENT_FLAG_ENABLED
))
608 result
= acpi_disable_event(event
, ACPI_NOT_ISR
);
609 else if (!strcmp(buf
, "enable\n") &&
610 !(status
& ACPI_EVENT_FLAG_ENABLED
))
611 result
= acpi_enable_event(event
, ACPI_NOT_ISR
);
612 else if (!strcmp(buf
, "clear\n") &&
613 (status
& ACPI_EVENT_FLAG_SET
))
614 result
= acpi_clear_event(event
);
615 else if (!kstrtoul(buf
, 0, &tmp
))
616 all_counters
[index
].count
= tmp
;
620 all_counters
[index
].count
= strtoul(buf
, NULL
, 0);
622 if (ACPI_FAILURE(result
))
625 return result
? result
: size
;
628 void acpi_irq_stats_init(void)
636 num_gpes
= acpi_current_gpe_count
;
637 num_counters
= num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ NUM_COUNTERS_EXTRA
;
639 all_attrs
= kzalloc(sizeof(struct attribute
*) * (num_counters
+ 1),
641 if (all_attrs
== NULL
)
644 all_counters
= kzalloc(sizeof(struct event_counter
) * (num_counters
),
646 if (all_counters
== NULL
)
649 status
= acpi_install_global_event_handler(acpi_global_event_handler
, NULL
);
650 if (ACPI_FAILURE(status
))
653 counter_attrs
= kzalloc(sizeof(struct kobj_attribute
) * (num_counters
),
655 if (counter_attrs
== NULL
)
658 for (i
= 0; i
< num_counters
; ++i
) {
663 sprintf(buffer
, "gpe%02X", i
);
664 else if (i
== num_gpes
+ ACPI_EVENT_PMTIMER
)
665 sprintf(buffer
, "ff_pmtimer");
666 else if (i
== num_gpes
+ ACPI_EVENT_GLOBAL
)
667 sprintf(buffer
, "ff_gbl_lock");
668 else if (i
== num_gpes
+ ACPI_EVENT_POWER_BUTTON
)
669 sprintf(buffer
, "ff_pwr_btn");
670 else if (i
== num_gpes
+ ACPI_EVENT_SLEEP_BUTTON
)
671 sprintf(buffer
, "ff_slp_btn");
672 else if (i
== num_gpes
+ ACPI_EVENT_RTC
)
673 sprintf(buffer
, "ff_rt_clk");
674 else if (i
== num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ COUNT_GPE
)
675 sprintf(buffer
, "gpe_all");
676 else if (i
== num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ COUNT_SCI
)
677 sprintf(buffer
, "sci");
678 else if (i
== num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ COUNT_SCI_NOT
)
679 sprintf(buffer
, "sci_not");
680 else if (i
== num_gpes
+ ACPI_NUM_FIXED_EVENTS
+ COUNT_ERROR
)
681 sprintf(buffer
, "error");
683 sprintf(buffer
, "bug%02X", i
);
685 name
= kstrdup(buffer
, GFP_KERNEL
);
689 sysfs_attr_init(&counter_attrs
[i
].attr
);
690 counter_attrs
[i
].attr
.name
= name
;
691 counter_attrs
[i
].attr
.mode
= 0644;
692 counter_attrs
[i
].show
= counter_show
;
693 counter_attrs
[i
].store
= counter_set
;
695 all_attrs
[i
] = &counter_attrs
[i
].attr
;
698 interrupt_stats_attr_group
.attrs
= all_attrs
;
699 if (!sysfs_create_group(acpi_kobj
, &interrupt_stats_attr_group
))
703 delete_gpe_attr_array();
707 static void __exit
interrupt_stats_exit(void)
709 sysfs_remove_group(acpi_kobj
, &interrupt_stats_attr_group
);
711 delete_gpe_attr_array();
717 acpi_show_profile(struct device
*dev
, struct device_attribute
*attr
,
720 return sprintf(buf
, "%d\n", acpi_gbl_FADT
.preferred_profile
);
723 static const struct device_attribute pm_profile_attr
=
724 __ATTR(pm_profile
, S_IRUGO
, acpi_show_profile
, NULL
);
726 static ssize_t
hotplug_enabled_show(struct kobject
*kobj
,
727 struct kobj_attribute
*attr
, char *buf
)
729 struct acpi_hotplug_profile
*hotplug
= to_acpi_hotplug_profile(kobj
);
731 return sprintf(buf
, "%d\n", hotplug
->enabled
);
734 static ssize_t
hotplug_enabled_store(struct kobject
*kobj
,
735 struct kobj_attribute
*attr
,
736 const char *buf
, size_t size
)
738 struct acpi_hotplug_profile
*hotplug
= to_acpi_hotplug_profile(kobj
);
741 if (kstrtouint(buf
, 10, &val
) || val
> 1)
744 acpi_scan_hotplug_enabled(hotplug
, val
);
748 static struct kobj_attribute hotplug_enabled_attr
=
749 __ATTR(enabled
, S_IRUGO
| S_IWUSR
, hotplug_enabled_show
,
750 hotplug_enabled_store
);
752 static struct attribute
*hotplug_profile_attrs
[] = {
753 &hotplug_enabled_attr
.attr
,
757 static struct kobj_type acpi_hotplug_profile_ktype
= {
758 .sysfs_ops
= &kobj_sysfs_ops
,
759 .default_attrs
= hotplug_profile_attrs
,
762 void acpi_sysfs_add_hotplug_profile(struct acpi_hotplug_profile
*hotplug
,
770 error
= kobject_init_and_add(&hotplug
->kobj
,
771 &acpi_hotplug_profile_ktype
, hotplug_kobj
, "%s", name
);
775 kobject_uevent(&hotplug
->kobj
, KOBJ_ADD
);
779 pr_err(PREFIX
"Unable to add hotplug profile '%s'\n", name
);
782 static ssize_t
force_remove_show(struct kobject
*kobj
,
783 struct kobj_attribute
*attr
, char *buf
)
785 return sprintf(buf
, "%d\n", !!acpi_force_hot_remove
);
788 static ssize_t
force_remove_store(struct kobject
*kobj
,
789 struct kobj_attribute
*attr
,
790 const char *buf
, size_t size
)
795 ret
= strtobool(buf
, &val
);
799 lock_device_hotplug();
800 acpi_force_hot_remove
= val
;
801 unlock_device_hotplug();
805 static const struct kobj_attribute force_remove_attr
=
806 __ATTR(force_remove
, S_IRUGO
| S_IWUSR
, force_remove_show
,
809 int __init
acpi_sysfs_init(void)
813 result
= acpi_tables_sysfs_init();
817 hotplug_kobj
= kobject_create_and_add("hotplug", acpi_kobj
);
818 result
= sysfs_create_file(hotplug_kobj
, &force_remove_attr
.attr
);
822 result
= sysfs_create_file(acpi_kobj
, &pm_profile_attr
.attr
);