1/* 2 * EFI Time Services Driver for Linux 3 * 4 * Copyright (C) 1999 Hewlett-Packard Co 5 * Copyright (C) 1999 Stephane Eranian <eranian@hpl.hp.com> 6 * 7 * Based on skeleton from the drivers/char/rtc.c driver by P. Gortmaker 8 * 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 13 * information. 14 * 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. 18 * 19 * NOTES: 20 * - Locking is required for safe execution of EFI calls with regards 21 * to interrupts and SMP. 22 * 23 * TODO (December 1999): 24 * - provide the API to set/get the WakeUp Alarm (different from the 25 * rtc.c alarm). 26 * - SMP testing 27 * - Add module support 28 */ 29 30#include <linux/types.h> 31#include <linux/errno.h> 32#include <linux/miscdevice.h> 33#include <linux/module.h> 34#include <linux/init.h> 35#include <linux/rtc.h> 36#include <linux/proc_fs.h> 37#include <linux/efi.h> 38#include <linux/uaccess.h> 39 40#include <asm/system.h> 41 42#define EFI_RTC_VERSION "0.4" 43 44#define EFI_ISDST (EFI_TIME_ADJUST_DAYLIGHT|EFI_TIME_IN_DAYLIGHT) 45/* 46 * EFI Epoch is 1/1/1998 47 */ 48#define EFI_RTC_EPOCH 1998 49 50static DEFINE_SPINLOCK(efi_rtc_lock); 51 52static long efi_rtc_ioctl(struct file *file, unsigned int cmd, 53 unsigned long arg); 54 55#define is_leap(year) \ 56 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0)) 57 58static const unsigned short int __mon_yday[2][13] = 59{ 60 /* Normal years. */ 61 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 }, 62 /* Leap years. */ 63 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 } 64}; 65 66/* 67 * returns day of the year [0-365] 68 */ 69static inline int 70compute_yday(efi_time_t *eft) 71{ 72 /* efi_time_t.month is in the [1-12] so, we need -1 */ 73 return __mon_yday[is_leap(eft->year)][eft->month-1]+ eft->day -1; 74} 75/* 76 * returns day of the week [0-6] 0=Sunday 77 * 78 * Don't try to provide a year that's before 1998, please ! 79 */ 80static int 81compute_wday(efi_time_t *eft) 82{ 83 int y; 84 int ndays = 0; 85 86 if ( eft->year < 1998 ) { 87 printk(KERN_ERR "efirtc: EFI year < 1998, invalid date\n"); 88 return -1; 89 } 90 91 for(y=EFI_RTC_EPOCH; y < eft->year; y++ ) { 92 ndays += 365 + (is_leap(y) ? 1 : 0); 93 } 94 ndays += compute_yday(eft); 95 96 /* 97 * 4=1/1/1998 was a Thursday 98 */ 99 return (ndays + 4) % 7; 100} 101 102static void 103convert_to_efi_time(struct rtc_time *wtime, efi_time_t *eft) 104{ 105 106 eft->year = wtime->tm_year + 1900; 107 eft->month = wtime->tm_mon + 1; 108 eft->day = wtime->tm_mday; 109 eft->hour = wtime->tm_hour; 110 eft->minute = wtime->tm_min; 111 eft->second = wtime->tm_sec; 112 eft->nanosecond = 0; 113 eft->daylight = wtime->tm_isdst ? EFI_ISDST: 0; 114 eft->timezone = EFI_UNSPECIFIED_TIMEZONE; 115} 116 117static void 118convert_from_efi_time(efi_time_t *eft, struct rtc_time *wtime) 119{ 120 memset(wtime, 0, sizeof(*wtime)); 121 wtime->tm_sec = eft->second; 122 wtime->tm_min = eft->minute; 123 wtime->tm_hour = eft->hour; 124 wtime->tm_mday = eft->day; 125 wtime->tm_mon = eft->month - 1; 126 wtime->tm_year = eft->year - 1900; 127 128 /* day of the week [0-6], Sunday=0 */ 129 wtime->tm_wday = compute_wday(eft); 130 131 /* day in the year [1-365]*/ 132 wtime->tm_yday = compute_yday(eft); 133 134 135 switch (eft->daylight & EFI_ISDST) { 136 case EFI_ISDST: 137 wtime->tm_isdst = 1; 138 break; 139 case EFI_TIME_ADJUST_DAYLIGHT: 140 wtime->tm_isdst = 0; 141 break; 142 default: 143 wtime->tm_isdst = -1; 144 } 145} 146 147static long efi_rtc_ioctl(struct file *file, unsigned int cmd, 148 unsigned long arg) 149{ 150 151 efi_status_t status; 152 unsigned long flags; 153 efi_time_t eft; 154 efi_time_cap_t cap; 155 struct rtc_time wtime; 156 struct rtc_wkalrm __user *ewp; 157 unsigned char enabled, pending; 158 159 switch (cmd) { 160 case RTC_UIE_ON: 161 case RTC_UIE_OFF: 162 case RTC_PIE_ON: 163 case RTC_PIE_OFF: 164 case RTC_AIE_ON: 165 case RTC_AIE_OFF: 166 case RTC_ALM_SET: 167 case RTC_ALM_READ: 168 case RTC_IRQP_READ: 169 case RTC_IRQP_SET: 170 case RTC_EPOCH_READ: 171 case RTC_EPOCH_SET: 172 return -EINVAL; 173 174 case RTC_RD_TIME: 175 spin_lock_irqsave(&efi_rtc_lock, flags); 176 177 status = efi.get_time(&eft, &cap); 178 179 spin_unlock_irqrestore(&efi_rtc_lock,flags); 180 181 if (status != EFI_SUCCESS) { 182 /* should never happen */ 183 printk(KERN_ERR "efitime: can't read time\n"); 184 return -EINVAL; 185 } 186 187 convert_from_efi_time(&eft, &wtime); 188 189 return copy_to_user((void __user *)arg, &wtime, 190 sizeof (struct rtc_time)) ? - EFAULT : 0; 191 192 case RTC_SET_TIME: 193 194 if (!capable(CAP_SYS_TIME)) return -EACCES; 195 196 if (copy_from_user(&wtime, (struct rtc_time __user *)arg, 197 sizeof(struct rtc_time)) ) 198 return -EFAULT; 199 200 convert_to_efi_time(&wtime, &eft); 201 202 spin_lock_irqsave(&efi_rtc_lock, flags); 203 204 status = efi.set_time(&eft); 205 206 spin_unlock_irqrestore(&efi_rtc_lock,flags); 207 208 return status == EFI_SUCCESS ? 0 : -EINVAL; 209 210 case RTC_WKALM_SET: 211 212 if (!capable(CAP_SYS_TIME)) return -EACCES; 213 214 ewp = (struct rtc_wkalrm __user *)arg; 215 216 if ( get_user(enabled, &ewp->enabled) 217 || copy_from_user(&wtime, &ewp->time, sizeof(struct rtc_time)) ) 218 return -EFAULT; 219 220 convert_to_efi_time(&wtime, &eft); 221 222 spin_lock_irqsave(&efi_rtc_lock, flags); 223 status = efi.set_wakeup_time((efi_bool_t)enabled, &eft); 224 225 spin_unlock_irqrestore(&efi_rtc_lock,flags); 226 227 return status == EFI_SUCCESS ? 0 : -EINVAL; 228 229 case RTC_WKALM_RD: 230 231 spin_lock_irqsave(&efi_rtc_lock, flags); 232 233 status = efi.get_wakeup_time((efi_bool_t *)&enabled, (efi_bool_t *)&pending, &eft); 234 235 spin_unlock_irqrestore(&efi_rtc_lock,flags); 236 237 if (status != EFI_SUCCESS) return -EINVAL; 238 239 ewp = (struct rtc_wkalrm __user *)arg; 240 241 if ( put_user(enabled, &ewp->enabled) 242 || put_user(pending, &ewp->pending)) return -EFAULT; 243 244 convert_from_efi_time(&eft, &wtime); 245 246 return copy_to_user(&ewp->time, &wtime, 247 sizeof(struct rtc_time)) ? -EFAULT : 0; 248 } 249 return -ENOTTY; 250} 251 252/* 253 * We enforce only one user at a time here with the open/close. 254 * Also clear the previous interrupt data on an open, and clean 255 * up things on a close. 256 */ 257 258static int efi_rtc_open(struct inode *inode, struct file *file) 259{ 260 /* 261 * nothing special to do here 262 * We do accept multiple open files at the same time as we 263 * synchronize on the per call operation. 264 */ 265 return 0; 266} 267 268static int efi_rtc_close(struct inode *inode, struct file *file) 269{ 270 return 0; 271} 272 273/* 274 * The various file operations we support. 275 */ 276 277static const struct file_operations efi_rtc_fops = { 278 .owner = THIS_MODULE, 279 .unlocked_ioctl = efi_rtc_ioctl, 280 .open = efi_rtc_open, 281 .release = efi_rtc_close, 282 .llseek = no_llseek, 283}; 284 285static struct miscdevice efi_rtc_dev= { 286 EFI_RTC_MINOR, 287 "efirtc", 288 &efi_rtc_fops 289}; 290 291/* 292 * We export RAW EFI information to /proc/driver/efirtc 293 */ 294static int 295efi_rtc_get_status(char *buf) 296{ 297 efi_time_t eft, alm; 298 efi_time_cap_t cap; 299 char *p = buf; 300 efi_bool_t enabled, pending; 301 unsigned long flags; 302 303 memset(&eft, 0, sizeof(eft)); 304 memset(&alm, 0, sizeof(alm)); 305 memset(&cap, 0, sizeof(cap)); 306 307 spin_lock_irqsave(&efi_rtc_lock, flags); 308 309 efi.get_time(&eft, &cap); 310 efi.get_wakeup_time(&enabled, &pending, &alm); 311 312 spin_unlock_irqrestore(&efi_rtc_lock,flags); 313 314 p += sprintf(p, 315 "Time : %u:%u:%u.%09u\n" 316 "Date : %u-%u-%u\n" 317 "Daylight : %u\n", 318 eft.hour, eft.minute, eft.second, eft.nanosecond, 319 eft.year, eft.month, eft.day, 320 eft.daylight); 321 322 if (eft.timezone == EFI_UNSPECIFIED_TIMEZONE) 323 p += sprintf(p, "Timezone : unspecified\n"); 324 else 325 p += sprintf(p, "Timezone : %u\n", eft.timezone); 326 327 328 p += sprintf(p, 329 "Alarm Time : %u:%u:%u.%09u\n" 330 "Alarm Date : %u-%u-%u\n" 331 "Alarm Daylight : %u\n" 332 "Enabled : %s\n" 333 "Pending : %s\n", 334 alm.hour, alm.minute, alm.second, alm.nanosecond, 335 alm.year, alm.month, alm.day, 336 alm.daylight, 337 enabled == 1 ? "yes" : "no", 338 pending == 1 ? "yes" : "no"); 339 340 if (eft.timezone == EFI_UNSPECIFIED_TIMEZONE) 341 p += sprintf(p, "Timezone : unspecified\n"); 342 else 343 p += sprintf(p, "Timezone : %u\n", alm.timezone); 344 345 /* 346 * now prints the capabilities 347 */ 348 p += sprintf(p, 349 "Resolution : %u\n" 350 "Accuracy : %u\n" 351 "SetstoZero : %u\n", 352 cap.resolution, cap.accuracy, cap.sets_to_zero); 353 354 return p - buf; 355} 356 357static int 358efi_rtc_read_proc(char *page, char **start, off_t off, 359 int count, int *eof, void *data) 360{ 361 int len = efi_rtc_get_status(page); 362 if (len <= off+count) *eof = 1; 363 *start = page + off; 364 len -= off; 365 if (len>count) len = count; 366 if (len<0) len = 0; 367 return len; 368} 369 370static int __init 371efi_rtc_init(void) 372{ 373 int ret; 374 struct proc_dir_entry *dir; 375 376 printk(KERN_INFO "EFI Time Services Driver v%s\n", EFI_RTC_VERSION); 377 378 ret = misc_register(&efi_rtc_dev); 379 if (ret) { 380 printk(KERN_ERR "efirtc: can't misc_register on minor=%d\n", 381 EFI_RTC_MINOR); 382 return ret; 383 } 384 385 dir = create_proc_read_entry ("driver/efirtc", 0, NULL, 386 efi_rtc_read_proc, NULL); 387 if (dir == NULL) { 388 printk(KERN_ERR "efirtc: can't create /proc/driver/efirtc.\n"); 389 misc_deregister(&efi_rtc_dev); 390 return -1; 391 } 392 return 0; 393} 394 395static void __exit 396efi_rtc_exit(void) 397{ 398 /* not yet used */ 399} 400 401module_init(efi_rtc_init); 402module_exit(efi_rtc_exit); 403 404MODULE_LICENSE("GPL"); 405