ia64/linux-2.6.18-xen.hg

view drivers/char/rtc.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 3e8752eb6d9c
children
line source
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 */
53 #define RTC_VERSION "1.12ac"
55 /*
56 * Note that *all* calls to CMOS_READ and CMOS_WRITE are done with
57 * interrupts disabled. Due to the index-port/data-port (0x70/0x71)
58 * design of the RTC, we don't want two different things trying to
59 * get to it at once. (e.g. the periodic 11 min sync from time.c vs.
60 * this driver.)
61 */
63 #include <linux/interrupt.h>
64 #include <linux/module.h>
65 #include <linux/kernel.h>
66 #include <linux/types.h>
67 #include <linux/miscdevice.h>
68 #include <linux/ioport.h>
69 #include <linux/fcntl.h>
70 #include <linux/mc146818rtc.h>
71 #include <linux/init.h>
72 #include <linux/poll.h>
73 #include <linux/proc_fs.h>
74 #include <linux/seq_file.h>
75 #include <linux/spinlock.h>
76 #include <linux/sysctl.h>
77 #include <linux/wait.h>
78 #include <linux/bcd.h>
79 #include <linux/delay.h>
81 #include <asm/current.h>
82 #include <asm/uaccess.h>
83 #include <asm/system.h>
85 #if defined(__i386__)
86 #include <asm/hpet.h>
87 #endif
89 #ifdef __sparc__
90 #include <linux/pci.h>
91 #include <asm/ebus.h>
92 #ifdef __sparc_v9__
93 #include <asm/isa.h>
94 #endif
96 static unsigned long rtc_port;
97 static int rtc_irq = PCI_IRQ_NONE;
98 #endif
100 #ifdef CONFIG_HPET_RTC_IRQ
101 #undef RTC_IRQ
102 #endif
104 #ifdef RTC_IRQ
105 static int rtc_has_irq = 1;
106 #endif
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 static inline irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs) {return 0;}
117 #else
118 extern irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
119 #endif
121 /*
122 * We sponge a minor off of the misc major. No need slurping
123 * up another valuable major dev number for this. If you add
124 * an ioctl, make sure you don't conflict with SPARC's RTC
125 * ioctls.
126 */
128 static struct fasync_struct *rtc_async_queue;
130 static DECLARE_WAIT_QUEUE_HEAD(rtc_wait);
132 #ifdef RTC_IRQ
133 static struct timer_list rtc_irq_timer;
134 #endif
136 static ssize_t rtc_read(struct file *file, char __user *buf,
137 size_t count, loff_t *ppos);
139 static int rtc_ioctl(struct inode *inode, struct file *file,
140 unsigned int cmd, unsigned long arg);
142 #ifdef RTC_IRQ
143 static unsigned int rtc_poll(struct file *file, poll_table *wait);
144 #endif
146 static void get_rtc_alm_time (struct rtc_time *alm_tm);
147 #ifdef RTC_IRQ
148 static void rtc_dropped_irq(unsigned long data);
150 static void set_rtc_irq_bit_locked(unsigned char bit);
151 static void mask_rtc_irq_bit_locked(unsigned char bit);
153 static inline void set_rtc_irq_bit(unsigned char bit)
154 {
155 spin_lock_irq(&rtc_lock);
156 set_rtc_irq_bit_locked(bit);
157 spin_unlock_irq(&rtc_lock);
158 }
160 static void mask_rtc_irq_bit(unsigned char bit)
161 {
162 spin_lock_irq(&rtc_lock);
163 mask_rtc_irq_bit_locked(bit);
164 spin_unlock_irq(&rtc_lock);
165 }
166 #endif
168 static int rtc_proc_open(struct inode *inode, struct file *file);
170 /*
171 * Bits in rtc_status. (6 bits of room for future expansion)
172 */
174 #define RTC_IS_OPEN 0x01 /* means /dev/rtc is in use */
175 #define RTC_TIMER_ON 0x02 /* missed irq timer active */
177 /*
178 * rtc_status is never changed by rtc_interrupt, and ioctl/open/close is
179 * protected by the big kernel lock. However, ioctl can still disable the timer
180 * in rtc_status and then with del_timer after the interrupt has read
181 * rtc_status but before mod_timer is called, which would then reenable the
182 * timer (but you would need to have an awful timing before you'd trip on it)
183 */
184 static unsigned long rtc_status = 0; /* bitmapped status byte. */
185 static unsigned long rtc_freq = 0; /* Current periodic IRQ rate */
186 static unsigned long rtc_irq_data = 0; /* our output to the world */
187 static unsigned long rtc_max_user_freq = 64; /* > this, need CAP_SYS_RESOURCE */
189 #ifdef RTC_IRQ
190 /*
191 * rtc_task_lock nests inside rtc_lock.
192 */
193 static DEFINE_SPINLOCK(rtc_task_lock);
194 static rtc_task_t *rtc_callback = NULL;
195 #endif
197 /*
198 * If this driver ever becomes modularised, it will be really nice
199 * to make the epoch retain its value across module reload...
200 */
202 static unsigned long epoch = 1900; /* year corresponding to 0x00 */
204 static const unsigned char days_in_mo[] =
205 {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
207 /*
208 * Returns true if a clock update is in progress
209 */
210 static inline unsigned char rtc_is_updating(void)
211 {
212 unsigned long flags;
213 unsigned char uip;
215 spin_lock_irqsave(&rtc_lock, flags);
216 uip = (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP);
217 spin_unlock_irqrestore(&rtc_lock, flags);
218 return uip;
219 }
221 #ifdef RTC_IRQ
222 /*
223 * A very tiny interrupt handler. It runs with IRQF_DISABLED set,
224 * but there is possibility of conflicting with the set_rtc_mmss()
225 * call (the rtc irq and the timer irq can easily run at the same
226 * time in two different CPUs). So we need to serialize
227 * accesses to the chip with the rtc_lock spinlock that each
228 * architecture should implement in the timer code.
229 * (See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.)
230 */
232 irqreturn_t rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
233 {
234 /*
235 * Can be an alarm interrupt, update complete interrupt,
236 * or a periodic interrupt. We store the status in the
237 * low byte and the number of interrupts received since
238 * the last read in the remainder of rtc_irq_data.
239 */
241 spin_lock (&rtc_lock);
242 rtc_irq_data += 0x100;
243 rtc_irq_data &= ~0xff;
244 if (is_hpet_enabled()) {
245 /*
246 * In this case it is HPET RTC interrupt handler
247 * calling us, with the interrupt information
248 * passed as arg1, instead of irq.
249 */
250 rtc_irq_data |= (unsigned long)irq & 0xF0;
251 } else {
252 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
253 }
255 if (rtc_status & RTC_TIMER_ON)
256 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
258 spin_unlock (&rtc_lock);
260 /* Now do the rest of the actions */
261 spin_lock(&rtc_task_lock);
262 if (rtc_callback)
263 rtc_callback->func(rtc_callback->private_data);
264 spin_unlock(&rtc_task_lock);
265 wake_up_interruptible(&rtc_wait);
267 kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);
269 return IRQ_HANDLED;
270 }
271 #endif
273 /*
274 * sysctl-tuning infrastructure.
275 */
276 static ctl_table rtc_table[] = {
277 {
278 .ctl_name = 1,
279 .procname = "max-user-freq",
280 .data = &rtc_max_user_freq,
281 .maxlen = sizeof(int),
282 .mode = 0644,
283 .proc_handler = &proc_dointvec,
284 },
285 { .ctl_name = 0 }
286 };
288 static ctl_table rtc_root[] = {
289 {
290 .ctl_name = 1,
291 .procname = "rtc",
292 .maxlen = 0,
293 .mode = 0555,
294 .child = rtc_table,
295 },
296 { .ctl_name = 0 }
297 };
299 static ctl_table dev_root[] = {
300 {
301 .ctl_name = CTL_DEV,
302 .procname = "dev",
303 .maxlen = 0,
304 .mode = 0555,
305 .child = rtc_root,
306 },
307 { .ctl_name = 0 }
308 };
310 static struct ctl_table_header *sysctl_header;
312 static int __init init_sysctl(void)
313 {
314 sysctl_header = register_sysctl_table(dev_root, 0);
315 return 0;
316 }
318 static void __exit cleanup_sysctl(void)
319 {
320 unregister_sysctl_table(sysctl_header);
321 }
323 /*
324 * Now all the various file operations that we export.
325 */
327 static ssize_t rtc_read(struct file *file, char __user *buf,
328 size_t count, loff_t *ppos)
329 {
330 #ifndef RTC_IRQ
331 return -EIO;
332 #else
333 DECLARE_WAITQUEUE(wait, current);
334 unsigned long data;
335 ssize_t retval;
337 if (rtc_has_irq == 0)
338 return -EIO;
340 /*
341 * Historically this function used to assume that sizeof(unsigned long)
342 * is the same in userspace and kernelspace. This lead to problems
343 * for configurations with multiple ABIs such a the MIPS o32 and 64
344 * ABIs supported on the same kernel. So now we support read of both
345 * 4 and 8 bytes and assume that's the sizeof(unsigned long) in the
346 * userspace ABI.
347 */
348 if (count != sizeof(unsigned int) && count != sizeof(unsigned long))
349 return -EINVAL;
351 add_wait_queue(&rtc_wait, &wait);
353 do {
354 /* First make it right. Then make it fast. Putting this whole
355 * block within the parentheses of a while would be too
356 * confusing. And no, xchg() is not the answer. */
358 __set_current_state(TASK_INTERRUPTIBLE);
360 spin_lock_irq (&rtc_lock);
361 data = rtc_irq_data;
362 rtc_irq_data = 0;
363 spin_unlock_irq (&rtc_lock);
365 if (data != 0)
366 break;
368 if (file->f_flags & O_NONBLOCK) {
369 retval = -EAGAIN;
370 goto out;
371 }
372 if (signal_pending(current)) {
373 retval = -ERESTARTSYS;
374 goto out;
375 }
376 schedule();
377 } while (1);
379 if (count == sizeof(unsigned int))
380 retval = put_user(data, (unsigned int __user *)buf) ?: sizeof(int);
381 else
382 retval = put_user(data, (unsigned long __user *)buf) ?: sizeof(long);
383 if (!retval)
384 retval = count;
385 out:
386 current->state = TASK_RUNNING;
387 remove_wait_queue(&rtc_wait, &wait);
389 return retval;
390 #endif
391 }
393 static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
394 {
395 struct rtc_time wtime;
397 #ifdef RTC_IRQ
398 if (rtc_has_irq == 0) {
399 switch (cmd) {
400 case RTC_AIE_OFF:
401 case RTC_AIE_ON:
402 case RTC_PIE_OFF:
403 case RTC_PIE_ON:
404 case RTC_UIE_OFF:
405 case RTC_UIE_ON:
406 case RTC_IRQP_READ:
407 case RTC_IRQP_SET:
408 return -EINVAL;
409 };
410 }
411 #endif
413 switch (cmd) {
414 #ifdef RTC_IRQ
415 case RTC_AIE_OFF: /* Mask alarm int. enab. bit */
416 {
417 mask_rtc_irq_bit(RTC_AIE);
418 return 0;
419 }
420 case RTC_AIE_ON: /* Allow alarm interrupts. */
421 {
422 set_rtc_irq_bit(RTC_AIE);
423 return 0;
424 }
425 case RTC_PIE_OFF: /* Mask periodic int. enab. bit */
426 {
427 unsigned long flags; /* can be called from isr via rtc_control() */
428 spin_lock_irqsave (&rtc_lock, flags);
429 mask_rtc_irq_bit_locked(RTC_PIE);
430 if (rtc_status & RTC_TIMER_ON) {
431 rtc_status &= ~RTC_TIMER_ON;
432 del_timer(&rtc_irq_timer);
433 }
434 spin_unlock_irqrestore (&rtc_lock, flags);
435 return 0;
436 }
437 case RTC_PIE_ON: /* Allow periodic ints */
438 {
439 unsigned long flags; /* can be called from isr via rtc_control() */
440 /*
441 * We don't really want Joe User enabling more
442 * than 64Hz of interrupts on a multi-user machine.
443 */
444 if (!kernel && (rtc_freq > rtc_max_user_freq) &&
445 (!capable(CAP_SYS_RESOURCE)))
446 return -EACCES;
448 spin_lock_irqsave (&rtc_lock, flags);
449 if (!(rtc_status & RTC_TIMER_ON)) {
450 rtc_irq_timer.expires = jiffies + HZ/rtc_freq + 2*HZ/100;
451 add_timer(&rtc_irq_timer);
452 rtc_status |= RTC_TIMER_ON;
453 }
454 set_rtc_irq_bit_locked(RTC_PIE);
455 spin_unlock_irqrestore (&rtc_lock, flags);
456 return 0;
457 }
458 case RTC_UIE_OFF: /* Mask ints from RTC updates. */
459 {
460 mask_rtc_irq_bit(RTC_UIE);
461 return 0;
462 }
463 case RTC_UIE_ON: /* Allow ints for RTC updates. */
464 {
465 set_rtc_irq_bit(RTC_UIE);
466 return 0;
467 }
468 #endif
469 case RTC_ALM_READ: /* Read the present alarm time */
470 {
471 /*
472 * This returns a struct rtc_time. Reading >= 0xc0
473 * means "don't care" or "match all". Only the tm_hour,
474 * tm_min, and tm_sec values are filled in.
475 */
476 memset(&wtime, 0, sizeof(struct rtc_time));
477 get_rtc_alm_time(&wtime);
478 break;
479 }
480 case RTC_ALM_SET: /* Store a time into the alarm */
481 {
482 /*
483 * This expects a struct rtc_time. Writing 0xff means
484 * "don't care" or "match all". Only the tm_hour,
485 * tm_min and tm_sec are used.
486 */
487 unsigned char hrs, min, sec;
488 struct rtc_time alm_tm;
490 if (copy_from_user(&alm_tm, (struct rtc_time __user *)arg,
491 sizeof(struct rtc_time)))
492 return -EFAULT;
494 hrs = alm_tm.tm_hour;
495 min = alm_tm.tm_min;
496 sec = alm_tm.tm_sec;
498 spin_lock_irq(&rtc_lock);
499 if (hpet_set_alarm_time(hrs, min, sec)) {
500 /*
501 * Fallthru and set alarm time in CMOS too,
502 * so that we will get proper value in RTC_ALM_READ
503 */
504 }
505 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) ||
506 RTC_ALWAYS_BCD)
507 {
508 if (sec < 60) BIN_TO_BCD(sec);
509 else sec = 0xff;
511 if (min < 60) BIN_TO_BCD(min);
512 else min = 0xff;
514 if (hrs < 24) BIN_TO_BCD(hrs);
515 else hrs = 0xff;
516 }
517 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
518 CMOS_WRITE(min, RTC_MINUTES_ALARM);
519 CMOS_WRITE(sec, RTC_SECONDS_ALARM);
520 spin_unlock_irq(&rtc_lock);
522 return 0;
523 }
524 case RTC_RD_TIME: /* Read the time/date from RTC */
525 {
526 memset(&wtime, 0, sizeof(struct rtc_time));
527 rtc_get_rtc_time(&wtime);
528 break;
529 }
530 case RTC_SET_TIME: /* Set the RTC */
531 {
532 struct rtc_time rtc_tm;
533 unsigned char mon, day, hrs, min, sec, leap_yr;
534 unsigned char save_control, save_freq_select;
535 unsigned int yrs;
536 #ifdef CONFIG_MACH_DECSTATION
537 unsigned int real_yrs;
538 #endif
540 if (!capable(CAP_SYS_TIME))
541 return -EACCES;
543 if (copy_from_user(&rtc_tm, (struct rtc_time __user *)arg,
544 sizeof(struct rtc_time)))
545 return -EFAULT;
547 yrs = rtc_tm.tm_year + 1900;
548 mon = rtc_tm.tm_mon + 1; /* tm_mon starts at zero */
549 day = rtc_tm.tm_mday;
550 hrs = rtc_tm.tm_hour;
551 min = rtc_tm.tm_min;
552 sec = rtc_tm.tm_sec;
554 if (yrs < 1970)
555 return -EINVAL;
557 leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
559 if ((mon > 12) || (day == 0))
560 return -EINVAL;
562 if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
563 return -EINVAL;
565 if ((hrs >= 24) || (min >= 60) || (sec >= 60))
566 return -EINVAL;
568 if ((yrs -= epoch) > 255) /* They are unsigned */
569 return -EINVAL;
571 spin_lock_irq(&rtc_lock);
572 #ifdef CONFIG_MACH_DECSTATION
573 real_yrs = yrs;
574 yrs = 72;
576 /*
577 * We want to keep the year set to 73 until March
578 * for non-leap years, so that Feb, 29th is handled
579 * correctly.
580 */
581 if (!leap_yr && mon < 3) {
582 real_yrs--;
583 yrs = 73;
584 }
585 #endif
586 /* These limits and adjustments are independent of
587 * whether the chip is in binary mode or not.
588 */
589 if (yrs > 169) {
590 spin_unlock_irq(&rtc_lock);
591 return -EINVAL;
592 }
593 if (yrs >= 100)
594 yrs -= 100;
596 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)
597 || RTC_ALWAYS_BCD) {
598 BIN_TO_BCD(sec);
599 BIN_TO_BCD(min);
600 BIN_TO_BCD(hrs);
601 BIN_TO_BCD(day);
602 BIN_TO_BCD(mon);
603 BIN_TO_BCD(yrs);
604 }
606 save_control = CMOS_READ(RTC_CONTROL);
607 CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
608 save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
609 CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
611 #ifdef CONFIG_MACH_DECSTATION
612 CMOS_WRITE(real_yrs, RTC_DEC_YEAR);
613 #endif
614 CMOS_WRITE(yrs, RTC_YEAR);
615 CMOS_WRITE(mon, RTC_MONTH);
616 CMOS_WRITE(day, RTC_DAY_OF_MONTH);
617 CMOS_WRITE(hrs, RTC_HOURS);
618 CMOS_WRITE(min, RTC_MINUTES);
619 CMOS_WRITE(sec, RTC_SECONDS);
621 CMOS_WRITE(save_control, RTC_CONTROL);
622 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
624 spin_unlock_irq(&rtc_lock);
625 return 0;
626 }
627 #ifdef RTC_IRQ
628 case RTC_IRQP_READ: /* Read the periodic IRQ rate. */
629 {
630 return put_user(rtc_freq, (unsigned long __user *)arg);
631 }
632 case RTC_IRQP_SET: /* Set periodic IRQ rate. */
633 {
634 int tmp = 0;
635 unsigned char val;
636 unsigned long flags; /* can be called from isr via rtc_control() */
638 /*
639 * The max we can do is 8192Hz.
640 */
641 if ((arg < 2) || (arg > 8192))
642 return -EINVAL;
643 /*
644 * We don't really want Joe User generating more
645 * than 64Hz of interrupts on a multi-user machine.
646 */
647 if (!kernel && (arg > rtc_max_user_freq) && (!capable(CAP_SYS_RESOURCE)))
648 return -EACCES;
650 while (arg > (1<<tmp))
651 tmp++;
653 /*
654 * Check that the input was really a power of 2.
655 */
656 if (arg != (1<<tmp))
657 return -EINVAL;
659 spin_lock_irqsave(&rtc_lock, flags);
660 if (hpet_set_periodic_freq(arg)) {
661 spin_unlock_irqrestore(&rtc_lock, flags);
662 return 0;
663 }
664 rtc_freq = arg;
666 val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0;
667 val |= (16 - tmp);
668 CMOS_WRITE(val, RTC_FREQ_SELECT);
669 spin_unlock_irqrestore(&rtc_lock, flags);
670 return 0;
671 }
672 #endif
673 case RTC_EPOCH_READ: /* Read the epoch. */
674 {
675 return put_user (epoch, (unsigned long __user *)arg);
676 }
677 case RTC_EPOCH_SET: /* Set the epoch. */
678 {
679 /*
680 * There were no RTC clocks before 1900.
681 */
682 if (arg < 1900)
683 return -EINVAL;
685 if (!capable(CAP_SYS_TIME))
686 return -EACCES;
688 epoch = arg;
689 return 0;
690 }
691 default:
692 return -ENOTTY;
693 }
694 return copy_to_user((void __user *)arg, &wtime, sizeof wtime) ? -EFAULT : 0;
695 }
697 static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
698 unsigned long arg)
699 {
700 return rtc_do_ioctl(cmd, arg, 0);
701 }
703 /*
704 * We enforce only one user at a time here with the open/close.
705 * Also clear the previous interrupt data on an open, and clean
706 * up things on a close.
707 */
709 /* We use rtc_lock to protect against concurrent opens. So the BKL is not
710 * needed here. Or anywhere else in this driver. */
711 static int rtc_open(struct inode *inode, struct file *file)
712 {
713 spin_lock_irq (&rtc_lock);
715 if(rtc_status & RTC_IS_OPEN)
716 goto out_busy;
718 rtc_status |= RTC_IS_OPEN;
720 rtc_irq_data = 0;
721 spin_unlock_irq (&rtc_lock);
722 return 0;
724 out_busy:
725 spin_unlock_irq (&rtc_lock);
726 return -EBUSY;
727 }
729 static int rtc_fasync (int fd, struct file *filp, int on)
731 {
732 return fasync_helper (fd, filp, on, &rtc_async_queue);
733 }
735 static int rtc_release(struct inode *inode, struct file *file)
736 {
737 #ifdef RTC_IRQ
738 unsigned char tmp;
740 if (rtc_has_irq == 0)
741 goto no_irq;
743 /*
744 * Turn off all interrupts once the device is no longer
745 * in use, and clear the data.
746 */
748 spin_lock_irq(&rtc_lock);
749 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
750 tmp = CMOS_READ(RTC_CONTROL);
751 tmp &= ~RTC_PIE;
752 tmp &= ~RTC_AIE;
753 tmp &= ~RTC_UIE;
754 CMOS_WRITE(tmp, RTC_CONTROL);
755 CMOS_READ(RTC_INTR_FLAGS);
756 }
757 if (rtc_status & RTC_TIMER_ON) {
758 rtc_status &= ~RTC_TIMER_ON;
759 del_timer(&rtc_irq_timer);
760 }
761 spin_unlock_irq(&rtc_lock);
763 if (file->f_flags & FASYNC) {
764 rtc_fasync (-1, file, 0);
765 }
766 no_irq:
767 #endif
769 spin_lock_irq (&rtc_lock);
770 rtc_irq_data = 0;
771 rtc_status &= ~RTC_IS_OPEN;
772 spin_unlock_irq (&rtc_lock);
773 return 0;
774 }
776 #ifdef RTC_IRQ
777 /* Called without the kernel lock - fine */
778 static unsigned int rtc_poll(struct file *file, poll_table *wait)
779 {
780 unsigned long l;
782 if (rtc_has_irq == 0)
783 return 0;
785 poll_wait(file, &rtc_wait, wait);
787 spin_lock_irq (&rtc_lock);
788 l = rtc_irq_data;
789 spin_unlock_irq (&rtc_lock);
791 if (l != 0)
792 return POLLIN | POLLRDNORM;
793 return 0;
794 }
795 #endif
797 /*
798 * exported stuffs
799 */
801 EXPORT_SYMBOL(rtc_register);
802 EXPORT_SYMBOL(rtc_unregister);
803 EXPORT_SYMBOL(rtc_control);
805 int rtc_register(rtc_task_t *task)
806 {
807 #ifndef RTC_IRQ
808 return -EIO;
809 #else
810 if (task == NULL || task->func == NULL)
811 return -EINVAL;
812 spin_lock_irq(&rtc_lock);
813 if (rtc_status & RTC_IS_OPEN) {
814 spin_unlock_irq(&rtc_lock);
815 return -EBUSY;
816 }
817 spin_lock(&rtc_task_lock);
818 if (rtc_callback) {
819 spin_unlock(&rtc_task_lock);
820 spin_unlock_irq(&rtc_lock);
821 return -EBUSY;
822 }
823 rtc_status |= RTC_IS_OPEN;
824 rtc_callback = task;
825 spin_unlock(&rtc_task_lock);
826 spin_unlock_irq(&rtc_lock);
827 return 0;
828 #endif
829 }
831 int rtc_unregister(rtc_task_t *task)
832 {
833 #ifndef RTC_IRQ
834 return -EIO;
835 #else
836 unsigned char tmp;
838 spin_lock_irq(&rtc_lock);
839 spin_lock(&rtc_task_lock);
840 if (rtc_callback != task) {
841 spin_unlock(&rtc_task_lock);
842 spin_unlock_irq(&rtc_lock);
843 return -ENXIO;
844 }
845 rtc_callback = NULL;
847 /* disable controls */
848 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
849 tmp = CMOS_READ(RTC_CONTROL);
850 tmp &= ~RTC_PIE;
851 tmp &= ~RTC_AIE;
852 tmp &= ~RTC_UIE;
853 CMOS_WRITE(tmp, RTC_CONTROL);
854 CMOS_READ(RTC_INTR_FLAGS);
855 }
856 if (rtc_status & RTC_TIMER_ON) {
857 rtc_status &= ~RTC_TIMER_ON;
858 del_timer(&rtc_irq_timer);
859 }
860 rtc_status &= ~RTC_IS_OPEN;
861 spin_unlock(&rtc_task_lock);
862 spin_unlock_irq(&rtc_lock);
863 return 0;
864 #endif
865 }
867 int rtc_control(rtc_task_t *task, unsigned int cmd, unsigned long arg)
868 {
869 #ifndef RTC_IRQ
870 return -EIO;
871 #else
872 unsigned long flags;
873 if (cmd != RTC_PIE_ON && cmd != RTC_PIE_OFF && cmd != RTC_IRQP_SET)
874 return -EINVAL;
875 spin_lock_irqsave(&rtc_task_lock, flags);
876 if (rtc_callback != task) {
877 spin_unlock_irqrestore(&rtc_task_lock, flags);
878 return -ENXIO;
879 }
880 spin_unlock_irqrestore(&rtc_task_lock, flags);
881 return rtc_do_ioctl(cmd, arg, 1);
882 #endif
883 }
886 /*
887 * The various file operations we support.
888 */
890 static const struct file_operations rtc_fops = {
891 .owner = THIS_MODULE,
892 .llseek = no_llseek,
893 .read = rtc_read,
894 #ifdef RTC_IRQ
895 .poll = rtc_poll,
896 #endif
897 .ioctl = rtc_ioctl,
898 .open = rtc_open,
899 .release = rtc_release,
900 .fasync = rtc_fasync,
901 };
903 static struct miscdevice rtc_dev = {
904 .minor = RTC_MINOR,
905 .name = "rtc",
906 .fops = &rtc_fops,
907 };
909 static const struct file_operations rtc_proc_fops = {
910 .owner = THIS_MODULE,
911 .open = rtc_proc_open,
912 .read = seq_read,
913 .llseek = seq_lseek,
914 .release = single_release,
915 };
917 #if defined(RTC_IRQ) && !defined(__sparc__)
918 static irqreturn_t (*rtc_int_handler_ptr)(int irq, void *dev_id, struct pt_regs *regs);
919 #endif
921 static int __init rtc_init(void)
922 {
923 struct proc_dir_entry *ent;
924 #if defined(__alpha__) || defined(__mips__)
925 unsigned int year, ctrl;
926 char *guess = NULL;
927 #endif
928 #ifdef __sparc__
929 struct linux_ebus *ebus;
930 struct linux_ebus_device *edev;
931 #ifdef __sparc_v9__
932 struct sparc_isa_bridge *isa_br;
933 struct sparc_isa_device *isa_dev;
934 #endif
935 #endif
936 #ifndef __sparc__
937 void *r;
938 #endif
940 #ifdef __sparc__
941 for_each_ebus(ebus) {
942 for_each_ebusdev(edev, ebus) {
943 if(strcmp(edev->prom_node->name, "rtc") == 0) {
944 rtc_port = edev->resource[0].start;
945 rtc_irq = edev->irqs[0];
946 goto found;
947 }
948 }
949 }
950 #ifdef __sparc_v9__
951 for_each_isa(isa_br) {
952 for_each_isadev(isa_dev, isa_br) {
953 if (strcmp(isa_dev->prom_node->name, "rtc") == 0) {
954 rtc_port = isa_dev->resource.start;
955 rtc_irq = isa_dev->irq;
956 goto found;
957 }
958 }
959 }
960 #endif
961 printk(KERN_ERR "rtc_init: no PC rtc found\n");
962 return -EIO;
964 found:
965 if (rtc_irq == PCI_IRQ_NONE) {
966 rtc_has_irq = 0;
967 goto no_irq;
968 }
970 /*
971 * XXX Interrupt pin #7 in Espresso is shared between RTC and
972 * PCI Slot 2 INTA# (and some INTx# in Slot 1).
973 */
974 if (request_irq(rtc_irq, rtc_interrupt, IRQF_SHARED, "rtc", (void *)&rtc_port)) {
975 printk(KERN_ERR "rtc: cannot register IRQ %d\n", rtc_irq);
976 return -EIO;
977 }
978 no_irq:
979 #else
980 if (RTC_IOMAPPED)
981 r = request_region(RTC_PORT(0), RTC_IO_EXTENT, "rtc");
982 else
983 r = request_mem_region(RTC_PORT(0), RTC_IO_EXTENT, "rtc");
984 if (!r) {
985 printk(KERN_ERR "rtc: I/O resource %lx is not free.\n",
986 (long)(RTC_PORT(0)));
987 return -EIO;
988 }
990 #ifdef RTC_IRQ
991 if (is_hpet_enabled()) {
992 rtc_int_handler_ptr = hpet_rtc_interrupt;
993 } else {
994 rtc_int_handler_ptr = rtc_interrupt;
995 }
997 if(request_irq(RTC_IRQ, rtc_int_handler_ptr, IRQF_DISABLED, "rtc", NULL)) {
998 /* Yeah right, seeing as irq 8 doesn't even hit the bus. */
999 printk(KERN_ERR "rtc: IRQ %d is not free.\n", RTC_IRQ);
1000 if (RTC_IOMAPPED)
1001 release_region(RTC_PORT(0), RTC_IO_EXTENT);
1002 else
1003 release_mem_region(RTC_PORT(0), RTC_IO_EXTENT);
1004 return -EIO;
1006 hpet_rtc_timer_init();
1008 #endif
1010 #endif /* __sparc__ vs. others */
1012 if (misc_register(&rtc_dev)) {
1013 #ifdef RTC_IRQ
1014 free_irq(RTC_IRQ, NULL);
1015 #endif
1016 release_region(RTC_PORT(0), RTC_IO_EXTENT);
1017 return -ENODEV;
1020 ent = create_proc_entry("driver/rtc", 0, NULL);
1021 if (!ent) {
1022 #ifdef RTC_IRQ
1023 free_irq(RTC_IRQ, NULL);
1024 #endif
1025 release_region(RTC_PORT(0), RTC_IO_EXTENT);
1026 misc_deregister(&rtc_dev);
1027 return -ENOMEM;
1029 ent->proc_fops = &rtc_proc_fops;
1031 #if defined(__alpha__) || defined(__mips__)
1032 rtc_freq = HZ;
1034 /* Each operating system on an Alpha uses its own epoch.
1035 Let's try to guess which one we are using now. */
1037 if (rtc_is_updating() != 0)
1038 msleep(20);
1040 spin_lock_irq(&rtc_lock);
1041 year = CMOS_READ(RTC_YEAR);
1042 ctrl = CMOS_READ(RTC_CONTROL);
1043 spin_unlock_irq(&rtc_lock);
1045 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1046 BCD_TO_BIN(year); /* This should never happen... */
1048 if (year < 20) {
1049 epoch = 2000;
1050 guess = "SRM (post-2000)";
1051 } else if (year >= 20 && year < 48) {
1052 epoch = 1980;
1053 guess = "ARC console";
1054 } else if (year >= 48 && year < 72) {
1055 epoch = 1952;
1056 guess = "Digital UNIX";
1057 #if defined(__mips__)
1058 } else if (year >= 72 && year < 74) {
1059 epoch = 2000;
1060 guess = "Digital DECstation";
1061 #else
1062 } else if (year >= 70) {
1063 epoch = 1900;
1064 guess = "Standard PC (1900)";
1065 #endif
1067 if (guess)
1068 printk(KERN_INFO "rtc: %s epoch (%lu) detected\n", guess, epoch);
1069 #endif
1070 #ifdef RTC_IRQ
1071 if (rtc_has_irq == 0)
1072 goto no_irq2;
1074 init_timer(&rtc_irq_timer);
1075 rtc_irq_timer.function = rtc_dropped_irq;
1076 spin_lock_irq(&rtc_lock);
1077 rtc_freq = 1024;
1078 if (!hpet_set_periodic_freq(rtc_freq)) {
1079 /* Initialize periodic freq. to CMOS reset default, which is 1024Hz */
1080 CMOS_WRITE(((CMOS_READ(RTC_FREQ_SELECT) & 0xF0) | 0x06), RTC_FREQ_SELECT);
1082 spin_unlock_irq(&rtc_lock);
1083 no_irq2:
1084 #endif
1086 (void) init_sysctl();
1088 printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n");
1090 return 0;
1093 static void __exit rtc_exit (void)
1095 cleanup_sysctl();
1096 remove_proc_entry ("driver/rtc", NULL);
1097 misc_deregister(&rtc_dev);
1099 #ifdef __sparc__
1100 if (rtc_has_irq)
1101 free_irq (rtc_irq, &rtc_port);
1102 #else
1103 if (RTC_IOMAPPED)
1104 release_region(RTC_PORT(0), RTC_IO_EXTENT);
1105 else
1106 release_mem_region(RTC_PORT(0), RTC_IO_EXTENT);
1107 #ifdef RTC_IRQ
1108 if (rtc_has_irq)
1109 free_irq (RTC_IRQ, NULL);
1110 #endif
1111 #endif /* __sparc__ */
1114 module_init(rtc_init);
1115 module_exit(rtc_exit);
1117 #ifdef RTC_IRQ
1118 /*
1119 * At IRQ rates >= 4096Hz, an interrupt may get lost altogether.
1120 * (usually during an IDE disk interrupt, with IRQ unmasking off)
1121 * Since the interrupt handler doesn't get called, the IRQ status
1122 * byte doesn't get read, and the RTC stops generating interrupts.
1123 * A timer is set, and will call this function if/when that happens.
1124 * To get it out of this stalled state, we just read the status.
1125 * At least a jiffy of interrupts (rtc_freq/HZ) will have been lost.
1126 * (You *really* shouldn't be trying to use a non-realtime system
1127 * for something that requires a steady > 1KHz signal anyways.)
1128 */
1130 static void rtc_dropped_irq(unsigned long data)
1132 unsigned long freq;
1134 spin_lock_irq (&rtc_lock);
1136 if (hpet_rtc_dropped_irq()) {
1137 spin_unlock_irq(&rtc_lock);
1138 return;
1141 /* Just in case someone disabled the timer from behind our back... */
1142 if (rtc_status & RTC_TIMER_ON)
1143 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
1145 rtc_irq_data += ((rtc_freq/HZ)<<8);
1146 rtc_irq_data &= ~0xff;
1147 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0); /* restart */
1149 freq = rtc_freq;
1151 spin_unlock_irq(&rtc_lock);
1153 printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n", freq);
1155 /* Now we have new data */
1156 wake_up_interruptible(&rtc_wait);
1158 kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);
1160 #endif
1162 /*
1163 * Info exported via "/proc/driver/rtc".
1164 */
1166 static int rtc_proc_show(struct seq_file *seq, void *v)
1168 #define YN(bit) ((ctrl & bit) ? "yes" : "no")
1169 #define NY(bit) ((ctrl & bit) ? "no" : "yes")
1170 struct rtc_time tm;
1171 unsigned char batt, ctrl;
1172 unsigned long freq;
1174 spin_lock_irq(&rtc_lock);
1175 batt = CMOS_READ(RTC_VALID) & RTC_VRT;
1176 ctrl = CMOS_READ(RTC_CONTROL);
1177 freq = rtc_freq;
1178 spin_unlock_irq(&rtc_lock);
1181 rtc_get_rtc_time(&tm);
1183 /*
1184 * There is no way to tell if the luser has the RTC set for local
1185 * time or for Universal Standard Time (GMT). Probably local though.
1186 */
1187 seq_printf(seq,
1188 "rtc_time\t: %02d:%02d:%02d\n"
1189 "rtc_date\t: %04d-%02d-%02d\n"
1190 "rtc_epoch\t: %04lu\n",
1191 tm.tm_hour, tm.tm_min, tm.tm_sec,
1192 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, epoch);
1194 get_rtc_alm_time(&tm);
1196 /*
1197 * We implicitly assume 24hr mode here. Alarm values >= 0xc0 will
1198 * match any value for that particular field. Values that are
1199 * greater than a valid time, but less than 0xc0 shouldn't appear.
1200 */
1201 seq_puts(seq, "alarm\t\t: ");
1202 if (tm.tm_hour <= 24)
1203 seq_printf(seq, "%02d:", tm.tm_hour);
1204 else
1205 seq_puts(seq, "**:");
1207 if (tm.tm_min <= 59)
1208 seq_printf(seq, "%02d:", tm.tm_min);
1209 else
1210 seq_puts(seq, "**:");
1212 if (tm.tm_sec <= 59)
1213 seq_printf(seq, "%02d\n", tm.tm_sec);
1214 else
1215 seq_puts(seq, "**\n");
1217 seq_printf(seq,
1218 "DST_enable\t: %s\n"
1219 "BCD\t\t: %s\n"
1220 "24hr\t\t: %s\n"
1221 "square_wave\t: %s\n"
1222 "alarm_IRQ\t: %s\n"
1223 "update_IRQ\t: %s\n"
1224 "periodic_IRQ\t: %s\n"
1225 "periodic_freq\t: %ld\n"
1226 "batt_status\t: %s\n",
1227 YN(RTC_DST_EN),
1228 NY(RTC_DM_BINARY),
1229 YN(RTC_24H),
1230 YN(RTC_SQWE),
1231 YN(RTC_AIE),
1232 YN(RTC_UIE),
1233 YN(RTC_PIE),
1234 freq,
1235 batt ? "okay" : "dead");
1237 return 0;
1238 #undef YN
1239 #undef NY
1242 static int rtc_proc_open(struct inode *inode, struct file *file)
1244 return single_open(file, rtc_proc_show, NULL);
1247 void rtc_get_rtc_time(struct rtc_time *rtc_tm)
1249 unsigned long uip_watchdog = jiffies, flags;
1250 unsigned char ctrl;
1251 #ifdef CONFIG_MACH_DECSTATION
1252 unsigned int real_year;
1253 #endif
1255 /*
1256 * read RTC once any update in progress is done. The update
1257 * can take just over 2ms. We wait 20ms. There is no need to
1258 * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
1259 * If you need to know *exactly* when a second has started, enable
1260 * periodic update complete interrupts, (via ioctl) and then
1261 * immediately read /dev/rtc which will block until you get the IRQ.
1262 * Once the read clears, read the RTC time (again via ioctl). Easy.
1263 */
1265 while (rtc_is_updating() != 0 && jiffies - uip_watchdog < 2*HZ/100) {
1266 barrier();
1267 cpu_relax();
1270 /*
1271 * Only the values that we read from the RTC are set. We leave
1272 * tm_wday, tm_yday and tm_isdst untouched. Note that while the
1273 * RTC has RTC_DAY_OF_WEEK, we should usually ignore it, as it is
1274 * only updated by the RTC when initially set to a non-zero value.
1275 */
1276 spin_lock_irqsave(&rtc_lock, flags);
1277 rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS);
1278 rtc_tm->tm_min = CMOS_READ(RTC_MINUTES);
1279 rtc_tm->tm_hour = CMOS_READ(RTC_HOURS);
1280 rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
1281 rtc_tm->tm_mon = CMOS_READ(RTC_MONTH);
1282 rtc_tm->tm_year = CMOS_READ(RTC_YEAR);
1283 /* Only set from 2.6.16 onwards */
1284 rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK);
1286 #ifdef CONFIG_MACH_DECSTATION
1287 real_year = CMOS_READ(RTC_DEC_YEAR);
1288 #endif
1289 ctrl = CMOS_READ(RTC_CONTROL);
1290 spin_unlock_irqrestore(&rtc_lock, flags);
1292 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1294 BCD_TO_BIN(rtc_tm->tm_sec);
1295 BCD_TO_BIN(rtc_tm->tm_min);
1296 BCD_TO_BIN(rtc_tm->tm_hour);
1297 BCD_TO_BIN(rtc_tm->tm_mday);
1298 BCD_TO_BIN(rtc_tm->tm_mon);
1299 BCD_TO_BIN(rtc_tm->tm_year);
1300 BCD_TO_BIN(rtc_tm->tm_wday);
1303 #ifdef CONFIG_MACH_DECSTATION
1304 rtc_tm->tm_year += real_year - 72;
1305 #endif
1307 /*
1308 * Account for differences between how the RTC uses the values
1309 * and how they are defined in a struct rtc_time;
1310 */
1311 if ((rtc_tm->tm_year += (epoch - 1900)) <= 69)
1312 rtc_tm->tm_year += 100;
1314 rtc_tm->tm_mon--;
1317 static void get_rtc_alm_time(struct rtc_time *alm_tm)
1319 unsigned char ctrl;
1321 /*
1322 * Only the values that we read from the RTC are set. That
1323 * means only tm_hour, tm_min, and tm_sec.
1324 */
1325 spin_lock_irq(&rtc_lock);
1326 alm_tm->tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
1327 alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM);
1328 alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM);
1329 ctrl = CMOS_READ(RTC_CONTROL);
1330 spin_unlock_irq(&rtc_lock);
1332 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1334 BCD_TO_BIN(alm_tm->tm_sec);
1335 BCD_TO_BIN(alm_tm->tm_min);
1336 BCD_TO_BIN(alm_tm->tm_hour);
1340 #ifdef RTC_IRQ
1341 /*
1342 * Used to disable/enable interrupts for any one of UIE, AIE, PIE.
1343 * Rumour has it that if you frob the interrupt enable/disable
1344 * bits in RTC_CONTROL, you should read RTC_INTR_FLAGS, to
1345 * ensure you actually start getting interrupts. Probably for
1346 * compatibility with older/broken chipset RTC implementations.
1347 * We also clear out any old irq data after an ioctl() that
1348 * meddles with the interrupt enable/disable bits.
1349 */
1351 static void mask_rtc_irq_bit_locked(unsigned char bit)
1353 unsigned char val;
1355 if (hpet_mask_rtc_irq_bit(bit))
1356 return;
1357 val = CMOS_READ(RTC_CONTROL);
1358 val &= ~bit;
1359 CMOS_WRITE(val, RTC_CONTROL);
1360 CMOS_READ(RTC_INTR_FLAGS);
1362 rtc_irq_data = 0;
1365 static void set_rtc_irq_bit_locked(unsigned char bit)
1367 unsigned char val;
1369 if (hpet_set_rtc_irq_bit(bit))
1370 return;
1371 val = CMOS_READ(RTC_CONTROL);
1372 val |= bit;
1373 CMOS_WRITE(val, RTC_CONTROL);
1374 CMOS_READ(RTC_INTR_FLAGS);
1376 rtc_irq_data = 0;
1378 #endif
1380 MODULE_AUTHOR("Paul Gortmaker");
1381 MODULE_LICENSE("GPL");
1382 MODULE_ALIAS_MISCDEV(RTC_MINOR);