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