Branch data Line data Source code
1 : : /*
2 : : * RTC subsystem, interface functions
3 : : *
4 : : * Copyright (C) 2005 Tower Technologies
5 : : * Author: Alessandro Zummo <a.zummo@towertech.it>
6 : : *
7 : : * based on arch/arm/common/rtctime.c
8 : : *
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.
12 : : */
13 : :
14 : : #include <linux/rtc.h>
15 : : #include <linux/sched.h>
16 : : #include <linux/module.h>
17 : : #include <linux/log2.h>
18 : : #include <linux/workqueue.h>
19 : :
20 : : static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer);
21 : : static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer);
22 : :
23 : 2 : static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
24 : : {
25 : : int err;
26 [ + - ]: 2 : if (!rtc->ops)
27 : : err = -ENODEV;
28 [ + - ]: 2 : else if (!rtc->ops->read_time)
29 : : err = -EINVAL;
30 : : else {
31 : 2 : memset(tm, 0, sizeof(struct rtc_time));
32 : 2 : err = rtc->ops->read_time(rtc->dev.parent, tm);
33 : : }
34 : 0 : return err;
35 : : }
36 : :
37 : 0 : int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
38 : : {
39 : : int err;
40 : :
41 : 1 : err = mutex_lock_interruptible(&rtc->ops_lock);
42 [ + - ]: 1 : if (err)
43 : : return err;
44 : :
45 : 1 : err = __rtc_read_time(rtc, tm);
46 : 1 : mutex_unlock(&rtc->ops_lock);
47 : 1 : return err;
48 : : }
49 : : EXPORT_SYMBOL_GPL(rtc_read_time);
50 : :
51 : 0 : int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
52 : : {
53 : : int err;
54 : :
55 : 1 : err = rtc_valid_tm(tm);
56 [ + - ]: 1 : if (err != 0)
57 : : return err;
58 : :
59 : 1 : err = mutex_lock_interruptible(&rtc->ops_lock);
60 [ + - ]: 1 : if (err)
61 : : return err;
62 : :
63 [ + - ]: 1 : if (!rtc->ops)
64 : : err = -ENODEV;
65 [ + - ]: 1 : else if (rtc->ops->set_time)
66 : 1 : err = rtc->ops->set_time(rtc->dev.parent, tm);
67 [ # # ]: 0 : else if (rtc->ops->set_mmss) {
68 : : unsigned long secs;
69 : 0 : err = rtc_tm_to_time(tm, &secs);
70 [ # # ]: 0 : if (err == 0)
71 : 0 : err = rtc->ops->set_mmss(rtc->dev.parent, secs);
72 : : } else
73 : : err = -EINVAL;
74 : :
75 : 1 : pm_stay_awake(rtc->dev.parent);
76 : 1 : mutex_unlock(&rtc->ops_lock);
77 : : /* A timer might have just expired */
78 : 1 : schedule_work(&rtc->irqwork);
79 : 1 : return err;
80 : : }
81 : : EXPORT_SYMBOL_GPL(rtc_set_time);
82 : :
83 : 0 : int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
84 : : {
85 : : int err;
86 : :
87 : 0 : err = mutex_lock_interruptible(&rtc->ops_lock);
88 [ # # ]: 0 : if (err)
89 : : return err;
90 : :
91 [ # # ]: 0 : if (!rtc->ops)
92 : : err = -ENODEV;
93 [ # # ]: 0 : else if (rtc->ops->set_mmss)
94 : 0 : err = rtc->ops->set_mmss(rtc->dev.parent, secs);
95 [ # # ][ # # ]: 0 : else if (rtc->ops->read_time && rtc->ops->set_time) {
96 : : struct rtc_time new, old;
97 : :
98 : 0 : err = rtc->ops->read_time(rtc->dev.parent, &old);
99 [ # # ]: 0 : if (err == 0) {
100 : 0 : rtc_time_to_tm(secs, &new);
101 : :
102 : : /*
103 : : * avoid writing when we're going to change the day of
104 : : * the month. We will retry in the next minute. This
105 : : * basically means that if the RTC must not drift
106 : : * by more than 1 minute in 11 minutes.
107 : : */
108 [ # # ][ # # ]: 0 : if (!((old.tm_hour == 23 && old.tm_min == 59) ||
[ # # ]
109 [ # # ]: 0 : (new.tm_hour == 23 && new.tm_min == 59)))
110 : 0 : err = rtc->ops->set_time(rtc->dev.parent,
111 : : &new);
112 : : }
113 : : } else {
114 : : err = -EINVAL;
115 : : }
116 : :
117 : 0 : pm_stay_awake(rtc->dev.parent);
118 : 0 : mutex_unlock(&rtc->ops_lock);
119 : : /* A timer might have just expired */
120 : 0 : schedule_work(&rtc->irqwork);
121 : :
122 : 0 : return err;
123 : : }
124 : : EXPORT_SYMBOL_GPL(rtc_set_mmss);
125 : :
126 : 0 : static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
127 : : {
128 : : int err;
129 : :
130 : 0 : err = mutex_lock_interruptible(&rtc->ops_lock);
131 [ # # ]: 0 : if (err)
132 : : return err;
133 : :
134 [ # # ]: 0 : if (rtc->ops == NULL)
135 : : err = -ENODEV;
136 [ # # ]: 0 : else if (!rtc->ops->read_alarm)
137 : : err = -EINVAL;
138 : : else {
139 : 0 : memset(alarm, 0, sizeof(struct rtc_wkalrm));
140 : 0 : err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
141 : : }
142 : :
143 : 0 : mutex_unlock(&rtc->ops_lock);
144 : 0 : return err;
145 : : }
146 : :
147 : 0 : int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
148 : : {
149 : : int err;
150 : : struct rtc_time before, now;
151 : : int first_time = 1;
152 : : unsigned long t_now, t_alm;
153 : : enum { none, day, month, year } missing = none;
154 : : unsigned days;
155 : :
156 : : /* The lower level RTC driver may return -1 in some fields,
157 : : * creating invalid alarm->time values, for reasons like:
158 : : *
159 : : * - The hardware may not be capable of filling them in;
160 : : * many alarms match only on time-of-day fields, not
161 : : * day/month/year calendar data.
162 : : *
163 : : * - Some hardware uses illegal values as "wildcard" match
164 : : * values, which non-Linux firmware (like a BIOS) may try
165 : : * to set up as e.g. "alarm 15 minutes after each hour".
166 : : * Linux uses only oneshot alarms.
167 : : *
168 : : * When we see that here, we deal with it by using values from
169 : : * a current RTC timestamp for any missing (-1) values. The
170 : : * RTC driver prevents "periodic alarm" modes.
171 : : *
172 : : * But this can be racey, because some fields of the RTC timestamp
173 : : * may have wrapped in the interval since we read the RTC alarm,
174 : : * which would lead to us inserting inconsistent values in place
175 : : * of the -1 fields.
176 : : *
177 : : * Reading the alarm and timestamp in the reverse sequence
178 : : * would have the same race condition, and not solve the issue.
179 : : *
180 : : * So, we must first read the RTC timestamp,
181 : : * then read the RTC alarm value,
182 : : * and then read a second RTC timestamp.
183 : : *
184 : : * If any fields of the second timestamp have changed
185 : : * when compared with the first timestamp, then we know
186 : : * our timestamp may be inconsistent with that used by
187 : : * the low-level rtc_read_alarm_internal() function.
188 : : *
189 : : * So, when the two timestamps disagree, we just loop and do
190 : : * the process again to get a fully consistent set of values.
191 : : *
192 : : * This could all instead be done in the lower level driver,
193 : : * but since more than one lower level RTC implementation needs it,
194 : : * then it's probably best best to do it here instead of there..
195 : : */
196 : :
197 : : /* Get the "before" timestamp */
198 : 0 : err = rtc_read_time(rtc, &before);
199 [ # # ]: 0 : if (err < 0)
200 : : return err;
201 : : do {
202 [ # # ]: 0 : if (!first_time)
203 : 0 : memcpy(&before, &now, sizeof(struct rtc_time));
204 : : first_time = 0;
205 : :
206 : : /* get the RTC alarm values, which may be incomplete */
207 : 0 : err = rtc_read_alarm_internal(rtc, alarm);
208 [ # # ]: 0 : if (err)
209 : : return err;
210 : :
211 : : /* full-function RTCs won't have such missing fields */
212 [ # # ]: 0 : if (rtc_valid_tm(&alarm->time) == 0)
213 : : return 0;
214 : :
215 : : /* get the "after" timestamp, to detect wrapped fields */
216 : 0 : err = rtc_read_time(rtc, &now);
217 [ # # ]: 0 : if (err < 0)
218 : : return err;
219 : :
220 : : /* note that tm_sec is a "don't care" value here: */
221 : 0 : } while ( before.tm_min != now.tm_min
222 [ # # ]: 0 : || before.tm_hour != now.tm_hour
223 [ # # ]: 0 : || before.tm_mon != now.tm_mon
224 [ # # ][ # # ]: 0 : || before.tm_year != now.tm_year);
225 : :
226 : : /* Fill in the missing alarm fields using the timestamp; we
227 : : * know there's at least one since alarm->time is invalid.
228 : : */
229 [ # # ]: 0 : if (alarm->time.tm_sec == -1)
230 : 0 : alarm->time.tm_sec = now.tm_sec;
231 [ # # ]: 0 : if (alarm->time.tm_min == -1)
232 : 0 : alarm->time.tm_min = now.tm_min;
233 [ # # ]: 0 : if (alarm->time.tm_hour == -1)
234 : 0 : alarm->time.tm_hour = now.tm_hour;
235 : :
236 : : /* For simplicity, only support date rollover for now */
237 [ # # ]: 0 : if (alarm->time.tm_mday < 1 || alarm->time.tm_mday > 31) {
238 : 0 : alarm->time.tm_mday = now.tm_mday;
239 : : missing = day;
240 : : }
241 [ # # ]: 0 : if ((unsigned)alarm->time.tm_mon >= 12) {
242 : 0 : alarm->time.tm_mon = now.tm_mon;
243 [ # # ]: 0 : if (missing == none)
244 : : missing = month;
245 : : }
246 [ # # ]: 0 : if (alarm->time.tm_year == -1) {
247 : 0 : alarm->time.tm_year = now.tm_year;
248 [ # # ]: 0 : if (missing == none)
249 : : missing = year;
250 : : }
251 : :
252 : : /* with luck, no rollover is needed */
253 : 0 : rtc_tm_to_time(&now, &t_now);
254 : 0 : rtc_tm_to_time(&alarm->time, &t_alm);
255 [ # # ]: 0 : if (t_now < t_alm)
256 : : goto done;
257 : :
258 [ # # # # ]: 0 : switch (missing) {
259 : :
260 : : /* 24 hour rollover ... if it's now 10am Monday, an alarm that
261 : : * that will trigger at 5am will do so at 5am Tuesday, which
262 : : * could also be in the next month or year. This is a common
263 : : * case, especially for PCs.
264 : : */
265 : : case day:
266 : : dev_dbg(&rtc->dev, "alarm rollover: %s\n", "day");
267 : 0 : t_alm += 24 * 60 * 60;
268 : 0 : rtc_time_to_tm(t_alm, &alarm->time);
269 : 0 : break;
270 : :
271 : : /* Month rollover ... if it's the 31th, an alarm on the 3rd will
272 : : * be next month. An alarm matching on the 30th, 29th, or 28th
273 : : * may end up in the month after that! Many newer PCs support
274 : : * this type of alarm.
275 : : */
276 : : case month:
277 : : dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month");
278 : : do {
279 [ # # ]: 0 : if (alarm->time.tm_mon < 11)
280 : 0 : alarm->time.tm_mon++;
281 : : else {
282 : 0 : alarm->time.tm_mon = 0;
283 : 0 : alarm->time.tm_year++;
284 : : }
285 : 0 : days = rtc_month_days(alarm->time.tm_mon,
286 : 0 : alarm->time.tm_year);
287 [ # # ]: 0 : } while (days < alarm->time.tm_mday);
288 : : break;
289 : :
290 : : /* Year rollover ... easy except for leap years! */
291 : : case year:
292 : : dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year");
293 : : do {
294 : 0 : alarm->time.tm_year++;
295 [ # # ]: 0 : } while (rtc_valid_tm(&alarm->time) != 0);
296 : : break;
297 : :
298 : : default:
299 : 0 : dev_warn(&rtc->dev, "alarm rollover not handled\n");
300 : : }
301 : :
302 : : done:
303 : : return 0;
304 : : }
305 : :
306 : 0 : int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
307 : : {
308 : : int err;
309 : :
310 : 1 : err = mutex_lock_interruptible(&rtc->ops_lock);
311 [ + - ]: 1 : if (err)
312 : : return err;
313 [ + - ]: 1 : if (rtc->ops == NULL)
314 : : err = -ENODEV;
315 [ + - ]: 1 : else if (!rtc->ops->read_alarm)
316 : : err = -EINVAL;
317 : : else {
318 : 1 : memset(alarm, 0, sizeof(struct rtc_wkalrm));
319 : 1 : alarm->enabled = rtc->aie_timer.enabled;
320 : 1 : alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires);
321 : : }
322 : 1 : mutex_unlock(&rtc->ops_lock);
323 : :
324 : 1 : return err;
325 : : }
326 : : EXPORT_SYMBOL_GPL(rtc_read_alarm);
327 : :
328 : 0 : static int __rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
329 : : {
330 : : struct rtc_time tm;
331 : : long now, scheduled;
332 : : int err;
333 : :
334 : 0 : err = rtc_valid_tm(&alarm->time);
335 [ # # ]: 0 : if (err)
336 : : return err;
337 : 0 : rtc_tm_to_time(&alarm->time, &scheduled);
338 : :
339 : : /* Make sure we're not setting alarms in the past */
340 : 0 : err = __rtc_read_time(rtc, &tm);
341 : 0 : rtc_tm_to_time(&tm, &now);
342 [ # # ]: 0 : if (scheduled <= now)
343 : : return -ETIME;
344 : : /*
345 : : * XXX - We just checked to make sure the alarm time is not
346 : : * in the past, but there is still a race window where if
347 : : * the is alarm set for the next second and the second ticks
348 : : * over right here, before we set the alarm.
349 : : */
350 : :
351 [ # # ]: 0 : if (!rtc->ops)
352 : : err = -ENODEV;
353 [ # # ]: 0 : else if (!rtc->ops->set_alarm)
354 : : err = -EINVAL;
355 : : else
356 : 0 : err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
357 : :
358 : 0 : return err;
359 : : }
360 : :
361 : 0 : int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
362 : : {
363 : : int err;
364 : :
365 : 0 : err = rtc_valid_tm(&alarm->time);
366 [ # # ]: 0 : if (err != 0)
367 : : return err;
368 : :
369 : 0 : err = mutex_lock_interruptible(&rtc->ops_lock);
370 [ # # ]: 0 : if (err)
371 : : return err;
372 [ # # ]: 0 : if (rtc->aie_timer.enabled)
373 : 0 : rtc_timer_remove(rtc, &rtc->aie_timer);
374 : :
375 : 0 : rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
376 : 0 : rtc->aie_timer.period = ktime_set(0, 0);
377 [ # # ]: 0 : if (alarm->enabled)
378 : 0 : err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
379 : :
380 : 0 : mutex_unlock(&rtc->ops_lock);
381 : 0 : return err;
382 : : }
383 : : EXPORT_SYMBOL_GPL(rtc_set_alarm);
384 : :
385 : : /* Called once per device from rtc_device_register */
386 : 0 : int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
387 : : {
388 : : int err;
389 : : struct rtc_time now;
390 : :
391 : 0 : err = rtc_valid_tm(&alarm->time);
392 [ # # ]: 0 : if (err != 0)
393 : : return err;
394 : :
395 : 0 : err = rtc_read_time(rtc, &now);
396 [ # # ]: 0 : if (err)
397 : : return err;
398 : :
399 : 0 : err = mutex_lock_interruptible(&rtc->ops_lock);
400 [ # # ]: 0 : if (err)
401 : : return err;
402 : :
403 : 0 : rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
404 : 0 : rtc->aie_timer.period = ktime_set(0, 0);
405 : :
406 : : /* Alarm has to be enabled & in the futrure for us to enqueue it */
407 [ # # ][ # # ]: 0 : if (alarm->enabled && (rtc_tm_to_ktime(now).tv64 <
408 : 0 : rtc->aie_timer.node.expires.tv64)) {
409 : :
410 : 0 : rtc->aie_timer.enabled = 1;
411 : 0 : timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node);
412 : : }
413 : 0 : mutex_unlock(&rtc->ops_lock);
414 : 0 : return err;
415 : : }
416 : : EXPORT_SYMBOL_GPL(rtc_initialize_alarm);
417 : :
418 : :
419 : :
420 : 0 : int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
421 : : {
422 : 0 : int err = mutex_lock_interruptible(&rtc->ops_lock);
423 [ # # ]: 0 : if (err)
424 : : return err;
425 : :
426 [ # # ]: 0 : if (rtc->aie_timer.enabled != enabled) {
427 [ # # ]: 0 : if (enabled)
428 : 0 : err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
429 : : else
430 : 0 : rtc_timer_remove(rtc, &rtc->aie_timer);
431 : : }
432 : :
433 [ # # ]: 0 : if (err)
434 : : /* nothing */;
435 [ # # ]: 0 : else if (!rtc->ops)
436 : : err = -ENODEV;
437 [ # # ]: 0 : else if (!rtc->ops->alarm_irq_enable)
438 : : err = -EINVAL;
439 : : else
440 : 0 : err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled);
441 : :
442 : 0 : mutex_unlock(&rtc->ops_lock);
443 : 0 : return err;
444 : : }
445 : : EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable);
446 : :
447 : 0 : int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
448 : : {
449 : 0 : int err = mutex_lock_interruptible(&rtc->ops_lock);
450 [ # # ]: 0 : if (err)
451 : : return err;
452 : :
453 : : #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
454 : : if (enabled == 0 && rtc->uie_irq_active) {
455 : : mutex_unlock(&rtc->ops_lock);
456 : : return rtc_dev_update_irq_enable_emul(rtc, 0);
457 : : }
458 : : #endif
459 : : /* make sure we're changing state */
460 [ # # ]: 0 : if (rtc->uie_rtctimer.enabled == enabled)
461 : : goto out;
462 : :
463 [ # # ]: 0 : if (rtc->uie_unsupported) {
464 : : err = -EINVAL;
465 : : goto out;
466 : : }
467 : :
468 [ # # ]: 0 : if (enabled) {
469 : : struct rtc_time tm;
470 : : ktime_t now, onesec;
471 : :
472 : 0 : __rtc_read_time(rtc, &tm);
473 : : onesec = ktime_set(1, 0);
474 : 0 : now = rtc_tm_to_ktime(tm);
475 : 0 : rtc->uie_rtctimer.node.expires = ktime_add(now, onesec);
476 : 0 : rtc->uie_rtctimer.period = ktime_set(1, 0);
477 : 0 : err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
478 : : } else
479 : 0 : rtc_timer_remove(rtc, &rtc->uie_rtctimer);
480 : :
481 : : out:
482 : 0 : mutex_unlock(&rtc->ops_lock);
483 : : #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
484 : : /*
485 : : * Enable emulation if the driver did not provide
486 : : * the update_irq_enable function pointer or if returned
487 : : * -EINVAL to signal that it has been configured without
488 : : * interrupts or that are not available at the moment.
489 : : */
490 : : if (err == -EINVAL)
491 : : err = rtc_dev_update_irq_enable_emul(rtc, enabled);
492 : : #endif
493 : 0 : return err;
494 : :
495 : : }
496 : : EXPORT_SYMBOL_GPL(rtc_update_irq_enable);
497 : :
498 : :
499 : : /**
500 : : * rtc_handle_legacy_irq - AIE, UIE and PIE event hook
501 : : * @rtc: pointer to the rtc device
502 : : *
503 : : * This function is called when an AIE, UIE or PIE mode interrupt
504 : : * has occurred (or been emulated).
505 : : *
506 : : * Triggers the registered irq_task function callback.
507 : : */
508 : 0 : void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
509 : : {
510 : : unsigned long flags;
511 : :
512 : : /* mark one irq of the appropriate mode */
513 : 0 : spin_lock_irqsave(&rtc->irq_lock, flags);
514 : 0 : rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode);
515 : : spin_unlock_irqrestore(&rtc->irq_lock, flags);
516 : :
517 : : /* call the task func */
518 : 0 : spin_lock_irqsave(&rtc->irq_task_lock, flags);
519 [ # # ]: 0 : if (rtc->irq_task)
520 : 0 : rtc->irq_task->func(rtc->irq_task->private_data);
521 : : spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
522 : :
523 : 0 : wake_up_interruptible(&rtc->irq_queue);
524 : 0 : kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
525 : 0 : }
526 : :
527 : :
528 : : /**
529 : : * rtc_aie_update_irq - AIE mode rtctimer hook
530 : : * @private: pointer to the rtc_device
531 : : *
532 : : * This functions is called when the aie_timer expires.
533 : : */
534 : 0 : void rtc_aie_update_irq(void *private)
535 : : {
536 : : struct rtc_device *rtc = (struct rtc_device *)private;
537 : 0 : rtc_handle_legacy_irq(rtc, 1, RTC_AF);
538 : 0 : }
539 : :
540 : :
541 : : /**
542 : : * rtc_uie_update_irq - UIE mode rtctimer hook
543 : : * @private: pointer to the rtc_device
544 : : *
545 : : * This functions is called when the uie_timer expires.
546 : : */
547 : 0 : void rtc_uie_update_irq(void *private)
548 : : {
549 : : struct rtc_device *rtc = (struct rtc_device *)private;
550 : 0 : rtc_handle_legacy_irq(rtc, 1, RTC_UF);
551 : 0 : }
552 : :
553 : :
554 : : /**
555 : : * rtc_pie_update_irq - PIE mode hrtimer hook
556 : : * @timer: pointer to the pie mode hrtimer
557 : : *
558 : : * This function is used to emulate PIE mode interrupts
559 : : * using an hrtimer. This function is called when the periodic
560 : : * hrtimer expires.
561 : : */
562 : 0 : enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
563 : : {
564 : : struct rtc_device *rtc;
565 : : ktime_t period;
566 : : int count;
567 : 0 : rtc = container_of(timer, struct rtc_device, pie_timer);
568 : :
569 : 0 : period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq);
570 : 0 : count = hrtimer_forward_now(timer, period);
571 : :
572 : 0 : rtc_handle_legacy_irq(rtc, count, RTC_PF);
573 : :
574 : 0 : return HRTIMER_RESTART;
575 : : }
576 : :
577 : : /**
578 : : * rtc_update_irq - Triggered when a RTC interrupt occurs.
579 : : * @rtc: the rtc device
580 : : * @num: how many irqs are being reported (usually one)
581 : : * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
582 : : * Context: any
583 : : */
584 : 0 : void rtc_update_irq(struct rtc_device *rtc,
585 : : unsigned long num, unsigned long events)
586 : : {
587 : 0 : pm_stay_awake(rtc->dev.parent);
588 : 0 : schedule_work(&rtc->irqwork);
589 : 0 : }
590 : : EXPORT_SYMBOL_GPL(rtc_update_irq);
591 : :
592 : 0 : static int __rtc_match(struct device *dev, const void *data)
593 : : {
594 : : const char *name = data;
595 : :
596 [ - - ]: 1 : if (strcmp(dev_name(dev), name) == 0)
597 : : return 1;
598 : 0 : return 0;
599 : : }
600 : :
601 : 0 : struct rtc_device *rtc_class_open(const char *name)
602 : : {
603 : : struct device *dev;
604 : : struct rtc_device *rtc = NULL;
605 : :
606 : 1 : dev = class_find_device(rtc_class, NULL, name, __rtc_match);
607 [ + - ]: 1 : if (dev)
608 : : rtc = to_rtc_device(dev);
609 : :
610 [ + - ]: 1 : if (rtc) {
611 [ - + ]: 1 : if (!try_module_get(rtc->owner)) {
612 : 0 : put_device(dev);
613 : : rtc = NULL;
614 : : }
615 : : }
616 : :
617 : 0 : return rtc;
618 : : }
619 : : EXPORT_SYMBOL_GPL(rtc_class_open);
620 : :
621 : 0 : void rtc_class_close(struct rtc_device *rtc)
622 : : {
623 : 1 : module_put(rtc->owner);
624 : 1 : put_device(&rtc->dev);
625 : 1 : }
626 : : EXPORT_SYMBOL_GPL(rtc_class_close);
627 : :
628 : 0 : int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task)
629 : : {
630 : : int retval = -EBUSY;
631 : :
632 [ # # ][ # # ]: 0 : if (task == NULL || task->func == NULL)
633 : : return -EINVAL;
634 : :
635 : : /* Cannot register while the char dev is in use */
636 [ # # ]: 0 : if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
637 : : return -EBUSY;
638 : :
639 : : spin_lock_irq(&rtc->irq_task_lock);
640 [ # # ]: 0 : if (rtc->irq_task == NULL) {
641 : 0 : rtc->irq_task = task;
642 : : retval = 0;
643 : : }
644 : : spin_unlock_irq(&rtc->irq_task_lock);
645 : :
646 : 0 : clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
647 : :
648 : 0 : return retval;
649 : : }
650 : : EXPORT_SYMBOL_GPL(rtc_irq_register);
651 : :
652 : 0 : void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task)
653 : : {
654 : : spin_lock_irq(&rtc->irq_task_lock);
655 [ # # ]: 0 : if (rtc->irq_task == task)
656 : 0 : rtc->irq_task = NULL;
657 : : spin_unlock_irq(&rtc->irq_task_lock);
658 : 0 : }
659 : : EXPORT_SYMBOL_GPL(rtc_irq_unregister);
660 : :
661 : 0 : static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled)
662 : : {
663 : : /*
664 : : * We always cancel the timer here first, because otherwise
665 : : * we could run into BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);
666 : : * when we manage to start the timer before the callback
667 : : * returns HRTIMER_RESTART.
668 : : *
669 : : * We cannot use hrtimer_cancel() here as a running callback
670 : : * could be blocked on rtc->irq_task_lock and hrtimer_cancel()
671 : : * would spin forever.
672 : : */
673 [ # # ]: 0 : if (hrtimer_try_to_cancel(&rtc->pie_timer) < 0)
674 : : return -1;
675 : :
676 [ # # ]: 0 : if (enabled) {
677 : 0 : ktime_t period = ktime_set(0, NSEC_PER_SEC / rtc->irq_freq);
678 : :
679 : 0 : hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL);
680 : : }
681 : : return 0;
682 : : }
683 : :
684 : : /**
685 : : * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs
686 : : * @rtc: the rtc device
687 : : * @task: currently registered with rtc_irq_register()
688 : : * @enabled: true to enable periodic IRQs
689 : : * Context: any
690 : : *
691 : : * Note that rtc_irq_set_freq() should previously have been used to
692 : : * specify the desired frequency of periodic IRQ task->func() callbacks.
693 : : */
694 : 0 : int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
695 : : {
696 : : int err = 0;
697 : : unsigned long flags;
698 : :
699 : : retry:
700 : 0 : spin_lock_irqsave(&rtc->irq_task_lock, flags);
701 [ # # ][ # # ]: 0 : if (rtc->irq_task != NULL && task == NULL)
702 : : err = -EBUSY;
703 [ # # ]: 0 : else if (rtc->irq_task != task)
704 : : err = -EACCES;
705 : : else {
706 [ # # ]: 0 : if (rtc_update_hrtimer(rtc, enabled) < 0) {
707 : : spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
708 : 0 : cpu_relax();
709 : 0 : goto retry;
710 : : }
711 : 0 : rtc->pie_enabled = enabled;
712 : : }
713 : : spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
714 : 0 : return err;
715 : : }
716 : : EXPORT_SYMBOL_GPL(rtc_irq_set_state);
717 : :
718 : : /**
719 : : * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ
720 : : * @rtc: the rtc device
721 : : * @task: currently registered with rtc_irq_register()
722 : : * @freq: positive frequency with which task->func() will be called
723 : : * Context: any
724 : : *
725 : : * Note that rtc_irq_set_state() is used to enable or disable the
726 : : * periodic IRQs.
727 : : */
728 : 0 : int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
729 : : {
730 : : int err = 0;
731 : : unsigned long flags;
732 : :
733 [ # # ]: 0 : if (freq <= 0 || freq > RTC_MAX_FREQ)
734 : : return -EINVAL;
735 : : retry:
736 : 0 : spin_lock_irqsave(&rtc->irq_task_lock, flags);
737 [ # # ][ # # ]: 0 : if (rtc->irq_task != NULL && task == NULL)
738 : : err = -EBUSY;
739 [ # # ]: 0 : else if (rtc->irq_task != task)
740 : : err = -EACCES;
741 : : else {
742 : 0 : rtc->irq_freq = freq;
743 [ # # ][ # # ]: 0 : if (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0) {
744 : : spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
745 : 0 : cpu_relax();
746 : 0 : goto retry;
747 : : }
748 : : }
749 : : spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
750 : 0 : return err;
751 : : }
752 : : EXPORT_SYMBOL_GPL(rtc_irq_set_freq);
753 : :
754 : : /**
755 : : * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue
756 : : * @rtc rtc device
757 : : * @timer timer being added.
758 : : *
759 : : * Enqueues a timer onto the rtc devices timerqueue and sets
760 : : * the next alarm event appropriately.
761 : : *
762 : : * Sets the enabled bit on the added timer.
763 : : *
764 : : * Must hold ops_lock for proper serialization of timerqueue
765 : : */
766 : 0 : static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
767 : : {
768 : 0 : timer->enabled = 1;
769 : 0 : timerqueue_add(&rtc->timerqueue, &timer->node);
770 [ # # ]: 0 : if (&timer->node == timerqueue_getnext(&rtc->timerqueue)) {
771 : : struct rtc_wkalrm alarm;
772 : : int err;
773 : 0 : alarm.time = rtc_ktime_to_tm(timer->node.expires);
774 : 0 : alarm.enabled = 1;
775 : 0 : err = __rtc_set_alarm(rtc, &alarm);
776 [ # # ]: 0 : if (err == -ETIME) {
777 : 0 : pm_stay_awake(rtc->dev.parent);
778 : 0 : schedule_work(&rtc->irqwork);
779 [ # # ]: 0 : } else if (err) {
780 : 0 : timerqueue_del(&rtc->timerqueue, &timer->node);
781 : 0 : timer->enabled = 0;
782 : 0 : return err;
783 : : }
784 : : }
785 : : return 0;
786 : : }
787 : :
788 : : static void rtc_alarm_disable(struct rtc_device *rtc)
789 : : {
790 [ + - ][ + - ]: 1 : if (!rtc->ops || !rtc->ops->alarm_irq_enable)
[ # # ][ # # ]
791 : : return;
792 : :
793 : 1 : rtc->ops->alarm_irq_enable(rtc->dev.parent, false);
794 : : }
795 : :
796 : : /**
797 : : * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue
798 : : * @rtc rtc device
799 : : * @timer timer being removed.
800 : : *
801 : : * Removes a timer onto the rtc devices timerqueue and sets
802 : : * the next alarm event appropriately.
803 : : *
804 : : * Clears the enabled bit on the removed timer.
805 : : *
806 : : * Must hold ops_lock for proper serialization of timerqueue
807 : : */
808 : 0 : static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
809 : : {
810 : 0 : struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
811 : 0 : timerqueue_del(&rtc->timerqueue, &timer->node);
812 : 0 : timer->enabled = 0;
813 [ # # ]: 0 : if (next == &timer->node) {
814 : : struct rtc_wkalrm alarm;
815 : : int err;
816 : : next = timerqueue_getnext(&rtc->timerqueue);
817 [ # # ]: 0 : if (!next) {
818 : : rtc_alarm_disable(rtc);
819 : 0 : return;
820 : : }
821 : 0 : alarm.time = rtc_ktime_to_tm(next->expires);
822 : 0 : alarm.enabled = 1;
823 : 0 : err = __rtc_set_alarm(rtc, &alarm);
824 [ # # ]: 0 : if (err == -ETIME) {
825 : 0 : pm_stay_awake(rtc->dev.parent);
826 : 0 : schedule_work(&rtc->irqwork);
827 : : }
828 : : }
829 : : }
830 : :
831 : : /**
832 : : * rtc_timer_do_work - Expires rtc timers
833 : : * @rtc rtc device
834 : : * @timer timer being removed.
835 : : *
836 : : * Expires rtc timers. Reprograms next alarm event if needed.
837 : : * Called via worktask.
838 : : *
839 : : * Serializes access to timerqueue via ops_lock mutex
840 : : */
841 : 0 : void rtc_timer_do_work(struct work_struct *work)
842 : : {
843 : : struct rtc_timer *timer;
844 : : struct timerqueue_node *next;
845 : : ktime_t now;
846 : : struct rtc_time tm;
847 : :
848 : 2 : struct rtc_device *rtc =
849 : : container_of(work, struct rtc_device, irqwork);
850 : :
851 : 1 : mutex_lock(&rtc->ops_lock);
852 : : again:
853 : 1 : __rtc_read_time(rtc, &tm);
854 : 1 : now = rtc_tm_to_ktime(tm);
855 [ - + ]: 2 : while ((next = timerqueue_getnext(&rtc->timerqueue))) {
856 [ # # ]: 0 : if (next->expires.tv64 > now.tv64)
857 : : break;
858 : :
859 : : /* expire timer */
860 : : timer = container_of(next, struct rtc_timer, node);
861 : 0 : timerqueue_del(&rtc->timerqueue, &timer->node);
862 : 0 : timer->enabled = 0;
863 [ # # ]: 0 : if (timer->task.func)
864 : 0 : timer->task.func(timer->task.private_data);
865 : :
866 : : /* Re-add/fwd periodic timers */
867 [ # # ]: 0 : if (ktime_to_ns(timer->period)) {
868 : 0 : timer->node.expires = ktime_add(timer->node.expires,
869 : : timer->period);
870 : 0 : timer->enabled = 1;
871 : 1 : timerqueue_add(&rtc->timerqueue, &timer->node);
872 : : }
873 : : }
874 : :
875 : : /* Set next alarm */
876 [ - + ]: 1 : if (next) {
877 : : struct rtc_wkalrm alarm;
878 : : int err;
879 : 0 : alarm.time = rtc_ktime_to_tm(next->expires);
880 : 0 : alarm.enabled = 1;
881 : 0 : err = __rtc_set_alarm(rtc, &alarm);
882 [ # # ]: 0 : if (err == -ETIME)
883 : : goto again;
884 : : } else
885 : : rtc_alarm_disable(rtc);
886 : :
887 : 1 : pm_relax(rtc->dev.parent);
888 : 1 : mutex_unlock(&rtc->ops_lock);
889 : 1 : }
890 : :
891 : :
892 : : /* rtc_timer_init - Initializes an rtc_timer
893 : : * @timer: timer to be intiialized
894 : : * @f: function pointer to be called when timer fires
895 : : * @data: private data passed to function pointer
896 : : *
897 : : * Kernel interface to initializing an rtc_timer.
898 : : */
899 : 0 : void rtc_timer_init(struct rtc_timer *timer, void (*f)(void *p), void *data)
900 : : {
901 : : timerqueue_init(&timer->node);
902 : 0 : timer->enabled = 0;
903 : 0 : timer->task.func = f;
904 : 0 : timer->task.private_data = data;
905 : 0 : }
906 : :
907 : : /* rtc_timer_start - Sets an rtc_timer to fire in the future
908 : : * @ rtc: rtc device to be used
909 : : * @ timer: timer being set
910 : : * @ expires: time at which to expire the timer
911 : : * @ period: period that the timer will recur
912 : : *
913 : : * Kernel interface to set an rtc_timer
914 : : */
915 : 0 : int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer,
916 : : ktime_t expires, ktime_t period)
917 : : {
918 : : int ret = 0;
919 : 0 : mutex_lock(&rtc->ops_lock);
920 [ # # ]: 0 : if (timer->enabled)
921 : 0 : rtc_timer_remove(rtc, timer);
922 : :
923 : 0 : timer->node.expires = expires;
924 : 0 : timer->period = period;
925 : :
926 : 0 : ret = rtc_timer_enqueue(rtc, timer);
927 : :
928 : 0 : mutex_unlock(&rtc->ops_lock);
929 : 0 : return ret;
930 : : }
931 : :
932 : : /* rtc_timer_cancel - Stops an rtc_timer
933 : : * @ rtc: rtc device to be used
934 : : * @ timer: timer being set
935 : : *
936 : : * Kernel interface to cancel an rtc_timer
937 : : */
938 : 0 : int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer)
939 : : {
940 : : int ret = 0;
941 : 0 : mutex_lock(&rtc->ops_lock);
942 [ # # ]: 0 : if (timer->enabled)
943 : 0 : rtc_timer_remove(rtc, timer);
944 : 0 : mutex_unlock(&rtc->ops_lock);
945 : 0 : return ret;
946 : : }
947 : :
948 : :
|
