Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
interface.c
Go to the documentation of this file.
1 /*
2  * RTC subsystem, interface functions
3  *
4  * Copyright (C) 2005 Tower Technologies
5  * Author: Alessandro Zummo <[email protected]>
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 
42  if (err)
43  return err;
44 
45  err = __rtc_read_time(rtc, tm);
46  mutex_unlock(&rtc->ops_lock);
47  return err;
48 }
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 
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 }
81 
82 int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
83 {
84  int err;
85 
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 }
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 }
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 }
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 }
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 }
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 }
495 
496 
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 
523 }
524 
525 
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 
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 
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 
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 }
589 
590 static int __rtc_match(struct device *dev, void *data)
591 {
592  char *name = (char *)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(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 }
618 
619 void rtc_class_close(struct rtc_device *rtc)
620 {
621  module_put(rtc->owner);
622  put_device(&rtc->dev);
623 }
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 */
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 
645 
646  return retval;
647 }
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 }
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 
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 }
715 
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 }
751 
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 
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 
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