1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54#define RTC_VERSION "1.12b"
55
56
57
58
59
60
61
62
63
64#include <linux/interrupt.h>
65#include <linux/module.h>
66#include <linux/kernel.h>
67#include <linux/types.h>
68#include <linux/miscdevice.h>
69#include <linux/ioport.h>
70#include <linux/fcntl.h>
71#include <linux/mc146818rtc.h>
72#include <linux/init.h>
73#include <linux/poll.h>
74#include <linux/proc_fs.h>
75#include <linux/seq_file.h>
76#include <linux/spinlock.h>
77#include <linux/sched/signal.h>
78#include <linux/sysctl.h>
79#include <linux/wait.h>
80#include <linux/bcd.h>
81#include <linux/delay.h>
82#include <linux/uaccess.h>
83#include <linux/ratelimit.h>
84
85#include <asm/current.h>
86
87#ifdef CONFIG_X86
88#include <asm/hpet.h>
89#endif
90
91#ifdef CONFIG_SPARC32
92#include <linux/of.h>
93#include <linux/of_device.h>
94#include <asm/io.h>
95
96static unsigned long rtc_port;
97static int rtc_irq;
98#endif
99
100#ifdef CONFIG_HPET_EMULATE_RTC
101#undef RTC_IRQ
102#endif
103
104#ifdef RTC_IRQ
105static int rtc_has_irq = 1;
106#endif
107
108#ifndef CONFIG_HPET_EMULATE_RTC
109#define is_hpet_enabled() 0
110#define hpet_set_alarm_time(hrs, min, sec) 0
111#define hpet_set_periodic_freq(arg) 0
112#define hpet_mask_rtc_irq_bit(arg) 0
113#define hpet_set_rtc_irq_bit(arg) 0
114#define hpet_rtc_timer_init() do { } while (0)
115#define hpet_rtc_dropped_irq() 0
116#define hpet_register_irq_handler(h) ({ 0; })
117#define hpet_unregister_irq_handler(h) ({ 0; })
118#ifdef RTC_IRQ
119static irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
120{
121 return 0;
122}
123#endif
124#endif
125
126
127
128
129
130
131
132
133static struct fasync_struct *rtc_async_queue;
134
135static DECLARE_WAIT_QUEUE_HEAD(rtc_wait);
136
137#ifdef RTC_IRQ
138static void rtc_dropped_irq(struct timer_list *unused);
139
140static DEFINE_TIMER(rtc_irq_timer, rtc_dropped_irq);
141#endif
142
143static ssize_t rtc_read(struct file *file, char __user *buf,
144 size_t count, loff_t *ppos);
145
146static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
147static void rtc_get_rtc_time(struct rtc_time *rtc_tm);
148
149#ifdef RTC_IRQ
150static __poll_t rtc_poll(struct file *file, poll_table *wait);
151#endif
152
153static void get_rtc_alm_time(struct rtc_time *alm_tm);
154#ifdef RTC_IRQ
155static void set_rtc_irq_bit_locked(unsigned char bit);
156static void mask_rtc_irq_bit_locked(unsigned char bit);
157
158static inline void set_rtc_irq_bit(unsigned char bit)
159{
160 spin_lock_irq(&rtc_lock);
161 set_rtc_irq_bit_locked(bit);
162 spin_unlock_irq(&rtc_lock);
163}
164
165static void mask_rtc_irq_bit(unsigned char bit)
166{
167 spin_lock_irq(&rtc_lock);
168 mask_rtc_irq_bit_locked(bit);
169 spin_unlock_irq(&rtc_lock);
170}
171#endif
172
173#ifdef CONFIG_PROC_FS
174static int rtc_proc_open(struct inode *inode, struct file *file);
175#endif
176
177
178
179
180
181#define RTC_IS_OPEN 0x01
182#define RTC_TIMER_ON 0x02
183
184
185
186
187
188
189
190
191static unsigned long rtc_status;
192static unsigned long rtc_freq;
193static unsigned long rtc_irq_data;
194static unsigned long rtc_max_user_freq = 64;
195
196#ifdef RTC_IRQ
197
198
199
200static DEFINE_SPINLOCK(rtc_task_lock);
201static rtc_task_t *rtc_callback;
202#endif
203
204
205
206
207
208
209static unsigned long epoch = 1900;
210
211static const unsigned char days_in_mo[] =
212{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
213
214
215
216
217static inline unsigned char rtc_is_updating(void)
218{
219 unsigned long flags;
220 unsigned char uip;
221
222 spin_lock_irqsave(&rtc_lock, flags);
223 uip = (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP);
224 spin_unlock_irqrestore(&rtc_lock, flags);
225 return uip;
226}
227
228#ifdef RTC_IRQ
229
230
231
232
233
234
235
236
237
238
239static irqreturn_t rtc_interrupt(int irq, void *dev_id)
240{
241
242
243
244
245
246
247
248 spin_lock(&rtc_lock);
249 rtc_irq_data += 0x100;
250 rtc_irq_data &= ~0xff;
251 if (is_hpet_enabled()) {
252
253
254
255
256
257 rtc_irq_data |= (unsigned long)irq & 0xF0;
258 } else {
259 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
260 }
261
262 if (rtc_status & RTC_TIMER_ON)
263 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
264
265 spin_unlock(&rtc_lock);
266
267
268 spin_lock(&rtc_task_lock);
269 if (rtc_callback)
270 rtc_callback->func(rtc_callback->private_data);
271 spin_unlock(&rtc_task_lock);
272 wake_up_interruptible(&rtc_wait);
273
274 kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
275
276 return IRQ_HANDLED;
277}
278#endif
279
280
281
282
283static struct ctl_table rtc_table[] = {
284 {
285 .procname = "max-user-freq",
286 .data = &rtc_max_user_freq,
287 .maxlen = sizeof(int),
288 .mode = 0644,
289 .proc_handler = proc_dointvec,
290 },
291 { }
292};
293
294static struct ctl_table rtc_root[] = {
295 {
296 .procname = "rtc",
297 .mode = 0555,
298 .child = rtc_table,
299 },
300 { }
301};
302
303static struct ctl_table dev_root[] = {
304 {
305 .procname = "dev",
306 .mode = 0555,
307 .child = rtc_root,
308 },
309 { }
310};
311
312static struct ctl_table_header *sysctl_header;
313
314static int __init init_sysctl(void)
315{
316 sysctl_header = register_sysctl_table(dev_root);
317 return 0;
318}
319
320static void __exit cleanup_sysctl(void)
321{
322 unregister_sysctl_table(sysctl_header);
323}
324
325
326
327
328
329static ssize_t rtc_read(struct file *file, char __user *buf,
330 size_t count, loff_t *ppos)
331{
332#ifndef RTC_IRQ
333 return -EIO;
334#else
335 DECLARE_WAITQUEUE(wait, current);
336 unsigned long data;
337 ssize_t retval;
338
339 if (rtc_has_irq == 0)
340 return -EIO;
341
342
343
344
345
346
347
348
349
350 if (count != sizeof(unsigned int) && count != sizeof(unsigned long))
351 return -EINVAL;
352
353 add_wait_queue(&rtc_wait, &wait);
354
355 do {
356
357
358
359
360 __set_current_state(TASK_INTERRUPTIBLE);
361
362 spin_lock_irq(&rtc_lock);
363 data = rtc_irq_data;
364 rtc_irq_data = 0;
365 spin_unlock_irq(&rtc_lock);
366
367 if (data != 0)
368 break;
369
370 if (file->f_flags & O_NONBLOCK) {
371 retval = -EAGAIN;
372 goto out;
373 }
374 if (signal_pending(current)) {
375 retval = -ERESTARTSYS;
376 goto out;
377 }
378 schedule();
379 } while (1);
380
381 if (count == sizeof(unsigned int)) {
382 retval = put_user(data,
383 (unsigned int __user *)buf) ?: sizeof(int);
384 } else {
385 retval = put_user(data,
386 (unsigned long __user *)buf) ?: sizeof(long);
387 }
388 if (!retval)
389 retval = count;
390 out:
391 __set_current_state(TASK_RUNNING);
392 remove_wait_queue(&rtc_wait, &wait);
393
394 return retval;
395#endif
396}
397
398static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
399{
400 struct rtc_time wtime;
401
402#ifdef RTC_IRQ
403 if (rtc_has_irq == 0) {
404 switch (cmd) {
405 case RTC_AIE_OFF:
406 case RTC_AIE_ON:
407 case RTC_PIE_OFF:
408 case RTC_PIE_ON:
409 case RTC_UIE_OFF:
410 case RTC_UIE_ON:
411 case RTC_IRQP_READ:
412 case RTC_IRQP_SET:
413 return -EINVAL;
414 }
415 }
416#endif
417
418 switch (cmd) {
419#ifdef RTC_IRQ
420 case RTC_AIE_OFF:
421 {
422 mask_rtc_irq_bit(RTC_AIE);
423 return 0;
424 }
425 case RTC_AIE_ON:
426 {
427 set_rtc_irq_bit(RTC_AIE);
428 return 0;
429 }
430 case RTC_PIE_OFF:
431 {
432
433 unsigned long flags;
434
435 spin_lock_irqsave(&rtc_lock, flags);
436 mask_rtc_irq_bit_locked(RTC_PIE);
437 if (rtc_status & RTC_TIMER_ON) {
438 rtc_status &= ~RTC_TIMER_ON;
439 del_timer(&rtc_irq_timer);
440 }
441 spin_unlock_irqrestore(&rtc_lock, flags);
442
443 return 0;
444 }
445 case RTC_PIE_ON:
446 {
447
448 unsigned long flags;
449
450
451
452
453
454 if (!kernel && (rtc_freq > rtc_max_user_freq) &&
455 (!capable(CAP_SYS_RESOURCE)))
456 return -EACCES;
457
458 spin_lock_irqsave(&rtc_lock, flags);
459 if (!(rtc_status & RTC_TIMER_ON)) {
460 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq +
461 2*HZ/100);
462 rtc_status |= RTC_TIMER_ON;
463 }
464 set_rtc_irq_bit_locked(RTC_PIE);
465 spin_unlock_irqrestore(&rtc_lock, flags);
466
467 return 0;
468 }
469 case RTC_UIE_OFF:
470 {
471 mask_rtc_irq_bit(RTC_UIE);
472 return 0;
473 }
474 case RTC_UIE_ON:
475 {
476 set_rtc_irq_bit(RTC_UIE);
477 return 0;
478 }
479#endif
480 case RTC_ALM_READ:
481 {
482
483
484
485
486
487 memset(&wtime, 0, sizeof(struct rtc_time));
488 get_rtc_alm_time(&wtime);
489 break;
490 }
491 case RTC_ALM_SET:
492 {
493
494
495
496
497
498 unsigned char hrs, min, sec;
499 struct rtc_time alm_tm;
500
501 if (copy_from_user(&alm_tm, (struct rtc_time __user *)arg,
502 sizeof(struct rtc_time)))
503 return -EFAULT;
504
505 hrs = alm_tm.tm_hour;
506 min = alm_tm.tm_min;
507 sec = alm_tm.tm_sec;
508
509 spin_lock_irq(&rtc_lock);
510 if (hpet_set_alarm_time(hrs, min, sec)) {
511
512
513
514
515 }
516 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) ||
517 RTC_ALWAYS_BCD) {
518 if (sec < 60)
519 sec = bin2bcd(sec);
520 else
521 sec = 0xff;
522
523 if (min < 60)
524 min = bin2bcd(min);
525 else
526 min = 0xff;
527
528 if (hrs < 24)
529 hrs = bin2bcd(hrs);
530 else
531 hrs = 0xff;
532 }
533 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
534 CMOS_WRITE(min, RTC_MINUTES_ALARM);
535 CMOS_WRITE(sec, RTC_SECONDS_ALARM);
536 spin_unlock_irq(&rtc_lock);
537
538 return 0;
539 }
540 case RTC_RD_TIME:
541 {
542 memset(&wtime, 0, sizeof(struct rtc_time));
543 rtc_get_rtc_time(&wtime);
544 break;
545 }
546 case RTC_SET_TIME:
547 {
548 struct rtc_time rtc_tm;
549 unsigned char mon, day, hrs, min, sec, leap_yr;
550 unsigned char save_control, save_freq_select;
551 unsigned int yrs;
552#ifdef CONFIG_MACH_DECSTATION
553 unsigned int real_yrs;
554#endif
555
556 if (!capable(CAP_SYS_TIME))
557 return -EACCES;
558
559 if (copy_from_user(&rtc_tm, (struct rtc_time __user *)arg,
560 sizeof(struct rtc_time)))
561 return -EFAULT;
562
563 yrs = rtc_tm.tm_year + 1900;
564 mon = rtc_tm.tm_mon + 1;
565 day = rtc_tm.tm_mday;
566 hrs = rtc_tm.tm_hour;
567 min = rtc_tm.tm_min;
568 sec = rtc_tm.tm_sec;
569
570 if (yrs < 1970)
571 return -EINVAL;
572
573 leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
574
575 if ((mon > 12) || (day == 0))
576 return -EINVAL;
577
578 if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
579 return -EINVAL;
580
581 if ((hrs >= 24) || (min >= 60) || (sec >= 60))
582 return -EINVAL;
583
584 yrs -= epoch;
585 if (yrs > 255)
586 return -EINVAL;
587
588 spin_lock_irq(&rtc_lock);
589#ifdef CONFIG_MACH_DECSTATION
590 real_yrs = yrs;
591 yrs = 72;
592
593
594
595
596
597
598 if (!leap_yr && mon < 3) {
599 real_yrs--;
600 yrs = 73;
601 }
602#endif
603
604
605
606 if (yrs > 169) {
607 spin_unlock_irq(&rtc_lock);
608 return -EINVAL;
609 }
610 if (yrs >= 100)
611 yrs -= 100;
612
613 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)
614 || RTC_ALWAYS_BCD) {
615 sec = bin2bcd(sec);
616 min = bin2bcd(min);
617 hrs = bin2bcd(hrs);
618 day = bin2bcd(day);
619 mon = bin2bcd(mon);
620 yrs = bin2bcd(yrs);
621 }
622
623 save_control = CMOS_READ(RTC_CONTROL);
624 CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
625 save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
626 CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
627
628#ifdef CONFIG_MACH_DECSTATION
629 CMOS_WRITE(real_yrs, RTC_DEC_YEAR);
630#endif
631 CMOS_WRITE(yrs, RTC_YEAR);
632 CMOS_WRITE(mon, RTC_MONTH);
633 CMOS_WRITE(day, RTC_DAY_OF_MONTH);
634 CMOS_WRITE(hrs, RTC_HOURS);
635 CMOS_WRITE(min, RTC_MINUTES);
636 CMOS_WRITE(sec, RTC_SECONDS);
637
638 CMOS_WRITE(save_control, RTC_CONTROL);
639 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
640
641 spin_unlock_irq(&rtc_lock);
642 return 0;
643 }
644#ifdef RTC_IRQ
645 case RTC_IRQP_READ:
646 {
647 return put_user(rtc_freq, (unsigned long __user *)arg);
648 }
649 case RTC_IRQP_SET:
650 {
651 int tmp = 0;
652 unsigned char val;
653
654 unsigned long flags;
655
656
657
658
659 if ((arg < 2) || (arg > 8192))
660 return -EINVAL;
661
662
663
664
665 if (!kernel && (arg > rtc_max_user_freq) &&
666 !capable(CAP_SYS_RESOURCE))
667 return -EACCES;
668
669 while (arg > (1<<tmp))
670 tmp++;
671
672
673
674
675 if (arg != (1<<tmp))
676 return -EINVAL;
677
678 rtc_freq = arg;
679
680 spin_lock_irqsave(&rtc_lock, flags);
681 if (hpet_set_periodic_freq(arg)) {
682 spin_unlock_irqrestore(&rtc_lock, flags);
683 return 0;
684 }
685
686 val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0;
687 val |= (16 - tmp);
688 CMOS_WRITE(val, RTC_FREQ_SELECT);
689 spin_unlock_irqrestore(&rtc_lock, flags);
690 return 0;
691 }
692#endif
693 case RTC_EPOCH_READ:
694 {
695 return put_user(epoch, (unsigned long __user *)arg);
696 }
697 case RTC_EPOCH_SET:
698 {
699
700
701
702 if (arg < 1900)
703 return -EINVAL;
704
705 if (!capable(CAP_SYS_TIME))
706 return -EACCES;
707
708 epoch = arg;
709 return 0;
710 }
711 default:
712 return -ENOTTY;
713 }
714 return copy_to_user((void __user *)arg,
715 &wtime, sizeof wtime) ? -EFAULT : 0;
716}
717
718static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
719{
720 long ret;
721 ret = rtc_do_ioctl(cmd, arg, 0);
722 return ret;
723}
724
725
726
727
728
729
730static int rtc_open(struct inode *inode, struct file *file)
731{
732 spin_lock_irq(&rtc_lock);
733
734 if (rtc_status & RTC_IS_OPEN)
735 goto out_busy;
736
737 rtc_status |= RTC_IS_OPEN;
738
739 rtc_irq_data = 0;
740 spin_unlock_irq(&rtc_lock);
741 return 0;
742
743out_busy:
744 spin_unlock_irq(&rtc_lock);
745 return -EBUSY;
746}
747
748static int rtc_fasync(int fd, struct file *filp, int on)
749{
750 return fasync_helper(fd, filp, on, &rtc_async_queue);
751}
752
753static int rtc_release(struct inode *inode, struct file *file)
754{
755#ifdef RTC_IRQ
756 unsigned char tmp;
757
758 if (rtc_has_irq == 0)
759 goto no_irq;
760
761
762
763
764
765
766 spin_lock_irq(&rtc_lock);
767 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
768 tmp = CMOS_READ(RTC_CONTROL);
769 tmp &= ~RTC_PIE;
770 tmp &= ~RTC_AIE;
771 tmp &= ~RTC_UIE;
772 CMOS_WRITE(tmp, RTC_CONTROL);
773 CMOS_READ(RTC_INTR_FLAGS);
774 }
775 if (rtc_status & RTC_TIMER_ON) {
776 rtc_status &= ~RTC_TIMER_ON;
777 del_timer(&rtc_irq_timer);
778 }
779 spin_unlock_irq(&rtc_lock);
780
781no_irq:
782#endif
783
784 spin_lock_irq(&rtc_lock);
785 rtc_irq_data = 0;
786 rtc_status &= ~RTC_IS_OPEN;
787 spin_unlock_irq(&rtc_lock);
788
789 return 0;
790}
791
792#ifdef RTC_IRQ
793static __poll_t rtc_poll(struct file *file, poll_table *wait)
794{
795 unsigned long l;
796
797 if (rtc_has_irq == 0)
798 return 0;
799
800 poll_wait(file, &rtc_wait, wait);
801
802 spin_lock_irq(&rtc_lock);
803 l = rtc_irq_data;
804 spin_unlock_irq(&rtc_lock);
805
806 if (l != 0)
807 return EPOLLIN | EPOLLRDNORM;
808 return 0;
809}
810#endif
811
812
813
814
815
816static const struct file_operations rtc_fops = {
817 .owner = THIS_MODULE,
818 .llseek = no_llseek,
819 .read = rtc_read,
820#ifdef RTC_IRQ
821 .poll = rtc_poll,
822#endif
823 .unlocked_ioctl = rtc_ioctl,
824 .open = rtc_open,
825 .release = rtc_release,
826 .fasync = rtc_fasync,
827};
828
829static struct miscdevice rtc_dev = {
830 .minor = RTC_MINOR,
831 .name = "rtc",
832 .fops = &rtc_fops,
833};
834
835#ifdef CONFIG_PROC_FS
836static const struct file_operations rtc_proc_fops = {
837 .owner = THIS_MODULE,
838 .open = rtc_proc_open,
839 .read = seq_read,
840 .llseek = seq_lseek,
841 .release = single_release,
842};
843#endif
844
845static resource_size_t rtc_size;
846
847static struct resource * __init rtc_request_region(resource_size_t size)
848{
849 struct resource *r;
850
851 if (RTC_IOMAPPED)
852 r = request_region(RTC_PORT(0), size, "rtc");
853 else
854 r = request_mem_region(RTC_PORT(0), size, "rtc");
855
856 if (r)
857 rtc_size = size;
858
859 return r;
860}
861
862static void rtc_release_region(void)
863{
864 if (RTC_IOMAPPED)
865 release_region(RTC_PORT(0), rtc_size);
866 else
867 release_mem_region(RTC_PORT(0), rtc_size);
868}
869
870static int __init rtc_init(void)
871{
872#ifdef CONFIG_PROC_FS
873 struct proc_dir_entry *ent;
874#endif
875#if defined(__alpha__) || defined(__mips__)
876 unsigned int year, ctrl;
877 char *guess = NULL;
878#endif
879#ifdef CONFIG_SPARC32
880 struct device_node *ebus_dp;
881 struct platform_device *op;
882#else
883 void *r;
884#ifdef RTC_IRQ
885 irq_handler_t rtc_int_handler_ptr;
886#endif
887#endif
888
889#ifdef CONFIG_SPARC32
890 for_each_node_by_name(ebus_dp, "ebus") {
891 struct device_node *dp;
892 for (dp = ebus_dp; dp; dp = dp->sibling) {
893 if (!strcmp(dp->name, "rtc")) {
894 op = of_find_device_by_node(dp);
895 if (op) {
896 rtc_port = op->resource[0].start;
897 rtc_irq = op->irqs[0];
898 goto found;
899 }
900 }
901 }
902 }
903 rtc_has_irq = 0;
904 printk(KERN_ERR "rtc_init: no PC rtc found\n");
905 return -EIO;
906
907found:
908 if (!rtc_irq) {
909 rtc_has_irq = 0;
910 goto no_irq;
911 }
912
913
914
915
916
917 if (request_irq(rtc_irq, rtc_interrupt, IRQF_SHARED, "rtc",
918 (void *)&rtc_port)) {
919 rtc_has_irq = 0;
920 printk(KERN_ERR "rtc: cannot register IRQ %d\n", rtc_irq);
921 return -EIO;
922 }
923no_irq:
924#else
925 r = rtc_request_region(RTC_IO_EXTENT);
926
927
928
929
930
931
932
933
934 if (!r)
935 r = rtc_request_region(RTC_IO_EXTENT_USED);
936 if (!r) {
937#ifdef RTC_IRQ
938 rtc_has_irq = 0;
939#endif
940 printk(KERN_ERR "rtc: I/O resource %lx is not free.\n",
941 (long)(RTC_PORT(0)));
942 return -EIO;
943 }
944
945#ifdef RTC_IRQ
946 if (is_hpet_enabled()) {
947 int err;
948
949 rtc_int_handler_ptr = hpet_rtc_interrupt;
950 err = hpet_register_irq_handler(rtc_interrupt);
951 if (err != 0) {
952 printk(KERN_WARNING "hpet_register_irq_handler failed "
953 "in rtc_init().");
954 return err;
955 }
956 } else {
957 rtc_int_handler_ptr = rtc_interrupt;
958 }
959
960 if (request_irq(RTC_IRQ, rtc_int_handler_ptr, 0, "rtc", NULL)) {
961
962 rtc_has_irq = 0;
963 printk(KERN_ERR "rtc: IRQ %d is not free.\n", RTC_IRQ);
964 rtc_release_region();
965
966 return -EIO;
967 }
968 hpet_rtc_timer_init();
969
970#endif
971
972#endif
973
974 if (misc_register(&rtc_dev)) {
975#ifdef RTC_IRQ
976 free_irq(RTC_IRQ, NULL);
977 hpet_unregister_irq_handler(rtc_interrupt);
978 rtc_has_irq = 0;
979#endif
980 rtc_release_region();
981 return -ENODEV;
982 }
983
984#ifdef CONFIG_PROC_FS
985 ent = proc_create("driver/rtc", 0, NULL, &rtc_proc_fops);
986 if (!ent)
987 printk(KERN_WARNING "rtc: Failed to register with procfs.\n");
988#endif
989
990#if defined(__alpha__) || defined(__mips__)
991 rtc_freq = HZ;
992
993
994
995
996 if (rtc_is_updating() != 0)
997 msleep(20);
998
999 spin_lock_irq(&rtc_lock);
1000 year = CMOS_READ(RTC_YEAR);
1001 ctrl = CMOS_READ(RTC_CONTROL);
1002 spin_unlock_irq(&rtc_lock);
1003
1004 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1005 year = bcd2bin(year);
1006
1007 if (year < 20) {
1008 epoch = 2000;
1009 guess = "SRM (post-2000)";
1010 } else if (year >= 20 && year < 48) {
1011 epoch = 1980;
1012 guess = "ARC console";
1013 } else if (year >= 48 && year < 72) {
1014 epoch = 1952;
1015 guess = "Digital UNIX";
1016#if defined(__mips__)
1017 } else if (year >= 72 && year < 74) {
1018 epoch = 2000;
1019 guess = "Digital DECstation";
1020#else
1021 } else if (year >= 70) {
1022 epoch = 1900;
1023 guess = "Standard PC (1900)";
1024#endif
1025 }
1026 if (guess)
1027 printk(KERN_INFO "rtc: %s epoch (%lu) detected\n",
1028 guess, epoch);
1029#endif
1030#ifdef RTC_IRQ
1031 if (rtc_has_irq == 0)
1032 goto no_irq2;
1033
1034 spin_lock_irq(&rtc_lock);
1035 rtc_freq = 1024;
1036 if (!hpet_set_periodic_freq(rtc_freq)) {
1037
1038
1039
1040
1041 CMOS_WRITE(((CMOS_READ(RTC_FREQ_SELECT) & 0xF0) | 0x06),
1042 RTC_FREQ_SELECT);
1043 }
1044 spin_unlock_irq(&rtc_lock);
1045no_irq2:
1046#endif
1047
1048 (void) init_sysctl();
1049
1050 printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n");
1051
1052 return 0;
1053}
1054
1055static void __exit rtc_exit(void)
1056{
1057 cleanup_sysctl();
1058 remove_proc_entry("driver/rtc", NULL);
1059 misc_deregister(&rtc_dev);
1060
1061#ifdef CONFIG_SPARC32
1062 if (rtc_has_irq)
1063 free_irq(rtc_irq, &rtc_port);
1064#else
1065 rtc_release_region();
1066#ifdef RTC_IRQ
1067 if (rtc_has_irq) {
1068 free_irq(RTC_IRQ, NULL);
1069 hpet_unregister_irq_handler(hpet_rtc_interrupt);
1070 }
1071#endif
1072#endif
1073}
1074
1075module_init(rtc_init);
1076module_exit(rtc_exit);
1077
1078#ifdef RTC_IRQ
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091static void rtc_dropped_irq(struct timer_list *unused)
1092{
1093 unsigned long freq;
1094
1095 spin_lock_irq(&rtc_lock);
1096
1097 if (hpet_rtc_dropped_irq()) {
1098 spin_unlock_irq(&rtc_lock);
1099 return;
1100 }
1101
1102
1103 if (rtc_status & RTC_TIMER_ON)
1104 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
1105
1106 rtc_irq_data += ((rtc_freq/HZ)<<8);
1107 rtc_irq_data &= ~0xff;
1108 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
1109
1110 freq = rtc_freq;
1111
1112 spin_unlock_irq(&rtc_lock);
1113
1114 printk_ratelimited(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n",
1115 freq);
1116
1117
1118 wake_up_interruptible(&rtc_wait);
1119
1120 kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
1121}
1122#endif
1123
1124#ifdef CONFIG_PROC_FS
1125
1126
1127
1128
1129static int rtc_proc_show(struct seq_file *seq, void *v)
1130{
1131#define YN(bit) ((ctrl & bit) ? "yes" : "no")
1132#define NY(bit) ((ctrl & bit) ? "no" : "yes")
1133 struct rtc_time tm;
1134 unsigned char batt, ctrl;
1135 unsigned long freq;
1136
1137 spin_lock_irq(&rtc_lock);
1138 batt = CMOS_READ(RTC_VALID) & RTC_VRT;
1139 ctrl = CMOS_READ(RTC_CONTROL);
1140 freq = rtc_freq;
1141 spin_unlock_irq(&rtc_lock);
1142
1143
1144 rtc_get_rtc_time(&tm);
1145
1146
1147
1148
1149
1150 seq_printf(seq,
1151 "rtc_time\t: %02d:%02d:%02d\n"
1152 "rtc_date\t: %04d-%02d-%02d\n"
1153 "rtc_epoch\t: %04lu\n",
1154 tm.tm_hour, tm.tm_min, tm.tm_sec,
1155 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, epoch);
1156
1157 get_rtc_alm_time(&tm);
1158
1159
1160
1161
1162
1163
1164 seq_puts(seq, "alarm\t\t: ");
1165 if (tm.tm_hour <= 24)
1166 seq_printf(seq, "%02d:", tm.tm_hour);
1167 else
1168 seq_puts(seq, "**:");
1169
1170 if (tm.tm_min <= 59)
1171 seq_printf(seq, "%02d:", tm.tm_min);
1172 else
1173 seq_puts(seq, "**:");
1174
1175 if (tm.tm_sec <= 59)
1176 seq_printf(seq, "%02d\n", tm.tm_sec);
1177 else
1178 seq_puts(seq, "**\n");
1179
1180 seq_printf(seq,
1181 "DST_enable\t: %s\n"
1182 "BCD\t\t: %s\n"
1183 "24hr\t\t: %s\n"
1184 "square_wave\t: %s\n"
1185 "alarm_IRQ\t: %s\n"
1186 "update_IRQ\t: %s\n"
1187 "periodic_IRQ\t: %s\n"
1188 "periodic_freq\t: %ld\n"
1189 "batt_status\t: %s\n",
1190 YN(RTC_DST_EN),
1191 NY(RTC_DM_BINARY),
1192 YN(RTC_24H),
1193 YN(RTC_SQWE),
1194 YN(RTC_AIE),
1195 YN(RTC_UIE),
1196 YN(RTC_PIE),
1197 freq,
1198 batt ? "okay" : "dead");
1199
1200 return 0;
1201#undef YN
1202#undef NY
1203}
1204
1205static int rtc_proc_open(struct inode *inode, struct file *file)
1206{
1207 return single_open(file, rtc_proc_show, NULL);
1208}
1209#endif
1210
1211static void rtc_get_rtc_time(struct rtc_time *rtc_tm)
1212{
1213 unsigned long uip_watchdog = jiffies, flags;
1214 unsigned char ctrl;
1215#ifdef CONFIG_MACH_DECSTATION
1216 unsigned int real_year;
1217#endif
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229 while (rtc_is_updating() != 0 &&
1230 time_before(jiffies, uip_watchdog + 2*HZ/100))
1231 cpu_relax();
1232
1233
1234
1235
1236
1237
1238
1239 spin_lock_irqsave(&rtc_lock, flags);
1240 rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS);
1241 rtc_tm->tm_min = CMOS_READ(RTC_MINUTES);
1242 rtc_tm->tm_hour = CMOS_READ(RTC_HOURS);
1243 rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
1244 rtc_tm->tm_mon = CMOS_READ(RTC_MONTH);
1245 rtc_tm->tm_year = CMOS_READ(RTC_YEAR);
1246
1247 rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK);
1248
1249#ifdef CONFIG_MACH_DECSTATION
1250 real_year = CMOS_READ(RTC_DEC_YEAR);
1251#endif
1252 ctrl = CMOS_READ(RTC_CONTROL);
1253 spin_unlock_irqrestore(&rtc_lock, flags);
1254
1255 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
1256 rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
1257 rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
1258 rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
1259 rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
1260 rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
1261 rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
1262 rtc_tm->tm_wday = bcd2bin(rtc_tm->tm_wday);
1263 }
1264
1265#ifdef CONFIG_MACH_DECSTATION
1266 rtc_tm->tm_year += real_year - 72;
1267#endif
1268
1269
1270
1271
1272
1273 rtc_tm->tm_year += epoch - 1900;
1274 if (rtc_tm->tm_year <= 69)
1275 rtc_tm->tm_year += 100;
1276
1277 rtc_tm->tm_mon--;
1278}
1279
1280static void get_rtc_alm_time(struct rtc_time *alm_tm)
1281{
1282 unsigned char ctrl;
1283
1284
1285
1286
1287
1288 spin_lock_irq(&rtc_lock);
1289 alm_tm->tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
1290 alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM);
1291 alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM);
1292 ctrl = CMOS_READ(RTC_CONTROL);
1293 spin_unlock_irq(&rtc_lock);
1294
1295 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
1296 alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
1297 alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
1298 alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
1299 }
1300}
1301
1302#ifdef RTC_IRQ
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313static void mask_rtc_irq_bit_locked(unsigned char bit)
1314{
1315 unsigned char val;
1316
1317 if (hpet_mask_rtc_irq_bit(bit))
1318 return;
1319 val = CMOS_READ(RTC_CONTROL);
1320 val &= ~bit;
1321 CMOS_WRITE(val, RTC_CONTROL);
1322 CMOS_READ(RTC_INTR_FLAGS);
1323
1324 rtc_irq_data = 0;
1325}
1326
1327static void set_rtc_irq_bit_locked(unsigned char bit)
1328{
1329 unsigned char val;
1330
1331 if (hpet_set_rtc_irq_bit(bit))
1332 return;
1333 val = CMOS_READ(RTC_CONTROL);
1334 val |= bit;
1335 CMOS_WRITE(val, RTC_CONTROL);
1336 CMOS_READ(RTC_INTR_FLAGS);
1337
1338 rtc_irq_data = 0;
1339}
1340#endif
1341
1342MODULE_AUTHOR("Paul Gortmaker");
1343MODULE_LICENSE("GPL");
1344MODULE_ALIAS_MISCDEV(RTC_MINOR);
1345