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