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.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
84#include <asm/current.h>
85#include <asm/system.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(unsigned long data);
139
140static DEFINE_TIMER(rtc_irq_timer, rtc_dropped_irq, 0, 0);
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 unsigned int 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 ctl_table rtc_table[] = {
284 {
285 .ctl_name = CTL_UNNUMBERED,
286 .procname = "max-user-freq",
287 .data = &rtc_max_user_freq,
288 .maxlen = sizeof(int),
289 .mode = 0644,
290 .proc_handler = &proc_dointvec,
291 },
292 { .ctl_name = 0 }
293};
294
295static ctl_table rtc_root[] = {
296 {
297 .ctl_name = CTL_UNNUMBERED,
298 .procname = "rtc",
299 .mode = 0555,
300 .child = rtc_table,
301 },
302 { .ctl_name = 0 }
303};
304
305static ctl_table dev_root[] = {
306 {
307 .ctl_name = CTL_DEV,
308 .procname = "dev",
309 .mode = 0555,
310 .child = rtc_root,
311 },
312 { .ctl_name = 0 }
313};
314
315static struct ctl_table_header *sysctl_header;
316
317static int __init init_sysctl(void)
318{
319 sysctl_header = register_sysctl_table(dev_root);
320 return 0;
321}
322
323static void __exit cleanup_sysctl(void)
324{
325 unregister_sysctl_table(sysctl_header);
326}
327
328
329
330
331
332static ssize_t rtc_read(struct file *file, char __user *buf,
333 size_t count, loff_t *ppos)
334{
335#ifndef RTC_IRQ
336 return -EIO;
337#else
338 DECLARE_WAITQUEUE(wait, current);
339 unsigned long data;
340 ssize_t retval;
341
342 if (rtc_has_irq == 0)
343 return -EIO;
344
345
346
347
348
349
350
351
352
353 if (count != sizeof(unsigned int) && count != sizeof(unsigned long))
354 return -EINVAL;
355
356 add_wait_queue(&rtc_wait, &wait);
357
358 do {
359
360
361
362
363 __set_current_state(TASK_INTERRUPTIBLE);
364
365 spin_lock_irq(&rtc_lock);
366 data = rtc_irq_data;
367 rtc_irq_data = 0;
368 spin_unlock_irq(&rtc_lock);
369
370 if (data != 0)
371 break;
372
373 if (file->f_flags & O_NONBLOCK) {
374 retval = -EAGAIN;
375 goto out;
376 }
377 if (signal_pending(current)) {
378 retval = -ERESTARTSYS;
379 goto out;
380 }
381 schedule();
382 } while (1);
383
384 if (count == sizeof(unsigned int)) {
385 retval = put_user(data,
386 (unsigned int __user *)buf) ?: sizeof(int);
387 } else {
388 retval = put_user(data,
389 (unsigned long __user *)buf) ?: sizeof(long);
390 }
391 if (!retval)
392 retval = count;
393 out:
394 __set_current_state(TASK_RUNNING);
395 remove_wait_queue(&rtc_wait, &wait);
396
397 return retval;
398#endif
399}
400
401static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
402{
403 struct rtc_time wtime;
404
405#ifdef RTC_IRQ
406 if (rtc_has_irq == 0) {
407 switch (cmd) {
408 case RTC_AIE_OFF:
409 case RTC_AIE_ON:
410 case RTC_PIE_OFF:
411 case RTC_PIE_ON:
412 case RTC_UIE_OFF:
413 case RTC_UIE_ON:
414 case RTC_IRQP_READ:
415 case RTC_IRQP_SET:
416 return -EINVAL;
417 };
418 }
419#endif
420
421 switch (cmd) {
422#ifdef RTC_IRQ
423 case RTC_AIE_OFF:
424 {
425 mask_rtc_irq_bit(RTC_AIE);
426 return 0;
427 }
428 case RTC_AIE_ON:
429 {
430 set_rtc_irq_bit(RTC_AIE);
431 return 0;
432 }
433 case RTC_PIE_OFF:
434 {
435
436 unsigned long flags;
437
438 spin_lock_irqsave(&rtc_lock, flags);
439 mask_rtc_irq_bit_locked(RTC_PIE);
440 if (rtc_status & RTC_TIMER_ON) {
441 rtc_status &= ~RTC_TIMER_ON;
442 del_timer(&rtc_irq_timer);
443 }
444 spin_unlock_irqrestore(&rtc_lock, flags);
445
446 return 0;
447 }
448 case RTC_PIE_ON:
449 {
450
451 unsigned long flags;
452
453
454
455
456
457 if (!kernel && (rtc_freq > rtc_max_user_freq) &&
458 (!capable(CAP_SYS_RESOURCE)))
459 return -EACCES;
460
461 spin_lock_irqsave(&rtc_lock, flags);
462 if (!(rtc_status & RTC_TIMER_ON)) {
463 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq +
464 2*HZ/100);
465 rtc_status |= RTC_TIMER_ON;
466 }
467 set_rtc_irq_bit_locked(RTC_PIE);
468 spin_unlock_irqrestore(&rtc_lock, flags);
469
470 return 0;
471 }
472 case RTC_UIE_OFF:
473 {
474 mask_rtc_irq_bit(RTC_UIE);
475 return 0;
476 }
477 case RTC_UIE_ON:
478 {
479 set_rtc_irq_bit(RTC_UIE);
480 return 0;
481 }
482#endif
483 case RTC_ALM_READ:
484 {
485
486
487
488
489
490 memset(&wtime, 0, sizeof(struct rtc_time));
491 get_rtc_alm_time(&wtime);
492 break;
493 }
494 case RTC_ALM_SET:
495 {
496
497
498
499
500
501 unsigned char hrs, min, sec;
502 struct rtc_time alm_tm;
503
504 if (copy_from_user(&alm_tm, (struct rtc_time __user *)arg,
505 sizeof(struct rtc_time)))
506 return -EFAULT;
507
508 hrs = alm_tm.tm_hour;
509 min = alm_tm.tm_min;
510 sec = alm_tm.tm_sec;
511
512 spin_lock_irq(&rtc_lock);
513 if (hpet_set_alarm_time(hrs, min, sec)) {
514
515
516
517
518 }
519 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) ||
520 RTC_ALWAYS_BCD) {
521 if (sec < 60)
522 sec = bin2bcd(sec);
523 else
524 sec = 0xff;
525
526 if (min < 60)
527 min = bin2bcd(min);
528 else
529 min = 0xff;
530
531 if (hrs < 24)
532 hrs = bin2bcd(hrs);
533 else
534 hrs = 0xff;
535 }
536 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
537 CMOS_WRITE(min, RTC_MINUTES_ALARM);
538 CMOS_WRITE(sec, RTC_SECONDS_ALARM);
539 spin_unlock_irq(&rtc_lock);
540
541 return 0;
542 }
543 case RTC_RD_TIME:
544 {
545 memset(&wtime, 0, sizeof(struct rtc_time));
546 rtc_get_rtc_time(&wtime);
547 break;
548 }
549 case RTC_SET_TIME:
550 {
551 struct rtc_time rtc_tm;
552 unsigned char mon, day, hrs, min, sec, leap_yr;
553 unsigned char save_control, save_freq_select;
554 unsigned int yrs;
555#ifdef CONFIG_MACH_DECSTATION
556 unsigned int real_yrs;
557#endif
558
559 if (!capable(CAP_SYS_TIME))
560 return -EACCES;
561
562 if (copy_from_user(&rtc_tm, (struct rtc_time __user *)arg,
563 sizeof(struct rtc_time)))
564 return -EFAULT;
565
566 yrs = rtc_tm.tm_year + 1900;
567 mon = rtc_tm.tm_mon + 1;
568 day = rtc_tm.tm_mday;
569 hrs = rtc_tm.tm_hour;
570 min = rtc_tm.tm_min;
571 sec = rtc_tm.tm_sec;
572
573 if (yrs < 1970)
574 return -EINVAL;
575
576 leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
577
578 if ((mon > 12) || (day == 0))
579 return -EINVAL;
580
581 if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
582 return -EINVAL;
583
584 if ((hrs >= 24) || (min >= 60) || (sec >= 60))
585 return -EINVAL;
586
587 yrs -= epoch;
588 if (yrs > 255)
589 return -EINVAL;
590
591 spin_lock_irq(&rtc_lock);
592#ifdef CONFIG_MACH_DECSTATION
593 real_yrs = yrs;
594 yrs = 72;
595
596
597
598
599
600
601 if (!leap_yr && mon < 3) {
602 real_yrs--;
603 yrs = 73;
604 }
605#endif
606
607
608
609 if (yrs > 169) {
610 spin_unlock_irq(&rtc_lock);
611 return -EINVAL;
612 }
613 if (yrs >= 100)
614 yrs -= 100;
615
616 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)
617 || RTC_ALWAYS_BCD) {
618 sec = bin2bcd(sec);
619 min = bin2bcd(min);
620 hrs = bin2bcd(hrs);
621 day = bin2bcd(day);
622 mon = bin2bcd(mon);
623 yrs = bin2bcd(yrs);
624 }
625
626 save_control = CMOS_READ(RTC_CONTROL);
627 CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
628 save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
629 CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
630
631#ifdef CONFIG_MACH_DECSTATION
632 CMOS_WRITE(real_yrs, RTC_DEC_YEAR);
633#endif
634 CMOS_WRITE(yrs, RTC_YEAR);
635 CMOS_WRITE(mon, RTC_MONTH);
636 CMOS_WRITE(day, RTC_DAY_OF_MONTH);
637 CMOS_WRITE(hrs, RTC_HOURS);
638 CMOS_WRITE(min, RTC_MINUTES);
639 CMOS_WRITE(sec, RTC_SECONDS);
640
641 CMOS_WRITE(save_control, RTC_CONTROL);
642 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
643
644 spin_unlock_irq(&rtc_lock);
645 return 0;
646 }
647#ifdef RTC_IRQ
648 case RTC_IRQP_READ:
649 {
650 return put_user(rtc_freq, (unsigned long __user *)arg);
651 }
652 case RTC_IRQP_SET:
653 {
654 int tmp = 0;
655 unsigned char val;
656
657 unsigned long flags;
658
659
660
661
662 if ((arg < 2) || (arg > 8192))
663 return -EINVAL;
664
665
666
667
668 if (!kernel && (arg > rtc_max_user_freq) &&
669 !capable(CAP_SYS_RESOURCE))
670 return -EACCES;
671
672 while (arg > (1<<tmp))
673 tmp++;
674
675
676
677
678 if (arg != (1<<tmp))
679 return -EINVAL;
680
681 rtc_freq = arg;
682
683 spin_lock_irqsave(&rtc_lock, flags);
684 if (hpet_set_periodic_freq(arg)) {
685 spin_unlock_irqrestore(&rtc_lock, flags);
686 return 0;
687 }
688
689 val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0;
690 val |= (16 - tmp);
691 CMOS_WRITE(val, RTC_FREQ_SELECT);
692 spin_unlock_irqrestore(&rtc_lock, flags);
693 return 0;
694 }
695#endif
696 case RTC_EPOCH_READ:
697 {
698 return put_user(epoch, (unsigned long __user *)arg);
699 }
700 case RTC_EPOCH_SET:
701 {
702
703
704
705 if (arg < 1900)
706 return -EINVAL;
707
708 if (!capable(CAP_SYS_TIME))
709 return -EACCES;
710
711 epoch = arg;
712 return 0;
713 }
714 default:
715 return -ENOTTY;
716 }
717 return copy_to_user((void __user *)arg,
718 &wtime, sizeof wtime) ? -EFAULT : 0;
719}
720
721static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
722{
723 long ret;
724 ret = rtc_do_ioctl(cmd, arg, 0);
725 return ret;
726}
727
728
729
730
731
732
733static int rtc_open(struct inode *inode, struct file *file)
734{
735 spin_lock_irq(&rtc_lock);
736
737 if (rtc_status & RTC_IS_OPEN)
738 goto out_busy;
739
740 rtc_status |= RTC_IS_OPEN;
741
742 rtc_irq_data = 0;
743 spin_unlock_irq(&rtc_lock);
744 return 0;
745
746out_busy:
747 spin_unlock_irq(&rtc_lock);
748 return -EBUSY;
749}
750
751static int rtc_fasync(int fd, struct file *filp, int on)
752{
753 return fasync_helper(fd, filp, on, &rtc_async_queue);
754}
755
756static int rtc_release(struct inode *inode, struct file *file)
757{
758#ifdef RTC_IRQ
759 unsigned char tmp;
760
761 if (rtc_has_irq == 0)
762 goto no_irq;
763
764
765
766
767
768
769 spin_lock_irq(&rtc_lock);
770 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
771 tmp = CMOS_READ(RTC_CONTROL);
772 tmp &= ~RTC_PIE;
773 tmp &= ~RTC_AIE;
774 tmp &= ~RTC_UIE;
775 CMOS_WRITE(tmp, RTC_CONTROL);
776 CMOS_READ(RTC_INTR_FLAGS);
777 }
778 if (rtc_status & RTC_TIMER_ON) {
779 rtc_status &= ~RTC_TIMER_ON;
780 del_timer(&rtc_irq_timer);
781 }
782 spin_unlock_irq(&rtc_lock);
783
784no_irq:
785#endif
786
787 spin_lock_irq(&rtc_lock);
788 rtc_irq_data = 0;
789 rtc_status &= ~RTC_IS_OPEN;
790 spin_unlock_irq(&rtc_lock);
791
792 return 0;
793}
794
795#ifdef RTC_IRQ
796static unsigned int rtc_poll(struct file *file, poll_table *wait)
797{
798 unsigned long l;
799
800 if (rtc_has_irq == 0)
801 return 0;
802
803 poll_wait(file, &rtc_wait, wait);
804
805 spin_lock_irq(&rtc_lock);
806 l = rtc_irq_data;
807 spin_unlock_irq(&rtc_lock);
808
809 if (l != 0)
810 return POLLIN | POLLRDNORM;
811 return 0;
812}
813#endif
814
815int rtc_register(rtc_task_t *task)
816{
817#ifndef RTC_IRQ
818 return -EIO;
819#else
820 if (task == NULL || task->func == NULL)
821 return -EINVAL;
822 spin_lock_irq(&rtc_lock);
823 if (rtc_status & RTC_IS_OPEN) {
824 spin_unlock_irq(&rtc_lock);
825 return -EBUSY;
826 }
827 spin_lock(&rtc_task_lock);
828 if (rtc_callback) {
829 spin_unlock(&rtc_task_lock);
830 spin_unlock_irq(&rtc_lock);
831 return -EBUSY;
832 }
833 rtc_status |= RTC_IS_OPEN;
834 rtc_callback = task;
835 spin_unlock(&rtc_task_lock);
836 spin_unlock_irq(&rtc_lock);
837 return 0;
838#endif
839}
840EXPORT_SYMBOL(rtc_register);
841
842int rtc_unregister(rtc_task_t *task)
843{
844#ifndef RTC_IRQ
845 return -EIO;
846#else
847 unsigned char tmp;
848
849 spin_lock_irq(&rtc_lock);
850 spin_lock(&rtc_task_lock);
851 if (rtc_callback != task) {
852 spin_unlock(&rtc_task_lock);
853 spin_unlock_irq(&rtc_lock);
854 return -ENXIO;
855 }
856 rtc_callback = NULL;
857
858
859 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
860 tmp = CMOS_READ(RTC_CONTROL);
861 tmp &= ~RTC_PIE;
862 tmp &= ~RTC_AIE;
863 tmp &= ~RTC_UIE;
864 CMOS_WRITE(tmp, RTC_CONTROL);
865 CMOS_READ(RTC_INTR_FLAGS);
866 }
867 if (rtc_status & RTC_TIMER_ON) {
868 rtc_status &= ~RTC_TIMER_ON;
869 del_timer(&rtc_irq_timer);
870 }
871 rtc_status &= ~RTC_IS_OPEN;
872 spin_unlock(&rtc_task_lock);
873 spin_unlock_irq(&rtc_lock);
874 return 0;
875#endif
876}
877EXPORT_SYMBOL(rtc_unregister);
878
879int rtc_control(rtc_task_t *task, unsigned int cmd, unsigned long arg)
880{
881#ifndef RTC_IRQ
882 return -EIO;
883#else
884 unsigned long flags;
885 if (cmd != RTC_PIE_ON && cmd != RTC_PIE_OFF && cmd != RTC_IRQP_SET)
886 return -EINVAL;
887 spin_lock_irqsave(&rtc_task_lock, flags);
888 if (rtc_callback != task) {
889 spin_unlock_irqrestore(&rtc_task_lock, flags);
890 return -ENXIO;
891 }
892 spin_unlock_irqrestore(&rtc_task_lock, flags);
893 return rtc_do_ioctl(cmd, arg, 1);
894#endif
895}
896EXPORT_SYMBOL(rtc_control);
897
898
899
900
901
902static const struct file_operations rtc_fops = {
903 .owner = THIS_MODULE,
904 .llseek = no_llseek,
905 .read = rtc_read,
906#ifdef RTC_IRQ
907 .poll = rtc_poll,
908#endif
909 .unlocked_ioctl = rtc_ioctl,
910 .open = rtc_open,
911 .release = rtc_release,
912 .fasync = rtc_fasync,
913};
914
915static struct miscdevice rtc_dev = {
916 .minor = RTC_MINOR,
917 .name = "rtc",
918 .fops = &rtc_fops,
919};
920
921#ifdef CONFIG_PROC_FS
922static const struct file_operations rtc_proc_fops = {
923 .owner = THIS_MODULE,
924 .open = rtc_proc_open,
925 .read = seq_read,
926 .llseek = seq_lseek,
927 .release = single_release,
928};
929#endif
930
931static resource_size_t rtc_size;
932
933static struct resource * __init rtc_request_region(resource_size_t size)
934{
935 struct resource *r;
936
937 if (RTC_IOMAPPED)
938 r = request_region(RTC_PORT(0), size, "rtc");
939 else
940 r = request_mem_region(RTC_PORT(0), size, "rtc");
941
942 if (r)
943 rtc_size = size;
944
945 return r;
946}
947
948static void rtc_release_region(void)
949{
950 if (RTC_IOMAPPED)
951 release_region(RTC_PORT(0), rtc_size);
952 else
953 release_mem_region(RTC_PORT(0), rtc_size);
954}
955
956static int __init rtc_init(void)
957{
958#ifdef CONFIG_PROC_FS
959 struct proc_dir_entry *ent;
960#endif
961#if defined(__alpha__) || defined(__mips__)
962 unsigned int year, ctrl;
963 char *guess = NULL;
964#endif
965#ifdef CONFIG_SPARC32
966 struct device_node *ebus_dp;
967 struct of_device *op;
968#else
969 void *r;
970#ifdef RTC_IRQ
971 irq_handler_t rtc_int_handler_ptr;
972#endif
973#endif
974
975#ifdef CONFIG_SPARC32
976 for_each_node_by_name(ebus_dp, "ebus") {
977 struct device_node *dp;
978 for (dp = ebus_dp; dp; dp = dp->sibling) {
979 if (!strcmp(dp->name, "rtc")) {
980 op = of_find_device_by_node(dp);
981 if (op) {
982 rtc_port = op->resource[0].start;
983 rtc_irq = op->irqs[0];
984 goto found;
985 }
986 }
987 }
988 }
989 rtc_has_irq = 0;
990 printk(KERN_ERR "rtc_init: no PC rtc found\n");
991 return -EIO;
992
993found:
994 if (!rtc_irq) {
995 rtc_has_irq = 0;
996 goto no_irq;
997 }
998
999
1000
1001
1002
1003 if (request_irq(rtc_irq, rtc_interrupt, IRQF_SHARED, "rtc",
1004 (void *)&rtc_port)) {
1005 rtc_has_irq = 0;
1006 printk(KERN_ERR "rtc: cannot register IRQ %d\n", rtc_irq);
1007 return -EIO;
1008 }
1009no_irq:
1010#else
1011 r = rtc_request_region(RTC_IO_EXTENT);
1012
1013
1014
1015
1016
1017
1018
1019
1020 if (!r)
1021 r = rtc_request_region(RTC_IO_EXTENT_USED);
1022 if (!r) {
1023#ifdef RTC_IRQ
1024 rtc_has_irq = 0;
1025#endif
1026 printk(KERN_ERR "rtc: I/O resource %lx is not free.\n",
1027 (long)(RTC_PORT(0)));
1028 return -EIO;
1029 }
1030
1031#ifdef RTC_IRQ
1032 if (is_hpet_enabled()) {
1033 int err;
1034
1035 rtc_int_handler_ptr = hpet_rtc_interrupt;
1036 err = hpet_register_irq_handler(rtc_interrupt);
1037 if (err != 0) {
1038 printk(KERN_WARNING "hpet_register_irq_handler failed "
1039 "in rtc_init().");
1040 return err;
1041 }
1042 } else {
1043 rtc_int_handler_ptr = rtc_interrupt;
1044 }
1045
1046 if (request_irq(RTC_IRQ, rtc_int_handler_ptr, IRQF_DISABLED,
1047 "rtc", NULL)) {
1048
1049 rtc_has_irq = 0;
1050 printk(KERN_ERR "rtc: IRQ %d is not free.\n", RTC_IRQ);
1051 rtc_release_region();
1052
1053 return -EIO;
1054 }
1055 hpet_rtc_timer_init();
1056
1057#endif
1058
1059#endif
1060
1061 if (misc_register(&rtc_dev)) {
1062#ifdef RTC_IRQ
1063 free_irq(RTC_IRQ, NULL);
1064 hpet_unregister_irq_handler(rtc_interrupt);
1065 rtc_has_irq = 0;
1066#endif
1067 rtc_release_region();
1068 return -ENODEV;
1069 }
1070
1071#ifdef CONFIG_PROC_FS
1072 ent = proc_create("driver/rtc", 0, NULL, &rtc_proc_fops);
1073 if (!ent)
1074 printk(KERN_WARNING "rtc: Failed to register with procfs.\n");
1075#endif
1076
1077#if defined(__alpha__) || defined(__mips__)
1078 rtc_freq = HZ;
1079
1080
1081
1082
1083 if (rtc_is_updating() != 0)
1084 msleep(20);
1085
1086 spin_lock_irq(&rtc_lock);
1087 year = CMOS_READ(RTC_YEAR);
1088 ctrl = CMOS_READ(RTC_CONTROL);
1089 spin_unlock_irq(&rtc_lock);
1090
1091 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1092 year = bcd2bin(year);
1093
1094 if (year < 20) {
1095 epoch = 2000;
1096 guess = "SRM (post-2000)";
1097 } else if (year >= 20 && year < 48) {
1098 epoch = 1980;
1099 guess = "ARC console";
1100 } else if (year >= 48 && year < 72) {
1101 epoch = 1952;
1102 guess = "Digital UNIX";
1103#if defined(__mips__)
1104 } else if (year >= 72 && year < 74) {
1105 epoch = 2000;
1106 guess = "Digital DECstation";
1107#else
1108 } else if (year >= 70) {
1109 epoch = 1900;
1110 guess = "Standard PC (1900)";
1111#endif
1112 }
1113 if (guess)
1114 printk(KERN_INFO "rtc: %s epoch (%lu) detected\n",
1115 guess, epoch);
1116#endif
1117#ifdef RTC_IRQ
1118 if (rtc_has_irq == 0)
1119 goto no_irq2;
1120
1121 spin_lock_irq(&rtc_lock);
1122 rtc_freq = 1024;
1123 if (!hpet_set_periodic_freq(rtc_freq)) {
1124
1125
1126
1127
1128 CMOS_WRITE(((CMOS_READ(RTC_FREQ_SELECT) & 0xF0) | 0x06),
1129 RTC_FREQ_SELECT);
1130 }
1131 spin_unlock_irq(&rtc_lock);
1132no_irq2:
1133#endif
1134
1135 (void) init_sysctl();
1136
1137 printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n");
1138
1139 return 0;
1140}
1141
1142static void __exit rtc_exit(void)
1143{
1144 cleanup_sysctl();
1145 remove_proc_entry("driver/rtc", NULL);
1146 misc_deregister(&rtc_dev);
1147
1148#ifdef CONFIG_SPARC32
1149 if (rtc_has_irq)
1150 free_irq(rtc_irq, &rtc_port);
1151#else
1152 rtc_release_region();
1153#ifdef RTC_IRQ
1154 if (rtc_has_irq) {
1155 free_irq(RTC_IRQ, NULL);
1156 hpet_unregister_irq_handler(hpet_rtc_interrupt);
1157 }
1158#endif
1159#endif
1160}
1161
1162module_init(rtc_init);
1163module_exit(rtc_exit);
1164
1165#ifdef RTC_IRQ
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178static void rtc_dropped_irq(unsigned long data)
1179{
1180 unsigned long freq;
1181
1182 spin_lock_irq(&rtc_lock);
1183
1184 if (hpet_rtc_dropped_irq()) {
1185 spin_unlock_irq(&rtc_lock);
1186 return;
1187 }
1188
1189
1190 if (rtc_status & RTC_TIMER_ON)
1191 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
1192
1193 rtc_irq_data += ((rtc_freq/HZ)<<8);
1194 rtc_irq_data &= ~0xff;
1195 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
1196
1197 freq = rtc_freq;
1198
1199 spin_unlock_irq(&rtc_lock);
1200
1201 if (printk_ratelimit()) {
1202 printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n",
1203 freq);
1204 }
1205
1206
1207 wake_up_interruptible(&rtc_wait);
1208
1209 kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
1210}
1211#endif
1212
1213#ifdef CONFIG_PROC_FS
1214
1215
1216
1217
1218static int rtc_proc_show(struct seq_file *seq, void *v)
1219{
1220#define YN(bit) ((ctrl & bit) ? "yes" : "no")
1221#define NY(bit) ((ctrl & bit) ? "no" : "yes")
1222 struct rtc_time tm;
1223 unsigned char batt, ctrl;
1224 unsigned long freq;
1225
1226 spin_lock_irq(&rtc_lock);
1227 batt = CMOS_READ(RTC_VALID) & RTC_VRT;
1228 ctrl = CMOS_READ(RTC_CONTROL);
1229 freq = rtc_freq;
1230 spin_unlock_irq(&rtc_lock);
1231
1232
1233 rtc_get_rtc_time(&tm);
1234
1235
1236
1237
1238
1239 seq_printf(seq,
1240 "rtc_time\t: %02d:%02d:%02d\n"
1241 "rtc_date\t: %04d-%02d-%02d\n"
1242 "rtc_epoch\t: %04lu\n",
1243 tm.tm_hour, tm.tm_min, tm.tm_sec,
1244 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, epoch);
1245
1246 get_rtc_alm_time(&tm);
1247
1248
1249
1250
1251
1252
1253 seq_puts(seq, "alarm\t\t: ");
1254 if (tm.tm_hour <= 24)
1255 seq_printf(seq, "%02d:", tm.tm_hour);
1256 else
1257 seq_puts(seq, "**:");
1258
1259 if (tm.tm_min <= 59)
1260 seq_printf(seq, "%02d:", tm.tm_min);
1261 else
1262 seq_puts(seq, "**:");
1263
1264 if (tm.tm_sec <= 59)
1265 seq_printf(seq, "%02d\n", tm.tm_sec);
1266 else
1267 seq_puts(seq, "**\n");
1268
1269 seq_printf(seq,
1270 "DST_enable\t: %s\n"
1271 "BCD\t\t: %s\n"
1272 "24hr\t\t: %s\n"
1273 "square_wave\t: %s\n"
1274 "alarm_IRQ\t: %s\n"
1275 "update_IRQ\t: %s\n"
1276 "periodic_IRQ\t: %s\n"
1277 "periodic_freq\t: %ld\n"
1278 "batt_status\t: %s\n",
1279 YN(RTC_DST_EN),
1280 NY(RTC_DM_BINARY),
1281 YN(RTC_24H),
1282 YN(RTC_SQWE),
1283 YN(RTC_AIE),
1284 YN(RTC_UIE),
1285 YN(RTC_PIE),
1286 freq,
1287 batt ? "okay" : "dead");
1288
1289 return 0;
1290#undef YN
1291#undef NY
1292}
1293
1294static int rtc_proc_open(struct inode *inode, struct file *file)
1295{
1296 return single_open(file, rtc_proc_show, NULL);
1297}
1298#endif
1299
1300static void rtc_get_rtc_time(struct rtc_time *rtc_tm)
1301{
1302 unsigned long uip_watchdog = jiffies, flags;
1303 unsigned char ctrl;
1304#ifdef CONFIG_MACH_DECSTATION
1305 unsigned int real_year;
1306#endif
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318 while (rtc_is_updating() != 0 &&
1319 time_before(jiffies, uip_watchdog + 2*HZ/100))
1320 cpu_relax();
1321
1322
1323
1324
1325
1326
1327
1328 spin_lock_irqsave(&rtc_lock, flags);
1329 rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS);
1330 rtc_tm->tm_min = CMOS_READ(RTC_MINUTES);
1331 rtc_tm->tm_hour = CMOS_READ(RTC_HOURS);
1332 rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
1333 rtc_tm->tm_mon = CMOS_READ(RTC_MONTH);
1334 rtc_tm->tm_year = CMOS_READ(RTC_YEAR);
1335
1336 rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK);
1337
1338#ifdef CONFIG_MACH_DECSTATION
1339 real_year = CMOS_READ(RTC_DEC_YEAR);
1340#endif
1341 ctrl = CMOS_READ(RTC_CONTROL);
1342 spin_unlock_irqrestore(&rtc_lock, flags);
1343
1344 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
1345 rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
1346 rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
1347 rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
1348 rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
1349 rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
1350 rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
1351 rtc_tm->tm_wday = bcd2bin(rtc_tm->tm_wday);
1352 }
1353
1354#ifdef CONFIG_MACH_DECSTATION
1355 rtc_tm->tm_year += real_year - 72;
1356#endif
1357
1358
1359
1360
1361
1362 rtc_tm->tm_year += epoch - 1900;
1363 if (rtc_tm->tm_year <= 69)
1364 rtc_tm->tm_year += 100;
1365
1366 rtc_tm->tm_mon--;
1367}
1368
1369static void get_rtc_alm_time(struct rtc_time *alm_tm)
1370{
1371 unsigned char ctrl;
1372
1373
1374
1375
1376
1377 spin_lock_irq(&rtc_lock);
1378 alm_tm->tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
1379 alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM);
1380 alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM);
1381 ctrl = CMOS_READ(RTC_CONTROL);
1382 spin_unlock_irq(&rtc_lock);
1383
1384 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
1385 alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
1386 alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
1387 alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
1388 }
1389}
1390
1391#ifdef RTC_IRQ
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402static void mask_rtc_irq_bit_locked(unsigned char bit)
1403{
1404 unsigned char val;
1405
1406 if (hpet_mask_rtc_irq_bit(bit))
1407 return;
1408 val = CMOS_READ(RTC_CONTROL);
1409 val &= ~bit;
1410 CMOS_WRITE(val, RTC_CONTROL);
1411 CMOS_READ(RTC_INTR_FLAGS);
1412
1413 rtc_irq_data = 0;
1414}
1415
1416static void set_rtc_irq_bit_locked(unsigned char bit)
1417{
1418 unsigned char val;
1419
1420 if (hpet_set_rtc_irq_bit(bit))
1421 return;
1422 val = CMOS_READ(RTC_CONTROL);
1423 val |= bit;
1424 CMOS_WRITE(val, RTC_CONTROL);
1425 CMOS_READ(RTC_INTR_FLAGS);
1426
1427 rtc_irq_data = 0;
1428}
1429#endif
1430
1431MODULE_AUTHOR("Paul Gortmaker");
1432MODULE_LICENSE("GPL");
1433MODULE_ALIAS_MISCDEV(RTC_MINOR);
1434