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