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 (timekeeping_rtc_skipsuspend())
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 (timekeeping_rtc_skipresume())
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 new_rtc
.tv_sec
= rtc_tm_to_time64(&tm
);
123 if (new_rtc
.tv_sec
< old_rtc
.tv_sec
) {
124 pr_debug("%s: time travel!\n", dev_name(&rtc
->dev
));
128 /* calculate the RTC time delta (sleep time)*/
129 sleep_time
= timespec64_sub(new_rtc
, old_rtc
);
132 * Since these RTC suspend/resume handlers are not called
133 * at the very end of suspend or the start of resume,
134 * some run-time may pass on either sides of the sleep time
135 * so subtract kernel run-time between rtc_suspend to rtc_resume
136 * to keep things accurate.
138 sleep_time
= timespec64_sub(sleep_time
,
139 timespec64_sub(new_system
, old_system
));
141 if (sleep_time
.tv_sec
>= 0)
142 timekeeping_inject_sleeptime64(&sleep_time
);
147 static SIMPLE_DEV_PM_OPS(rtc_class_dev_pm_ops
, rtc_suspend
, rtc_resume
);
148 #define RTC_CLASS_DEV_PM_OPS (&rtc_class_dev_pm_ops)
150 #define RTC_CLASS_DEV_PM_OPS NULL
153 /* Ensure the caller will set the id before releasing the device */
154 static struct rtc_device
*rtc_allocate_device(void)
156 struct rtc_device
*rtc
;
158 rtc
= kzalloc(sizeof(*rtc
), GFP_KERNEL
);
162 device_initialize(&rtc
->dev
);
165 rtc
->max_user_freq
= 64;
166 rtc
->dev
.class = rtc_class
;
167 rtc
->dev
.groups
= rtc_get_dev_attribute_groups();
168 rtc
->dev
.release
= rtc_device_release
;
170 mutex_init(&rtc
->ops_lock
);
171 spin_lock_init(&rtc
->irq_lock
);
172 spin_lock_init(&rtc
->irq_task_lock
);
173 init_waitqueue_head(&rtc
->irq_queue
);
175 /* Init timerqueue */
176 timerqueue_init_head(&rtc
->timerqueue
);
177 INIT_WORK(&rtc
->irqwork
, rtc_timer_do_work
);
179 rtc_timer_init(&rtc
->aie_timer
, rtc_aie_update_irq
, (void *)rtc
);
181 rtc_timer_init(&rtc
->uie_rtctimer
, rtc_uie_update_irq
, (void *)rtc
);
183 hrtimer_init(&rtc
->pie_timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
184 rtc
->pie_timer
.function
= rtc_pie_update_irq
;
185 rtc
->pie_enabled
= 0;
190 static int rtc_device_get_id(struct device
*dev
)
192 int of_id
= -1, id
= -1;
195 of_id
= of_alias_get_id(dev
->of_node
, "rtc");
196 else if (dev
->parent
&& dev
->parent
->of_node
)
197 of_id
= of_alias_get_id(dev
->parent
->of_node
, "rtc");
200 id
= ida_simple_get(&rtc_ida
, of_id
, of_id
+ 1, GFP_KERNEL
);
202 dev_warn(dev
, "/aliases ID %d not available\n", of_id
);
206 id
= ida_simple_get(&rtc_ida
, 0, 0, GFP_KERNEL
);
212 * rtc_device_register - register w/ RTC class
213 * @dev: the device to register
215 * rtc_device_unregister() must be called when the class device is no
218 * Returns the pointer to the new struct class device.
220 struct rtc_device
*rtc_device_register(const char *name
, struct device
*dev
,
221 const struct rtc_class_ops
*ops
,
222 struct module
*owner
)
224 struct rtc_device
*rtc
;
225 struct rtc_wkalrm alrm
;
228 id
= rtc_device_get_id(dev
);
234 rtc
= rtc_allocate_device();
243 rtc
->dev
.parent
= dev
;
245 dev_set_name(&rtc
->dev
, "rtc%d", id
);
247 /* Check to see if there is an ALARM already set in hw */
248 err
= __rtc_read_alarm(rtc
, &alrm
);
250 if (!err
&& !rtc_valid_tm(&alrm
.time
))
251 rtc_initialize_alarm(rtc
, &alrm
);
253 rtc_dev_prepare(rtc
);
255 err
= cdev_device_add(&rtc
->char_dev
, &rtc
->dev
);
257 dev_warn(&rtc
->dev
, "%s: failed to add char device %d:%d\n",
258 name
, MAJOR(rtc
->dev
.devt
), rtc
->id
);
260 /* This will free both memory and the ID */
261 put_device(&rtc
->dev
);
264 dev_dbg(&rtc
->dev
, "%s: dev (%d:%d)\n", name
,
265 MAJOR(rtc
->dev
.devt
), rtc
->id
);
268 rtc_proc_add_device(rtc
);
270 dev_info(dev
, "rtc core: registered %s as %s\n",
271 name
, dev_name(&rtc
->dev
));
276 ida_simple_remove(&rtc_ida
, id
);
279 dev_err(dev
, "rtc core: unable to register %s, err = %d\n",
283 EXPORT_SYMBOL_GPL(rtc_device_register
);
287 * rtc_device_unregister - removes the previously registered RTC class device
289 * @rtc: the RTC class device to destroy
291 void rtc_device_unregister(struct rtc_device
*rtc
)
293 rtc_nvmem_unregister(rtc
);
295 mutex_lock(&rtc
->ops_lock
);
297 * Remove innards of this RTC, then disable it, before
298 * letting any rtc_class_open() users access it again
300 rtc_proc_del_device(rtc
);
301 cdev_device_del(&rtc
->char_dev
, &rtc
->dev
);
303 mutex_unlock(&rtc
->ops_lock
);
304 put_device(&rtc
->dev
);
306 EXPORT_SYMBOL_GPL(rtc_device_unregister
);
308 static void devm_rtc_device_release(struct device
*dev
, void *res
)
310 struct rtc_device
*rtc
= *(struct rtc_device
**)res
;
312 rtc_device_unregister(rtc
);
315 static int devm_rtc_device_match(struct device
*dev
, void *res
, void *data
)
317 struct rtc
**r
= res
;
323 * devm_rtc_device_register - resource managed rtc_device_register()
324 * @dev: the device to register
325 * @name: the name of the device
326 * @ops: the rtc operations structure
327 * @owner: the module owner
329 * @return a struct rtc on success, or an ERR_PTR on error
331 * Managed rtc_device_register(). The rtc_device returned from this function
332 * are automatically freed on driver detach. See rtc_device_register()
333 * for more information.
336 struct rtc_device
*devm_rtc_device_register(struct device
*dev
,
338 const struct rtc_class_ops
*ops
,
339 struct module
*owner
)
341 struct rtc_device
**ptr
, *rtc
;
343 ptr
= devres_alloc(devm_rtc_device_release
, sizeof(*ptr
), GFP_KERNEL
);
345 return ERR_PTR(-ENOMEM
);
347 rtc
= rtc_device_register(name
, dev
, ops
, owner
);
350 devres_add(dev
, ptr
);
357 EXPORT_SYMBOL_GPL(devm_rtc_device_register
);
360 * devm_rtc_device_unregister - resource managed devm_rtc_device_unregister()
361 * @dev: the device to unregister
362 * @rtc: the RTC class device to unregister
364 * Deallocated a rtc allocated with devm_rtc_device_register(). Normally this
365 * function will not need to be called and the resource management code will
366 * ensure that the resource is freed.
368 void devm_rtc_device_unregister(struct device
*dev
, struct rtc_device
*rtc
)
372 rc
= devres_release(dev
, devm_rtc_device_release
,
373 devm_rtc_device_match
, rtc
);
376 EXPORT_SYMBOL_GPL(devm_rtc_device_unregister
);
378 static void devm_rtc_release_device(struct device
*dev
, void *res
)
380 struct rtc_device
*rtc
= *(struct rtc_device
**)res
;
383 rtc_device_unregister(rtc
);
385 put_device(&rtc
->dev
);
388 struct rtc_device
*devm_rtc_allocate_device(struct device
*dev
)
390 struct rtc_device
**ptr
, *rtc
;
393 id
= rtc_device_get_id(dev
);
397 ptr
= devres_alloc(devm_rtc_release_device
, sizeof(*ptr
), GFP_KERNEL
);
403 rtc
= rtc_allocate_device();
410 devres_add(dev
, ptr
);
413 rtc
->dev
.parent
= dev
;
414 dev_set_name(&rtc
->dev
, "rtc%d", id
);
421 ida_simple_remove(&rtc_ida
, id
);
424 EXPORT_SYMBOL_GPL(devm_rtc_allocate_device
);
426 int __rtc_register_device(struct module
*owner
, struct rtc_device
*rtc
)
428 struct rtc_wkalrm alrm
;
436 /* Check to see if there is an ALARM already set in hw */
437 err
= __rtc_read_alarm(rtc
, &alrm
);
438 if (!err
&& !rtc_valid_tm(&alrm
.time
))
439 rtc_initialize_alarm(rtc
, &alrm
);
441 rtc_dev_prepare(rtc
);
443 err
= cdev_device_add(&rtc
->char_dev
, &rtc
->dev
);
445 dev_warn(rtc
->dev
.parent
, "failed to add char device %d:%d\n",
446 MAJOR(rtc
->dev
.devt
), rtc
->id
);
448 dev_dbg(rtc
->dev
.parent
, "char device (%d:%d)\n",
449 MAJOR(rtc
->dev
.devt
), rtc
->id
);
451 rtc_proc_add_device(rtc
);
453 rtc_nvmem_register(rtc
);
455 rtc
->registered
= true;
456 dev_info(rtc
->dev
.parent
, "registered as %s\n",
457 dev_name(&rtc
->dev
));
461 EXPORT_SYMBOL_GPL(__rtc_register_device
);
463 static int __init
rtc_init(void)
465 rtc_class
= class_create(THIS_MODULE
, "rtc");
466 if (IS_ERR(rtc_class
)) {
467 pr_err("couldn't create class\n");
468 return PTR_ERR(rtc_class
);
470 rtc_class
->pm
= RTC_CLASS_DEV_PM_OPS
;
474 subsys_initcall(rtc_init
);