1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * ACPI Time and Alarm (TAD) Device Driver 4 * 5 * Copyright (C) 2018 - 2026 Intel Corporation 6 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> 7 * 8 * This driver is based on ACPI 6.6, Section 9.17. 9 * 10 * Provided are sysfs attributes, available under the TAD platform device, 11 * allowing user space to manage the AC and DC wakeup timers of the TAD: 12 * set and read their values, set and check their expire timer wake policies, 13 * check and clear their status and check the capabilities of the TAD reported 14 * by AML. The DC timer attributes are only present if the TAD supports a 15 * separate DC alarm timer. 16 * 17 * The wakeup events handling and power management of the TAD is expected to 18 * be taken care of by the ACPI PM domain attached to its platform device. 19 * 20 * If the TAD supports the get/set real time features, as indicated by the 21 * capability mask returned by _GCP under the TAD object, additional sysfs 22 * attributes are created allowing the real time to be set and read and an RTC 23 * class device is registered under the TAD platform device. 24 */ 25 26 #include <linux/acpi.h> 27 #include <linux/kernel.h> 28 #include <linux/ktime.h> 29 #include <linux/module.h> 30 #include <linux/platform_device.h> 31 #include <linux/pm_runtime.h> 32 #include <linux/rtc.h> 33 #include <linux/suspend.h> 34 35 MODULE_DESCRIPTION("ACPI Time and Alarm (TAD) Device Driver"); 36 MODULE_LICENSE("GPL v2"); 37 MODULE_AUTHOR("Rafael J. Wysocki"); 38 39 /* ACPI TAD capability flags (ACPI 6.6, Section 9.17.2) */ 40 #define ACPI_TAD_AC_WAKE BIT(0) 41 #define ACPI_TAD_DC_WAKE BIT(1) 42 #define ACPI_TAD_RT BIT(2) 43 #define ACPI_TAD_RT_IN_MS BIT(3) 44 #define ACPI_TAD_S4_S5__GWS BIT(4) 45 #define ACPI_TAD_AC_S4_WAKE BIT(5) 46 #define ACPI_TAD_AC_S5_WAKE BIT(6) 47 #define ACPI_TAD_DC_S4_WAKE BIT(7) 48 #define ACPI_TAD_DC_S5_WAKE BIT(8) 49 50 /* ACPI TAD alarm timer selection */ 51 #define ACPI_TAD_AC_TIMER (u32)0 52 #define ACPI_TAD_DC_TIMER (u32)1 53 54 /* Special value for disabled timer or expired timer wake policy. */ 55 #define ACPI_TAD_WAKE_DISABLED (~(u32)0) 56 57 /* ACPI TAD RTC */ 58 #define ACPI_TAD_TZ_UNSPEC 2047 59 #define ACPI_TAD_TIME_ISDST 3 60 61 struct acpi_tad_driver_data { 62 u32 capabilities; 63 }; 64 65 struct acpi_tad_rt { 66 u16 year; /* 1900 - 9999 */ 67 u8 month; /* 1 - 12 */ 68 u8 day; /* 1 - 31 */ 69 u8 hour; /* 0 - 23 */ 70 u8 minute; /* 0 - 59 */ 71 u8 second; /* 0 - 59 */ 72 u8 valid; /* 0 (failed) or 1 (success) for reads, 0 for writes */ 73 u16 msec; /* 1 - 1000 */ 74 s16 tz; /* -1440 to 1440 or 2047 (unspecified) */ 75 u8 daylight; 76 u8 padding[3]; /* must be 0 */ 77 } __packed; 78 79 static bool acpi_tad_rt_is_invalid(struct acpi_tad_rt *rt) 80 { 81 return rt->year < 1900 || rt->year > 9999 || 82 rt->month < 1 || rt->month > 12 || 83 rt->hour > 23 || rt->minute > 59 || rt->second > 59 || 84 rt->tz < -1440 || 85 (rt->tz > 1440 && rt->tz != ACPI_TAD_TZ_UNSPEC) || 86 rt->daylight > 3; 87 } 88 89 static int acpi_tad_set_real_time(struct device *dev, struct acpi_tad_rt *rt) 90 { 91 acpi_handle handle = ACPI_HANDLE(dev); 92 union acpi_object args[] = { 93 { .type = ACPI_TYPE_BUFFER, }, 94 }; 95 struct acpi_object_list arg_list = { 96 .pointer = args, 97 .count = ARRAY_SIZE(args), 98 }; 99 unsigned long long retval; 100 acpi_status status; 101 102 if (acpi_tad_rt_is_invalid(rt)) 103 return -EINVAL; 104 105 rt->valid = 0; 106 rt->msec = 0; 107 memset(rt->padding, 0, 3); 108 109 args[0].buffer.pointer = (u8 *)rt; 110 args[0].buffer.length = sizeof(*rt); 111 112 PM_RUNTIME_ACQUIRE(dev, pm); 113 if (PM_RUNTIME_ACQUIRE_ERR(&pm)) 114 return -ENXIO; 115 116 status = acpi_evaluate_integer(handle, "_SRT", &arg_list, &retval); 117 if (ACPI_FAILURE(status) || retval) 118 return -EIO; 119 120 return 0; 121 } 122 123 static int acpi_tad_evaluate_grt(struct device *dev, struct acpi_tad_rt *rt) 124 { 125 acpi_handle handle = ACPI_HANDLE(dev); 126 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER }; 127 union acpi_object *out_obj; 128 struct acpi_tad_rt *data; 129 acpi_status status; 130 int ret = -EIO; 131 132 status = acpi_evaluate_object(handle, "_GRT", NULL, &output); 133 if (ACPI_FAILURE(status)) 134 goto out_free; 135 136 out_obj = output.pointer; 137 if (out_obj->type != ACPI_TYPE_BUFFER) 138 goto out_free; 139 140 if (out_obj->buffer.length != sizeof(*rt)) 141 goto out_free; 142 143 data = (struct acpi_tad_rt *)(out_obj->buffer.pointer); 144 if (!data->valid) 145 goto out_free; 146 147 memcpy(rt, data, sizeof(*rt)); 148 ret = 0; 149 150 out_free: 151 ACPI_FREE(output.pointer); 152 return ret; 153 } 154 155 static int __acpi_tad_get_real_time(struct device *dev, struct acpi_tad_rt *rt) 156 { 157 int ret; 158 159 ret = acpi_tad_evaluate_grt(dev, rt); 160 if (ret) 161 return ret; 162 163 if (acpi_tad_rt_is_invalid(rt)) 164 return -ENODATA; 165 166 return 0; 167 } 168 169 static int acpi_tad_get_real_time(struct device *dev, struct acpi_tad_rt *rt) 170 { 171 PM_RUNTIME_ACQUIRE(dev, pm); 172 if (PM_RUNTIME_ACQUIRE_ERR(&pm)) 173 return -ENXIO; 174 175 return __acpi_tad_get_real_time(dev, rt); 176 } 177 178 static int __acpi_tad_wake_set(struct device *dev, char *method, u32 timer_id, 179 u32 value) 180 { 181 acpi_handle handle = ACPI_HANDLE(dev); 182 union acpi_object args[] = { 183 { .type = ACPI_TYPE_INTEGER, }, 184 { .type = ACPI_TYPE_INTEGER, }, 185 }; 186 struct acpi_object_list arg_list = { 187 .pointer = args, 188 .count = ARRAY_SIZE(args), 189 }; 190 unsigned long long retval; 191 acpi_status status; 192 193 args[0].integer.value = timer_id; 194 args[1].integer.value = value; 195 196 status = acpi_evaluate_integer(handle, method, &arg_list, &retval); 197 if (ACPI_FAILURE(status) || retval) 198 return -EIO; 199 200 return 0; 201 } 202 203 static int __acpi_tad_wake_read(struct device *dev, char *method, u32 timer_id, 204 unsigned long long *retval) 205 { 206 acpi_handle handle = ACPI_HANDLE(dev); 207 union acpi_object args[] = { 208 { .type = ACPI_TYPE_INTEGER, }, 209 }; 210 struct acpi_object_list arg_list = { 211 .pointer = args, 212 .count = ARRAY_SIZE(args), 213 }; 214 acpi_status status; 215 216 args[0].integer.value = timer_id; 217 218 status = acpi_evaluate_integer(handle, method, &arg_list, retval); 219 if (ACPI_FAILURE(status)) 220 return -EIO; 221 222 return 0; 223 } 224 225 /* sysfs interface */ 226 227 static char *acpi_tad_rt_next_field(char *s, int *val) 228 { 229 char *p; 230 231 p = strchr(s, ':'); 232 if (!p) 233 return NULL; 234 235 *p = '\0'; 236 if (kstrtoint(s, 10, val)) 237 return NULL; 238 239 return p + 1; 240 } 241 242 static ssize_t time_store(struct device *dev, struct device_attribute *attr, 243 const char *buf, size_t count) 244 { 245 struct acpi_tad_rt rt; 246 int val, ret; 247 char *s; 248 249 char *str __free(kfree) = kmemdup_nul(buf, count, GFP_KERNEL); 250 if (!str) 251 return -ENOMEM; 252 253 s = acpi_tad_rt_next_field(str, &val); 254 if (!s) 255 return -ENODATA; 256 257 rt.year = val; 258 259 s = acpi_tad_rt_next_field(s, &val); 260 if (!s) 261 return -ENODATA; 262 263 rt.month = val; 264 265 s = acpi_tad_rt_next_field(s, &val); 266 if (!s) 267 return -ENODATA; 268 269 rt.day = val; 270 271 s = acpi_tad_rt_next_field(s, &val); 272 if (!s) 273 return -ENODATA; 274 275 rt.hour = val; 276 277 s = acpi_tad_rt_next_field(s, &val); 278 if (!s) 279 return -ENODATA; 280 281 rt.minute = val; 282 283 s = acpi_tad_rt_next_field(s, &val); 284 if (!s) 285 return -ENODATA; 286 287 rt.second = val; 288 289 s = acpi_tad_rt_next_field(s, &val); 290 if (!s) 291 return -ENODATA; 292 293 rt.tz = val; 294 295 if (kstrtoint(s, 10, &val)) 296 return -ENODATA; 297 298 rt.daylight = val; 299 300 ret = acpi_tad_set_real_time(dev, &rt); 301 if (ret) 302 return ret; 303 304 return count; 305 } 306 307 static ssize_t time_show(struct device *dev, struct device_attribute *attr, 308 char *buf) 309 { 310 struct acpi_tad_rt rt; 311 int ret; 312 313 ret = acpi_tad_get_real_time(dev, &rt); 314 if (ret) 315 return ret; 316 317 return sysfs_emit(buf, "%u:%u:%u:%u:%u:%u:%d:%u\n", 318 rt.year, rt.month, rt.day, rt.hour, rt.minute, rt.second, 319 rt.tz, rt.daylight); 320 } 321 322 static DEVICE_ATTR_RW(time); 323 324 static int acpi_tad_wake_set(struct device *dev, char *method, u32 timer_id, 325 u32 value) 326 { 327 PM_RUNTIME_ACQUIRE(dev, pm); 328 if (PM_RUNTIME_ACQUIRE_ERR(&pm)) 329 return -ENXIO; 330 331 return __acpi_tad_wake_set(dev, method, timer_id, value); 332 } 333 334 static int acpi_tad_wake_write(struct device *dev, const char *buf, char *method, 335 u32 timer_id, const char *specval) 336 { 337 u32 value; 338 339 if (sysfs_streq(buf, specval)) { 340 value = ACPI_TAD_WAKE_DISABLED; 341 } else { 342 int ret = kstrtou32(buf, 0, &value); 343 344 if (ret) 345 return ret; 346 347 if (value == ACPI_TAD_WAKE_DISABLED) 348 return -EINVAL; 349 } 350 351 return acpi_tad_wake_set(dev, method, timer_id, value); 352 } 353 354 static ssize_t acpi_tad_wake_read(struct device *dev, char *buf, char *method, 355 u32 timer_id, const char *specval) 356 { 357 unsigned long long retval; 358 int ret; 359 360 PM_RUNTIME_ACQUIRE(dev, pm); 361 if (PM_RUNTIME_ACQUIRE_ERR(&pm)) 362 return -ENXIO; 363 364 ret = __acpi_tad_wake_read(dev, method, timer_id, &retval); 365 if (ret) 366 return ret; 367 368 if ((u32)retval == ACPI_TAD_WAKE_DISABLED) 369 return sprintf(buf, "%s\n", specval); 370 371 return sprintf(buf, "%u\n", (u32)retval); 372 } 373 374 static const char *alarm_specval = "disabled"; 375 376 static int acpi_tad_alarm_write(struct device *dev, const char *buf, 377 u32 timer_id) 378 { 379 return acpi_tad_wake_write(dev, buf, "_STV", timer_id, alarm_specval); 380 } 381 382 static ssize_t acpi_tad_alarm_read(struct device *dev, char *buf, u32 timer_id) 383 { 384 return acpi_tad_wake_read(dev, buf, "_TIV", timer_id, alarm_specval); 385 } 386 387 static const char *policy_specval = "never"; 388 389 static int acpi_tad_policy_write(struct device *dev, const char *buf, 390 u32 timer_id) 391 { 392 return acpi_tad_wake_write(dev, buf, "_STP", timer_id, policy_specval); 393 } 394 395 static ssize_t acpi_tad_policy_read(struct device *dev, char *buf, u32 timer_id) 396 { 397 return acpi_tad_wake_read(dev, buf, "_TIP", timer_id, policy_specval); 398 } 399 400 static int acpi_tad_clear_status(struct device *dev, u32 timer_id) 401 { 402 acpi_handle handle = ACPI_HANDLE(dev); 403 union acpi_object args[] = { 404 { .type = ACPI_TYPE_INTEGER, }, 405 }; 406 struct acpi_object_list arg_list = { 407 .pointer = args, 408 .count = ARRAY_SIZE(args), 409 }; 410 unsigned long long retval; 411 acpi_status status; 412 413 args[0].integer.value = timer_id; 414 415 PM_RUNTIME_ACQUIRE(dev, pm); 416 if (PM_RUNTIME_ACQUIRE_ERR(&pm)) 417 return -ENXIO; 418 419 status = acpi_evaluate_integer(handle, "_CWS", &arg_list, &retval); 420 if (ACPI_FAILURE(status) || retval) 421 return -EIO; 422 423 return 0; 424 } 425 426 static int acpi_tad_status_write(struct device *dev, const char *buf, u32 timer_id) 427 { 428 int ret, value; 429 430 ret = kstrtoint(buf, 0, &value); 431 if (ret) 432 return ret; 433 434 if (value) 435 return -EINVAL; 436 437 return acpi_tad_clear_status(dev, timer_id); 438 } 439 440 static ssize_t acpi_tad_status_read(struct device *dev, char *buf, u32 timer_id) 441 { 442 acpi_handle handle = ACPI_HANDLE(dev); 443 union acpi_object args[] = { 444 { .type = ACPI_TYPE_INTEGER, }, 445 }; 446 struct acpi_object_list arg_list = { 447 .pointer = args, 448 .count = ARRAY_SIZE(args), 449 }; 450 unsigned long long retval; 451 acpi_status status; 452 453 args[0].integer.value = timer_id; 454 455 PM_RUNTIME_ACQUIRE(dev, pm); 456 if (PM_RUNTIME_ACQUIRE_ERR(&pm)) 457 return -ENXIO; 458 459 status = acpi_evaluate_integer(handle, "_GWS", &arg_list, &retval); 460 if (ACPI_FAILURE(status)) 461 return -EIO; 462 463 return sprintf(buf, "0x%02X\n", (u32)retval); 464 } 465 466 static ssize_t caps_show(struct device *dev, struct device_attribute *attr, 467 char *buf) 468 { 469 struct acpi_tad_driver_data *dd = dev_get_drvdata(dev); 470 471 return sysfs_emit(buf, "0x%02X\n", dd->capabilities); 472 } 473 474 static DEVICE_ATTR_RO(caps); 475 476 static ssize_t ac_alarm_store(struct device *dev, struct device_attribute *attr, 477 const char *buf, size_t count) 478 { 479 int ret = acpi_tad_alarm_write(dev, buf, ACPI_TAD_AC_TIMER); 480 481 return ret ? ret : count; 482 } 483 484 static ssize_t ac_alarm_show(struct device *dev, struct device_attribute *attr, 485 char *buf) 486 { 487 return acpi_tad_alarm_read(dev, buf, ACPI_TAD_AC_TIMER); 488 } 489 490 static DEVICE_ATTR_RW(ac_alarm); 491 492 static ssize_t ac_policy_store(struct device *dev, struct device_attribute *attr, 493 const char *buf, size_t count) 494 { 495 int ret = acpi_tad_policy_write(dev, buf, ACPI_TAD_AC_TIMER); 496 497 return ret ? ret : count; 498 } 499 500 static ssize_t ac_policy_show(struct device *dev, struct device_attribute *attr, 501 char *buf) 502 { 503 return acpi_tad_policy_read(dev, buf, ACPI_TAD_AC_TIMER); 504 } 505 506 static DEVICE_ATTR_RW(ac_policy); 507 508 static ssize_t ac_status_store(struct device *dev, struct device_attribute *attr, 509 const char *buf, size_t count) 510 { 511 int ret = acpi_tad_status_write(dev, buf, ACPI_TAD_AC_TIMER); 512 513 return ret ? ret : count; 514 } 515 516 static ssize_t ac_status_show(struct device *dev, struct device_attribute *attr, 517 char *buf) 518 { 519 return acpi_tad_status_read(dev, buf, ACPI_TAD_AC_TIMER); 520 } 521 522 static DEVICE_ATTR_RW(ac_status); 523 524 static ssize_t dc_alarm_store(struct device *dev, struct device_attribute *attr, 525 const char *buf, size_t count) 526 { 527 int ret = acpi_tad_alarm_write(dev, buf, ACPI_TAD_DC_TIMER); 528 529 return ret ? ret : count; 530 } 531 532 static ssize_t dc_alarm_show(struct device *dev, struct device_attribute *attr, 533 char *buf) 534 { 535 return acpi_tad_alarm_read(dev, buf, ACPI_TAD_DC_TIMER); 536 } 537 538 static DEVICE_ATTR_RW(dc_alarm); 539 540 static ssize_t dc_policy_store(struct device *dev, struct device_attribute *attr, 541 const char *buf, size_t count) 542 { 543 int ret = acpi_tad_policy_write(dev, buf, ACPI_TAD_DC_TIMER); 544 545 return ret ? ret : count; 546 } 547 548 static ssize_t dc_policy_show(struct device *dev, struct device_attribute *attr, 549 char *buf) 550 { 551 return acpi_tad_policy_read(dev, buf, ACPI_TAD_DC_TIMER); 552 } 553 554 static DEVICE_ATTR_RW(dc_policy); 555 556 static ssize_t dc_status_store(struct device *dev, struct device_attribute *attr, 557 const char *buf, size_t count) 558 { 559 int ret = acpi_tad_status_write(dev, buf, ACPI_TAD_DC_TIMER); 560 561 return ret ? ret : count; 562 } 563 564 static ssize_t dc_status_show(struct device *dev, struct device_attribute *attr, 565 char *buf) 566 { 567 return acpi_tad_status_read(dev, buf, ACPI_TAD_DC_TIMER); 568 } 569 570 static DEVICE_ATTR_RW(dc_status); 571 572 static struct attribute *acpi_tad_attrs[] = { 573 &dev_attr_caps.attr, 574 &dev_attr_ac_alarm.attr, 575 &dev_attr_ac_policy.attr, 576 &dev_attr_ac_status.attr, 577 &dev_attr_dc_alarm.attr, 578 &dev_attr_dc_policy.attr, 579 &dev_attr_dc_status.attr, 580 &dev_attr_time.attr, 581 NULL, 582 }; 583 584 static umode_t acpi_tad_attr_is_visible(struct kobject *kobj, 585 struct attribute *a, int n) 586 { 587 struct acpi_tad_driver_data *dd = dev_get_drvdata(kobj_to_dev(kobj)); 588 589 if (a == &dev_attr_caps.attr) 590 return a->mode; 591 592 if ((dd->capabilities & ACPI_TAD_AC_WAKE) && 593 (a == &dev_attr_ac_alarm.attr || a == &dev_attr_ac_policy.attr || 594 a == &dev_attr_ac_status.attr)) 595 return a->mode; 596 597 if ((dd->capabilities & ACPI_TAD_DC_WAKE) && 598 (a == &dev_attr_dc_alarm.attr || a == &dev_attr_dc_policy.attr || 599 a == &dev_attr_dc_status.attr)) 600 return a->mode; 601 602 if ((dd->capabilities & ACPI_TAD_RT) && a == &dev_attr_time.attr) 603 return a->mode; 604 605 return 0; 606 } 607 608 static const struct attribute_group acpi_tad_attr_group = { 609 .attrs = acpi_tad_attrs, 610 .is_visible = acpi_tad_attr_is_visible, 611 }; 612 613 static const struct attribute_group *acpi_tad_attr_groups[] = { 614 &acpi_tad_attr_group, 615 NULL, 616 }; 617 618 #ifdef CONFIG_RTC_CLASS 619 /* RTC class device interface */ 620 621 static void acpi_tad_rt_to_tm(struct acpi_tad_rt *rt, struct rtc_time *tm) 622 { 623 tm->tm_year = rt->year - 1900; 624 tm->tm_mon = rt->month - 1; 625 tm->tm_mday = rt->day; 626 tm->tm_hour = rt->hour; 627 tm->tm_min = rt->minute; 628 tm->tm_sec = rt->second; 629 tm->tm_isdst = rt->daylight == ACPI_TAD_TIME_ISDST; 630 } 631 632 static int acpi_tad_rtc_set_time(struct device *dev, struct rtc_time *tm) 633 { 634 struct acpi_tad_rt rt; 635 636 rt.year = tm->tm_year + 1900; 637 rt.month = tm->tm_mon + 1; 638 rt.day = tm->tm_mday; 639 rt.hour = tm->tm_hour; 640 rt.minute = tm->tm_min; 641 rt.second = tm->tm_sec; 642 rt.tz = ACPI_TAD_TZ_UNSPEC; 643 rt.daylight = ACPI_TAD_TIME_ISDST * !!tm->tm_isdst; 644 645 return acpi_tad_set_real_time(dev, &rt); 646 } 647 648 static int acpi_tad_rtc_read_time(struct device *dev, struct rtc_time *tm) 649 { 650 struct acpi_tad_rt rt; 651 int ret; 652 653 ret = acpi_tad_get_real_time(dev, &rt); 654 if (ret) 655 return ret; 656 657 acpi_tad_rt_to_tm(&rt, tm); 658 659 return 0; 660 } 661 662 static int acpi_tad_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *t) 663 { 664 struct acpi_tad_driver_data *dd = dev_get_drvdata(dev); 665 s64 value = ACPI_TAD_WAKE_DISABLED; 666 struct rtc_time tm_now; 667 struct acpi_tad_rt rt; 668 int ret; 669 670 PM_RUNTIME_ACQUIRE(dev, pm); 671 if (PM_RUNTIME_ACQUIRE_ERR(&pm)) 672 return -ENXIO; 673 674 if (t->enabled) { 675 /* 676 * The value to pass to _STV is expected to be the number of 677 * seconds between the time when the timer is programmed and the 678 * time when it expires represented as a 32-bit integer. 679 */ 680 ret = __acpi_tad_get_real_time(dev, &rt); 681 if (ret) 682 return ret; 683 684 acpi_tad_rt_to_tm(&rt, &tm_now); 685 686 value = ktime_divns(ktime_sub(rtc_tm_to_ktime(t->time), 687 rtc_tm_to_ktime(tm_now)), NSEC_PER_SEC); 688 if (value <= 0 || value > U32_MAX) 689 return -EINVAL; 690 } 691 692 ret = __acpi_tad_wake_set(dev, "_STV", ACPI_TAD_AC_TIMER, value); 693 if (ret && t->enabled) 694 return ret; 695 696 /* 697 * If a separate DC alarm timer is supported, set it to the same value 698 * as the AC alarm timer. 699 */ 700 if (dd->capabilities & ACPI_TAD_DC_WAKE) { 701 ret = __acpi_tad_wake_set(dev, "_STV", ACPI_TAD_DC_TIMER, value); 702 if (ret && t->enabled) { 703 __acpi_tad_wake_set(dev, "_STV", ACPI_TAD_AC_TIMER, 704 ACPI_TAD_WAKE_DISABLED); 705 return ret; 706 } 707 } 708 709 /* Assume success if the alarm is being disabled. */ 710 return 0; 711 } 712 713 static int acpi_tad_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *t) 714 { 715 unsigned long long retval; 716 struct rtc_time tm_now; 717 struct acpi_tad_rt rt; 718 int ret; 719 720 PM_RUNTIME_ACQUIRE(dev, pm); 721 if (PM_RUNTIME_ACQUIRE_ERR(&pm)) 722 return -ENXIO; 723 724 ret = __acpi_tad_get_real_time(dev, &rt); 725 if (ret) 726 return ret; 727 728 acpi_tad_rt_to_tm(&rt, &tm_now); 729 730 /* 731 * Assume that the alarm was set by acpi_tad_rtc_set_alarm(), so the AC 732 * and DC alarm timer settings are the same and it is sufficient to read 733 * the former. 734 * 735 * The value returned by _TIV should be the number of seconds till the 736 * expiration of the timer, represented as a 32-bit integer, or the 737 * special ACPI_TAD_WAKE_DISABLED value meaning that the timer has 738 * been disabled. 739 */ 740 ret = __acpi_tad_wake_read(dev, "_TIV", ACPI_TAD_AC_TIMER, &retval); 741 if (ret) 742 return ret; 743 744 if (retval > U32_MAX) 745 return -ENODATA; 746 747 t->pending = 0; 748 749 if (retval != ACPI_TAD_WAKE_DISABLED) { 750 t->enabled = 1; 751 t->time = rtc_ktime_to_tm(ktime_add_ns(rtc_tm_to_ktime(tm_now), 752 (u64)retval * NSEC_PER_SEC)); 753 } else { 754 t->enabled = 0; 755 t->time = tm_now; 756 } 757 758 return 0; 759 } 760 761 static const struct rtc_class_ops acpi_tad_rtc_ops = { 762 .read_time = acpi_tad_rtc_read_time, 763 .set_time = acpi_tad_rtc_set_time, 764 .set_alarm = acpi_tad_rtc_set_alarm, 765 .read_alarm = acpi_tad_rtc_read_alarm, 766 }; 767 768 static void acpi_tad_register_rtc(struct device *dev, unsigned long long caps) 769 { 770 struct rtc_device *rtc; 771 772 rtc = devm_rtc_allocate_device(dev); 773 if (IS_ERR(rtc)) 774 return; 775 776 rtc->range_min = mktime64(1900, 1, 1, 0, 0, 0); 777 rtc->range_max = mktime64(9999, 12, 31, 23, 59, 59); 778 779 rtc->ops = &acpi_tad_rtc_ops; 780 781 if (!(caps & ACPI_TAD_AC_WAKE)) 782 clear_bit(RTC_FEATURE_ALARM, rtc->features); 783 784 devm_rtc_register_device(rtc); 785 } 786 #else /* !CONFIG_RTC_CLASS */ 787 static inline void acpi_tad_register_rtc(struct device *dev, 788 unsigned long long caps) {} 789 #endif /* !CONFIG_RTC_CLASS */ 790 791 /* Platform driver interface */ 792 793 static int acpi_tad_disable_timer(struct device *dev, u32 timer_id) 794 { 795 return acpi_tad_wake_set(dev, "_STV", timer_id, ACPI_TAD_WAKE_DISABLED); 796 } 797 798 static void acpi_tad_remove(struct platform_device *pdev) 799 { 800 struct device *dev = &pdev->dev; 801 struct acpi_tad_driver_data *dd = dev_get_drvdata(dev); 802 803 device_init_wakeup(dev, false); 804 805 scoped_guard(pm_runtime_noresume, dev) { 806 if (dd->capabilities & ACPI_TAD_AC_WAKE) { 807 acpi_tad_disable_timer(dev, ACPI_TAD_AC_TIMER); 808 acpi_tad_clear_status(dev, ACPI_TAD_AC_TIMER); 809 } 810 if (dd->capabilities & ACPI_TAD_DC_WAKE) { 811 acpi_tad_disable_timer(dev, ACPI_TAD_DC_TIMER); 812 acpi_tad_clear_status(dev, ACPI_TAD_DC_TIMER); 813 } 814 } 815 816 pm_runtime_suspend(dev); 817 pm_runtime_disable(dev); 818 } 819 820 static int acpi_tad_probe(struct platform_device *pdev) 821 { 822 struct device *dev = &pdev->dev; 823 acpi_handle handle = ACPI_HANDLE(dev); 824 struct acpi_tad_driver_data *dd; 825 acpi_status status; 826 unsigned long long caps; 827 828 /* 829 * Initialization failure messages are mostly about firmware issues, so 830 * print them at the "info" level. 831 */ 832 status = acpi_evaluate_integer(handle, "_GCP", NULL, &caps); 833 if (ACPI_FAILURE(status)) { 834 dev_info(dev, "Unable to get capabilities\n"); 835 return -ENODEV; 836 } 837 838 if (!acpi_has_method(handle, "_PRW")) { 839 dev_info(dev, "Missing _PRW\n"); 840 caps &= ~(ACPI_TAD_AC_WAKE | ACPI_TAD_DC_WAKE); 841 } 842 843 if (!(caps & ACPI_TAD_AC_WAKE)) 844 caps &= ~ACPI_TAD_DC_WAKE; 845 846 dd = devm_kzalloc(dev, sizeof(*dd), GFP_KERNEL); 847 if (!dd) 848 return -ENOMEM; 849 850 dd->capabilities = caps; 851 dev_set_drvdata(dev, dd); 852 853 /* 854 * Assume that the ACPI PM domain has been attached to the device and 855 * simply enable system wakeup and runtime PM and put the device into 856 * runtime suspend. Everything else should be taken care of by the ACPI 857 * PM domain callbacks. 858 */ 859 if (ACPI_TAD_AC_WAKE) { 860 device_init_wakeup(dev, true); 861 dev_pm_set_driver_flags(dev, DPM_FLAG_SMART_SUSPEND | 862 DPM_FLAG_MAY_SKIP_RESUME); 863 } 864 865 /* 866 * The platform bus type layer tells the ACPI PM domain powers up the 867 * device, so set the runtime PM status of it to "active". 868 */ 869 pm_runtime_set_active(dev); 870 pm_runtime_enable(dev); 871 pm_runtime_suspend(dev); 872 873 if (caps & ACPI_TAD_RT) 874 acpi_tad_register_rtc(dev, caps); 875 876 return 0; 877 } 878 879 static const struct acpi_device_id acpi_tad_ids[] = { 880 {"ACPI000E", 0}, 881 {} 882 }; 883 884 static struct platform_driver acpi_tad_driver = { 885 .driver = { 886 .name = "acpi-tad", 887 .acpi_match_table = acpi_tad_ids, 888 .dev_groups = acpi_tad_attr_groups, 889 }, 890 .probe = acpi_tad_probe, 891 .remove = acpi_tad_remove, 892 }; 893 MODULE_DEVICE_TABLE(acpi, acpi_tad_ids); 894 895 module_platform_driver(acpi_tad_driver); 896