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