2 * RTC class driver for "CMOS RTC": PCs, ACPI, etc
4 * Copyright (C) 1996 Paul Gortmaker (drivers/char/rtc.c)
5 * Copyright (C) 2006 David Brownell (convert to new framework)
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
14 * The original "cmos clock" chip was an MC146818 chip, now obsolete.
15 * That defined the register interface now provided by all PCs, some
16 * non-PC systems, and incorporated into ACPI. Modern PC chipsets
17 * integrate an MC146818 clone in their southbridge, and boards use
18 * that instead of discrete clones like the DS12887 or M48T86. There
19 * are also clones that connect using the LPC bus.
21 * That register API is also used directly by various other drivers
22 * (notably for integrated NVRAM), infrastructure (x86 has code to
23 * bypass the RTC framework, directly reading the RTC during boot
24 * and updating minutes/seconds for systems using NTP synch) and
25 * utilities (like userspace 'hwclock', if no /dev node exists).
27 * So **ALL** calls to CMOS_READ and CMOS_WRITE must be done with
28 * interrupts disabled, holding the global rtc_lock, to exclude those
29 * other drivers and utilities on correctly configured systems.
32 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
34 #include <linux/kernel.h>
35 #include <linux/module.h>
36 #include <linux/init.h>
37 #include <linux/interrupt.h>
38 #include <linux/spinlock.h>
39 #include <linux/platform_device.h>
40 #include <linux/log2.h>
43 #include <linux/of_platform.h>
45 #include <asm/i8259.h>
48 /* this is for "generic access to PC-style RTC" using CMOS_READ/CMOS_WRITE */
49 #include <linux/mc146818rtc.h>
52 struct rtc_device
*rtc
;
55 struct resource
*iomem
;
56 time64_t alarm_expires
;
58 void (*wake_on
)(struct device
*);
59 void (*wake_off
)(struct device
*);
64 /* newer hardware extends the original register set */
69 struct rtc_wkalrm saved_wkalrm
;
72 /* both platform and pnp busses use negative numbers for invalid irqs */
73 #define is_valid_irq(n) ((n) > 0)
75 static const char driver_name
[] = "rtc_cmos";
77 /* The RTC_INTR register may have e.g. RTC_PF set even if RTC_PIE is clear;
78 * always mask it against the irq enable bits in RTC_CONTROL. Bit values
79 * are the same: PF==PIE, AF=AIE, UF=UIE; so RTC_IRQMASK works with both.
81 #define RTC_IRQMASK (RTC_PF | RTC_AF | RTC_UF)
83 static inline int is_intr(u8 rtc_intr
)
85 if (!(rtc_intr
& RTC_IRQF
))
87 return rtc_intr
& RTC_IRQMASK
;
90 /*----------------------------------------------------------------*/
92 /* Much modern x86 hardware has HPETs (10+ MHz timers) which, because
93 * many BIOS programmers don't set up "sane mode" IRQ routing, are mostly
94 * used in a broken "legacy replacement" mode. The breakage includes
95 * HPET #1 hijacking the IRQ for this RTC, and being unavailable for
98 * When that broken mode is in use, platform glue provides a partial
99 * emulation of hardware RTC IRQ facilities using HPET #1. We don't
100 * want to use HPET for anything except those IRQs though...
102 #ifdef CONFIG_HPET_EMULATE_RTC
103 #include <asm/hpet.h>
106 static inline int is_hpet_enabled(void)
111 static inline int hpet_mask_rtc_irq_bit(unsigned long mask
)
116 static inline int hpet_set_rtc_irq_bit(unsigned long mask
)
122 hpet_set_alarm_time(unsigned char hrs
, unsigned char min
, unsigned char sec
)
127 static inline int hpet_set_periodic_freq(unsigned long freq
)
132 static inline int hpet_rtc_dropped_irq(void)
137 static inline int hpet_rtc_timer_init(void)
142 extern irq_handler_t hpet_rtc_interrupt
;
144 static inline int hpet_register_irq_handler(irq_handler_t handler
)
149 static inline int hpet_unregister_irq_handler(irq_handler_t handler
)
156 /*----------------------------------------------------------------*/
160 /* Most newer x86 systems have two register banks, the first used
161 * for RTC and NVRAM and the second only for NVRAM. Caller must
162 * own rtc_lock ... and we won't worry about access during NMI.
164 #define can_bank2 true
166 static inline unsigned char cmos_read_bank2(unsigned char addr
)
168 outb(addr
, RTC_PORT(2));
169 return inb(RTC_PORT(3));
172 static inline void cmos_write_bank2(unsigned char val
, unsigned char addr
)
174 outb(addr
, RTC_PORT(2));
175 outb(val
, RTC_PORT(3));
180 #define can_bank2 false
182 static inline unsigned char cmos_read_bank2(unsigned char addr
)
187 static inline void cmos_write_bank2(unsigned char val
, unsigned char addr
)
193 /*----------------------------------------------------------------*/
195 static int cmos_read_time(struct device
*dev
, struct rtc_time
*t
)
198 * If pm_trace abused the RTC for storage, set the timespec to 0,
199 * which tells the caller that this RTC value is unusable.
201 if (!pm_trace_rtc_valid())
204 /* REVISIT: if the clock has a "century" register, use
205 * that instead of the heuristic in mc146818_get_time().
206 * That'll make Y3K compatility (year > 2070) easy!
208 mc146818_get_time(t
);
212 static int cmos_set_time(struct device
*dev
, struct rtc_time
*t
)
214 /* REVISIT: set the "century" register if available
216 * NOTE: this ignores the issue whereby updating the seconds
217 * takes effect exactly 500ms after we write the register.
218 * (Also queueing and other delays before we get this far.)
220 return mc146818_set_time(t
);
223 static int cmos_read_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
225 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
226 unsigned char rtc_control
;
228 if (!is_valid_irq(cmos
->irq
))
231 /* Basic alarms only support hour, minute, and seconds fields.
232 * Some also support day and month, for alarms up to a year in
236 spin_lock_irq(&rtc_lock
);
237 t
->time
.tm_sec
= CMOS_READ(RTC_SECONDS_ALARM
);
238 t
->time
.tm_min
= CMOS_READ(RTC_MINUTES_ALARM
);
239 t
->time
.tm_hour
= CMOS_READ(RTC_HOURS_ALARM
);
241 if (cmos
->day_alrm
) {
242 /* ignore upper bits on readback per ACPI spec */
243 t
->time
.tm_mday
= CMOS_READ(cmos
->day_alrm
) & 0x3f;
244 if (!t
->time
.tm_mday
)
245 t
->time
.tm_mday
= -1;
247 if (cmos
->mon_alrm
) {
248 t
->time
.tm_mon
= CMOS_READ(cmos
->mon_alrm
);
254 rtc_control
= CMOS_READ(RTC_CONTROL
);
255 spin_unlock_irq(&rtc_lock
);
257 if (!(rtc_control
& RTC_DM_BINARY
) || RTC_ALWAYS_BCD
) {
258 if (((unsigned)t
->time
.tm_sec
) < 0x60)
259 t
->time
.tm_sec
= bcd2bin(t
->time
.tm_sec
);
262 if (((unsigned)t
->time
.tm_min
) < 0x60)
263 t
->time
.tm_min
= bcd2bin(t
->time
.tm_min
);
266 if (((unsigned)t
->time
.tm_hour
) < 0x24)
267 t
->time
.tm_hour
= bcd2bin(t
->time
.tm_hour
);
269 t
->time
.tm_hour
= -1;
271 if (cmos
->day_alrm
) {
272 if (((unsigned)t
->time
.tm_mday
) <= 0x31)
273 t
->time
.tm_mday
= bcd2bin(t
->time
.tm_mday
);
275 t
->time
.tm_mday
= -1;
277 if (cmos
->mon_alrm
) {
278 if (((unsigned)t
->time
.tm_mon
) <= 0x12)
279 t
->time
.tm_mon
= bcd2bin(t
->time
.tm_mon
)-1;
286 t
->enabled
= !!(rtc_control
& RTC_AIE
);
292 static void cmos_checkintr(struct cmos_rtc
*cmos
, unsigned char rtc_control
)
294 unsigned char rtc_intr
;
296 /* NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
297 * allegedly some older rtcs need that to handle irqs properly
299 rtc_intr
= CMOS_READ(RTC_INTR_FLAGS
);
301 if (is_hpet_enabled())
304 rtc_intr
&= (rtc_control
& RTC_IRQMASK
) | RTC_IRQF
;
305 if (is_intr(rtc_intr
))
306 rtc_update_irq(cmos
->rtc
, 1, rtc_intr
);
309 static void cmos_irq_enable(struct cmos_rtc
*cmos
, unsigned char mask
)
311 unsigned char rtc_control
;
313 /* flush any pending IRQ status, notably for update irqs,
314 * before we enable new IRQs
316 rtc_control
= CMOS_READ(RTC_CONTROL
);
317 cmos_checkintr(cmos
, rtc_control
);
320 CMOS_WRITE(rtc_control
, RTC_CONTROL
);
321 hpet_set_rtc_irq_bit(mask
);
323 cmos_checkintr(cmos
, rtc_control
);
326 static void cmos_irq_disable(struct cmos_rtc
*cmos
, unsigned char mask
)
328 unsigned char rtc_control
;
330 rtc_control
= CMOS_READ(RTC_CONTROL
);
331 rtc_control
&= ~mask
;
332 CMOS_WRITE(rtc_control
, RTC_CONTROL
);
333 hpet_mask_rtc_irq_bit(mask
);
335 cmos_checkintr(cmos
, rtc_control
);
338 static int cmos_validate_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
340 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
343 cmos_read_time(dev
, &now
);
345 if (!cmos
->day_alrm
) {
349 t_max_date
= rtc_tm_to_time64(&now
);
350 t_max_date
+= 24 * 60 * 60 - 1;
351 t_alrm
= rtc_tm_to_time64(&t
->time
);
352 if (t_alrm
> t_max_date
) {
354 "Alarms can be up to one day in the future\n");
357 } else if (!cmos
->mon_alrm
) {
358 struct rtc_time max_date
= now
;
363 if (max_date
.tm_mon
== 11) {
365 max_date
.tm_year
+= 1;
367 max_date
.tm_mon
+= 1;
369 max_mday
= rtc_month_days(max_date
.tm_mon
, max_date
.tm_year
);
370 if (max_date
.tm_mday
> max_mday
)
371 max_date
.tm_mday
= max_mday
;
373 t_max_date
= rtc_tm_to_time64(&max_date
);
375 t_alrm
= rtc_tm_to_time64(&t
->time
);
376 if (t_alrm
> t_max_date
) {
378 "Alarms can be up to one month in the future\n");
382 struct rtc_time max_date
= now
;
387 max_date
.tm_year
+= 1;
388 max_mday
= rtc_month_days(max_date
.tm_mon
, max_date
.tm_year
);
389 if (max_date
.tm_mday
> max_mday
)
390 max_date
.tm_mday
= max_mday
;
392 t_max_date
= rtc_tm_to_time64(&max_date
);
394 t_alrm
= rtc_tm_to_time64(&t
->time
);
395 if (t_alrm
> t_max_date
) {
397 "Alarms can be up to one year in the future\n");
405 static int cmos_set_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
407 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
408 unsigned char mon
, mday
, hrs
, min
, sec
, rtc_control
;
411 if (!is_valid_irq(cmos
->irq
))
414 ret
= cmos_validate_alarm(dev
, t
);
418 mon
= t
->time
.tm_mon
+ 1;
419 mday
= t
->time
.tm_mday
;
420 hrs
= t
->time
.tm_hour
;
421 min
= t
->time
.tm_min
;
422 sec
= t
->time
.tm_sec
;
424 rtc_control
= CMOS_READ(RTC_CONTROL
);
425 if (!(rtc_control
& RTC_DM_BINARY
) || RTC_ALWAYS_BCD
) {
426 /* Writing 0xff means "don't care" or "match all". */
427 mon
= (mon
<= 12) ? bin2bcd(mon
) : 0xff;
428 mday
= (mday
>= 1 && mday
<= 31) ? bin2bcd(mday
) : 0xff;
429 hrs
= (hrs
< 24) ? bin2bcd(hrs
) : 0xff;
430 min
= (min
< 60) ? bin2bcd(min
) : 0xff;
431 sec
= (sec
< 60) ? bin2bcd(sec
) : 0xff;
434 spin_lock_irq(&rtc_lock
);
436 /* next rtc irq must not be from previous alarm setting */
437 cmos_irq_disable(cmos
, RTC_AIE
);
440 CMOS_WRITE(hrs
, RTC_HOURS_ALARM
);
441 CMOS_WRITE(min
, RTC_MINUTES_ALARM
);
442 CMOS_WRITE(sec
, RTC_SECONDS_ALARM
);
444 /* the system may support an "enhanced" alarm */
445 if (cmos
->day_alrm
) {
446 CMOS_WRITE(mday
, cmos
->day_alrm
);
448 CMOS_WRITE(mon
, cmos
->mon_alrm
);
451 /* FIXME the HPET alarm glue currently ignores day_alrm
454 hpet_set_alarm_time(t
->time
.tm_hour
, t
->time
.tm_min
, t
->time
.tm_sec
);
457 cmos_irq_enable(cmos
, RTC_AIE
);
459 spin_unlock_irq(&rtc_lock
);
461 cmos
->alarm_expires
= rtc_tm_to_time64(&t
->time
);
466 static int cmos_alarm_irq_enable(struct device
*dev
, unsigned int enabled
)
468 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
471 if (!is_valid_irq(cmos
->irq
))
474 spin_lock_irqsave(&rtc_lock
, flags
);
477 cmos_irq_enable(cmos
, RTC_AIE
);
479 cmos_irq_disable(cmos
, RTC_AIE
);
481 spin_unlock_irqrestore(&rtc_lock
, flags
);
485 #if IS_ENABLED(CONFIG_RTC_INTF_PROC)
487 static int cmos_procfs(struct device
*dev
, struct seq_file
*seq
)
489 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
490 unsigned char rtc_control
, valid
;
492 spin_lock_irq(&rtc_lock
);
493 rtc_control
= CMOS_READ(RTC_CONTROL
);
494 valid
= CMOS_READ(RTC_VALID
);
495 spin_unlock_irq(&rtc_lock
);
497 /* NOTE: at least ICH6 reports battery status using a different
498 * (non-RTC) bit; and SQWE is ignored on many current systems.
501 "periodic_IRQ\t: %s\n"
503 "HPET_emulated\t: %s\n"
504 // "square_wave\t: %s\n"
507 "periodic_freq\t: %d\n"
508 "batt_status\t: %s\n",
509 (rtc_control
& RTC_PIE
) ? "yes" : "no",
510 (rtc_control
& RTC_UIE
) ? "yes" : "no",
511 is_hpet_enabled() ? "yes" : "no",
512 // (rtc_control & RTC_SQWE) ? "yes" : "no",
513 (rtc_control
& RTC_DM_BINARY
) ? "no" : "yes",
514 (rtc_control
& RTC_DST_EN
) ? "yes" : "no",
516 (valid
& RTC_VRT
) ? "okay" : "dead");
522 #define cmos_procfs NULL
525 static const struct rtc_class_ops cmos_rtc_ops
= {
526 .read_time
= cmos_read_time
,
527 .set_time
= cmos_set_time
,
528 .read_alarm
= cmos_read_alarm
,
529 .set_alarm
= cmos_set_alarm
,
531 .alarm_irq_enable
= cmos_alarm_irq_enable
,
534 /*----------------------------------------------------------------*/
537 * All these chips have at least 64 bytes of address space, shared by
538 * RTC registers and NVRAM. Most of those bytes of NVRAM are used
539 * by boot firmware. Modern chips have 128 or 256 bytes.
542 #define NVRAM_OFFSET (RTC_REG_D + 1)
545 cmos_nvram_read(struct file
*filp
, struct kobject
*kobj
,
546 struct bin_attribute
*attr
,
547 char *buf
, loff_t off
, size_t count
)
552 spin_lock_irq(&rtc_lock
);
553 for (retval
= 0; count
; count
--, off
++, retval
++) {
555 *buf
++ = CMOS_READ(off
);
557 *buf
++ = cmos_read_bank2(off
);
561 spin_unlock_irq(&rtc_lock
);
567 cmos_nvram_write(struct file
*filp
, struct kobject
*kobj
,
568 struct bin_attribute
*attr
,
569 char *buf
, loff_t off
, size_t count
)
571 struct cmos_rtc
*cmos
;
574 cmos
= dev_get_drvdata(container_of(kobj
, struct device
, kobj
));
576 /* NOTE: on at least PCs and Ataris, the boot firmware uses a
577 * checksum on part of the NVRAM data. That's currently ignored
578 * here. If userspace is smart enough to know what fields of
579 * NVRAM to update, updating checksums is also part of its job.
582 spin_lock_irq(&rtc_lock
);
583 for (retval
= 0; count
; count
--, off
++, retval
++) {
584 /* don't trash RTC registers */
585 if (off
== cmos
->day_alrm
586 || off
== cmos
->mon_alrm
587 || off
== cmos
->century
)
590 CMOS_WRITE(*buf
++, off
);
592 cmos_write_bank2(*buf
++, off
);
596 spin_unlock_irq(&rtc_lock
);
601 static struct bin_attribute nvram
= {
604 .mode
= S_IRUGO
| S_IWUSR
,
607 .read
= cmos_nvram_read
,
608 .write
= cmos_nvram_write
,
609 /* size gets set up later */
612 /*----------------------------------------------------------------*/
614 static struct cmos_rtc cmos_rtc
;
616 static irqreturn_t
cmos_interrupt(int irq
, void *p
)
621 spin_lock(&rtc_lock
);
623 /* When the HPET interrupt handler calls us, the interrupt
624 * status is passed as arg1 instead of the irq number. But
625 * always clear irq status, even when HPET is in the way.
627 * Note that HPET and RTC are almost certainly out of phase,
628 * giving different IRQ status ...
630 irqstat
= CMOS_READ(RTC_INTR_FLAGS
);
631 rtc_control
= CMOS_READ(RTC_CONTROL
);
632 if (is_hpet_enabled())
633 irqstat
= (unsigned long)irq
& 0xF0;
635 /* If we were suspended, RTC_CONTROL may not be accurate since the
636 * bios may have cleared it.
638 if (!cmos_rtc
.suspend_ctrl
)
639 irqstat
&= (rtc_control
& RTC_IRQMASK
) | RTC_IRQF
;
641 irqstat
&= (cmos_rtc
.suspend_ctrl
& RTC_IRQMASK
) | RTC_IRQF
;
643 /* All Linux RTC alarms should be treated as if they were oneshot.
644 * Similar code may be needed in system wakeup paths, in case the
645 * alarm woke the system.
647 if (irqstat
& RTC_AIE
) {
648 cmos_rtc
.suspend_ctrl
&= ~RTC_AIE
;
649 rtc_control
&= ~RTC_AIE
;
650 CMOS_WRITE(rtc_control
, RTC_CONTROL
);
651 hpet_mask_rtc_irq_bit(RTC_AIE
);
652 CMOS_READ(RTC_INTR_FLAGS
);
654 spin_unlock(&rtc_lock
);
656 if (is_intr(irqstat
)) {
657 rtc_update_irq(p
, 1, irqstat
);
667 #define INITSECTION __init
670 static int INITSECTION
671 cmos_do_probe(struct device
*dev
, struct resource
*ports
, int rtc_irq
)
673 struct cmos_rtc_board_info
*info
= dev_get_platdata(dev
);
675 unsigned char rtc_control
;
676 unsigned address_space
;
679 /* there can be only one ... */
686 /* Claim I/O ports ASAP, minimizing conflict with legacy driver.
688 * REVISIT non-x86 systems may instead use memory space resources
689 * (needing ioremap etc), not i/o space resources like this ...
692 ports
= request_region(ports
->start
, resource_size(ports
),
695 ports
= request_mem_region(ports
->start
, resource_size(ports
),
698 dev_dbg(dev
, "i/o registers already in use\n");
702 cmos_rtc
.irq
= rtc_irq
;
703 cmos_rtc
.iomem
= ports
;
705 /* Heuristic to deduce NVRAM size ... do what the legacy NVRAM
706 * driver did, but don't reject unknown configs. Old hardware
707 * won't address 128 bytes. Newer chips have multiple banks,
708 * though they may not be listed in one I/O resource.
710 #if defined(CONFIG_ATARI)
712 #elif defined(__i386__) || defined(__x86_64__) || defined(__arm__) \
713 || defined(__sparc__) || defined(__mips__) \
714 || defined(__powerpc__) || defined(CONFIG_MN10300)
717 #warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes.
720 if (can_bank2
&& ports
->end
> (ports
->start
+ 1))
723 /* For ACPI systems extension info comes from the FADT. On others,
724 * board specific setup provides it as appropriate. Systems where
725 * the alarm IRQ isn't automatically a wakeup IRQ (like ACPI, and
726 * some almost-clones) can provide hooks to make that behave.
728 * Note that ACPI doesn't preclude putting these registers into
729 * "extended" areas of the chip, including some that we won't yet
730 * expect CMOS_READ and friends to handle.
735 if (info
->address_space
)
736 address_space
= info
->address_space
;
738 if (info
->rtc_day_alarm
&& info
->rtc_day_alarm
< 128)
739 cmos_rtc
.day_alrm
= info
->rtc_day_alarm
;
740 if (info
->rtc_mon_alarm
&& info
->rtc_mon_alarm
< 128)
741 cmos_rtc
.mon_alrm
= info
->rtc_mon_alarm
;
742 if (info
->rtc_century
&& info
->rtc_century
< 128)
743 cmos_rtc
.century
= info
->rtc_century
;
745 if (info
->wake_on
&& info
->wake_off
) {
746 cmos_rtc
.wake_on
= info
->wake_on
;
747 cmos_rtc
.wake_off
= info
->wake_off
;
752 dev_set_drvdata(dev
, &cmos_rtc
);
754 cmos_rtc
.rtc
= rtc_device_register(driver_name
, dev
,
755 &cmos_rtc_ops
, THIS_MODULE
);
756 if (IS_ERR(cmos_rtc
.rtc
)) {
757 retval
= PTR_ERR(cmos_rtc
.rtc
);
761 rename_region(ports
, dev_name(&cmos_rtc
.rtc
->dev
));
763 spin_lock_irq(&rtc_lock
);
765 if (!(flags
& CMOS_RTC_FLAGS_NOFREQ
)) {
766 /* force periodic irq to CMOS reset default of 1024Hz;
768 * REVISIT it's been reported that at least one x86_64 ALI
769 * mobo doesn't use 32KHz here ... for portability we might
770 * need to do something about other clock frequencies.
772 cmos_rtc
.rtc
->irq_freq
= 1024;
773 hpet_set_periodic_freq(cmos_rtc
.rtc
->irq_freq
);
774 CMOS_WRITE(RTC_REF_CLCK_32KHZ
| 0x06, RTC_FREQ_SELECT
);
778 if (is_valid_irq(rtc_irq
))
779 cmos_irq_disable(&cmos_rtc
, RTC_PIE
| RTC_AIE
| RTC_UIE
);
781 rtc_control
= CMOS_READ(RTC_CONTROL
);
783 spin_unlock_irq(&rtc_lock
);
785 if (is_valid_irq(rtc_irq
) && !(rtc_control
& RTC_24H
)) {
786 dev_warn(dev
, "only 24-hr supported\n");
791 hpet_rtc_timer_init();
793 if (is_valid_irq(rtc_irq
)) {
794 irq_handler_t rtc_cmos_int_handler
;
796 if (is_hpet_enabled()) {
797 rtc_cmos_int_handler
= hpet_rtc_interrupt
;
798 retval
= hpet_register_irq_handler(cmos_interrupt
);
800 hpet_mask_rtc_irq_bit(RTC_IRQMASK
);
801 dev_warn(dev
, "hpet_register_irq_handler "
802 " failed in rtc_init().");
806 rtc_cmos_int_handler
= cmos_interrupt
;
808 retval
= request_irq(rtc_irq
, rtc_cmos_int_handler
,
809 IRQF_SHARED
, dev_name(&cmos_rtc
.rtc
->dev
),
812 dev_dbg(dev
, "IRQ %d is already in use\n", rtc_irq
);
817 /* export at least the first block of NVRAM */
818 nvram
.size
= address_space
- NVRAM_OFFSET
;
819 retval
= sysfs_create_bin_file(&dev
->kobj
, &nvram
);
821 dev_dbg(dev
, "can't create nvram file? %d\n", retval
);
825 dev_info(dev
, "%s%s, %zd bytes nvram%s\n",
826 !is_valid_irq(rtc_irq
) ? "no alarms" :
827 cmos_rtc
.mon_alrm
? "alarms up to one year" :
828 cmos_rtc
.day_alrm
? "alarms up to one month" :
829 "alarms up to one day",
830 cmos_rtc
.century
? ", y3k" : "",
832 is_hpet_enabled() ? ", hpet irqs" : "");
837 if (is_valid_irq(rtc_irq
))
838 free_irq(rtc_irq
, cmos_rtc
.rtc
);
841 rtc_device_unregister(cmos_rtc
.rtc
);
844 release_region(ports
->start
, resource_size(ports
));
846 release_mem_region(ports
->start
, resource_size(ports
));
850 static void cmos_do_shutdown(int rtc_irq
)
852 spin_lock_irq(&rtc_lock
);
853 if (is_valid_irq(rtc_irq
))
854 cmos_irq_disable(&cmos_rtc
, RTC_IRQMASK
);
855 spin_unlock_irq(&rtc_lock
);
858 static void cmos_do_remove(struct device
*dev
)
860 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
861 struct resource
*ports
;
863 cmos_do_shutdown(cmos
->irq
);
865 sysfs_remove_bin_file(&dev
->kobj
, &nvram
);
867 if (is_valid_irq(cmos
->irq
)) {
868 free_irq(cmos
->irq
, cmos
->rtc
);
869 hpet_unregister_irq_handler(cmos_interrupt
);
872 rtc_device_unregister(cmos
->rtc
);
877 release_region(ports
->start
, resource_size(ports
));
879 release_mem_region(ports
->start
, resource_size(ports
));
885 static int cmos_aie_poweroff(struct device
*dev
)
887 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
891 unsigned char rtc_control
;
893 if (!cmos
->alarm_expires
)
896 spin_lock_irq(&rtc_lock
);
897 rtc_control
= CMOS_READ(RTC_CONTROL
);
898 spin_unlock_irq(&rtc_lock
);
900 /* We only care about the situation where AIE is disabled. */
901 if (rtc_control
& RTC_AIE
)
904 cmos_read_time(dev
, &now
);
905 t_now
= rtc_tm_to_time64(&now
);
908 * When enabling "RTC wake-up" in BIOS setup, the machine reboots
909 * automatically right after shutdown on some buggy boxes.
910 * This automatic rebooting issue won't happen when the alarm
911 * time is larger than now+1 seconds.
913 * If the alarm time is equal to now+1 seconds, the issue can be
914 * prevented by cancelling the alarm.
916 if (cmos
->alarm_expires
== t_now
+ 1) {
917 struct rtc_wkalrm alarm
;
919 /* Cancel the AIE timer by configuring the past time. */
920 rtc_time64_to_tm(t_now
- 1, &alarm
.time
);
922 retval
= cmos_set_alarm(dev
, &alarm
);
923 } else if (cmos
->alarm_expires
> t_now
+ 1) {
930 static int cmos_suspend(struct device
*dev
)
932 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
935 /* only the alarm might be a wakeup event source */
936 spin_lock_irq(&rtc_lock
);
937 cmos
->suspend_ctrl
= tmp
= CMOS_READ(RTC_CONTROL
);
938 if (tmp
& (RTC_PIE
|RTC_AIE
|RTC_UIE
)) {
941 if (device_may_wakeup(dev
))
942 mask
= RTC_IRQMASK
& ~RTC_AIE
;
946 CMOS_WRITE(tmp
, RTC_CONTROL
);
947 hpet_mask_rtc_irq_bit(mask
);
949 cmos_checkintr(cmos
, tmp
);
951 spin_unlock_irq(&rtc_lock
);
954 cmos
->enabled_wake
= 1;
958 enable_irq_wake(cmos
->irq
);
961 cmos_read_alarm(dev
, &cmos
->saved_wkalrm
);
963 dev_dbg(dev
, "suspend%s, ctrl %02x\n",
964 (tmp
& RTC_AIE
) ? ", alarm may wake" : "",
970 /* We want RTC alarms to wake us from e.g. ACPI G2/S5 "soft off", even
971 * after a detour through G3 "mechanical off", although the ACPI spec
972 * says wakeup should only work from G1/S4 "hibernate". To most users,
973 * distinctions between S4 and S5 are pointless. So when the hardware
974 * allows, don't draw that distinction.
976 static inline int cmos_poweroff(struct device
*dev
)
978 if (!IS_ENABLED(CONFIG_PM
))
981 return cmos_suspend(dev
);
984 static void cmos_check_wkalrm(struct device
*dev
)
986 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
987 struct rtc_wkalrm current_alarm
;
988 time64_t t_current_expires
;
989 time64_t t_saved_expires
;
991 cmos_read_alarm(dev
, ¤t_alarm
);
992 t_current_expires
= rtc_tm_to_time64(¤t_alarm
.time
);
993 t_saved_expires
= rtc_tm_to_time64(&cmos
->saved_wkalrm
.time
);
994 if (t_current_expires
!= t_saved_expires
||
995 cmos
->saved_wkalrm
.enabled
!= current_alarm
.enabled
) {
996 cmos_set_alarm(dev
, &cmos
->saved_wkalrm
);
1000 static void cmos_check_acpi_rtc_status(struct device
*dev
,
1001 unsigned char *rtc_control
);
1003 static int __maybe_unused
cmos_resume(struct device
*dev
)
1005 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
1008 if (cmos
->enabled_wake
) {
1010 cmos
->wake_off(dev
);
1012 disable_irq_wake(cmos
->irq
);
1013 cmos
->enabled_wake
= 0;
1016 /* The BIOS might have changed the alarm, restore it */
1017 cmos_check_wkalrm(dev
);
1019 spin_lock_irq(&rtc_lock
);
1020 tmp
= cmos
->suspend_ctrl
;
1021 cmos
->suspend_ctrl
= 0;
1022 /* re-enable any irqs previously active */
1023 if (tmp
& RTC_IRQMASK
) {
1026 if (device_may_wakeup(dev
))
1027 hpet_rtc_timer_init();
1030 CMOS_WRITE(tmp
, RTC_CONTROL
);
1031 hpet_set_rtc_irq_bit(tmp
& RTC_IRQMASK
);
1033 mask
= CMOS_READ(RTC_INTR_FLAGS
);
1034 mask
&= (tmp
& RTC_IRQMASK
) | RTC_IRQF
;
1035 if (!is_hpet_enabled() || !is_intr(mask
))
1038 /* force one-shot behavior if HPET blocked
1039 * the wake alarm's irq
1041 rtc_update_irq(cmos
->rtc
, 1, mask
);
1043 hpet_mask_rtc_irq_bit(RTC_AIE
);
1044 } while (mask
& RTC_AIE
);
1047 cmos_check_acpi_rtc_status(dev
, &tmp
);
1049 spin_unlock_irq(&rtc_lock
);
1051 dev_dbg(dev
, "resume, ctrl %02x\n", tmp
);
1056 static SIMPLE_DEV_PM_OPS(cmos_pm_ops
, cmos_suspend
, cmos_resume
);
1058 /*----------------------------------------------------------------*/
1060 /* On non-x86 systems, a "CMOS" RTC lives most naturally on platform_bus.
1061 * ACPI systems always list these as PNPACPI devices, and pre-ACPI PCs
1062 * probably list them in similar PNPBIOS tables; so PNP is more common.
1064 * We don't use legacy "poke at the hardware" probing. Ancient PCs that
1065 * predate even PNPBIOS should set up platform_bus devices.
1070 #include <linux/acpi.h>
1072 static u32
rtc_handler(void *context
)
1074 struct device
*dev
= context
;
1075 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
1076 unsigned char rtc_control
= 0;
1077 unsigned char rtc_intr
;
1078 unsigned long flags
;
1080 spin_lock_irqsave(&rtc_lock
, flags
);
1081 if (cmos_rtc
.suspend_ctrl
)
1082 rtc_control
= CMOS_READ(RTC_CONTROL
);
1083 if (rtc_control
& RTC_AIE
) {
1084 cmos_rtc
.suspend_ctrl
&= ~RTC_AIE
;
1085 CMOS_WRITE(rtc_control
, RTC_CONTROL
);
1086 rtc_intr
= CMOS_READ(RTC_INTR_FLAGS
);
1087 rtc_update_irq(cmos
->rtc
, 1, rtc_intr
);
1089 spin_unlock_irqrestore(&rtc_lock
, flags
);
1091 pm_wakeup_hard_event(dev
);
1092 acpi_clear_event(ACPI_EVENT_RTC
);
1093 acpi_disable_event(ACPI_EVENT_RTC
, 0);
1094 return ACPI_INTERRUPT_HANDLED
;
1097 static inline void rtc_wake_setup(struct device
*dev
)
1099 acpi_install_fixed_event_handler(ACPI_EVENT_RTC
, rtc_handler
, dev
);
1101 * After the RTC handler is installed, the Fixed_RTC event should
1102 * be disabled. Only when the RTC alarm is set will it be enabled.
1104 acpi_clear_event(ACPI_EVENT_RTC
);
1105 acpi_disable_event(ACPI_EVENT_RTC
, 0);
1108 static void rtc_wake_on(struct device
*dev
)
1110 acpi_clear_event(ACPI_EVENT_RTC
);
1111 acpi_enable_event(ACPI_EVENT_RTC
, 0);
1114 static void rtc_wake_off(struct device
*dev
)
1116 acpi_disable_event(ACPI_EVENT_RTC
, 0);
1119 /* Every ACPI platform has a mc146818 compatible "cmos rtc". Here we find
1120 * its device node and pass extra config data. This helps its driver use
1121 * capabilities that the now-obsolete mc146818 didn't have, and informs it
1122 * that this board's RTC is wakeup-capable (per ACPI spec).
1124 static struct cmos_rtc_board_info acpi_rtc_info
;
1126 static void cmos_wake_setup(struct device
*dev
)
1131 rtc_wake_setup(dev
);
1132 acpi_rtc_info
.wake_on
= rtc_wake_on
;
1133 acpi_rtc_info
.wake_off
= rtc_wake_off
;
1135 /* workaround bug in some ACPI tables */
1136 if (acpi_gbl_FADT
.month_alarm
&& !acpi_gbl_FADT
.day_alarm
) {
1137 dev_dbg(dev
, "bogus FADT month_alarm (%d)\n",
1138 acpi_gbl_FADT
.month_alarm
);
1139 acpi_gbl_FADT
.month_alarm
= 0;
1142 acpi_rtc_info
.rtc_day_alarm
= acpi_gbl_FADT
.day_alarm
;
1143 acpi_rtc_info
.rtc_mon_alarm
= acpi_gbl_FADT
.month_alarm
;
1144 acpi_rtc_info
.rtc_century
= acpi_gbl_FADT
.century
;
1146 /* NOTE: S4_RTC_WAKE is NOT currently useful to Linux */
1147 if (acpi_gbl_FADT
.flags
& ACPI_FADT_S4_RTC_WAKE
)
1148 dev_info(dev
, "RTC can wake from S4\n");
1150 dev
->platform_data
= &acpi_rtc_info
;
1152 /* RTC always wakes from S1/S2/S3, and often S4/STD */
1153 device_init_wakeup(dev
, 1);
1156 static void cmos_check_acpi_rtc_status(struct device
*dev
,
1157 unsigned char *rtc_control
)
1159 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
1160 acpi_event_status rtc_status
;
1163 if (acpi_gbl_FADT
.flags
& ACPI_FADT_FIXED_RTC
)
1166 status
= acpi_get_event_status(ACPI_EVENT_RTC
, &rtc_status
);
1167 if (ACPI_FAILURE(status
)) {
1168 dev_err(dev
, "Could not get RTC status\n");
1169 } else if (rtc_status
& ACPI_EVENT_FLAG_SET
) {
1171 *rtc_control
&= ~RTC_AIE
;
1172 CMOS_WRITE(*rtc_control
, RTC_CONTROL
);
1173 mask
= CMOS_READ(RTC_INTR_FLAGS
);
1174 rtc_update_irq(cmos
->rtc
, 1, mask
);
1180 static void cmos_wake_setup(struct device
*dev
)
1184 static void cmos_check_acpi_rtc_status(struct device
*dev
,
1185 unsigned char *rtc_control
)
1193 #include <linux/pnp.h>
1195 static int cmos_pnp_probe(struct pnp_dev
*pnp
, const struct pnp_device_id
*id
)
1197 cmos_wake_setup(&pnp
->dev
);
1199 if (pnp_port_start(pnp
, 0) == 0x70 && !pnp_irq_valid(pnp
, 0)) {
1200 unsigned int irq
= 0;
1202 /* Some machines contain a PNP entry for the RTC, but
1203 * don't define the IRQ. It should always be safe to
1204 * hardcode it on systems with a legacy PIC.
1206 if (nr_legacy_irqs())
1209 return cmos_do_probe(&pnp
->dev
,
1210 pnp_get_resource(pnp
, IORESOURCE_IO
, 0), irq
);
1212 return cmos_do_probe(&pnp
->dev
,
1213 pnp_get_resource(pnp
, IORESOURCE_IO
, 0),
1218 static void cmos_pnp_remove(struct pnp_dev
*pnp
)
1220 cmos_do_remove(&pnp
->dev
);
1223 static void cmos_pnp_shutdown(struct pnp_dev
*pnp
)
1225 struct device
*dev
= &pnp
->dev
;
1226 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
1228 if (system_state
== SYSTEM_POWER_OFF
) {
1229 int retval
= cmos_poweroff(dev
);
1231 if (cmos_aie_poweroff(dev
) < 0 && !retval
)
1235 cmos_do_shutdown(cmos
->irq
);
1238 static const struct pnp_device_id rtc_ids
[] = {
1239 { .id
= "PNP0b00", },
1240 { .id
= "PNP0b01", },
1241 { .id
= "PNP0b02", },
1244 MODULE_DEVICE_TABLE(pnp
, rtc_ids
);
1246 static struct pnp_driver cmos_pnp_driver
= {
1247 .name
= (char *) driver_name
,
1248 .id_table
= rtc_ids
,
1249 .probe
= cmos_pnp_probe
,
1250 .remove
= cmos_pnp_remove
,
1251 .shutdown
= cmos_pnp_shutdown
,
1253 /* flag ensures resume() gets called, and stops syslog spam */
1254 .flags
= PNP_DRIVER_RES_DO_NOT_CHANGE
,
1260 #endif /* CONFIG_PNP */
1263 static const struct of_device_id of_cmos_match
[] = {
1265 .compatible
= "motorola,mc146818",
1269 MODULE_DEVICE_TABLE(of
, of_cmos_match
);
1271 static __init
void cmos_of_init(struct platform_device
*pdev
)
1273 struct device_node
*node
= pdev
->dev
.of_node
;
1274 struct rtc_time time
;
1281 val
= of_get_property(node
, "ctrl-reg", NULL
);
1283 CMOS_WRITE(be32_to_cpup(val
), RTC_CONTROL
);
1285 val
= of_get_property(node
, "freq-reg", NULL
);
1287 CMOS_WRITE(be32_to_cpup(val
), RTC_FREQ_SELECT
);
1289 cmos_read_time(&pdev
->dev
, &time
);
1290 ret
= rtc_valid_tm(&time
);
1292 struct rtc_time def_time
= {
1296 cmos_set_time(&pdev
->dev
, &def_time
);
1300 static inline void cmos_of_init(struct platform_device
*pdev
) {}
1302 /*----------------------------------------------------------------*/
1304 /* Platform setup should have set up an RTC device, when PNP is
1305 * unavailable ... this could happen even on (older) PCs.
1308 static int __init
cmos_platform_probe(struct platform_device
*pdev
)
1310 struct resource
*resource
;
1314 cmos_wake_setup(&pdev
->dev
);
1317 resource
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
1319 resource
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1320 irq
= platform_get_irq(pdev
, 0);
1324 return cmos_do_probe(&pdev
->dev
, resource
, irq
);
1327 static int cmos_platform_remove(struct platform_device
*pdev
)
1329 cmos_do_remove(&pdev
->dev
);
1333 static void cmos_platform_shutdown(struct platform_device
*pdev
)
1335 struct device
*dev
= &pdev
->dev
;
1336 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
1338 if (system_state
== SYSTEM_POWER_OFF
) {
1339 int retval
= cmos_poweroff(dev
);
1341 if (cmos_aie_poweroff(dev
) < 0 && !retval
)
1345 cmos_do_shutdown(cmos
->irq
);
1348 /* work with hotplug and coldplug */
1349 MODULE_ALIAS("platform:rtc_cmos");
1351 static struct platform_driver cmos_platform_driver
= {
1352 .remove
= cmos_platform_remove
,
1353 .shutdown
= cmos_platform_shutdown
,
1355 .name
= driver_name
,
1357 .of_match_table
= of_match_ptr(of_cmos_match
),
1362 static bool pnp_driver_registered
;
1364 static bool platform_driver_registered
;
1366 static int __init
cmos_init(void)
1371 retval
= pnp_register_driver(&cmos_pnp_driver
);
1373 pnp_driver_registered
= true;
1376 if (!cmos_rtc
.dev
) {
1377 retval
= platform_driver_probe(&cmos_platform_driver
,
1378 cmos_platform_probe
);
1380 platform_driver_registered
= true;
1387 if (pnp_driver_registered
)
1388 pnp_unregister_driver(&cmos_pnp_driver
);
1392 module_init(cmos_init
);
1394 static void __exit
cmos_exit(void)
1397 if (pnp_driver_registered
)
1398 pnp_unregister_driver(&cmos_pnp_driver
);
1400 if (platform_driver_registered
)
1401 platform_driver_unregister(&cmos_platform_driver
);
1403 module_exit(cmos_exit
);
1406 MODULE_AUTHOR("David Brownell");
1407 MODULE_DESCRIPTION("Driver for PC-style 'CMOS' RTCs");
1408 MODULE_LICENSE("GPL");