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
acpi_tad_set_real_time(struct device * dev,struct acpi_tad_rt * rt)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
acpi_tad_get_real_time(struct device * dev,struct acpi_tad_rt * rt)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
acpi_tad_rt_next_field(char * s,int * val)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
time_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
time_show(struct device * dev,struct device_attribute * attr,char * buf)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
acpi_tad_wake_set(struct device * dev,char * method,u32 timer_id,u32 value)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
acpi_tad_wake_write(struct device * dev,const char * buf,char * method,u32 timer_id,const char * specval)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
acpi_tad_wake_read(struct device * dev,char * buf,char * method,u32 timer_id,const char * specval)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
acpi_tad_alarm_write(struct device * dev,const char * buf,u32 timer_id)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
acpi_tad_alarm_read(struct device * dev,char * buf,u32 timer_id)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
acpi_tad_policy_write(struct device * dev,const char * buf,u32 timer_id)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
acpi_tad_policy_read(struct device * dev,char * buf,u32 timer_id)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
acpi_tad_clear_status(struct device * dev,u32 timer_id)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
acpi_tad_status_write(struct device * dev,const char * buf,u32 timer_id)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
acpi_tad_status_read(struct device * dev,char * buf,u32 timer_id)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
caps_show(struct device * dev,struct device_attribute * attr,char * buf)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
ac_alarm_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
ac_alarm_show(struct device * dev,struct device_attribute * attr,char * buf)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
ac_policy_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
ac_policy_show(struct device * dev,struct device_attribute * attr,char * buf)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
ac_status_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
ac_status_show(struct device * dev,struct device_attribute * attr,char * buf)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
dc_alarm_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
dc_alarm_show(struct device * dev,struct device_attribute * attr,char * buf)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
dc_policy_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
dc_policy_show(struct device * dev,struct device_attribute * attr,char * buf)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
dc_status_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
dc_status_show(struct device * dev,struct device_attribute * attr,char * buf)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
acpi_tad_disable_timer(struct device * dev,u32 timer_id)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
acpi_tad_remove(struct platform_device * pdev)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
acpi_tad_probe(struct platform_device * pdev)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