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 static int acpi_tad_wake_set(struct device *dev, char *method, u32 timer_id, 56 u32 value) 57 { 58 acpi_handle handle = ACPI_HANDLE(dev); 59 union acpi_object args[] = { 60 { .type = ACPI_TYPE_INTEGER, }, 61 { .type = ACPI_TYPE_INTEGER, }, 62 }; 63 struct acpi_object_list arg_list = { 64 .pointer = args, 65 .count = ARRAY_SIZE(args), 66 }; 67 unsigned long long retval; 68 acpi_status status; 69 70 args[0].integer.value = timer_id; 71 args[1].integer.value = value; 72 73 pm_runtime_get_sync(dev); 74 75 status = acpi_evaluate_integer(handle, method, &arg_list, &retval); 76 77 pm_runtime_put_sync(dev); 78 79 if (ACPI_FAILURE(status) || retval) 80 return -EIO; 81 82 return 0; 83 } 84 85 static int acpi_tad_wake_write(struct device *dev, const char *buf, char *method, 86 u32 timer_id, const char *specval) 87 { 88 u32 value; 89 90 if (sysfs_streq(buf, specval)) { 91 value = ACPI_TAD_WAKE_DISABLED; 92 } else { 93 int ret = kstrtou32(buf, 0, &value); 94 95 if (ret) 96 return ret; 97 98 if (value == ACPI_TAD_WAKE_DISABLED) 99 return -EINVAL; 100 } 101 102 return acpi_tad_wake_set(dev, method, timer_id, value); 103 } 104 105 static ssize_t acpi_tad_wake_read(struct device *dev, char *buf, char *method, 106 u32 timer_id, const char *specval) 107 { 108 acpi_handle handle = ACPI_HANDLE(dev); 109 union acpi_object args[] = { 110 { .type = ACPI_TYPE_INTEGER, }, 111 }; 112 struct acpi_object_list arg_list = { 113 .pointer = args, 114 .count = ARRAY_SIZE(args), 115 }; 116 unsigned long long retval; 117 acpi_status status; 118 119 args[0].integer.value = timer_id; 120 121 pm_runtime_get_sync(dev); 122 123 status = acpi_evaluate_integer(handle, method, &arg_list, &retval); 124 125 pm_runtime_put_sync(dev); 126 127 if (ACPI_FAILURE(status)) 128 return -EIO; 129 130 if ((u32)retval == ACPI_TAD_WAKE_DISABLED) 131 return sprintf(buf, "%s\n", specval); 132 133 return sprintf(buf, "%u\n", (u32)retval); 134 } 135 136 static const char *alarm_specval = "disabled"; 137 138 static int acpi_tad_alarm_write(struct device *dev, const char *buf, 139 u32 timer_id) 140 { 141 return acpi_tad_wake_write(dev, buf, "_STV", timer_id, alarm_specval); 142 } 143 144 static ssize_t acpi_tad_alarm_read(struct device *dev, char *buf, u32 timer_id) 145 { 146 return acpi_tad_wake_read(dev, buf, "_TIV", timer_id, alarm_specval); 147 } 148 149 static const char *policy_specval = "never"; 150 151 static int acpi_tad_policy_write(struct device *dev, const char *buf, 152 u32 timer_id) 153 { 154 return acpi_tad_wake_write(dev, buf, "_STP", timer_id, policy_specval); 155 } 156 157 static ssize_t acpi_tad_policy_read(struct device *dev, char *buf, u32 timer_id) 158 { 159 return acpi_tad_wake_read(dev, buf, "_TIP", timer_id, policy_specval); 160 } 161 162 static int acpi_tad_clear_status(struct device *dev, u32 timer_id) 163 { 164 acpi_handle handle = ACPI_HANDLE(dev); 165 union acpi_object args[] = { 166 { .type = ACPI_TYPE_INTEGER, }, 167 }; 168 struct acpi_object_list arg_list = { 169 .pointer = args, 170 .count = ARRAY_SIZE(args), 171 }; 172 unsigned long long retval; 173 acpi_status status; 174 175 args[0].integer.value = timer_id; 176 177 pm_runtime_get_sync(dev); 178 179 status = acpi_evaluate_integer(handle, "_CWS", &arg_list, &retval); 180 181 pm_runtime_put_sync(dev); 182 183 if (ACPI_FAILURE(status) || retval) 184 return -EIO; 185 186 return 0; 187 } 188 189 static int acpi_tad_status_write(struct device *dev, const char *buf, u32 timer_id) 190 { 191 int ret, value; 192 193 ret = kstrtoint(buf, 0, &value); 194 if (ret) 195 return ret; 196 197 if (value) 198 return -EINVAL; 199 200 return acpi_tad_clear_status(dev, timer_id); 201 } 202 203 static ssize_t acpi_tad_status_read(struct device *dev, char *buf, u32 timer_id) 204 { 205 acpi_handle handle = ACPI_HANDLE(dev); 206 union acpi_object args[] = { 207 { .type = ACPI_TYPE_INTEGER, }, 208 }; 209 struct acpi_object_list arg_list = { 210 .pointer = args, 211 .count = ARRAY_SIZE(args), 212 }; 213 unsigned long long retval; 214 acpi_status status; 215 216 args[0].integer.value = timer_id; 217 218 pm_runtime_get_sync(dev); 219 220 status = acpi_evaluate_integer(handle, "_GWS", &arg_list, &retval); 221 222 pm_runtime_put_sync(dev); 223 224 if (ACPI_FAILURE(status)) 225 return -EIO; 226 227 return sprintf(buf, "0x%02X\n", (u32)retval); 228 } 229 230 static ssize_t caps_show(struct device *dev, struct device_attribute *attr, 231 char *buf) 232 { 233 struct acpi_tad_driver_data *dd = dev_get_drvdata(dev); 234 235 return sprintf(buf, "0x%02X\n", dd->capabilities); 236 } 237 238 static DEVICE_ATTR_RO(caps); 239 240 static ssize_t ac_alarm_store(struct device *dev, struct device_attribute *attr, 241 const char *buf, size_t count) 242 { 243 int ret = acpi_tad_alarm_write(dev, buf, ACPI_TAD_AC_TIMER); 244 245 return ret ? ret : count; 246 } 247 248 static ssize_t ac_alarm_show(struct device *dev, struct device_attribute *attr, 249 char *buf) 250 { 251 return acpi_tad_alarm_read(dev, buf, ACPI_TAD_AC_TIMER); 252 } 253 254 static DEVICE_ATTR(ac_alarm, S_IRUSR | S_IWUSR, ac_alarm_show, ac_alarm_store); 255 256 static ssize_t ac_policy_store(struct device *dev, struct device_attribute *attr, 257 const char *buf, size_t count) 258 { 259 int ret = acpi_tad_policy_write(dev, buf, ACPI_TAD_AC_TIMER); 260 261 return ret ? ret : count; 262 } 263 264 static ssize_t ac_policy_show(struct device *dev, struct device_attribute *attr, 265 char *buf) 266 { 267 return acpi_tad_policy_read(dev, buf, ACPI_TAD_AC_TIMER); 268 } 269 270 static DEVICE_ATTR(ac_policy, S_IRUSR | S_IWUSR, ac_policy_show, ac_policy_store); 271 272 static ssize_t ac_status_store(struct device *dev, struct device_attribute *attr, 273 const char *buf, size_t count) 274 { 275 int ret = acpi_tad_status_write(dev, buf, ACPI_TAD_AC_TIMER); 276 277 return ret ? ret : count; 278 } 279 280 static ssize_t ac_status_show(struct device *dev, struct device_attribute *attr, 281 char *buf) 282 { 283 return acpi_tad_status_read(dev, buf, ACPI_TAD_AC_TIMER); 284 } 285 286 static DEVICE_ATTR(ac_status, S_IRUSR | S_IWUSR, ac_status_show, ac_status_store); 287 288 static struct attribute *acpi_tad_attrs[] = { 289 &dev_attr_caps.attr, 290 &dev_attr_ac_alarm.attr, 291 &dev_attr_ac_policy.attr, 292 &dev_attr_ac_status.attr, 293 NULL, 294 }; 295 static const struct attribute_group acpi_tad_attr_group = { 296 .attrs = acpi_tad_attrs, 297 }; 298 299 static ssize_t dc_alarm_store(struct device *dev, struct device_attribute *attr, 300 const char *buf, size_t count) 301 { 302 int ret = acpi_tad_alarm_write(dev, buf, ACPI_TAD_DC_TIMER); 303 304 return ret ? ret : count; 305 } 306 307 static ssize_t dc_alarm_show(struct device *dev, struct device_attribute *attr, 308 char *buf) 309 { 310 return acpi_tad_alarm_read(dev, buf, ACPI_TAD_DC_TIMER); 311 } 312 313 static DEVICE_ATTR(dc_alarm, S_IRUSR | S_IWUSR, dc_alarm_show, dc_alarm_store); 314 315 static ssize_t dc_policy_store(struct device *dev, struct device_attribute *attr, 316 const char *buf, size_t count) 317 { 318 int ret = acpi_tad_policy_write(dev, buf, ACPI_TAD_DC_TIMER); 319 320 return ret ? ret : count; 321 } 322 323 static ssize_t dc_policy_show(struct device *dev, struct device_attribute *attr, 324 char *buf) 325 { 326 return acpi_tad_policy_read(dev, buf, ACPI_TAD_DC_TIMER); 327 } 328 329 static DEVICE_ATTR(dc_policy, S_IRUSR | S_IWUSR, dc_policy_show, dc_policy_store); 330 331 static ssize_t dc_status_store(struct device *dev, struct device_attribute *attr, 332 const char *buf, size_t count) 333 { 334 int ret = acpi_tad_status_write(dev, buf, ACPI_TAD_DC_TIMER); 335 336 return ret ? ret : count; 337 } 338 339 static ssize_t dc_status_show(struct device *dev, struct device_attribute *attr, 340 char *buf) 341 { 342 return acpi_tad_status_read(dev, buf, ACPI_TAD_DC_TIMER); 343 } 344 345 static DEVICE_ATTR(dc_status, S_IRUSR | S_IWUSR, dc_status_show, dc_status_store); 346 347 static struct attribute *acpi_tad_dc_attrs[] = { 348 &dev_attr_dc_alarm.attr, 349 &dev_attr_dc_policy.attr, 350 &dev_attr_dc_status.attr, 351 NULL, 352 }; 353 static const struct attribute_group acpi_tad_dc_attr_group = { 354 .attrs = acpi_tad_dc_attrs, 355 }; 356 357 static int acpi_tad_disable_timer(struct device *dev, u32 timer_id) 358 { 359 return acpi_tad_wake_set(dev, "_STV", timer_id, ACPI_TAD_WAKE_DISABLED); 360 } 361 362 static int acpi_tad_remove(struct platform_device *pdev) 363 { 364 struct device *dev = &pdev->dev; 365 struct acpi_tad_driver_data *dd = dev_get_drvdata(dev); 366 367 device_init_wakeup(dev, false); 368 369 pm_runtime_get_sync(dev); 370 371 if (dd->capabilities & ACPI_TAD_DC_WAKE) 372 sysfs_remove_group(&dev->kobj, &acpi_tad_dc_attr_group); 373 374 sysfs_remove_group(&dev->kobj, &acpi_tad_attr_group); 375 376 acpi_tad_disable_timer(dev, ACPI_TAD_AC_TIMER); 377 acpi_tad_clear_status(dev, ACPI_TAD_AC_TIMER); 378 if (dd->capabilities & ACPI_TAD_DC_WAKE) { 379 acpi_tad_disable_timer(dev, ACPI_TAD_DC_TIMER); 380 acpi_tad_clear_status(dev, ACPI_TAD_DC_TIMER); 381 } 382 383 pm_runtime_put_sync(dev); 384 pm_runtime_disable(dev); 385 return 0; 386 } 387 388 static int acpi_tad_probe(struct platform_device *pdev) 389 { 390 struct device *dev = &pdev->dev; 391 acpi_handle handle = ACPI_HANDLE(dev); 392 struct acpi_tad_driver_data *dd; 393 acpi_status status; 394 unsigned long long caps; 395 int ret; 396 397 /* 398 * Initialization failure messages are mostly about firmware issues, so 399 * print them at the "info" level. 400 */ 401 status = acpi_evaluate_integer(handle, "_GCP", NULL, &caps); 402 if (ACPI_FAILURE(status)) { 403 dev_info(dev, "Unable to get capabilities\n"); 404 return -ENODEV; 405 } 406 407 if (!(caps & ACPI_TAD_AC_WAKE)) { 408 dev_info(dev, "Unsupported capabilities\n"); 409 return -ENODEV; 410 } 411 412 if (!acpi_has_method(handle, "_PRW")) { 413 dev_info(dev, "Missing _PRW\n"); 414 return -ENODEV; 415 } 416 417 dd = devm_kzalloc(dev, sizeof(*dd), GFP_KERNEL); 418 if (!dd) 419 return -ENOMEM; 420 421 dd->capabilities = caps; 422 dev_set_drvdata(dev, dd); 423 424 /* 425 * Assume that the ACPI PM domain has been attached to the device and 426 * simply enable system wakeup and runtime PM and put the device into 427 * runtime suspend. Everything else should be taken care of by the ACPI 428 * PM domain callbacks. 429 */ 430 device_init_wakeup(dev, true); 431 dev_pm_set_driver_flags(dev, DPM_FLAG_SMART_SUSPEND | 432 DPM_FLAG_LEAVE_SUSPENDED); 433 /* 434 * The platform bus type layer tells the ACPI PM domain powers up the 435 * device, so set the runtime PM status of it to "active". 436 */ 437 pm_runtime_set_active(dev); 438 pm_runtime_enable(dev); 439 pm_runtime_suspend(dev); 440 441 ret = sysfs_create_group(&dev->kobj, &acpi_tad_attr_group); 442 if (ret) 443 goto fail; 444 445 if (caps & ACPI_TAD_DC_WAKE) { 446 ret = sysfs_create_group(&dev->kobj, &acpi_tad_dc_attr_group); 447 if (ret) 448 goto fail; 449 } 450 451 return 0; 452 453 fail: 454 acpi_tad_remove(pdev); 455 return ret; 456 } 457 458 static const struct acpi_device_id acpi_tad_ids[] = { 459 {"ACPI000E", 0}, 460 {} 461 }; 462 463 static struct platform_driver acpi_tad_driver = { 464 .driver = { 465 .name = "acpi-tad", 466 .acpi_match_table = acpi_tad_ids, 467 }, 468 .probe = acpi_tad_probe, 469 .remove = acpi_tad_remove, 470 }; 471 MODULE_DEVICE_TABLE(acpi, acpi_tad_ids); 472 473 module_platform_driver(acpi_tad_driver); 474