4696a85a98b92b34c2789e52fae6a6122039b447
[linux-3.10.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;
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_alrm)
91                 /* ACPI spec: only low 6 its should be cared */
92                 day = CMOS_READ(acpi_gbl_FADT->day_alrm) & 0x3F;
93         else
94                 day = CMOS_READ(RTC_DAY_OF_MONTH);
95         if (acpi_gbl_FADT->mon_alrm)
96                 mo = CMOS_READ(acpi_gbl_FADT->mon_alrm);
97         else
98                 mo = CMOS_READ(RTC_MONTH);
99         if (acpi_gbl_FADT->century)
100                 yr = CMOS_READ(acpi_gbl_FADT->century) * 100 +
101                     CMOS_READ(RTC_YEAR);
102         else
103                 yr = CMOS_READ(RTC_YEAR);
104
105         spin_unlock_irqrestore(&rtc_lock, flags);
106
107         if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
108                 BCD_TO_BIN(sec);
109                 BCD_TO_BIN(min);
110                 BCD_TO_BIN(hr);
111                 BCD_TO_BIN(day);
112                 BCD_TO_BIN(mo);
113                 BCD_TO_BIN(yr);
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
138         seq_printf(seq, "%4.4u-", yr);
139         (mo > 12) ? seq_puts(seq, "**-") : seq_printf(seq, "%2.2u-", mo);
140         (day > 31) ? seq_puts(seq, "** ") : seq_printf(seq, "%2.2u ", day);
141         (hr > 23) ? seq_puts(seq, "**:") : seq_printf(seq, "%2.2u:", hr);
142         (min > 59) ? seq_puts(seq, "**:") : seq_printf(seq, "%2.2u:", min);
143         (sec > 59) ? seq_puts(seq, "**\n") : seq_printf(seq, "%2.2u\n", sec);
144
145         return 0;
146 }
147
148 static int acpi_system_alarm_open_fs(struct inode *inode, struct file *file)
149 {
150         return single_open(file, acpi_system_alarm_seq_show, PDE(inode)->data);
151 }
152
153 static int get_date_field(char **p, u32 * value)
154 {
155         char *next = NULL;
156         char *string_end = NULL;
157         int result = -EINVAL;
158
159         /*
160          * Try to find delimeter, only to insert null.  The end of the
161          * string won't have one, but is still valid.
162          */
163         next = strpbrk(*p, "- :");
164         if (next)
165                 *next++ = '\0';
166
167         *value = simple_strtoul(*p, &string_end, 10);
168
169         /* Signal success if we got a good digit */
170         if (string_end != *p)
171                 result = 0;
172
173         if (next)
174                 *p = next;
175
176         return result;
177 }
178
179 static ssize_t
180 acpi_system_write_alarm(struct file *file,
181                         const char __user * buffer, size_t count, loff_t * ppos)
182 {
183         int result = 0;
184         char alarm_string[30] = { '\0' };
185         char *p = alarm_string;
186         u32 sec, min, hr, day, mo, yr;
187         int adjust = 0;
188         unsigned char rtc_control = 0;
189
190         ACPI_FUNCTION_TRACE("acpi_system_write_alarm");
191
192         if (count > sizeof(alarm_string) - 1)
193                 return_VALUE(-EINVAL);
194
195         if (copy_from_user(alarm_string, buffer, count))
196                 return_VALUE(-EFAULT);
197
198         alarm_string[count] = '\0';
199
200         /* check for time adjustment */
201         if (alarm_string[0] == '+') {
202                 p++;
203                 adjust = 1;
204         }
205
206         if ((result = get_date_field(&p, &yr)))
207                 goto end;
208         if ((result = get_date_field(&p, &mo)))
209                 goto end;
210         if ((result = get_date_field(&p, &day)))
211                 goto end;
212         if ((result = get_date_field(&p, &hr)))
213                 goto end;
214         if ((result = get_date_field(&p, &min)))
215                 goto end;
216         if ((result = get_date_field(&p, &sec)))
217                 goto end;
218
219         if (sec > 59) {
220                 min += 1;
221                 sec -= 60;
222         }
223         if (min > 59) {
224                 hr += 1;
225                 min -= 60;
226         }
227         if (hr > 23) {
228                 day += 1;
229                 hr -= 24;
230         }
231         if (day > 31) {
232                 mo += 1;
233                 day -= 31;
234         }
235         if (mo > 12) {
236                 yr += 1;
237                 mo -= 12;
238         }
239
240         spin_lock_irq(&rtc_lock);
241
242         rtc_control = CMOS_READ(RTC_CONTROL);
243         if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
244                 BIN_TO_BCD(yr);
245                 BIN_TO_BCD(mo);
246                 BIN_TO_BCD(day);
247                 BIN_TO_BCD(hr);
248                 BIN_TO_BCD(min);
249                 BIN_TO_BCD(sec);
250         }
251
252         if (adjust) {
253                 yr += CMOS_READ(RTC_YEAR);
254                 mo += CMOS_READ(RTC_MONTH);
255                 day += CMOS_READ(RTC_DAY_OF_MONTH);
256                 hr += CMOS_READ(RTC_HOURS);
257                 min += CMOS_READ(RTC_MINUTES);
258                 sec += CMOS_READ(RTC_SECONDS);
259         }
260
261         spin_unlock_irq(&rtc_lock);
262
263         if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
264                 BCD_TO_BIN(yr);
265                 BCD_TO_BIN(mo);
266                 BCD_TO_BIN(day);
267                 BCD_TO_BIN(hr);
268                 BCD_TO_BIN(min);
269                 BCD_TO_BIN(sec);
270         }
271
272         if (sec > 59) {
273                 min++;
274                 sec -= 60;
275         }
276         if (min > 59) {
277                 hr++;
278                 min -= 60;
279         }
280         if (hr > 23) {
281                 day++;
282                 hr -= 24;
283         }
284         if (day > 31) {
285                 mo++;
286                 day -= 31;
287         }
288         if (mo > 12) {
289                 yr++;
290                 mo -= 12;
291         }
292         if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
293                 BIN_TO_BCD(yr);
294                 BIN_TO_BCD(mo);
295                 BIN_TO_BCD(day);
296                 BIN_TO_BCD(hr);
297                 BIN_TO_BCD(min);
298                 BIN_TO_BCD(sec);
299         }
300
301         spin_lock_irq(&rtc_lock);
302         /*
303          * Disable alarm interrupt before setting alarm timer or else
304          * when ACPI_EVENT_RTC is enabled, a spurious ACPI interrupt occurs
305          */
306         rtc_control &= ~RTC_AIE;
307         CMOS_WRITE(rtc_control, RTC_CONTROL);
308         CMOS_READ(RTC_INTR_FLAGS);
309
310         /* write the fields the rtc knows about */
311         CMOS_WRITE(hr, RTC_HOURS_ALARM);
312         CMOS_WRITE(min, RTC_MINUTES_ALARM);
313         CMOS_WRITE(sec, RTC_SECONDS_ALARM);
314
315         /*
316          * If the system supports an enhanced alarm it will have non-zero
317          * offsets into the CMOS RAM here -- which for some reason are pointing
318          * to the RTC area of memory.
319          */
320         if (acpi_gbl_FADT->day_alrm)
321                 CMOS_WRITE(day, acpi_gbl_FADT->day_alrm);
322         if (acpi_gbl_FADT->mon_alrm)
323                 CMOS_WRITE(mo, acpi_gbl_FADT->mon_alrm);
324         if (acpi_gbl_FADT->century)
325                 CMOS_WRITE(yr / 100, acpi_gbl_FADT->century);
326         /* enable the rtc alarm interrupt */
327         rtc_control |= RTC_AIE;
328         CMOS_WRITE(rtc_control, RTC_CONTROL);
329         CMOS_READ(RTC_INTR_FLAGS);
330
331         spin_unlock_irq(&rtc_lock);
332
333         acpi_clear_event(ACPI_EVENT_RTC);
334         acpi_enable_event(ACPI_EVENT_RTC, 0);
335
336         *ppos += count;
337
338         result = 0;
339       end:
340         return_VALUE(result ? result : count);
341 }
342
343 extern struct list_head acpi_wakeup_device_list;
344 extern spinlock_t acpi_device_lock;
345
346 static int
347 acpi_system_wakeup_device_seq_show(struct seq_file *seq, void *offset)
348 {
349         struct list_head *node, *next;
350
351         seq_printf(seq, "Device Sleep state     Status\n");
352
353         spin_lock(&acpi_device_lock);
354         list_for_each_safe(node, next, &acpi_wakeup_device_list) {
355                 struct acpi_device *dev =
356                     container_of(node, struct acpi_device, wakeup_list);
357
358                 if (!dev->wakeup.flags.valid)
359                         continue;
360                 spin_unlock(&acpi_device_lock);
361                 seq_printf(seq, "%4s    %4d             %s%8s\n",
362                            dev->pnp.bus_id,
363                            (u32) dev->wakeup.sleep_state,
364                            dev->wakeup.flags.run_wake ? "*" : "",
365                            dev->wakeup.state.enabled ? "enabled" : "disabled");
366                 spin_lock(&acpi_device_lock);
367         }
368         spin_unlock(&acpi_device_lock);
369         return 0;
370 }
371
372 static ssize_t
373 acpi_system_write_wakeup_device(struct file *file,
374                                 const char __user * buffer,
375                                 size_t count, loff_t * ppos)
376 {
377         struct list_head *node, *next;
378         char strbuf[5];
379         char str[5] = "";
380         int len = count;
381         struct acpi_device *found_dev = NULL;
382
383         if (len > 4)
384                 len = 4;
385
386         if (copy_from_user(strbuf, buffer, len))
387                 return -EFAULT;
388         strbuf[len] = '\0';
389         sscanf(strbuf, "%s", str);
390
391         spin_lock(&acpi_device_lock);
392         list_for_each_safe(node, next, &acpi_wakeup_device_list) {
393                 struct acpi_device *dev =
394                     container_of(node, struct acpi_device, wakeup_list);
395                 if (!dev->wakeup.flags.valid)
396                         continue;
397
398                 if (!strncmp(dev->pnp.bus_id, str, 4)) {
399                         dev->wakeup.state.enabled =
400                             dev->wakeup.state.enabled ? 0 : 1;
401                         found_dev = dev;
402                         break;
403                 }
404         }
405         if (found_dev) {
406                 list_for_each_safe(node, next, &acpi_wakeup_device_list) {
407                         struct acpi_device *dev = container_of(node,
408                                                                struct
409                                                                acpi_device,
410                                                                wakeup_list);
411
412                         if ((dev != found_dev) &&
413                             (dev->wakeup.gpe_number ==
414                              found_dev->wakeup.gpe_number)
415                             && (dev->wakeup.gpe_device ==
416                                 found_dev->wakeup.gpe_device)) {
417                                 printk(KERN_WARNING
418                                        "ACPI: '%s' and '%s' have the same GPE, "
419                                        "can't disable/enable one seperately\n",
420                                        dev->pnp.bus_id, found_dev->pnp.bus_id);
421                                 dev->wakeup.state.enabled =
422                                     found_dev->wakeup.state.enabled;
423                         }
424                 }
425         }
426         spin_unlock(&acpi_device_lock);
427         return count;
428 }
429
430 static int
431 acpi_system_wakeup_device_open_fs(struct inode *inode, struct file *file)
432 {
433         return single_open(file, acpi_system_wakeup_device_seq_show,
434                            PDE(inode)->data);
435 }
436
437 static struct file_operations acpi_system_wakeup_device_fops = {
438         .open = acpi_system_wakeup_device_open_fs,
439         .read = seq_read,
440         .write = acpi_system_write_wakeup_device,
441         .llseek = seq_lseek,
442         .release = single_release,
443 };
444
445 #ifdef  CONFIG_ACPI_SLEEP_PROC_SLEEP
446 static struct file_operations acpi_system_sleep_fops = {
447         .open = acpi_system_sleep_open_fs,
448         .read = seq_read,
449         .write = acpi_system_write_sleep,
450         .llseek = seq_lseek,
451         .release = single_release,
452 };
453 #endif                          /* CONFIG_ACPI_SLEEP_PROC_SLEEP */
454
455 static struct file_operations acpi_system_alarm_fops = {
456         .open = acpi_system_alarm_open_fs,
457         .read = seq_read,
458         .write = acpi_system_write_alarm,
459         .llseek = seq_lseek,
460         .release = single_release,
461 };
462
463 static u32 rtc_handler(void *context)
464 {
465         acpi_clear_event(ACPI_EVENT_RTC);
466         acpi_disable_event(ACPI_EVENT_RTC, 0);
467
468         return ACPI_INTERRUPT_HANDLED;
469 }
470
471 static int acpi_sleep_proc_init(void)
472 {
473         struct proc_dir_entry *entry = NULL;
474
475         if (acpi_disabled)
476                 return 0;
477
478 #ifdef  CONFIG_ACPI_SLEEP_PROC_SLEEP
479         /* 'sleep' [R/W] */
480         entry =
481             create_proc_entry("sleep", S_IFREG | S_IRUGO | S_IWUSR,
482                               acpi_root_dir);
483         if (entry)
484                 entry->proc_fops = &acpi_system_sleep_fops;
485 #endif
486
487         /* 'alarm' [R/W] */
488         entry =
489             create_proc_entry("alarm", S_IFREG | S_IRUGO | S_IWUSR,
490                               acpi_root_dir);
491         if (entry)
492                 entry->proc_fops = &acpi_system_alarm_fops;
493
494         /* 'wakeup device' [R/W] */
495         entry =
496             create_proc_entry("wakeup", S_IFREG | S_IRUGO | S_IWUSR,
497                               acpi_root_dir);
498         if (entry)
499                 entry->proc_fops = &acpi_system_wakeup_device_fops;
500
501         acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
502         return 0;
503 }
504
505 late_initcall(acpi_sleep_proc_init);