1 /*
2 * Real Time Clock interface for Linux
3 *
4 * Copyright (C) 1996 Paul Gortmaker
5 *
6 * This driver allows use of the real time clock (built into
7 * nearly all computers) from user space. It exports the /dev/rtc
8 * interface supporting various ioctl() and also the
9 * /proc/driver/rtc pseudo-file for status information.
10 *
11 * The ioctls can be used to set the interrupt behaviour and
12 * generation rate from the RTC via IRQ 8. Then the /dev/rtc
13 * interface can be used to make use of these timer interrupts,
14 * be they interval or alarm based.
15 *
16 * The /dev/rtc interface will block on reads until an interrupt
17 * has been received. If a RTC interrupt has already happened,
18 * it will output an unsigned long and then block. The output value
19 * contains the interrupt status in the low byte and the number of
20 * interrupts since the last read in the remaining high bytes. The
21 * /dev/rtc interface can also be used with the select(2) call.
22 *
23 * This program is free software; you can redistribute it and/or
24 * modify it under the terms of the GNU General Public License
25 * as published by the Free Software Foundation; either version
26 * 2 of the License, or (at your option) any later version.
27 *
28 * Based on other minimal char device drivers, like Alan's
29 * watchdog, Ted's random, etc. etc.
30 *
31 * 1.07 Paul Gortmaker.
32 * 1.08 Miquel van Smoorenburg: disallow certain things on the
33 * DEC Alpha as the CMOS clock is also used for other things.
34 * 1.09 Nikita Schmidt: epoch support and some Alpha cleanup.
35 * 1.09a Pete Zaitcev: Sun SPARC
36 * 1.09b Jeff Garzik: Modularize, init cleanup
37 * 1.09c Jeff Garzik: SMP cleanup
38 * 1.10 Paul Barton-Davis: add support for async I/O
39 * 1.10a Andrea Arcangeli: Alpha updates
40 * 1.10b Andrew Morton: SMP lock fix
41 * 1.10c Cesar Barros: SMP locking fixes and cleanup
42 * 1.10d Paul Gortmaker: delete paranoia check in rtc_exit
43 * 1.10e Maciej W. Rozycki: Handle DECstation's year weirdness.
44 * 1.11 Takashi Iwai: Kernel access functions
45 * rtc_register/rtc_unregister/rtc_control
46 * 1.11a Daniele Bellucci: Audit create_proc_read_entry in rtc_init
47 * 1.12 Venkatesh Pallipadi: Hooks for emulating rtc on HPET base-timer
48 * CONFIG_HPET_EMULATE_RTC
49 * 1.12a Maciej W. Rozycki: Handle memory-mapped chips properly.
50 * 1.12ac Alan Cox: Allow read access to the day of week register
51 * 1.12b David John: Remove calls to the BKL.
52 */
53
54 #define RTC_VERSION "1.12b"
55
56 /*
57 * Note that *all* calls to CMOS_READ and CMOS_WRITE are done with
58 * interrupts disabled. Due to the index-port/data-port (0x70/0x71)
59 * design of the RTC, we don't want two different things trying to
60 * get to it at once. (e.g. the periodic 11 min sync from time.c vs.
61 * this driver.)
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 #include <linux/ratelimit.h>
84
85 #include <asm/current.h>
86 #include <asm/system.h>
87
88 #ifdef CONFIG_X86
89 #include <asm/hpet.h>
90 #endif
91
92 #ifdef CONFIG_SPARC32
93 #include <linux/of.h>
94 #include <linux/of_device.h>
95 #include <asm/io.h>
96
97 static unsigned long rtc_port;
98 static int rtc_irq;
99 #endif
100
101 #ifdef CONFIG_HPET_EMULATE_RTC
102 #undef RTC_IRQ
103 #endif
104
105 #ifdef RTC_IRQ
106 static int rtc_has_irq = 1;
107 #endif
108
109 #ifndef CONFIG_HPET_EMULATE_RTC
110 #define is_hpet_enabled() 0
111 #define hpet_set_alarm_time(hrs, min, sec) 0
112 #define hpet_set_periodic_freq(arg) 0
113 #define hpet_mask_rtc_irq_bit(arg) 0
114 #define hpet_set_rtc_irq_bit(arg) 0
115 #define hpet_rtc_timer_init() do { } while (0)
116 #define hpet_rtc_dropped_irq() 0
117 #define hpet_register_irq_handler(h) ({ 0; })
118 #define hpet_unregister_irq_handler(h) ({ 0; })
119 #ifdef RTC_IRQ
hpet_rtc_interrupt(int irq,void * dev_id)120 static irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
121 {
122 return 0;
123 }
124 #endif
125 #endif
126
127 /*
128 * We sponge a minor off of the misc major. No need slurping
129 * up another valuable major dev number for this. If you add
130 * an ioctl, make sure you don't conflict with SPARC's RTC
131 * ioctls.
132 */
133
134 static struct fasync_struct *rtc_async_queue;
135
136 static DECLARE_WAIT_QUEUE_HEAD(rtc_wait);
137
138 #ifdef RTC_IRQ
139 static void rtc_dropped_irq(unsigned long data);
140
141 static DEFINE_TIMER(rtc_irq_timer, rtc_dropped_irq, 0, 0);
142 #endif
143
144 static ssize_t rtc_read(struct file *file, char __user *buf,
145 size_t count, loff_t *ppos);
146
147 static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
148 static void rtc_get_rtc_time(struct rtc_time *rtc_tm);
149
150 #ifdef RTC_IRQ
151 static unsigned int rtc_poll(struct file *file, poll_table *wait);
152 #endif
153
154 static void get_rtc_alm_time(struct rtc_time *alm_tm);
155 #ifdef RTC_IRQ
156 static void set_rtc_irq_bit_locked(unsigned char bit);
157 static void mask_rtc_irq_bit_locked(unsigned char bit);
158
set_rtc_irq_bit(unsigned char bit)159 static inline void set_rtc_irq_bit(unsigned char bit)
160 {
161 spin_lock_irq(&rtc_lock);
162 set_rtc_irq_bit_locked(bit);
163 spin_unlock_irq(&rtc_lock);
164 }
165
mask_rtc_irq_bit(unsigned char bit)166 static void mask_rtc_irq_bit(unsigned char bit)
167 {
168 spin_lock_irq(&rtc_lock);
169 mask_rtc_irq_bit_locked(bit);
170 spin_unlock_irq(&rtc_lock);
171 }
172 #endif
173
174 #ifdef CONFIG_PROC_FS
175 static int rtc_proc_open(struct inode *inode, struct file *file);
176 #endif
177
178 /*
179 * Bits in rtc_status. (6 bits of room for future expansion)
180 */
181
182 #define RTC_IS_OPEN 0x01 /* means /dev/rtc is in use */
183 #define RTC_TIMER_ON 0x02 /* missed irq timer active */
184
185 /*
186 * rtc_status is never changed by rtc_interrupt, and ioctl/open/close is
187 * protected by the spin lock rtc_lock. However, ioctl can still disable the
188 * timer in rtc_status and then with del_timer after the interrupt has read
189 * rtc_status but before mod_timer is called, which would then reenable the
190 * timer (but you would need to have an awful timing before you'd trip on it)
191 */
192 static unsigned long rtc_status; /* bitmapped status byte. */
193 static unsigned long rtc_freq; /* Current periodic IRQ rate */
194 static unsigned long rtc_irq_data; /* our output to the world */
195 static unsigned long rtc_max_user_freq = 64; /* > this, need CAP_SYS_RESOURCE */
196
197 #ifdef RTC_IRQ
198 /*
199 * rtc_task_lock nests inside rtc_lock.
200 */
201 static DEFINE_SPINLOCK(rtc_task_lock);
202 static rtc_task_t *rtc_callback;
203 #endif
204
205 /*
206 * If this driver ever becomes modularised, it will be really nice
207 * to make the epoch retain its value across module reload...
208 */
209
210 static unsigned long epoch = 1900; /* year corresponding to 0x00 */
211
212 static const unsigned char days_in_mo[] =
213 {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
214
215 /*
216 * Returns true if a clock update is in progress
217 */
rtc_is_updating(void)218 static inline unsigned char rtc_is_updating(void)
219 {
220 unsigned long flags;
221 unsigned char uip;
222
223 spin_lock_irqsave(&rtc_lock, flags);
224 uip = (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP);
225 spin_unlock_irqrestore(&rtc_lock, flags);
226 return uip;
227 }
228
229 #ifdef RTC_IRQ
230 /*
231 * A very tiny interrupt handler. It runs with IRQF_DISABLED set,
232 * but there is possibility of conflicting with the set_rtc_mmss()
233 * call (the rtc irq and the timer irq can easily run at the same
234 * time in two different CPUs). So we need to serialize
235 * accesses to the chip with the rtc_lock spinlock that each
236 * architecture should implement in the timer code.
237 * (See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.)
238 */
239
rtc_interrupt(int irq,void * dev_id)240 static irqreturn_t rtc_interrupt(int irq, void *dev_id)
241 {
242 /*
243 * Can be an alarm interrupt, update complete interrupt,
244 * or a periodic interrupt. We store the status in the
245 * low byte and the number of interrupts received since
246 * the last read in the remainder of rtc_irq_data.
247 */
248
249 spin_lock(&rtc_lock);
250 rtc_irq_data += 0x100;
251 rtc_irq_data &= ~0xff;
252 if (is_hpet_enabled()) {
253 /*
254 * In this case it is HPET RTC interrupt handler
255 * calling us, with the interrupt information
256 * passed as arg1, instead of irq.
257 */
258 rtc_irq_data |= (unsigned long)irq & 0xF0;
259 } else {
260 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
261 }
262
263 if (rtc_status & RTC_TIMER_ON)
264 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
265
266 spin_unlock(&rtc_lock);
267
268 /* Now do the rest of the actions */
269 spin_lock(&rtc_task_lock);
270 if (rtc_callback)
271 rtc_callback->func(rtc_callback->private_data);
272 spin_unlock(&rtc_task_lock);
273 wake_up_interruptible(&rtc_wait);
274
275 kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
276
277 return IRQ_HANDLED;
278 }
279 #endif
280
281 /*
282 * sysctl-tuning infrastructure.
283 */
284 static ctl_table rtc_table[] = {
285 {
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 { }
293 };
294
295 static ctl_table rtc_root[] = {
296 {
297 .procname = "rtc",
298 .mode = 0555,
299 .child = rtc_table,
300 },
301 { }
302 };
303
304 static ctl_table dev_root[] = {
305 {
306 .procname = "dev",
307 .mode = 0555,
308 .child = rtc_root,
309 },
310 { }
311 };
312
313 static struct ctl_table_header *sysctl_header;
314
init_sysctl(void)315 static int __init init_sysctl(void)
316 {
317 sysctl_header = register_sysctl_table(dev_root);
318 return 0;
319 }
320
cleanup_sysctl(void)321 static void __exit cleanup_sysctl(void)
322 {
323 unregister_sysctl_table(sysctl_header);
324 }
325
326 /*
327 * Now all the various file operations that we export.
328 */
329
rtc_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)330 static ssize_t rtc_read(struct file *file, char __user *buf,
331 size_t count, loff_t *ppos)
332 {
333 #ifndef RTC_IRQ
334 return -EIO;
335 #else
336 DECLARE_WAITQUEUE(wait, current);
337 unsigned long data;
338 ssize_t retval;
339
340 if (rtc_has_irq == 0)
341 return -EIO;
342
343 /*
344 * Historically this function used to assume that sizeof(unsigned long)
345 * is the same in userspace and kernelspace. This lead to problems
346 * for configurations with multiple ABIs such a the MIPS o32 and 64
347 * ABIs supported on the same kernel. So now we support read of both
348 * 4 and 8 bytes and assume that's the sizeof(unsigned long) in the
349 * userspace ABI.
350 */
351 if (count != sizeof(unsigned int) && count != sizeof(unsigned long))
352 return -EINVAL;
353
354 add_wait_queue(&rtc_wait, &wait);
355
356 do {
357 /* First make it right. Then make it fast. Putting this whole
358 * block within the parentheses of a while would be too
359 * confusing. And no, xchg() is not the answer. */
360
361 __set_current_state(TASK_INTERRUPTIBLE);
362
363 spin_lock_irq(&rtc_lock);
364 data = rtc_irq_data;
365 rtc_irq_data = 0;
366 spin_unlock_irq(&rtc_lock);
367
368 if (data != 0)
369 break;
370
371 if (file->f_flags & O_NONBLOCK) {
372 retval = -EAGAIN;
373 goto out;
374 }
375 if (signal_pending(current)) {
376 retval = -ERESTARTSYS;
377 goto out;
378 }
379 schedule();
380 } while (1);
381
382 if (count == sizeof(unsigned int)) {
383 retval = put_user(data,
384 (unsigned int __user *)buf) ?: sizeof(int);
385 } else {
386 retval = put_user(data,
387 (unsigned long __user *)buf) ?: sizeof(long);
388 }
389 if (!retval)
390 retval = count;
391 out:
392 __set_current_state(TASK_RUNNING);
393 remove_wait_queue(&rtc_wait, &wait);
394
395 return retval;
396 #endif
397 }
398
rtc_do_ioctl(unsigned int cmd,unsigned long arg,int kernel)399 static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
400 {
401 struct rtc_time wtime;
402
403 #ifdef RTC_IRQ
404 if (rtc_has_irq == 0) {
405 switch (cmd) {
406 case RTC_AIE_OFF:
407 case RTC_AIE_ON:
408 case RTC_PIE_OFF:
409 case RTC_PIE_ON:
410 case RTC_UIE_OFF:
411 case RTC_UIE_ON:
412 case RTC_IRQP_READ:
413 case RTC_IRQP_SET:
414 return -EINVAL;
415 };
416 }
417 #endif
418
419 switch (cmd) {
420 #ifdef RTC_IRQ
421 case RTC_AIE_OFF: /* Mask alarm int. enab. bit */
422 {
423 mask_rtc_irq_bit(RTC_AIE);
424 return 0;
425 }
426 case RTC_AIE_ON: /* Allow alarm interrupts. */
427 {
428 set_rtc_irq_bit(RTC_AIE);
429 return 0;
430 }
431 case RTC_PIE_OFF: /* Mask periodic int. enab. bit */
432 {
433 /* can be called from isr via rtc_control() */
434 unsigned long flags;
435
436 spin_lock_irqsave(&rtc_lock, flags);
437 mask_rtc_irq_bit_locked(RTC_PIE);
438 if (rtc_status & RTC_TIMER_ON) {
439 rtc_status &= ~RTC_TIMER_ON;
440 del_timer(&rtc_irq_timer);
441 }
442 spin_unlock_irqrestore(&rtc_lock, flags);
443
444 return 0;
445 }
446 case RTC_PIE_ON: /* Allow periodic ints */
447 {
448 /* can be called from isr via rtc_control() */
449 unsigned long flags;
450
451 /*
452 * We don't really want Joe User enabling more
453 * than 64Hz of interrupts on a multi-user machine.
454 */
455 if (!kernel && (rtc_freq > rtc_max_user_freq) &&
456 (!capable(CAP_SYS_RESOURCE)))
457 return -EACCES;
458
459 spin_lock_irqsave(&rtc_lock, flags);
460 if (!(rtc_status & RTC_TIMER_ON)) {
461 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq +
462 2*HZ/100);
463 rtc_status |= RTC_TIMER_ON;
464 }
465 set_rtc_irq_bit_locked(RTC_PIE);
466 spin_unlock_irqrestore(&rtc_lock, flags);
467
468 return 0;
469 }
470 case RTC_UIE_OFF: /* Mask ints from RTC updates. */
471 {
472 mask_rtc_irq_bit(RTC_UIE);
473 return 0;
474 }
475 case RTC_UIE_ON: /* Allow ints for RTC updates. */
476 {
477 set_rtc_irq_bit(RTC_UIE);
478 return 0;
479 }
480 #endif
481 case RTC_ALM_READ: /* Read the present alarm time */
482 {
483 /*
484 * This returns a struct rtc_time. Reading >= 0xc0
485 * means "don't care" or "match all". Only the tm_hour,
486 * tm_min, and tm_sec values are filled in.
487 */
488 memset(&wtime, 0, sizeof(struct rtc_time));
489 get_rtc_alm_time(&wtime);
490 break;
491 }
492 case RTC_ALM_SET: /* Store a time into the alarm */
493 {
494 /*
495 * This expects a struct rtc_time. Writing 0xff means
496 * "don't care" or "match all". Only the tm_hour,
497 * tm_min and tm_sec are used.
498 */
499 unsigned char hrs, min, sec;
500 struct rtc_time alm_tm;
501
502 if (copy_from_user(&alm_tm, (struct rtc_time __user *)arg,
503 sizeof(struct rtc_time)))
504 return -EFAULT;
505
506 hrs = alm_tm.tm_hour;
507 min = alm_tm.tm_min;
508 sec = alm_tm.tm_sec;
509
510 spin_lock_irq(&rtc_lock);
511 if (hpet_set_alarm_time(hrs, min, sec)) {
512 /*
513 * Fallthru and set alarm time in CMOS too,
514 * so that we will get proper value in RTC_ALM_READ
515 */
516 }
517 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) ||
518 RTC_ALWAYS_BCD) {
519 if (sec < 60)
520 sec = bin2bcd(sec);
521 else
522 sec = 0xff;
523
524 if (min < 60)
525 min = bin2bcd(min);
526 else
527 min = 0xff;
528
529 if (hrs < 24)
530 hrs = bin2bcd(hrs);
531 else
532 hrs = 0xff;
533 }
534 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
535 CMOS_WRITE(min, RTC_MINUTES_ALARM);
536 CMOS_WRITE(sec, RTC_SECONDS_ALARM);
537 spin_unlock_irq(&rtc_lock);
538
539 return 0;
540 }
541 case RTC_RD_TIME: /* Read the time/date from RTC */
542 {
543 memset(&wtime, 0, sizeof(struct rtc_time));
544 rtc_get_rtc_time(&wtime);
545 break;
546 }
547 case RTC_SET_TIME: /* Set the RTC */
548 {
549 struct rtc_time rtc_tm;
550 unsigned char mon, day, hrs, min, sec, leap_yr;
551 unsigned char save_control, save_freq_select;
552 unsigned int yrs;
553 #ifdef CONFIG_MACH_DECSTATION
554 unsigned int real_yrs;
555 #endif
556
557 if (!capable(CAP_SYS_TIME))
558 return -EACCES;
559
560 if (copy_from_user(&rtc_tm, (struct rtc_time __user *)arg,
561 sizeof(struct rtc_time)))
562 return -EFAULT;
563
564 yrs = rtc_tm.tm_year + 1900;
565 mon = rtc_tm.tm_mon + 1; /* tm_mon starts at zero */
566 day = rtc_tm.tm_mday;
567 hrs = rtc_tm.tm_hour;
568 min = rtc_tm.tm_min;
569 sec = rtc_tm.tm_sec;
570
571 if (yrs < 1970)
572 return -EINVAL;
573
574 leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
575
576 if ((mon > 12) || (day == 0))
577 return -EINVAL;
578
579 if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
580 return -EINVAL;
581
582 if ((hrs >= 24) || (min >= 60) || (sec >= 60))
583 return -EINVAL;
584
585 yrs -= epoch;
586 if (yrs > 255) /* They are unsigned */
587 return -EINVAL;
588
589 spin_lock_irq(&rtc_lock);
590 #ifdef CONFIG_MACH_DECSTATION
591 real_yrs = yrs;
592 yrs = 72;
593
594 /*
595 * We want to keep the year set to 73 until March
596 * for non-leap years, so that Feb, 29th is handled
597 * correctly.
598 */
599 if (!leap_yr && mon < 3) {
600 real_yrs--;
601 yrs = 73;
602 }
603 #endif
604 /* These limits and adjustments are independent of
605 * whether the chip is in binary mode or not.
606 */
607 if (yrs > 169) {
608 spin_unlock_irq(&rtc_lock);
609 return -EINVAL;
610 }
611 if (yrs >= 100)
612 yrs -= 100;
613
614 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)
615 || RTC_ALWAYS_BCD) {
616 sec = bin2bcd(sec);
617 min = bin2bcd(min);
618 hrs = bin2bcd(hrs);
619 day = bin2bcd(day);
620 mon = bin2bcd(mon);
621 yrs = bin2bcd(yrs);
622 }
623
624 save_control = CMOS_READ(RTC_CONTROL);
625 CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
626 save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
627 CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
628
629 #ifdef CONFIG_MACH_DECSTATION
630 CMOS_WRITE(real_yrs, RTC_DEC_YEAR);
631 #endif
632 CMOS_WRITE(yrs, RTC_YEAR);
633 CMOS_WRITE(mon, RTC_MONTH);
634 CMOS_WRITE(day, RTC_DAY_OF_MONTH);
635 CMOS_WRITE(hrs, RTC_HOURS);
636 CMOS_WRITE(min, RTC_MINUTES);
637 CMOS_WRITE(sec, RTC_SECONDS);
638
639 CMOS_WRITE(save_control, RTC_CONTROL);
640 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
641
642 spin_unlock_irq(&rtc_lock);
643 return 0;
644 }
645 #ifdef RTC_IRQ
646 case RTC_IRQP_READ: /* Read the periodic IRQ rate. */
647 {
648 return put_user(rtc_freq, (unsigned long __user *)arg);
649 }
650 case RTC_IRQP_SET: /* Set periodic IRQ rate. */
651 {
652 int tmp = 0;
653 unsigned char val;
654 /* can be called from isr via rtc_control() */
655 unsigned long flags;
656
657 /*
658 * The max we can do is 8192Hz.
659 */
660 if ((arg < 2) || (arg > 8192))
661 return -EINVAL;
662 /*
663 * We don't really want Joe User generating more
664 * than 64Hz of interrupts on a multi-user machine.
665 */
666 if (!kernel && (arg > rtc_max_user_freq) &&
667 !capable(CAP_SYS_RESOURCE))
668 return -EACCES;
669
670 while (arg > (1<<tmp))
671 tmp++;
672
673 /*
674 * Check that the input was really a power of 2.
675 */
676 if (arg != (1<<tmp))
677 return -EINVAL;
678
679 rtc_freq = arg;
680
681 spin_lock_irqsave(&rtc_lock, flags);
682 if (hpet_set_periodic_freq(arg)) {
683 spin_unlock_irqrestore(&rtc_lock, flags);
684 return 0;
685 }
686
687 val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0;
688 val |= (16 - tmp);
689 CMOS_WRITE(val, RTC_FREQ_SELECT);
690 spin_unlock_irqrestore(&rtc_lock, flags);
691 return 0;
692 }
693 #endif
694 case RTC_EPOCH_READ: /* Read the epoch. */
695 {
696 return put_user(epoch, (unsigned long __user *)arg);
697 }
698 case RTC_EPOCH_SET: /* Set the epoch. */
699 {
700 /*
701 * There were no RTC clocks before 1900.
702 */
703 if (arg < 1900)
704 return -EINVAL;
705
706 if (!capable(CAP_SYS_TIME))
707 return -EACCES;
708
709 epoch = arg;
710 return 0;
711 }
712 default:
713 return -ENOTTY;
714 }
715 return copy_to_user((void __user *)arg,
716 &wtime, sizeof wtime) ? -EFAULT : 0;
717 }
718
rtc_ioctl(struct file * file,unsigned int cmd,unsigned long arg)719 static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
720 {
721 long ret;
722 ret = rtc_do_ioctl(cmd, arg, 0);
723 return ret;
724 }
725
726 /*
727 * We enforce only one user at a time here with the open/close.
728 * Also clear the previous interrupt data on an open, and clean
729 * up things on a close.
730 */
rtc_open(struct inode * inode,struct file * file)731 static int rtc_open(struct inode *inode, struct file *file)
732 {
733 spin_lock_irq(&rtc_lock);
734
735 if (rtc_status & RTC_IS_OPEN)
736 goto out_busy;
737
738 rtc_status |= RTC_IS_OPEN;
739
740 rtc_irq_data = 0;
741 spin_unlock_irq(&rtc_lock);
742 return 0;
743
744 out_busy:
745 spin_unlock_irq(&rtc_lock);
746 return -EBUSY;
747 }
748
rtc_fasync(int fd,struct file * filp,int on)749 static int rtc_fasync(int fd, struct file *filp, int on)
750 {
751 return fasync_helper(fd, filp, on, &rtc_async_queue);
752 }
753
rtc_release(struct inode * inode,struct file * file)754 static int rtc_release(struct inode *inode, struct file *file)
755 {
756 #ifdef RTC_IRQ
757 unsigned char tmp;
758
759 if (rtc_has_irq == 0)
760 goto no_irq;
761
762 /*
763 * Turn off all interrupts once the device is no longer
764 * in use, and clear the data.
765 */
766
767 spin_lock_irq(&rtc_lock);
768 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
769 tmp = CMOS_READ(RTC_CONTROL);
770 tmp &= ~RTC_PIE;
771 tmp &= ~RTC_AIE;
772 tmp &= ~RTC_UIE;
773 CMOS_WRITE(tmp, RTC_CONTROL);
774 CMOS_READ(RTC_INTR_FLAGS);
775 }
776 if (rtc_status & RTC_TIMER_ON) {
777 rtc_status &= ~RTC_TIMER_ON;
778 del_timer(&rtc_irq_timer);
779 }
780 spin_unlock_irq(&rtc_lock);
781
782 no_irq:
783 #endif
784
785 spin_lock_irq(&rtc_lock);
786 rtc_irq_data = 0;
787 rtc_status &= ~RTC_IS_OPEN;
788 spin_unlock_irq(&rtc_lock);
789
790 return 0;
791 }
792
793 #ifdef RTC_IRQ
rtc_poll(struct file * file,poll_table * wait)794 static unsigned int rtc_poll(struct file *file, poll_table *wait)
795 {
796 unsigned long l;
797
798 if (rtc_has_irq == 0)
799 return 0;
800
801 poll_wait(file, &rtc_wait, wait);
802
803 spin_lock_irq(&rtc_lock);
804 l = rtc_irq_data;
805 spin_unlock_irq(&rtc_lock);
806
807 if (l != 0)
808 return POLLIN | POLLRDNORM;
809 return 0;
810 }
811 #endif
812
rtc_register(rtc_task_t * task)813 int rtc_register(rtc_task_t *task)
814 {
815 #ifndef RTC_IRQ
816 return -EIO;
817 #else
818 if (task == NULL || task->func == NULL)
819 return -EINVAL;
820 spin_lock_irq(&rtc_lock);
821 if (rtc_status & RTC_IS_OPEN) {
822 spin_unlock_irq(&rtc_lock);
823 return -EBUSY;
824 }
825 spin_lock(&rtc_task_lock);
826 if (rtc_callback) {
827 spin_unlock(&rtc_task_lock);
828 spin_unlock_irq(&rtc_lock);
829 return -EBUSY;
830 }
831 rtc_status |= RTC_IS_OPEN;
832 rtc_callback = task;
833 spin_unlock(&rtc_task_lock);
834 spin_unlock_irq(&rtc_lock);
835 return 0;
836 #endif
837 }
838 EXPORT_SYMBOL(rtc_register);
839
rtc_unregister(rtc_task_t * task)840 int rtc_unregister(rtc_task_t *task)
841 {
842 #ifndef RTC_IRQ
843 return -EIO;
844 #else
845 unsigned char tmp;
846
847 spin_lock_irq(&rtc_lock);
848 spin_lock(&rtc_task_lock);
849 if (rtc_callback != task) {
850 spin_unlock(&rtc_task_lock);
851 spin_unlock_irq(&rtc_lock);
852 return -ENXIO;
853 }
854 rtc_callback = NULL;
855
856 /* disable controls */
857 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
858 tmp = CMOS_READ(RTC_CONTROL);
859 tmp &= ~RTC_PIE;
860 tmp &= ~RTC_AIE;
861 tmp &= ~RTC_UIE;
862 CMOS_WRITE(tmp, RTC_CONTROL);
863 CMOS_READ(RTC_INTR_FLAGS);
864 }
865 if (rtc_status & RTC_TIMER_ON) {
866 rtc_status &= ~RTC_TIMER_ON;
867 del_timer(&rtc_irq_timer);
868 }
869 rtc_status &= ~RTC_IS_OPEN;
870 spin_unlock(&rtc_task_lock);
871 spin_unlock_irq(&rtc_lock);
872 return 0;
873 #endif
874 }
875 EXPORT_SYMBOL(rtc_unregister);
876
rtc_control(rtc_task_t * task,unsigned int cmd,unsigned long arg)877 int rtc_control(rtc_task_t *task, unsigned int cmd, unsigned long arg)
878 {
879 #ifndef RTC_IRQ
880 return -EIO;
881 #else
882 unsigned long flags;
883 if (cmd != RTC_PIE_ON && cmd != RTC_PIE_OFF && cmd != RTC_IRQP_SET)
884 return -EINVAL;
885 spin_lock_irqsave(&rtc_task_lock, flags);
886 if (rtc_callback != task) {
887 spin_unlock_irqrestore(&rtc_task_lock, flags);
888 return -ENXIO;
889 }
890 spin_unlock_irqrestore(&rtc_task_lock, flags);
891 return rtc_do_ioctl(cmd, arg, 1);
892 #endif
893 }
894 EXPORT_SYMBOL(rtc_control);
895
896 /*
897 * The various file operations we support.
898 */
899
900 static const struct file_operations rtc_fops = {
901 .owner = THIS_MODULE,
902 .llseek = no_llseek,
903 .read = rtc_read,
904 #ifdef RTC_IRQ
905 .poll = rtc_poll,
906 #endif
907 .unlocked_ioctl = rtc_ioctl,
908 .open = rtc_open,
909 .release = rtc_release,
910 .fasync = rtc_fasync,
911 };
912
913 static struct miscdevice rtc_dev = {
914 .minor = RTC_MINOR,
915 .name = "rtc",
916 .fops = &rtc_fops,
917 };
918
919 #ifdef CONFIG_PROC_FS
920 static const struct file_operations rtc_proc_fops = {
921 .owner = THIS_MODULE,
922 .open = rtc_proc_open,
923 .read = seq_read,
924 .llseek = seq_lseek,
925 .release = single_release,
926 };
927 #endif
928
929 static resource_size_t rtc_size;
930
rtc_request_region(resource_size_t size)931 static struct resource * __init rtc_request_region(resource_size_t size)
932 {
933 struct resource *r;
934
935 if (RTC_IOMAPPED)
936 r = request_region(RTC_PORT(0), size, "rtc");
937 else
938 r = request_mem_region(RTC_PORT(0), size, "rtc");
939
940 if (r)
941 rtc_size = size;
942
943 return r;
944 }
945
rtc_release_region(void)946 static void rtc_release_region(void)
947 {
948 if (RTC_IOMAPPED)
949 release_region(RTC_PORT(0), rtc_size);
950 else
951 release_mem_region(RTC_PORT(0), rtc_size);
952 }
953
rtc_init(void)954 static int __init rtc_init(void)
955 {
956 #ifdef CONFIG_PROC_FS
957 struct proc_dir_entry *ent;
958 #endif
959 #if defined(__alpha__) || defined(__mips__)
960 unsigned int year, ctrl;
961 char *guess = NULL;
962 #endif
963 #ifdef CONFIG_SPARC32
964 struct device_node *ebus_dp;
965 struct platform_device *op;
966 #else
967 void *r;
968 #ifdef RTC_IRQ
969 irq_handler_t rtc_int_handler_ptr;
970 #endif
971 #endif
972
973 #ifdef CONFIG_SPARC32
974 for_each_node_by_name(ebus_dp, "ebus") {
975 struct device_node *dp;
976 for (dp = ebus_dp; dp; dp = dp->sibling) {
977 if (!strcmp(dp->name, "rtc")) {
978 op = of_find_device_by_node(dp);
979 if (op) {
980 rtc_port = op->resource[0].start;
981 rtc_irq = op->irqs[0];
982 goto found;
983 }
984 }
985 }
986 }
987 rtc_has_irq = 0;
988 printk(KERN_ERR "rtc_init: no PC rtc found\n");
989 return -EIO;
990
991 found:
992 if (!rtc_irq) {
993 rtc_has_irq = 0;
994 goto no_irq;
995 }
996
997 /*
998 * XXX Interrupt pin #7 in Espresso is shared between RTC and
999 * PCI Slot 2 INTA# (and some INTx# in Slot 1).
1000 */
1001 if (request_irq(rtc_irq, rtc_interrupt, IRQF_SHARED, "rtc",
1002 (void *)&rtc_port)) {
1003 rtc_has_irq = 0;
1004 printk(KERN_ERR "rtc: cannot register IRQ %d\n", rtc_irq);
1005 return -EIO;
1006 }
1007 no_irq:
1008 #else
1009 r = rtc_request_region(RTC_IO_EXTENT);
1010
1011 /*
1012 * If we've already requested a smaller range (for example, because
1013 * PNPBIOS or ACPI told us how the device is configured), the request
1014 * above might fail because it's too big.
1015 *
1016 * If so, request just the range we actually use.
1017 */
1018 if (!r)
1019 r = rtc_request_region(RTC_IO_EXTENT_USED);
1020 if (!r) {
1021 #ifdef RTC_IRQ
1022 rtc_has_irq = 0;
1023 #endif
1024 printk(KERN_ERR "rtc: I/O resource %lx is not free.\n",
1025 (long)(RTC_PORT(0)));
1026 return -EIO;
1027 }
1028
1029 #ifdef RTC_IRQ
1030 if (is_hpet_enabled()) {
1031 int err;
1032
1033 rtc_int_handler_ptr = hpet_rtc_interrupt;
1034 err = hpet_register_irq_handler(rtc_interrupt);
1035 if (err != 0) {
1036 printk(KERN_WARNING "hpet_register_irq_handler failed "
1037 "in rtc_init().");
1038 return err;
1039 }
1040 } else {
1041 rtc_int_handler_ptr = rtc_interrupt;
1042 }
1043
1044 if (request_irq(RTC_IRQ, rtc_int_handler_ptr, IRQF_DISABLED,
1045 "rtc", NULL)) {
1046 /* Yeah right, seeing as irq 8 doesn't even hit the bus. */
1047 rtc_has_irq = 0;
1048 printk(KERN_ERR "rtc: IRQ %d is not free.\n", RTC_IRQ);
1049 rtc_release_region();
1050
1051 return -EIO;
1052 }
1053 hpet_rtc_timer_init();
1054
1055 #endif
1056
1057 #endif /* CONFIG_SPARC32 vs. others */
1058
1059 if (misc_register(&rtc_dev)) {
1060 #ifdef RTC_IRQ
1061 free_irq(RTC_IRQ, NULL);
1062 hpet_unregister_irq_handler(rtc_interrupt);
1063 rtc_has_irq = 0;
1064 #endif
1065 rtc_release_region();
1066 return -ENODEV;
1067 }
1068
1069 #ifdef CONFIG_PROC_FS
1070 ent = proc_create("driver/rtc", 0, NULL, &rtc_proc_fops);
1071 if (!ent)
1072 printk(KERN_WARNING "rtc: Failed to register with procfs.\n");
1073 #endif
1074
1075 #if defined(__alpha__) || defined(__mips__)
1076 rtc_freq = HZ;
1077
1078 /* Each operating system on an Alpha uses its own epoch.
1079 Let's try to guess which one we are using now. */
1080
1081 if (rtc_is_updating() != 0)
1082 msleep(20);
1083
1084 spin_lock_irq(&rtc_lock);
1085 year = CMOS_READ(RTC_YEAR);
1086 ctrl = CMOS_READ(RTC_CONTROL);
1087 spin_unlock_irq(&rtc_lock);
1088
1089 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1090 year = bcd2bin(year); /* This should never happen... */
1091
1092 if (year < 20) {
1093 epoch = 2000;
1094 guess = "SRM (post-2000)";
1095 } else if (year >= 20 && year < 48) {
1096 epoch = 1980;
1097 guess = "ARC console";
1098 } else if (year >= 48 && year < 72) {
1099 epoch = 1952;
1100 guess = "Digital UNIX";
1101 #if defined(__mips__)
1102 } else if (year >= 72 && year < 74) {
1103 epoch = 2000;
1104 guess = "Digital DECstation";
1105 #else
1106 } else if (year >= 70) {
1107 epoch = 1900;
1108 guess = "Standard PC (1900)";
1109 #endif
1110 }
1111 if (guess)
1112 printk(KERN_INFO "rtc: %s epoch (%lu) detected\n",
1113 guess, epoch);
1114 #endif
1115 #ifdef RTC_IRQ
1116 if (rtc_has_irq == 0)
1117 goto no_irq2;
1118
1119 spin_lock_irq(&rtc_lock);
1120 rtc_freq = 1024;
1121 if (!hpet_set_periodic_freq(rtc_freq)) {
1122 /*
1123 * Initialize periodic frequency to CMOS reset default,
1124 * which is 1024Hz
1125 */
1126 CMOS_WRITE(((CMOS_READ(RTC_FREQ_SELECT) & 0xF0) | 0x06),
1127 RTC_FREQ_SELECT);
1128 }
1129 spin_unlock_irq(&rtc_lock);
1130 no_irq2:
1131 #endif
1132
1133 (void) init_sysctl();
1134
1135 printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n");
1136
1137 return 0;
1138 }
1139
rtc_exit(void)1140 static void __exit rtc_exit(void)
1141 {
1142 cleanup_sysctl();
1143 remove_proc_entry("driver/rtc", NULL);
1144 misc_deregister(&rtc_dev);
1145
1146 #ifdef CONFIG_SPARC32
1147 if (rtc_has_irq)
1148 free_irq(rtc_irq, &rtc_port);
1149 #else
1150 rtc_release_region();
1151 #ifdef RTC_IRQ
1152 if (rtc_has_irq) {
1153 free_irq(RTC_IRQ, NULL);
1154 hpet_unregister_irq_handler(hpet_rtc_interrupt);
1155 }
1156 #endif
1157 #endif /* CONFIG_SPARC32 */
1158 }
1159
1160 module_init(rtc_init);
1161 module_exit(rtc_exit);
1162
1163 #ifdef RTC_IRQ
1164 /*
1165 * At IRQ rates >= 4096Hz, an interrupt may get lost altogether.
1166 * (usually during an IDE disk interrupt, with IRQ unmasking off)
1167 * Since the interrupt handler doesn't get called, the IRQ status
1168 * byte doesn't get read, and the RTC stops generating interrupts.
1169 * A timer is set, and will call this function if/when that happens.
1170 * To get it out of this stalled state, we just read the status.
1171 * At least a jiffy of interrupts (rtc_freq/HZ) will have been lost.
1172 * (You *really* shouldn't be trying to use a non-realtime system
1173 * for something that requires a steady > 1KHz signal anyways.)
1174 */
1175
rtc_dropped_irq(unsigned long data)1176 static void rtc_dropped_irq(unsigned long data)
1177 {
1178 unsigned long freq;
1179
1180 spin_lock_irq(&rtc_lock);
1181
1182 if (hpet_rtc_dropped_irq()) {
1183 spin_unlock_irq(&rtc_lock);
1184 return;
1185 }
1186
1187 /* Just in case someone disabled the timer from behind our back... */
1188 if (rtc_status & RTC_TIMER_ON)
1189 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
1190
1191 rtc_irq_data += ((rtc_freq/HZ)<<8);
1192 rtc_irq_data &= ~0xff;
1193 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0); /* restart */
1194
1195 freq = rtc_freq;
1196
1197 spin_unlock_irq(&rtc_lock);
1198
1199 printk_ratelimited(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n",
1200 freq);
1201
1202 /* Now we have new data */
1203 wake_up_interruptible(&rtc_wait);
1204
1205 kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
1206 }
1207 #endif
1208
1209 #ifdef CONFIG_PROC_FS
1210 /*
1211 * Info exported via "/proc/driver/rtc".
1212 */
1213
rtc_proc_show(struct seq_file * seq,void * v)1214 static int rtc_proc_show(struct seq_file *seq, void *v)
1215 {
1216 #define YN(bit) ((ctrl & bit) ? "yes" : "no")
1217 #define NY(bit) ((ctrl & bit) ? "no" : "yes")
1218 struct rtc_time tm;
1219 unsigned char batt, ctrl;
1220 unsigned long freq;
1221
1222 spin_lock_irq(&rtc_lock);
1223 batt = CMOS_READ(RTC_VALID) & RTC_VRT;
1224 ctrl = CMOS_READ(RTC_CONTROL);
1225 freq = rtc_freq;
1226 spin_unlock_irq(&rtc_lock);
1227
1228
1229 rtc_get_rtc_time(&tm);
1230
1231 /*
1232 * There is no way to tell if the luser has the RTC set for local
1233 * time or for Universal Standard Time (GMT). Probably local though.
1234 */
1235 seq_printf(seq,
1236 "rtc_time\t: %02d:%02d:%02d\n"
1237 "rtc_date\t: %04d-%02d-%02d\n"
1238 "rtc_epoch\t: %04lu\n",
1239 tm.tm_hour, tm.tm_min, tm.tm_sec,
1240 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, epoch);
1241
1242 get_rtc_alm_time(&tm);
1243
1244 /*
1245 * We implicitly assume 24hr mode here. Alarm values >= 0xc0 will
1246 * match any value for that particular field. Values that are
1247 * greater than a valid time, but less than 0xc0 shouldn't appear.
1248 */
1249 seq_puts(seq, "alarm\t\t: ");
1250 if (tm.tm_hour <= 24)
1251 seq_printf(seq, "%02d:", tm.tm_hour);
1252 else
1253 seq_puts(seq, "**:");
1254
1255 if (tm.tm_min <= 59)
1256 seq_printf(seq, "%02d:", tm.tm_min);
1257 else
1258 seq_puts(seq, "**:");
1259
1260 if (tm.tm_sec <= 59)
1261 seq_printf(seq, "%02d\n", tm.tm_sec);
1262 else
1263 seq_puts(seq, "**\n");
1264
1265 seq_printf(seq,
1266 "DST_enable\t: %s\n"
1267 "BCD\t\t: %s\n"
1268 "24hr\t\t: %s\n"
1269 "square_wave\t: %s\n"
1270 "alarm_IRQ\t: %s\n"
1271 "update_IRQ\t: %s\n"
1272 "periodic_IRQ\t: %s\n"
1273 "periodic_freq\t: %ld\n"
1274 "batt_status\t: %s\n",
1275 YN(RTC_DST_EN),
1276 NY(RTC_DM_BINARY),
1277 YN(RTC_24H),
1278 YN(RTC_SQWE),
1279 YN(RTC_AIE),
1280 YN(RTC_UIE),
1281 YN(RTC_PIE),
1282 freq,
1283 batt ? "okay" : "dead");
1284
1285 return 0;
1286 #undef YN
1287 #undef NY
1288 }
1289
rtc_proc_open(struct inode * inode,struct file * file)1290 static int rtc_proc_open(struct inode *inode, struct file *file)
1291 {
1292 return single_open(file, rtc_proc_show, NULL);
1293 }
1294 #endif
1295
rtc_get_rtc_time(struct rtc_time * rtc_tm)1296 static void rtc_get_rtc_time(struct rtc_time *rtc_tm)
1297 {
1298 unsigned long uip_watchdog = jiffies, flags;
1299 unsigned char ctrl;
1300 #ifdef CONFIG_MACH_DECSTATION
1301 unsigned int real_year;
1302 #endif
1303
1304 /*
1305 * read RTC once any update in progress is done. The update
1306 * can take just over 2ms. We wait 20ms. There is no need to
1307 * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
1308 * If you need to know *exactly* when a second has started, enable
1309 * periodic update complete interrupts, (via ioctl) and then
1310 * immediately read /dev/rtc which will block until you get the IRQ.
1311 * Once the read clears, read the RTC time (again via ioctl). Easy.
1312 */
1313
1314 while (rtc_is_updating() != 0 &&
1315 time_before(jiffies, uip_watchdog + 2*HZ/100))
1316 cpu_relax();
1317
1318 /*
1319 * Only the values that we read from the RTC are set. We leave
1320 * tm_wday, tm_yday and tm_isdst untouched. Note that while the
1321 * RTC has RTC_DAY_OF_WEEK, we should usually ignore it, as it is
1322 * only updated by the RTC when initially set to a non-zero value.
1323 */
1324 spin_lock_irqsave(&rtc_lock, flags);
1325 rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS);
1326 rtc_tm->tm_min = CMOS_READ(RTC_MINUTES);
1327 rtc_tm->tm_hour = CMOS_READ(RTC_HOURS);
1328 rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
1329 rtc_tm->tm_mon = CMOS_READ(RTC_MONTH);
1330 rtc_tm->tm_year = CMOS_READ(RTC_YEAR);
1331 /* Only set from 2.6.16 onwards */
1332 rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK);
1333
1334 #ifdef CONFIG_MACH_DECSTATION
1335 real_year = CMOS_READ(RTC_DEC_YEAR);
1336 #endif
1337 ctrl = CMOS_READ(RTC_CONTROL);
1338 spin_unlock_irqrestore(&rtc_lock, flags);
1339
1340 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
1341 rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
1342 rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
1343 rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
1344 rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
1345 rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
1346 rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
1347 rtc_tm->tm_wday = bcd2bin(rtc_tm->tm_wday);
1348 }
1349
1350 #ifdef CONFIG_MACH_DECSTATION
1351 rtc_tm->tm_year += real_year - 72;
1352 #endif
1353
1354 /*
1355 * Account for differences between how the RTC uses the values
1356 * and how they are defined in a struct rtc_time;
1357 */
1358 rtc_tm->tm_year += epoch - 1900;
1359 if (rtc_tm->tm_year <= 69)
1360 rtc_tm->tm_year += 100;
1361
1362 rtc_tm->tm_mon--;
1363 }
1364
get_rtc_alm_time(struct rtc_time * alm_tm)1365 static void get_rtc_alm_time(struct rtc_time *alm_tm)
1366 {
1367 unsigned char ctrl;
1368
1369 /*
1370 * Only the values that we read from the RTC are set. That
1371 * means only tm_hour, tm_min, and tm_sec.
1372 */
1373 spin_lock_irq(&rtc_lock);
1374 alm_tm->tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
1375 alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM);
1376 alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM);
1377 ctrl = CMOS_READ(RTC_CONTROL);
1378 spin_unlock_irq(&rtc_lock);
1379
1380 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
1381 alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
1382 alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
1383 alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
1384 }
1385 }
1386
1387 #ifdef RTC_IRQ
1388 /*
1389 * Used to disable/enable interrupts for any one of UIE, AIE, PIE.
1390 * Rumour has it that if you frob the interrupt enable/disable
1391 * bits in RTC_CONTROL, you should read RTC_INTR_FLAGS, to
1392 * ensure you actually start getting interrupts. Probably for
1393 * compatibility with older/broken chipset RTC implementations.
1394 * We also clear out any old irq data after an ioctl() that
1395 * meddles with the interrupt enable/disable bits.
1396 */
1397
mask_rtc_irq_bit_locked(unsigned char bit)1398 static void mask_rtc_irq_bit_locked(unsigned char bit)
1399 {
1400 unsigned char val;
1401
1402 if (hpet_mask_rtc_irq_bit(bit))
1403 return;
1404 val = CMOS_READ(RTC_CONTROL);
1405 val &= ~bit;
1406 CMOS_WRITE(val, RTC_CONTROL);
1407 CMOS_READ(RTC_INTR_FLAGS);
1408
1409 rtc_irq_data = 0;
1410 }
1411
set_rtc_irq_bit_locked(unsigned char bit)1412 static void set_rtc_irq_bit_locked(unsigned char bit)
1413 {
1414 unsigned char val;
1415
1416 if (hpet_set_rtc_irq_bit(bit))
1417 return;
1418 val = CMOS_READ(RTC_CONTROL);
1419 val |= bit;
1420 CMOS_WRITE(val, RTC_CONTROL);
1421 CMOS_READ(RTC_INTR_FLAGS);
1422
1423 rtc_irq_data = 0;
1424 }
1425 #endif
1426
1427 MODULE_AUTHOR("Paul Gortmaker");
1428 MODULE_LICENSE("GPL");
1429 MODULE_ALIAS_MISCDEV(RTC_MINOR);
1430