acpi_tad.c 15 KB

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