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_LICENSE("GPL v2"); 31 MODULE_AUTHOR("Rafael J. Wysocki"); 32 33 /* ACPI TAD capability flags (ACPI 6.2, Section 9.18.2) */ 34 #define ACPI_TAD_AC_WAKE BIT(0) 35 #define ACPI_TAD_DC_WAKE BIT(1) 36 #define ACPI_TAD_RT BIT(2) 37 #define ACPI_TAD_RT_IN_MS BIT(3) 38 #define ACPI_TAD_S4_S5__GWS BIT(4) 39 #define ACPI_TAD_AC_S4_WAKE BIT(5) 40 #define ACPI_TAD_AC_S5_WAKE BIT(6) 41 #define ACPI_TAD_DC_S4_WAKE BIT(7) 42 #define ACPI_TAD_DC_S5_WAKE BIT(8) 43 44 /* ACPI TAD alarm timer selection */ 45 #define ACPI_TAD_AC_TIMER (u32)0 46 #define ACPI_TAD_DC_TIMER (u32)1 47 48 /* Special value for disabled timer or expired timer wake policy. */ 49 #define ACPI_TAD_WAKE_DISABLED (~(u32)0) 50 51 struct acpi_tad_driver_data { 52 u32 capabilities; 53 }; 54 55 struct acpi_tad_rt { 56 u16 year; /* 1900 - 9999 */ 57 u8 month; /* 1 - 12 */ 58 u8 day; /* 1 - 31 */ 59 u8 hour; /* 0 - 23 */ 60 u8 minute; /* 0 - 59 */ 61 u8 second; /* 0 - 59 */ 62 u8 valid; /* 0 (failed) or 1 (success) for reads, 0 for writes */ 63 u16 msec; /* 1 - 1000 */ 64 s16 tz; /* -1440 to 1440 or 2047 (unspecified) */ 65 u8 daylight; 66 u8 padding[3]; /* must be 0 */ 67 } __packed; 68 69 static int acpi_tad_set_real_time(struct device *dev, struct acpi_tad_rt *rt) 70 { 71 acpi_handle handle = ACPI_HANDLE(dev); 72 union acpi_object args[] = { 73 { .type = ACPI_TYPE_BUFFER, }, 74 }; 75 struct acpi_object_list arg_list = { 76 .pointer = args, 77 .count = ARRAY_SIZE(args), 78 }; 79 unsigned long long retval; 80 acpi_status status; 81 82 if (rt->year < 1900 || rt->year > 9999 || 83 rt->month < 1 || rt->month > 12 || 84 rt->hour > 23 || rt->minute > 59 || rt->second > 59 || 85 rt->tz < -1440 || (rt->tz > 1440 && rt->tz != 2047) || 86 rt->daylight > 3) 87 return -ERANGE; 88 89 args[0].buffer.pointer = (u8 *)rt; 90 args[0].buffer.length = sizeof(*rt); 91 92 pm_runtime_get_sync(dev); 93 94 status = acpi_evaluate_integer(handle, "_SRT", &arg_list, &retval); 95 96 pm_runtime_put_sync(dev); 97 98 if (ACPI_FAILURE(status) || retval) 99 return -EIO; 100 101 return 0; 102 } 103 104 static int acpi_tad_get_real_time(struct device *dev, struct acpi_tad_rt *rt) 105 { 106 acpi_handle handle = ACPI_HANDLE(dev); 107 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER }; 108 union acpi_object *out_obj; 109 struct acpi_tad_rt *data; 110 acpi_status status; 111 int ret = -EIO; 112 113 pm_runtime_get_sync(dev); 114 115 status = acpi_evaluate_object(handle, "_GRT", NULL, &output); 116 117 pm_runtime_put_sync(dev); 118 119 if (ACPI_FAILURE(status)) 120 goto out_free; 121 122 out_obj = output.pointer; 123 if (out_obj->type != ACPI_TYPE_BUFFER) 124 goto out_free; 125 126 if (out_obj->buffer.length != sizeof(*rt)) 127 goto out_free; 128 129 data = (struct acpi_tad_rt *)(out_obj->buffer.pointer); 130 if (!data->valid) 131 goto out_free; 132 133 memcpy(rt, data, sizeof(*rt)); 134 ret = 0; 135 136 out_free: 137 ACPI_FREE(output.pointer); 138 return ret; 139 } 140 141 static char *acpi_tad_rt_next_field(char *s, int *val) 142 { 143 char *p; 144 145 p = strchr(s, ':'); 146 if (!p) 147 return NULL; 148 149 *p = '\0'; 150 if (kstrtoint(s, 10, val)) 151 return NULL; 152 153 return p + 1; 154 } 155 156 static ssize_t time_store(struct device *dev, struct device_attribute *attr, 157 const char *buf, size_t count) 158 { 159 struct acpi_tad_rt rt; 160 char *str, *s; 161 int val, ret = -ENODATA; 162 163 str = kmemdup_nul(buf, count, GFP_KERNEL); 164 if (!str) 165 return -ENOMEM; 166 167 s = acpi_tad_rt_next_field(str, &val); 168 if (!s) 169 goto out_free; 170 171 rt.year = val; 172 173 s = acpi_tad_rt_next_field(s, &val); 174 if (!s) 175 goto out_free; 176 177 rt.month = val; 178 179 s = acpi_tad_rt_next_field(s, &val); 180 if (!s) 181 goto out_free; 182 183 rt.day = val; 184 185 s = acpi_tad_rt_next_field(s, &val); 186 if (!s) 187 goto out_free; 188 189 rt.hour = val; 190 191 s = acpi_tad_rt_next_field(s, &val); 192 if (!s) 193 goto out_free; 194 195 rt.minute = val; 196 197 s = acpi_tad_rt_next_field(s, &val); 198 if (!s) 199 goto out_free; 200 201 rt.second = val; 202 203 s = acpi_tad_rt_next_field(s, &val); 204 if (!s) 205 goto out_free; 206 207 rt.tz = val; 208 209 if (kstrtoint(s, 10, &val)) 210 goto out_free; 211 212 rt.daylight = val; 213 214 rt.valid = 0; 215 rt.msec = 0; 216 memset(rt.padding, 0, 3); 217 218 ret = acpi_tad_set_real_time(dev, &rt); 219 220 out_free: 221 kfree(str); 222 return ret ? ret : count; 223 } 224 225 static ssize_t time_show(struct device *dev, struct device_attribute *attr, 226 char *buf) 227 { 228 struct acpi_tad_rt rt; 229 int ret; 230 231 ret = acpi_tad_get_real_time(dev, &rt); 232 if (ret) 233 return ret; 234 235 return sprintf(buf, "%u:%u:%u:%u:%u:%u:%d:%u\n", 236 rt.year, rt.month, rt.day, rt.hour, rt.minute, rt.second, 237 rt.tz, rt.daylight); 238 } 239 240 static DEVICE_ATTR_RW(time); 241 242 static struct attribute *acpi_tad_time_attrs[] = { 243 &dev_attr_time.attr, 244 NULL, 245 }; 246 static const struct attribute_group acpi_tad_time_attr_group = { 247 .attrs = acpi_tad_time_attrs, 248 }; 249 250 static int acpi_tad_wake_set(struct device *dev, char *method, u32 timer_id, 251 u32 value) 252 { 253 acpi_handle handle = ACPI_HANDLE(dev); 254 union acpi_object args[] = { 255 { .type = ACPI_TYPE_INTEGER, }, 256 { .type = ACPI_TYPE_INTEGER, }, 257 }; 258 struct acpi_object_list arg_list = { 259 .pointer = args, 260 .count = ARRAY_SIZE(args), 261 }; 262 unsigned long long retval; 263 acpi_status status; 264 265 args[0].integer.value = timer_id; 266 args[1].integer.value = value; 267 268 pm_runtime_get_sync(dev); 269 270 status = acpi_evaluate_integer(handle, method, &arg_list, &retval); 271 272 pm_runtime_put_sync(dev); 273 274 if (ACPI_FAILURE(status) || retval) 275 return -EIO; 276 277 return 0; 278 } 279 280 static int acpi_tad_wake_write(struct device *dev, const char *buf, char *method, 281 u32 timer_id, const char *specval) 282 { 283 u32 value; 284 285 if (sysfs_streq(buf, specval)) { 286 value = ACPI_TAD_WAKE_DISABLED; 287 } else { 288 int ret = kstrtou32(buf, 0, &value); 289 290 if (ret) 291 return ret; 292 293 if (value == ACPI_TAD_WAKE_DISABLED) 294 return -EINVAL; 295 } 296 297 return acpi_tad_wake_set(dev, method, timer_id, value); 298 } 299 300 static ssize_t acpi_tad_wake_read(struct device *dev, char *buf, char *method, 301 u32 timer_id, const char *specval) 302 { 303 acpi_handle handle = ACPI_HANDLE(dev); 304 union acpi_object args[] = { 305 { .type = ACPI_TYPE_INTEGER, }, 306 }; 307 struct acpi_object_list arg_list = { 308 .pointer = args, 309 .count = ARRAY_SIZE(args), 310 }; 311 unsigned long long retval; 312 acpi_status status; 313 314 args[0].integer.value = timer_id; 315 316 pm_runtime_get_sync(dev); 317 318 status = acpi_evaluate_integer(handle, method, &arg_list, &retval); 319 320 pm_runtime_put_sync(dev); 321 322 if (ACPI_FAILURE(status)) 323 return -EIO; 324 325 if ((u32)retval == ACPI_TAD_WAKE_DISABLED) 326 return sprintf(buf, "%s\n", specval); 327 328 return sprintf(buf, "%u\n", (u32)retval); 329 } 330 331 static const char *alarm_specval = "disabled"; 332 333 static int acpi_tad_alarm_write(struct device *dev, const char *buf, 334 u32 timer_id) 335 { 336 return acpi_tad_wake_write(dev, buf, "_STV", timer_id, alarm_specval); 337 } 338 339 static ssize_t acpi_tad_alarm_read(struct device *dev, char *buf, u32 timer_id) 340 { 341 return acpi_tad_wake_read(dev, buf, "_TIV", timer_id, alarm_specval); 342 } 343 344 static const char *policy_specval = "never"; 345 346 static int acpi_tad_policy_write(struct device *dev, const char *buf, 347 u32 timer_id) 348 { 349 return acpi_tad_wake_write(dev, buf, "_STP", timer_id, policy_specval); 350 } 351 352 static ssize_t acpi_tad_policy_read(struct device *dev, char *buf, u32 timer_id) 353 { 354 return acpi_tad_wake_read(dev, buf, "_TIP", timer_id, policy_specval); 355 } 356 357 static int acpi_tad_clear_status(struct device *dev, u32 timer_id) 358 { 359 acpi_handle handle = ACPI_HANDLE(dev); 360 union acpi_object args[] = { 361 { .type = ACPI_TYPE_INTEGER, }, 362 }; 363 struct acpi_object_list arg_list = { 364 .pointer = args, 365 .count = ARRAY_SIZE(args), 366 }; 367 unsigned long long retval; 368 acpi_status status; 369 370 args[0].integer.value = timer_id; 371 372 pm_runtime_get_sync(dev); 373 374 status = acpi_evaluate_integer(handle, "_CWS", &arg_list, &retval); 375 376 pm_runtime_put_sync(dev); 377 378 if (ACPI_FAILURE(status) || retval) 379 return -EIO; 380 381 return 0; 382 } 383 384 static int acpi_tad_status_write(struct device *dev, const char *buf, u32 timer_id) 385 { 386 int ret, value; 387 388 ret = kstrtoint(buf, 0, &value); 389 if (ret) 390 return ret; 391 392 if (value) 393 return -EINVAL; 394 395 return acpi_tad_clear_status(dev, timer_id); 396 } 397 398 static ssize_t acpi_tad_status_read(struct device *dev, char *buf, u32 timer_id) 399 { 400 acpi_handle handle = ACPI_HANDLE(dev); 401 union acpi_object args[] = { 402 { .type = ACPI_TYPE_INTEGER, }, 403 }; 404 struct acpi_object_list arg_list = { 405 .pointer = args, 406 .count = ARRAY_SIZE(args), 407 }; 408 unsigned long long retval; 409 acpi_status status; 410 411 args[0].integer.value = timer_id; 412 413 pm_runtime_get_sync(dev); 414 415 status = acpi_evaluate_integer(handle, "_GWS", &arg_list, &retval); 416 417 pm_runtime_put_sync(dev); 418 419 if (ACPI_FAILURE(status)) 420 return -EIO; 421 422 return sprintf(buf, "0x%02X\n", (u32)retval); 423 } 424 425 static ssize_t caps_show(struct device *dev, struct device_attribute *attr, 426 char *buf) 427 { 428 struct acpi_tad_driver_data *dd = dev_get_drvdata(dev); 429 430 return sprintf(buf, "0x%02X\n", dd->capabilities); 431 } 432 433 static DEVICE_ATTR_RO(caps); 434 435 static ssize_t ac_alarm_store(struct device *dev, struct device_attribute *attr, 436 const char *buf, size_t count) 437 { 438 int ret = acpi_tad_alarm_write(dev, buf, ACPI_TAD_AC_TIMER); 439 440 return ret ? ret : count; 441 } 442 443 static ssize_t ac_alarm_show(struct device *dev, struct device_attribute *attr, 444 char *buf) 445 { 446 return acpi_tad_alarm_read(dev, buf, ACPI_TAD_AC_TIMER); 447 } 448 449 static DEVICE_ATTR_RW(ac_alarm); 450 451 static ssize_t ac_policy_store(struct device *dev, struct device_attribute *attr, 452 const char *buf, size_t count) 453 { 454 int ret = acpi_tad_policy_write(dev, buf, ACPI_TAD_AC_TIMER); 455 456 return ret ? ret : count; 457 } 458 459 static ssize_t ac_policy_show(struct device *dev, struct device_attribute *attr, 460 char *buf) 461 { 462 return acpi_tad_policy_read(dev, buf, ACPI_TAD_AC_TIMER); 463 } 464 465 static DEVICE_ATTR_RW(ac_policy); 466 467 static ssize_t ac_status_store(struct device *dev, struct device_attribute *attr, 468 const char *buf, size_t count) 469 { 470 int ret = acpi_tad_status_write(dev, buf, ACPI_TAD_AC_TIMER); 471 472 return ret ? ret : count; 473 } 474 475 static ssize_t ac_status_show(struct device *dev, struct device_attribute *attr, 476 char *buf) 477 { 478 return acpi_tad_status_read(dev, buf, ACPI_TAD_AC_TIMER); 479 } 480 481 static DEVICE_ATTR_RW(ac_status); 482 483 static struct attribute *acpi_tad_attrs[] = { 484 &dev_attr_caps.attr, 485 &dev_attr_ac_alarm.attr, 486 &dev_attr_ac_policy.attr, 487 &dev_attr_ac_status.attr, 488 NULL, 489 }; 490 static const struct attribute_group acpi_tad_attr_group = { 491 .attrs = acpi_tad_attrs, 492 }; 493 494 static ssize_t dc_alarm_store(struct device *dev, struct device_attribute *attr, 495 const char *buf, size_t count) 496 { 497 int ret = acpi_tad_alarm_write(dev, buf, ACPI_TAD_DC_TIMER); 498 499 return ret ? ret : count; 500 } 501 502 static ssize_t dc_alarm_show(struct device *dev, struct device_attribute *attr, 503 char *buf) 504 { 505 return acpi_tad_alarm_read(dev, buf, ACPI_TAD_DC_TIMER); 506 } 507 508 static DEVICE_ATTR_RW(dc_alarm); 509 510 static ssize_t dc_policy_store(struct device *dev, struct device_attribute *attr, 511 const char *buf, size_t count) 512 { 513 int ret = acpi_tad_policy_write(dev, buf, ACPI_TAD_DC_TIMER); 514 515 return ret ? ret : count; 516 } 517 518 static ssize_t dc_policy_show(struct device *dev, struct device_attribute *attr, 519 char *buf) 520 { 521 return acpi_tad_policy_read(dev, buf, ACPI_TAD_DC_TIMER); 522 } 523 524 static DEVICE_ATTR_RW(dc_policy); 525 526 static ssize_t dc_status_store(struct device *dev, struct device_attribute *attr, 527 const char *buf, size_t count) 528 { 529 int ret = acpi_tad_status_write(dev, buf, ACPI_TAD_DC_TIMER); 530 531 return ret ? ret : count; 532 } 533 534 static ssize_t dc_status_show(struct device *dev, struct device_attribute *attr, 535 char *buf) 536 { 537 return acpi_tad_status_read(dev, buf, ACPI_TAD_DC_TIMER); 538 } 539 540 static DEVICE_ATTR_RW(dc_status); 541 542 static struct attribute *acpi_tad_dc_attrs[] = { 543 &dev_attr_dc_alarm.attr, 544 &dev_attr_dc_policy.attr, 545 &dev_attr_dc_status.attr, 546 NULL, 547 }; 548 static const struct attribute_group acpi_tad_dc_attr_group = { 549 .attrs = acpi_tad_dc_attrs, 550 }; 551 552 static int acpi_tad_disable_timer(struct device *dev, u32 timer_id) 553 { 554 return acpi_tad_wake_set(dev, "_STV", timer_id, ACPI_TAD_WAKE_DISABLED); 555 } 556 557 static int acpi_tad_remove(struct platform_device *pdev) 558 { 559 struct device *dev = &pdev->dev; 560 acpi_handle handle = ACPI_HANDLE(dev); 561 struct acpi_tad_driver_data *dd = dev_get_drvdata(dev); 562 563 device_init_wakeup(dev, false); 564 565 pm_runtime_get_sync(dev); 566 567 if (dd->capabilities & ACPI_TAD_DC_WAKE) 568 sysfs_remove_group(&dev->kobj, &acpi_tad_dc_attr_group); 569 570 sysfs_remove_group(&dev->kobj, &acpi_tad_attr_group); 571 572 acpi_tad_disable_timer(dev, ACPI_TAD_AC_TIMER); 573 acpi_tad_clear_status(dev, ACPI_TAD_AC_TIMER); 574 if (dd->capabilities & ACPI_TAD_DC_WAKE) { 575 acpi_tad_disable_timer(dev, ACPI_TAD_DC_TIMER); 576 acpi_tad_clear_status(dev, ACPI_TAD_DC_TIMER); 577 } 578 579 pm_runtime_put_sync(dev); 580 pm_runtime_disable(dev); 581 acpi_remove_cmos_rtc_space_handler(handle); 582 return 0; 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 = acpi_tad_remove, 688 }; 689 MODULE_DEVICE_TABLE(acpi, acpi_tad_ids); 690 691 module_platform_driver(acpi_tad_driver); 692