2 * linux/arch/arm/common/rtctime.c
4 * Copyright (C) 2003 Deep Blue Solutions Ltd.
5 * Based on sa1100-rtc.c, Nils Faerber, CIH, Nicolas Pitre.
6 * Based on rtc.c by Paul Gortmaker
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/time.h>
15 #include <linux/rtc.h>
16 #include <linux/poll.h>
17 #include <linux/proc_fs.h>
18 #include <linux/miscdevice.h>
19 #include <linux/spinlock.h>
20 #include <linux/device.h>
23 #include <asm/semaphore.h>
25 static DECLARE_WAIT_QUEUE_HEAD(rtc_wait
);
26 static struct fasync_struct
*rtc_async_queue
;
29 * rtc_lock protects rtc_irq_data
31 static DEFINE_SPINLOCK(rtc_lock
);
32 static unsigned long rtc_irq_data
;
35 * rtc_sem protects rtc_inuse and rtc_ops
37 static DECLARE_MUTEX(rtc_sem
);
38 static unsigned long rtc_inuse
;
39 static struct rtc_ops
*rtc_ops
;
41 #define rtc_epoch 1900UL
43 static const unsigned char days_in_month
[] = {
44 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
47 #define LEAPS_THRU_END_OF(y) ((y)/4 - (y)/100 + (y)/400)
48 #define LEAP_YEAR(year) ((!(year % 4) && (year % 100)) || !(year % 400))
50 static int month_days(unsigned int month
, unsigned int year
)
52 return days_in_month
[month
] + (LEAP_YEAR(year
) && month
== 1);
56 * Convert seconds since 01-01-1970 00:00:00 to Gregorian date.
58 void rtc_time_to_tm(unsigned long time
, struct rtc_time
*tm
)
60 int days
, month
, year
;
65 tm
->tm_wday
= (days
+ 4) % 7;
67 year
= 1970 + days
/ 365;
68 days
-= (year
- 1970) * 365
69 + LEAPS_THRU_END_OF(year
- 1)
70 - LEAPS_THRU_END_OF(1970 - 1);
73 days
+= 365 + LEAP_YEAR(year
);
75 tm
->tm_year
= year
- 1900;
76 tm
->tm_yday
= days
+ 1;
78 for (month
= 0; month
< 11; month
++) {
81 newdays
= days
- month_days(month
, year
);
87 tm
->tm_mday
= days
+ 1;
89 tm
->tm_hour
= time
/ 3600;
90 time
-= tm
->tm_hour
* 3600;
91 tm
->tm_min
= time
/ 60;
92 tm
->tm_sec
= time
- tm
->tm_min
* 60;
94 EXPORT_SYMBOL(rtc_time_to_tm
);
97 * Does the rtc_time represent a valid date/time?
99 int rtc_valid_tm(struct rtc_time
*tm
)
101 if (tm
->tm_year
< 70 ||
104 tm
->tm_mday
> month_days(tm
->tm_mon
, tm
->tm_year
+ 1900) ||
112 EXPORT_SYMBOL(rtc_valid_tm
);
115 * Convert Gregorian date to seconds since 01-01-1970 00:00:00.
117 int rtc_tm_to_time(struct rtc_time
*tm
, unsigned long *time
)
119 *time
= mktime(tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
120 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
124 EXPORT_SYMBOL(rtc_tm_to_time
);
127 * Calculate the next alarm time given the requested alarm time mask
128 * and the current time.
130 * FIXME: for now, we just copy the alarm time because we're lazy (and
131 * is therefore buggy - setting a 10am alarm at 8pm will not result in
132 * the alarm triggering.)
134 void rtc_next_alarm_time(struct rtc_time
*next
, struct rtc_time
*now
, struct rtc_time
*alrm
)
136 next
->tm_year
= now
->tm_year
;
137 next
->tm_mon
= now
->tm_mon
;
138 next
->tm_mday
= now
->tm_mday
;
139 next
->tm_hour
= alrm
->tm_hour
;
140 next
->tm_min
= alrm
->tm_min
;
141 next
->tm_sec
= alrm
->tm_sec
;
144 static inline void rtc_read_time(struct rtc_ops
*ops
, struct rtc_time
*tm
)
146 memset(tm
, 0, sizeof(struct rtc_time
));
150 static inline int rtc_set_time(struct rtc_ops
*ops
, struct rtc_time
*tm
)
154 ret
= rtc_valid_tm(tm
);
156 ret
= ops
->set_time(tm
);
161 static inline int rtc_read_alarm(struct rtc_ops
*ops
, struct rtc_wkalrm
*alrm
)
164 if (ops
->read_alarm
) {
165 memset(alrm
, 0, sizeof(struct rtc_wkalrm
));
166 ops
->read_alarm(alrm
);
172 static inline int rtc_set_alarm(struct rtc_ops
*ops
, struct rtc_wkalrm
*alrm
)
176 ret
= ops
->set_alarm(alrm
);
180 void rtc_update(unsigned long num
, unsigned long events
)
182 spin_lock(&rtc_lock
);
183 rtc_irq_data
= (rtc_irq_data
+ (num
<< 8)) | events
;
184 spin_unlock(&rtc_lock
);
186 wake_up_interruptible(&rtc_wait
);
187 kill_fasync(&rtc_async_queue
, SIGIO
, POLL_IN
);
189 EXPORT_SYMBOL(rtc_update
);
193 rtc_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
195 DECLARE_WAITQUEUE(wait
, current
);
199 if (count
< sizeof(unsigned long))
202 add_wait_queue(&rtc_wait
, &wait
);
204 __set_current_state(TASK_INTERRUPTIBLE
);
206 spin_lock_irq(&rtc_lock
);
209 spin_unlock_irq(&rtc_lock
);
215 if (file
->f_flags
& O_NONBLOCK
) {
219 if (signal_pending(current
)) {
225 set_current_state(TASK_RUNNING
);
226 remove_wait_queue(&rtc_wait
, &wait
);
229 ret
= put_user(data
, (unsigned long __user
*)buf
);
231 ret
= sizeof(unsigned long);
236 static unsigned int rtc_poll(struct file
*file
, poll_table
*wait
)
240 poll_wait(file
, &rtc_wait
, wait
);
242 spin_lock_irq(&rtc_lock
);
244 spin_unlock_irq(&rtc_lock
);
246 return data
!= 0 ? POLLIN
| POLLRDNORM
: 0;
249 static int rtc_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
,
252 struct rtc_ops
*ops
= file
->private_data
;
254 struct rtc_wkalrm alrm
;
255 void __user
*uarg
= (void __user
*)arg
;
260 ret
= rtc_read_alarm(ops
, &alrm
);
263 ret
= copy_to_user(uarg
, &alrm
.time
, sizeof(tm
));
269 ret
= copy_from_user(&alrm
.time
, uarg
, sizeof(tm
));
276 alrm
.time
.tm_mday
= -1;
277 alrm
.time
.tm_mon
= -1;
278 alrm
.time
.tm_year
= -1;
279 alrm
.time
.tm_wday
= -1;
280 alrm
.time
.tm_yday
= -1;
281 alrm
.time
.tm_isdst
= -1;
282 ret
= rtc_set_alarm(ops
, &alrm
);
286 rtc_read_time(ops
, &tm
);
287 ret
= copy_to_user(uarg
, &tm
, sizeof(tm
));
293 if (!capable(CAP_SYS_TIME
)) {
297 ret
= copy_from_user(&tm
, uarg
, sizeof(tm
));
302 ret
= rtc_set_time(ops
, &tm
);
308 * There were no RTC clocks before 1900.
314 if (!capable(CAP_SYS_TIME
)) {
324 ret
= put_user(rtc_epoch
, (unsigned long __user
*)uarg
);
328 ret
= copy_from_user(&alrm
, uarg
, sizeof(alrm
));
333 ret
= rtc_set_alarm(ops
, &alrm
);
337 ret
= rtc_read_alarm(ops
, &alrm
);
340 ret
= copy_to_user(uarg
, &alrm
, sizeof(alrm
));
347 ret
= ops
->ioctl(cmd
, arg
);
353 static int rtc_open(struct inode
*inode
, struct file
*file
)
361 } else if (!rtc_ops
|| !try_module_get(rtc_ops
->owner
)) {
364 file
->private_data
= rtc_ops
;
366 ret
= rtc_ops
->open
? rtc_ops
->open() : 0;
368 spin_lock_irq(&rtc_lock
);
370 spin_unlock_irq(&rtc_lock
);
380 static int rtc_release(struct inode
*inode
, struct file
*file
)
382 struct rtc_ops
*ops
= file
->private_data
;
387 spin_lock_irq(&rtc_lock
);
389 spin_unlock_irq(&rtc_lock
);
391 module_put(rtc_ops
->owner
);
397 static int rtc_fasync(int fd
, struct file
*file
, int on
)
399 return fasync_helper(fd
, file
, on
, &rtc_async_queue
);
402 static struct file_operations rtc_fops
= {
403 .owner
= THIS_MODULE
,
409 .release
= rtc_release
,
410 .fasync
= rtc_fasync
,
413 static struct miscdevice rtc_miscdev
= {
420 static int rtc_read_proc(char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
422 struct rtc_ops
*ops
= data
;
423 struct rtc_wkalrm alrm
;
427 rtc_read_time(ops
, &tm
);
430 "rtc_time\t: %02d:%02d:%02d\n"
431 "rtc_date\t: %04d-%02d-%02d\n"
432 "rtc_epoch\t: %04lu\n",
433 tm
.tm_hour
, tm
.tm_min
, tm
.tm_sec
,
434 tm
.tm_year
+ 1900, tm
.tm_mon
+ 1, tm
.tm_mday
,
437 if (rtc_read_alarm(ops
, &alrm
) == 0) {
438 p
+= sprintf(p
, "alrm_time\t: ");
439 if ((unsigned int)alrm
.time
.tm_hour
<= 24)
440 p
+= sprintf(p
, "%02d:", alrm
.time
.tm_hour
);
442 p
+= sprintf(p
, "**:");
443 if ((unsigned int)alrm
.time
.tm_min
<= 59)
444 p
+= sprintf(p
, "%02d:", alrm
.time
.tm_min
);
446 p
+= sprintf(p
, "**:");
447 if ((unsigned int)alrm
.time
.tm_sec
<= 59)
448 p
+= sprintf(p
, "%02d\n", alrm
.time
.tm_sec
);
450 p
+= sprintf(p
, "**\n");
452 p
+= sprintf(p
, "alrm_date\t: ");
453 if ((unsigned int)alrm
.time
.tm_year
<= 200)
454 p
+= sprintf(p
, "%04d-", alrm
.time
.tm_year
+ 1900);
456 p
+= sprintf(p
, "****-");
457 if ((unsigned int)alrm
.time
.tm_mon
<= 11)
458 p
+= sprintf(p
, "%02d-", alrm
.time
.tm_mon
+ 1);
460 p
+= sprintf(p
, "**-");
461 if ((unsigned int)alrm
.time
.tm_mday
<= 31)
462 p
+= sprintf(p
, "%02d\n", alrm
.time
.tm_mday
);
464 p
+= sprintf(p
, "**\n");
465 p
+= sprintf(p
, "alrm_wakeup\t: %s\n",
466 alrm
.enabled
? "yes" : "no");
467 p
+= sprintf(p
, "alrm_pending\t: %s\n",
468 alrm
.pending
? "yes" : "no");
477 int register_rtc(struct rtc_ops
*ops
)
482 if (rtc_ops
== NULL
) {
485 ret
= misc_register(&rtc_miscdev
);
487 create_proc_read_entry("driver/rtc", 0, NULL
,
494 EXPORT_SYMBOL(register_rtc
);
496 void unregister_rtc(struct rtc_ops
*rtc
)
499 if (rtc
== rtc_ops
) {
500 remove_proc_entry("driver/rtc", NULL
);
501 misc_deregister(&rtc_miscdev
);
506 EXPORT_SYMBOL(unregister_rtc
);