Merge branches 'x86/mmio', 'x86/delay', 'x86/idle', 'x86/oprofile', 'x86/debug',...
[linux-2.6] / 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 <asm/uaccess.h>
30
31 #include <acpi/acpi_drivers.h>
32
33 #define _COMPONENT              ACPI_SYSTEM_COMPONENT
34 ACPI_MODULE_NAME("system");
35 #ifdef MODULE_PARAM_PREFIX
36 #undef MODULE_PARAM_PREFIX
37 #endif
38 #define MODULE_PARAM_PREFIX "acpi."
39
40 #define ACPI_SYSTEM_CLASS               "system"
41 #define ACPI_SYSTEM_DEVICE_NAME         "System"
42
43 u32 acpi_irq_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
65 struct acpi_table_attr {
66         struct bin_attribute attr;
67         char name[8];
68         int instance;
69         struct list_head node;
70 };
71
72 static ssize_t acpi_table_show(struct kobject *kobj,
73                                struct bin_attribute *bin_attr, char *buf,
74                                loff_t offset, size_t count)
75 {
76         struct acpi_table_attr *table_attr =
77             container_of(bin_attr, struct acpi_table_attr, attr);
78         struct acpi_table_header *table_header = NULL;
79         acpi_status status;
80
81         status =
82             acpi_get_table(table_attr->name, table_attr->instance,
83                            &table_header);
84         if (ACPI_FAILURE(status))
85                 return -ENODEV;
86
87         return memory_read_from_buffer(buf, count, &offset,
88                                         table_header, table_header->length);
89 }
90
91 static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
92                                  struct acpi_table_header *table_header)
93 {
94         struct acpi_table_header *header = NULL;
95         struct acpi_table_attr *attr = NULL;
96
97         memcpy(table_attr->name, table_header->signature, ACPI_NAME_SIZE);
98
99         list_for_each_entry(attr, &acpi_table_attr_list, node) {
100                 if (!memcmp(table_header->signature, attr->name,
101                             ACPI_NAME_SIZE))
102                         if (table_attr->instance < attr->instance)
103                                 table_attr->instance = attr->instance;
104         }
105         table_attr->instance++;
106
107         if (table_attr->instance > 1 || (table_attr->instance == 1 &&
108                                          !acpi_get_table(table_header->
109                                                          signature, 2,
110                                                          &header)))
111                 sprintf(table_attr->name + 4, "%d", table_attr->instance);
112
113         table_attr->attr.size = 0;
114         table_attr->attr.read = acpi_table_show;
115         table_attr->attr.attr.name = table_attr->name;
116         table_attr->attr.attr.mode = 0444;
117         table_attr->attr.attr.owner = THIS_MODULE;
118
119         return;
120 }
121
122 static int acpi_system_sysfs_init(void)
123 {
124         struct acpi_table_attr *table_attr;
125         struct acpi_table_header *table_header = NULL;
126         int table_index = 0;
127         int result;
128
129         tables_kobj = kobject_create_and_add("tables", acpi_kobj);
130         if (!tables_kobj)
131                 return -ENOMEM;
132
133         do {
134                 result = acpi_get_table_by_index(table_index, &table_header);
135                 if (!result) {
136                         table_index++;
137                         table_attr = NULL;
138                         table_attr =
139                             kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
140                         if (!table_attr)
141                                 return -ENOMEM;
142
143                         acpi_table_attr_init(table_attr, table_header);
144                         result =
145                             sysfs_create_bin_file(tables_kobj,
146                                                   &table_attr->attr);
147                         if (result) {
148                                 kfree(table_attr);
149                                 return result;
150                         } else
151                                 list_add_tail(&table_attr->node,
152                                               &acpi_table_attr_list);
153                 }
154         } while (!result);
155         kobject_uevent(tables_kobj, KOBJ_ADD);
156
157         return 0;
158 }
159
160 /*
161  * Detailed ACPI IRQ counters in /sys/firmware/acpi/interrupts/
162  * See Documentation/ABI/testing/sysfs-firmware-acpi
163  */
164
165 #define COUNT_GPE 0
166 #define COUNT_SCI 1     /* acpi_irq_handled */
167 #define COUNT_ERROR 2   /* other */
168 #define NUM_COUNTERS_EXTRA 3
169
170 static u32 *all_counters;
171 static u32 num_gpes;
172 static u32 num_counters;
173 static struct attribute **all_attrs;
174 static u32 acpi_gpe_count;
175
176 static struct attribute_group interrupt_stats_attr_group = {
177         .name = "interrupts",
178 };
179 static struct kobj_attribute *counter_attrs;
180
181 static int count_num_gpes(void)
182 {
183         int count = 0;
184         struct acpi_gpe_xrupt_info *gpe_xrupt_info;
185         struct acpi_gpe_block_info *gpe_block;
186         acpi_cpu_flags flags;
187
188         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
189
190         gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head;
191         while (gpe_xrupt_info) {
192                 gpe_block = gpe_xrupt_info->gpe_block_list_head;
193                 while (gpe_block) {
194                         count += gpe_block->register_count *
195                             ACPI_GPE_REGISTER_WIDTH;
196                         gpe_block = gpe_block->next;
197                 }
198                 gpe_xrupt_info = gpe_xrupt_info->next;
199         }
200         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
201
202         return count;
203 }
204
205 static void delete_gpe_attr_array(void)
206 {
207         u32 *tmp = all_counters;
208
209         all_counters = NULL;
210         kfree(tmp);
211
212         if (counter_attrs) {
213                 int i;
214
215                 for (i = 0; i < num_gpes; i++)
216                         kfree(counter_attrs[i].attr.name);
217
218                 kfree(counter_attrs);
219         }
220         kfree(all_attrs);
221
222         return;
223 }
224
225 void acpi_os_gpe_count(u32 gpe_number)
226 {
227         acpi_gpe_count++;
228
229         if (!all_counters)
230                 return;
231
232         if (gpe_number < num_gpes)
233                 all_counters[gpe_number]++;
234         else
235                 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR]++;
236
237         return;
238 }
239
240 void acpi_os_fixed_event_count(u32 event_number)
241 {
242         if (!all_counters)
243                 return;
244
245         if (event_number < ACPI_NUM_FIXED_EVENTS)
246                 all_counters[num_gpes + event_number]++;
247         else
248                 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR]++;
249
250         return;
251 }
252
253 static ssize_t counter_show(struct kobject *kobj,
254         struct kobj_attribute *attr, char *buf)
255 {
256         all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI] =
257                 acpi_irq_handled;
258         all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE] =
259                 acpi_gpe_count;
260
261         return sprintf(buf, "%d\n", all_counters[attr - counter_attrs]);
262 }
263
264 /*
265  * counter_set() sets the specified counter.
266  * setting the total "sci" file to any value clears all counters.
267  */
268 static ssize_t counter_set(struct kobject *kobj,
269         struct kobj_attribute *attr, const char *buf, size_t size)
270 {
271         int index = attr - counter_attrs;
272
273         if (index == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) {
274                 int i;
275                 for (i = 0; i < num_counters; ++i)
276                         all_counters[i] = 0;
277                 acpi_gpe_count = 0;
278                 acpi_irq_handled = 0;
279
280         } else
281                 all_counters[index] = strtoul(buf, NULL, 0);
282
283         return size;
284 }
285
286 void acpi_irq_stats_init(void)
287 {
288         int i;
289
290         if (all_counters)
291                 return;
292
293         num_gpes = count_num_gpes();
294         num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA;
295
296         all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1),
297                         GFP_KERNEL);
298         if (all_attrs == NULL)
299                 return;
300
301         all_counters = kzalloc(sizeof(u32) * (num_counters), GFP_KERNEL);
302         if (all_counters == NULL)
303                 goto fail;
304
305         counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters),
306                         GFP_KERNEL);
307         if (counter_attrs == NULL)
308                 goto fail;
309
310         for (i = 0; i < num_counters; ++i) {
311                 char buffer[12];
312                 char *name;
313
314                 if (i < num_gpes)
315                         sprintf(buffer, "gpe%02X", i);
316                 else if (i == num_gpes + ACPI_EVENT_PMTIMER)
317                         sprintf(buffer, "ff_pmtimer");
318                 else if (i == num_gpes + ACPI_EVENT_GLOBAL)
319                         sprintf(buffer, "ff_gbl_lock");
320                 else if (i == num_gpes + ACPI_EVENT_POWER_BUTTON)
321                         sprintf(buffer, "ff_pwr_btn");
322                 else if (i == num_gpes + ACPI_EVENT_SLEEP_BUTTON)
323                         sprintf(buffer, "ff_slp_btn");
324                 else if (i == num_gpes + ACPI_EVENT_RTC)
325                         sprintf(buffer, "ff_rt_clk");
326                 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE)
327                         sprintf(buffer, "gpe_all");
328                 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI)
329                         sprintf(buffer, "sci");
330                 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR)
331                         sprintf(buffer, "error");
332                 else
333                         sprintf(buffer, "bug%02X", i);
334
335                 name = kzalloc(strlen(buffer) + 1, GFP_KERNEL);
336                 if (name == NULL)
337                         goto fail;
338                 strncpy(name, buffer, strlen(buffer) + 1);
339
340                 counter_attrs[i].attr.name = name;
341                 counter_attrs[i].attr.mode = 0644;
342                 counter_attrs[i].show = counter_show;
343                 counter_attrs[i].store = counter_set;
344
345                 all_attrs[i] = &counter_attrs[i].attr;
346         }
347
348         interrupt_stats_attr_group.attrs = all_attrs;
349         if (!sysfs_create_group(acpi_kobj, &interrupt_stats_attr_group))
350                 return;
351
352 fail:
353         delete_gpe_attr_array();
354         return;
355 }
356
357 static void __exit interrupt_stats_exit(void)
358 {
359         sysfs_remove_group(acpi_kobj, &interrupt_stats_attr_group);
360
361         delete_gpe_attr_array();
362
363         return;
364 }
365
366 /* --------------------------------------------------------------------------
367                               FS Interface (/proc)
368    -------------------------------------------------------------------------- */
369 #ifdef CONFIG_ACPI_PROCFS
370 #define ACPI_SYSTEM_FILE_INFO           "info"
371 #define ACPI_SYSTEM_FILE_EVENT          "event"
372 #define ACPI_SYSTEM_FILE_DSDT           "dsdt"
373 #define ACPI_SYSTEM_FILE_FADT           "fadt"
374
375 static int acpi_system_read_info(struct seq_file *seq, void *offset)
376 {
377
378         seq_printf(seq, "version:                 %x\n", ACPI_CA_VERSION);
379         return 0;
380 }
381
382 static int acpi_system_info_open_fs(struct inode *inode, struct file *file)
383 {
384         return single_open(file, acpi_system_read_info, PDE(inode)->data);
385 }
386
387 static const struct file_operations acpi_system_info_ops = {
388         .owner = THIS_MODULE,
389         .open = acpi_system_info_open_fs,
390         .read = seq_read,
391         .llseek = seq_lseek,
392         .release = single_release,
393 };
394
395 static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t,
396                                      loff_t *);
397
398 static const struct file_operations acpi_system_dsdt_ops = {
399         .owner = THIS_MODULE,
400         .read = acpi_system_read_dsdt,
401 };
402
403 static ssize_t
404 acpi_system_read_dsdt(struct file *file,
405                       char __user * buffer, size_t count, loff_t * ppos)
406 {
407         acpi_status status = AE_OK;
408         struct acpi_table_header *dsdt = NULL;
409         ssize_t res;
410
411         status = acpi_get_table(ACPI_SIG_DSDT, 1, &dsdt);
412         if (ACPI_FAILURE(status))
413                 return -ENODEV;
414
415         res = simple_read_from_buffer(buffer, count, ppos, dsdt, dsdt->length);
416
417         return res;
418 }
419
420 static ssize_t acpi_system_read_fadt(struct file *, char __user *, size_t,
421                                      loff_t *);
422
423 static const struct file_operations acpi_system_fadt_ops = {
424         .owner = THIS_MODULE,
425         .read = acpi_system_read_fadt,
426 };
427
428 static ssize_t
429 acpi_system_read_fadt(struct file *file,
430                       char __user * buffer, size_t count, loff_t * ppos)
431 {
432         acpi_status status = AE_OK;
433         struct acpi_table_header *fadt = NULL;
434         ssize_t res;
435
436         status = acpi_get_table(ACPI_SIG_FADT, 1, &fadt);
437         if (ACPI_FAILURE(status))
438                 return -ENODEV;
439
440         res = simple_read_from_buffer(buffer, count, ppos, fadt, fadt->length);
441
442         return res;
443 }
444
445 static int acpi_system_procfs_init(void)
446 {
447         struct proc_dir_entry *entry;
448         int error = 0;
449
450         /* 'info' [R] */
451         entry = proc_create(ACPI_SYSTEM_FILE_INFO, S_IRUGO, acpi_root_dir,
452                             &acpi_system_info_ops);
453         if (!entry)
454                 goto Error;
455
456         /* 'dsdt' [R] */
457         entry = proc_create(ACPI_SYSTEM_FILE_DSDT, S_IRUSR, acpi_root_dir,
458                             &acpi_system_dsdt_ops);
459         if (!entry)
460                 goto Error;
461
462         /* 'fadt' [R] */
463         entry = proc_create(ACPI_SYSTEM_FILE_FADT, S_IRUSR, acpi_root_dir,
464                             &acpi_system_fadt_ops);
465         if (!entry)
466                 goto Error;
467
468       Done:
469         return error;
470
471       Error:
472         remove_proc_entry(ACPI_SYSTEM_FILE_FADT, acpi_root_dir);
473         remove_proc_entry(ACPI_SYSTEM_FILE_DSDT, acpi_root_dir);
474         remove_proc_entry(ACPI_SYSTEM_FILE_INFO, acpi_root_dir);
475
476         error = -EFAULT;
477         goto Done;
478 }
479 #else
480 static int acpi_system_procfs_init(void)
481 {
482         return 0;
483 }
484 #endif
485
486 static int __init acpi_system_init(void)
487 {
488         int result = 0;
489
490         if (acpi_disabled)
491                 return 0;
492
493         result = acpi_system_procfs_init();
494         if (result)
495                 return result;
496
497         result = acpi_system_sysfs_init();
498
499         return result;
500 }
501
502 subsys_initcall(acpi_system_init);