blob: 20380a2c4dee400c877a44bdc92010b467130c7d [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
Andrew Morton533ffc22006-12-22 01:06:36 -0800116#ifdef RTC_IRQ
117static irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
118{
119 return 0;
120}
121#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122#else
David Howells7d12e782006-10-05 14:55:46 +0100123extern irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124#endif
125
126/*
127 * We sponge a minor off of the misc major. No need slurping
128 * up another valuable major dev number for this. If you add
129 * an ioctl, make sure you don't conflict with SPARC's RTC
130 * ioctls.
131 */
132
133static struct fasync_struct *rtc_async_queue;
134
135static DECLARE_WAIT_QUEUE_HEAD(rtc_wait);
136
137#ifdef RTC_IRQ
Jiri Slaby40565f12007-02-12 00:52:31 -0800138static void rtc_dropped_irq(unsigned long data);
139
140static DEFINE_TIMER(rtc_irq_timer, rtc_dropped_irq, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141#endif
142
143static ssize_t rtc_read(struct file *file, char __user *buf,
144 size_t count, loff_t *ppos);
145
146static int rtc_ioctl(struct inode *inode, struct file *file,
147 unsigned int cmd, unsigned long arg);
148
149#ifdef RTC_IRQ
150static unsigned int rtc_poll(struct file *file, poll_table *wait);
151#endif
152
153static void get_rtc_alm_time (struct rtc_time *alm_tm);
154#ifdef RTC_IRQ
Takashi Iwaic3348762005-11-07 11:14:57 +0100155static void set_rtc_irq_bit_locked(unsigned char bit);
156static void mask_rtc_irq_bit_locked(unsigned char bit);
157
158static inline void set_rtc_irq_bit(unsigned char bit)
159{
160 spin_lock_irq(&rtc_lock);
161 set_rtc_irq_bit_locked(bit);
162 spin_unlock_irq(&rtc_lock);
163}
164
165static void mask_rtc_irq_bit(unsigned char bit)
166{
167 spin_lock_irq(&rtc_lock);
168 mask_rtc_irq_bit_locked(bit);
169 spin_unlock_irq(&rtc_lock);
170}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171#endif
172
Jan Beulich9cef7792006-12-13 00:35:05 -0800173#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174static int rtc_proc_open(struct inode *inode, struct file *file);
Jan Beulich9cef7792006-12-13 00:35:05 -0800175#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
177/*
178 * Bits in rtc_status. (6 bits of room for future expansion)
179 */
180
181#define RTC_IS_OPEN 0x01 /* means /dev/rtc is in use */
182#define RTC_TIMER_ON 0x02 /* missed irq timer active */
183
184/*
185 * rtc_status is never changed by rtc_interrupt, and ioctl/open/close is
186 * protected by the big kernel lock. However, ioctl can still disable the timer
187 * in rtc_status and then with del_timer after the interrupt has read
188 * rtc_status but before mod_timer is called, which would then reenable the
189 * timer (but you would need to have an awful timing before you'd trip on it)
190 */
191static unsigned long rtc_status = 0; /* bitmapped status byte. */
192static unsigned long rtc_freq = 0; /* Current periodic IRQ rate */
193static unsigned long rtc_irq_data = 0; /* our output to the world */
194static unsigned long rtc_max_user_freq = 64; /* > this, need CAP_SYS_RESOURCE */
195
196#ifdef RTC_IRQ
197/*
198 * rtc_task_lock nests inside rtc_lock.
199 */
200static DEFINE_SPINLOCK(rtc_task_lock);
201static rtc_task_t *rtc_callback = NULL;
202#endif
203
204/*
205 * If this driver ever becomes modularised, it will be really nice
206 * to make the epoch retain its value across module reload...
207 */
208
209static unsigned long epoch = 1900; /* year corresponding to 0x00 */
210
211static const unsigned char days_in_mo[] =
212{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
213
214/*
215 * Returns true if a clock update is in progress
216 */
217static inline unsigned char rtc_is_updating(void)
218{
Peter Zijlstra0b16f212006-09-25 16:24:23 -0700219 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 unsigned char uip;
221
Peter Zijlstra0b16f212006-09-25 16:24:23 -0700222 spin_lock_irqsave(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 uip = (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP);
Peter Zijlstra0b16f212006-09-25 16:24:23 -0700224 spin_unlock_irqrestore(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 return uip;
226}
227
228#ifdef RTC_IRQ
229/*
Thomas Gleixner0f2ed4c2006-07-01 19:29:33 -0700230 * A very tiny interrupt handler. It runs with IRQF_DISABLED set,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 * but there is possibility of conflicting with the set_rtc_mmss()
232 * call (the rtc irq and the timer irq can easily run at the same
233 * time in two different CPUs). So we need to serialize
234 * accesses to the chip with the rtc_lock spinlock that each
235 * architecture should implement in the timer code.
236 * (See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.)
237 */
238
David Howells7d12e782006-10-05 14:55:46 +0100239irqreturn_t rtc_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
241 /*
242 * Can be an alarm interrupt, update complete interrupt,
243 * or a periodic interrupt. We store the status in the
244 * low byte and the number of interrupts received since
245 * the last read in the remainder of rtc_irq_data.
246 */
247
248 spin_lock (&rtc_lock);
249 rtc_irq_data += 0x100;
250 rtc_irq_data &= ~0xff;
251 if (is_hpet_enabled()) {
252 /*
253 * In this case it is HPET RTC interrupt handler
254 * calling us, with the interrupt information
255 * passed as arg1, instead of irq.
256 */
257 rtc_irq_data |= (unsigned long)irq & 0xF0;
258 } else {
259 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
260 }
261
262 if (rtc_status & RTC_TIMER_ON)
263 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
264
265 spin_unlock (&rtc_lock);
266
267 /* Now do the rest of the actions */
268 spin_lock(&rtc_task_lock);
269 if (rtc_callback)
270 rtc_callback->func(rtc_callback->private_data);
271 spin_unlock(&rtc_task_lock);
272 wake_up_interruptible(&rtc_wait);
273
274 kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);
275
276 return IRQ_HANDLED;
277}
278#endif
279
280/*
281 * sysctl-tuning infrastructure.
282 */
283static ctl_table rtc_table[] = {
284 {
Eric W. Biederman77353622007-02-14 00:33:52 -0800285 .ctl_name = CTL_UNNUMBERED,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 .procname = "max-user-freq",
287 .data = &rtc_max_user_freq,
288 .maxlen = sizeof(int),
289 .mode = 0644,
290 .proc_handler = &proc_dointvec,
291 },
292 { .ctl_name = 0 }
293};
294
295static ctl_table rtc_root[] = {
296 {
Eric W. Biederman77353622007-02-14 00:33:52 -0800297 .ctl_name = CTL_UNNUMBERED,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 .procname = "rtc",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 .mode = 0555,
300 .child = rtc_table,
301 },
302 { .ctl_name = 0 }
303};
304
305static ctl_table dev_root[] = {
306 {
307 .ctl_name = CTL_DEV,
308 .procname = "dev",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 .mode = 0555,
310 .child = rtc_root,
311 },
312 { .ctl_name = 0 }
313};
314
315static struct ctl_table_header *sysctl_header;
316
317static int __init init_sysctl(void)
318{
Eric W. Biederman0b4d4142007-02-14 00:34:09 -0800319 sysctl_header = register_sysctl_table(dev_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 return 0;
321}
322
323static void __exit cleanup_sysctl(void)
324{
325 unregister_sysctl_table(sysctl_header);
326}
327
328/*
329 * Now all the various file operations that we export.
330 */
331
332static ssize_t rtc_read(struct file *file, char __user *buf,
333 size_t count, loff_t *ppos)
334{
335#ifndef RTC_IRQ
336 return -EIO;
337#else
338 DECLARE_WAITQUEUE(wait, current);
339 unsigned long data;
340 ssize_t retval;
341
342 if (rtc_has_irq == 0)
343 return -EIO;
344
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700345 /*
346 * Historically this function used to assume that sizeof(unsigned long)
347 * is the same in userspace and kernelspace. This lead to problems
348 * for configurations with multiple ABIs such a the MIPS o32 and 64
349 * ABIs supported on the same kernel. So now we support read of both
350 * 4 and 8 bytes and assume that's the sizeof(unsigned long) in the
351 * userspace ABI.
352 */
353 if (count != sizeof(unsigned int) && count != sizeof(unsigned long))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 return -EINVAL;
355
356 add_wait_queue(&rtc_wait, &wait);
357
358 do {
359 /* First make it right. Then make it fast. Putting this whole
360 * block within the parentheses of a while would be too
361 * confusing. And no, xchg() is not the answer. */
362
363 __set_current_state(TASK_INTERRUPTIBLE);
364
365 spin_lock_irq (&rtc_lock);
366 data = rtc_irq_data;
367 rtc_irq_data = 0;
368 spin_unlock_irq (&rtc_lock);
369
370 if (data != 0)
371 break;
372
373 if (file->f_flags & O_NONBLOCK) {
374 retval = -EAGAIN;
375 goto out;
376 }
377 if (signal_pending(current)) {
378 retval = -ERESTARTSYS;
379 goto out;
380 }
381 schedule();
382 } while (1);
383
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700384 if (count == sizeof(unsigned int))
385 retval = put_user(data, (unsigned int __user *)buf) ?: sizeof(int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 else
387 retval = put_user(data, (unsigned long __user *)buf) ?: sizeof(long);
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700388 if (!retval)
389 retval = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 out:
Milind Arun Choudharycc0a8fb2007-05-08 00:30:52 -0700391 __set_current_state(TASK_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 remove_wait_queue(&rtc_wait, &wait);
393
394 return retval;
395#endif
396}
397
398static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
399{
400 struct rtc_time wtime;
401
402#ifdef RTC_IRQ
403 if (rtc_has_irq == 0) {
404 switch (cmd) {
405 case RTC_AIE_OFF:
406 case RTC_AIE_ON:
407 case RTC_PIE_OFF:
408 case RTC_PIE_ON:
409 case RTC_UIE_OFF:
410 case RTC_UIE_ON:
411 case RTC_IRQP_READ:
412 case RTC_IRQP_SET:
413 return -EINVAL;
414 };
415 }
416#endif
417
418 switch (cmd) {
419#ifdef RTC_IRQ
420 case RTC_AIE_OFF: /* Mask alarm int. enab. bit */
421 {
422 mask_rtc_irq_bit(RTC_AIE);
423 return 0;
424 }
425 case RTC_AIE_ON: /* Allow alarm interrupts. */
426 {
427 set_rtc_irq_bit(RTC_AIE);
428 return 0;
429 }
430 case RTC_PIE_OFF: /* Mask periodic int. enab. bit */
431 {
Takashi Iwaic3348762005-11-07 11:14:57 +0100432 unsigned long flags; /* can be called from isr via rtc_control() */
433 spin_lock_irqsave (&rtc_lock, flags);
434 mask_rtc_irq_bit_locked(RTC_PIE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 if (rtc_status & RTC_TIMER_ON) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 rtc_status &= ~RTC_TIMER_ON;
437 del_timer(&rtc_irq_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 }
Takashi Iwaic3348762005-11-07 11:14:57 +0100439 spin_unlock_irqrestore (&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 return 0;
441 }
442 case RTC_PIE_ON: /* Allow periodic ints */
443 {
Takashi Iwaic3348762005-11-07 11:14:57 +0100444 unsigned long flags; /* can be called from isr via rtc_control() */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 /*
446 * We don't really want Joe User enabling more
447 * than 64Hz of interrupts on a multi-user machine.
448 */
449 if (!kernel && (rtc_freq > rtc_max_user_freq) &&
450 (!capable(CAP_SYS_RESOURCE)))
451 return -EACCES;
452
Takashi Iwaic3348762005-11-07 11:14:57 +0100453 spin_lock_irqsave (&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 if (!(rtc_status & RTC_TIMER_ON)) {
Jiri Slaby40565f12007-02-12 00:52:31 -0800455 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq +
456 2*HZ/100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 rtc_status |= RTC_TIMER_ON;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 }
Takashi Iwaic3348762005-11-07 11:14:57 +0100459 set_rtc_irq_bit_locked(RTC_PIE);
460 spin_unlock_irqrestore (&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 return 0;
462 }
463 case RTC_UIE_OFF: /* Mask ints from RTC updates. */
464 {
465 mask_rtc_irq_bit(RTC_UIE);
466 return 0;
467 }
468 case RTC_UIE_ON: /* Allow ints for RTC updates. */
469 {
470 set_rtc_irq_bit(RTC_UIE);
471 return 0;
472 }
473#endif
474 case RTC_ALM_READ: /* Read the present alarm time */
475 {
476 /*
477 * This returns a struct rtc_time. Reading >= 0xc0
478 * means "don't care" or "match all". Only the tm_hour,
479 * tm_min, and tm_sec values are filled in.
480 */
481 memset(&wtime, 0, sizeof(struct rtc_time));
482 get_rtc_alm_time(&wtime);
483 break;
484 }
485 case RTC_ALM_SET: /* Store a time into the alarm */
486 {
487 /*
488 * This expects a struct rtc_time. Writing 0xff means
489 * "don't care" or "match all". Only the tm_hour,
490 * tm_min and tm_sec are used.
491 */
492 unsigned char hrs, min, sec;
493 struct rtc_time alm_tm;
494
495 if (copy_from_user(&alm_tm, (struct rtc_time __user *)arg,
496 sizeof(struct rtc_time)))
497 return -EFAULT;
498
499 hrs = alm_tm.tm_hour;
500 min = alm_tm.tm_min;
501 sec = alm_tm.tm_sec;
502
503 spin_lock_irq(&rtc_lock);
504 if (hpet_set_alarm_time(hrs, min, sec)) {
505 /*
506 * Fallthru and set alarm time in CMOS too,
507 * so that we will get proper value in RTC_ALM_READ
508 */
509 }
510 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) ||
511 RTC_ALWAYS_BCD)
512 {
513 if (sec < 60) BIN_TO_BCD(sec);
514 else sec = 0xff;
515
516 if (min < 60) BIN_TO_BCD(min);
517 else min = 0xff;
518
519 if (hrs < 24) BIN_TO_BCD(hrs);
520 else hrs = 0xff;
521 }
522 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
523 CMOS_WRITE(min, RTC_MINUTES_ALARM);
524 CMOS_WRITE(sec, RTC_SECONDS_ALARM);
525 spin_unlock_irq(&rtc_lock);
526
527 return 0;
528 }
529 case RTC_RD_TIME: /* Read the time/date from RTC */
530 {
531 memset(&wtime, 0, sizeof(struct rtc_time));
532 rtc_get_rtc_time(&wtime);
533 break;
534 }
535 case RTC_SET_TIME: /* Set the RTC */
536 {
537 struct rtc_time rtc_tm;
538 unsigned char mon, day, hrs, min, sec, leap_yr;
539 unsigned char save_control, save_freq_select;
540 unsigned int yrs;
541#ifdef CONFIG_MACH_DECSTATION
542 unsigned int real_yrs;
543#endif
544
545 if (!capable(CAP_SYS_TIME))
546 return -EACCES;
547
548 if (copy_from_user(&rtc_tm, (struct rtc_time __user *)arg,
549 sizeof(struct rtc_time)))
550 return -EFAULT;
551
552 yrs = rtc_tm.tm_year + 1900;
553 mon = rtc_tm.tm_mon + 1; /* tm_mon starts at zero */
554 day = rtc_tm.tm_mday;
555 hrs = rtc_tm.tm_hour;
556 min = rtc_tm.tm_min;
557 sec = rtc_tm.tm_sec;
558
559 if (yrs < 1970)
560 return -EINVAL;
561
562 leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
563
564 if ((mon > 12) || (day == 0))
565 return -EINVAL;
566
567 if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
568 return -EINVAL;
569
570 if ((hrs >= 24) || (min >= 60) || (sec >= 60))
571 return -EINVAL;
572
573 if ((yrs -= epoch) > 255) /* They are unsigned */
574 return -EINVAL;
575
576 spin_lock_irq(&rtc_lock);
577#ifdef CONFIG_MACH_DECSTATION
578 real_yrs = yrs;
579 yrs = 72;
580
581 /*
582 * We want to keep the year set to 73 until March
583 * for non-leap years, so that Feb, 29th is handled
584 * correctly.
585 */
586 if (!leap_yr && mon < 3) {
587 real_yrs--;
588 yrs = 73;
589 }
590#endif
591 /* These limits and adjustments are independent of
592 * whether the chip is in binary mode or not.
593 */
594 if (yrs > 169) {
595 spin_unlock_irq(&rtc_lock);
596 return -EINVAL;
597 }
598 if (yrs >= 100)
599 yrs -= 100;
600
601 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)
602 || RTC_ALWAYS_BCD) {
603 BIN_TO_BCD(sec);
604 BIN_TO_BCD(min);
605 BIN_TO_BCD(hrs);
606 BIN_TO_BCD(day);
607 BIN_TO_BCD(mon);
608 BIN_TO_BCD(yrs);
609 }
610
611 save_control = CMOS_READ(RTC_CONTROL);
612 CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
613 save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
614 CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
615
616#ifdef CONFIG_MACH_DECSTATION
617 CMOS_WRITE(real_yrs, RTC_DEC_YEAR);
618#endif
619 CMOS_WRITE(yrs, RTC_YEAR);
620 CMOS_WRITE(mon, RTC_MONTH);
621 CMOS_WRITE(day, RTC_DAY_OF_MONTH);
622 CMOS_WRITE(hrs, RTC_HOURS);
623 CMOS_WRITE(min, RTC_MINUTES);
624 CMOS_WRITE(sec, RTC_SECONDS);
625
626 CMOS_WRITE(save_control, RTC_CONTROL);
627 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
628
629 spin_unlock_irq(&rtc_lock);
630 return 0;
631 }
632#ifdef RTC_IRQ
633 case RTC_IRQP_READ: /* Read the periodic IRQ rate. */
634 {
635 return put_user(rtc_freq, (unsigned long __user *)arg);
636 }
637 case RTC_IRQP_SET: /* Set periodic IRQ rate. */
638 {
639 int tmp = 0;
640 unsigned char val;
Takashi Iwaic3348762005-11-07 11:14:57 +0100641 unsigned long flags; /* can be called from isr via rtc_control() */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
643 /*
644 * The max we can do is 8192Hz.
645 */
646 if ((arg < 2) || (arg > 8192))
647 return -EINVAL;
648 /*
649 * We don't really want Joe User generating more
650 * than 64Hz of interrupts on a multi-user machine.
651 */
652 if (!kernel && (arg > rtc_max_user_freq) && (!capable(CAP_SYS_RESOURCE)))
653 return -EACCES;
654
655 while (arg > (1<<tmp))
656 tmp++;
657
658 /*
659 * Check that the input was really a power of 2.
660 */
661 if (arg != (1<<tmp))
662 return -EINVAL;
663
Takashi Iwaic3348762005-11-07 11:14:57 +0100664 spin_lock_irqsave(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 if (hpet_set_periodic_freq(arg)) {
Takashi Iwaic3348762005-11-07 11:14:57 +0100666 spin_unlock_irqrestore(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 return 0;
668 }
669 rtc_freq = arg;
670
671 val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0;
672 val |= (16 - tmp);
673 CMOS_WRITE(val, RTC_FREQ_SELECT);
Takashi Iwaic3348762005-11-07 11:14:57 +0100674 spin_unlock_irqrestore(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 return 0;
676 }
677#endif
678 case RTC_EPOCH_READ: /* Read the epoch. */
679 {
680 return put_user (epoch, (unsigned long __user *)arg);
681 }
682 case RTC_EPOCH_SET: /* Set the epoch. */
683 {
684 /*
685 * There were no RTC clocks before 1900.
686 */
687 if (arg < 1900)
688 return -EINVAL;
689
690 if (!capable(CAP_SYS_TIME))
691 return -EACCES;
692
693 epoch = arg;
694 return 0;
695 }
696 default:
697 return -ENOTTY;
698 }
699 return copy_to_user((void __user *)arg, &wtime, sizeof wtime) ? -EFAULT : 0;
700}
701
702static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
703 unsigned long arg)
704{
705 return rtc_do_ioctl(cmd, arg, 0);
706}
707
708/*
709 * We enforce only one user at a time here with the open/close.
710 * Also clear the previous interrupt data on an open, and clean
711 * up things on a close.
712 */
713
714/* We use rtc_lock to protect against concurrent opens. So the BKL is not
715 * needed here. Or anywhere else in this driver. */
716static int rtc_open(struct inode *inode, struct file *file)
717{
718 spin_lock_irq (&rtc_lock);
719
720 if(rtc_status & RTC_IS_OPEN)
721 goto out_busy;
722
723 rtc_status |= RTC_IS_OPEN;
724
725 rtc_irq_data = 0;
726 spin_unlock_irq (&rtc_lock);
727 return 0;
728
729out_busy:
730 spin_unlock_irq (&rtc_lock);
731 return -EBUSY;
732}
733
734static int rtc_fasync (int fd, struct file *filp, int on)
735
736{
737 return fasync_helper (fd, filp, on, &rtc_async_queue);
738}
739
740static int rtc_release(struct inode *inode, struct file *file)
741{
742#ifdef RTC_IRQ
743 unsigned char tmp;
744
745 if (rtc_has_irq == 0)
746 goto no_irq;
747
748 /*
749 * Turn off all interrupts once the device is no longer
750 * in use, and clear the data.
751 */
752
753 spin_lock_irq(&rtc_lock);
754 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
755 tmp = CMOS_READ(RTC_CONTROL);
756 tmp &= ~RTC_PIE;
757 tmp &= ~RTC_AIE;
758 tmp &= ~RTC_UIE;
759 CMOS_WRITE(tmp, RTC_CONTROL);
760 CMOS_READ(RTC_INTR_FLAGS);
761 }
762 if (rtc_status & RTC_TIMER_ON) {
763 rtc_status &= ~RTC_TIMER_ON;
764 del_timer(&rtc_irq_timer);
765 }
766 spin_unlock_irq(&rtc_lock);
767
768 if (file->f_flags & FASYNC) {
769 rtc_fasync (-1, file, 0);
770 }
771no_irq:
772#endif
773
774 spin_lock_irq (&rtc_lock);
775 rtc_irq_data = 0;
776 rtc_status &= ~RTC_IS_OPEN;
777 spin_unlock_irq (&rtc_lock);
778 return 0;
779}
780
781#ifdef RTC_IRQ
782/* Called without the kernel lock - fine */
783static unsigned int rtc_poll(struct file *file, poll_table *wait)
784{
785 unsigned long l;
786
787 if (rtc_has_irq == 0)
788 return 0;
789
790 poll_wait(file, &rtc_wait, wait);
791
792 spin_lock_irq (&rtc_lock);
793 l = rtc_irq_data;
794 spin_unlock_irq (&rtc_lock);
795
796 if (l != 0)
797 return POLLIN | POLLRDNORM;
798 return 0;
799}
800#endif
801
802/*
803 * exported stuffs
804 */
805
806EXPORT_SYMBOL(rtc_register);
807EXPORT_SYMBOL(rtc_unregister);
808EXPORT_SYMBOL(rtc_control);
809
810int rtc_register(rtc_task_t *task)
811{
812#ifndef RTC_IRQ
813 return -EIO;
814#else
815 if (task == NULL || task->func == NULL)
816 return -EINVAL;
817 spin_lock_irq(&rtc_lock);
818 if (rtc_status & RTC_IS_OPEN) {
819 spin_unlock_irq(&rtc_lock);
820 return -EBUSY;
821 }
822 spin_lock(&rtc_task_lock);
823 if (rtc_callback) {
824 spin_unlock(&rtc_task_lock);
825 spin_unlock_irq(&rtc_lock);
826 return -EBUSY;
827 }
828 rtc_status |= RTC_IS_OPEN;
829 rtc_callback = task;
830 spin_unlock(&rtc_task_lock);
831 spin_unlock_irq(&rtc_lock);
832 return 0;
833#endif
834}
835
836int rtc_unregister(rtc_task_t *task)
837{
838#ifndef RTC_IRQ
839 return -EIO;
840#else
841 unsigned char tmp;
842
843 spin_lock_irq(&rtc_lock);
844 spin_lock(&rtc_task_lock);
845 if (rtc_callback != task) {
846 spin_unlock(&rtc_task_lock);
847 spin_unlock_irq(&rtc_lock);
848 return -ENXIO;
849 }
850 rtc_callback = NULL;
851
852 /* disable controls */
853 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
854 tmp = CMOS_READ(RTC_CONTROL);
855 tmp &= ~RTC_PIE;
856 tmp &= ~RTC_AIE;
857 tmp &= ~RTC_UIE;
858 CMOS_WRITE(tmp, RTC_CONTROL);
859 CMOS_READ(RTC_INTR_FLAGS);
860 }
861 if (rtc_status & RTC_TIMER_ON) {
862 rtc_status &= ~RTC_TIMER_ON;
863 del_timer(&rtc_irq_timer);
864 }
865 rtc_status &= ~RTC_IS_OPEN;
866 spin_unlock(&rtc_task_lock);
867 spin_unlock_irq(&rtc_lock);
868 return 0;
869#endif
870}
871
872int rtc_control(rtc_task_t *task, unsigned int cmd, unsigned long arg)
873{
874#ifndef RTC_IRQ
875 return -EIO;
876#else
Takashi Iwaic3348762005-11-07 11:14:57 +0100877 unsigned long flags;
878 if (cmd != RTC_PIE_ON && cmd != RTC_PIE_OFF && cmd != RTC_IRQP_SET)
879 return -EINVAL;
880 spin_lock_irqsave(&rtc_task_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 if (rtc_callback != task) {
Takashi Iwaic3348762005-11-07 11:14:57 +0100882 spin_unlock_irqrestore(&rtc_task_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 return -ENXIO;
884 }
Takashi Iwaic3348762005-11-07 11:14:57 +0100885 spin_unlock_irqrestore(&rtc_task_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 return rtc_do_ioctl(cmd, arg, 1);
887#endif
888}
889
890
891/*
892 * The various file operations we support.
893 */
894
Arjan van de Ven62322d22006-07-03 00:24:21 -0700895static const struct file_operations rtc_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 .owner = THIS_MODULE,
897 .llseek = no_llseek,
898 .read = rtc_read,
899#ifdef RTC_IRQ
900 .poll = rtc_poll,
901#endif
902 .ioctl = rtc_ioctl,
903 .open = rtc_open,
904 .release = rtc_release,
905 .fasync = rtc_fasync,
906};
907
908static struct miscdevice rtc_dev = {
909 .minor = RTC_MINOR,
910 .name = "rtc",
911 .fops = &rtc_fops,
912};
913
Jan Beulich9cef7792006-12-13 00:35:05 -0800914#ifdef CONFIG_PROC_FS
Arjan van de Ven62322d22006-07-03 00:24:21 -0700915static const struct file_operations rtc_proc_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 .owner = THIS_MODULE,
917 .open = rtc_proc_open,
918 .read = seq_read,
919 .llseek = seq_lseek,
920 .release = single_release,
921};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922#endif
923
924static int __init rtc_init(void)
925{
Jan Beulich9cef7792006-12-13 00:35:05 -0800926#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 struct proc_dir_entry *ent;
Jan Beulich9cef7792006-12-13 00:35:05 -0800928#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929#if defined(__alpha__) || defined(__mips__)
930 unsigned int year, ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 char *guess = NULL;
932#endif
933#ifdef __sparc__
934 struct linux_ebus *ebus;
935 struct linux_ebus_device *edev;
936#ifdef __sparc_v9__
937 struct sparc_isa_bridge *isa_br;
938 struct sparc_isa_device *isa_dev;
939#endif
Jan Beulich9cef7792006-12-13 00:35:05 -0800940#else
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700941 void *r;
Jan Beulich9cef7792006-12-13 00:35:05 -0800942#ifdef RTC_IRQ
943 irq_handler_t rtc_int_handler_ptr;
944#endif
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700945#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
947#ifdef __sparc__
948 for_each_ebus(ebus) {
949 for_each_ebusdev(edev, ebus) {
David S. Miller690c8fd2006-06-22 19:12:03 -0700950 if(strcmp(edev->prom_node->name, "rtc") == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 rtc_port = edev->resource[0].start;
952 rtc_irq = edev->irqs[0];
953 goto found;
954 }
955 }
956 }
957#ifdef __sparc_v9__
958 for_each_isa(isa_br) {
959 for_each_isadev(isa_dev, isa_br) {
David S. Miller690c8fd2006-06-22 19:12:03 -0700960 if (strcmp(isa_dev->prom_node->name, "rtc") == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 rtc_port = isa_dev->resource.start;
962 rtc_irq = isa_dev->irq;
963 goto found;
964 }
965 }
966 }
967#endif
Jan Beulichf3e92d32006-12-13 00:35:04 -0800968 rtc_has_irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 printk(KERN_ERR "rtc_init: no PC rtc found\n");
970 return -EIO;
971
972found:
973 if (rtc_irq == PCI_IRQ_NONE) {
974 rtc_has_irq = 0;
975 goto no_irq;
976 }
977
978 /*
979 * XXX Interrupt pin #7 in Espresso is shared between RTC and
David S. Miller53d0fc22005-09-05 23:33:05 -0700980 * PCI Slot 2 INTA# (and some INTx# in Slot 1).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 */
Thomas Gleixner0f2ed4c2006-07-01 19:29:33 -0700982 if (request_irq(rtc_irq, rtc_interrupt, IRQF_SHARED, "rtc", (void *)&rtc_port)) {
Jan Beulichf3e92d32006-12-13 00:35:04 -0800983 rtc_has_irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 printk(KERN_ERR "rtc: cannot register IRQ %d\n", rtc_irq);
985 return -EIO;
986 }
987no_irq:
988#else
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700989 if (RTC_IOMAPPED)
990 r = request_region(RTC_PORT(0), RTC_IO_EXTENT, "rtc");
991 else
992 r = request_mem_region(RTC_PORT(0), RTC_IO_EXTENT, "rtc");
993 if (!r) {
Jan Beulichf3e92d32006-12-13 00:35:04 -0800994#ifdef RTC_IRQ
995 rtc_has_irq = 0;
996#endif
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700997 printk(KERN_ERR "rtc: I/O resource %lx is not free.\n",
998 (long)(RTC_PORT(0)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 return -EIO;
1000 }
1001
1002#ifdef RTC_IRQ
1003 if (is_hpet_enabled()) {
1004 rtc_int_handler_ptr = hpet_rtc_interrupt;
1005 } else {
1006 rtc_int_handler_ptr = rtc_interrupt;
1007 }
1008
Thomas Gleixner0f2ed4c2006-07-01 19:29:33 -07001009 if(request_irq(RTC_IRQ, rtc_int_handler_ptr, IRQF_DISABLED, "rtc", NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 /* Yeah right, seeing as irq 8 doesn't even hit the bus. */
Jan Beulichf3e92d32006-12-13 00:35:04 -08001011 rtc_has_irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 printk(KERN_ERR "rtc: IRQ %d is not free.\n", RTC_IRQ);
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -07001013 if (RTC_IOMAPPED)
1014 release_region(RTC_PORT(0), RTC_IO_EXTENT);
1015 else
1016 release_mem_region(RTC_PORT(0), RTC_IO_EXTENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 return -EIO;
1018 }
1019 hpet_rtc_timer_init();
1020
1021#endif
1022
1023#endif /* __sparc__ vs. others */
1024
1025 if (misc_register(&rtc_dev)) {
1026#ifdef RTC_IRQ
1027 free_irq(RTC_IRQ, NULL);
Jan Beulichf3e92d32006-12-13 00:35:04 -08001028 rtc_has_irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029#endif
1030 release_region(RTC_PORT(0), RTC_IO_EXTENT);
1031 return -ENODEV;
1032 }
1033
Jan Beulich9cef7792006-12-13 00:35:05 -08001034#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 ent = create_proc_entry("driver/rtc", 0, NULL);
Jan Beulich9cef7792006-12-13 00:35:05 -08001036 if (ent)
1037 ent->proc_fops = &rtc_proc_fops;
1038 else
1039 printk(KERN_WARNING "rtc: Failed to register with procfs.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041
1042#if defined(__alpha__) || defined(__mips__)
1043 rtc_freq = HZ;
1044
1045 /* Each operating system on an Alpha uses its own epoch.
1046 Let's try to guess which one we are using now. */
1047
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 if (rtc_is_updating() != 0)
Luca Falavigna47f176f2005-06-28 20:44:42 -07001049 msleep(20);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
1051 spin_lock_irq(&rtc_lock);
1052 year = CMOS_READ(RTC_YEAR);
1053 ctrl = CMOS_READ(RTC_CONTROL);
1054 spin_unlock_irq(&rtc_lock);
1055
1056 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1057 BCD_TO_BIN(year); /* This should never happen... */
1058
1059 if (year < 20) {
1060 epoch = 2000;
1061 guess = "SRM (post-2000)";
1062 } else if (year >= 20 && year < 48) {
1063 epoch = 1980;
1064 guess = "ARC console";
1065 } else if (year >= 48 && year < 72) {
1066 epoch = 1952;
1067 guess = "Digital UNIX";
1068#if defined(__mips__)
1069 } else if (year >= 72 && year < 74) {
1070 epoch = 2000;
1071 guess = "Digital DECstation";
1072#else
1073 } else if (year >= 70) {
1074 epoch = 1900;
1075 guess = "Standard PC (1900)";
1076#endif
1077 }
1078 if (guess)
1079 printk(KERN_INFO "rtc: %s epoch (%lu) detected\n", guess, epoch);
1080#endif
1081#ifdef RTC_IRQ
1082 if (rtc_has_irq == 0)
1083 goto no_irq2;
1084
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 spin_lock_irq(&rtc_lock);
1086 rtc_freq = 1024;
1087 if (!hpet_set_periodic_freq(rtc_freq)) {
1088 /* Initialize periodic freq. to CMOS reset default, which is 1024Hz */
1089 CMOS_WRITE(((CMOS_READ(RTC_FREQ_SELECT) & 0xF0) | 0x06), RTC_FREQ_SELECT);
1090 }
1091 spin_unlock_irq(&rtc_lock);
1092no_irq2:
1093#endif
1094
1095 (void) init_sysctl();
1096
1097 printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n");
1098
1099 return 0;
1100}
1101
1102static void __exit rtc_exit (void)
1103{
1104 cleanup_sysctl();
1105 remove_proc_entry ("driver/rtc", NULL);
1106 misc_deregister(&rtc_dev);
1107
1108#ifdef __sparc__
1109 if (rtc_has_irq)
1110 free_irq (rtc_irq, &rtc_port);
1111#else
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -07001112 if (RTC_IOMAPPED)
1113 release_region(RTC_PORT(0), RTC_IO_EXTENT);
1114 else
1115 release_mem_region(RTC_PORT(0), RTC_IO_EXTENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116#ifdef RTC_IRQ
1117 if (rtc_has_irq)
1118 free_irq (RTC_IRQ, NULL);
1119#endif
1120#endif /* __sparc__ */
1121}
1122
1123module_init(rtc_init);
1124module_exit(rtc_exit);
1125
1126#ifdef RTC_IRQ
1127/*
1128 * At IRQ rates >= 4096Hz, an interrupt may get lost altogether.
1129 * (usually during an IDE disk interrupt, with IRQ unmasking off)
1130 * Since the interrupt handler doesn't get called, the IRQ status
1131 * byte doesn't get read, and the RTC stops generating interrupts.
1132 * A timer is set, and will call this function if/when that happens.
1133 * To get it out of this stalled state, we just read the status.
1134 * At least a jiffy of interrupts (rtc_freq/HZ) will have been lost.
1135 * (You *really* shouldn't be trying to use a non-realtime system
1136 * for something that requires a steady > 1KHz signal anyways.)
1137 */
1138
1139static void rtc_dropped_irq(unsigned long data)
1140{
1141 unsigned long freq;
1142
1143 spin_lock_irq (&rtc_lock);
1144
1145 if (hpet_rtc_dropped_irq()) {
1146 spin_unlock_irq(&rtc_lock);
1147 return;
1148 }
1149
1150 /* Just in case someone disabled the timer from behind our back... */
1151 if (rtc_status & RTC_TIMER_ON)
1152 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
1153
1154 rtc_irq_data += ((rtc_freq/HZ)<<8);
1155 rtc_irq_data &= ~0xff;
1156 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0); /* restart */
1157
1158 freq = rtc_freq;
1159
1160 spin_unlock_irq(&rtc_lock);
1161
1162 printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n", freq);
1163
1164 /* Now we have new data */
1165 wake_up_interruptible(&rtc_wait);
1166
1167 kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);
1168}
1169#endif
1170
Jan Beulich9cef7792006-12-13 00:35:05 -08001171#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172/*
1173 * Info exported via "/proc/driver/rtc".
1174 */
1175
1176static int rtc_proc_show(struct seq_file *seq, void *v)
1177{
1178#define YN(bit) ((ctrl & bit) ? "yes" : "no")
1179#define NY(bit) ((ctrl & bit) ? "no" : "yes")
1180 struct rtc_time tm;
1181 unsigned char batt, ctrl;
1182 unsigned long freq;
1183
1184 spin_lock_irq(&rtc_lock);
1185 batt = CMOS_READ(RTC_VALID) & RTC_VRT;
1186 ctrl = CMOS_READ(RTC_CONTROL);
1187 freq = rtc_freq;
1188 spin_unlock_irq(&rtc_lock);
1189
1190
1191 rtc_get_rtc_time(&tm);
1192
1193 /*
1194 * There is no way to tell if the luser has the RTC set for local
1195 * time or for Universal Standard Time (GMT). Probably local though.
1196 */
1197 seq_printf(seq,
1198 "rtc_time\t: %02d:%02d:%02d\n"
1199 "rtc_date\t: %04d-%02d-%02d\n"
1200 "rtc_epoch\t: %04lu\n",
1201 tm.tm_hour, tm.tm_min, tm.tm_sec,
1202 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, epoch);
1203
1204 get_rtc_alm_time(&tm);
1205
1206 /*
1207 * We implicitly assume 24hr mode here. Alarm values >= 0xc0 will
1208 * match any value for that particular field. Values that are
1209 * greater than a valid time, but less than 0xc0 shouldn't appear.
1210 */
1211 seq_puts(seq, "alarm\t\t: ");
1212 if (tm.tm_hour <= 24)
1213 seq_printf(seq, "%02d:", tm.tm_hour);
1214 else
1215 seq_puts(seq, "**:");
1216
1217 if (tm.tm_min <= 59)
1218 seq_printf(seq, "%02d:", tm.tm_min);
1219 else
1220 seq_puts(seq, "**:");
1221
1222 if (tm.tm_sec <= 59)
1223 seq_printf(seq, "%02d\n", tm.tm_sec);
1224 else
1225 seq_puts(seq, "**\n");
1226
1227 seq_printf(seq,
1228 "DST_enable\t: %s\n"
1229 "BCD\t\t: %s\n"
1230 "24hr\t\t: %s\n"
1231 "square_wave\t: %s\n"
1232 "alarm_IRQ\t: %s\n"
1233 "update_IRQ\t: %s\n"
1234 "periodic_IRQ\t: %s\n"
1235 "periodic_freq\t: %ld\n"
1236 "batt_status\t: %s\n",
1237 YN(RTC_DST_EN),
1238 NY(RTC_DM_BINARY),
1239 YN(RTC_24H),
1240 YN(RTC_SQWE),
1241 YN(RTC_AIE),
1242 YN(RTC_UIE),
1243 YN(RTC_PIE),
1244 freq,
1245 batt ? "okay" : "dead");
1246
1247 return 0;
1248#undef YN
1249#undef NY
1250}
1251
1252static int rtc_proc_open(struct inode *inode, struct file *file)
1253{
1254 return single_open(file, rtc_proc_show, NULL);
1255}
Jan Beulich9cef7792006-12-13 00:35:05 -08001256#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257
1258void rtc_get_rtc_time(struct rtc_time *rtc_tm)
1259{
Ingo Molnar0f749642006-07-12 09:03:10 -07001260 unsigned long uip_watchdog = jiffies, flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 unsigned char ctrl;
1262#ifdef CONFIG_MACH_DECSTATION
1263 unsigned int real_year;
1264#endif
1265
1266 /*
1267 * read RTC once any update in progress is done. The update
Luca Falavigna47f176f2005-06-28 20:44:42 -07001268 * can take just over 2ms. We wait 20ms. There is no need to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
1270 * If you need to know *exactly* when a second has started, enable
1271 * periodic update complete interrupts, (via ioctl) and then
1272 * immediately read /dev/rtc which will block until you get the IRQ.
1273 * Once the read clears, read the RTC time (again via ioctl). Easy.
1274 */
1275
Steven Rostedt358333a2006-09-29 01:59:04 -07001276 while (rtc_is_updating() != 0 && jiffies - uip_watchdog < 2*HZ/100)
Petr Vandrovec403fe5a2005-08-05 15:50:07 +02001277 cpu_relax();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278
1279 /*
1280 * Only the values that we read from the RTC are set. We leave
Alan Coxb7599582006-01-11 12:17:32 -08001281 * tm_wday, tm_yday and tm_isdst untouched. Note that while the
1282 * RTC has RTC_DAY_OF_WEEK, we should usually ignore it, as it is
1283 * only updated by the RTC when initially set to a non-zero value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 */
Ingo Molnar0f749642006-07-12 09:03:10 -07001285 spin_lock_irqsave(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS);
1287 rtc_tm->tm_min = CMOS_READ(RTC_MINUTES);
1288 rtc_tm->tm_hour = CMOS_READ(RTC_HOURS);
1289 rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
1290 rtc_tm->tm_mon = CMOS_READ(RTC_MONTH);
1291 rtc_tm->tm_year = CMOS_READ(RTC_YEAR);
Alan Coxb7599582006-01-11 12:17:32 -08001292 /* Only set from 2.6.16 onwards */
1293 rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK);
1294
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295#ifdef CONFIG_MACH_DECSTATION
1296 real_year = CMOS_READ(RTC_DEC_YEAR);
1297#endif
1298 ctrl = CMOS_READ(RTC_CONTROL);
Ingo Molnar0f749642006-07-12 09:03:10 -07001299 spin_unlock_irqrestore(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
1301 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1302 {
1303 BCD_TO_BIN(rtc_tm->tm_sec);
1304 BCD_TO_BIN(rtc_tm->tm_min);
1305 BCD_TO_BIN(rtc_tm->tm_hour);
1306 BCD_TO_BIN(rtc_tm->tm_mday);
1307 BCD_TO_BIN(rtc_tm->tm_mon);
1308 BCD_TO_BIN(rtc_tm->tm_year);
Alan Coxb7599582006-01-11 12:17:32 -08001309 BCD_TO_BIN(rtc_tm->tm_wday);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 }
1311
1312#ifdef CONFIG_MACH_DECSTATION
1313 rtc_tm->tm_year += real_year - 72;
1314#endif
1315
1316 /*
1317 * Account for differences between how the RTC uses the values
1318 * and how they are defined in a struct rtc_time;
1319 */
1320 if ((rtc_tm->tm_year += (epoch - 1900)) <= 69)
1321 rtc_tm->tm_year += 100;
1322
1323 rtc_tm->tm_mon--;
1324}
1325
1326static void get_rtc_alm_time(struct rtc_time *alm_tm)
1327{
1328 unsigned char ctrl;
1329
1330 /*
1331 * Only the values that we read from the RTC are set. That
1332 * means only tm_hour, tm_min, and tm_sec.
1333 */
1334 spin_lock_irq(&rtc_lock);
1335 alm_tm->tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
1336 alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM);
1337 alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM);
1338 ctrl = CMOS_READ(RTC_CONTROL);
1339 spin_unlock_irq(&rtc_lock);
1340
1341 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1342 {
1343 BCD_TO_BIN(alm_tm->tm_sec);
1344 BCD_TO_BIN(alm_tm->tm_min);
1345 BCD_TO_BIN(alm_tm->tm_hour);
1346 }
1347}
1348
1349#ifdef RTC_IRQ
1350/*
1351 * Used to disable/enable interrupts for any one of UIE, AIE, PIE.
1352 * Rumour has it that if you frob the interrupt enable/disable
1353 * bits in RTC_CONTROL, you should read RTC_INTR_FLAGS, to
1354 * ensure you actually start getting interrupts. Probably for
1355 * compatibility with older/broken chipset RTC implementations.
1356 * We also clear out any old irq data after an ioctl() that
1357 * meddles with the interrupt enable/disable bits.
1358 */
1359
Takashi Iwaic3348762005-11-07 11:14:57 +01001360static void mask_rtc_irq_bit_locked(unsigned char bit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361{
1362 unsigned char val;
1363
Takashi Iwaic3348762005-11-07 11:14:57 +01001364 if (hpet_mask_rtc_irq_bit(bit))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 val = CMOS_READ(RTC_CONTROL);
1367 val &= ~bit;
1368 CMOS_WRITE(val, RTC_CONTROL);
1369 CMOS_READ(RTC_INTR_FLAGS);
1370
1371 rtc_irq_data = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372}
1373
Takashi Iwaic3348762005-11-07 11:14:57 +01001374static void set_rtc_irq_bit_locked(unsigned char bit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375{
1376 unsigned char val;
1377
Takashi Iwaic3348762005-11-07 11:14:57 +01001378 if (hpet_set_rtc_irq_bit(bit))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 val = CMOS_READ(RTC_CONTROL);
1381 val |= bit;
1382 CMOS_WRITE(val, RTC_CONTROL);
1383 CMOS_READ(RTC_INTR_FLAGS);
1384
1385 rtc_irq_data = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386}
1387#endif
1388
1389MODULE_AUTHOR("Paul Gortmaker");
1390MODULE_LICENSE("GPL");
1391MODULE_ALIAS_MISCDEV(RTC_MINOR);