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