1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * ACPI Time and Alarm (TAD) Device Driver 4 * 5 * Copyright (C) 2018 Intel Corporation 6 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> 7 * 8 * This driver is based on Section 9.18 of the ACPI 6.2 specification revision. 9 * 10 * It only supports the system wakeup capabilities of the TAD. 11 * 12 * Provided are sysfs attributes, available under the TAD platform device, 13 * allowing user space to manage the AC and DC wakeup timers of the TAD: 14 * set and read their values, set and check their expire timer wake policies, 15 * check and clear their status and check the capabilities of the TAD reported 16 * by AML. The DC timer attributes are only present if the TAD supports a 17 * separate DC alarm timer. 18 * 19 * The wakeup events handling and power management of the TAD is expected to 20 * be taken care of by the ACPI PM domain attached to its platform device. 21 */ 22 23 #include <linux/acpi.h> 24 #include <linux/kernel.h> 25 #include <linux/module.h> 26 #include <linux/platform_device.h> 27 #include <linux/pm_runtime.h> 28 #include <linux/suspend.h> 29 30 MODULE_DESCRIPTION("ACPI Time and Alarm (TAD) Device Driver"); 31 MODULE_LICENSE("GPL v2"); 32 MODULE_AUTHOR("Rafael J. Wysocki"); 33 34 /* ACPI TAD capability flags (ACPI 6.2, Section 9.18.2) */ 35 #define ACPI_TAD_AC_WAKE BIT(0) 36 #define ACPI_TAD_DC_WAKE BIT(1) 37 #define ACPI_TAD_RT BIT(2) 38 #define ACPI_TAD_RT_IN_MS BIT(3) 39 #define ACPI_TAD_S4_S5__GWS BIT(4) 40 #define ACPI_TAD_AC_S4_WAKE BIT(5) 41 #define ACPI_TAD_AC_S5_WAKE BIT(6) 42 #define ACPI_TAD_DC_S4_WAKE BIT(7) 43 #define ACPI_TAD_DC_S5_WAKE BIT(8) 44 45 /* ACPI TAD alarm timer selection */ 46 #define ACPI_TAD_AC_TIMER (u32)0 47 #define ACPI_TAD_DC_TIMER (u32)1 48 49 /* Special value for disabled timer or expired timer wake policy. */ 50 #define ACPI_TAD_WAKE_DISABLED (~(u32)0) 51 52 struct acpi_tad_driver_data { 53 u32 capabilities; 54 }; 55 56 struct acpi_tad_rt { 57 u16 year; /* 1900 - 9999 */ 58 u8 month; /* 1 - 12 */ 59 u8 day; /* 1 - 31 */ 60 u8 hour; /* 0 - 23 */ 61 u8 minute; /* 0 - 59 */ 62 u8 second; /* 0 - 59 */ 63 u8 valid; /* 0 (failed) or 1 (success) for reads, 0 for writes */ 64 u16 msec; /* 1 - 1000 */ 65 s16 tz; /* -1440 to 1440 or 2047 (unspecified) */ 66 u8 daylight; 67 u8 padding[3]; /* must be 0 */ 68 } __packed; 69 70 static int acpi_tad_set_real_time(struct device *dev, struct acpi_tad_rt *rt) 71 { 72 acpi_handle handle = ACPI_HANDLE(dev); 73 union acpi_object args[] = { 74 { .type = ACPI_TYPE_BUFFER, }, 75 }; 76 struct acpi_object_list arg_list = { 77 .pointer = args, 78 .count = ARRAY_SIZE(args), 79 }; 80 unsigned long long retval; 81 acpi_status status; 82 83 if (rt->year < 1900 || rt->year > 9999 || 84 rt->month < 1 || rt->month > 12 || 85 rt->hour > 23 || rt->minute > 59 || rt->second > 59 || 86 rt->tz < -1440 || (rt->tz > 1440 && rt->tz != 2047) || 87 rt->daylight > 3) 88 return -ERANGE; 89 90 args[0].buffer.pointer = (u8 *)rt; 91 args[0].buffer.length = sizeof(*rt); 92 93 pm_runtime_get_sync(dev); 94 95 status = acpi_evaluate_integer(handle, "_SRT", &arg_list, &retval); 96 97 pm_runtime_put_sync(dev); 98 99 if (ACPI_FAILURE(status) || retval) 100 return -EIO; 101 102 return 0; 103 } 104 105 static int acpi_tad_get_real_time(struct device *dev, struct acpi_tad_rt *rt) 106 { 107 acpi_handle handle = ACPI_HANDLE(dev); 108 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER }; 109 union acpi_object *out_obj; 110 struct acpi_tad_rt *data; 111 acpi_status status; 112 int ret = -EIO; 113 114 pm_runtime_get_sync(dev); 115 116 status = acpi_evaluate_object(handle, "_GRT", NULL, &output); 117 118 pm_runtime_put_sync(dev); 119 120 if (ACPI_FAILURE(status)) 121 goto out_free; 122 123 out_obj = output.pointer; 124 if (out_obj->type != ACPI_TYPE_BUFFER) 125 goto out_free; 126 127 if (out_obj->buffer.length != sizeof(*rt)) 128 goto out_free; 129 130 data = (struct acpi_tad_rt *)(out_obj->buffer.pointer); 131 if (!data->valid) 132 goto out_free; 133 134 memcpy(rt, data, sizeof(*rt)); 135 ret = 0; 136 137 out_free: 138 ACPI_FREE(output.pointer); 139 return ret; 140 } 141 142 static char *acpi_tad_rt_next_field(char *s, int *val) 143 { 144 char *p; 145 146 p = strchr(s, ':'); 147 if (!p) 148 return NULL; 149 150 *p = '\0'; 151 if (kstrtoint(s, 10, val)) 152 return NULL; 153 154 return p + 1; 155 } 156 157 static ssize_t time_store(struct device *dev, struct device_attribute *attr, 158 const char *buf, size_t count) 159 { 160 struct acpi_tad_rt rt; 161 char *str, *s; 162 int val, ret = -ENODATA; 163 164 str = kmemdup_nul(buf, count, GFP_KERNEL); 165 if (!str) 166 return -ENOMEM; 167 168 s = acpi_tad_rt_next_field(str, &val); 169 if (!s) 170 goto out_free; 171 172 rt.year = val; 173 174 s = acpi_tad_rt_next_field(s, &val); 175 if (!s) 176 goto out_free; 177 178 rt.month = val; 179 180 s = acpi_tad_rt_next_field(s, &val); 181 if (!s) 182 goto out_free; 183 184 rt.day = val; 185 186 s = acpi_tad_rt_next_field(s, &val); 187 if (!s) 188 goto out_free; 189 190 rt.hour = val; 191 192 s = acpi_tad_rt_next_field(s, &val); 193 if (!s) 194 goto out_free; 195 196 rt.minute = val; 197 198 s = acpi_tad_rt_next_field(s, &val); 199 if (!s) 200 goto out_free; 201 202 rt.second = val; 203 204 s = acpi_tad_rt_next_field(s, &val); 205 if (!s) 206 goto out_free; 207 208 rt.tz = val; 209 210 if (kstrtoint(s, 10, &val)) 211 goto out_free; 212 213 rt.daylight = val; 214 215 rt.valid = 0; 216 rt.msec = 0; 217 memset(rt.padding, 0, 3); 218 219 ret = acpi_tad_set_real_time(dev, &rt); 220 221 out_free: 222 kfree(str); 223 return ret ? ret : count; 224 } 225 226 static ssize_t time_show(struct device *dev, struct device_attribute *attr, 227 char *buf) 228 { 229 struct acpi_tad_rt rt; 230 int ret; 231 232 ret = acpi_tad_get_real_time(dev, &rt); 233 if (ret) 234 return ret; 235 236 return sprintf(buf, "%u:%u:%u:%u:%u:%u:%d:%u\n", 237 rt.year, rt.month, rt.day, rt.hour, rt.minute, rt.second, 238 rt.tz, rt.daylight); 239 } 240 241 static DEVICE_ATTR_RW(time); 242 243 static struct attribute *acpi_tad_time_attrs[] = { 244 &dev_attr_time.attr, 245 NULL, 246 }; 247 static const struct attribute_group acpi_tad_time_attr_group = { 248 .attrs = acpi_tad_time_attrs, 249 }; 250 251 static int acpi_tad_wake_set(struct device *dev, char *method, u32 timer_id, 252 u32 value) 253 { 254 acpi_handle handle = ACPI_HANDLE(dev); 255 union acpi_object args[] = { 256 { .type = ACPI_TYPE_INTEGER, }, 257 { .type = ACPI_TYPE_INTEGER, }, 258 }; 259 struct acpi_object_list arg_list = { 260 .pointer = args, 261 .count = ARRAY_SIZE(args), 262 }; 263 unsigned long long retval; 264 acpi_status status; 265 266 args[0].integer.value = timer_id; 267 args[1].integer.value = value; 268 269 pm_runtime_get_sync(dev); 270 271 status = acpi_evaluate_integer(handle, method, &arg_list, &retval); 272 273 pm_runtime_put_sync(dev); 274 275 if (ACPI_FAILURE(status) || retval) 276 return -EIO; 277 278 return 0; 279 } 280 281 static int acpi_tad_wake_write(struct device *dev, const char *buf, char *method, 282 u32 timer_id, const char *specval) 283 { 284 u32 value; 285 286 if (sysfs_streq(buf, specval)) { 287 value = ACPI_TAD_WAKE_DISABLED; 288 } else { 289 int ret = kstrtou32(buf, 0, &value); 290 291 if (ret) 292 return ret; 293 294 if (value == ACPI_TAD_WAKE_DISABLED) 295 return -EINVAL; 296 } 297 298 return acpi_tad_wake_set(dev, method, timer_id, value); 299 } 300 301 static ssize_t acpi_tad_wake_read(struct device *dev, char *buf, char *method, 302 u32 timer_id, const char *specval) 303 { 304 acpi_handle handle = ACPI_HANDLE(dev); 305 union acpi_object args[] = { 306 { .type = ACPI_TYPE_INTEGER, }, 307 }; 308 struct acpi_object_list arg_list = { 309 .pointer = args, 310 .count = ARRAY_SIZE(args), 311 }; 312 unsigned long long retval; 313 acpi_status status; 314 315 args[0].integer.value = timer_id; 316 317 pm_runtime_get_sync(dev); 318 319 status = acpi_evaluate_integer(handle, method, &arg_list, &retval); 320 321 pm_runtime_put_sync(dev); 322 323 if (ACPI_FAILURE(status)) 324 return -EIO; 325 326 if ((u32)retval == ACPI_TAD_WAKE_DISABLED) 327 return sprintf(buf, "%s\n", specval); 328 329 return sprintf(buf, "%u\n", (u32)retval); 330 } 331 332 static const char *alarm_specval = "disabled"; 333 334 static int acpi_tad_alarm_write(struct device *dev, const char *buf, 335 u32 timer_id) 336 { 337 return acpi_tad_wake_write(dev, buf, "_STV", timer_id, alarm_specval); 338 } 339 340 static ssize_t acpi_tad_alarm_read(struct device *dev, char *buf, u32 timer_id) 341 { 342 return acpi_tad_wake_read(dev, buf, "_TIV", timer_id, alarm_specval); 343 } 344 345 static const char *policy_specval = "never"; 346 347 static int acpi_tad_policy_write(struct device *dev, const char *buf, 348 u32 timer_id) 349 { 350 return acpi_tad_wake_write(dev, buf, "_STP", timer_id, policy_specval); 351 } 352 353 static ssize_t acpi_tad_policy_read(struct device *dev, char *buf, u32 timer_id) 354 { 355 return acpi_tad_wake_read(dev, buf, "_TIP", timer_id, policy_specval); 356 } 357 358 static int acpi_tad_clear_status(struct device *dev, u32 timer_id) 359 { 360 acpi_handle handle = ACPI_HANDLE(dev); 361 union acpi_object args[] = { 362 { .type = ACPI_TYPE_INTEGER, }, 363 }; 364 struct acpi_object_list arg_list = { 365 .pointer = args, 366 .count = ARRAY_SIZE(args), 367 }; 368 unsigned long long retval; 369 acpi_status status; 370 371 args[0].integer.value = timer_id; 372 373 pm_runtime_get_sync(dev); 374 375 status = acpi_evaluate_integer(handle, "_CWS", &arg_list, &retval); 376 377 pm_runtime_put_sync(dev); 378 379 if (ACPI_FAILURE(status) || retval) 380 return -EIO; 381 382 return 0; 383 } 384 385 static int acpi_tad_status_write(struct device *dev, const char *buf, u32 timer_id) 386 { 387 int ret, value; 388 389 ret = kstrtoint(buf, 0, &value); 390 if (ret) 391 return ret; 392 393 if (value) 394 return -EINVAL; 395 396 return acpi_tad_clear_status(dev, timer_id); 397 } 398 399 static ssize_t acpi_tad_status_read(struct device *dev, char *buf, u32 timer_id) 400 { 401 acpi_handle handle = ACPI_HANDLE(dev); 402 union acpi_object args[] = { 403 { .type = ACPI_TYPE_INTEGER, }, 404 }; 405 struct acpi_object_list arg_list = { 406 .pointer = args, 407 .count = ARRAY_SIZE(args), 408 }; 409 unsigned long long retval; 410 acpi_status status; 411 412 args[0].integer.value = timer_id; 413 414 pm_runtime_get_sync(dev); 415 416 status = acpi_evaluate_integer(handle, "_GWS", &arg_list, &retval); 417 418 pm_runtime_put_sync(dev); 419 420 if (ACPI_FAILURE(status)) 421 return -EIO; 422 423 return sprintf(buf, "0x%02X\n", (u32)retval); 424 } 425 426 static ssize_t caps_show(struct device *dev, struct device_attribute *attr, 427 char *buf) 428 { 429 struct acpi_tad_driver_data *dd = dev_get_drvdata(dev); 430 431 return sprintf(buf, "0x%02X\n", dd->capabilities); 432 } 433 434 static DEVICE_ATTR_RO(caps); 435 436 static ssize_t ac_alarm_store(struct device *dev, struct device_attribute *attr, 437 const char *buf, size_t count) 438 { 439 int ret = acpi_tad_alarm_write(dev, buf, ACPI_TAD_AC_TIMER); 440 441 return ret ? ret : count; 442 } 443 444 static ssize_t ac_alarm_show(struct device *dev, struct device_attribute *attr, 445 char *buf) 446 { 447 return acpi_tad_alarm_read(dev, buf, ACPI_TAD_AC_TIMER); 448 } 449 450 static DEVICE_ATTR_RW(ac_alarm); 451 452 static ssize_t ac_policy_store(struct device *dev, struct device_attribute *attr, 453 const char *buf, size_t count) 454 { 455 int ret = acpi_tad_policy_write(dev, buf, ACPI_TAD_AC_TIMER); 456 457 return ret ? ret : count; 458 } 459 460 static ssize_t ac_policy_show(struct device *dev, struct device_attribute *attr, 461 char *buf) 462 { 463 return acpi_tad_policy_read(dev, buf, ACPI_TAD_AC_TIMER); 464 } 465 466 static DEVICE_ATTR_RW(ac_policy); 467 468 static ssize_t ac_status_store(struct device *dev, struct device_attribute *attr, 469 const char *buf, size_t count) 470 { 471 int ret = acpi_tad_status_write(dev, buf, ACPI_TAD_AC_TIMER); 472 473 return ret ? ret : count; 474 } 475 476 static ssize_t ac_status_show(struct device *dev, struct device_attribute *attr, 477 char *buf) 478 { 479 return acpi_tad_status_read(dev, buf, ACPI_TAD_AC_TIMER); 480 } 481 482 static DEVICE_ATTR_RW(ac_status); 483 484 static struct attribute *acpi_tad_attrs[] = { 485 &dev_attr_caps.attr, 486 &dev_attr_ac_alarm.attr, 487 &dev_attr_ac_policy.attr, 488 &dev_attr_ac_status.attr, 489 NULL, 490 }; 491 static const struct attribute_group acpi_tad_attr_group = { 492 .attrs = acpi_tad_attrs, 493 }; 494 495 static ssize_t dc_alarm_store(struct device *dev, struct device_attribute *attr, 496 const char *buf, size_t count) 497 { 498 int ret = acpi_tad_alarm_write(dev, buf, ACPI_TAD_DC_TIMER); 499 500 return ret ? ret : count; 501 } 502 503 static ssize_t dc_alarm_show(struct device *dev, struct device_attribute *attr, 504 char *buf) 505 { 506 return acpi_tad_alarm_read(dev, buf, ACPI_TAD_DC_TIMER); 507 } 508 509 static DEVICE_ATTR_RW(dc_alarm); 510 511 static ssize_t dc_policy_store(struct device *dev, struct device_attribute *attr, 512 const char *buf, size_t count) 513 { 514 int ret = acpi_tad_policy_write(dev, buf, ACPI_TAD_DC_TIMER); 515 516 return ret ? ret : count; 517 } 518 519 static ssize_t dc_policy_show(struct device *dev, struct device_attribute *attr, 520 char *buf) 521 { 522 return acpi_tad_policy_read(dev, buf, ACPI_TAD_DC_TIMER); 523 } 524 525 static DEVICE_ATTR_RW(dc_policy); 526 527 static ssize_t dc_status_store(struct device *dev, struct device_attribute *attr, 528 const char *buf, size_t count) 529 { 530 int ret = acpi_tad_status_write(dev, buf, ACPI_TAD_DC_TIMER); 531 532 return ret ? ret : count; 533 } 534 535 static ssize_t dc_status_show(struct device *dev, struct device_attribute *attr, 536 char *buf) 537 { 538 return acpi_tad_status_read(dev, buf, ACPI_TAD_DC_TIMER); 539 } 540 541 static DEVICE_ATTR_RW(dc_status); 542 543 static struct attribute *acpi_tad_dc_attrs[] = { 544 &dev_attr_dc_alarm.attr, 545 &dev_attr_dc_policy.attr, 546 &dev_attr_dc_status.attr, 547 NULL, 548 }; 549 static const struct attribute_group acpi_tad_dc_attr_group = { 550 .attrs = acpi_tad_dc_attrs, 551 }; 552 553 static int acpi_tad_disable_timer(struct device *dev, u32 timer_id) 554 { 555 return acpi_tad_wake_set(dev, "_STV", timer_id, ACPI_TAD_WAKE_DISABLED); 556 } 557 558 static void acpi_tad_remove(struct platform_device *pdev) 559 { 560 struct device *dev = &pdev->dev; 561 acpi_handle handle = ACPI_HANDLE(dev); 562 struct acpi_tad_driver_data *dd = dev_get_drvdata(dev); 563 564 device_init_wakeup(dev, false); 565 566 pm_runtime_get_sync(dev); 567 568 if (dd->capabilities & ACPI_TAD_DC_WAKE) 569 sysfs_remove_group(&dev->kobj, &acpi_tad_dc_attr_group); 570 571 sysfs_remove_group(&dev->kobj, &acpi_tad_attr_group); 572 573 acpi_tad_disable_timer(dev, ACPI_TAD_AC_TIMER); 574 acpi_tad_clear_status(dev, ACPI_TAD_AC_TIMER); 575 if (dd->capabilities & ACPI_TAD_DC_WAKE) { 576 acpi_tad_disable_timer(dev, ACPI_TAD_DC_TIMER); 577 acpi_tad_clear_status(dev, ACPI_TAD_DC_TIMER); 578 } 579 580 pm_runtime_put_sync(dev); 581 pm_runtime_disable(dev); 582 acpi_remove_cmos_rtc_space_handler(handle); 583 } 584 585 static int acpi_tad_probe(struct platform_device *pdev) 586 { 587 struct device *dev = &pdev->dev; 588 acpi_handle handle = ACPI_HANDLE(dev); 589 struct acpi_tad_driver_data *dd; 590 acpi_status status; 591 unsigned long long caps; 592 int ret; 593 594 ret = acpi_install_cmos_rtc_space_handler(handle); 595 if (ret < 0) { 596 dev_info(dev, "Unable to install space handler\n"); 597 return -ENODEV; 598 } 599 /* 600 * Initialization failure messages are mostly about firmware issues, so 601 * print them at the "info" level. 602 */ 603 status = acpi_evaluate_integer(handle, "_GCP", NULL, &caps); 604 if (ACPI_FAILURE(status)) { 605 dev_info(dev, "Unable to get capabilities\n"); 606 ret = -ENODEV; 607 goto remove_handler; 608 } 609 610 if (!(caps & ACPI_TAD_AC_WAKE)) { 611 dev_info(dev, "Unsupported capabilities\n"); 612 ret = -ENODEV; 613 goto remove_handler; 614 } 615 616 if (!acpi_has_method(handle, "_PRW")) { 617 dev_info(dev, "Missing _PRW\n"); 618 ret = -ENODEV; 619 goto remove_handler; 620 } 621 622 dd = devm_kzalloc(dev, sizeof(*dd), GFP_KERNEL); 623 if (!dd) { 624 ret = -ENOMEM; 625 goto remove_handler; 626 } 627 628 dd->capabilities = caps; 629 dev_set_drvdata(dev, dd); 630 631 /* 632 * Assume that the ACPI PM domain has been attached to the device and 633 * simply enable system wakeup and runtime PM and put the device into 634 * runtime suspend. Everything else should be taken care of by the ACPI 635 * PM domain callbacks. 636 */ 637 device_init_wakeup(dev, true); 638 dev_pm_set_driver_flags(dev, DPM_FLAG_SMART_SUSPEND | 639 DPM_FLAG_MAY_SKIP_RESUME); 640 /* 641 * The platform bus type layer tells the ACPI PM domain powers up the 642 * device, so set the runtime PM status of it to "active". 643 */ 644 pm_runtime_set_active(dev); 645 pm_runtime_enable(dev); 646 pm_runtime_suspend(dev); 647 648 ret = sysfs_create_group(&dev->kobj, &acpi_tad_attr_group); 649 if (ret) 650 goto fail; 651 652 if (caps & ACPI_TAD_DC_WAKE) { 653 ret = sysfs_create_group(&dev->kobj, &acpi_tad_dc_attr_group); 654 if (ret) 655 goto fail; 656 } 657 658 if (caps & ACPI_TAD_RT) { 659 ret = sysfs_create_group(&dev->kobj, &acpi_tad_time_attr_group); 660 if (ret) 661 goto fail; 662 } 663 664 return 0; 665 666 fail: 667 acpi_tad_remove(pdev); 668 /* Don't fallthrough because cmos rtc space handler is removed in acpi_tad_remove() */ 669 return ret; 670 671 remove_handler: 672 acpi_remove_cmos_rtc_space_handler(handle); 673 return ret; 674 } 675 676 static const struct acpi_device_id acpi_tad_ids[] = { 677 {"ACPI000E", 0}, 678 {} 679 }; 680 681 static struct platform_driver acpi_tad_driver = { 682 .driver = { 683 .name = "acpi-tad", 684 .acpi_match_table = acpi_tad_ids, 685 }, 686 .probe = acpi_tad_probe, 687 .remove_new = acpi_tad_remove, 688 }; 689 MODULE_DEVICE_TABLE(acpi, acpi_tad_ids); 690 691 module_platform_driver(acpi_tad_driver); 692