blob: 5f80a9dff5735103b91cc16c40338aafa96f853a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01002 * Real Time Clock interface for Linux
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
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
Ingo Molnar5fd1fe92008-01-30 13:31:09 +010020 * interrupts since the last read in the remaining high bytes. The
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 * /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
Chris Wright55f93af2007-07-21 17:10:09 +020085#ifdef CONFIG_X86
Linus Torvalds1da177e2005-04-16 15:20:36 -070086#include <asm/hpet.h>
87#endif
88
David S. Millercdee99d2007-07-19 13:59:58 -070089#ifdef CONFIG_SPARC32
Linus Torvalds1da177e2005-04-16 15:20:36 -070090#include <linux/pci.h>
Julia Lawalldca03a52008-04-28 02:11:59 -070091#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070092#include <asm/ebus.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94static unsigned long rtc_port;
95static int rtc_irq = PCI_IRQ_NONE;
96#endif
97
98#ifdef CONFIG_HPET_RTC_IRQ
99#undef RTC_IRQ
100#endif
101
102#ifdef RTC_IRQ
103static int rtc_has_irq = 1;
104#endif
105
106#ifndef CONFIG_HPET_EMULATE_RTC
107#define is_hpet_enabled() 0
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100108#define hpet_set_alarm_time(hrs, min, sec) 0
109#define hpet_set_periodic_freq(arg) 0
110#define hpet_mask_rtc_irq_bit(arg) 0
111#define hpet_set_rtc_irq_bit(arg) 0
112#define hpet_rtc_timer_init() do { } while (0)
113#define hpet_rtc_dropped_irq() 0
David Howells32fa4582008-02-28 13:29:43 +0000114#define hpet_register_irq_handler(h) ({ 0; })
115#define hpet_unregister_irq_handler(h) ({ 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
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100153static void get_rtc_alm_time(struct rtc_time *alm_tm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154#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 */
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100191static unsigned long rtc_status; /* bitmapped status byte. */
192static unsigned long rtc_freq; /* Current periodic IRQ rate */
193static unsigned long rtc_irq_data; /* our output to the world */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194static 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);
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100201static rtc_task_t *rtc_callback;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202#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
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100211static const unsigned char days_in_mo[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{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
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100248 spin_lock(&rtc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 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
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100265 spin_unlock(&rtc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
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);
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100272 wake_up_interruptible(&rtc_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100274 kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
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;
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 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);
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100364
365 spin_lock_irq(&rtc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 data = rtc_irq_data;
367 rtc_irq_data = 0;
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100368 spin_unlock_irq(&rtc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
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
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100384 if (count == sizeof(unsigned int)) {
385 retval = put_user(data,
386 (unsigned int __user *)buf) ?: sizeof(int);
387 } else {
388 retval = put_user(data,
389 (unsigned long __user *)buf) ?: sizeof(long);
390 }
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700391 if (!retval)
392 retval = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 out:
Milind Arun Choudharycc0a8fb2007-05-08 00:30:52 -0700394 __set_current_state(TASK_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 remove_wait_queue(&rtc_wait, &wait);
396
397 return retval;
398#endif
399}
400
401static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
402{
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100403 struct rtc_time wtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
405#ifdef RTC_IRQ
406 if (rtc_has_irq == 0) {
407 switch (cmd) {
408 case RTC_AIE_OFF:
409 case RTC_AIE_ON:
410 case RTC_PIE_OFF:
411 case RTC_PIE_ON:
412 case RTC_UIE_OFF:
413 case RTC_UIE_ON:
414 case RTC_IRQP_READ:
415 case RTC_IRQP_SET:
416 return -EINVAL;
417 };
418 }
419#endif
420
421 switch (cmd) {
422#ifdef RTC_IRQ
423 case RTC_AIE_OFF: /* Mask alarm int. enab. bit */
424 {
425 mask_rtc_irq_bit(RTC_AIE);
426 return 0;
427 }
428 case RTC_AIE_ON: /* Allow alarm interrupts. */
429 {
430 set_rtc_irq_bit(RTC_AIE);
431 return 0;
432 }
433 case RTC_PIE_OFF: /* Mask periodic int. enab. bit */
434 {
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100435 /* can be called from isr via rtc_control() */
436 unsigned long flags;
437
438 spin_lock_irqsave(&rtc_lock, flags);
Takashi Iwaic3348762005-11-07 11:14:57 +0100439 mask_rtc_irq_bit_locked(RTC_PIE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 if (rtc_status & RTC_TIMER_ON) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 rtc_status &= ~RTC_TIMER_ON;
442 del_timer(&rtc_irq_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 }
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100444 spin_unlock_irqrestore(&rtc_lock, flags);
445
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 return 0;
447 }
448 case RTC_PIE_ON: /* Allow periodic ints */
449 {
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100450 /* can be called from isr via rtc_control() */
451 unsigned long flags;
452
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 /*
454 * We don't really want Joe User enabling more
455 * than 64Hz of interrupts on a multi-user machine.
456 */
457 if (!kernel && (rtc_freq > rtc_max_user_freq) &&
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100458 (!capable(CAP_SYS_RESOURCE)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 return -EACCES;
460
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100461 spin_lock_irqsave(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 if (!(rtc_status & RTC_TIMER_ON)) {
Jiri Slaby40565f12007-02-12 00:52:31 -0800463 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq +
464 2*HZ/100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 rtc_status |= RTC_TIMER_ON;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 }
Takashi Iwaic3348762005-11-07 11:14:57 +0100467 set_rtc_irq_bit_locked(RTC_PIE);
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100468 spin_unlock_irqrestore(&rtc_lock, flags);
469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 return 0;
471 }
472 case RTC_UIE_OFF: /* Mask ints from RTC updates. */
473 {
474 mask_rtc_irq_bit(RTC_UIE);
475 return 0;
476 }
477 case RTC_UIE_ON: /* Allow ints for RTC updates. */
478 {
479 set_rtc_irq_bit(RTC_UIE);
480 return 0;
481 }
482#endif
483 case RTC_ALM_READ: /* Read the present alarm time */
484 {
485 /*
486 * This returns a struct rtc_time. Reading >= 0xc0
487 * means "don't care" or "match all". Only the tm_hour,
488 * tm_min, and tm_sec values are filled in.
489 */
490 memset(&wtime, 0, sizeof(struct rtc_time));
491 get_rtc_alm_time(&wtime);
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100492 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 }
494 case RTC_ALM_SET: /* Store a time into the alarm */
495 {
496 /*
497 * This expects a struct rtc_time. Writing 0xff means
498 * "don't care" or "match all". Only the tm_hour,
499 * tm_min and tm_sec are used.
500 */
501 unsigned char hrs, min, sec;
502 struct rtc_time alm_tm;
503
504 if (copy_from_user(&alm_tm, (struct rtc_time __user *)arg,
505 sizeof(struct rtc_time)))
506 return -EFAULT;
507
508 hrs = alm_tm.tm_hour;
509 min = alm_tm.tm_min;
510 sec = alm_tm.tm_sec;
511
512 spin_lock_irq(&rtc_lock);
513 if (hpet_set_alarm_time(hrs, min, sec)) {
514 /*
515 * Fallthru and set alarm time in CMOS too,
516 * so that we will get proper value in RTC_ALM_READ
517 */
518 }
519 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) ||
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100520 RTC_ALWAYS_BCD) {
521 if (sec < 60)
522 BIN_TO_BCD(sec);
523 else
524 sec = 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100526 if (min < 60)
527 BIN_TO_BCD(min);
528 else
529 min = 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100531 if (hrs < 24)
532 BIN_TO_BCD(hrs);
533 else
534 hrs = 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 }
536 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
537 CMOS_WRITE(min, RTC_MINUTES_ALARM);
538 CMOS_WRITE(sec, RTC_SECONDS_ALARM);
539 spin_unlock_irq(&rtc_lock);
540
541 return 0;
542 }
543 case RTC_RD_TIME: /* Read the time/date from RTC */
544 {
545 memset(&wtime, 0, sizeof(struct rtc_time));
546 rtc_get_rtc_time(&wtime);
547 break;
548 }
549 case RTC_SET_TIME: /* Set the RTC */
550 {
551 struct rtc_time rtc_tm;
552 unsigned char mon, day, hrs, min, sec, leap_yr;
553 unsigned char save_control, save_freq_select;
554 unsigned int yrs;
555#ifdef CONFIG_MACH_DECSTATION
556 unsigned int real_yrs;
557#endif
558
559 if (!capable(CAP_SYS_TIME))
560 return -EACCES;
561
562 if (copy_from_user(&rtc_tm, (struct rtc_time __user *)arg,
563 sizeof(struct rtc_time)))
564 return -EFAULT;
565
566 yrs = rtc_tm.tm_year + 1900;
567 mon = rtc_tm.tm_mon + 1; /* tm_mon starts at zero */
568 day = rtc_tm.tm_mday;
569 hrs = rtc_tm.tm_hour;
570 min = rtc_tm.tm_min;
571 sec = rtc_tm.tm_sec;
572
573 if (yrs < 1970)
574 return -EINVAL;
575
576 leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
577
578 if ((mon > 12) || (day == 0))
579 return -EINVAL;
580
581 if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
582 return -EINVAL;
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100583
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 if ((hrs >= 24) || (min >= 60) || (sec >= 60))
585 return -EINVAL;
586
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100587 yrs -= epoch;
588 if (yrs > 255) /* They are unsigned */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 return -EINVAL;
590
591 spin_lock_irq(&rtc_lock);
592#ifdef CONFIG_MACH_DECSTATION
593 real_yrs = yrs;
594 yrs = 72;
595
596 /*
597 * We want to keep the year set to 73 until March
598 * for non-leap years, so that Feb, 29th is handled
599 * correctly.
600 */
601 if (!leap_yr && mon < 3) {
602 real_yrs--;
603 yrs = 73;
604 }
605#endif
606 /* These limits and adjustments are independent of
607 * whether the chip is in binary mode or not.
608 */
609 if (yrs > 169) {
610 spin_unlock_irq(&rtc_lock);
611 return -EINVAL;
612 }
613 if (yrs >= 100)
614 yrs -= 100;
615
616 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)
617 || RTC_ALWAYS_BCD) {
618 BIN_TO_BCD(sec);
619 BIN_TO_BCD(min);
620 BIN_TO_BCD(hrs);
621 BIN_TO_BCD(day);
622 BIN_TO_BCD(mon);
623 BIN_TO_BCD(yrs);
624 }
625
626 save_control = CMOS_READ(RTC_CONTROL);
627 CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
628 save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
629 CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
630
631#ifdef CONFIG_MACH_DECSTATION
632 CMOS_WRITE(real_yrs, RTC_DEC_YEAR);
633#endif
634 CMOS_WRITE(yrs, RTC_YEAR);
635 CMOS_WRITE(mon, RTC_MONTH);
636 CMOS_WRITE(day, RTC_DAY_OF_MONTH);
637 CMOS_WRITE(hrs, RTC_HOURS);
638 CMOS_WRITE(min, RTC_MINUTES);
639 CMOS_WRITE(sec, RTC_SECONDS);
640
641 CMOS_WRITE(save_control, RTC_CONTROL);
642 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
643
644 spin_unlock_irq(&rtc_lock);
645 return 0;
646 }
647#ifdef RTC_IRQ
648 case RTC_IRQP_READ: /* Read the periodic IRQ rate. */
649 {
650 return put_user(rtc_freq, (unsigned long __user *)arg);
651 }
652 case RTC_IRQP_SET: /* Set periodic IRQ rate. */
653 {
654 int tmp = 0;
655 unsigned char val;
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100656 /* can be called from isr via rtc_control() */
657 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100659 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 * The max we can do is 8192Hz.
661 */
662 if ((arg < 2) || (arg > 8192))
663 return -EINVAL;
664 /*
665 * We don't really want Joe User generating more
666 * than 64Hz of interrupts on a multi-user machine.
667 */
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100668 if (!kernel && (arg > rtc_max_user_freq) &&
669 !capable(CAP_SYS_RESOURCE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 return -EACCES;
671
672 while (arg > (1<<tmp))
673 tmp++;
674
675 /*
676 * Check that the input was really a power of 2.
677 */
678 if (arg != (1<<tmp))
679 return -EINVAL;
680
Takashi Iwaic3348762005-11-07 11:14:57 +0100681 spin_lock_irqsave(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 if (hpet_set_periodic_freq(arg)) {
Takashi Iwaic3348762005-11-07 11:14:57 +0100683 spin_unlock_irqrestore(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 return 0;
685 }
686 rtc_freq = arg;
687
688 val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0;
689 val |= (16 - tmp);
690 CMOS_WRITE(val, RTC_FREQ_SELECT);
Takashi Iwaic3348762005-11-07 11:14:57 +0100691 spin_unlock_irqrestore(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 return 0;
693 }
694#endif
695 case RTC_EPOCH_READ: /* Read the epoch. */
696 {
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100697 return put_user(epoch, (unsigned long __user *)arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 }
699 case RTC_EPOCH_SET: /* Set the epoch. */
700 {
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100701 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 * There were no RTC clocks before 1900.
703 */
704 if (arg < 1900)
705 return -EINVAL;
706
707 if (!capable(CAP_SYS_TIME))
708 return -EACCES;
709
710 epoch = arg;
711 return 0;
712 }
713 default:
714 return -ENOTTY;
715 }
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100716 return copy_to_user((void __user *)arg,
717 &wtime, sizeof wtime) ? -EFAULT : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718}
719
720static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
721 unsigned long arg)
722{
723 return rtc_do_ioctl(cmd, arg, 0);
724}
725
726/*
727 * We enforce only one user at a time here with the open/close.
728 * Also clear the previous interrupt data on an open, and clean
729 * up things on a close.
730 */
731
732/* We use rtc_lock to protect against concurrent opens. So the BKL is not
733 * needed here. Or anywhere else in this driver. */
734static int rtc_open(struct inode *inode, struct file *file)
735{
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100736 spin_lock_irq(&rtc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100738 if (rtc_status & RTC_IS_OPEN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 goto out_busy;
740
741 rtc_status |= RTC_IS_OPEN;
742
743 rtc_irq_data = 0;
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100744 spin_unlock_irq(&rtc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 return 0;
746
747out_busy:
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100748 spin_unlock_irq(&rtc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 return -EBUSY;
750}
751
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100752static int rtc_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100754 return fasync_helper(fd, filp, on, &rtc_async_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755}
756
757static int rtc_release(struct inode *inode, struct file *file)
758{
759#ifdef RTC_IRQ
760 unsigned char tmp;
761
762 if (rtc_has_irq == 0)
763 goto no_irq;
764
765 /*
766 * Turn off all interrupts once the device is no longer
767 * in use, and clear the data.
768 */
769
770 spin_lock_irq(&rtc_lock);
771 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
772 tmp = CMOS_READ(RTC_CONTROL);
773 tmp &= ~RTC_PIE;
774 tmp &= ~RTC_AIE;
775 tmp &= ~RTC_UIE;
776 CMOS_WRITE(tmp, RTC_CONTROL);
777 CMOS_READ(RTC_INTR_FLAGS);
778 }
779 if (rtc_status & RTC_TIMER_ON) {
780 rtc_status &= ~RTC_TIMER_ON;
781 del_timer(&rtc_irq_timer);
782 }
783 spin_unlock_irq(&rtc_lock);
784
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100785 if (file->f_flags & FASYNC)
786 rtc_fasync(-1, file, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787no_irq:
788#endif
789
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100790 spin_lock_irq(&rtc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 rtc_irq_data = 0;
792 rtc_status &= ~RTC_IS_OPEN;
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100793 spin_unlock_irq(&rtc_lock);
794
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 return 0;
796}
797
798#ifdef RTC_IRQ
799/* Called without the kernel lock - fine */
800static unsigned int rtc_poll(struct file *file, poll_table *wait)
801{
802 unsigned long l;
803
804 if (rtc_has_irq == 0)
805 return 0;
806
807 poll_wait(file, &rtc_wait, wait);
808
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100809 spin_lock_irq(&rtc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 l = rtc_irq_data;
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100811 spin_unlock_irq(&rtc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812
813 if (l != 0)
814 return POLLIN | POLLRDNORM;
815 return 0;
816}
817#endif
818
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819int rtc_register(rtc_task_t *task)
820{
821#ifndef RTC_IRQ
822 return -EIO;
823#else
824 if (task == NULL || task->func == NULL)
825 return -EINVAL;
826 spin_lock_irq(&rtc_lock);
827 if (rtc_status & RTC_IS_OPEN) {
828 spin_unlock_irq(&rtc_lock);
829 return -EBUSY;
830 }
831 spin_lock(&rtc_task_lock);
832 if (rtc_callback) {
833 spin_unlock(&rtc_task_lock);
834 spin_unlock_irq(&rtc_lock);
835 return -EBUSY;
836 }
837 rtc_status |= RTC_IS_OPEN;
838 rtc_callback = task;
839 spin_unlock(&rtc_task_lock);
840 spin_unlock_irq(&rtc_lock);
841 return 0;
842#endif
843}
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100844EXPORT_SYMBOL(rtc_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845
846int rtc_unregister(rtc_task_t *task)
847{
848#ifndef RTC_IRQ
849 return -EIO;
850#else
851 unsigned char tmp;
852
853 spin_lock_irq(&rtc_lock);
854 spin_lock(&rtc_task_lock);
855 if (rtc_callback != task) {
856 spin_unlock(&rtc_task_lock);
857 spin_unlock_irq(&rtc_lock);
858 return -ENXIO;
859 }
860 rtc_callback = NULL;
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100861
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 /* disable controls */
863 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
864 tmp = CMOS_READ(RTC_CONTROL);
865 tmp &= ~RTC_PIE;
866 tmp &= ~RTC_AIE;
867 tmp &= ~RTC_UIE;
868 CMOS_WRITE(tmp, RTC_CONTROL);
869 CMOS_READ(RTC_INTR_FLAGS);
870 }
871 if (rtc_status & RTC_TIMER_ON) {
872 rtc_status &= ~RTC_TIMER_ON;
873 del_timer(&rtc_irq_timer);
874 }
875 rtc_status &= ~RTC_IS_OPEN;
876 spin_unlock(&rtc_task_lock);
877 spin_unlock_irq(&rtc_lock);
878 return 0;
879#endif
880}
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100881EXPORT_SYMBOL(rtc_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
883int rtc_control(rtc_task_t *task, unsigned int cmd, unsigned long arg)
884{
885#ifndef RTC_IRQ
886 return -EIO;
887#else
Takashi Iwaic3348762005-11-07 11:14:57 +0100888 unsigned long flags;
889 if (cmd != RTC_PIE_ON && cmd != RTC_PIE_OFF && cmd != RTC_IRQP_SET)
890 return -EINVAL;
891 spin_lock_irqsave(&rtc_task_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 if (rtc_callback != task) {
Takashi Iwaic3348762005-11-07 11:14:57 +0100893 spin_unlock_irqrestore(&rtc_task_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 return -ENXIO;
895 }
Takashi Iwaic3348762005-11-07 11:14:57 +0100896 spin_unlock_irqrestore(&rtc_task_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 return rtc_do_ioctl(cmd, arg, 1);
898#endif
899}
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100900EXPORT_SYMBOL(rtc_control);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
902/*
903 * The various file operations we support.
904 */
905
Arjan van de Ven62322d22006-07-03 00:24:21 -0700906static const struct file_operations rtc_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 .owner = THIS_MODULE,
908 .llseek = no_llseek,
909 .read = rtc_read,
910#ifdef RTC_IRQ
911 .poll = rtc_poll,
912#endif
913 .ioctl = rtc_ioctl,
914 .open = rtc_open,
915 .release = rtc_release,
916 .fasync = rtc_fasync,
917};
918
919static struct miscdevice rtc_dev = {
920 .minor = RTC_MINOR,
921 .name = "rtc",
922 .fops = &rtc_fops,
923};
924
Jan Beulich9cef7792006-12-13 00:35:05 -0800925#ifdef CONFIG_PROC_FS
Arjan van de Ven62322d22006-07-03 00:24:21 -0700926static const struct file_operations rtc_proc_fops = {
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100927 .owner = THIS_MODULE,
928 .open = rtc_proc_open,
929 .read = seq_read,
930 .llseek = seq_lseek,
931 .release = single_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933#endif
934
Bjorn Helgaas9626f1f12007-11-14 16:59:57 -0800935static resource_size_t rtc_size;
936
937static struct resource * __init rtc_request_region(resource_size_t size)
938{
939 struct resource *r;
940
941 if (RTC_IOMAPPED)
942 r = request_region(RTC_PORT(0), size, "rtc");
943 else
944 r = request_mem_region(RTC_PORT(0), size, "rtc");
945
946 if (r)
947 rtc_size = size;
948
949 return r;
950}
951
Bjorn Helgaas4c06be12007-11-14 16:59:56 -0800952static void rtc_release_region(void)
953{
954 if (RTC_IOMAPPED)
Bjorn Helgaas9626f1f12007-11-14 16:59:57 -0800955 release_region(RTC_PORT(0), rtc_size);
Bjorn Helgaas4c06be12007-11-14 16:59:56 -0800956 else
Bjorn Helgaas9626f1f12007-11-14 16:59:57 -0800957 release_mem_region(RTC_PORT(0), rtc_size);
Bjorn Helgaas4c06be12007-11-14 16:59:56 -0800958}
959
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960static int __init rtc_init(void)
961{
Jan Beulich9cef7792006-12-13 00:35:05 -0800962#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 struct proc_dir_entry *ent;
Jan Beulich9cef7792006-12-13 00:35:05 -0800964#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965#if defined(__alpha__) || defined(__mips__)
966 unsigned int year, ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 char *guess = NULL;
968#endif
David S. Millercdee99d2007-07-19 13:59:58 -0700969#ifdef CONFIG_SPARC32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 struct linux_ebus *ebus;
971 struct linux_ebus_device *edev;
Jan Beulich9cef7792006-12-13 00:35:05 -0800972#else
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700973 void *r;
Jan Beulich9cef7792006-12-13 00:35:05 -0800974#ifdef RTC_IRQ
975 irq_handler_t rtc_int_handler_ptr;
976#endif
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -0700977#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
David S. Millercdee99d2007-07-19 13:59:58 -0700979#ifdef CONFIG_SPARC32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 for_each_ebus(ebus) {
981 for_each_ebusdev(edev, ebus) {
Ingo Molnar5fd1fe92008-01-30 13:31:09 +0100982 if (strcmp(edev->prom_node->name, "rtc") == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 rtc_port = edev->resource[0].start;
984 rtc_irq = edev->irqs[0];
985 goto found;
986 }
987 }
988 }
Jan Beulichf3e92d32006-12-13 00:35:04 -0800989 rtc_has_irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 printk(KERN_ERR "rtc_init: no PC rtc found\n");
991 return -EIO;
992
993found:
994 if (rtc_irq == PCI_IRQ_NONE) {
995 rtc_has_irq = 0;
996 goto no_irq;
997 }
998
999 /*
1000 * XXX Interrupt pin #7 in Espresso is shared between RTC and
David S. Miller53d0fc22005-09-05 23:33:05 -07001001 * PCI Slot 2 INTA# (and some INTx# in Slot 1).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 */
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001003 if (request_irq(rtc_irq, rtc_interrupt, IRQF_SHARED, "rtc",
1004 (void *)&rtc_port)) {
Jan Beulichf3e92d32006-12-13 00:35:04 -08001005 rtc_has_irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 printk(KERN_ERR "rtc: cannot register IRQ %d\n", rtc_irq);
1007 return -EIO;
1008 }
1009no_irq:
1010#else
Bjorn Helgaas9626f1f12007-11-14 16:59:57 -08001011 r = rtc_request_region(RTC_IO_EXTENT);
1012
1013 /*
1014 * If we've already requested a smaller range (for example, because
1015 * PNPBIOS or ACPI told us how the device is configured), the request
1016 * above might fail because it's too big.
1017 *
1018 * If so, request just the range we actually use.
1019 */
1020 if (!r)
1021 r = rtc_request_region(RTC_IO_EXTENT_USED);
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -07001022 if (!r) {
Jan Beulichf3e92d32006-12-13 00:35:04 -08001023#ifdef RTC_IRQ
1024 rtc_has_irq = 0;
1025#endif
Maciej W. Rozycki38e0e8c2006-07-10 04:45:30 -07001026 printk(KERN_ERR "rtc: I/O resource %lx is not free.\n",
1027 (long)(RTC_PORT(0)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 return -EIO;
1029 }
1030
1031#ifdef RTC_IRQ
1032 if (is_hpet_enabled()) {
Bernhard Wallef8f76482008-01-30 13:33:31 +01001033 int err;
1034
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 rtc_int_handler_ptr = hpet_rtc_interrupt;
Bernhard Wallef8f76482008-01-30 13:33:31 +01001036 err = hpet_register_irq_handler(rtc_interrupt);
1037 if (err != 0) {
1038 printk(KERN_WARNING "hpet_register_irq_handler failed "
1039 "in rtc_init().");
1040 return err;
1041 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 } else {
1043 rtc_int_handler_ptr = rtc_interrupt;
1044 }
1045
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001046 if (request_irq(RTC_IRQ, rtc_int_handler_ptr, IRQF_DISABLED,
1047 "rtc", NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 /* Yeah right, seeing as irq 8 doesn't even hit the bus. */
Jan Beulichf3e92d32006-12-13 00:35:04 -08001049 rtc_has_irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 printk(KERN_ERR "rtc: IRQ %d is not free.\n", RTC_IRQ);
Bjorn Helgaas4c06be12007-11-14 16:59:56 -08001051 rtc_release_region();
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001052
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 return -EIO;
1054 }
1055 hpet_rtc_timer_init();
1056
1057#endif
1058
David S. Millercdee99d2007-07-19 13:59:58 -07001059#endif /* CONFIG_SPARC32 vs. others */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060
1061 if (misc_register(&rtc_dev)) {
1062#ifdef RTC_IRQ
1063 free_irq(RTC_IRQ, NULL);
Bernhard Wallef8f76482008-01-30 13:33:31 +01001064 hpet_unregister_irq_handler(rtc_interrupt);
Jan Beulichf3e92d32006-12-13 00:35:04 -08001065 rtc_has_irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066#endif
Bjorn Helgaas4c06be12007-11-14 16:59:56 -08001067 rtc_release_region();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 return -ENODEV;
1069 }
1070
Jan Beulich9cef7792006-12-13 00:35:05 -08001071#ifdef CONFIG_PROC_FS
Denis V. Lunev1b502212008-04-29 01:02:34 -07001072 ent = proc_create("driver/rtc", 0, NULL, &rtc_proc_fops);
1073 if (!ent)
Jan Beulich9cef7792006-12-13 00:35:05 -08001074 printk(KERN_WARNING "rtc: Failed to register with procfs.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
1077#if defined(__alpha__) || defined(__mips__)
1078 rtc_freq = HZ;
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001079
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 /* Each operating system on an Alpha uses its own epoch.
1081 Let's try to guess which one we are using now. */
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001082
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 if (rtc_is_updating() != 0)
Luca Falavigna47f176f2005-06-28 20:44:42 -07001084 msleep(20);
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001085
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 spin_lock_irq(&rtc_lock);
1087 year = CMOS_READ(RTC_YEAR);
1088 ctrl = CMOS_READ(RTC_CONTROL);
1089 spin_unlock_irq(&rtc_lock);
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001090
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1092 BCD_TO_BIN(year); /* This should never happen... */
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001093
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 if (year < 20) {
1095 epoch = 2000;
1096 guess = "SRM (post-2000)";
1097 } else if (year >= 20 && year < 48) {
1098 epoch = 1980;
1099 guess = "ARC console";
1100 } else if (year >= 48 && year < 72) {
1101 epoch = 1952;
1102 guess = "Digital UNIX";
1103#if defined(__mips__)
1104 } else if (year >= 72 && year < 74) {
1105 epoch = 2000;
1106 guess = "Digital DECstation";
1107#else
1108 } else if (year >= 70) {
1109 epoch = 1900;
1110 guess = "Standard PC (1900)";
1111#endif
1112 }
1113 if (guess)
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001114 printk(KERN_INFO "rtc: %s epoch (%lu) detected\n",
1115 guess, epoch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116#endif
1117#ifdef RTC_IRQ
1118 if (rtc_has_irq == 0)
1119 goto no_irq2;
1120
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 spin_lock_irq(&rtc_lock);
1122 rtc_freq = 1024;
1123 if (!hpet_set_periodic_freq(rtc_freq)) {
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001124 /*
1125 * Initialize periodic frequency to CMOS reset default,
1126 * which is 1024Hz
1127 */
1128 CMOS_WRITE(((CMOS_READ(RTC_FREQ_SELECT) & 0xF0) | 0x06),
1129 RTC_FREQ_SELECT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 }
1131 spin_unlock_irq(&rtc_lock);
1132no_irq2:
1133#endif
1134
1135 (void) init_sysctl();
1136
1137 printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n");
1138
1139 return 0;
1140}
1141
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001142static void __exit rtc_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143{
1144 cleanup_sysctl();
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001145 remove_proc_entry("driver/rtc", NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 misc_deregister(&rtc_dev);
1147
David S. Millercdee99d2007-07-19 13:59:58 -07001148#ifdef CONFIG_SPARC32
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 if (rtc_has_irq)
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001150 free_irq(rtc_irq, &rtc_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151#else
Bjorn Helgaas4c06be12007-11-14 16:59:56 -08001152 rtc_release_region();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153#ifdef RTC_IRQ
Bernhard Wallef8f76482008-01-30 13:33:31 +01001154 if (rtc_has_irq) {
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001155 free_irq(RTC_IRQ, NULL);
Bernhard Wallef8f76482008-01-30 13:33:31 +01001156 hpet_unregister_irq_handler(hpet_rtc_interrupt);
1157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158#endif
David S. Millercdee99d2007-07-19 13:59:58 -07001159#endif /* CONFIG_SPARC32 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160}
1161
1162module_init(rtc_init);
1163module_exit(rtc_exit);
1164
1165#ifdef RTC_IRQ
1166/*
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001167 * At IRQ rates >= 4096Hz, an interrupt may get lost altogether.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 * (usually during an IDE disk interrupt, with IRQ unmasking off)
1169 * Since the interrupt handler doesn't get called, the IRQ status
1170 * byte doesn't get read, and the RTC stops generating interrupts.
1171 * A timer is set, and will call this function if/when that happens.
1172 * To get it out of this stalled state, we just read the status.
1173 * At least a jiffy of interrupts (rtc_freq/HZ) will have been lost.
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001174 * (You *really* shouldn't be trying to use a non-realtime system
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 * for something that requires a steady > 1KHz signal anyways.)
1176 */
1177
1178static void rtc_dropped_irq(unsigned long data)
1179{
1180 unsigned long freq;
1181
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001182 spin_lock_irq(&rtc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183
1184 if (hpet_rtc_dropped_irq()) {
1185 spin_unlock_irq(&rtc_lock);
1186 return;
1187 }
1188
1189 /* Just in case someone disabled the timer from behind our back... */
1190 if (rtc_status & RTC_TIMER_ON)
1191 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
1192
1193 rtc_irq_data += ((rtc_freq/HZ)<<8);
1194 rtc_irq_data &= ~0xff;
1195 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0); /* restart */
1196
1197 freq = rtc_freq;
1198
1199 spin_unlock_irq(&rtc_lock);
1200
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001201 if (printk_ratelimit()) {
1202 printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n",
1203 freq);
1204 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205
1206 /* Now we have new data */
1207 wake_up_interruptible(&rtc_wait);
1208
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001209 kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210}
1211#endif
1212
Jan Beulich9cef7792006-12-13 00:35:05 -08001213#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214/*
1215 * Info exported via "/proc/driver/rtc".
1216 */
1217
1218static int rtc_proc_show(struct seq_file *seq, void *v)
1219{
1220#define YN(bit) ((ctrl & bit) ? "yes" : "no")
1221#define NY(bit) ((ctrl & bit) ? "no" : "yes")
1222 struct rtc_time tm;
1223 unsigned char batt, ctrl;
1224 unsigned long freq;
1225
1226 spin_lock_irq(&rtc_lock);
1227 batt = CMOS_READ(RTC_VALID) & RTC_VRT;
1228 ctrl = CMOS_READ(RTC_CONTROL);
1229 freq = rtc_freq;
1230 spin_unlock_irq(&rtc_lock);
1231
1232
1233 rtc_get_rtc_time(&tm);
1234
1235 /*
1236 * There is no way to tell if the luser has the RTC set for local
1237 * time or for Universal Standard Time (GMT). Probably local though.
1238 */
1239 seq_printf(seq,
1240 "rtc_time\t: %02d:%02d:%02d\n"
1241 "rtc_date\t: %04d-%02d-%02d\n"
1242 "rtc_epoch\t: %04lu\n",
1243 tm.tm_hour, tm.tm_min, tm.tm_sec,
1244 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, epoch);
1245
1246 get_rtc_alm_time(&tm);
1247
1248 /*
1249 * We implicitly assume 24hr mode here. Alarm values >= 0xc0 will
1250 * match any value for that particular field. Values that are
1251 * greater than a valid time, but less than 0xc0 shouldn't appear.
1252 */
1253 seq_puts(seq, "alarm\t\t: ");
1254 if (tm.tm_hour <= 24)
1255 seq_printf(seq, "%02d:", tm.tm_hour);
1256 else
1257 seq_puts(seq, "**:");
1258
1259 if (tm.tm_min <= 59)
1260 seq_printf(seq, "%02d:", tm.tm_min);
1261 else
1262 seq_puts(seq, "**:");
1263
1264 if (tm.tm_sec <= 59)
1265 seq_printf(seq, "%02d\n", tm.tm_sec);
1266 else
1267 seq_puts(seq, "**\n");
1268
1269 seq_printf(seq,
1270 "DST_enable\t: %s\n"
1271 "BCD\t\t: %s\n"
1272 "24hr\t\t: %s\n"
1273 "square_wave\t: %s\n"
1274 "alarm_IRQ\t: %s\n"
1275 "update_IRQ\t: %s\n"
1276 "periodic_IRQ\t: %s\n"
1277 "periodic_freq\t: %ld\n"
1278 "batt_status\t: %s\n",
1279 YN(RTC_DST_EN),
1280 NY(RTC_DM_BINARY),
1281 YN(RTC_24H),
1282 YN(RTC_SQWE),
1283 YN(RTC_AIE),
1284 YN(RTC_UIE),
1285 YN(RTC_PIE),
1286 freq,
1287 batt ? "okay" : "dead");
1288
1289 return 0;
1290#undef YN
1291#undef NY
1292}
1293
1294static int rtc_proc_open(struct inode *inode, struct file *file)
1295{
1296 return single_open(file, rtc_proc_show, NULL);
1297}
Jan Beulich9cef7792006-12-13 00:35:05 -08001298#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
1300void rtc_get_rtc_time(struct rtc_time *rtc_tm)
1301{
Ingo Molnar0f749642006-07-12 09:03:10 -07001302 unsigned long uip_watchdog = jiffies, flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 unsigned char ctrl;
1304#ifdef CONFIG_MACH_DECSTATION
1305 unsigned int real_year;
1306#endif
1307
1308 /*
1309 * read RTC once any update in progress is done. The update
Luca Falavigna47f176f2005-06-28 20:44:42 -07001310 * can take just over 2ms. We wait 20ms. There is no need to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
1312 * If you need to know *exactly* when a second has started, enable
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001313 * periodic update complete interrupts, (via ioctl) and then
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 * immediately read /dev/rtc which will block until you get the IRQ.
1315 * Once the read clears, read the RTC time (again via ioctl). Easy.
1316 */
1317
Julia Lawalldca03a52008-04-28 02:11:59 -07001318 while (rtc_is_updating() != 0 &&
1319 time_before(jiffies, uip_watchdog + 2*HZ/100))
Petr Vandrovec403fe5a2005-08-05 15:50:07 +02001320 cpu_relax();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
1322 /*
1323 * Only the values that we read from the RTC are set. We leave
Alan Coxb7599582006-01-11 12:17:32 -08001324 * tm_wday, tm_yday and tm_isdst untouched. Note that while the
1325 * RTC has RTC_DAY_OF_WEEK, we should usually ignore it, as it is
1326 * only updated by the RTC when initially set to a non-zero value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 */
Ingo Molnar0f749642006-07-12 09:03:10 -07001328 spin_lock_irqsave(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS);
1330 rtc_tm->tm_min = CMOS_READ(RTC_MINUTES);
1331 rtc_tm->tm_hour = CMOS_READ(RTC_HOURS);
1332 rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
1333 rtc_tm->tm_mon = CMOS_READ(RTC_MONTH);
1334 rtc_tm->tm_year = CMOS_READ(RTC_YEAR);
Alan Coxb7599582006-01-11 12:17:32 -08001335 /* Only set from 2.6.16 onwards */
1336 rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK);
1337
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338#ifdef CONFIG_MACH_DECSTATION
1339 real_year = CMOS_READ(RTC_DEC_YEAR);
1340#endif
1341 ctrl = CMOS_READ(RTC_CONTROL);
Ingo Molnar0f749642006-07-12 09:03:10 -07001342 spin_unlock_irqrestore(&rtc_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001344 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 BCD_TO_BIN(rtc_tm->tm_sec);
1346 BCD_TO_BIN(rtc_tm->tm_min);
1347 BCD_TO_BIN(rtc_tm->tm_hour);
1348 BCD_TO_BIN(rtc_tm->tm_mday);
1349 BCD_TO_BIN(rtc_tm->tm_mon);
1350 BCD_TO_BIN(rtc_tm->tm_year);
Alan Coxb7599582006-01-11 12:17:32 -08001351 BCD_TO_BIN(rtc_tm->tm_wday);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 }
1353
1354#ifdef CONFIG_MACH_DECSTATION
1355 rtc_tm->tm_year += real_year - 72;
1356#endif
1357
1358 /*
1359 * Account for differences between how the RTC uses the values
1360 * and how they are defined in a struct rtc_time;
1361 */
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001362 rtc_tm->tm_year += epoch - 1900;
1363 if (rtc_tm->tm_year <= 69)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 rtc_tm->tm_year += 100;
1365
1366 rtc_tm->tm_mon--;
1367}
1368
1369static void get_rtc_alm_time(struct rtc_time *alm_tm)
1370{
1371 unsigned char ctrl;
1372
1373 /*
1374 * Only the values that we read from the RTC are set. That
1375 * means only tm_hour, tm_min, and tm_sec.
1376 */
1377 spin_lock_irq(&rtc_lock);
1378 alm_tm->tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
1379 alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM);
1380 alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM);
1381 ctrl = CMOS_READ(RTC_CONTROL);
1382 spin_unlock_irq(&rtc_lock);
1383
Ingo Molnar5fd1fe92008-01-30 13:31:09 +01001384 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 BCD_TO_BIN(alm_tm->tm_sec);
1386 BCD_TO_BIN(alm_tm->tm_min);
1387 BCD_TO_BIN(alm_tm->tm_hour);
1388 }
1389}
1390
1391#ifdef RTC_IRQ
1392/*
1393 * Used to disable/enable interrupts for any one of UIE, AIE, PIE.
1394 * Rumour has it that if you frob the interrupt enable/disable
1395 * bits in RTC_CONTROL, you should read RTC_INTR_FLAGS, to
1396 * ensure you actually start getting interrupts. Probably for
1397 * compatibility with older/broken chipset RTC implementations.
1398 * We also clear out any old irq data after an ioctl() that
1399 * meddles with the interrupt enable/disable bits.
1400 */
1401
Takashi Iwaic3348762005-11-07 11:14:57 +01001402static void mask_rtc_irq_bit_locked(unsigned char bit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403{
1404 unsigned char val;
1405
Takashi Iwaic3348762005-11-07 11:14:57 +01001406 if (hpet_mask_rtc_irq_bit(bit))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 val = CMOS_READ(RTC_CONTROL);
1409 val &= ~bit;
1410 CMOS_WRITE(val, RTC_CONTROL);
1411 CMOS_READ(RTC_INTR_FLAGS);
1412
1413 rtc_irq_data = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414}
1415
Takashi Iwaic3348762005-11-07 11:14:57 +01001416static void set_rtc_irq_bit_locked(unsigned char bit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417{
1418 unsigned char val;
1419
Takashi Iwaic3348762005-11-07 11:14:57 +01001420 if (hpet_set_rtc_irq_bit(bit))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 val = CMOS_READ(RTC_CONTROL);
1423 val |= bit;
1424 CMOS_WRITE(val, RTC_CONTROL);
1425 CMOS_READ(RTC_INTR_FLAGS);
1426
1427 rtc_irq_data = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428}
1429#endif
1430
1431MODULE_AUTHOR("Paul Gortmaker");
1432MODULE_LICENSE("GPL");
1433MODULE_ALIAS_MISCDEV(RTC_MINOR);