ACPICA: minimal patch to integrate new tables into Linux
[linux-2.6.git] / drivers / acpi / sleep / proc.c
1 #include <linux/proc_fs.h>
2 #include <linux/seq_file.h>
3 #include <linux/suspend.h>
4 #include <linux/bcd.h>
5 #include <asm/uaccess.h>
6
7 #include <acpi/acpi_bus.h>
8 #include <acpi/acpi_drivers.h>
9
10 #ifdef CONFIG_X86
11 #include <linux/mc146818rtc.h>
12 #endif
13
14 #include "sleep.h"
15
16 #define _COMPONENT              ACPI_SYSTEM_COMPONENT
17 ACPI_MODULE_NAME("sleep")
18 #ifdef  CONFIG_ACPI_SLEEP_PROC_SLEEP
19 static int acpi_system_sleep_seq_show(struct seq_file *seq, void *offset)
20 {
21         int i;
22
23         ACPI_FUNCTION_TRACE("acpi_system_sleep_seq_show");
24
25         for (i = 0; i <= ACPI_STATE_S5; i++) {
26                 if (sleep_states[i]) {
27                         seq_printf(seq, "S%d ", i);
28                 }
29         }
30
31         seq_puts(seq, "\n");
32
33         return 0;
34 }
35
36 static int acpi_system_sleep_open_fs(struct inode *inode, struct file *file)
37 {
38         return single_open(file, acpi_system_sleep_seq_show, PDE(inode)->data);
39 }
40
41 static ssize_t
42 acpi_system_write_sleep(struct file *file,
43                         const char __user * buffer, size_t count, loff_t * ppos)
44 {
45         char str[12];
46         u32 state = 0;
47         int error = 0;
48
49         if (count > sizeof(str) - 1)
50                 goto Done;
51         memset(str, 0, sizeof(str));
52         if (copy_from_user(str, buffer, count))
53                 return -EFAULT;
54
55         /* Check for S4 bios request */
56         if (!strcmp(str, "4b")) {
57                 error = acpi_suspend(4);
58                 goto Done;
59         }
60         state = simple_strtoul(str, NULL, 0);
61 #ifdef CONFIG_SOFTWARE_SUSPEND
62         if (state == 4) {
63                 error = software_suspend();
64                 goto Done;
65         }
66 #endif
67         error = acpi_suspend(state);
68       Done:
69         return error ? error : count;
70 }
71 #endif                          /* CONFIG_ACPI_SLEEP_PROC_SLEEP */
72
73 static int acpi_system_alarm_seq_show(struct seq_file *seq, void *offset)
74 {
75         u32 sec, min, hr;
76         u32 day, mo, yr, cent = 0;
77         unsigned char rtc_control = 0;
78         unsigned long flags;
79
80         ACPI_FUNCTION_TRACE("acpi_system_alarm_seq_show");
81
82         spin_lock_irqsave(&rtc_lock, flags);
83
84         sec = CMOS_READ(RTC_SECONDS_ALARM);
85         min = CMOS_READ(RTC_MINUTES_ALARM);
86         hr = CMOS_READ(RTC_HOURS_ALARM);
87         rtc_control = CMOS_READ(RTC_CONTROL);
88
89         /* If we ever get an FACP with proper values... */
90         if (acpi_gbl_FADT.day_alarm)
91                 /* ACPI spec: only low 6 its should be cared */
92                 day = CMOS_READ(acpi_gbl_FADT.day_alarm) & 0x3F;
93         else
94                 day = CMOS_READ(RTC_DAY_OF_MONTH);
95         if (acpi_gbl_FADT.month_alarm)
96                 mo = CMOS_READ(acpi_gbl_FADT.month_alarm);
97         else
98                 mo = CMOS_READ(RTC_MONTH);
99         if (acpi_gbl_FADT.century)
100                 cent = CMOS_READ(acpi_gbl_FADT.century);
101
102         yr = CMOS_READ(RTC_YEAR);
103
104         spin_unlock_irqrestore(&rtc_lock, flags);
105
106         if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
107                 BCD_TO_BIN(sec);
108                 BCD_TO_BIN(min);
109                 BCD_TO_BIN(hr);
110                 BCD_TO_BIN(day);
111                 BCD_TO_BIN(mo);
112                 BCD_TO_BIN(yr);
113                 BCD_TO_BIN(cent);
114         }
115
116         /* we're trusting the FADT (see above) */
117         if (!acpi_gbl_FADT.century)
118                 /* If we're not trusting the FADT, we should at least make it
119                  * right for _this_ century... ehm, what is _this_ century?
120                  *
121                  * TBD:
122                  *  ASAP: find piece of code in the kernel, e.g. star tracker driver,
123                  *        which we can trust to determine the century correctly. Atom
124                  *        watch driver would be nice, too...
125                  *
126                  *  if that has not happened, change for first release in 2050:
127                  *        if (yr<50)
128                  *                yr += 2100;
129                  *        else
130                  *                yr += 2000;   // current line of code
131                  *
132                  *  if that has not happened either, please do on 2099/12/31:23:59:59
133                  *        s/2000/2100
134                  *
135                  */
136                 yr += 2000;
137         else
138                 yr += cent * 100;
139
140         seq_printf(seq, "%4.4u-", yr);
141         (mo > 12) ? seq_puts(seq, "**-") : seq_printf(seq, "%2.2u-", mo);
142         (day > 31) ? seq_puts(seq, "** ") : seq_printf(seq, "%2.2u ", day);
143         (hr > 23) ? seq_puts(seq, "**:") : seq_printf(seq, "%2.2u:", hr);
144         (min > 59) ? seq_puts(seq, "**:") : seq_printf(seq, "%2.2u:", min);
145         (sec > 59) ? seq_puts(seq, "**\n") : seq_printf(seq, "%2.2u\n", sec);
146
147         return 0;
148 }
149
150 static int acpi_system_alarm_open_fs(struct inode *inode, struct file *file)
151 {
152         return single_open(file, acpi_system_alarm_seq_show, PDE(inode)->data);
153 }
154
155 static int get_date_field(char **p, u32 * value)
156 {
157         char *next = NULL;
158         char *string_end = NULL;
159         int result = -EINVAL;
160
161         /*
162          * Try to find delimeter, only to insert null.  The end of the
163          * string won't have one, but is still valid.
164          */
165         next = strpbrk(*p, "- :");
166         if (next)
167                 *next++ = '\0';
168
169         *value = simple_strtoul(*p, &string_end, 10);
170
171         /* Signal success if we got a good digit */
172         if (string_end != *p)
173                 result = 0;
174
175         if (next)
176                 *p = next;
177
178         return result;
179 }
180
181 static ssize_t
182 acpi_system_write_alarm(struct file *file,
183                         const char __user * buffer, size_t count, loff_t * ppos)
184 {
185         int result = 0;
186         char alarm_string[30] = { '\0' };
187         char *p = alarm_string;
188         u32 sec, min, hr, day, mo, yr;
189         int adjust = 0;
190         unsigned char rtc_control = 0;
191
192         ACPI_FUNCTION_TRACE("acpi_system_write_alarm");
193
194         if (count > sizeof(alarm_string) - 1)
195                 return_VALUE(-EINVAL);
196
197         if (copy_from_user(alarm_string, buffer, count))
198                 return_VALUE(-EFAULT);
199
200         alarm_string[count] = '\0';
201
202         /* check for time adjustment */
203         if (alarm_string[0] == '+') {
204                 p++;
205                 adjust = 1;
206         }
207
208         if ((result = get_date_field(&p, &yr)))
209                 goto end;
210         if ((result = get_date_field(&p, &mo)))
211                 goto end;
212         if ((result = get_date_field(&p, &day)))
213                 goto end;
214         if ((result = get_date_field(&p, &hr)))
215                 goto end;
216         if ((result = get_date_field(&p, &min)))
217                 goto end;
218         if ((result = get_date_field(&p, &sec)))
219                 goto end;
220
221         if (sec > 59) {
222                 min += 1;
223                 sec -= 60;
224         }
225         if (min > 59) {
226                 hr += 1;
227                 min -= 60;
228         }
229         if (hr > 23) {
230                 day += 1;
231                 hr -= 24;
232         }
233         if (day > 31) {
234                 mo += 1;
235                 day -= 31;
236         }
237         if (mo > 12) {
238                 yr += 1;
239                 mo -= 12;
240         }
241
242         spin_lock_irq(&rtc_lock);
243
244         rtc_control = CMOS_READ(RTC_CONTROL);
245         if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
246                 BIN_TO_BCD(yr);
247                 BIN_TO_BCD(mo);
248                 BIN_TO_BCD(day);
249                 BIN_TO_BCD(hr);
250                 BIN_TO_BCD(min);
251                 BIN_TO_BCD(sec);
252         }
253
254         if (adjust) {
255                 yr += CMOS_READ(RTC_YEAR);
256                 mo += CMOS_READ(RTC_MONTH);
257                 day += CMOS_READ(RTC_DAY_OF_MONTH);
258                 hr += CMOS_READ(RTC_HOURS);
259                 min += CMOS_READ(RTC_MINUTES);
260                 sec += CMOS_READ(RTC_SECONDS);
261         }
262
263         spin_unlock_irq(&rtc_lock);
264
265         if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
266                 BCD_TO_BIN(yr);
267                 BCD_TO_BIN(mo);
268                 BCD_TO_BIN(day);
269                 BCD_TO_BIN(hr);
270                 BCD_TO_BIN(min);
271                 BCD_TO_BIN(sec);
272         }
273
274         if (sec > 59) {
275                 min++;
276                 sec -= 60;
277         }
278         if (min > 59) {
279                 hr++;
280                 min -= 60;
281         }
282         if (hr > 23) {
283                 day++;
284                 hr -= 24;
285         }
286         if (day > 31) {
287                 mo++;
288                 day -= 31;
289         }
290         if (mo > 12) {
291                 yr++;
292                 mo -= 12;
293         }
294         if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
295                 BIN_TO_BCD(yr);
296                 BIN_TO_BCD(mo);
297                 BIN_TO_BCD(day);
298                 BIN_TO_BCD(hr);
299                 BIN_TO_BCD(min);
300                 BIN_TO_BCD(sec);
301         }
302
303         spin_lock_irq(&rtc_lock);
304         /*
305          * Disable alarm interrupt before setting alarm timer or else
306          * when ACPI_EVENT_RTC is enabled, a spurious ACPI interrupt occurs
307          */
308         rtc_control &= ~RTC_AIE;
309         CMOS_WRITE(rtc_control, RTC_CONTROL);
310         CMOS_READ(RTC_INTR_FLAGS);
311
312         /* write the fields the rtc knows about */
313         CMOS_WRITE(hr, RTC_HOURS_ALARM);
314         CMOS_WRITE(min, RTC_MINUTES_ALARM);
315         CMOS_WRITE(sec, RTC_SECONDS_ALARM);
316
317         /*
318          * If the system supports an enhanced alarm it will have non-zero
319          * offsets into the CMOS RAM here -- which for some reason are pointing
320          * to the RTC area of memory.
321          */
322         if (acpi_gbl_FADT.day_alarm)
323                 CMOS_WRITE(day, acpi_gbl_FADT.day_alarm);
324         if (acpi_gbl_FADT.month_alarm)
325                 CMOS_WRITE(mo, acpi_gbl_FADT.month_alarm);
326         if (acpi_gbl_FADT.century)
327                 CMOS_WRITE(yr / 100, acpi_gbl_FADT.century);
328         /* enable the rtc alarm interrupt */
329         rtc_control |= RTC_AIE;
330         CMOS_WRITE(rtc_control, RTC_CONTROL);
331         CMOS_READ(RTC_INTR_FLAGS);
332
333         spin_unlock_irq(&rtc_lock);
334
335         acpi_clear_event(ACPI_EVENT_RTC);
336         acpi_enable_event(ACPI_EVENT_RTC, 0);
337
338         *ppos += count;
339
340         result = 0;
341       end:
342         return_VALUE(result ? result : count);
343 }
344
345 extern struct list_head acpi_wakeup_device_list;
346 extern spinlock_t acpi_device_lock;
347
348 static int
349 acpi_system_wakeup_device_seq_show(struct seq_file *seq, void *offset)
350 {
351         struct list_head *node, *next;
352
353         seq_printf(seq, "Device Sleep state     Status\n");
354
355         spin_lock(&acpi_device_lock);
356         list_for_each_safe(node, next, &acpi_wakeup_device_list) {
357                 struct acpi_device *dev =
358                     container_of(node, struct acpi_device, wakeup_list);
359
360                 if (!dev->wakeup.flags.valid)
361                         continue;
362                 spin_unlock(&acpi_device_lock);
363                 seq_printf(seq, "%4s    %4d             %s%8s\n",
364                            dev->pnp.bus_id,
365                            (u32) dev->wakeup.sleep_state,
366                            dev->wakeup.flags.run_wake ? "*" : "",
367                            dev->wakeup.state.enabled ? "enabled" : "disabled");
368                 spin_lock(&acpi_device_lock);
369         }
370         spin_unlock(&acpi_device_lock);
371         return 0;
372 }
373
374 static ssize_t
375 acpi_system_write_wakeup_device(struct file *file,
376                                 const char __user * buffer,
377                                 size_t count, loff_t * ppos)
378 {
379         struct list_head *node, *next;
380         char strbuf[5];
381         char str[5] = "";
382         int len = count;
383         struct acpi_device *found_dev = NULL;
384
385         if (len > 4)
386                 len = 4;
387
388         if (copy_from_user(strbuf, buffer, len))
389                 return -EFAULT;
390         strbuf[len] = '\0';
391         sscanf(strbuf, "%s", str);
392
393         spin_lock(&acpi_device_lock);
394         list_for_each_safe(node, next, &acpi_wakeup_device_list) {
395                 struct acpi_device *dev =
396                     container_of(node, struct acpi_device, wakeup_list);
397                 if (!dev->wakeup.flags.valid)
398                         continue;
399
400                 if (!strncmp(dev->pnp.bus_id, str, 4)) {
401                         dev->wakeup.state.enabled =
402                             dev->wakeup.state.enabled ? 0 : 1;
403                         found_dev = dev;
404                         break;
405                 }
406         }
407         if (found_dev) {
408                 list_for_each_safe(node, next, &acpi_wakeup_device_list) {
409                         struct acpi_device *dev = container_of(node,
410                                                                struct
411                                                                acpi_device,
412                                                                wakeup_list);
413
414                         if ((dev != found_dev) &&
415                             (dev->wakeup.gpe_number ==
416                              found_dev->wakeup.gpe_number)
417                             && (dev->wakeup.gpe_device ==
418                                 found_dev->wakeup.gpe_device)) {
419                                 printk(KERN_WARNING
420                                        "ACPI: '%s' and '%s' have the same GPE, "
421                                        "can't disable/enable one seperately\n",
422                                        dev->pnp.bus_id, found_dev->pnp.bus_id);
423                                 dev->wakeup.state.enabled =
424                                     found_dev->wakeup.state.enabled;
425                         }
426                 }
427         }
428         spin_unlock(&acpi_device_lock);
429         return count;
430 }
431
432 static int
433 acpi_system_wakeup_device_open_fs(struct inode *inode, struct file *file)
434 {
435         return single_open(file, acpi_system_wakeup_device_seq_show,
436                            PDE(inode)->data);
437 }
438
439 static const struct file_operations acpi_system_wakeup_device_fops = {
440         .open = acpi_system_wakeup_device_open_fs,
441         .read = seq_read,
442         .write = acpi_system_write_wakeup_device,
443         .llseek = seq_lseek,
444         .release = single_release,
445 };
446
447 #ifdef  CONFIG_ACPI_SLEEP_PROC_SLEEP
448 static const struct file_operations acpi_system_sleep_fops = {
449         .open = acpi_system_sleep_open_fs,
450         .read = seq_read,
451         .write = acpi_system_write_sleep,
452         .llseek = seq_lseek,
453         .release = single_release,
454 };
455 #endif                          /* CONFIG_ACPI_SLEEP_PROC_SLEEP */
456
457 static const struct file_operations acpi_system_alarm_fops = {
458         .open = acpi_system_alarm_open_fs,
459         .read = seq_read,
460         .write = acpi_system_write_alarm,
461         .llseek = seq_lseek,
462         .release = single_release,
463 };
464
465 static u32 rtc_handler(void *context)
466 {
467         acpi_clear_event(ACPI_EVENT_RTC);
468         acpi_disable_event(ACPI_EVENT_RTC, 0);
469
470         return ACPI_INTERRUPT_HANDLED;
471 }
472
473 static int acpi_sleep_proc_init(void)
474 {
475         struct proc_dir_entry *entry = NULL;
476
477         if (acpi_disabled)
478                 return 0;
479
480 #ifdef  CONFIG_ACPI_SLEEP_PROC_SLEEP
481         /* 'sleep' [R/W] */
482         entry =
483             create_proc_entry("sleep", S_IFREG | S_IRUGO | S_IWUSR,
484                               acpi_root_dir);
485         if (entry)
486                 entry->proc_fops = &acpi_system_sleep_fops;
487 #endif
488
489         /* 'alarm' [R/W] */
490         entry =
491             create_proc_entry("alarm", S_IFREG | S_IRUGO | S_IWUSR,
492                               acpi_root_dir);
493         if (entry)
494                 entry->proc_fops = &acpi_system_alarm_fops;
495
496         /* 'wakeup device' [R/W] */
497         entry =
498             create_proc_entry("wakeup", S_IFREG | S_IRUGO | S_IWUSR,
499                               acpi_root_dir);
500         if (entry)
501                 entry->proc_fops = &acpi_system_wakeup_device_fops;
502
503         acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
504         return 0;
505 }
506
507 late_initcall(acpi_sleep_proc_init);