| blob | ac48b08612c7c2a5f9ae06e9dd9be90449aa60e8 |
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 #else
107 #define rtc_has_irq 0
108 #endif
110 #ifndef CONFIG_HPET_EMULATE_RTC
111 #define is_hpet_enabled() 0
112 #define hpet_set_alarm_time(hrs, min, sec) 0
113 #define hpet_set_periodic_freq(arg) 0
114 #define hpet_mask_rtc_irq_bit(arg) 0
115 #define hpet_set_rtc_irq_bit(arg) 0
116 #define hpet_rtc_timer_init() do { } while (0)
117 #define hpet_rtc_dropped_irq() 0
118 static inline irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id) {return 0;}
119 #else
120 extern irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id);
121 #endif
123 /*
124 * We sponge a minor off of the misc major. No need slurping
125 * up another valuable major dev number for this. If you add
126 * an ioctl, make sure you don't conflict with SPARC's RTC
127 * ioctls.
128 */
130 static struct fasync_struct *rtc_async_queue;
132 static DECLARE_WAIT_QUEUE_HEAD(rtc_wait);
134 #ifdef RTC_IRQ
135 static struct timer_list rtc_irq_timer;
136 #endif
138 static ssize_t rtc_read(struct file *file, char __user *buf,
139 size_t count, loff_t *ppos);
141 static int rtc_ioctl(struct inode *inode, struct file *file,
142 unsigned int cmd, unsigned long arg);
144 #ifdef RTC_IRQ
145 static unsigned int rtc_poll(struct file *file, poll_table *wait);
146 #endif
148 static void get_rtc_alm_time (struct rtc_time *alm_tm);
149 #ifdef RTC_IRQ
150 static void rtc_dropped_irq(unsigned long data);
152 static void set_rtc_irq_bit_locked(unsigned char bit);
153 static void mask_rtc_irq_bit_locked(unsigned char bit);
155 static inline void set_rtc_irq_bit(unsigned char bit)
156 {
157 spin_lock_irq(&rtc_lock);
158 set_rtc_irq_bit_locked(bit);
159 spin_unlock_irq(&rtc_lock);
160 }
162 static void mask_rtc_irq_bit(unsigned char bit)
163 {
164 spin_lock_irq(&rtc_lock);
165 mask_rtc_irq_bit_locked(bit);
166 spin_unlock_irq(&rtc_lock);
167 }
168 #endif
170 static int rtc_proc_open(struct inode *inode, struct file *file);
172 /*
173 * Bits in rtc_status. (6 bits of room for future expansion)
174 */
176 #define RTC_IS_OPEN 0x01 /* means /dev/rtc is in use */
177 #define RTC_TIMER_ON 0x02 /* missed irq timer active */
179 /*
180 * rtc_status is never changed by rtc_interrupt, and ioctl/open/close is
181 * protected by the big kernel lock. However, ioctl can still disable the timer
182 * in rtc_status and then with del_timer after the interrupt has read
183 * rtc_status but before mod_timer is called, which would then reenable the
184 * timer (but you would need to have an awful timing before you'd trip on it)
185 */
186 static unsigned long rtc_status = 0; /* bitmapped status byte. */
187 static unsigned long rtc_freq = 0; /* Current periodic IRQ rate */
188 static unsigned long rtc_irq_data = 0; /* our output to the world */
189 static unsigned long rtc_max_user_freq = 64; /* > this, need CAP_SYS_RESOURCE */
191 #ifdef RTC_IRQ
192 /*
193 * rtc_task_lock nests inside rtc_lock.
194 */
195 static DEFINE_SPINLOCK(rtc_task_lock);
196 static rtc_task_t *rtc_callback = NULL;
197 #endif
199 /*
200 * If this driver ever becomes modularised, it will be really nice
201 * to make the epoch retain its value across module reload...
202 */
204 static unsigned long epoch = 1900; /* year corresponding to 0x00 */
206 static const unsigned char days_in_mo[] =
207 {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
209 /*
210 * Returns true if a clock update is in progress
211 */
212 static inline unsigned char rtc_is_updating(void)
213 {
214 unsigned long flags;
215 unsigned char uip;
217 spin_lock_irqsave(&rtc_lock, flags);
218 uip = (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP);
219 spin_unlock_irqrestore(&rtc_lock, flags);
220 return uip;
221 }
223 #ifdef RTC_IRQ
224 /*
225 * A very tiny interrupt handler. It runs with IRQF_DISABLED set,
226 * but there is possibility of conflicting with the set_rtc_mmss()
227 * call (the rtc irq and the timer irq can easily run at the same
228 * time in two different CPUs). So we need to serialize
229 * accesses to the chip with the rtc_lock spinlock that each
230 * architecture should implement in the timer code.
231 * (See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.)
232 */
234 irqreturn_t rtc_interrupt(int irq, void *dev_id)
235 {
236 /*
237 * Can be an alarm interrupt, update complete interrupt,
238 * or a periodic interrupt. We store the status in the
239 * low byte and the number of interrupts received since
240 * the last read in the remainder of rtc_irq_data.
241 */
243 spin_lock (&rtc_lock);
244 rtc_irq_data += 0x100;
245 rtc_irq_data &= ~0xff;
246 if (is_hpet_enabled()) {
247 /*
248 * In this case it is HPET RTC interrupt handler
249 * calling us, with the interrupt information
250 * passed as arg1, instead of irq.
251 */
252 rtc_irq_data |= (unsigned long)irq & 0xF0;
253 } else {
254 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
255 }
257 if (rtc_status & RTC_TIMER_ON)
258 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
260 spin_unlock (&rtc_lock);
262 /* Now do the rest of the actions */
263 spin_lock(&rtc_task_lock);
264 if (rtc_callback)
265 rtc_callback->func(rtc_callback->private_data);
266 spin_unlock(&rtc_task_lock);
267 wake_up_interruptible(&rtc_wait);
269 kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);
271 return IRQ_HANDLED;
272 }
273 #endif
275 /*
276 * sysctl-tuning infrastructure.
277 */
278 static ctl_table rtc_table[] = {
279 {
280 .ctl_name = 1,
281 .procname = "max-user-freq",
282 .data = &rtc_max_user_freq,
283 .maxlen = sizeof(int),
284 .mode = 0644,
285 .proc_handler = &proc_dointvec,
286 },
287 { .ctl_name = 0 }
288 };
290 static ctl_table rtc_root[] = {
291 {
292 .ctl_name = 1,
293 .procname = "rtc",
294 .maxlen = 0,
295 .mode = 0555,
296 .child = rtc_table,
297 },
298 { .ctl_name = 0 }
299 };
301 static ctl_table dev_root[] = {
302 {
303 .ctl_name = CTL_DEV,
304 .procname = "dev",
305 .maxlen = 0,
306 .mode = 0555,
307 .child = rtc_root,
308 },
309 { .ctl_name = 0 }
310 };
312 static struct ctl_table_header *sysctl_header;
314 static int __init init_sysctl(void)
315 {
316 sysctl_header = register_sysctl_table(dev_root, 0);
317 return 0;
318 }
320 static void __exit cleanup_sysctl(void)
321 {
322 unregister_sysctl_table(sysctl_header);
323 }
325 /*
326 * Now all the various file operations that we export.
327 */
329 static ssize_t rtc_read(struct file *file, char __user *buf,
330 size_t count, loff_t *ppos)
331 {
332 #ifndef RTC_IRQ
333 return -EIO;
334 #else
335 DECLARE_WAITQUEUE(wait, current);
336 unsigned long data;
337 ssize_t retval;
339 if (rtc_has_irq == 0)
340 return -EIO;
342 /*
343 * Historically this function used to assume that sizeof(unsigned long)
344 * is the same in userspace and kernelspace. This lead to problems
345 * for configurations with multiple ABIs such a the MIPS o32 and 64
346 * ABIs supported on the same kernel. So now we support read of both
347 * 4 and 8 bytes and assume that's the sizeof(unsigned long) in the
348 * userspace ABI.
349 */
350 if (count != sizeof(unsigned int) && count != sizeof(unsigned long))
351 return -EINVAL;
353 add_wait_queue(&rtc_wait, &wait);
355 do {
356 /* First make it right. Then make it fast. Putting this whole
357 * block within the parentheses of a while would be too
358 * confusing. And no, xchg() is not the answer. */
360 __set_current_state(TASK_INTERRUPTIBLE);
362 spin_lock_irq (&rtc_lock);
363 data = rtc_irq_data;
364 rtc_irq_data = 0;
365 spin_unlock_irq (&rtc_lock);
367 if (data != 0)
368 break;
370 if (file->f_flags & O_NONBLOCK) {
371 retval = -EAGAIN;
372 goto out;
373 }
374 if (signal_pending(current)) {
375 retval = -ERESTARTSYS;
376 goto out;
377 }
378 schedule();
379 } while (1);
381 if (count == sizeof(unsigned int))
382 retval = put_user(data, (unsigned int __user *)buf) ?: sizeof(int);
383 else
384 retval = put_user(data, (unsigned long __user *)buf) ?: sizeof(long);
385 if (!retval)
386 retval = count;
387 out:
388 current->state = TASK_RUNNING;
389 remove_wait_queue(&rtc_wait, &wait);
391 return retval;
392 #endif
393 }
395 static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
396 {
397 struct rtc_time wtime;
399 if (rtc_has_irq == 0) {
400 switch (cmd) {
401 case RTC_AIE_OFF:
402 case RTC_AIE_ON:
403 case RTC_PIE_OFF:
404 case RTC_PIE_ON:
405 case RTC_UIE_OFF:
406 case RTC_UIE_ON:
407 case RTC_IRQP_READ:
408 case RTC_IRQP_SET:
409 return -EINVAL;
410 };
411 }
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 irq_handler_t rtc_int_handler_ptr;
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;
1005 }
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;
1018 }
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;
1028 }
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
1066 }
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);
1081 }
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;
1091 }
1093 static void __exit rtc_exit (void)
1094 {
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__ */
1112 }
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)
1131 {
1132 unsigned long freq;
1134 spin_lock_irq (&rtc_lock);
1136 if (hpet_rtc_dropped_irq()) {
1137 spin_unlock_irq(&rtc_lock);
1138 return;
1139 }
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);
1159 }
1160 #endif
1162 /*
1163 * Info exported via "/proc/driver/rtc".
1164 */
1166 static int rtc_proc_show(struct seq_file *seq, void *v)
1167 {
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
1240 }
1242 static int rtc_proc_open(struct inode *inode, struct file *file)
1243 {
1244 return single_open(file, rtc_proc_show, NULL);
1245 }
1247 void rtc_get_rtc_time(struct rtc_time *rtc_tm)
1248 {
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 cpu_relax();
1268 /*
1269 * Only the values that we read from the RTC are set. We leave
1270 * tm_wday, tm_yday and tm_isdst untouched. Note that while the
1271 * RTC has RTC_DAY_OF_WEEK, we should usually ignore it, as it is
1272 * only updated by the RTC when initially set to a non-zero value.
1273 */
1274 spin_lock_irqsave(&rtc_lock, flags);
1275 rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS);
1276 rtc_tm->tm_min = CMOS_READ(RTC_MINUTES);
1277 rtc_tm->tm_hour = CMOS_READ(RTC_HOURS);
1278 rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
1279 rtc_tm->tm_mon = CMOS_READ(RTC_MONTH);
1280 rtc_tm->tm_year = CMOS_READ(RTC_YEAR);
1281 /* Only set from 2.6.16 onwards */
1282 rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK);
1284 #ifdef CONFIG_MACH_DECSTATION
1285 real_year = CMOS_READ(RTC_DEC_YEAR);
1286 #endif
1287 ctrl = CMOS_READ(RTC_CONTROL);
1288 spin_unlock_irqrestore(&rtc_lock, flags);
1290 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1291 {
1292 BCD_TO_BIN(rtc_tm->tm_sec);
1293 BCD_TO_BIN(rtc_tm->tm_min);
1294 BCD_TO_BIN(rtc_tm->tm_hour);
1295 BCD_TO_BIN(rtc_tm->tm_mday);
1296 BCD_TO_BIN(rtc_tm->tm_mon);
1297 BCD_TO_BIN(rtc_tm->tm_year);
1298 BCD_TO_BIN(rtc_tm->tm_wday);
1299 }
1301 #ifdef CONFIG_MACH_DECSTATION
1302 rtc_tm->tm_year += real_year - 72;
1303 #endif
1305 /*
1306 * Account for differences between how the RTC uses the values
1307 * and how they are defined in a struct rtc_time;
1308 */
1309 if ((rtc_tm->tm_year += (epoch - 1900)) <= 69)
1310 rtc_tm->tm_year += 100;
1312 rtc_tm->tm_mon--;
1313 }
1315 static void get_rtc_alm_time(struct rtc_time *alm_tm)
1316 {
1317 unsigned char ctrl;
1319 /*
1320 * Only the values that we read from the RTC are set. That
1321 * means only tm_hour, tm_min, and tm_sec.
1322 */
1323 spin_lock_irq(&rtc_lock);
1324 alm_tm->tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
1325 alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM);
1326 alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM);
1327 ctrl = CMOS_READ(RTC_CONTROL);
1328 spin_unlock_irq(&rtc_lock);
1330 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1331 {
1332 BCD_TO_BIN(alm_tm->tm_sec);
1333 BCD_TO_BIN(alm_tm->tm_min);
1334 BCD_TO_BIN(alm_tm->tm_hour);
1335 }
1336 }
1338 #ifdef RTC_IRQ
1339 /*
1340 * Used to disable/enable interrupts for any one of UIE, AIE, PIE.
1341 * Rumour has it that if you frob the interrupt enable/disable
1342 * bits in RTC_CONTROL, you should read RTC_INTR_FLAGS, to
1343 * ensure you actually start getting interrupts. Probably for
1344 * compatibility with older/broken chipset RTC implementations.
1345 * We also clear out any old irq data after an ioctl() that
1346 * meddles with the interrupt enable/disable bits.
1347 */
1349 static void mask_rtc_irq_bit_locked(unsigned char bit)
1350 {
1351 unsigned char val;
1353 if (hpet_mask_rtc_irq_bit(bit))
1354 return;
1355 val = CMOS_READ(RTC_CONTROL);
1356 val &= ~bit;
1357 CMOS_WRITE(val, RTC_CONTROL);
1358 CMOS_READ(RTC_INTR_FLAGS);
1360 rtc_irq_data = 0;
1361 }
1363 static void set_rtc_irq_bit_locked(unsigned char bit)
1364 {
1365 unsigned char val;
1367 if (hpet_set_rtc_irq_bit(bit))
1368 return;
1369 val = CMOS_READ(RTC_CONTROL);
1370 val |= bit;
1371 CMOS_WRITE(val, RTC_CONTROL);
1372 CMOS_READ(RTC_INTR_FLAGS);
1374 rtc_irq_data = 0;
1375 }
1376 #endif
1378 MODULE_AUTHOR("Paul Gortmaker");
1379 MODULE_LICENSE("GPL");
1380 MODULE_ALIAS_MISCDEV(RTC_MINOR);