1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/proc_fs.h>
27#include <linux/seq_file.h>
28#include <linux/init.h>
29#include <linux/string.h>
30#include <asm/uaccess.h>
31
32#include <acpi/acpi_drivers.h>
33
34#define PREFIX "ACPI: "
35
36#define _COMPONENT ACPI_SYSTEM_COMPONENT
37ACPI_MODULE_NAME("system");
38
39#define ACPI_SYSTEM_CLASS "system"
40#define ACPI_SYSTEM_DEVICE_NAME "System"
41
42u32 acpi_irq_handled;
43u32 acpi_irq_not_handled;
44
45
46
47
48static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
49{
50 int result;
51
52 result = sprintf(buffer, "%x", ACPI_CA_VERSION);
53
54 return result;
55}
56
57module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);
58
59
60
61
62static LIST_HEAD(acpi_table_attr_list);
63static struct kobject *tables_kobj;
64static struct kobject *dynamic_tables_kobj;
65
66struct acpi_table_attr {
67 struct bin_attribute attr;
68 char name[8];
69 int instance;
70 struct list_head node;
71};
72
73static ssize_t acpi_table_show(struct kobject *kobj,
74 struct bin_attribute *bin_attr, char *buf,
75 loff_t offset, size_t count)
76{
77 struct acpi_table_attr *table_attr =
78 container_of(bin_attr, struct acpi_table_attr, attr);
79 struct acpi_table_header *table_header = NULL;
80 acpi_status status;
81 char name[ACPI_NAME_SIZE];
82
83 if (strncmp(table_attr->name, "NULL", 4))
84 memcpy(name, table_attr->name, ACPI_NAME_SIZE);
85 else
86 memcpy(name, "\0\0\0\0", 4);
87
88 status =
89 acpi_get_table(name, table_attr->instance,
90 &table_header);
91 if (ACPI_FAILURE(status))
92 return -ENODEV;
93
94 return memory_read_from_buffer(buf, count, &offset,
95 table_header, table_header->length);
96}
97
98static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
99 struct acpi_table_header *table_header)
100{
101 struct acpi_table_header *header = NULL;
102 struct acpi_table_attr *attr = NULL;
103
104 if (table_header->signature[0] != '\0')
105 memcpy(table_attr->name, table_header->signature,
106 ACPI_NAME_SIZE);
107 else
108 memcpy(table_attr->name, "NULL", 4);
109
110 list_for_each_entry(attr, &acpi_table_attr_list, node) {
111 if (!memcmp(table_attr->name, attr->name, ACPI_NAME_SIZE))
112 if (table_attr->instance < attr->instance)
113 table_attr->instance = attr->instance;
114 }
115 table_attr->instance++;
116
117 if (table_attr->instance > 1 || (table_attr->instance == 1 &&
118 !acpi_get_table
119 (table_header->signature, 2, &header)))
120 sprintf(table_attr->name + ACPI_NAME_SIZE, "%d",
121 table_attr->instance);
122
123 table_attr->attr.size = 0;
124 table_attr->attr.read = acpi_table_show;
125 table_attr->attr.attr.name = table_attr->name;
126 table_attr->attr.attr.mode = 0400;
127
128 return;
129}
130
131static acpi_status
132acpi_sysfs_table_handler(u32 event, void *table, void *context)
133{
134 struct acpi_table_attr *table_attr;
135
136 switch (event) {
137 case ACPI_TABLE_EVENT_LOAD:
138 table_attr =
139 kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
140 if (!table_attr)
141 return AE_NO_MEMORY;
142
143 acpi_table_attr_init(table_attr, table);
144 if (sysfs_create_bin_file(dynamic_tables_kobj,
145 &table_attr->attr)) {
146 kfree(table_attr);
147 return AE_ERROR;
148 } else
149 list_add_tail(&table_attr->node,
150 &acpi_table_attr_list);
151 break;
152 case ACPI_TABLE_EVENT_UNLOAD:
153
154
155
156
157
158 break;
159 default:
160 return AE_BAD_PARAMETER;
161 }
162 return AE_OK;
163}
164
165static int acpi_system_sysfs_init(void)
166{
167 struct acpi_table_attr *table_attr;
168 struct acpi_table_header *table_header = NULL;
169 int table_index = 0;
170 int result;
171
172 tables_kobj = kobject_create_and_add("tables", acpi_kobj);
173 if (!tables_kobj)
174 goto err;
175
176 dynamic_tables_kobj = kobject_create_and_add("dynamic", tables_kobj);
177 if (!dynamic_tables_kobj)
178 goto err_dynamic_tables;
179
180 do {
181 result = acpi_get_table_by_index(table_index, &table_header);
182 if (!result) {
183 table_index++;
184 table_attr = NULL;
185 table_attr =
186 kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
187 if (!table_attr)
188 return -ENOMEM;
189
190 acpi_table_attr_init(table_attr, table_header);
191 result =
192 sysfs_create_bin_file(tables_kobj,
193 &table_attr->attr);
194 if (result) {
195 kfree(table_attr);
196 return result;
197 } else
198 list_add_tail(&table_attr->node,
199 &acpi_table_attr_list);
200 }
201 } while (!result);
202 kobject_uevent(tables_kobj, KOBJ_ADD);
203 kobject_uevent(dynamic_tables_kobj, KOBJ_ADD);
204 result = acpi_install_table_handler(acpi_sysfs_table_handler, NULL);
205
206 return result == AE_OK ? 0 : -EINVAL;
207err_dynamic_tables:
208 kobject_put(tables_kobj);
209err:
210 return -ENOMEM;
211}
212
213
214
215
216
217
218#define COUNT_GPE 0
219#define COUNT_SCI 1
220#define COUNT_SCI_NOT 2
221#define COUNT_ERROR 3
222#define NUM_COUNTERS_EXTRA 4
223
224struct event_counter {
225 u32 count;
226 u32 flags;
227};
228
229static struct event_counter *all_counters;
230static u32 num_gpes;
231static u32 num_counters;
232static struct attribute **all_attrs;
233static u32 acpi_gpe_count;
234
235static struct attribute_group interrupt_stats_attr_group = {
236 .name = "interrupts",
237};
238static struct kobj_attribute *counter_attrs;
239
240static void delete_gpe_attr_array(void)
241{
242 struct event_counter *tmp = all_counters;
243
244 all_counters = NULL;
245 kfree(tmp);
246
247 if (counter_attrs) {
248 int i;
249
250 for (i = 0; i < num_gpes; i++)
251 kfree(counter_attrs[i].attr.name);
252
253 kfree(counter_attrs);
254 }
255 kfree(all_attrs);
256
257 return;
258}
259
260void acpi_os_gpe_count(u32 gpe_number)
261{
262 acpi_gpe_count++;
263
264 if (!all_counters)
265 return;
266
267 if (gpe_number < num_gpes)
268 all_counters[gpe_number].count++;
269 else
270 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
271 count++;
272
273 return;
274}
275
276void acpi_os_fixed_event_count(u32 event_number)
277{
278 if (!all_counters)
279 return;
280
281 if (event_number < ACPI_NUM_FIXED_EVENTS)
282 all_counters[num_gpes + event_number].count++;
283 else
284 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
285 count++;
286
287 return;
288}
289
290static int get_status(u32 index, acpi_event_status *status, acpi_handle *handle)
291{
292 int result = 0;
293
294 if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
295 goto end;
296
297 if (index < num_gpes) {
298 result = acpi_get_gpe_device(index, handle);
299 if (result) {
300 ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND,
301 "Invalid GPE 0x%x\n", index));
302 goto end;
303 }
304 result = acpi_get_gpe_status(*handle, index,
305 ACPI_NOT_ISR, status);
306 } else if (index < (num_gpes + ACPI_NUM_FIXED_EVENTS))
307 result = acpi_get_event_status(index - num_gpes, status);
308
309end:
310 return result;
311}
312
313static ssize_t counter_show(struct kobject *kobj,
314 struct kobj_attribute *attr, char *buf)
315{
316 int index = attr - counter_attrs;
317 int size;
318 acpi_handle handle;
319 acpi_event_status status;
320 int result = 0;
321
322 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI].count =
323 acpi_irq_handled;
324 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT].count =
325 acpi_irq_not_handled;
326 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE].count =
327 acpi_gpe_count;
328
329 size = sprintf(buf, "%8d", all_counters[index].count);
330
331
332 if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
333 goto end;
334
335 result = get_status(index, &status, &handle);
336 if (result)
337 goto end;
338
339 if (!(status & ACPI_EVENT_FLAG_HANDLE))
340 size += sprintf(buf + size, " invalid");
341 else if (status & ACPI_EVENT_FLAG_ENABLED)
342 size += sprintf(buf + size, " enabled");
343 else if (status & ACPI_EVENT_FLAG_WAKE_ENABLED)
344 size += sprintf(buf + size, " wake_enabled");
345 else
346 size += sprintf(buf + size, " disabled");
347
348end:
349 size += sprintf(buf + size, "\n");
350 return result ? result : size;
351}
352
353
354
355
356
357
358static ssize_t counter_set(struct kobject *kobj,
359 struct kobj_attribute *attr, const char *buf, size_t size)
360{
361 int index = attr - counter_attrs;
362 acpi_event_status status;
363 acpi_handle handle;
364 int result = 0;
365
366 if (index == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) {
367 int i;
368 for (i = 0; i < num_counters; ++i)
369 all_counters[i].count = 0;
370 acpi_gpe_count = 0;
371 acpi_irq_handled = 0;
372 acpi_irq_not_handled = 0;
373 goto end;
374 }
375
376
377 result = get_status(index, &status, &handle);
378 if (result)
379 goto end;
380
381 if (!(status & ACPI_EVENT_FLAG_HANDLE)) {
382 printk(KERN_WARNING PREFIX
383 "Can not change Invalid GPE/Fixed Event status\n");
384 return -EINVAL;
385 }
386
387 if (index < num_gpes) {
388 if (!strcmp(buf, "disable\n") &&
389 (status & ACPI_EVENT_FLAG_ENABLED))
390 result = acpi_disable_gpe(handle, index);
391 else if (!strcmp(buf, "enable\n") &&
392 !(status & ACPI_EVENT_FLAG_ENABLED))
393 result = acpi_enable_gpe(handle, index);
394 else if (!strcmp(buf, "clear\n") &&
395 (status & ACPI_EVENT_FLAG_SET))
396 result = acpi_clear_gpe(handle, index, ACPI_NOT_ISR);
397 else
398 all_counters[index].count = strtoul(buf, NULL, 0);
399 } else if (index < num_gpes + ACPI_NUM_FIXED_EVENTS) {
400 int event = index - num_gpes;
401 if (!strcmp(buf, "disable\n") &&
402 (status & ACPI_EVENT_FLAG_ENABLED))
403 result = acpi_disable_event(event, ACPI_NOT_ISR);
404 else if (!strcmp(buf, "enable\n") &&
405 !(status & ACPI_EVENT_FLAG_ENABLED))
406 result = acpi_enable_event(event, ACPI_NOT_ISR);
407 else if (!strcmp(buf, "clear\n") &&
408 (status & ACPI_EVENT_FLAG_SET))
409 result = acpi_clear_event(event);
410 else
411 all_counters[index].count = strtoul(buf, NULL, 0);
412 } else
413 all_counters[index].count = strtoul(buf, NULL, 0);
414
415 if (ACPI_FAILURE(result))
416 result = -EINVAL;
417end:
418 return result ? result : size;
419}
420
421void acpi_irq_stats_init(void)
422{
423 int i;
424
425 if (all_counters)
426 return;
427
428 num_gpes = acpi_current_gpe_count;
429 num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA;
430
431 all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1),
432 GFP_KERNEL);
433 if (all_attrs == NULL)
434 return;
435
436 all_counters = kzalloc(sizeof(struct event_counter) * (num_counters),
437 GFP_KERNEL);
438 if (all_counters == NULL)
439 goto fail;
440
441 counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters),
442 GFP_KERNEL);
443 if (counter_attrs == NULL)
444 goto fail;
445
446 for (i = 0; i < num_counters; ++i) {
447 char buffer[12];
448 char *name;
449
450 if (i < num_gpes)
451 sprintf(buffer, "gpe%02X", i);
452 else if (i == num_gpes + ACPI_EVENT_PMTIMER)
453 sprintf(buffer, "ff_pmtimer");
454 else if (i == num_gpes + ACPI_EVENT_GLOBAL)
455 sprintf(buffer, "ff_gbl_lock");
456 else if (i == num_gpes + ACPI_EVENT_POWER_BUTTON)
457 sprintf(buffer, "ff_pwr_btn");
458 else if (i == num_gpes + ACPI_EVENT_SLEEP_BUTTON)
459 sprintf(buffer, "ff_slp_btn");
460 else if (i == num_gpes + ACPI_EVENT_RTC)
461 sprintf(buffer, "ff_rt_clk");
462 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE)
463 sprintf(buffer, "gpe_all");
464 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI)
465 sprintf(buffer, "sci");
466 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT)
467 sprintf(buffer, "sci_not");
468 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR)
469 sprintf(buffer, "error");
470 else
471 sprintf(buffer, "bug%02X", i);
472
473 name = kzalloc(strlen(buffer) + 1, GFP_KERNEL);
474 if (name == NULL)
475 goto fail;
476 strncpy(name, buffer, strlen(buffer) + 1);
477
478 counter_attrs[i].attr.name = name;
479 counter_attrs[i].attr.mode = 0644;
480 counter_attrs[i].show = counter_show;
481 counter_attrs[i].store = counter_set;
482
483 all_attrs[i] = &counter_attrs[i].attr;
484 }
485
486 interrupt_stats_attr_group.attrs = all_attrs;
487 if (!sysfs_create_group(acpi_kobj, &interrupt_stats_attr_group))
488 return;
489
490fail:
491 delete_gpe_attr_array();
492 return;
493}
494
495static void __exit interrupt_stats_exit(void)
496{
497 sysfs_remove_group(acpi_kobj, &interrupt_stats_attr_group);
498
499 delete_gpe_attr_array();
500
501 return;
502}
503
504
505
506
507#ifdef CONFIG_ACPI_PROCFS
508#define ACPI_SYSTEM_FILE_INFO "info"
509#define ACPI_SYSTEM_FILE_EVENT "event"
510#define ACPI_SYSTEM_FILE_DSDT "dsdt"
511#define ACPI_SYSTEM_FILE_FADT "fadt"
512
513static int acpi_system_read_info(struct seq_file *seq, void *offset)
514{
515
516 seq_printf(seq, "version: %x\n", ACPI_CA_VERSION);
517 return 0;
518}
519
520static int acpi_system_info_open_fs(struct inode *inode, struct file *file)
521{
522 return single_open(file, acpi_system_read_info, PDE(inode)->data);
523}
524
525static const struct file_operations acpi_system_info_ops = {
526 .owner = THIS_MODULE,
527 .open = acpi_system_info_open_fs,
528 .read = seq_read,
529 .llseek = seq_lseek,
530 .release = single_release,
531};
532
533static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t,
534 loff_t *);
535
536static const struct file_operations acpi_system_dsdt_ops = {
537 .owner = THIS_MODULE,
538 .read = acpi_system_read_dsdt,
539};
540
541static ssize_t
542acpi_system_read_dsdt(struct file *file,
543 char __user * buffer, size_t count, loff_t * ppos)
544{
545 acpi_status status = AE_OK;
546 struct acpi_table_header *dsdt = NULL;
547 ssize_t res;
548
549 status = acpi_get_table(ACPI_SIG_DSDT, 1, &dsdt);
550 if (ACPI_FAILURE(status))
551 return -ENODEV;
552
553 res = simple_read_from_buffer(buffer, count, ppos, dsdt, dsdt->length);
554
555 return res;
556}
557
558static ssize_t acpi_system_read_fadt(struct file *, char __user *, size_t,
559 loff_t *);
560
561static const struct file_operations acpi_system_fadt_ops = {
562 .owner = THIS_MODULE,
563 .read = acpi_system_read_fadt,
564};
565
566static ssize_t
567acpi_system_read_fadt(struct file *file,
568 char __user * buffer, size_t count, loff_t * ppos)
569{
570 acpi_status status = AE_OK;
571 struct acpi_table_header *fadt = NULL;
572 ssize_t res;
573
574 status = acpi_get_table(ACPI_SIG_FADT, 1, &fadt);
575 if (ACPI_FAILURE(status))
576 return -ENODEV;
577
578 res = simple_read_from_buffer(buffer, count, ppos, fadt, fadt->length);
579
580 return res;
581}
582
583static int acpi_system_procfs_init(void)
584{
585 struct proc_dir_entry *entry;
586 int error = 0;
587
588
589 entry = proc_create(ACPI_SYSTEM_FILE_INFO, S_IRUGO, acpi_root_dir,
590 &acpi_system_info_ops);
591 if (!entry)
592 goto Error;
593
594
595 entry = proc_create(ACPI_SYSTEM_FILE_DSDT, S_IRUSR, acpi_root_dir,
596 &acpi_system_dsdt_ops);
597 if (!entry)
598 goto Error;
599
600
601 entry = proc_create(ACPI_SYSTEM_FILE_FADT, S_IRUSR, acpi_root_dir,
602 &acpi_system_fadt_ops);
603 if (!entry)
604 goto Error;
605
606 Done:
607 return error;
608
609 Error:
610 remove_proc_entry(ACPI_SYSTEM_FILE_FADT, acpi_root_dir);
611 remove_proc_entry(ACPI_SYSTEM_FILE_DSDT, acpi_root_dir);
612 remove_proc_entry(ACPI_SYSTEM_FILE_INFO, acpi_root_dir);
613
614 error = -EFAULT;
615 goto Done;
616}
617#else
618static int acpi_system_procfs_init(void)
619{
620 return 0;
621}
622#endif
623
624int __init acpi_system_init(void)
625{
626 int result;
627
628 result = acpi_system_procfs_init();
629 if (result)
630 return result;
631
632 result = acpi_system_sysfs_init();
633
634 return result;
635}
636
