1
2
3
4
5
6
7
8
9
10
11
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
20static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer);
21static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer);
22
23static 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 if (err < 0) {
34 dev_dbg(&rtc->dev, "read_time: fail to read: %d\n",
35 err);
36 return err;
37 }
38
39 err = rtc_valid_tm(tm);
40 if (err < 0)
41 dev_dbg(&rtc->dev, "read_time: rtc_time isn't valid\n");
42 }
43 return err;
44}
45
46int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
47{
48 int err;
49
50 err = mutex_lock_interruptible(&rtc->ops_lock);
51 if (err)
52 return err;
53
54 err = __rtc_read_time(rtc, tm);
55 mutex_unlock(&rtc->ops_lock);
56 return err;
57}
58EXPORT_SYMBOL_GPL(rtc_read_time);
59
60int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
61{
62 int err;
63
64 err = rtc_valid_tm(tm);
65 if (err != 0)
66 return err;
67
68 err = mutex_lock_interruptible(&rtc->ops_lock);
69 if (err)
70 return err;
71
72 if (!rtc->ops)
73 err = -ENODEV;
74 else if (rtc->ops->set_time)
75 err = rtc->ops->set_time(rtc->dev.parent, tm);
76 else if (rtc->ops->set_mmss64) {
77 time64_t secs64 = rtc_tm_to_time64(tm);
78
79 err = rtc->ops->set_mmss64(rtc->dev.parent, secs64);
80 } else if (rtc->ops->set_mmss) {
81 time64_t secs64 = rtc_tm_to_time64(tm);
82 err = rtc->ops->set_mmss(rtc->dev.parent, secs64);
83 } else
84 err = -EINVAL;
85
86 pm_stay_awake(rtc->dev.parent);
87 mutex_unlock(&rtc->ops_lock);
88
89 schedule_work(&rtc->irqwork);
90 return err;
91}
92EXPORT_SYMBOL_GPL(rtc_set_time);
93
94static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
95{
96 int err;
97
98 err = mutex_lock_interruptible(&rtc->ops_lock);
99 if (err)
100 return err;
101
102 if (rtc->ops == NULL)
103 err = -ENODEV;
104 else if (!rtc->ops->read_alarm)
105 err = -EINVAL;
106 else {
107 memset(alarm, 0, sizeof(struct rtc_wkalrm));
108 err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
109 }
110
111 mutex_unlock(&rtc->ops_lock);
112 return err;
113}
114
115int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
116{
117 int err;
118 struct rtc_time before, now;
119 int first_time = 1;
120 time64_t t_now, t_alm;
121 enum { none, day, month, year } missing = none;
122 unsigned days;
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166 err = rtc_read_time(rtc, &before);
167 if (err < 0)
168 return err;
169 do {
170 if (!first_time)
171 memcpy(&before, &now, sizeof(struct rtc_time));
172 first_time = 0;
173
174
175 err = rtc_read_alarm_internal(rtc, alarm);
176 if (err)
177 return err;
178
179
180 if (rtc_valid_tm(&alarm->time) == 0)
181 return 0;
182
183
184 err = rtc_read_time(rtc, &now);
185 if (err < 0)
186 return err;
187
188
189 } while ( before.tm_min != now.tm_min
190 || before.tm_hour != now.tm_hour
191 || before.tm_mon != now.tm_mon
192 || before.tm_year != now.tm_year);
193
194
195
196
197 if (alarm->time.tm_sec == -1)
198 alarm->time.tm_sec = now.tm_sec;
199 if (alarm->time.tm_min == -1)
200 alarm->time.tm_min = now.tm_min;
201 if (alarm->time.tm_hour == -1)
202 alarm->time.tm_hour = now.tm_hour;
203
204
205 if (alarm->time.tm_mday < 1 || alarm->time.tm_mday > 31) {
206 alarm->time.tm_mday = now.tm_mday;
207 missing = day;
208 }
209 if ((unsigned)alarm->time.tm_mon >= 12) {
210 alarm->time.tm_mon = now.tm_mon;
211 if (missing == none)
212 missing = month;
213 }
214 if (alarm->time.tm_year == -1) {
215 alarm->time.tm_year = now.tm_year;
216 if (missing == none)
217 missing = year;
218 }
219
220
221 t_now = rtc_tm_to_time64(&now);
222 t_alm = rtc_tm_to_time64(&alarm->time);
223 if (t_now < t_alm)
224 goto done;
225
226 switch (missing) {
227
228
229
230
231
232
233 case day:
234 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "day");
235 t_alm += 24 * 60 * 60;
236 rtc_time64_to_tm(t_alm, &alarm->time);
237 break;
238
239
240
241
242
243
244 case month:
245 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month");
246 do {
247 if (alarm->time.tm_mon < 11)
248 alarm->time.tm_mon++;
249 else {
250 alarm->time.tm_mon = 0;
251 alarm->time.tm_year++;
252 }
253 days = rtc_month_days(alarm->time.tm_mon,
254 alarm->time.tm_year);
255 } while (days < alarm->time.tm_mday);
256 break;
257
258
259 case year:
260 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year");
261 do {
262 alarm->time.tm_year++;
263 } while (!is_leap_year(alarm->time.tm_year + 1900)
264 && rtc_valid_tm(&alarm->time) != 0);
265 break;
266
267 default:
268 dev_warn(&rtc->dev, "alarm rollover not handled\n");
269 }
270
271done:
272 err = rtc_valid_tm(&alarm->time);
273
274 if (err) {
275 dev_warn(&rtc->dev, "invalid alarm value: %d-%d-%d %d:%d:%d\n",
276 alarm->time.tm_year + 1900, alarm->time.tm_mon + 1,
277 alarm->time.tm_mday, alarm->time.tm_hour, alarm->time.tm_min,
278 alarm->time.tm_sec);
279 }
280
281 return err;
282}
283
284int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
285{
286 int err;
287
288 err = mutex_lock_interruptible(&rtc->ops_lock);
289 if (err)
290 return err;
291 if (rtc->ops == NULL)
292 err = -ENODEV;
293 else if (!rtc->ops->read_alarm)
294 err = -EINVAL;
295 else {
296 memset(alarm, 0, sizeof(struct rtc_wkalrm));
297 alarm->enabled = rtc->aie_timer.enabled;
298 alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires);
299 }
300 mutex_unlock(&rtc->ops_lock);
301
302 return err;
303}
304EXPORT_SYMBOL_GPL(rtc_read_alarm);
305
306static int __rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
307{
308 struct rtc_time tm;
309 time64_t now, scheduled;
310 int err;
311
312 err = rtc_valid_tm(&alarm->time);
313 if (err)
314 return err;
315 scheduled = rtc_tm_to_time64(&alarm->time);
316
317
318 err = __rtc_read_time(rtc, &tm);
319 if (err)
320 return err;
321 now = rtc_tm_to_time64(&tm);
322 if (scheduled <= now)
323 return -ETIME;
324
325
326
327
328
329
330
331 if (!rtc->ops)
332 err = -ENODEV;
333 else if (!rtc->ops->set_alarm)
334 err = -EINVAL;
335 else
336 err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
337
338 return err;
339}
340
341int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
342{
343 int err;
344
345 err = rtc_valid_tm(&alarm->time);
346 if (err != 0)
347 return err;
348
349 err = mutex_lock_interruptible(&rtc->ops_lock);
350 if (err)
351 return err;
352 if (rtc->aie_timer.enabled)
353 rtc_timer_remove(rtc, &rtc->aie_timer);
354
355 rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
356 rtc->aie_timer.period = ktime_set(0, 0);
357 if (alarm->enabled)
358 err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
359
360 mutex_unlock(&rtc->ops_lock);
361 return err;
362}
363EXPORT_SYMBOL_GPL(rtc_set_alarm);
364
365
366int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
367{
368 int err;
369 struct rtc_time now;
370
371 err = rtc_valid_tm(&alarm->time);
372 if (err != 0)
373 return err;
374
375 err = rtc_read_time(rtc, &now);
376 if (err)
377 return err;
378
379 err = mutex_lock_interruptible(&rtc->ops_lock);
380 if (err)
381 return err;
382
383 rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
384 rtc->aie_timer.period = ktime_set(0, 0);
385
386
387 if (alarm->enabled && (rtc_tm_to_ktime(now).tv64 <
388 rtc->aie_timer.node.expires.tv64)) {
389
390 rtc->aie_timer.enabled = 1;
391 timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node);
392 }
393 mutex_unlock(&rtc->ops_lock);
394 return err;
395}
396EXPORT_SYMBOL_GPL(rtc_initialize_alarm);
397
398
399
400int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
401{
402 int err = mutex_lock_interruptible(&rtc->ops_lock);
403 if (err)
404 return err;
405
406 if (rtc->aie_timer.enabled != enabled) {
407 if (enabled)
408 err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
409 else
410 rtc_timer_remove(rtc, &rtc->aie_timer);
411 }
412
413 if (err)
414 ;
415 else if (!rtc->ops)
416 err = -ENODEV;
417 else if (!rtc->ops->alarm_irq_enable)
418 err = -EINVAL;
419 else
420 err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled);
421
422 mutex_unlock(&rtc->ops_lock);
423 return err;
424}
425EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable);
426
427int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
428{
429 int err = mutex_lock_interruptible(&rtc->ops_lock);
430 if (err)
431 return err;
432
433#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
434 if (enabled == 0 && rtc->uie_irq_active) {
435 mutex_unlock(&rtc->ops_lock);
436 return rtc_dev_update_irq_enable_emul(rtc, 0);
437 }
438#endif
439
440 if (rtc->uie_rtctimer.enabled == enabled)
441 goto out;
442
443 if (rtc->uie_unsupported) {
444 err = -EINVAL;
445 goto out;
446 }
447
448 if (enabled) {
449 struct rtc_time tm;
450 ktime_t now, onesec;
451
452 __rtc_read_time(rtc, &tm);
453 onesec = ktime_set(1, 0);
454 now = rtc_tm_to_ktime(tm);
455 rtc->uie_rtctimer.node.expires = ktime_add(now, onesec);
456 rtc->uie_rtctimer.period = ktime_set(1, 0);
457 err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
458 } else
459 rtc_timer_remove(rtc, &rtc->uie_rtctimer);
460
461out:
462 mutex_unlock(&rtc->ops_lock);
463#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
464
465
466
467
468
469
470 if (err == -EINVAL)
471 err = rtc_dev_update_irq_enable_emul(rtc, enabled);
472#endif
473 return err;
474
475}
476EXPORT_SYMBOL_GPL(rtc_update_irq_enable);
477
478
479
480
481
482
483
484
485
486
487
488void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
489{
490 unsigned long flags;
491
492
493 spin_lock_irqsave(&rtc->irq_lock, flags);
494 rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode);
495 spin_unlock_irqrestore(&rtc->irq_lock, flags);
496
497
498 spin_lock_irqsave(&rtc->irq_task_lock, flags);
499 if (rtc->irq_task)
500 rtc->irq_task->func(rtc->irq_task->private_data);
501 spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
502
503 wake_up_interruptible(&rtc->irq_queue);
504 kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
505}
506
507
508
509
510
511
512
513
514void rtc_aie_update_irq(void *private)
515{
516 struct rtc_device *rtc = (struct rtc_device *)private;
517 rtc_handle_legacy_irq(rtc, 1, RTC_AF);
518}
519
520
521
522
523
524
525
526
527void rtc_uie_update_irq(void *private)
528{
529 struct rtc_device *rtc = (struct rtc_device *)private;
530 rtc_handle_legacy_irq(rtc, 1, RTC_UF);
531}
532
533
534
535
536
537
538
539
540
541
542enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
543{
544 struct rtc_device *rtc;
545 ktime_t period;
546 int count;
547 rtc = container_of(timer, struct rtc_device, pie_timer);
548
549 period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq);
550 count = hrtimer_forward_now(timer, period);
551
552 rtc_handle_legacy_irq(rtc, count, RTC_PF);
553
554 return HRTIMER_RESTART;
555}
556
557
558
559
560
561
562
563
564void rtc_update_irq(struct rtc_device *rtc,
565 unsigned long num, unsigned long events)
566{
567 if (IS_ERR_OR_NULL(rtc))
568 return;
569
570 pm_stay_awake(rtc->dev.parent);
571 schedule_work(&rtc->irqwork);
572}
573EXPORT_SYMBOL_GPL(rtc_update_irq);
574
575static int __rtc_match(struct device *dev, const void *data)
576{
577 const char *name = data;
578
579 if (strcmp(dev_name(dev), name) == 0)
580 return 1;
581 return 0;
582}
583
584struct rtc_device *rtc_class_open(const char *name)
585{
586 struct device *dev;
587 struct rtc_device *rtc = NULL;
588
589 dev = class_find_device(rtc_class, NULL, name, __rtc_match);
590 if (dev)
591 rtc = to_rtc_device(dev);
592
593 if (rtc) {
594 if (!try_module_get(rtc->owner)) {
595 put_device(dev);
596 rtc = NULL;
597 }
598 }
599
600 return rtc;
601}
602EXPORT_SYMBOL_GPL(rtc_class_open);
603
604void rtc_class_close(struct rtc_device *rtc)
605{
606 module_put(rtc->owner);
607 put_device(&rtc->dev);
608}
609EXPORT_SYMBOL_GPL(rtc_class_close);
610
611int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task)
612{
613 int retval = -EBUSY;
614
615 if (task == NULL || task->func == NULL)
616 return -EINVAL;
617
618
619 if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
620 return -EBUSY;
621
622 spin_lock_irq(&rtc->irq_task_lock);
623 if (rtc->irq_task == NULL) {
624 rtc->irq_task = task;
625 retval = 0;
626 }
627 spin_unlock_irq(&rtc->irq_task_lock);
628
629 clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
630
631 return retval;
632}
633EXPORT_SYMBOL_GPL(rtc_irq_register);
634
635void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task)
636{
637 spin_lock_irq(&rtc->irq_task_lock);
638 if (rtc->irq_task == task)
639 rtc->irq_task = NULL;
640 spin_unlock_irq(&rtc->irq_task_lock);
641}
642EXPORT_SYMBOL_GPL(rtc_irq_unregister);
643
644static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled)
645{
646
647
648
649
650
651
652
653
654
655
656 if (hrtimer_try_to_cancel(&rtc->pie_timer) < 0)
657 return -1;
658
659 if (enabled) {
660 ktime_t period = ktime_set(0, NSEC_PER_SEC / rtc->irq_freq);
661
662 hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL);
663 }
664 return 0;
665}
666
667
668
669
670
671
672
673
674
675
676
677int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
678{
679 int err = 0;
680 unsigned long flags;
681
682retry:
683 spin_lock_irqsave(&rtc->irq_task_lock, flags);
684 if (rtc->irq_task != NULL && task == NULL)
685 err = -EBUSY;
686 else if (rtc->irq_task != task)
687 err = -EACCES;
688 else {
689 if (rtc_update_hrtimer(rtc, enabled) < 0) {
690 spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
691 cpu_relax();
692 goto retry;
693 }
694 rtc->pie_enabled = enabled;
695 }
696 spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
697 return err;
698}
699EXPORT_SYMBOL_GPL(rtc_irq_set_state);
700
701
702
703
704
705
706
707
708
709
710
711int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
712{
713 int err = 0;
714 unsigned long flags;
715
716 if (freq <= 0 || freq > RTC_MAX_FREQ)
717 return -EINVAL;
718retry:
719 spin_lock_irqsave(&rtc->irq_task_lock, flags);
720 if (rtc->irq_task != NULL && task == NULL)
721 err = -EBUSY;
722 else if (rtc->irq_task != task)
723 err = -EACCES;
724 else {
725 rtc->irq_freq = freq;
726 if (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0) {
727 spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
728 cpu_relax();
729 goto retry;
730 }
731 }
732 spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
733 return err;
734}
735EXPORT_SYMBOL_GPL(rtc_irq_set_freq);
736
737
738
739
740
741
742
743
744
745
746
747
748
749static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
750{
751 timer->enabled = 1;
752 timerqueue_add(&rtc->timerqueue, &timer->node);
753 if (&timer->node == timerqueue_getnext(&rtc->timerqueue)) {
754 struct rtc_wkalrm alarm;
755 int err;
756 alarm.time = rtc_ktime_to_tm(timer->node.expires);
757 alarm.enabled = 1;
758 err = __rtc_set_alarm(rtc, &alarm);
759 if (err == -ETIME) {
760 pm_stay_awake(rtc->dev.parent);
761 schedule_work(&rtc->irqwork);
762 } else if (err) {
763 timerqueue_del(&rtc->timerqueue, &timer->node);
764 timer->enabled = 0;
765 return err;
766 }
767 }
768 return 0;
769}
770
771static void rtc_alarm_disable(struct rtc_device *rtc)
772{
773 if (!rtc->ops || !rtc->ops->alarm_irq_enable)
774 return;
775
776 rtc->ops->alarm_irq_enable(rtc->dev.parent, false);
777}
778
779
780
781
782
783
784
785
786
787
788
789
790
791static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
792{
793 struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
794 timerqueue_del(&rtc->timerqueue, &timer->node);
795 timer->enabled = 0;
796 if (next == &timer->node) {
797 struct rtc_wkalrm alarm;
798 int err;
799 next = timerqueue_getnext(&rtc->timerqueue);
800 if (!next) {
801 rtc_alarm_disable(rtc);
802 return;
803 }
804 alarm.time = rtc_ktime_to_tm(next->expires);
805 alarm.enabled = 1;
806 err = __rtc_set_alarm(rtc, &alarm);
807 if (err == -ETIME) {
808 pm_stay_awake(rtc->dev.parent);
809 schedule_work(&rtc->irqwork);
810 }
811 }
812}
813
814
815
816
817
818
819
820
821
822
823
824void rtc_timer_do_work(struct work_struct *work)
825{
826 struct rtc_timer *timer;
827 struct timerqueue_node *next;
828 ktime_t now;
829 struct rtc_time tm;
830
831 struct rtc_device *rtc =
832 container_of(work, struct rtc_device, irqwork);
833
834 mutex_lock(&rtc->ops_lock);
835again:
836 __rtc_read_time(rtc, &tm);
837 now = rtc_tm_to_ktime(tm);
838 while ((next = timerqueue_getnext(&rtc->timerqueue))) {
839 if (next->expires.tv64 > now.tv64)
840 break;
841
842
843 timer = container_of(next, struct rtc_timer, node);
844 timerqueue_del(&rtc->timerqueue, &timer->node);
845 timer->enabled = 0;
846 if (timer->task.func)
847 timer->task.func(timer->task.private_data);
848
849
850 if (ktime_to_ns(timer->period)) {
851 timer->node.expires = ktime_add(timer->node.expires,
852 timer->period);
853 timer->enabled = 1;
854 timerqueue_add(&rtc->timerqueue, &timer->node);
855 }
856 }
857
858
859 if (next) {
860 struct rtc_wkalrm alarm;
861 int err;
862 int retry = 3;
863
864 alarm.time = rtc_ktime_to_tm(next->expires);
865 alarm.enabled = 1;
866reprogram:
867 err = __rtc_set_alarm(rtc, &alarm);
868 if (err == -ETIME)
869 goto again;
870 else if (err) {
871 if (retry-- > 0)
872 goto reprogram;
873
874 timer = container_of(next, struct rtc_timer, node);
875 timerqueue_del(&rtc->timerqueue, &timer->node);
876 timer->enabled = 0;
877 dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err);
878 goto again;
879 }
880 } else
881 rtc_alarm_disable(rtc);
882
883 pm_relax(rtc->dev.parent);
884 mutex_unlock(&rtc->ops_lock);
885}
886
887
888
889
890
891
892
893
894
895void rtc_timer_init(struct rtc_timer *timer, void (*f)(void *p), void *data)
896{
897 timerqueue_init(&timer->node);
898 timer->enabled = 0;
899 timer->task.func = f;
900 timer->task.private_data = data;
901}
902
903
904
905
906
907
908
909
910
911int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer,
912 ktime_t expires, ktime_t period)
913{
914 int ret = 0;
915 mutex_lock(&rtc->ops_lock);
916 if (timer->enabled)
917 rtc_timer_remove(rtc, timer);
918
919 timer->node.expires = expires;
920 timer->period = period;
921
922 ret = rtc_timer_enqueue(rtc, timer);
923
924 mutex_unlock(&rtc->ops_lock);
925 return ret;
926}
927
928
929
930
931
932
933
934void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer)
935{
936 mutex_lock(&rtc->ops_lock);
937 if (timer->enabled)
938 rtc_timer_remove(rtc, timer);
939 mutex_unlock(&rtc->ops_lock);
940}
941
942
943
944
945
946
947
948
949
950
951
952
953int rtc_read_offset(struct rtc_device *rtc, long *offset)
954{
955 int ret;
956
957 if (!rtc->ops)
958 return -ENODEV;
959
960 if (!rtc->ops->read_offset)
961 return -EINVAL;
962
963 mutex_lock(&rtc->ops_lock);
964 ret = rtc->ops->read_offset(rtc->dev.parent, offset);
965 mutex_unlock(&rtc->ops_lock);
966 return ret;
967}
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982int rtc_set_offset(struct rtc_device *rtc, long offset)
983{
984 int ret;
985
986 if (!rtc->ops)
987 return -ENODEV;
988
989 if (!rtc->ops->set_offset)
990 return -EINVAL;
991
992 mutex_lock(&rtc->ops_lock);
993 ret = rtc->ops->set_offset(rtc->dev.parent, offset);
994 mutex_unlock(&rtc->ops_lock);
995 return ret;
996}
997