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 = pm_suspend(PM_SUSPEND_DISK);
  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\tS-state\t  Status   Sysfs node\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                 struct device *ldev;
 360
 361                 if (!dev->wakeup.flags.valid)
 362                         continue;
 363                 spin_unlock(&acpi_device_lock);
 364
 365                 ldev = acpi_get_physical_device(dev->handle);
 366                 seq_printf(seq, "%s\t  S%d\t%c%-8s  ",
 367                            dev->pnp.bus_id,
 368                            (u32) dev->wakeup.sleep_state,
 369                            dev->wakeup.flags.run_wake ? '*' : ' ',
 370                            dev->wakeup.state.enabled ? "enabled" : "disabled");
 371                 if (ldev)
 372                         seq_printf(seq, "%s:%s",
 373                                 ldev->bus ? ldev->bus->name : "no-bus",
 374                                 ldev->bus_id);
 375                 seq_printf(seq, "\n");
 376                 put_device(ldev);
 377
 378                 spin_lock(&acpi_device_lock);
 379         }
 380         spin_unlock(&acpi_device_lock);
 381         return 0;
 382 }
 383
 384 static ssize_t
 385 acpi_system_write_wakeup_device(struct file *file,
 386                                 const char __user * buffer,
 387                                 size_t count, loff_t * ppos)
 388 {
 389         struct list_head *node, *next;
 390         char strbuf[5];
 391         char str[5] = "";
 392         int len = count;
 393         struct acpi_device *found_dev = NULL;
 394
 395         if (len > 4)
 396                 len = 4;
 397
 398         if (copy_from_user(strbuf, buffer, len))
 399                 return -EFAULT;
 400         strbuf[len] = '\0';
 401         sscanf(strbuf, "%s", str);
 402
 403         spin_lock(&acpi_device_lock);
 404         list_for_each_safe(node, next, &acpi_wakeup_device_list) {
 405                 struct acpi_device *dev =
 406                     container_of(node, struct acpi_device, wakeup_list);
 407                 if (!dev->wakeup.flags.valid)
 408                         continue;
 409
 410                 if (!strncmp(dev->pnp.bus_id, str, 4)) {
 411                         dev->wakeup.state.enabled =
 412                             dev->wakeup.state.enabled ? 0 : 1;
 413                         found_dev = dev;
 414                         break;
 415                 }
 416         }
 417         if (found_dev) {
 418                 list_for_each_safe(node, next, &acpi_wakeup_device_list) {
 419                         struct acpi_device *dev = container_of(node,
 420                                                                struct
 421                                                                acpi_device,
 422                                                                wakeup_list);
 423
 424                         if ((dev != found_dev) &&
 425                             (dev->wakeup.gpe_number ==
 426                              found_dev->wakeup.gpe_number)
 427                             && (dev->wakeup.gpe_device ==
 428                                 found_dev->wakeup.gpe_device)) {
 429                                 printk(KERN_WARNING
 430                                        "ACPI: '%s' and '%s' have the same GPE, "
 431                                        "can't disable/enable one seperately\n",
 432                                        dev->pnp.bus_id, found_dev->pnp.bus_id);
 433                                 dev->wakeup.state.enabled =
 434                                     found_dev->wakeup.state.enabled;
 435                         }
 436                 }
 437         }
 438         spin_unlock(&acpi_device_lock);
 439         return count;
 440 }
 441
 442 static int
 443 acpi_system_wakeup_device_open_fs(struct inode *inode, struct file *file)
 444 {
 445         return single_open(file, acpi_system_wakeup_device_seq_show,
 446                            PDE(inode)->data);
 447 }
 448
 449 static const struct file_operations acpi_system_wakeup_device_fops = {
 450         .open = acpi_system_wakeup_device_open_fs,
 451         .read = seq_read,
 452         .write = acpi_system_write_wakeup_device,
 453         .llseek = seq_lseek,
 454         .release = single_release,
 455 };
 456
 457 #ifdef  CONFIG_ACPI_SLEEP_PROC_SLEEP
 458 static const struct file_operations acpi_system_sleep_fops = {
 459         .open = acpi_system_sleep_open_fs,
 460         .read = seq_read,
 461         .write = acpi_system_write_sleep,
 462         .llseek = seq_lseek,
 463         .release = single_release,
 464 };
 465 #endif                          /* CONFIG_ACPI_SLEEP_PROC_SLEEP */
 466
 467 static const struct file_operations acpi_system_alarm_fops = {
 468         .open = acpi_system_alarm_open_fs,
 469         .read = seq_read,
 470         .write = acpi_system_write_alarm,
 471         .llseek = seq_lseek,
 472         .release = single_release,
 473 };
 474
 475 static u32 rtc_handler(void *context)
 476 {
 477         acpi_clear_event(ACPI_EVENT_RTC);
 478         acpi_disable_event(ACPI_EVENT_RTC, 0);
 479
 480         return ACPI_INTERRUPT_HANDLED;
 481 }
 482
 483 static int acpi_sleep_proc_init(void)
 484 {
 485         struct proc_dir_entry *entry = NULL;
 486
 487         if (acpi_disabled)
 488                 return 0;
 489
 490 #ifdef  CONFIG_ACPI_SLEEP_PROC_SLEEP
 491         /* 'sleep' [R/W] */
 492         entry =
 493             create_proc_entry("sleep", S_IFREG | S_IRUGO | S_IWUSR,
 494                               acpi_root_dir);
 495         if (entry)
 496                 entry->proc_fops = &acpi_system_sleep_fops;
 497 #endif
 498
 499         /* 'alarm' [R/W] */
 500         entry =
 501             create_proc_entry("alarm", S_IFREG | S_IRUGO | S_IWUSR,
 502                               acpi_root_dir);
 503         if (entry)
 504                 entry->proc_fops = &acpi_system_alarm_fops;
 505
 506         /* 'wakeup device' [R/W] */
 507         entry =
 508             create_proc_entry("wakeup", S_IFREG | S_IRUGO | S_IWUSR,
 509                               acpi_root_dir);
 510         if (entry)
 511                 entry->proc_fops = &acpi_system_wakeup_device_fops;
 512
 513         acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
 514         return 0;
 515 }
 516
 517 late_initcall(acpi_sleep_proc_init);