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