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