xref: /openbmc/linux/drivers/acpi/sysfs.c (revision c819e2cf)
1 /*
2  * sysfs.c - ACPI sysfs interface to userspace.
3  */
4 
5 #include <linux/init.h>
6 #include <linux/kernel.h>
7 #include <linux/moduleparam.h>
8 #include <linux/acpi.h>
9 
10 #include "internal.h"
11 
12 #define _COMPONENT		ACPI_SYSTEM_COMPONENT
13 ACPI_MODULE_NAME("sysfs");
14 
15 #ifdef CONFIG_ACPI_DEBUG
16 /*
17  * ACPI debug sysfs I/F, including:
18  * /sys/modules/acpi/parameters/debug_layer
19  * /sys/modules/acpi/parameters/debug_level
20  * /sys/modules/acpi/parameters/trace_method_name
21  * /sys/modules/acpi/parameters/trace_state
22  * /sys/modules/acpi/parameters/trace_debug_layer
23  * /sys/modules/acpi/parameters/trace_debug_level
24  */
25 
26 struct acpi_dlayer {
27 	const char *name;
28 	unsigned long value;
29 };
30 struct acpi_dlevel {
31 	const char *name;
32 	unsigned long value;
33 };
34 #define ACPI_DEBUG_INIT(v)	{ .name = #v, .value = v }
35 
36 static const struct acpi_dlayer acpi_debug_layers[] = {
37 	ACPI_DEBUG_INIT(ACPI_UTILITIES),
38 	ACPI_DEBUG_INIT(ACPI_HARDWARE),
39 	ACPI_DEBUG_INIT(ACPI_EVENTS),
40 	ACPI_DEBUG_INIT(ACPI_TABLES),
41 	ACPI_DEBUG_INIT(ACPI_NAMESPACE),
42 	ACPI_DEBUG_INIT(ACPI_PARSER),
43 	ACPI_DEBUG_INIT(ACPI_DISPATCHER),
44 	ACPI_DEBUG_INIT(ACPI_EXECUTER),
45 	ACPI_DEBUG_INIT(ACPI_RESOURCES),
46 	ACPI_DEBUG_INIT(ACPI_CA_DEBUGGER),
47 	ACPI_DEBUG_INIT(ACPI_OS_SERVICES),
48 	ACPI_DEBUG_INIT(ACPI_CA_DISASSEMBLER),
49 	ACPI_DEBUG_INIT(ACPI_COMPILER),
50 	ACPI_DEBUG_INIT(ACPI_TOOLS),
51 
52 	ACPI_DEBUG_INIT(ACPI_BUS_COMPONENT),
53 	ACPI_DEBUG_INIT(ACPI_AC_COMPONENT),
54 	ACPI_DEBUG_INIT(ACPI_BATTERY_COMPONENT),
55 	ACPI_DEBUG_INIT(ACPI_BUTTON_COMPONENT),
56 	ACPI_DEBUG_INIT(ACPI_SBS_COMPONENT),
57 	ACPI_DEBUG_INIT(ACPI_FAN_COMPONENT),
58 	ACPI_DEBUG_INIT(ACPI_PCI_COMPONENT),
59 	ACPI_DEBUG_INIT(ACPI_POWER_COMPONENT),
60 	ACPI_DEBUG_INIT(ACPI_CONTAINER_COMPONENT),
61 	ACPI_DEBUG_INIT(ACPI_SYSTEM_COMPONENT),
62 	ACPI_DEBUG_INIT(ACPI_THERMAL_COMPONENT),
63 	ACPI_DEBUG_INIT(ACPI_MEMORY_DEVICE_COMPONENT),
64 	ACPI_DEBUG_INIT(ACPI_VIDEO_COMPONENT),
65 	ACPI_DEBUG_INIT(ACPI_PROCESSOR_COMPONENT),
66 };
67 
68 static const struct acpi_dlevel acpi_debug_levels[] = {
69 	ACPI_DEBUG_INIT(ACPI_LV_INIT),
70 	ACPI_DEBUG_INIT(ACPI_LV_DEBUG_OBJECT),
71 	ACPI_DEBUG_INIT(ACPI_LV_INFO),
72 
73 	ACPI_DEBUG_INIT(ACPI_LV_INIT_NAMES),
74 	ACPI_DEBUG_INIT(ACPI_LV_PARSE),
75 	ACPI_DEBUG_INIT(ACPI_LV_LOAD),
76 	ACPI_DEBUG_INIT(ACPI_LV_DISPATCH),
77 	ACPI_DEBUG_INIT(ACPI_LV_EXEC),
78 	ACPI_DEBUG_INIT(ACPI_LV_NAMES),
79 	ACPI_DEBUG_INIT(ACPI_LV_OPREGION),
80 	ACPI_DEBUG_INIT(ACPI_LV_BFIELD),
81 	ACPI_DEBUG_INIT(ACPI_LV_TABLES),
82 	ACPI_DEBUG_INIT(ACPI_LV_VALUES),
83 	ACPI_DEBUG_INIT(ACPI_LV_OBJECTS),
84 	ACPI_DEBUG_INIT(ACPI_LV_RESOURCES),
85 	ACPI_DEBUG_INIT(ACPI_LV_USER_REQUESTS),
86 	ACPI_DEBUG_INIT(ACPI_LV_PACKAGE),
87 
88 	ACPI_DEBUG_INIT(ACPI_LV_ALLOCATIONS),
89 	ACPI_DEBUG_INIT(ACPI_LV_FUNCTIONS),
90 	ACPI_DEBUG_INIT(ACPI_LV_OPTIMIZATIONS),
91 
92 	ACPI_DEBUG_INIT(ACPI_LV_MUTEX),
93 	ACPI_DEBUG_INIT(ACPI_LV_THREADS),
94 	ACPI_DEBUG_INIT(ACPI_LV_IO),
95 	ACPI_DEBUG_INIT(ACPI_LV_INTERRUPTS),
96 
97 	ACPI_DEBUG_INIT(ACPI_LV_AML_DISASSEMBLE),
98 	ACPI_DEBUG_INIT(ACPI_LV_VERBOSE_INFO),
99 	ACPI_DEBUG_INIT(ACPI_LV_FULL_TABLES),
100 	ACPI_DEBUG_INIT(ACPI_LV_EVENTS),
101 };
102 
103 static int param_get_debug_layer(char *buffer, const struct kernel_param *kp)
104 {
105 	int result = 0;
106 	int i;
107 
108 	result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
109 
110 	for (i = 0; i < ARRAY_SIZE(acpi_debug_layers); i++) {
111 		result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n",
112 				  acpi_debug_layers[i].name,
113 				  acpi_debug_layers[i].value,
114 				  (acpi_dbg_layer & acpi_debug_layers[i].value)
115 				  ? '*' : ' ');
116 	}
117 	result +=
118 	    sprintf(buffer + result, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
119 		    ACPI_ALL_DRIVERS,
120 		    (acpi_dbg_layer & ACPI_ALL_DRIVERS) ==
121 		    ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer & ACPI_ALL_DRIVERS)
122 		    == 0 ? ' ' : '-');
123 	result +=
124 	    sprintf(buffer + result,
125 		    "--\ndebug_layer = 0x%08X ( * = enabled)\n",
126 		    acpi_dbg_layer);
127 
128 	return result;
129 }
130 
131 static int param_get_debug_level(char *buffer, const struct kernel_param *kp)
132 {
133 	int result = 0;
134 	int i;
135 
136 	result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
137 
138 	for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) {
139 		result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n",
140 				  acpi_debug_levels[i].name,
141 				  acpi_debug_levels[i].value,
142 				  (acpi_dbg_level & acpi_debug_levels[i].value)
143 				  ? '*' : ' ');
144 	}
145 	result +=
146 	    sprintf(buffer + result, "--\ndebug_level = 0x%08X (* = enabled)\n",
147 		    acpi_dbg_level);
148 
149 	return result;
150 }
151 
152 static const struct kernel_param_ops param_ops_debug_layer = {
153 	.set = param_set_uint,
154 	.get = param_get_debug_layer,
155 };
156 
157 static const struct kernel_param_ops param_ops_debug_level = {
158 	.set = param_set_uint,
159 	.get = param_get_debug_level,
160 };
161 
162 module_param_cb(debug_layer, &param_ops_debug_layer, &acpi_dbg_layer, 0644);
163 module_param_cb(debug_level, &param_ops_debug_level, &acpi_dbg_level, 0644);
164 
165 static char trace_method_name[6];
166 module_param_string(trace_method_name, trace_method_name, 6, 0644);
167 static unsigned int trace_debug_layer;
168 module_param(trace_debug_layer, uint, 0644);
169 static unsigned int trace_debug_level;
170 module_param(trace_debug_level, uint, 0644);
171 
172 static int param_set_trace_state(const char *val, struct kernel_param *kp)
173 {
174 	int result = 0;
175 
176 	if (!strncmp(val, "enable", sizeof("enable") - 1)) {
177 		result = acpi_debug_trace(trace_method_name, trace_debug_level,
178 					  trace_debug_layer, 0);
179 		if (result)
180 			result = -EBUSY;
181 		goto exit;
182 	}
183 
184 	if (!strncmp(val, "disable", sizeof("disable") - 1)) {
185 		int name = 0;
186 		result = acpi_debug_trace((char *)&name, trace_debug_level,
187 					  trace_debug_layer, 0);
188 		if (result)
189 			result = -EBUSY;
190 		goto exit;
191 	}
192 
193 	if (!strncmp(val, "1", 1)) {
194 		result = acpi_debug_trace(trace_method_name, trace_debug_level,
195 					  trace_debug_layer, 1);
196 		if (result)
197 			result = -EBUSY;
198 		goto exit;
199 	}
200 
201 	result = -EINVAL;
202 exit:
203 	return result;
204 }
205 
206 static int param_get_trace_state(char *buffer, struct kernel_param *kp)
207 {
208 	if (!acpi_gbl_trace_method_name)
209 		return sprintf(buffer, "disable");
210 	else {
211 		if (acpi_gbl_trace_flags & 1)
212 			return sprintf(buffer, "1");
213 		else
214 			return sprintf(buffer, "enable");
215 	}
216 	return 0;
217 }
218 
219 module_param_call(trace_state, param_set_trace_state, param_get_trace_state,
220 		  NULL, 0644);
221 #endif /* CONFIG_ACPI_DEBUG */
222 
223 
224 /* /sys/modules/acpi/parameters/aml_debug_output */
225 
226 module_param_named(aml_debug_output, acpi_gbl_enable_aml_debug_object,
227 		   byte, 0644);
228 MODULE_PARM_DESC(aml_debug_output,
229 		 "To enable/disable the ACPI Debug Object output.");
230 
231 /* /sys/module/acpi/parameters/acpica_version */
232 static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
233 {
234 	int result;
235 
236 	result = sprintf(buffer, "%x", ACPI_CA_VERSION);
237 
238 	return result;
239 }
240 
241 module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);
242 
243 /*
244  * ACPI table sysfs I/F:
245  * /sys/firmware/acpi/tables/
246  * /sys/firmware/acpi/tables/dynamic/
247  */
248 
249 static LIST_HEAD(acpi_table_attr_list);
250 static struct kobject *tables_kobj;
251 static struct kobject *dynamic_tables_kobj;
252 static struct kobject *hotplug_kobj;
253 
254 struct acpi_table_attr {
255 	struct bin_attribute attr;
256 	char name[8];
257 	int instance;
258 	struct list_head node;
259 };
260 
261 static ssize_t acpi_table_show(struct file *filp, struct kobject *kobj,
262 			       struct bin_attribute *bin_attr, char *buf,
263 			       loff_t offset, size_t count)
264 {
265 	struct acpi_table_attr *table_attr =
266 	    container_of(bin_attr, struct acpi_table_attr, attr);
267 	struct acpi_table_header *table_header = NULL;
268 	acpi_status status;
269 	char name[ACPI_NAME_SIZE];
270 
271 	if (strncmp(table_attr->name, "NULL", 4))
272 		memcpy(name, table_attr->name, ACPI_NAME_SIZE);
273 	else
274 		memcpy(name, "\0\0\0\0", 4);
275 
276 	status = acpi_get_table(name, table_attr->instance, &table_header);
277 	if (ACPI_FAILURE(status))
278 		return -ENODEV;
279 
280 	return memory_read_from_buffer(buf, count, &offset,
281 				       table_header, table_header->length);
282 }
283 
284 static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
285 				 struct acpi_table_header *table_header)
286 {
287 	struct acpi_table_header *header = NULL;
288 	struct acpi_table_attr *attr = NULL;
289 
290 	sysfs_attr_init(&table_attr->attr.attr);
291 	if (table_header->signature[0] != '\0')
292 		memcpy(table_attr->name, table_header->signature,
293 		       ACPI_NAME_SIZE);
294 	else
295 		memcpy(table_attr->name, "NULL", 4);
296 
297 	list_for_each_entry(attr, &acpi_table_attr_list, node) {
298 		if (!memcmp(table_attr->name, attr->name, ACPI_NAME_SIZE))
299 			if (table_attr->instance < attr->instance)
300 				table_attr->instance = attr->instance;
301 	}
302 	table_attr->instance++;
303 
304 	if (table_attr->instance > 1 || (table_attr->instance == 1 &&
305 					 !acpi_get_table
306 					 (table_header->signature, 2, &header)))
307 		sprintf(table_attr->name + ACPI_NAME_SIZE, "%d",
308 			table_attr->instance);
309 
310 	table_attr->attr.size = table_header->length;
311 	table_attr->attr.read = acpi_table_show;
312 	table_attr->attr.attr.name = table_attr->name;
313 	table_attr->attr.attr.mode = 0400;
314 
315 	return;
316 }
317 
318 static acpi_status
319 acpi_sysfs_table_handler(u32 event, void *table, void *context)
320 {
321 	struct acpi_table_attr *table_attr;
322 
323 	switch (event) {
324 	case ACPI_TABLE_EVENT_LOAD:
325 		table_attr =
326 		    kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
327 		if (!table_attr)
328 			return AE_NO_MEMORY;
329 
330 		acpi_table_attr_init(table_attr, table);
331 		if (sysfs_create_bin_file(dynamic_tables_kobj,
332 					  &table_attr->attr)) {
333 			kfree(table_attr);
334 			return AE_ERROR;
335 		} else
336 			list_add_tail(&table_attr->node, &acpi_table_attr_list);
337 		break;
338 	case ACPI_TABLE_EVENT_UNLOAD:
339 		/*
340 		 * we do not need to do anything right now
341 		 * because the table is not deleted from the
342 		 * global table list when unloading it.
343 		 */
344 		break;
345 	default:
346 		return AE_BAD_PARAMETER;
347 	}
348 	return AE_OK;
349 }
350 
351 static int acpi_tables_sysfs_init(void)
352 {
353 	struct acpi_table_attr *table_attr;
354 	struct acpi_table_header *table_header = NULL;
355 	int table_index;
356 	acpi_status status;
357 	int ret;
358 
359 	tables_kobj = kobject_create_and_add("tables", acpi_kobj);
360 	if (!tables_kobj)
361 		goto err;
362 
363 	dynamic_tables_kobj = kobject_create_and_add("dynamic", tables_kobj);
364 	if (!dynamic_tables_kobj)
365 		goto err_dynamic_tables;
366 
367 	for (table_index = 0;; table_index++) {
368 		status = acpi_get_table_by_index(table_index, &table_header);
369 
370 		if (status == AE_BAD_PARAMETER)
371 			break;
372 
373 		if (ACPI_FAILURE(status))
374 			continue;
375 
376 		table_attr = NULL;
377 		table_attr = kzalloc(sizeof(*table_attr), GFP_KERNEL);
378 		if (!table_attr)
379 			return -ENOMEM;
380 
381 		acpi_table_attr_init(table_attr, table_header);
382 		ret = sysfs_create_bin_file(tables_kobj, &table_attr->attr);
383 		if (ret) {
384 			kfree(table_attr);
385 			return ret;
386 		}
387 		list_add_tail(&table_attr->node, &acpi_table_attr_list);
388 	}
389 
390 	kobject_uevent(tables_kobj, KOBJ_ADD);
391 	kobject_uevent(dynamic_tables_kobj, KOBJ_ADD);
392 	status = acpi_install_table_handler(acpi_sysfs_table_handler, NULL);
393 
394 	return ACPI_FAILURE(status) ? -EINVAL : 0;
395 err_dynamic_tables:
396 	kobject_put(tables_kobj);
397 err:
398 	return -ENOMEM;
399 }
400 
401 /*
402  * Detailed ACPI IRQ counters:
403  * /sys/firmware/acpi/interrupts/
404  */
405 
406 u32 acpi_irq_handled;
407 u32 acpi_irq_not_handled;
408 
409 #define COUNT_GPE 0
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
414 
415 struct event_counter {
416 	u32 count;
417 	u32 flags;
418 };
419 
420 static struct event_counter *all_counters;
421 static u32 num_gpes;
422 static u32 num_counters;
423 static struct attribute **all_attrs;
424 static u32 acpi_gpe_count;
425 
426 static struct attribute_group interrupt_stats_attr_group = {
427 	.name = "interrupts",
428 };
429 
430 static struct kobj_attribute *counter_attrs;
431 
432 static void delete_gpe_attr_array(void)
433 {
434 	struct event_counter *tmp = all_counters;
435 
436 	all_counters = NULL;
437 	kfree(tmp);
438 
439 	if (counter_attrs) {
440 		int i;
441 
442 		for (i = 0; i < num_gpes; i++)
443 			kfree(counter_attrs[i].attr.name);
444 
445 		kfree(counter_attrs);
446 	}
447 	kfree(all_attrs);
448 
449 	return;
450 }
451 
452 static void gpe_count(u32 gpe_number)
453 {
454 	acpi_gpe_count++;
455 
456 	if (!all_counters)
457 		return;
458 
459 	if (gpe_number < num_gpes)
460 		all_counters[gpe_number].count++;
461 	else
462 		all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS +
463 			     COUNT_ERROR].count++;
464 
465 	return;
466 }
467 
468 static void fixed_event_count(u32 event_number)
469 {
470 	if (!all_counters)
471 		return;
472 
473 	if (event_number < ACPI_NUM_FIXED_EVENTS)
474 		all_counters[num_gpes + event_number].count++;
475 	else
476 		all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS +
477 			     COUNT_ERROR].count++;
478 
479 	return;
480 }
481 
482 static void acpi_global_event_handler(u32 event_type, acpi_handle device,
483 	u32 event_number, void *context)
484 {
485 	if (event_type == ACPI_EVENT_TYPE_GPE)
486 		gpe_count(event_number);
487 
488 	if (event_type == ACPI_EVENT_TYPE_FIXED)
489 		fixed_event_count(event_number);
490 }
491 
492 static int get_status(u32 index, acpi_event_status *status,
493 		      acpi_handle *handle)
494 {
495 	int result = 0;
496 
497 	if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
498 		goto end;
499 
500 	if (index < num_gpes) {
501 		result = acpi_get_gpe_device(index, handle);
502 		if (result) {
503 			ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND,
504 					"Invalid GPE 0x%x", index));
505 			goto end;
506 		}
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);
510 
511 end:
512 	return result;
513 }
514 
515 static ssize_t counter_show(struct kobject *kobj,
516 			    struct kobj_attribute *attr, char *buf)
517 {
518 	int index = attr - counter_attrs;
519 	int size;
520 	acpi_handle handle;
521 	acpi_event_status status;
522 	int result = 0;
523 
524 	all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI].count =
525 	    acpi_irq_handled;
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 =
529 	    acpi_gpe_count;
530 	size = sprintf(buf, "%8d", all_counters[index].count);
531 
532 	/* "gpe_all" or "sci" */
533 	if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
534 		goto end;
535 
536 	result = get_status(index, &status, &handle);
537 	if (result)
538 		goto end;
539 
540 	if (!(status & ACPI_EVENT_FLAG_HAS_HANDLER))
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");
546 	else
547 		size += sprintf(buf + size, "   disabled");
548 
549 end:
550 	size += sprintf(buf + size, "\n");
551 	return result ? result : size;
552 }
553 
554 /*
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.
558  */
559 static ssize_t counter_set(struct kobject *kobj,
560 			   struct kobj_attribute *attr, const char *buf,
561 			   size_t size)
562 {
563 	int index = attr - counter_attrs;
564 	acpi_event_status status;
565 	acpi_handle handle;
566 	int result = 0;
567 	unsigned long tmp;
568 
569 	if (index == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) {
570 		int i;
571 		for (i = 0; i < num_counters; ++i)
572 			all_counters[i].count = 0;
573 		acpi_gpe_count = 0;
574 		acpi_irq_handled = 0;
575 		acpi_irq_not_handled = 0;
576 		goto end;
577 	}
578 
579 	/* show the event status for both GPEs and Fixed Events */
580 	result = get_status(index, &status, &handle);
581 	if (result)
582 		goto end;
583 
584 	if (!(status & ACPI_EVENT_FLAG_HAS_HANDLER)) {
585 		printk(KERN_WARNING PREFIX
586 		       "Can not change Invalid GPE/Fixed Event status\n");
587 		return -EINVAL;
588 	}
589 
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;
602 		else
603 			result = -EINVAL;
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;
617 		else
618 			result = -EINVAL;
619 	} else
620 		all_counters[index].count = strtoul(buf, NULL, 0);
621 
622 	if (ACPI_FAILURE(result))
623 		result = -EINVAL;
624 end:
625 	return result ? result : size;
626 }
627 
628 void acpi_irq_stats_init(void)
629 {
630 	acpi_status status;
631 	int i;
632 
633 	if (all_counters)
634 		return;
635 
636 	num_gpes = acpi_current_gpe_count;
637 	num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA;
638 
639 	all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1),
640 			    GFP_KERNEL);
641 	if (all_attrs == NULL)
642 		return;
643 
644 	all_counters = kzalloc(sizeof(struct event_counter) * (num_counters),
645 			       GFP_KERNEL);
646 	if (all_counters == NULL)
647 		goto fail;
648 
649 	status = acpi_install_global_event_handler(acpi_global_event_handler, NULL);
650 	if (ACPI_FAILURE(status))
651 		goto fail;
652 
653 	counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters),
654 				GFP_KERNEL);
655 	if (counter_attrs == NULL)
656 		goto fail;
657 
658 	for (i = 0; i < num_counters; ++i) {
659 		char buffer[12];
660 		char *name;
661 
662 		if (i < num_gpes)
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");
682 		else
683 			sprintf(buffer, "bug%02X", i);
684 
685 		name = kstrdup(buffer, GFP_KERNEL);
686 		if (name == NULL)
687 			goto fail;
688 
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;
694 
695 		all_attrs[i] = &counter_attrs[i].attr;
696 	}
697 
698 	interrupt_stats_attr_group.attrs = all_attrs;
699 	if (!sysfs_create_group(acpi_kobj, &interrupt_stats_attr_group))
700 		return;
701 
702 fail:
703 	delete_gpe_attr_array();
704 	return;
705 }
706 
707 static void __exit interrupt_stats_exit(void)
708 {
709 	sysfs_remove_group(acpi_kobj, &interrupt_stats_attr_group);
710 
711 	delete_gpe_attr_array();
712 
713 	return;
714 }
715 
716 static ssize_t
717 acpi_show_profile(struct device *dev, struct device_attribute *attr,
718 		  char *buf)
719 {
720 	return sprintf(buf, "%d\n", acpi_gbl_FADT.preferred_profile);
721 }
722 
723 static const struct device_attribute pm_profile_attr =
724 	__ATTR(pm_profile, S_IRUGO, acpi_show_profile, NULL);
725 
726 static ssize_t hotplug_enabled_show(struct kobject *kobj,
727 				    struct kobj_attribute *attr, char *buf)
728 {
729 	struct acpi_hotplug_profile *hotplug = to_acpi_hotplug_profile(kobj);
730 
731 	return sprintf(buf, "%d\n", hotplug->enabled);
732 }
733 
734 static ssize_t hotplug_enabled_store(struct kobject *kobj,
735 				     struct kobj_attribute *attr,
736 				     const char *buf, size_t size)
737 {
738 	struct acpi_hotplug_profile *hotplug = to_acpi_hotplug_profile(kobj);
739 	unsigned int val;
740 
741 	if (kstrtouint(buf, 10, &val) || val > 1)
742 		return -EINVAL;
743 
744 	acpi_scan_hotplug_enabled(hotplug, val);
745 	return size;
746 }
747 
748 static struct kobj_attribute hotplug_enabled_attr =
749 	__ATTR(enabled, S_IRUGO | S_IWUSR, hotplug_enabled_show,
750 		hotplug_enabled_store);
751 
752 static struct attribute *hotplug_profile_attrs[] = {
753 	&hotplug_enabled_attr.attr,
754 	NULL
755 };
756 
757 static struct kobj_type acpi_hotplug_profile_ktype = {
758 	.sysfs_ops = &kobj_sysfs_ops,
759 	.default_attrs = hotplug_profile_attrs,
760 };
761 
762 void acpi_sysfs_add_hotplug_profile(struct acpi_hotplug_profile *hotplug,
763 				    const char *name)
764 {
765 	int error;
766 
767 	if (!hotplug_kobj)
768 		goto err_out;
769 
770 	error = kobject_init_and_add(&hotplug->kobj,
771 		&acpi_hotplug_profile_ktype, hotplug_kobj, "%s", name);
772 	if (error)
773 		goto err_out;
774 
775 	kobject_uevent(&hotplug->kobj, KOBJ_ADD);
776 	return;
777 
778  err_out:
779 	pr_err(PREFIX "Unable to add hotplug profile '%s'\n", name);
780 }
781 
782 static ssize_t force_remove_show(struct kobject *kobj,
783 				 struct kobj_attribute *attr, char *buf)
784 {
785 	return sprintf(buf, "%d\n", !!acpi_force_hot_remove);
786 }
787 
788 static ssize_t force_remove_store(struct kobject *kobj,
789 				  struct kobj_attribute *attr,
790 				  const char *buf, size_t size)
791 {
792 	bool val;
793 	int ret;
794 
795 	ret = strtobool(buf, &val);
796 	if (ret < 0)
797 		return ret;
798 
799 	lock_device_hotplug();
800 	acpi_force_hot_remove = val;
801 	unlock_device_hotplug();
802 	return size;
803 }
804 
805 static const struct kobj_attribute force_remove_attr =
806 	__ATTR(force_remove, S_IRUGO | S_IWUSR, force_remove_show,
807 	       force_remove_store);
808 
809 int __init acpi_sysfs_init(void)
810 {
811 	int result;
812 
813 	result = acpi_tables_sysfs_init();
814 	if (result)
815 		return result;
816 
817 	hotplug_kobj = kobject_create_and_add("hotplug", acpi_kobj);
818 	result = sysfs_create_file(hotplug_kobj, &force_remove_attr.attr);
819 	if (result)
820 		return result;
821 
822 	result = sysfs_create_file(acpi_kobj, &pm_profile_attr.attr);
823 	return result;
824 }
825