Blame view
drivers/rtc/class.c
11.1 KB
0c86edc0d
|
1 2 3 4 5 6 7 8 9 10 11 12 |
/* * RTC subsystem, base class * * Copyright (C) 2005 Tower Technologies * Author: Alessandro Zummo <a.zummo@towertech.it> * * class skeleton from drivers/hwmon/hwmon.c * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ |
c100a5e02
|
13 |
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
0c86edc0d
|
14 |
#include <linux/module.h> |
9d2b7e532
|
15 |
#include <linux/of.h> |
0c86edc0d
|
16 17 18 |
#include <linux/rtc.h> #include <linux/kdev_t.h> #include <linux/idr.h> |
5a0e3ad6a
|
19 |
#include <linux/slab.h> |
6610e0893
|
20 |
#include <linux/workqueue.h> |
0c86edc0d
|
21 |
|
5726fb201
|
22 |
#include "rtc-core.h" |
6d03d06db
|
23 |
static DEFINE_IDA(rtc_ida); |
0c86edc0d
|
24 |
struct class *rtc_class; |
cd9662094
|
25 |
static void rtc_device_release(struct device *dev) |
0c86edc0d
|
26 |
{ |
cd9662094
|
27 |
struct rtc_device *rtc = to_rtc_device(dev); |
6d03d06db
|
28 |
ida_simple_remove(&rtc_ida, rtc->id); |
0c86edc0d
|
29 30 |
kfree(rtc); } |
4c24e29e6
|
31 32 33 34 |
#ifdef CONFIG_RTC_HCTOSYS_DEVICE /* Result of the last RTC to system clock attempt. */ int rtc_hctosys_ret = -ENODEV; #endif |
7ca1d488f
|
35 |
|
92e7f04a7
|
36 |
#if defined(CONFIG_PM_SLEEP) && defined(CONFIG_RTC_HCTOSYS_DEVICE) |
7ca1d488f
|
37 38 39 40 |
/* * On suspend(), measure the delta between one RTC and the * system's wall clock; restore it on resume(). */ |
d4bda8f84
|
41 |
static struct timespec64 old_rtc, old_system, old_delta; |
3dcad5ff0
|
42 |
|
7ca1d488f
|
43 |
|
92e7f04a7
|
44 |
static int rtc_suspend(struct device *dev) |
7ca1d488f
|
45 46 47 |
{ struct rtc_device *rtc = to_rtc_device(dev); struct rtc_time tm; |
d4bda8f84
|
48 |
struct timespec64 delta, delta_delta; |
e1d60093c
|
49 |
int err; |
9ecf37eb7
|
50 |
|
0fa88cb4b
|
51 |
if (timekeeping_rtc_skipsuspend()) |
9ecf37eb7
|
52 |
return 0; |
d4afc76c0
|
53 |
if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0) |
7ca1d488f
|
54 |
return 0; |
3dcad5ff0
|
55 |
/* snapshot the current RTC and system time at suspend*/ |
e1d60093c
|
56 57 58 59 60 61 |
err = rtc_read_time(rtc, &tm); if (err < 0) { pr_debug("%s: fail to read rtc time ", dev_name(&rtc->dev)); return 0; } |
d4bda8f84
|
62 63 |
getnstimeofday64(&old_system); old_rtc.tv_sec = rtc_tm_to_time64(&tm); |
3dcad5ff0
|
64 65 66 67 68 69 70 71 |
/* * To avoid drift caused by repeated suspend/resumes, * which each can add ~1 second drift error, * try to compensate so the difference in system time * and rtc time stays close to constant. */ |
d4bda8f84
|
72 73 |
delta = timespec64_sub(old_system, old_rtc); delta_delta = timespec64_sub(delta, old_delta); |
6a8943d9e
|
74 |
if (delta_delta.tv_sec < -2 || delta_delta.tv_sec >= 2) { |
3dcad5ff0
|
75 76 77 78 79 80 81 |
/* * if delta_delta is too large, assume time correction * has occured and set old_delta to the current delta. */ old_delta = delta; } else { /* Otherwise try to adjust old_system to compensate */ |
d4bda8f84
|
82 |
old_system = timespec64_sub(old_system, delta_delta); |
3dcad5ff0
|
83 |
} |
7ca1d488f
|
84 |
|
7ca1d488f
|
85 86 87 88 89 90 91 |
return 0; } static int rtc_resume(struct device *dev) { struct rtc_device *rtc = to_rtc_device(dev); struct rtc_time tm; |
d4bda8f84
|
92 93 |
struct timespec64 new_system, new_rtc; struct timespec64 sleep_time; |
e1d60093c
|
94 |
int err; |
7ca1d488f
|
95 |
|
0fa88cb4b
|
96 |
if (timekeeping_rtc_skipresume()) |
9ecf37eb7
|
97 |
return 0; |
4c24e29e6
|
98 |
rtc_hctosys_ret = -ENODEV; |
d4afc76c0
|
99 |
if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0) |
7ca1d488f
|
100 |
return 0; |
3dcad5ff0
|
101 |
/* snapshot the current rtc and system time at resume */ |
d4bda8f84
|
102 |
getnstimeofday64(&new_system); |
e1d60093c
|
103 104 105 106 107 108 |
err = rtc_read_time(rtc, &tm); if (err < 0) { pr_debug("%s: fail to read rtc time ", dev_name(&rtc->dev)); return 0; } |
d4bda8f84
|
109 |
new_rtc.tv_sec = rtc_tm_to_time64(&tm); |
3dcad5ff0
|
110 |
new_rtc.tv_nsec = 0; |
6a8943d9e
|
111 112 113 |
if (new_rtc.tv_sec < old_rtc.tv_sec) { pr_debug("%s: time travel! ", dev_name(&rtc->dev)); |
7ca1d488f
|
114 115 |
return 0; } |
3dcad5ff0
|
116 |
/* calculate the RTC time delta (sleep time)*/ |
d4bda8f84
|
117 |
sleep_time = timespec64_sub(new_rtc, old_rtc); |
3dcad5ff0
|
118 119 120 121 122 123 124 125 |
/* * Since these RTC suspend/resume handlers are not called * at the very end of suspend or the start of resume, * some run-time may pass on either sides of the sleep time * so subtract kernel run-time between rtc_suspend to rtc_resume * to keep things accurate. */ |
d4bda8f84
|
126 127 |
sleep_time = timespec64_sub(sleep_time, timespec64_sub(new_system, old_system)); |
7ca1d488f
|
128 |
|
6a8943d9e
|
129 |
if (sleep_time.tv_sec >= 0) |
d4bda8f84
|
130 |
timekeeping_inject_sleeptime64(&sleep_time); |
4c24e29e6
|
131 |
rtc_hctosys_ret = 0; |
7ca1d488f
|
132 133 |
return 0; } |
92e7f04a7
|
134 135 |
static SIMPLE_DEV_PM_OPS(rtc_class_dev_pm_ops, rtc_suspend, rtc_resume); #define RTC_CLASS_DEV_PM_OPS (&rtc_class_dev_pm_ops) |
7ca1d488f
|
136 |
#else |
92e7f04a7
|
137 |
#define RTC_CLASS_DEV_PM_OPS NULL |
7ca1d488f
|
138 |
#endif |
3068a254d
|
139 |
/* Ensure the caller will set the id before releasing the device */ |
d1bec20fa
|
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 |
static struct rtc_device *rtc_allocate_device(void) { struct rtc_device *rtc; rtc = kzalloc(sizeof(*rtc), GFP_KERNEL); if (!rtc) return NULL; device_initialize(&rtc->dev); rtc->irq_freq = 1; rtc->max_user_freq = 64; rtc->dev.class = rtc_class; rtc->dev.groups = rtc_get_dev_attribute_groups(); rtc->dev.release = rtc_device_release; mutex_init(&rtc->ops_lock); spin_lock_init(&rtc->irq_lock); spin_lock_init(&rtc->irq_task_lock); init_waitqueue_head(&rtc->irq_queue); /* Init timerqueue */ timerqueue_init_head(&rtc->timerqueue); INIT_WORK(&rtc->irqwork, rtc_timer_do_work); /* Init aie timer */ rtc_timer_init(&rtc->aie_timer, rtc_aie_update_irq, (void *)rtc); /* Init uie timer */ rtc_timer_init(&rtc->uie_rtctimer, rtc_uie_update_irq, (void *)rtc); /* Init pie timer */ hrtimer_init(&rtc->pie_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); rtc->pie_timer.function = rtc_pie_update_irq; rtc->pie_enabled = 0; return rtc; } |
7ca1d488f
|
175 |
|
b91336df8
|
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 |
static int rtc_device_get_id(struct device *dev) { int of_id = -1, id = -1; if (dev->of_node) of_id = of_alias_get_id(dev->of_node, "rtc"); else if (dev->parent && dev->parent->of_node) of_id = of_alias_get_id(dev->parent->of_node, "rtc"); if (of_id >= 0) { id = ida_simple_get(&rtc_ida, of_id, of_id + 1, GFP_KERNEL); if (id < 0) dev_warn(dev, "/aliases ID %d not available ", of_id); } if (id < 0) id = ida_simple_get(&rtc_ida, 0, 0, GFP_KERNEL); return id; } |
0c86edc0d
|
197 198 199 200 201 202 203 204 205 206 |
/** * rtc_device_register - register w/ RTC class * @dev: the device to register * * rtc_device_unregister() must be called when the class device is no * longer needed. * * Returns the pointer to the new struct class device. */ struct rtc_device *rtc_device_register(const char *name, struct device *dev, |
ff8371ac9
|
207 |
const struct rtc_class_ops *ops, |
0c86edc0d
|
208 209 210 |
struct module *owner) { struct rtc_device *rtc; |
f44f7f96a
|
211 |
struct rtc_wkalrm alrm; |
b91336df8
|
212 |
int id, err; |
0c86edc0d
|
213 |
|
b91336df8
|
214 |
id = rtc_device_get_id(dev); |
6d03d06db
|
215 |
if (id < 0) { |
b91336df8
|
216 217 |
err = id; goto exit; |
0c86edc0d
|
218 |
} |
d1bec20fa
|
219 220 |
rtc = rtc_allocate_device(); if (!rtc) { |
0c86edc0d
|
221 |
err = -ENOMEM; |
6d03d06db
|
222 |
goto exit_ida; |
0c86edc0d
|
223 224 225 226 227 |
} rtc->id = id; rtc->ops = ops; rtc->owner = owner; |
cd9662094
|
228 |
rtc->dev.parent = dev; |
6610e0893
|
229 |
|
182683e95
|
230 |
dev_set_name(&rtc->dev, "rtc%d", id); |
f44f7f96a
|
231 232 233 234 |
/* Check to see if there is an ALARM already set in hw */ err = __rtc_read_alarm(rtc, &alrm); if (!err && !rtc_valid_tm(&alrm.time)) |
f6d5b3312
|
235 |
rtc_initialize_alarm(rtc, &alrm); |
f44f7f96a
|
236 |
|
cb3a58d2a
|
237 |
rtc_dev_prepare(rtc); |
d5ed9177f
|
238 |
err = cdev_device_add(&rtc->char_dev, &rtc->dev); |
59cca865f
|
239 |
if (err) { |
d5ed9177f
|
240 241 |
dev_warn(&rtc->dev, "%s: failed to add char device %d:%d ", |
5c82a6ae0
|
242 |
name, MAJOR(rtc->dev.devt), rtc->id); |
d5ed9177f
|
243 |
|
6706664d9
|
244 |
/* This will free both memory and the ID */ |
59cca865f
|
245 |
put_device(&rtc->dev); |
6706664d9
|
246 |
goto exit; |
d5ed9177f
|
247 |
} else { |
5c82a6ae0
|
248 249 |
dev_dbg(&rtc->dev, "%s: dev (%d:%d) ", name, |
d5ed9177f
|
250 |
MAJOR(rtc->dev.devt), rtc->id); |
59cca865f
|
251 |
} |
0c86edc0d
|
252 |
|
7d9f99ecc
|
253 |
rtc_proc_add_device(rtc); |
5726fb201
|
254 |
|
0c86edc0d
|
255 256 |
dev_info(dev, "rtc core: registered %s as %s ", |
5c82a6ae0
|
257 |
name, dev_name(&rtc->dev)); |
0c86edc0d
|
258 259 |
return rtc; |
6d03d06db
|
260 261 |
exit_ida: ida_simple_remove(&rtc_ida, id); |
0c86edc0d
|
262 263 |
exit: |
d1d65b771
|
264 265 266 |
dev_err(dev, "rtc core: unable to register %s, err = %d ", name, err); |
0c86edc0d
|
267 268 269 270 271 272 273 274 275 276 277 278 |
return ERR_PTR(err); } EXPORT_SYMBOL_GPL(rtc_device_register); /** * rtc_device_unregister - removes the previously registered RTC class device * * @rtc: the RTC class device to destroy */ void rtc_device_unregister(struct rtc_device *rtc) { |
697e5a47a
|
279 |
rtc_nvmem_unregister(rtc); |
c3b399a4b
|
280 281 282 283 284 |
mutex_lock(&rtc->ops_lock); /* * Remove innards of this RTC, then disable it, before * letting any rtc_class_open() users access it again */ |
c3b399a4b
|
285 |
rtc_proc_del_device(rtc); |
d5ed9177f
|
286 |
cdev_device_del(&rtc->char_dev, &rtc->dev); |
c3b399a4b
|
287 288 289 |
rtc->ops = NULL; mutex_unlock(&rtc->ops_lock); put_device(&rtc->dev); |
0c86edc0d
|
290 291 |
} EXPORT_SYMBOL_GPL(rtc_device_unregister); |
3e217b660
|
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 |
static void devm_rtc_device_release(struct device *dev, void *res) { struct rtc_device *rtc = *(struct rtc_device **)res; rtc_device_unregister(rtc); } static int devm_rtc_device_match(struct device *dev, void *res, void *data) { struct rtc **r = res; return *r == data; } /** * devm_rtc_device_register - resource managed rtc_device_register() |
3e217b660
|
308 |
* @dev: the device to register |
6636a9944
|
309 |
* @name: the name of the device |
3e217b660
|
310 311 312 313 314 315 316 317 318 |
* @ops: the rtc operations structure * @owner: the module owner * * @return a struct rtc on success, or an ERR_PTR on error * * Managed rtc_device_register(). The rtc_device returned from this function * are automatically freed on driver detach. See rtc_device_register() * for more information. */ |
6636a9944
|
319 320 |
struct rtc_device *devm_rtc_device_register(struct device *dev, const char *name, |
3e217b660
|
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 |
const struct rtc_class_ops *ops, struct module *owner) { struct rtc_device **ptr, *rtc; ptr = devres_alloc(devm_rtc_device_release, sizeof(*ptr), GFP_KERNEL); if (!ptr) return ERR_PTR(-ENOMEM); rtc = rtc_device_register(name, dev, ops, owner); if (!IS_ERR(rtc)) { *ptr = rtc; devres_add(dev, ptr); } else { devres_free(ptr); } return rtc; } EXPORT_SYMBOL_GPL(devm_rtc_device_register); /** * devm_rtc_device_unregister - resource managed devm_rtc_device_unregister() * @dev: the device to unregister * @rtc: the RTC class device to unregister * * Deallocated a rtc allocated with devm_rtc_device_register(). Normally this * function will not need to be called and the resource management code will * ensure that the resource is freed. */ void devm_rtc_device_unregister(struct device *dev, struct rtc_device *rtc) { int rc; rc = devres_release(dev, devm_rtc_device_release, devm_rtc_device_match, rtc); WARN_ON(rc); } EXPORT_SYMBOL_GPL(devm_rtc_device_unregister); |
3068a254d
|
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 |
static void devm_rtc_release_device(struct device *dev, void *res) { struct rtc_device *rtc = *(struct rtc_device **)res; if (rtc->registered) rtc_device_unregister(rtc); else put_device(&rtc->dev); } struct rtc_device *devm_rtc_allocate_device(struct device *dev) { struct rtc_device **ptr, *rtc; int id, err; id = rtc_device_get_id(dev); if (id < 0) return ERR_PTR(id); ptr = devres_alloc(devm_rtc_release_device, sizeof(*ptr), GFP_KERNEL); if (!ptr) { err = -ENOMEM; goto exit_ida; } rtc = rtc_allocate_device(); if (!rtc) { err = -ENOMEM; goto exit_devres; } *ptr = rtc; devres_add(dev, ptr); rtc->id = id; rtc->dev.parent = dev; dev_set_name(&rtc->dev, "rtc%d", id); return rtc; exit_devres: devres_free(ptr); exit_ida: ida_simple_remove(&rtc_ida, id); return ERR_PTR(err); } EXPORT_SYMBOL_GPL(devm_rtc_allocate_device); int __rtc_register_device(struct module *owner, struct rtc_device *rtc) { struct rtc_wkalrm alrm; int err; if (!rtc->ops) return -EINVAL; rtc->owner = owner; /* Check to see if there is an ALARM already set in hw */ err = __rtc_read_alarm(rtc, &alrm); if (!err && !rtc_valid_tm(&alrm.time)) rtc_initialize_alarm(rtc, &alrm); rtc_dev_prepare(rtc); err = cdev_device_add(&rtc->char_dev, &rtc->dev); if (err) dev_warn(rtc->dev.parent, "failed to add char device %d:%d ", MAJOR(rtc->dev.devt), rtc->id); else dev_dbg(rtc->dev.parent, "char device (%d:%d) ", MAJOR(rtc->dev.devt), rtc->id); rtc_proc_add_device(rtc); |
697e5a47a
|
436 |
rtc_nvmem_register(rtc); |
3068a254d
|
437 438 439 440 441 442 443 444 |
rtc->registered = true; dev_info(rtc->dev.parent, "registered as %s ", dev_name(&rtc->dev)); return 0; } EXPORT_SYMBOL_GPL(__rtc_register_device); |
0c86edc0d
|
445 446 447 448 |
static int __init rtc_init(void) { rtc_class = class_create(THIS_MODULE, "rtc"); if (IS_ERR(rtc_class)) { |
c100a5e02
|
449 450 |
pr_err("couldn't create class "); |
0c86edc0d
|
451 452 |
return PTR_ERR(rtc_class); } |
92e7f04a7
|
453 |
rtc_class->pm = RTC_CLASS_DEV_PM_OPS; |
5726fb201
|
454 |
rtc_dev_init(); |
0c86edc0d
|
455 456 |
return 0; } |
818a8674b
|
457 |
subsys_initcall(rtc_init); |