xref: /openbmc/linux/drivers/acpi/acpi_tad.c (revision 596ca52a)
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