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