2 * EFI Time Services Driver for Linux
4 * Copyright (C) 1999 Hewlett-Packard Co
5 * Copyright (C) 1999 Stephane Eranian <eranian@hpl.hp.com>
7 * Based on skeleton from the drivers/char/rtc.c driver by P. Gortmaker
9 * This code provides an architected & portable interface to the real time
10 * clock by using EFI instead of direct bit fiddling. The functionalities are
11 * quite different from the rtc.c driver. The only way to talk to the device
12 * is by using ioctl(). There is a /proc interface which provides the raw
15 * Please note that we have kept the API as close as possible to the
16 * legacy RTC. The standard /sbin/hwclock program should work normally
17 * when used to get/set the time.
20 * - Locking is required for safe execution of EFI calls with regards
21 * to interrupts and SMP.
23 * TODO (December 1999):
24 * - provide the API to set/get the WakeUp Alarm (different from the
27 * - Add module support
31 #include <linux/smp_lock.h>
32 #include <linux/types.h>
33 #include <linux/errno.h>
34 #include <linux/miscdevice.h>
35 #include <linux/module.h>
36 #include <linux/init.h>
37 #include <linux/rtc.h>
38 #include <linux/proc_fs.h>
39 #include <linux/efi.h>
40 #include <linux/smp_lock.h>
41 #include <linux/uaccess.h>
43 #include <asm/system.h>
45 #define EFI_RTC_VERSION "0.4"
47 #define EFI_ISDST (EFI_TIME_ADJUST_DAYLIGHT|EFI_TIME_IN_DAYLIGHT)
49 * EFI Epoch is 1/1/1998
51 #define EFI_RTC_EPOCH 1998
53 static DEFINE_SPINLOCK(efi_rtc_lock
);
55 static long efi_rtc_ioctl(struct file
*file
, unsigned int cmd
,
58 #define is_leap(year) \
59 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
61 static const unsigned short int __mon_yday
[2][13] =
64 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
66 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
70 * returns day of the year [0-365]
73 compute_yday(efi_time_t
*eft
)
75 /* efi_time_t.month is in the [1-12] so, we need -1 */
76 return __mon_yday
[is_leap(eft
->year
)][eft
->month
-1]+ eft
->day
-1;
79 * returns day of the week [0-6] 0=Sunday
81 * Don't try to provide a year that's before 1998, please !
84 compute_wday(efi_time_t
*eft
)
89 if ( eft
->year
< 1998 ) {
90 printk(KERN_ERR
"efirtc: EFI year < 1998, invalid date\n");
94 for(y
=EFI_RTC_EPOCH
; y
< eft
->year
; y
++ ) {
95 ndays
+= 365 + (is_leap(y
) ? 1 : 0);
97 ndays
+= compute_yday(eft
);
100 * 4=1/1/1998 was a Thursday
102 return (ndays
+ 4) % 7;
106 convert_to_efi_time(struct rtc_time
*wtime
, efi_time_t
*eft
)
109 eft
->year
= wtime
->tm_year
+ 1900;
110 eft
->month
= wtime
->tm_mon
+ 1;
111 eft
->day
= wtime
->tm_mday
;
112 eft
->hour
= wtime
->tm_hour
;
113 eft
->minute
= wtime
->tm_min
;
114 eft
->second
= wtime
->tm_sec
;
116 eft
->daylight
= wtime
->tm_isdst
? EFI_ISDST
: 0;
117 eft
->timezone
= EFI_UNSPECIFIED_TIMEZONE
;
121 convert_from_efi_time(efi_time_t
*eft
, struct rtc_time
*wtime
)
123 memset(wtime
, 0, sizeof(*wtime
));
124 wtime
->tm_sec
= eft
->second
;
125 wtime
->tm_min
= eft
->minute
;
126 wtime
->tm_hour
= eft
->hour
;
127 wtime
->tm_mday
= eft
->day
;
128 wtime
->tm_mon
= eft
->month
- 1;
129 wtime
->tm_year
= eft
->year
- 1900;
131 /* day of the week [0-6], Sunday=0 */
132 wtime
->tm_wday
= compute_wday(eft
);
134 /* day in the year [1-365]*/
135 wtime
->tm_yday
= compute_yday(eft
);
138 switch (eft
->daylight
& EFI_ISDST
) {
142 case EFI_TIME_ADJUST_DAYLIGHT
:
146 wtime
->tm_isdst
= -1;
150 static long efi_rtc_ioctl(struct file
*file
, unsigned int cmd
,
158 struct rtc_time wtime
;
159 struct rtc_wkalrm __user
*ewp
;
160 unsigned char enabled
, pending
;
179 spin_lock_irqsave(&efi_rtc_lock
, flags
);
181 status
= efi
.get_time(&eft
, &cap
);
183 spin_unlock_irqrestore(&efi_rtc_lock
,flags
);
185 if (status
!= EFI_SUCCESS
) {
186 /* should never happen */
187 printk(KERN_ERR
"efitime: can't read time\n");
191 convert_from_efi_time(&eft
, &wtime
);
193 return copy_to_user((void __user
*)arg
, &wtime
,
194 sizeof (struct rtc_time
)) ? - EFAULT
: 0;
198 if (!capable(CAP_SYS_TIME
)) return -EACCES
;
200 if (copy_from_user(&wtime
, (struct rtc_time __user
*)arg
,
201 sizeof(struct rtc_time
)) )
204 convert_to_efi_time(&wtime
, &eft
);
207 spin_lock_irqsave(&efi_rtc_lock
, flags
);
209 status
= efi
.set_time(&eft
);
211 spin_unlock_irqrestore(&efi_rtc_lock
,flags
);
214 return status
== EFI_SUCCESS
? 0 : -EINVAL
;
218 if (!capable(CAP_SYS_TIME
)) return -EACCES
;
220 ewp
= (struct rtc_wkalrm __user
*)arg
;
222 if ( get_user(enabled
, &ewp
->enabled
)
223 || copy_from_user(&wtime
, &ewp
->time
, sizeof(struct rtc_time
)) )
226 convert_to_efi_time(&wtime
, &eft
);
229 spin_lock_irqsave(&efi_rtc_lock
, flags
);
232 * As of EFI 0.92 with the firmware I have on my
233 * machine this call does not seem to work quite
236 status
= efi
.set_wakeup_time((efi_bool_t
)enabled
, &eft
);
238 spin_unlock_irqrestore(&efi_rtc_lock
,flags
);
241 return status
== EFI_SUCCESS
? 0 : -EINVAL
;
246 spin_lock_irqsave(&efi_rtc_lock
, flags
);
248 status
= efi
.get_wakeup_time((efi_bool_t
*)&enabled
, (efi_bool_t
*)&pending
, &eft
);
250 spin_unlock_irqrestore(&efi_rtc_lock
,flags
);
253 if (status
!= EFI_SUCCESS
) return -EINVAL
;
255 ewp
= (struct rtc_wkalrm __user
*)arg
;
257 if ( put_user(enabled
, &ewp
->enabled
)
258 || put_user(pending
, &ewp
->pending
)) return -EFAULT
;
260 convert_from_efi_time(&eft
, &wtime
);
262 return copy_to_user(&ewp
->time
, &wtime
,
263 sizeof(struct rtc_time
)) ? -EFAULT
: 0;
269 * We enforce only one user at a time here with the open/close.
270 * Also clear the previous interrupt data on an open, and clean
271 * up things on a close.
274 static int efi_rtc_open(struct inode
*inode
, struct file
*file
)
277 * nothing special to do here
278 * We do accept multiple open files at the same time as we
279 * synchronize on the per call operation.
285 static int efi_rtc_close(struct inode
*inode
, struct file
*file
)
291 * The various file operations we support.
294 static const struct file_operations efi_rtc_fops
= {
295 .owner
= THIS_MODULE
,
296 .unlocked_ioctl
= efi_rtc_ioctl
,
297 .open
= efi_rtc_open
,
298 .release
= efi_rtc_close
,
301 static struct miscdevice efi_rtc_dev
= {
308 * We export RAW EFI information to /proc/driver/efirtc
311 efi_rtc_get_status(char *buf
)
316 efi_bool_t enabled
, pending
;
319 memset(&eft
, 0, sizeof(eft
));
320 memset(&alm
, 0, sizeof(alm
));
321 memset(&cap
, 0, sizeof(cap
));
323 spin_lock_irqsave(&efi_rtc_lock
, flags
);
325 efi
.get_time(&eft
, &cap
);
326 efi
.get_wakeup_time(&enabled
, &pending
, &alm
);
328 spin_unlock_irqrestore(&efi_rtc_lock
,flags
);
331 "Time : %u:%u:%u.%09u\n"
334 eft
.hour
, eft
.minute
, eft
.second
, eft
.nanosecond
,
335 eft
.year
, eft
.month
, eft
.day
,
338 if (eft
.timezone
== EFI_UNSPECIFIED_TIMEZONE
)
339 p
+= sprintf(p
, "Timezone : unspecified\n");
341 /* XXX fixme: convert to string? */
342 p
+= sprintf(p
, "Timezone : %u\n", eft
.timezone
);
346 "Alarm Time : %u:%u:%u.%09u\n"
347 "Alarm Date : %u-%u-%u\n"
348 "Alarm Daylight : %u\n"
351 alm
.hour
, alm
.minute
, alm
.second
, alm
.nanosecond
,
352 alm
.year
, alm
.month
, alm
.day
,
354 enabled
== 1 ? "yes" : "no",
355 pending
== 1 ? "yes" : "no");
357 if (eft
.timezone
== EFI_UNSPECIFIED_TIMEZONE
)
358 p
+= sprintf(p
, "Timezone : unspecified\n");
360 /* XXX fixme: convert to string? */
361 p
+= sprintf(p
, "Timezone : %u\n", alm
.timezone
);
364 * now prints the capabilities
370 cap
.resolution
, cap
.accuracy
, cap
.sets_to_zero
);
376 efi_rtc_read_proc(char *page
, char **start
, off_t off
,
377 int count
, int *eof
, void *data
)
379 int len
= efi_rtc_get_status(page
);
380 if (len
<= off
+count
) *eof
= 1;
383 if (len
>count
) len
= count
;
392 struct proc_dir_entry
*dir
;
394 printk(KERN_INFO
"EFI Time Services Driver v%s\n", EFI_RTC_VERSION
);
396 ret
= misc_register(&efi_rtc_dev
);
398 printk(KERN_ERR
"efirtc: can't misc_register on minor=%d\n",
403 dir
= create_proc_read_entry ("driver/efirtc", 0, NULL
,
404 efi_rtc_read_proc
, NULL
);
406 printk(KERN_ERR
"efirtc: can't create /proc/driver/efirtc.\n");
407 misc_deregister(&efi_rtc_dev
);
419 module_init(efi_rtc_init
);
420 module_exit(efi_rtc_exit
);
422 MODULE_LICENSE("GPL");