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