Merge branch 'linux-next' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes...
[linux-2.6-block.git] / drivers / acpi / system.c
1 /*
2  *  acpi_system.c - ACPI System Driver ($Revision: 63 $)
3  *
4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6  *
7  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or (at
12  *  your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful, but
15  *  WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  *  General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License along
20  *  with this program; if not, write to the Free Software Foundation, Inc.,
21  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
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
37 ACPI_MODULE_NAME("system");
38
39 #define ACPI_SYSTEM_CLASS               "system"
40 #define ACPI_SYSTEM_DEVICE_NAME         "System"
41
42 u32 acpi_irq_handled;
43 u32 acpi_irq_not_handled;
44
45 /*
46  * Make ACPICA version work as module param
47  */
48 static 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
57 module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);
58
59 /* --------------------------------------------------------------------------
60                               FS Interface (/sys)
61    -------------------------------------------------------------------------- */
62 static LIST_HEAD(acpi_table_attr_list);
63 static struct kobject *tables_kobj;
64 static struct kobject *dynamic_tables_kobj;
65
66 struct acpi_table_attr {
67         struct bin_attribute attr;
68         char name[8];
69         int instance;
70         struct list_head node;
71 };
72
73 static 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
98 static 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
131 static acpi_status
132 acpi_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                  * we do not need to do anything right now
155                  * because the table is not deleted from the
156                  * global table list when unloading it.
157                  */
158                 break;
159         default:
160                 return AE_BAD_PARAMETER;
161         }
162         return AE_OK;
163 }
164
165 static 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;
207 err_dynamic_tables:
208         kobject_put(tables_kobj);
209 err:
210         return -ENOMEM;
211 }
212
213 /*
214  * Detailed ACPI IRQ counters in /sys/firmware/acpi/interrupts/
215  * See Documentation/ABI/testing/sysfs-firmware-acpi
216  */
217
218 #define COUNT_GPE 0
219 #define COUNT_SCI 1     /* acpi_irq_handled */
220 #define COUNT_SCI_NOT 2 /* acpi_irq_not_handled */
221 #define COUNT_ERROR 3   /* other */
222 #define NUM_COUNTERS_EXTRA 4
223
224 struct event_counter {
225         u32 count;
226         u32 flags;
227 };
228
229 static struct event_counter *all_counters;
230 static u32 num_gpes;
231 static u32 num_counters;
232 static struct attribute **all_attrs;
233 static u32 acpi_gpe_count;
234
235 static struct attribute_group interrupt_stats_attr_group = {
236         .name = "interrupts",
237 };
238 static struct kobj_attribute *counter_attrs;
239
240 static 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
260 void 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
276 void 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
290 static 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
309 end:
310         return result;
311 }
312
313 static 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         /* "gpe_all" or "sci" */
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
348 end:
349         size += sprintf(buf + size, "\n");
350         return result ? result : size;
351 }
352
353 /*
354  * counter_set() sets the specified counter.
355  * setting the total "sci" file to any value clears all counters.
356  * enable/disable/clear a gpe/fixed event in user space.
357  */
358 static 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         /* show the event status for both GPEs and Fixed Events */
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;
417 end:
418         return result ? result : size;
419 }
420
421 void 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
490 fail:
491         delete_gpe_attr_array();
492         return;
493 }
494
495 static 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                               FS Interface (/proc)
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
513 static 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
520 static 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
525 static 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
533 static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t,
534                                      loff_t *);
535
536 static const struct file_operations acpi_system_dsdt_ops = {
537         .owner = THIS_MODULE,
538         .read = acpi_system_read_dsdt,
539 };
540
541 static ssize_t
542 acpi_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
558 static ssize_t acpi_system_read_fadt(struct file *, char __user *, size_t,
559                                      loff_t *);
560
561 static const struct file_operations acpi_system_fadt_ops = {
562         .owner = THIS_MODULE,
563         .read = acpi_system_read_fadt,
564 };
565
566 static ssize_t
567 acpi_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
583 static int acpi_system_procfs_init(void)
584 {
585         struct proc_dir_entry *entry;
586         int error = 0;
587
588         /* 'info' [R] */
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         /* 'dsdt' [R] */
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         /* 'fadt' [R] */
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
618 static int acpi_system_procfs_init(void)
619 {
620         return 0;
621 }
622 #endif
623
624 int __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 }