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