2 * RTC subsystem, base class
4 * Copyright (C) 2005 Tower Technologies
5 * Author: Alessandro Zummo <a.zummo@towertech.it>
7 * class skeleton from drivers/hwmon/hwmon.c
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 #include <linux/module.h>
18 #include <linux/rtc.h>
19 #include <linux/kdev_t.h>
20 #include <linux/idr.h>
21 #include <linux/slab.h>
22 #include <linux/workqueue.h>
27 static DEFINE_IDA(rtc_ida
);
28 struct class *rtc_class
;
30 static void rtc_device_release(struct device
*dev
)
32 struct rtc_device
*rtc
= to_rtc_device(dev
);
33 ida_simple_remove(&rtc_ida
, rtc
->id
);
37 #ifdef CONFIG_RTC_HCTOSYS_DEVICE
38 /* Result of the last RTC to system clock attempt. */
39 int rtc_hctosys_ret
= -ENODEV
;
42 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_RTC_HCTOSYS_DEVICE)
44 * On suspend(), measure the delta between one RTC and the
45 * system's wall clock; restore it on resume().
48 static struct timespec64 old_rtc
, old_system
, old_delta
;
51 static int rtc_suspend(struct device
*dev
)
53 struct rtc_device
*rtc
= to_rtc_device(dev
);
55 struct timespec64 delta
, delta_delta
;
58 if (has_persistent_clock())
61 if (strcmp(dev_name(&rtc
->dev
), CONFIG_RTC_HCTOSYS_DEVICE
) != 0)
64 /* snapshot the current RTC and system time at suspend*/
65 err
= rtc_read_time(rtc
, &tm
);
67 pr_debug("%s: fail to read rtc time\n", dev_name(&rtc
->dev
));
71 getnstimeofday64(&old_system
);
72 old_rtc
.tv_sec
= rtc_tm_to_time64(&tm
);
76 * To avoid drift caused by repeated suspend/resumes,
77 * which each can add ~1 second drift error,
78 * try to compensate so the difference in system time
79 * and rtc time stays close to constant.
81 delta
= timespec64_sub(old_system
, old_rtc
);
82 delta_delta
= timespec64_sub(delta
, old_delta
);
83 if (delta_delta
.tv_sec
< -2 || delta_delta
.tv_sec
>= 2) {
85 * if delta_delta is too large, assume time correction
86 * has occured and set old_delta to the current delta.
90 /* Otherwise try to adjust old_system to compensate */
91 old_system
= timespec64_sub(old_system
, delta_delta
);
97 static int rtc_resume(struct device
*dev
)
99 struct rtc_device
*rtc
= to_rtc_device(dev
);
101 struct timespec64 new_system
, new_rtc
;
102 struct timespec64 sleep_time
;
105 if (has_persistent_clock())
108 rtc_hctosys_ret
= -ENODEV
;
109 if (strcmp(dev_name(&rtc
->dev
), CONFIG_RTC_HCTOSYS_DEVICE
) != 0)
112 /* snapshot the current rtc and system time at resume */
113 getnstimeofday64(&new_system
);
114 err
= rtc_read_time(rtc
, &tm
);
116 pr_debug("%s: fail to read rtc time\n", dev_name(&rtc
->dev
));
120 if (rtc_valid_tm(&tm
) != 0) {
121 pr_debug("%s: bogus resume time\n", dev_name(&rtc
->dev
));
124 new_rtc
.tv_sec
= rtc_tm_to_time64(&tm
);
127 if (new_rtc
.tv_sec
< old_rtc
.tv_sec
) {
128 pr_debug("%s: time travel!\n", dev_name(&rtc
->dev
));
132 /* calculate the RTC time delta (sleep time)*/
133 sleep_time
= timespec64_sub(new_rtc
, old_rtc
);
136 * Since these RTC suspend/resume handlers are not called
137 * at the very end of suspend or the start of resume,
138 * some run-time may pass on either sides of the sleep time
139 * so subtract kernel run-time between rtc_suspend to rtc_resume
140 * to keep things accurate.
142 sleep_time
= timespec64_sub(sleep_time
,
143 timespec64_sub(new_system
, old_system
));
145 if (sleep_time
.tv_sec
>= 0)
146 timekeeping_inject_sleeptime64(&sleep_time
);
151 static SIMPLE_DEV_PM_OPS(rtc_class_dev_pm_ops
, rtc_suspend
, rtc_resume
);
152 #define RTC_CLASS_DEV_PM_OPS (&rtc_class_dev_pm_ops)
154 #define RTC_CLASS_DEV_PM_OPS NULL
159 * rtc_device_register - register w/ RTC class
160 * @dev: the device to register
162 * rtc_device_unregister() must be called when the class device is no
165 * Returns the pointer to the new struct class device.
167 struct rtc_device
*rtc_device_register(const char *name
, struct device
*dev
,
168 const struct rtc_class_ops
*ops
,
169 struct module
*owner
)
171 struct rtc_device
*rtc
;
172 struct rtc_wkalrm alrm
;
173 int of_id
= -1, id
= -1, err
;
176 of_id
= of_alias_get_id(dev
->of_node
, "rtc");
177 else if (dev
->parent
&& dev
->parent
->of_node
)
178 of_id
= of_alias_get_id(dev
->parent
->of_node
, "rtc");
181 id
= ida_simple_get(&rtc_ida
, of_id
, of_id
+ 1,
184 dev_warn(dev
, "/aliases ID %d not available\n",
189 id
= ida_simple_get(&rtc_ida
, 0, 0, GFP_KERNEL
);
196 rtc
= kzalloc(sizeof(struct rtc_device
), GFP_KERNEL
);
206 rtc
->max_user_freq
= 64;
207 rtc
->dev
.parent
= dev
;
208 rtc
->dev
.class = rtc_class
;
209 rtc
->dev
.release
= rtc_device_release
;
211 mutex_init(&rtc
->ops_lock
);
212 spin_lock_init(&rtc
->irq_lock
);
213 spin_lock_init(&rtc
->irq_task_lock
);
214 init_waitqueue_head(&rtc
->irq_queue
);
216 /* Init timerqueue */
217 timerqueue_init_head(&rtc
->timerqueue
);
218 INIT_WORK(&rtc
->irqwork
, rtc_timer_do_work
);
220 rtc_timer_init(&rtc
->aie_timer
, rtc_aie_update_irq
, (void *)rtc
);
222 rtc_timer_init(&rtc
->uie_rtctimer
, rtc_uie_update_irq
, (void *)rtc
);
224 hrtimer_init(&rtc
->pie_timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
225 rtc
->pie_timer
.function
= rtc_pie_update_irq
;
226 rtc
->pie_enabled
= 0;
228 /* Check to see if there is an ALARM already set in hw */
229 err
= __rtc_read_alarm(rtc
, &alrm
);
231 if (!err
&& !rtc_valid_tm(&alrm
.time
))
232 rtc_initialize_alarm(rtc
, &alrm
);
234 strlcpy(rtc
->name
, name
, RTC_DEVICE_NAME_SIZE
);
235 dev_set_name(&rtc
->dev
, "rtc%d", id
);
237 rtc_dev_prepare(rtc
);
239 err
= device_register(&rtc
->dev
);
241 put_device(&rtc
->dev
);
245 rtc_dev_add_device(rtc
);
246 rtc_sysfs_add_device(rtc
);
247 rtc_proc_add_device(rtc
);
249 dev_info(dev
, "rtc core: registered %s as %s\n",
250 rtc
->name
, dev_name(&rtc
->dev
));
258 ida_simple_remove(&rtc_ida
, id
);
261 dev_err(dev
, "rtc core: unable to register %s, err = %d\n",
265 EXPORT_SYMBOL_GPL(rtc_device_register
);
269 * rtc_device_unregister - removes the previously registered RTC class device
271 * @rtc: the RTC class device to destroy
273 void rtc_device_unregister(struct rtc_device
*rtc
)
275 if (get_device(&rtc
->dev
) != NULL
) {
276 mutex_lock(&rtc
->ops_lock
);
277 /* remove innards of this RTC, then disable it, before
278 * letting any rtc_class_open() users access it again
280 rtc_sysfs_del_device(rtc
);
281 rtc_dev_del_device(rtc
);
282 rtc_proc_del_device(rtc
);
283 device_unregister(&rtc
->dev
);
285 mutex_unlock(&rtc
->ops_lock
);
286 put_device(&rtc
->dev
);
289 EXPORT_SYMBOL_GPL(rtc_device_unregister
);
291 static void devm_rtc_device_release(struct device
*dev
, void *res
)
293 struct rtc_device
*rtc
= *(struct rtc_device
**)res
;
295 rtc_device_unregister(rtc
);
298 static int devm_rtc_device_match(struct device
*dev
, void *res
, void *data
)
300 struct rtc
**r
= res
;
306 * devm_rtc_device_register - resource managed rtc_device_register()
307 * @dev: the device to register
308 * @name: the name of the device
309 * @ops: the rtc operations structure
310 * @owner: the module owner
312 * @return a struct rtc on success, or an ERR_PTR on error
314 * Managed rtc_device_register(). The rtc_device returned from this function
315 * are automatically freed on driver detach. See rtc_device_register()
316 * for more information.
319 struct rtc_device
*devm_rtc_device_register(struct device
*dev
,
321 const struct rtc_class_ops
*ops
,
322 struct module
*owner
)
324 struct rtc_device
**ptr
, *rtc
;
326 ptr
= devres_alloc(devm_rtc_device_release
, sizeof(*ptr
), GFP_KERNEL
);
328 return ERR_PTR(-ENOMEM
);
330 rtc
= rtc_device_register(name
, dev
, ops
, owner
);
333 devres_add(dev
, ptr
);
340 EXPORT_SYMBOL_GPL(devm_rtc_device_register
);
343 * devm_rtc_device_unregister - resource managed devm_rtc_device_unregister()
344 * @dev: the device to unregister
345 * @rtc: the RTC class device to unregister
347 * Deallocated a rtc allocated with devm_rtc_device_register(). Normally this
348 * function will not need to be called and the resource management code will
349 * ensure that the resource is freed.
351 void devm_rtc_device_unregister(struct device
*dev
, struct rtc_device
*rtc
)
355 rc
= devres_release(dev
, devm_rtc_device_release
,
356 devm_rtc_device_match
, rtc
);
359 EXPORT_SYMBOL_GPL(devm_rtc_device_unregister
);
361 static int __init
rtc_init(void)
363 rtc_class
= class_create(THIS_MODULE
, "rtc");
364 if (IS_ERR(rtc_class
)) {
365 pr_err("couldn't create class\n");
366 return PTR_ERR(rtc_class
);
368 rtc_class
->pm
= RTC_CLASS_DEV_PM_OPS
;
370 rtc_sysfs_init(rtc_class
);
374 static void __exit
rtc_exit(void)
377 class_destroy(rtc_class
);
378 ida_destroy(&rtc_ida
);
381 subsys_initcall(rtc_init
);
382 module_exit(rtc_exit
);
384 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
385 MODULE_DESCRIPTION("RTC class support");
386 MODULE_LICENSE("GPL");