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 mutex_unlock(&rtc->ops_lock);
76
77 schedule_work(&rtc->irqwork);
78 return err;
79}
80EXPORT_SYMBOL_GPL(rtc_set_time);
81
82int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
83{
84 int err;
85
86 err = mutex_lock_interruptible(&rtc->ops_lock);
87 if (err)
88 return err;
89
90 if (!rtc->ops)
91 err = -ENODEV;
92 else if (rtc->ops->set_mmss)
93 err = rtc->ops->set_mmss(rtc->dev.parent, secs);
94 else if (rtc->ops->read_time && rtc->ops->set_time) {
95 struct rtc_time new, old;
96
97 err = rtc->ops->read_time(rtc->dev.parent, &old);
98 if (err == 0) {
99 rtc_time_to_tm(secs, &new);
100
101
102
103
104
105
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
118 schedule_work(&rtc->irqwork);
119
120 return err;
121}
122EXPORT_SYMBOL_GPL(rtc_set_mmss);
123
124static 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
145int __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
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 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
205 err = rtc_read_alarm_internal(rtc, alarm);
206 if (err)
207 return err;
208
209
210 if (rtc_valid_tm(&alarm->time) == 0)
211 return 0;
212
213
214 err = rtc_read_time(rtc, &now);
215 if (err < 0)
216 return err;
217
218
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
225
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
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
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
259
260
261
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
270
271
272
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
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
300done:
301 return 0;
302}
303
304int 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}
324EXPORT_SYMBOL_GPL(rtc_read_alarm);
325
326static 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
338 err = __rtc_read_time(rtc, &tm);
339 rtc_tm_to_time(&tm, &now);
340 if (scheduled <= now)
341 return -ETIME;
342
343
344
345
346
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
359int 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}
381EXPORT_SYMBOL_GPL(rtc_set_alarm);
382
383
384int 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
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}
414EXPORT_SYMBOL_GPL(rtc_initialize_alarm);
415
416
417
418int 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 ;
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}
443EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable);
444
445int 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
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
479out:
480 mutex_unlock(&rtc->ops_lock);
481#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
482
483
484
485
486
487
488 if (err == -EINVAL)
489 err = rtc_dev_update_irq_enable_emul(rtc, enabled);
490#endif
491 return err;
492
493}
494EXPORT_SYMBOL_GPL(rtc_update_irq_enable);
495
496
497
498
499
500
501
502
503
504
505
506void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
507{
508 unsigned long flags;
509
510
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
516 spin_lock_irqsave(&rtc->irq_task_lock, flags);
517 if (rtc->irq_task)
518 rtc->irq_task->func(rtc->irq_task->private_data);
519 spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
520
521 wake_up_interruptible(&rtc->irq_queue);
522 kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
523}
524
525
526
527
528
529
530
531
532void rtc_aie_update_irq(void *private)
533{
534 struct rtc_device *rtc = (struct rtc_device *)private;
535 rtc_handle_legacy_irq(rtc, 1, RTC_AF);
536}
537
538
539
540
541
542
543
544
545void rtc_uie_update_irq(void *private)
546{
547 struct rtc_device *rtc = (struct rtc_device *)private;
548 rtc_handle_legacy_irq(rtc, 1, RTC_UF);
549}
550
551
552
553
554
555
556
557
558
559
560enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
561{
562 struct rtc_device *rtc;
563 ktime_t period;
564 int count;
565 rtc = container_of(timer, struct rtc_device, pie_timer);
566
567 period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq);
568 count = hrtimer_forward_now(timer, period);
569
570 rtc_handle_legacy_irq(rtc, count, RTC_PF);
571
572 return HRTIMER_RESTART;
573}
574
575
576
577
578
579
580
581
582void 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}
588EXPORT_SYMBOL_GPL(rtc_update_irq);
589
590static int __rtc_match(struct device *dev, const void *data)
591{
592 const char *name = data;
593
594 if (strcmp(dev_name(dev), name) == 0)
595 return 1;
596 return 0;
597}
598
599struct rtc_device *rtc_class_open(const char *name)
600{
601 struct device *dev;
602 struct rtc_device *rtc = NULL;
603
604 dev = class_find_device(rtc_class, NULL, name, __rtc_match);
605 if (dev)
606 rtc = to_rtc_device(dev);
607
608 if (rtc) {
609 if (!try_module_get(rtc->owner)) {
610 put_device(dev);
611 rtc = NULL;
612 }
613 }
614
615 return rtc;
616}
617EXPORT_SYMBOL_GPL(rtc_class_open);
618
619void rtc_class_close(struct rtc_device *rtc)
620{
621 module_put(rtc->owner);
622 put_device(&rtc->dev);
623}
624EXPORT_SYMBOL_GPL(rtc_class_close);
625
626int 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
634 if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
635 return -EBUSY;
636
637 spin_lock_irq(&rtc->irq_task_lock);
638 if (rtc->irq_task == NULL) {
639 rtc->irq_task = task;
640 retval = 0;
641 }
642 spin_unlock_irq(&rtc->irq_task_lock);
643
644 clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
645
646 return retval;
647}
648EXPORT_SYMBOL_GPL(rtc_irq_register);
649
650void 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}
657EXPORT_SYMBOL_GPL(rtc_irq_unregister);
658
659static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled)
660{
661
662
663
664
665
666
667
668
669
670
671 if (hrtimer_try_to_cancel(&rtc->pie_timer) < 0)
672 return -1;
673
674 if (enabled) {
675 ktime_t period = ktime_set(0, NSEC_PER_SEC / rtc->irq_freq);
676
677 hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL);
678 }
679 return 0;
680}
681
682
683
684
685
686
687
688
689
690
691
692int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
693{
694 int err = 0;
695 unsigned long flags;
696
697retry:
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}
714EXPORT_SYMBOL_GPL(rtc_irq_set_state);
715
716
717
718
719
720
721
722
723
724
725
726int 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;
733retry:
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}
750EXPORT_SYMBOL_GPL(rtc_irq_set_freq);
751
752
753
754
755
756
757
758
759
760
761
762
763
764static 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
785static void rtc_alarm_disable(struct rtc_device *rtc)
786{
787 if (!rtc->ops || !rtc->ops->alarm_irq_enable)
788 return;
789
790 rtc->ops->alarm_irq_enable(rtc->dev.parent, false);
791}
792
793
794
795
796
797
798
799
800
801
802
803
804
805static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
806{
807 struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
808 timerqueue_del(&rtc->timerqueue, &timer->node);
809 timer->enabled = 0;
810 if (next == &timer->node) {
811 struct rtc_wkalrm alarm;
812 int err;
813 next = timerqueue_getnext(&rtc->timerqueue);
814 if (!next) {
815 rtc_alarm_disable(rtc);
816 return;
817 }
818 alarm.time = rtc_ktime_to_tm(next->expires);
819 alarm.enabled = 1;
820 err = __rtc_set_alarm(rtc, &alarm);
821 if (err == -ETIME)
822 schedule_work(&rtc->irqwork);
823 }
824}
825
826
827
828
829
830
831
832
833
834
835
836void rtc_timer_do_work(struct work_struct *work)
837{
838 struct rtc_timer *timer;
839 struct timerqueue_node *next;
840 ktime_t now;
841 struct rtc_time tm;
842
843 struct rtc_device *rtc =
844 container_of(work, struct rtc_device, irqwork);
845
846 mutex_lock(&rtc->ops_lock);
847again:
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
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
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
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
888
889
890
891
892
893
894void 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
903
904
905
906
907
908
909
910int 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
928
929
930
931
932
933int 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
944