blob: 66a7385bc34aebb96cbda088b2a0b74f23f31363 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Ralf Baechle12a0a702006-10-09 23:20:47 +010038 * 1.10 Paul Barton-Davis: add support for async I/O
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 * 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.
Ralf Baechle12a0a702006-10-09 23:20:47 +010044 * 1.11 Takashi Iwai: Kernel access functions
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 * 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
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -070049 * 1.12a Maciej W. Rozycki: Handle memory-mapped chips properly.
Alan Coxb7599582006-01-11 12:17:32 -080050 * 1.12ac Alan Cox: Allow read access to the day of week register
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 */
52
Alan Coxb7599582006-01-11 12:17:32 -080053#define RTC_VERSION "1.12ac"
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Linus Torvalds1da177e2005-04-16 15:20:36 -070055/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070063#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>
Luca Falavigna47f176f2005-06-28 20:44:42 -070079#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
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
David Howells7d12e782006-10-05 14:55:46 +0100116static inline irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id) {return 0;}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117#else
David Howells7d12e782006-10-05 14:55:46 +0100118extern irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119#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
Takashi Iwaic3348762005-11-07 11:14:57 +0100150static 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}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166#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{
Peter Zijlstra0b16f212006-09-25 16:24:23 -0700212 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 unsigned char uip;
214
Peter Zijlstra0b16f212006-09-25 16:24:23 -0700215 spin_lock_irqsave(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 uip = (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP);
Peter Zijlstra0b16f212006-09-25 16:24:23 -0700217 spin_unlock_irqrestore(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 return uip;
219}
220
221#ifdef RTC_IRQ
222/*
Thomas Gleixner0f2ed4c2006-07-01 19:29:33 -0700223 * A very tiny interrupt handler. It runs with IRQF_DISABLED set,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 * but there is possibility of conflicting with the set_rtc_mmss()
225 * call (the rtc irq and the timer irq can easily run at the same
226 * time in two different CPUs). So we need to serialize
227 * accesses to the chip with the rtc_lock spinlock that each
228 * architecture should implement in the timer code.
229 * (See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.)
230 */
231
David Howells7d12e782006-10-05 14:55:46 +0100232irqreturn_t rtc_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233{
234 /*
235 * Can be an alarm interrupt, update complete interrupt,
236 * or a periodic interrupt. We store the status in the
237 * low byte and the number of interrupts received since
238 * the last read in the remainder of rtc_irq_data.
239 */
240
241 spin_lock (&rtc_lock);
242 rtc_irq_data += 0x100;
243 rtc_irq_data &= ~0xff;
244 if (is_hpet_enabled()) {
245 /*
246 * In this case it is HPET RTC interrupt handler
247 * calling us, with the interrupt information
248 * passed as arg1, instead of irq.
249 */
250 rtc_irq_data |= (unsigned long)irq & 0xF0;
251 } else {
252 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
253 }
254
255 if (rtc_status & RTC_TIMER_ON)
256 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
257
258 spin_unlock (&rtc_lock);
259
260 /* Now do the rest of the actions */
261 spin_lock(&rtc_task_lock);
262 if (rtc_callback)
263 rtc_callback->func(rtc_callback->private_data);
264 spin_unlock(&rtc_task_lock);
265 wake_up_interruptible(&rtc_wait);
266
267 kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);
268
269 return IRQ_HANDLED;
270}
271#endif
272
273/*
274 * sysctl-tuning infrastructure.
275 */
276static ctl_table rtc_table[] = {
277 {
278 .ctl_name = 1,
279 .procname = "max-user-freq",
280 .data = &rtc_max_user_freq,
281 .maxlen = sizeof(int),
282 .mode = 0644,
283 .proc_handler = &proc_dointvec,
284 },
285 { .ctl_name = 0 }
286};
287
288static ctl_table rtc_root[] = {
289 {
290 .ctl_name = 1,
291 .procname = "rtc",
292 .maxlen = 0,
293 .mode = 0555,
294 .child = rtc_table,
295 },
296 { .ctl_name = 0 }
297};
298
299static ctl_table dev_root[] = {
300 {
301 .ctl_name = CTL_DEV,
302 .procname = "dev",
303 .maxlen = 0,
304 .mode = 0555,
305 .child = rtc_root,
306 },
307 { .ctl_name = 0 }
308};
309
310static struct ctl_table_header *sysctl_header;
311
312static int __init init_sysctl(void)
313{
314 sysctl_header = register_sysctl_table(dev_root, 0);
315 return 0;
316}
317
318static void __exit cleanup_sysctl(void)
319{
320 unregister_sysctl_table(sysctl_header);
321}
322
323/*
324 * Now all the various file operations that we export.
325 */
326
327static ssize_t rtc_read(struct file *file, char __user *buf,
328 size_t count, loff_t *ppos)
329{
330#ifndef RTC_IRQ
331 return -EIO;
332#else
333 DECLARE_WAITQUEUE(wait, current);
334 unsigned long data;
335 ssize_t retval;
336
337 if (rtc_has_irq == 0)
338 return -EIO;
339
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700340 /*
341 * Historically this function used to assume that sizeof(unsigned long)
342 * is the same in userspace and kernelspace. This lead to problems
343 * for configurations with multiple ABIs such a the MIPS o32 and 64
344 * ABIs supported on the same kernel. So now we support read of both
345 * 4 and 8 bytes and assume that's the sizeof(unsigned long) in the
346 * userspace ABI.
347 */
348 if (count != sizeof(unsigned int) && count != sizeof(unsigned long))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 return -EINVAL;
350
351 add_wait_queue(&rtc_wait, &wait);
352
353 do {
354 /* First make it right. Then make it fast. Putting this whole
355 * block within the parentheses of a while would be too
356 * confusing. And no, xchg() is not the answer. */
357
358 __set_current_state(TASK_INTERRUPTIBLE);
359
360 spin_lock_irq (&rtc_lock);
361 data = rtc_irq_data;
362 rtc_irq_data = 0;
363 spin_unlock_irq (&rtc_lock);
364
365 if (data != 0)
366 break;
367
368 if (file->f_flags & O_NONBLOCK) {
369 retval = -EAGAIN;
370 goto out;
371 }
372 if (signal_pending(current)) {
373 retval = -ERESTARTSYS;
374 goto out;
375 }
376 schedule();
377 } while (1);
378
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700379 if (count == sizeof(unsigned int))
380 retval = put_user(data, (unsigned int __user *)buf) ?: sizeof(int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 else
382 retval = put_user(data, (unsigned long __user *)buf) ?: sizeof(long);
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700383 if (!retval)
384 retval = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 out:
386 current->state = TASK_RUNNING;
387 remove_wait_queue(&rtc_wait, &wait);
388
389 return retval;
390#endif
391}
392
393static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
394{
395 struct rtc_time wtime;
396
397#ifdef RTC_IRQ
398 if (rtc_has_irq == 0) {
399 switch (cmd) {
400 case RTC_AIE_OFF:
401 case RTC_AIE_ON:
402 case RTC_PIE_OFF:
403 case RTC_PIE_ON:
404 case RTC_UIE_OFF:
405 case RTC_UIE_ON:
406 case RTC_IRQP_READ:
407 case RTC_IRQP_SET:
408 return -EINVAL;
409 };
410 }
411#endif
412
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 {
Takashi Iwaic3348762005-11-07 11:14:57 +0100427 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 if (rtc_status & RTC_TIMER_ON) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 rtc_status &= ~RTC_TIMER_ON;
432 del_timer(&rtc_irq_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 }
Takashi Iwaic3348762005-11-07 11:14:57 +0100434 spin_unlock_irqrestore (&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 return 0;
436 }
437 case RTC_PIE_ON: /* Allow periodic ints */
438 {
Takashi Iwaic3348762005-11-07 11:14:57 +0100439 unsigned long flags; /* can be called from isr via rtc_control() */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 /*
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;
447
Takashi Iwaic3348762005-11-07 11:14:57 +0100448 spin_lock_irqsave (&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 if (!(rtc_status & RTC_TIMER_ON)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 rtc_irq_timer.expires = jiffies + HZ/rtc_freq + 2*HZ/100;
451 add_timer(&rtc_irq_timer);
452 rtc_status |= RTC_TIMER_ON;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 }
Takashi Iwaic3348762005-11-07 11:14:57 +0100454 set_rtc_irq_bit_locked(RTC_PIE);
455 spin_unlock_irqrestore (&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 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;
489
490 if (copy_from_user(&alm_tm, (struct rtc_time __user *)arg,
491 sizeof(struct rtc_time)))
492 return -EFAULT;
493
494 hrs = alm_tm.tm_hour;
495 min = alm_tm.tm_min;
496 sec = alm_tm.tm_sec;
497
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;
510
511 if (min < 60) BIN_TO_BCD(min);
512 else min = 0xff;
513
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);
521
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
539
540 if (!capable(CAP_SYS_TIME))
541 return -EACCES;
542
543 if (copy_from_user(&rtc_tm, (struct rtc_time __user *)arg,
544 sizeof(struct rtc_time)))
545 return -EFAULT;
546
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;
553
554 if (yrs < 1970)
555 return -EINVAL;
556
557 leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
558
559 if ((mon > 12) || (day == 0))
560 return -EINVAL;
561
562 if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
563 return -EINVAL;
564
565 if ((hrs >= 24) || (min >= 60) || (sec >= 60))
566 return -EINVAL;
567
568 if ((yrs -= epoch) > 255) /* They are unsigned */
569 return -EINVAL;
570
571 spin_lock_irq(&rtc_lock);
572#ifdef CONFIG_MACH_DECSTATION
573 real_yrs = yrs;
574 yrs = 72;
575
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;
595
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 }
605
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);
610
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);
620
621 CMOS_WRITE(save_control, RTC_CONTROL);
622 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
623
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;
Takashi Iwaic3348762005-11-07 11:14:57 +0100636 unsigned long flags; /* can be called from isr via rtc_control() */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
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;
649
650 while (arg > (1<<tmp))
651 tmp++;
652
653 /*
654 * Check that the input was really a power of 2.
655 */
656 if (arg != (1<<tmp))
657 return -EINVAL;
658
Takashi Iwaic3348762005-11-07 11:14:57 +0100659 spin_lock_irqsave(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 if (hpet_set_periodic_freq(arg)) {
Takashi Iwaic3348762005-11-07 11:14:57 +0100661 spin_unlock_irqrestore(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 return 0;
663 }
664 rtc_freq = arg;
665
666 val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0;
667 val |= (16 - tmp);
668 CMOS_WRITE(val, RTC_FREQ_SELECT);
Takashi Iwaic3348762005-11-07 11:14:57 +0100669 spin_unlock_irqrestore(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 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;
684
685 if (!capable(CAP_SYS_TIME))
686 return -EACCES;
687
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}
696
697static 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}
702
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 */
708
709/* We use rtc_lock to protect against concurrent opens. So the BKL is not
710 * needed here. Or anywhere else in this driver. */
711static int rtc_open(struct inode *inode, struct file *file)
712{
713 spin_lock_irq (&rtc_lock);
714
715 if(rtc_status & RTC_IS_OPEN)
716 goto out_busy;
717
718 rtc_status |= RTC_IS_OPEN;
719
720 rtc_irq_data = 0;
721 spin_unlock_irq (&rtc_lock);
722 return 0;
723
724out_busy:
725 spin_unlock_irq (&rtc_lock);
726 return -EBUSY;
727}
728
729static int rtc_fasync (int fd, struct file *filp, int on)
730
731{
732 return fasync_helper (fd, filp, on, &rtc_async_queue);
733}
734
735static int rtc_release(struct inode *inode, struct file *file)
736{
737#ifdef RTC_IRQ
738 unsigned char tmp;
739
740 if (rtc_has_irq == 0)
741 goto no_irq;
742
743 /*
744 * Turn off all interrupts once the device is no longer
745 * in use, and clear the data.
746 */
747
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);
762
763 if (file->f_flags & FASYNC) {
764 rtc_fasync (-1, file, 0);
765 }
766no_irq:
767#endif
768
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}
775
776#ifdef RTC_IRQ
777/* Called without the kernel lock - fine */
778static unsigned int rtc_poll(struct file *file, poll_table *wait)
779{
780 unsigned long l;
781
782 if (rtc_has_irq == 0)
783 return 0;
784
785 poll_wait(file, &rtc_wait, wait);
786
787 spin_lock_irq (&rtc_lock);
788 l = rtc_irq_data;
789 spin_unlock_irq (&rtc_lock);
790
791 if (l != 0)
792 return POLLIN | POLLRDNORM;
793 return 0;
794}
795#endif
796
797/*
798 * exported stuffs
799 */
800
801EXPORT_SYMBOL(rtc_register);
802EXPORT_SYMBOL(rtc_unregister);
803EXPORT_SYMBOL(rtc_control);
804
805int 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}
830
831int rtc_unregister(rtc_task_t *task)
832{
833#ifndef RTC_IRQ
834 return -EIO;
835#else
836 unsigned char tmp;
837
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;
846
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}
866
867int rtc_control(rtc_task_t *task, unsigned int cmd, unsigned long arg)
868{
869#ifndef RTC_IRQ
870 return -EIO;
871#else
Takashi Iwaic3348762005-11-07 11:14:57 +0100872 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 if (rtc_callback != task) {
Takashi Iwaic3348762005-11-07 11:14:57 +0100877 spin_unlock_irqrestore(&rtc_task_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 return -ENXIO;
879 }
Takashi Iwaic3348762005-11-07 11:14:57 +0100880 spin_unlock_irqrestore(&rtc_task_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 return rtc_do_ioctl(cmd, arg, 1);
882#endif
883}
884
885
886/*
887 * The various file operations we support.
888 */
889
Arjan van de Ven62322d22006-07-03 00:24:21 -0700890static const struct file_operations rtc_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 .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};
902
903static struct miscdevice rtc_dev = {
904 .minor = RTC_MINOR,
905 .name = "rtc",
906 .fops = &rtc_fops,
907};
908
Arjan van de Ven62322d22006-07-03 00:24:21 -0700909static const struct file_operations rtc_proc_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 .owner = THIS_MODULE,
911 .open = rtc_proc_open,
912 .read = seq_read,
913 .llseek = seq_lseek,
914 .release = single_release,
915};
916
917#if defined(RTC_IRQ) && !defined(__sparc__)
David Howells7d12e782006-10-05 14:55:46 +0100918static irq_handler_t rtc_int_handler_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919#endif
920
921static int __init rtc_init(void)
922{
923 struct proc_dir_entry *ent;
924#if defined(__alpha__) || defined(__mips__)
925 unsigned int year, ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 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
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700936#ifndef __sparc__
937 void *r;
938#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939
940#ifdef __sparc__
941 for_each_ebus(ebus) {
942 for_each_ebusdev(edev, ebus) {
David S. Miller690c8fd2006-06-22 19:12:03 -0700943 if(strcmp(edev->prom_node->name, "rtc") == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 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) {
David S. Miller690c8fd2006-06-22 19:12:03 -0700953 if (strcmp(isa_dev->prom_node->name, "rtc") == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 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;
963
964found:
965 if (rtc_irq == PCI_IRQ_NONE) {
966 rtc_has_irq = 0;
967 goto no_irq;
968 }
969
970 /*
971 * XXX Interrupt pin #7 in Espresso is shared between RTC and
David S. Miller53d0fc22005-09-05 23:33:05 -0700972 * PCI Slot 2 INTA# (and some INTx# in Slot 1).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 */
Thomas Gleixner0f2ed4c2006-07-01 19:29:33 -0700974 if (request_irq(rtc_irq, rtc_interrupt, IRQF_SHARED, "rtc", (void *)&rtc_port)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 printk(KERN_ERR "rtc: cannot register IRQ %d\n", rtc_irq);
976 return -EIO;
977 }
978no_irq:
979#else
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700980 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)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 return -EIO;
988 }
989
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 }
996
Thomas Gleixner0f2ed4c2006-07-01 19:29:33 -0700997 if(request_irq(RTC_IRQ, rtc_int_handler_ptr, IRQF_DISABLED, "rtc", NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 /* 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);
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -07001000 if (RTC_IOMAPPED)
1001 release_region(RTC_PORT(0), RTC_IO_EXTENT);
1002 else
1003 release_mem_region(RTC_PORT(0), RTC_IO_EXTENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 return -EIO;
1005 }
1006 hpet_rtc_timer_init();
1007
1008#endif
1009
1010#endif /* __sparc__ vs. others */
1011
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 }
1019
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;
1030
1031#if defined(__alpha__) || defined(__mips__)
1032 rtc_freq = HZ;
1033
1034 /* Each operating system on an Alpha uses its own epoch.
1035 Let's try to guess which one we are using now. */
1036
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 if (rtc_is_updating() != 0)
Luca Falavigna47f176f2005-06-28 20:44:42 -07001038 msleep(20);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039
1040 spin_lock_irq(&rtc_lock);
1041 year = CMOS_READ(RTC_YEAR);
1042 ctrl = CMOS_READ(RTC_CONTROL);
1043 spin_unlock_irq(&rtc_lock);
1044
1045 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1046 BCD_TO_BIN(year); /* This should never happen... */
1047
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;
1073
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);
1083no_irq2:
1084#endif
1085
1086 (void) init_sysctl();
1087
1088 printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n");
1089
1090 return 0;
1091}
1092
1093static void __exit rtc_exit (void)
1094{
1095 cleanup_sysctl();
1096 remove_proc_entry ("driver/rtc", NULL);
1097 misc_deregister(&rtc_dev);
1098
1099#ifdef __sparc__
1100 if (rtc_has_irq)
1101 free_irq (rtc_irq, &rtc_port);
1102#else
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -07001103 if (RTC_IOMAPPED)
1104 release_region(RTC_PORT(0), RTC_IO_EXTENT);
1105 else
1106 release_mem_region(RTC_PORT(0), RTC_IO_EXTENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107#ifdef RTC_IRQ
1108 if (rtc_has_irq)
1109 free_irq (RTC_IRQ, NULL);
1110#endif
1111#endif /* __sparc__ */
1112}
1113
1114module_init(rtc_init);
1115module_exit(rtc_exit);
1116
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 */
1129
1130static void rtc_dropped_irq(unsigned long data)
1131{
1132 unsigned long freq;
1133
1134 spin_lock_irq (&rtc_lock);
1135
1136 if (hpet_rtc_dropped_irq()) {
1137 spin_unlock_irq(&rtc_lock);
1138 return;
1139 }
1140
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);
1144
1145 rtc_irq_data += ((rtc_freq/HZ)<<8);
1146 rtc_irq_data &= ~0xff;
1147 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0); /* restart */
1148
1149 freq = rtc_freq;
1150
1151 spin_unlock_irq(&rtc_lock);
1152
1153 printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n", freq);
1154
1155 /* Now we have new data */
1156 wake_up_interruptible(&rtc_wait);
1157
1158 kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);
1159}
1160#endif
1161
1162/*
1163 * Info exported via "/proc/driver/rtc".
1164 */
1165
1166static 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;
1173
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);
1179
1180
1181 rtc_get_rtc_time(&tm);
1182
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);
1193
1194 get_rtc_alm_time(&tm);
1195
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, "**:");
1206
1207 if (tm.tm_min <= 59)
1208 seq_printf(seq, "%02d:", tm.tm_min);
1209 else
1210 seq_puts(seq, "**:");
1211
1212 if (tm.tm_sec <= 59)
1213 seq_printf(seq, "%02d\n", tm.tm_sec);
1214 else
1215 seq_puts(seq, "**\n");
1216
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");
1236
1237 return 0;
1238#undef YN
1239#undef NY
1240}
1241
1242static int rtc_proc_open(struct inode *inode, struct file *file)
1243{
1244 return single_open(file, rtc_proc_show, NULL);
1245}
1246
1247void rtc_get_rtc_time(struct rtc_time *rtc_tm)
1248{
Ingo Molnar0f749642006-07-12 09:03:10 -07001249 unsigned long uip_watchdog = jiffies, flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 unsigned char ctrl;
1251#ifdef CONFIG_MACH_DECSTATION
1252 unsigned int real_year;
1253#endif
1254
1255 /*
1256 * read RTC once any update in progress is done. The update
Luca Falavigna47f176f2005-06-28 20:44:42 -07001257 * can take just over 2ms. We wait 20ms. There is no need to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 * 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 */
1264
Steven Rostedt358333a2006-09-29 01:59:04 -07001265 while (rtc_is_updating() != 0 && jiffies - uip_watchdog < 2*HZ/100)
Petr Vandrovec403fe5a2005-08-05 15:50:07 +02001266 cpu_relax();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
1268 /*
1269 * Only the values that we read from the RTC are set. We leave
Alan Coxb7599582006-01-11 12:17:32 -08001270 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 */
Ingo Molnar0f749642006-07-12 09:03:10 -07001274 spin_lock_irqsave(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 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);
Alan Coxb7599582006-01-11 12:17:32 -08001281 /* Only set from 2.6.16 onwards */
1282 rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK);
1283
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284#ifdef CONFIG_MACH_DECSTATION
1285 real_year = CMOS_READ(RTC_DEC_YEAR);
1286#endif
1287 ctrl = CMOS_READ(RTC_CONTROL);
Ingo Molnar0f749642006-07-12 09:03:10 -07001288 spin_unlock_irqrestore(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289
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);
Alan Coxb7599582006-01-11 12:17:32 -08001298 BCD_TO_BIN(rtc_tm->tm_wday);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 }
1300
1301#ifdef CONFIG_MACH_DECSTATION
1302 rtc_tm->tm_year += real_year - 72;
1303#endif
1304
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;
1311
1312 rtc_tm->tm_mon--;
1313}
1314
1315static void get_rtc_alm_time(struct rtc_time *alm_tm)
1316{
1317 unsigned char ctrl;
1318
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);
1329
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}
1337
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 */
1348
Takashi Iwaic3348762005-11-07 11:14:57 +01001349static void mask_rtc_irq_bit_locked(unsigned char bit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350{
1351 unsigned char val;
1352
Takashi Iwaic3348762005-11-07 11:14:57 +01001353 if (hpet_mask_rtc_irq_bit(bit))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 val = CMOS_READ(RTC_CONTROL);
1356 val &= ~bit;
1357 CMOS_WRITE(val, RTC_CONTROL);
1358 CMOS_READ(RTC_INTR_FLAGS);
1359
1360 rtc_irq_data = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361}
1362
Takashi Iwaic3348762005-11-07 11:14:57 +01001363static void set_rtc_irq_bit_locked(unsigned char bit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364{
1365 unsigned char val;
1366
Takashi Iwaic3348762005-11-07 11:14:57 +01001367 if (hpet_set_rtc_irq_bit(bit))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 val = CMOS_READ(RTC_CONTROL);
1370 val |= bit;
1371 CMOS_WRITE(val, RTC_CONTROL);
1372 CMOS_READ(RTC_INTR_FLAGS);
1373
1374 rtc_irq_data = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375}
1376#endif
1377
1378MODULE_AUTHOR("Paul Gortmaker");
1379MODULE_LICENSE("GPL");
1380MODULE_ALIAS_MISCDEV(RTC_MINOR);