rtc.c revision b7599587faea9403edf4d7f74e80b3c9ea217930
1/* 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 38 * 1.10 Paul Barton-Davis: add support for async I/O 39 * 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. 44 * 1.11 Takashi Iwai: Kernel access functions 45 * 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 49 * 1.12ac Alan Cox: Allow read access to the day of week register 50 */ 51 52#define RTC_VERSION "1.12ac" 53 54#define RTC_IO_EXTENT 0x8 55 56/* 57 * Note that *all* calls to CMOS_READ and CMOS_WRITE are done with 58 * interrupts disabled. Due to the index-port/data-port (0x70/0x71) 59 * design of the RTC, we don't want two different things trying to 60 * get to it at once. (e.g. the periodic 11 min sync from time.c vs. 61 * this driver.) 62 */ 63 64#include <linux/config.h> 65#include <linux/interrupt.h> 66#include <linux/module.h> 67#include <linux/kernel.h> 68#include <linux/types.h> 69#include <linux/miscdevice.h> 70#include <linux/ioport.h> 71#include <linux/fcntl.h> 72#include <linux/mc146818rtc.h> 73#include <linux/init.h> 74#include <linux/poll.h> 75#include <linux/proc_fs.h> 76#include <linux/seq_file.h> 77#include <linux/spinlock.h> 78#include <linux/sysctl.h> 79#include <linux/wait.h> 80#include <linux/bcd.h> 81#include <linux/delay.h> 82 83#include <asm/current.h> 84#include <asm/uaccess.h> 85#include <asm/system.h> 86 87#if defined(__i386__) 88#include <asm/hpet.h> 89#endif 90 91#ifdef __sparc__ 92#include <linux/pci.h> 93#include <asm/ebus.h> 94#ifdef __sparc_v9__ 95#include <asm/isa.h> 96#endif 97 98static unsigned long rtc_port; 99static int rtc_irq = PCI_IRQ_NONE; 100#endif 101 102#ifdef CONFIG_HPET_RTC_IRQ 103#undef RTC_IRQ 104#endif 105 106#ifdef RTC_IRQ 107static int rtc_has_irq = 1; 108#endif 109 110#ifndef CONFIG_HPET_EMULATE_RTC 111#define is_hpet_enabled() 0 112#define hpet_set_alarm_time(hrs, min, sec) 0 113#define hpet_set_periodic_freq(arg) 0 114#define hpet_mask_rtc_irq_bit(arg) 0 115#define hpet_set_rtc_irq_bit(arg) 0 116#define hpet_rtc_timer_init() do { } while (0) 117#define hpet_rtc_dropped_irq() 0 118static inline irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs) {return 0;} 119#else 120extern irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs); 121#endif 122 123/* 124 * We sponge a minor off of the misc major. No need slurping 125 * up another valuable major dev number for this. If you add 126 * an ioctl, make sure you don't conflict with SPARC's RTC 127 * ioctls. 128 */ 129 130static struct fasync_struct *rtc_async_queue; 131 132static DECLARE_WAIT_QUEUE_HEAD(rtc_wait); 133 134#ifdef RTC_IRQ 135static struct timer_list rtc_irq_timer; 136#endif 137 138static ssize_t rtc_read(struct file *file, char __user *buf, 139 size_t count, loff_t *ppos); 140 141static int rtc_ioctl(struct inode *inode, struct file *file, 142 unsigned int cmd, unsigned long arg); 143 144#ifdef RTC_IRQ 145static unsigned int rtc_poll(struct file *file, poll_table *wait); 146#endif 147 148static void get_rtc_alm_time (struct rtc_time *alm_tm); 149#ifdef RTC_IRQ 150static void rtc_dropped_irq(unsigned long data); 151 152static void set_rtc_irq_bit_locked(unsigned char bit); 153static void mask_rtc_irq_bit_locked(unsigned char bit); 154 155static inline void set_rtc_irq_bit(unsigned char bit) 156{ 157 spin_lock_irq(&rtc_lock); 158 set_rtc_irq_bit_locked(bit); 159 spin_unlock_irq(&rtc_lock); 160} 161 162static void mask_rtc_irq_bit(unsigned char bit) 163{ 164 spin_lock_irq(&rtc_lock); 165 mask_rtc_irq_bit_locked(bit); 166 spin_unlock_irq(&rtc_lock); 167} 168#endif 169 170static int rtc_proc_open(struct inode *inode, struct file *file); 171 172/* 173 * Bits in rtc_status. (6 bits of room for future expansion) 174 */ 175 176#define RTC_IS_OPEN 0x01 /* means /dev/rtc is in use */ 177#define RTC_TIMER_ON 0x02 /* missed irq timer active */ 178 179/* 180 * rtc_status is never changed by rtc_interrupt, and ioctl/open/close is 181 * protected by the big kernel lock. However, ioctl can still disable the timer 182 * in rtc_status and then with del_timer after the interrupt has read 183 * rtc_status but before mod_timer is called, which would then reenable the 184 * timer (but you would need to have an awful timing before you'd trip on it) 185 */ 186static unsigned long rtc_status = 0; /* bitmapped status byte. */ 187static unsigned long rtc_freq = 0; /* Current periodic IRQ rate */ 188static unsigned long rtc_irq_data = 0; /* our output to the world */ 189static unsigned long rtc_max_user_freq = 64; /* > this, need CAP_SYS_RESOURCE */ 190 191#ifdef RTC_IRQ 192/* 193 * rtc_task_lock nests inside rtc_lock. 194 */ 195static DEFINE_SPINLOCK(rtc_task_lock); 196static rtc_task_t *rtc_callback = NULL; 197#endif 198 199/* 200 * If this driver ever becomes modularised, it will be really nice 201 * to make the epoch retain its value across module reload... 202 */ 203 204static unsigned long epoch = 1900; /* year corresponding to 0x00 */ 205 206static const unsigned char days_in_mo[] = 207{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; 208 209/* 210 * Returns true if a clock update is in progress 211 */ 212static inline unsigned char rtc_is_updating(void) 213{ 214 unsigned char uip; 215 216 spin_lock_irq(&rtc_lock); 217 uip = (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP); 218 spin_unlock_irq(&rtc_lock); 219 return uip; 220} 221 222#ifdef RTC_IRQ 223/* 224 * A very tiny interrupt handler. It runs with SA_INTERRUPT set, 225 * but there is possibility of conflicting with the set_rtc_mmss() 226 * call (the rtc irq and the timer irq can easily run at the same 227 * time in two different CPUs). So we need to serialize 228 * accesses to the chip with the rtc_lock spinlock that each 229 * architecture should implement in the timer code. 230 * (See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.) 231 */ 232 233irqreturn_t rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs) 234{ 235 /* 236 * Can be an alarm interrupt, update complete interrupt, 237 * or a periodic interrupt. We store the status in the 238 * low byte and the number of interrupts received since 239 * the last read in the remainder of rtc_irq_data. 240 */ 241 242 spin_lock (&rtc_lock); 243 rtc_irq_data += 0x100; 244 rtc_irq_data &= ~0xff; 245 if (is_hpet_enabled()) { 246 /* 247 * In this case it is HPET RTC interrupt handler 248 * calling us, with the interrupt information 249 * passed as arg1, instead of irq. 250 */ 251 rtc_irq_data |= (unsigned long)irq & 0xF0; 252 } else { 253 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0); 254 } 255 256 if (rtc_status & RTC_TIMER_ON) 257 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100); 258 259 spin_unlock (&rtc_lock); 260 261 /* Now do the rest of the actions */ 262 spin_lock(&rtc_task_lock); 263 if (rtc_callback) 264 rtc_callback->func(rtc_callback->private_data); 265 spin_unlock(&rtc_task_lock); 266 wake_up_interruptible(&rtc_wait); 267 268 kill_fasync (&rtc_async_queue, SIGIO, POLL_IN); 269 270 return IRQ_HANDLED; 271} 272#endif 273 274/* 275 * sysctl-tuning infrastructure. 276 */ 277static ctl_table rtc_table[] = { 278 { 279 .ctl_name = 1, 280 .procname = "max-user-freq", 281 .data = &rtc_max_user_freq, 282 .maxlen = sizeof(int), 283 .mode = 0644, 284 .proc_handler = &proc_dointvec, 285 }, 286 { .ctl_name = 0 } 287}; 288 289static ctl_table rtc_root[] = { 290 { 291 .ctl_name = 1, 292 .procname = "rtc", 293 .maxlen = 0, 294 .mode = 0555, 295 .child = rtc_table, 296 }, 297 { .ctl_name = 0 } 298}; 299 300static ctl_table dev_root[] = { 301 { 302 .ctl_name = CTL_DEV, 303 .procname = "dev", 304 .maxlen = 0, 305 .mode = 0555, 306 .child = rtc_root, 307 }, 308 { .ctl_name = 0 } 309}; 310 311static struct ctl_table_header *sysctl_header; 312 313static int __init init_sysctl(void) 314{ 315 sysctl_header = register_sysctl_table(dev_root, 0); 316 return 0; 317} 318 319static void __exit cleanup_sysctl(void) 320{ 321 unregister_sysctl_table(sysctl_header); 322} 323 324/* 325 * Now all the various file operations that we export. 326 */ 327 328static ssize_t rtc_read(struct file *file, char __user *buf, 329 size_t count, loff_t *ppos) 330{ 331#ifndef RTC_IRQ 332 return -EIO; 333#else 334 DECLARE_WAITQUEUE(wait, current); 335 unsigned long data; 336 ssize_t retval; 337 338 if (rtc_has_irq == 0) 339 return -EIO; 340 341 if (count < sizeof(unsigned)) 342 return -EINVAL; 343 344 add_wait_queue(&rtc_wait, &wait); 345 346 do { 347 /* First make it right. Then make it fast. Putting this whole 348 * block within the parentheses of a while would be too 349 * confusing. And no, xchg() is not the answer. */ 350 351 __set_current_state(TASK_INTERRUPTIBLE); 352 353 spin_lock_irq (&rtc_lock); 354 data = rtc_irq_data; 355 rtc_irq_data = 0; 356 spin_unlock_irq (&rtc_lock); 357 358 if (data != 0) 359 break; 360 361 if (file->f_flags & O_NONBLOCK) { 362 retval = -EAGAIN; 363 goto out; 364 } 365 if (signal_pending(current)) { 366 retval = -ERESTARTSYS; 367 goto out; 368 } 369 schedule(); 370 } while (1); 371 372 if (count < sizeof(unsigned long)) 373 retval = put_user(data, (unsigned int __user *)buf) ?: sizeof(int); 374 else 375 retval = put_user(data, (unsigned long __user *)buf) ?: sizeof(long); 376 out: 377 current->state = TASK_RUNNING; 378 remove_wait_queue(&rtc_wait, &wait); 379 380 return retval; 381#endif 382} 383 384static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel) 385{ 386 struct rtc_time wtime; 387 388#ifdef RTC_IRQ 389 if (rtc_has_irq == 0) { 390 switch (cmd) { 391 case RTC_AIE_OFF: 392 case RTC_AIE_ON: 393 case RTC_PIE_OFF: 394 case RTC_PIE_ON: 395 case RTC_UIE_OFF: 396 case RTC_UIE_ON: 397 case RTC_IRQP_READ: 398 case RTC_IRQP_SET: 399 return -EINVAL; 400 }; 401 } 402#endif 403 404 switch (cmd) { 405#ifdef RTC_IRQ 406 case RTC_AIE_OFF: /* Mask alarm int. enab. bit */ 407 { 408 mask_rtc_irq_bit(RTC_AIE); 409 return 0; 410 } 411 case RTC_AIE_ON: /* Allow alarm interrupts. */ 412 { 413 set_rtc_irq_bit(RTC_AIE); 414 return 0; 415 } 416 case RTC_PIE_OFF: /* Mask periodic int. enab. bit */ 417 { 418 unsigned long flags; /* can be called from isr via rtc_control() */ 419 spin_lock_irqsave (&rtc_lock, flags); 420 mask_rtc_irq_bit_locked(RTC_PIE); 421 if (rtc_status & RTC_TIMER_ON) { 422 rtc_status &= ~RTC_TIMER_ON; 423 del_timer(&rtc_irq_timer); 424 } 425 spin_unlock_irqrestore (&rtc_lock, flags); 426 return 0; 427 } 428 case RTC_PIE_ON: /* Allow periodic ints */ 429 { 430 unsigned long flags; /* can be called from isr via rtc_control() */ 431 /* 432 * We don't really want Joe User enabling more 433 * than 64Hz of interrupts on a multi-user machine. 434 */ 435 if (!kernel && (rtc_freq > rtc_max_user_freq) && 436 (!capable(CAP_SYS_RESOURCE))) 437 return -EACCES; 438 439 spin_lock_irqsave (&rtc_lock, flags); 440 if (!(rtc_status & RTC_TIMER_ON)) { 441 rtc_irq_timer.expires = jiffies + HZ/rtc_freq + 2*HZ/100; 442 add_timer(&rtc_irq_timer); 443 rtc_status |= RTC_TIMER_ON; 444 } 445 set_rtc_irq_bit_locked(RTC_PIE); 446 spin_unlock_irqrestore (&rtc_lock, flags); 447 return 0; 448 } 449 case RTC_UIE_OFF: /* Mask ints from RTC updates. */ 450 { 451 mask_rtc_irq_bit(RTC_UIE); 452 return 0; 453 } 454 case RTC_UIE_ON: /* Allow ints for RTC updates. */ 455 { 456 set_rtc_irq_bit(RTC_UIE); 457 return 0; 458 } 459#endif 460 case RTC_ALM_READ: /* Read the present alarm time */ 461 { 462 /* 463 * This returns a struct rtc_time. Reading >= 0xc0 464 * means "don't care" or "match all". Only the tm_hour, 465 * tm_min, and tm_sec values are filled in. 466 */ 467 memset(&wtime, 0, sizeof(struct rtc_time)); 468 get_rtc_alm_time(&wtime); 469 break; 470 } 471 case RTC_ALM_SET: /* Store a time into the alarm */ 472 { 473 /* 474 * This expects a struct rtc_time. Writing 0xff means 475 * "don't care" or "match all". Only the tm_hour, 476 * tm_min and tm_sec are used. 477 */ 478 unsigned char hrs, min, sec; 479 struct rtc_time alm_tm; 480 481 if (copy_from_user(&alm_tm, (struct rtc_time __user *)arg, 482 sizeof(struct rtc_time))) 483 return -EFAULT; 484 485 hrs = alm_tm.tm_hour; 486 min = alm_tm.tm_min; 487 sec = alm_tm.tm_sec; 488 489 spin_lock_irq(&rtc_lock); 490 if (hpet_set_alarm_time(hrs, min, sec)) { 491 /* 492 * Fallthru and set alarm time in CMOS too, 493 * so that we will get proper value in RTC_ALM_READ 494 */ 495 } 496 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) || 497 RTC_ALWAYS_BCD) 498 { 499 if (sec < 60) BIN_TO_BCD(sec); 500 else sec = 0xff; 501 502 if (min < 60) BIN_TO_BCD(min); 503 else min = 0xff; 504 505 if (hrs < 24) BIN_TO_BCD(hrs); 506 else hrs = 0xff; 507 } 508 CMOS_WRITE(hrs, RTC_HOURS_ALARM); 509 CMOS_WRITE(min, RTC_MINUTES_ALARM); 510 CMOS_WRITE(sec, RTC_SECONDS_ALARM); 511 spin_unlock_irq(&rtc_lock); 512 513 return 0; 514 } 515 case RTC_RD_TIME: /* Read the time/date from RTC */ 516 { 517 memset(&wtime, 0, sizeof(struct rtc_time)); 518 rtc_get_rtc_time(&wtime); 519 break; 520 } 521 case RTC_SET_TIME: /* Set the RTC */ 522 { 523 struct rtc_time rtc_tm; 524 unsigned char mon, day, hrs, min, sec, leap_yr; 525 unsigned char save_control, save_freq_select; 526 unsigned int yrs; 527#ifdef CONFIG_MACH_DECSTATION 528 unsigned int real_yrs; 529#endif 530 531 if (!capable(CAP_SYS_TIME)) 532 return -EACCES; 533 534 if (copy_from_user(&rtc_tm, (struct rtc_time __user *)arg, 535 sizeof(struct rtc_time))) 536 return -EFAULT; 537 538 yrs = rtc_tm.tm_year + 1900; 539 mon = rtc_tm.tm_mon + 1; /* tm_mon starts at zero */ 540 day = rtc_tm.tm_mday; 541 hrs = rtc_tm.tm_hour; 542 min = rtc_tm.tm_min; 543 sec = rtc_tm.tm_sec; 544 545 if (yrs < 1970) 546 return -EINVAL; 547 548 leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400)); 549 550 if ((mon > 12) || (day == 0)) 551 return -EINVAL; 552 553 if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr))) 554 return -EINVAL; 555 556 if ((hrs >= 24) || (min >= 60) || (sec >= 60)) 557 return -EINVAL; 558 559 if ((yrs -= epoch) > 255) /* They are unsigned */ 560 return -EINVAL; 561 562 spin_lock_irq(&rtc_lock); 563#ifdef CONFIG_MACH_DECSTATION 564 real_yrs = yrs; 565 yrs = 72; 566 567 /* 568 * We want to keep the year set to 73 until March 569 * for non-leap years, so that Feb, 29th is handled 570 * correctly. 571 */ 572 if (!leap_yr && mon < 3) { 573 real_yrs--; 574 yrs = 73; 575 } 576#endif 577 /* These limits and adjustments are independent of 578 * whether the chip is in binary mode or not. 579 */ 580 if (yrs > 169) { 581 spin_unlock_irq(&rtc_lock); 582 return -EINVAL; 583 } 584 if (yrs >= 100) 585 yrs -= 100; 586 587 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) 588 || RTC_ALWAYS_BCD) { 589 BIN_TO_BCD(sec); 590 BIN_TO_BCD(min); 591 BIN_TO_BCD(hrs); 592 BIN_TO_BCD(day); 593 BIN_TO_BCD(mon); 594 BIN_TO_BCD(yrs); 595 } 596 597 save_control = CMOS_READ(RTC_CONTROL); 598 CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL); 599 save_freq_select = CMOS_READ(RTC_FREQ_SELECT); 600 CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT); 601 602#ifdef CONFIG_MACH_DECSTATION 603 CMOS_WRITE(real_yrs, RTC_DEC_YEAR); 604#endif 605 CMOS_WRITE(yrs, RTC_YEAR); 606 CMOS_WRITE(mon, RTC_MONTH); 607 CMOS_WRITE(day, RTC_DAY_OF_MONTH); 608 CMOS_WRITE(hrs, RTC_HOURS); 609 CMOS_WRITE(min, RTC_MINUTES); 610 CMOS_WRITE(sec, RTC_SECONDS); 611 612 CMOS_WRITE(save_control, RTC_CONTROL); 613 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT); 614 615 spin_unlock_irq(&rtc_lock); 616 return 0; 617 } 618#ifdef RTC_IRQ 619 case RTC_IRQP_READ: /* Read the periodic IRQ rate. */ 620 { 621 return put_user(rtc_freq, (unsigned long __user *)arg); 622 } 623 case RTC_IRQP_SET: /* Set periodic IRQ rate. */ 624 { 625 int tmp = 0; 626 unsigned char val; 627 unsigned long flags; /* can be called from isr via rtc_control() */ 628 629 /* 630 * The max we can do is 8192Hz. 631 */ 632 if ((arg < 2) || (arg > 8192)) 633 return -EINVAL; 634 /* 635 * We don't really want Joe User generating more 636 * than 64Hz of interrupts on a multi-user machine. 637 */ 638 if (!kernel && (arg > rtc_max_user_freq) && (!capable(CAP_SYS_RESOURCE))) 639 return -EACCES; 640 641 while (arg > (1<<tmp)) 642 tmp++; 643 644 /* 645 * Check that the input was really a power of 2. 646 */ 647 if (arg != (1<<tmp)) 648 return -EINVAL; 649 650 spin_lock_irqsave(&rtc_lock, flags); 651 if (hpet_set_periodic_freq(arg)) { 652 spin_unlock_irqrestore(&rtc_lock, flags); 653 return 0; 654 } 655 rtc_freq = arg; 656 657 val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0; 658 val |= (16 - tmp); 659 CMOS_WRITE(val, RTC_FREQ_SELECT); 660 spin_unlock_irqrestore(&rtc_lock, flags); 661 return 0; 662 } 663#endif 664 case RTC_EPOCH_READ: /* Read the epoch. */ 665 { 666 return put_user (epoch, (unsigned long __user *)arg); 667 } 668 case RTC_EPOCH_SET: /* Set the epoch. */ 669 { 670 /* 671 * There were no RTC clocks before 1900. 672 */ 673 if (arg < 1900) 674 return -EINVAL; 675 676 if (!capable(CAP_SYS_TIME)) 677 return -EACCES; 678 679 epoch = arg; 680 return 0; 681 } 682 default: 683 return -ENOTTY; 684 } 685 return copy_to_user((void __user *)arg, &wtime, sizeof wtime) ? -EFAULT : 0; 686} 687 688static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd, 689 unsigned long arg) 690{ 691 return rtc_do_ioctl(cmd, arg, 0); 692} 693 694/* 695 * We enforce only one user at a time here with the open/close. 696 * Also clear the previous interrupt data on an open, and clean 697 * up things on a close. 698 */ 699 700/* We use rtc_lock to protect against concurrent opens. So the BKL is not 701 * needed here. Or anywhere else in this driver. */ 702static int rtc_open(struct inode *inode, struct file *file) 703{ 704 spin_lock_irq (&rtc_lock); 705 706 if(rtc_status & RTC_IS_OPEN) 707 goto out_busy; 708 709 rtc_status |= RTC_IS_OPEN; 710 711 rtc_irq_data = 0; 712 spin_unlock_irq (&rtc_lock); 713 return 0; 714 715out_busy: 716 spin_unlock_irq (&rtc_lock); 717 return -EBUSY; 718} 719 720static int rtc_fasync (int fd, struct file *filp, int on) 721 722{ 723 return fasync_helper (fd, filp, on, &rtc_async_queue); 724} 725 726static int rtc_release(struct inode *inode, struct file *file) 727{ 728#ifdef RTC_IRQ 729 unsigned char tmp; 730 731 if (rtc_has_irq == 0) 732 goto no_irq; 733 734 /* 735 * Turn off all interrupts once the device is no longer 736 * in use, and clear the data. 737 */ 738 739 spin_lock_irq(&rtc_lock); 740 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) { 741 tmp = CMOS_READ(RTC_CONTROL); 742 tmp &= ~RTC_PIE; 743 tmp &= ~RTC_AIE; 744 tmp &= ~RTC_UIE; 745 CMOS_WRITE(tmp, RTC_CONTROL); 746 CMOS_READ(RTC_INTR_FLAGS); 747 } 748 if (rtc_status & RTC_TIMER_ON) { 749 rtc_status &= ~RTC_TIMER_ON; 750 del_timer(&rtc_irq_timer); 751 } 752 spin_unlock_irq(&rtc_lock); 753 754 if (file->f_flags & FASYNC) { 755 rtc_fasync (-1, file, 0); 756 } 757no_irq: 758#endif 759 760 spin_lock_irq (&rtc_lock); 761 rtc_irq_data = 0; 762 rtc_status &= ~RTC_IS_OPEN; 763 spin_unlock_irq (&rtc_lock); 764 return 0; 765} 766 767#ifdef RTC_IRQ 768/* Called without the kernel lock - fine */ 769static unsigned int rtc_poll(struct file *file, poll_table *wait) 770{ 771 unsigned long l; 772 773 if (rtc_has_irq == 0) 774 return 0; 775 776 poll_wait(file, &rtc_wait, wait); 777 778 spin_lock_irq (&rtc_lock); 779 l = rtc_irq_data; 780 spin_unlock_irq (&rtc_lock); 781 782 if (l != 0) 783 return POLLIN | POLLRDNORM; 784 return 0; 785} 786#endif 787 788/* 789 * exported stuffs 790 */ 791 792EXPORT_SYMBOL(rtc_register); 793EXPORT_SYMBOL(rtc_unregister); 794EXPORT_SYMBOL(rtc_control); 795 796int rtc_register(rtc_task_t *task) 797{ 798#ifndef RTC_IRQ 799 return -EIO; 800#else 801 if (task == NULL || task->func == NULL) 802 return -EINVAL; 803 spin_lock_irq(&rtc_lock); 804 if (rtc_status & RTC_IS_OPEN) { 805 spin_unlock_irq(&rtc_lock); 806 return -EBUSY; 807 } 808 spin_lock(&rtc_task_lock); 809 if (rtc_callback) { 810 spin_unlock(&rtc_task_lock); 811 spin_unlock_irq(&rtc_lock); 812 return -EBUSY; 813 } 814 rtc_status |= RTC_IS_OPEN; 815 rtc_callback = task; 816 spin_unlock(&rtc_task_lock); 817 spin_unlock_irq(&rtc_lock); 818 return 0; 819#endif 820} 821 822int rtc_unregister(rtc_task_t *task) 823{ 824#ifndef RTC_IRQ 825 return -EIO; 826#else 827 unsigned char tmp; 828 829 spin_lock_irq(&rtc_lock); 830 spin_lock(&rtc_task_lock); 831 if (rtc_callback != task) { 832 spin_unlock(&rtc_task_lock); 833 spin_unlock_irq(&rtc_lock); 834 return -ENXIO; 835 } 836 rtc_callback = NULL; 837 838 /* disable controls */ 839 if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) { 840 tmp = CMOS_READ(RTC_CONTROL); 841 tmp &= ~RTC_PIE; 842 tmp &= ~RTC_AIE; 843 tmp &= ~RTC_UIE; 844 CMOS_WRITE(tmp, RTC_CONTROL); 845 CMOS_READ(RTC_INTR_FLAGS); 846 } 847 if (rtc_status & RTC_TIMER_ON) { 848 rtc_status &= ~RTC_TIMER_ON; 849 del_timer(&rtc_irq_timer); 850 } 851 rtc_status &= ~RTC_IS_OPEN; 852 spin_unlock(&rtc_task_lock); 853 spin_unlock_irq(&rtc_lock); 854 return 0; 855#endif 856} 857 858int rtc_control(rtc_task_t *task, unsigned int cmd, unsigned long arg) 859{ 860#ifndef RTC_IRQ 861 return -EIO; 862#else 863 unsigned long flags; 864 if (cmd != RTC_PIE_ON && cmd != RTC_PIE_OFF && cmd != RTC_IRQP_SET) 865 return -EINVAL; 866 spin_lock_irqsave(&rtc_task_lock, flags); 867 if (rtc_callback != task) { 868 spin_unlock_irqrestore(&rtc_task_lock, flags); 869 return -ENXIO; 870 } 871 spin_unlock_irqrestore(&rtc_task_lock, flags); 872 return rtc_do_ioctl(cmd, arg, 1); 873#endif 874} 875 876 877/* 878 * The various file operations we support. 879 */ 880 881static struct file_operations rtc_fops = { 882 .owner = THIS_MODULE, 883 .llseek = no_llseek, 884 .read = rtc_read, 885#ifdef RTC_IRQ 886 .poll = rtc_poll, 887#endif 888 .ioctl = rtc_ioctl, 889 .open = rtc_open, 890 .release = rtc_release, 891 .fasync = rtc_fasync, 892}; 893 894static struct miscdevice rtc_dev = { 895 .minor = RTC_MINOR, 896 .name = "rtc", 897 .fops = &rtc_fops, 898}; 899 900static struct file_operations rtc_proc_fops = { 901 .owner = THIS_MODULE, 902 .open = rtc_proc_open, 903 .read = seq_read, 904 .llseek = seq_lseek, 905 .release = single_release, 906}; 907 908#if defined(RTC_IRQ) && !defined(__sparc__) 909static irqreturn_t (*rtc_int_handler_ptr)(int irq, void *dev_id, struct pt_regs *regs); 910#endif 911 912static int __init rtc_init(void) 913{ 914 struct proc_dir_entry *ent; 915#if defined(__alpha__) || defined(__mips__) 916 unsigned int year, ctrl; 917 char *guess = NULL; 918#endif 919#ifdef __sparc__ 920 struct linux_ebus *ebus; 921 struct linux_ebus_device *edev; 922#ifdef __sparc_v9__ 923 struct sparc_isa_bridge *isa_br; 924 struct sparc_isa_device *isa_dev; 925#endif 926#endif 927 928#ifdef __sparc__ 929 for_each_ebus(ebus) { 930 for_each_ebusdev(edev, ebus) { 931 if(strcmp(edev->prom_name, "rtc") == 0) { 932 rtc_port = edev->resource[0].start; 933 rtc_irq = edev->irqs[0]; 934 goto found; 935 } 936 } 937 } 938#ifdef __sparc_v9__ 939 for_each_isa(isa_br) { 940 for_each_isadev(isa_dev, isa_br) { 941 if (strcmp(isa_dev->prom_name, "rtc") == 0) { 942 rtc_port = isa_dev->resource.start; 943 rtc_irq = isa_dev->irq; 944 goto found; 945 } 946 } 947 } 948#endif 949 printk(KERN_ERR "rtc_init: no PC rtc found\n"); 950 return -EIO; 951 952found: 953 if (rtc_irq == PCI_IRQ_NONE) { 954 rtc_has_irq = 0; 955 goto no_irq; 956 } 957 958 /* 959 * XXX Interrupt pin #7 in Espresso is shared between RTC and 960 * PCI Slot 2 INTA# (and some INTx# in Slot 1). 961 */ 962 if (request_irq(rtc_irq, rtc_interrupt, SA_SHIRQ, "rtc", (void *)&rtc_port)) { 963 /* 964 * Standard way for sparc to print irq's is to use 965 * __irq_itoa(). I think for EBus it's ok to use %d. 966 */ 967 printk(KERN_ERR "rtc: cannot register IRQ %d\n", rtc_irq); 968 return -EIO; 969 } 970no_irq: 971#else 972 if (!request_region(RTC_PORT(0), RTC_IO_EXTENT, "rtc")) { 973 printk(KERN_ERR "rtc: I/O port %d is not free.\n", RTC_PORT (0)); 974 return -EIO; 975 } 976 977#ifdef RTC_IRQ 978 if (is_hpet_enabled()) { 979 rtc_int_handler_ptr = hpet_rtc_interrupt; 980 } else { 981 rtc_int_handler_ptr = rtc_interrupt; 982 } 983 984 if(request_irq(RTC_IRQ, rtc_int_handler_ptr, SA_INTERRUPT, "rtc", NULL)) { 985 /* Yeah right, seeing as irq 8 doesn't even hit the bus. */ 986 printk(KERN_ERR "rtc: IRQ %d is not free.\n", RTC_IRQ); 987 release_region(RTC_PORT(0), RTC_IO_EXTENT); 988 return -EIO; 989 } 990 hpet_rtc_timer_init(); 991 992#endif 993 994#endif /* __sparc__ vs. others */ 995 996 if (misc_register(&rtc_dev)) { 997#ifdef RTC_IRQ 998 free_irq(RTC_IRQ, NULL); 999#endif 1000 release_region(RTC_PORT(0), RTC_IO_EXTENT); 1001 return -ENODEV; 1002 } 1003 1004 ent = create_proc_entry("driver/rtc", 0, NULL); 1005 if (!ent) { 1006#ifdef RTC_IRQ 1007 free_irq(RTC_IRQ, NULL); 1008#endif 1009 release_region(RTC_PORT(0), RTC_IO_EXTENT); 1010 misc_deregister(&rtc_dev); 1011 return -ENOMEM; 1012 } 1013 ent->proc_fops = &rtc_proc_fops; 1014 1015#if defined(__alpha__) || defined(__mips__) 1016 rtc_freq = HZ; 1017 1018 /* Each operating system on an Alpha uses its own epoch. 1019 Let's try to guess which one we are using now. */ 1020 1021 if (rtc_is_updating() != 0) 1022 msleep(20); 1023 1024 spin_lock_irq(&rtc_lock); 1025 year = CMOS_READ(RTC_YEAR); 1026 ctrl = CMOS_READ(RTC_CONTROL); 1027 spin_unlock_irq(&rtc_lock); 1028 1029 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) 1030 BCD_TO_BIN(year); /* This should never happen... */ 1031 1032 if (year < 20) { 1033 epoch = 2000; 1034 guess = "SRM (post-2000)"; 1035 } else if (year >= 20 && year < 48) { 1036 epoch = 1980; 1037 guess = "ARC console"; 1038 } else if (year >= 48 && year < 72) { 1039 epoch = 1952; 1040 guess = "Digital UNIX"; 1041#if defined(__mips__) 1042 } else if (year >= 72 && year < 74) { 1043 epoch = 2000; 1044 guess = "Digital DECstation"; 1045#else 1046 } else if (year >= 70) { 1047 epoch = 1900; 1048 guess = "Standard PC (1900)"; 1049#endif 1050 } 1051 if (guess) 1052 printk(KERN_INFO "rtc: %s epoch (%lu) detected\n", guess, epoch); 1053#endif 1054#ifdef RTC_IRQ 1055 if (rtc_has_irq == 0) 1056 goto no_irq2; 1057 1058 init_timer(&rtc_irq_timer); 1059 rtc_irq_timer.function = rtc_dropped_irq; 1060 spin_lock_irq(&rtc_lock); 1061 rtc_freq = 1024; 1062 if (!hpet_set_periodic_freq(rtc_freq)) { 1063 /* Initialize periodic freq. to CMOS reset default, which is 1024Hz */ 1064 CMOS_WRITE(((CMOS_READ(RTC_FREQ_SELECT) & 0xF0) | 0x06), RTC_FREQ_SELECT); 1065 } 1066 spin_unlock_irq(&rtc_lock); 1067no_irq2: 1068#endif 1069 1070 (void) init_sysctl(); 1071 1072 printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n"); 1073 1074 return 0; 1075} 1076 1077static void __exit rtc_exit (void) 1078{ 1079 cleanup_sysctl(); 1080 remove_proc_entry ("driver/rtc", NULL); 1081 misc_deregister(&rtc_dev); 1082 1083#ifdef __sparc__ 1084 if (rtc_has_irq) 1085 free_irq (rtc_irq, &rtc_port); 1086#else 1087 release_region (RTC_PORT (0), RTC_IO_EXTENT); 1088#ifdef RTC_IRQ 1089 if (rtc_has_irq) 1090 free_irq (RTC_IRQ, NULL); 1091#endif 1092#endif /* __sparc__ */ 1093} 1094 1095module_init(rtc_init); 1096module_exit(rtc_exit); 1097 1098#ifdef RTC_IRQ 1099/* 1100 * At IRQ rates >= 4096Hz, an interrupt may get lost altogether. 1101 * (usually during an IDE disk interrupt, with IRQ unmasking off) 1102 * Since the interrupt handler doesn't get called, the IRQ status 1103 * byte doesn't get read, and the RTC stops generating interrupts. 1104 * A timer is set, and will call this function if/when that happens. 1105 * To get it out of this stalled state, we just read the status. 1106 * At least a jiffy of interrupts (rtc_freq/HZ) will have been lost. 1107 * (You *really* shouldn't be trying to use a non-realtime system 1108 * for something that requires a steady > 1KHz signal anyways.) 1109 */ 1110 1111static void rtc_dropped_irq(unsigned long data) 1112{ 1113 unsigned long freq; 1114 1115 spin_lock_irq (&rtc_lock); 1116 1117 if (hpet_rtc_dropped_irq()) { 1118 spin_unlock_irq(&rtc_lock); 1119 return; 1120 } 1121 1122 /* Just in case someone disabled the timer from behind our back... */ 1123 if (rtc_status & RTC_TIMER_ON) 1124 mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100); 1125 1126 rtc_irq_data += ((rtc_freq/HZ)<<8); 1127 rtc_irq_data &= ~0xff; 1128 rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0); /* restart */ 1129 1130 freq = rtc_freq; 1131 1132 spin_unlock_irq(&rtc_lock); 1133 1134 printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n", freq); 1135 1136 /* Now we have new data */ 1137 wake_up_interruptible(&rtc_wait); 1138 1139 kill_fasync (&rtc_async_queue, SIGIO, POLL_IN); 1140} 1141#endif 1142 1143/* 1144 * Info exported via "/proc/driver/rtc". 1145 */ 1146 1147static int rtc_proc_show(struct seq_file *seq, void *v) 1148{ 1149#define YN(bit) ((ctrl & bit) ? "yes" : "no") 1150#define NY(bit) ((ctrl & bit) ? "no" : "yes") 1151 struct rtc_time tm; 1152 unsigned char batt, ctrl; 1153 unsigned long freq; 1154 1155 spin_lock_irq(&rtc_lock); 1156 batt = CMOS_READ(RTC_VALID) & RTC_VRT; 1157 ctrl = CMOS_READ(RTC_CONTROL); 1158 freq = rtc_freq; 1159 spin_unlock_irq(&rtc_lock); 1160 1161 1162 rtc_get_rtc_time(&tm); 1163 1164 /* 1165 * There is no way to tell if the luser has the RTC set for local 1166 * time or for Universal Standard Time (GMT). Probably local though. 1167 */ 1168 seq_printf(seq, 1169 "rtc_time\t: %02d:%02d:%02d\n" 1170 "rtc_date\t: %04d-%02d-%02d\n" 1171 "rtc_epoch\t: %04lu\n", 1172 tm.tm_hour, tm.tm_min, tm.tm_sec, 1173 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, epoch); 1174 1175 get_rtc_alm_time(&tm); 1176 1177 /* 1178 * We implicitly assume 24hr mode here. Alarm values >= 0xc0 will 1179 * match any value for that particular field. Values that are 1180 * greater than a valid time, but less than 0xc0 shouldn't appear. 1181 */ 1182 seq_puts(seq, "alarm\t\t: "); 1183 if (tm.tm_hour <= 24) 1184 seq_printf(seq, "%02d:", tm.tm_hour); 1185 else 1186 seq_puts(seq, "**:"); 1187 1188 if (tm.tm_min <= 59) 1189 seq_printf(seq, "%02d:", tm.tm_min); 1190 else 1191 seq_puts(seq, "**:"); 1192 1193 if (tm.tm_sec <= 59) 1194 seq_printf(seq, "%02d\n", tm.tm_sec); 1195 else 1196 seq_puts(seq, "**\n"); 1197 1198 seq_printf(seq, 1199 "DST_enable\t: %s\n" 1200 "BCD\t\t: %s\n" 1201 "24hr\t\t: %s\n" 1202 "square_wave\t: %s\n" 1203 "alarm_IRQ\t: %s\n" 1204 "update_IRQ\t: %s\n" 1205 "periodic_IRQ\t: %s\n" 1206 "periodic_freq\t: %ld\n" 1207 "batt_status\t: %s\n", 1208 YN(RTC_DST_EN), 1209 NY(RTC_DM_BINARY), 1210 YN(RTC_24H), 1211 YN(RTC_SQWE), 1212 YN(RTC_AIE), 1213 YN(RTC_UIE), 1214 YN(RTC_PIE), 1215 freq, 1216 batt ? "okay" : "dead"); 1217 1218 return 0; 1219#undef YN 1220#undef NY 1221} 1222 1223static int rtc_proc_open(struct inode *inode, struct file *file) 1224{ 1225 return single_open(file, rtc_proc_show, NULL); 1226} 1227 1228void rtc_get_rtc_time(struct rtc_time *rtc_tm) 1229{ 1230 unsigned long uip_watchdog = jiffies; 1231 unsigned char ctrl; 1232#ifdef CONFIG_MACH_DECSTATION 1233 unsigned int real_year; 1234#endif 1235 1236 /* 1237 * read RTC once any update in progress is done. The update 1238 * can take just over 2ms. We wait 20ms. There is no need to 1239 * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP. 1240 * If you need to know *exactly* when a second has started, enable 1241 * periodic update complete interrupts, (via ioctl) and then 1242 * immediately read /dev/rtc which will block until you get the IRQ. 1243 * Once the read clears, read the RTC time (again via ioctl). Easy. 1244 */ 1245 1246 while (rtc_is_updating() != 0 && jiffies - uip_watchdog < 2*HZ/100) { 1247 barrier(); 1248 cpu_relax(); 1249 } 1250 1251 /* 1252 * Only the values that we read from the RTC are set. We leave 1253 * tm_wday, tm_yday and tm_isdst untouched. Note that while the 1254 * RTC has RTC_DAY_OF_WEEK, we should usually ignore it, as it is 1255 * only updated by the RTC when initially set to a non-zero value. 1256 */ 1257 spin_lock_irq(&rtc_lock); 1258 rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS); 1259 rtc_tm->tm_min = CMOS_READ(RTC_MINUTES); 1260 rtc_tm->tm_hour = CMOS_READ(RTC_HOURS); 1261 rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH); 1262 rtc_tm->tm_mon = CMOS_READ(RTC_MONTH); 1263 rtc_tm->tm_year = CMOS_READ(RTC_YEAR); 1264 /* Only set from 2.6.16 onwards */ 1265 rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK); 1266 1267#ifdef CONFIG_MACH_DECSTATION 1268 real_year = CMOS_READ(RTC_DEC_YEAR); 1269#endif 1270 ctrl = CMOS_READ(RTC_CONTROL); 1271 spin_unlock_irq(&rtc_lock); 1272 1273 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) 1274 { 1275 BCD_TO_BIN(rtc_tm->tm_sec); 1276 BCD_TO_BIN(rtc_tm->tm_min); 1277 BCD_TO_BIN(rtc_tm->tm_hour); 1278 BCD_TO_BIN(rtc_tm->tm_mday); 1279 BCD_TO_BIN(rtc_tm->tm_mon); 1280 BCD_TO_BIN(rtc_tm->tm_year); 1281 BCD_TO_BIN(rtc_tm->tm_wday); 1282 } 1283 1284#ifdef CONFIG_MACH_DECSTATION 1285 rtc_tm->tm_year += real_year - 72; 1286#endif 1287 1288 /* 1289 * Account for differences between how the RTC uses the values 1290 * and how they are defined in a struct rtc_time; 1291 */ 1292 if ((rtc_tm->tm_year += (epoch - 1900)) <= 69) 1293 rtc_tm->tm_year += 100; 1294 1295 rtc_tm->tm_mon--; 1296} 1297 1298static void get_rtc_alm_time(struct rtc_time *alm_tm) 1299{ 1300 unsigned char ctrl; 1301 1302 /* 1303 * Only the values that we read from the RTC are set. That 1304 * means only tm_hour, tm_min, and tm_sec. 1305 */ 1306 spin_lock_irq(&rtc_lock); 1307 alm_tm->tm_sec = CMOS_READ(RTC_SECONDS_ALARM); 1308 alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM); 1309 alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM); 1310 ctrl = CMOS_READ(RTC_CONTROL); 1311 spin_unlock_irq(&rtc_lock); 1312 1313 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) 1314 { 1315 BCD_TO_BIN(alm_tm->tm_sec); 1316 BCD_TO_BIN(alm_tm->tm_min); 1317 BCD_TO_BIN(alm_tm->tm_hour); 1318 } 1319} 1320 1321#ifdef RTC_IRQ 1322/* 1323 * Used to disable/enable interrupts for any one of UIE, AIE, PIE. 1324 * Rumour has it that if you frob the interrupt enable/disable 1325 * bits in RTC_CONTROL, you should read RTC_INTR_FLAGS, to 1326 * ensure you actually start getting interrupts. Probably for 1327 * compatibility with older/broken chipset RTC implementations. 1328 * We also clear out any old irq data after an ioctl() that 1329 * meddles with the interrupt enable/disable bits. 1330 */ 1331 1332static void mask_rtc_irq_bit_locked(unsigned char bit) 1333{ 1334 unsigned char val; 1335 1336 if (hpet_mask_rtc_irq_bit(bit)) 1337 return; 1338 val = CMOS_READ(RTC_CONTROL); 1339 val &= ~bit; 1340 CMOS_WRITE(val, RTC_CONTROL); 1341 CMOS_READ(RTC_INTR_FLAGS); 1342 1343 rtc_irq_data = 0; 1344} 1345 1346static void set_rtc_irq_bit_locked(unsigned char bit) 1347{ 1348 unsigned char val; 1349 1350 if (hpet_set_rtc_irq_bit(bit)) 1351 return; 1352 val = CMOS_READ(RTC_CONTROL); 1353 val |= bit; 1354 CMOS_WRITE(val, RTC_CONTROL); 1355 CMOS_READ(RTC_INTR_FLAGS); 1356 1357 rtc_irq_data = 0; 1358} 1359#endif 1360 1361MODULE_AUTHOR("Paul Gortmaker"); 1362MODULE_LICENSE("GPL"); 1363MODULE_ALIAS_MISCDEV(RTC_MINOR); 1364