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