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