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