rtc: Staticize non-exported __rtc_set_alarm()
[linux-2.6.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 /**
640  * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs
641  * @rtc: the rtc device
642  * @task: currently registered with rtc_irq_register()
643  * @enabled: true to enable periodic IRQs
644  * Context: any
645  *
646  * Note that rtc_irq_set_freq() should previously have been used to
647  * specify the desired frequency of periodic IRQ task->func() callbacks.
648  */
649 int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
650 {
651         int err = 0;
652         unsigned long flags;
653
654         spin_lock_irqsave(&rtc->irq_task_lock, flags);
655         if (rtc->irq_task != NULL && task == NULL)
656                 err = -EBUSY;
657         if (rtc->irq_task != task)
658                 err = -EACCES;
659
660         if (enabled) {
661                 ktime_t period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq);
662                 hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL);
663         } else {
664                 hrtimer_cancel(&rtc->pie_timer);
665         }
666         rtc->pie_enabled = enabled;
667         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
668
669         return err;
670 }
671 EXPORT_SYMBOL_GPL(rtc_irq_set_state);
672
673 /**
674  * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ
675  * @rtc: the rtc device
676  * @task: currently registered with rtc_irq_register()
677  * @freq: positive frequency with which task->func() will be called
678  * Context: any
679  *
680  * Note that rtc_irq_set_state() is used to enable or disable the
681  * periodic IRQs.
682  */
683 int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
684 {
685         int err = 0;
686         unsigned long flags;
687
688         if (freq <= 0)
689                 return -EINVAL;
690
691         spin_lock_irqsave(&rtc->irq_task_lock, flags);
692         if (rtc->irq_task != NULL && task == NULL)
693                 err = -EBUSY;
694         if (rtc->irq_task != task)
695                 err = -EACCES;
696         if (err == 0) {
697                 rtc->irq_freq = freq;
698                 if (rtc->pie_enabled) {
699                         ktime_t period;
700                         hrtimer_cancel(&rtc->pie_timer);
701                         period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq);
702                         hrtimer_start(&rtc->pie_timer, period,
703                                         HRTIMER_MODE_REL);
704                 }
705         }
706         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
707         return err;
708 }
709 EXPORT_SYMBOL_GPL(rtc_irq_set_freq);
710
711 /**
712  * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue
713  * @rtc rtc device
714  * @timer timer being added.
715  *
716  * Enqueues a timer onto the rtc devices timerqueue and sets
717  * the next alarm event appropriately.
718  *
719  * Sets the enabled bit on the added timer.
720  *
721  * Must hold ops_lock for proper serialization of timerqueue
722  */
723 static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
724 {
725         timer->enabled = 1;
726         timerqueue_add(&rtc->timerqueue, &timer->node);
727         if (&timer->node == timerqueue_getnext(&rtc->timerqueue)) {
728                 struct rtc_wkalrm alarm;
729                 int err;
730                 alarm.time = rtc_ktime_to_tm(timer->node.expires);
731                 alarm.enabled = 1;
732                 err = __rtc_set_alarm(rtc, &alarm);
733                 if (err == -ETIME)
734                         schedule_work(&rtc->irqwork);
735                 else if (err) {
736                         timerqueue_del(&rtc->timerqueue, &timer->node);
737                         timer->enabled = 0;
738                         return err;
739                 }
740         }
741         return 0;
742 }
743
744 /**
745  * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue
746  * @rtc rtc device
747  * @timer timer being removed.
748  *
749  * Removes a timer onto the rtc devices timerqueue and sets
750  * the next alarm event appropriately.
751  *
752  * Clears the enabled bit on the removed timer.
753  *
754  * Must hold ops_lock for proper serialization of timerqueue
755  */
756 static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
757 {
758         struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
759         timerqueue_del(&rtc->timerqueue, &timer->node);
760         timer->enabled = 0;
761         if (next == &timer->node) {
762                 struct rtc_wkalrm alarm;
763                 int err;
764                 next = timerqueue_getnext(&rtc->timerqueue);
765                 if (!next)
766                         return;
767                 alarm.time = rtc_ktime_to_tm(next->expires);
768                 alarm.enabled = 1;
769                 err = __rtc_set_alarm(rtc, &alarm);
770                 if (err == -ETIME)
771                         schedule_work(&rtc->irqwork);
772         }
773 }
774
775 /**
776  * rtc_timer_do_work - Expires rtc timers
777  * @rtc rtc device
778  * @timer timer being removed.
779  *
780  * Expires rtc timers. Reprograms next alarm event if needed.
781  * Called via worktask.
782  *
783  * Serializes access to timerqueue via ops_lock mutex
784  */
785 void rtc_timer_do_work(struct work_struct *work)
786 {
787         struct rtc_timer *timer;
788         struct timerqueue_node *next;
789         ktime_t now;
790         struct rtc_time tm;
791
792         struct rtc_device *rtc =
793                 container_of(work, struct rtc_device, irqwork);
794
795         mutex_lock(&rtc->ops_lock);
796 again:
797         __rtc_read_time(rtc, &tm);
798         now = rtc_tm_to_ktime(tm);
799         while ((next = timerqueue_getnext(&rtc->timerqueue))) {
800                 if (next->expires.tv64 > now.tv64)
801                         break;
802
803                 /* expire timer */
804                 timer = container_of(next, struct rtc_timer, node);
805                 timerqueue_del(&rtc->timerqueue, &timer->node);
806                 timer->enabled = 0;
807                 if (timer->task.func)
808                         timer->task.func(timer->task.private_data);
809
810                 /* Re-add/fwd periodic timers */
811                 if (ktime_to_ns(timer->period)) {
812                         timer->node.expires = ktime_add(timer->node.expires,
813                                                         timer->period);
814                         timer->enabled = 1;
815                         timerqueue_add(&rtc->timerqueue, &timer->node);
816                 }
817         }
818
819         /* Set next alarm */
820         if (next) {
821                 struct rtc_wkalrm alarm;
822                 int err;
823                 alarm.time = rtc_ktime_to_tm(next->expires);
824                 alarm.enabled = 1;
825                 err = __rtc_set_alarm(rtc, &alarm);
826                 if (err == -ETIME)
827                         goto again;
828         }
829
830         mutex_unlock(&rtc->ops_lock);
831 }
832
833
834 /* rtc_timer_init - Initializes an rtc_timer
835  * @timer: timer to be intiialized
836  * @f: function pointer to be called when timer fires
837  * @data: private data passed to function pointer
838  *
839  * Kernel interface to initializing an rtc_timer.
840  */
841 void rtc_timer_init(struct rtc_timer *timer, void (*f)(void* p), void* data)
842 {
843         timerqueue_init(&timer->node);
844         timer->enabled = 0;
845         timer->task.func = f;
846         timer->task.private_data = data;
847 }
848
849 /* rtc_timer_start - Sets an rtc_timer to fire in the future
850  * @ rtc: rtc device to be used
851  * @ timer: timer being set
852  * @ expires: time at which to expire the timer
853  * @ period: period that the timer will recur
854  *
855  * Kernel interface to set an rtc_timer
856  */
857 int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer,
858                         ktime_t expires, ktime_t period)
859 {
860         int ret = 0;
861         mutex_lock(&rtc->ops_lock);
862         if (timer->enabled)
863                 rtc_timer_remove(rtc, timer);
864
865         timer->node.expires = expires;
866         timer->period = period;
867
868         ret = rtc_timer_enqueue(rtc, timer);
869
870         mutex_unlock(&rtc->ops_lock);
871         return ret;
872 }
873
874 /* rtc_timer_cancel - Stops an rtc_timer
875  * @ rtc: rtc device to be used
876  * @ timer: timer being set
877  *
878  * Kernel interface to cancel an rtc_timer
879  */
880 int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer* timer)
881 {
882         int ret = 0;
883         mutex_lock(&rtc->ops_lock);
884         if (timer->enabled)
885                 rtc_timer_remove(rtc, timer);
886         mutex_unlock(&rtc->ops_lock);
887         return ret;
888 }
889
890