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.
31 #include <linux/kernel.h>
32 #include <linux/module.h>
33 #include <linux/init.h>
34 #include <linux/interrupt.h>
35 #include <linux/spinlock.h>
36 #include <linux/platform_device.h>
37 #include <linux/mod_devicetable.h>
39 #ifdef CONFIG_HPET_EMULATE_RTC
43 /* this is for "generic access to PC-style RTC" using CMOS_READ/CMOS_WRITE */
44 #include <asm-generic/rtc.h>
46 #ifndef CONFIG_HPET_EMULATE_RTC
47 #define is_hpet_enabled() 0
48 #define hpet_set_alarm_time(hrs, min, sec) do { } while (0)
49 #define hpet_set_periodic_freq(arg) 0
50 #define hpet_mask_rtc_irq_bit(arg) do { } while (0)
51 #define hpet_set_rtc_irq_bit(arg) do { } while (0)
52 #define hpet_rtc_timer_init() do { } while (0)
53 #define hpet_register_irq_handler(h) 0
54 #define hpet_unregister_irq_handler(h) do { } while (0)
55 extern irqreturn_t
hpet_rtc_interrupt(int irq
, void *dev_id
);
59 struct rtc_device
*rtc
;
62 struct resource
*iomem
;
64 void (*wake_on
)(struct device
*);
65 void (*wake_off
)(struct device
*);
70 /* newer hardware extends the original register set */
76 /* both platform and pnp busses use negative numbers for invalid irqs */
77 #define is_valid_irq(n) ((n) >= 0)
79 static const char driver_name
[] = "rtc_cmos";
81 /* The RTC_INTR register may have e.g. RTC_PF set even if RTC_PIE is clear;
82 * always mask it against the irq enable bits in RTC_CONTROL. Bit values
83 * are the same: PF==PIE, AF=AIE, UF=UIE; so RTC_IRQMASK works with both.
85 #define RTC_IRQMASK (RTC_PF | RTC_AF | RTC_UF)
87 static inline int is_intr(u8 rtc_intr
)
89 if (!(rtc_intr
& RTC_IRQF
))
91 return rtc_intr
& RTC_IRQMASK
;
94 /*----------------------------------------------------------------*/
96 static int cmos_read_time(struct device
*dev
, struct rtc_time
*t
)
98 /* REVISIT: if the clock has a "century" register, use
99 * that instead of the heuristic in get_rtc_time().
100 * That'll make Y3K compatility (year > 2070) easy!
106 static int cmos_set_time(struct device
*dev
, struct rtc_time
*t
)
108 /* REVISIT: set the "century" register if available
110 * NOTE: this ignores the issue whereby updating the seconds
111 * takes effect exactly 500ms after we write the register.
112 * (Also queueing and other delays before we get this far.)
114 return set_rtc_time(t
);
117 static int cmos_read_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
119 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
120 unsigned char rtc_control
;
122 if (!is_valid_irq(cmos
->irq
))
125 /* Basic alarms only support hour, minute, and seconds fields.
126 * Some also support day and month, for alarms up to a year in
129 t
->time
.tm_mday
= -1;
132 spin_lock_irq(&rtc_lock
);
133 t
->time
.tm_sec
= CMOS_READ(RTC_SECONDS_ALARM
);
134 t
->time
.tm_min
= CMOS_READ(RTC_MINUTES_ALARM
);
135 t
->time
.tm_hour
= CMOS_READ(RTC_HOURS_ALARM
);
137 if (cmos
->day_alrm
) {
138 /* ignore upper bits on readback per ACPI spec */
139 t
->time
.tm_mday
= CMOS_READ(cmos
->day_alrm
) & 0x3f;
140 if (!t
->time
.tm_mday
)
141 t
->time
.tm_mday
= -1;
143 if (cmos
->mon_alrm
) {
144 t
->time
.tm_mon
= CMOS_READ(cmos
->mon_alrm
);
150 rtc_control
= CMOS_READ(RTC_CONTROL
);
151 spin_unlock_irq(&rtc_lock
);
153 /* REVISIT this assumes PC style usage: always BCD */
155 if (((unsigned)t
->time
.tm_sec
) < 0x60)
156 t
->time
.tm_sec
= BCD2BIN(t
->time
.tm_sec
);
159 if (((unsigned)t
->time
.tm_min
) < 0x60)
160 t
->time
.tm_min
= BCD2BIN(t
->time
.tm_min
);
163 if (((unsigned)t
->time
.tm_hour
) < 0x24)
164 t
->time
.tm_hour
= BCD2BIN(t
->time
.tm_hour
);
166 t
->time
.tm_hour
= -1;
168 if (cmos
->day_alrm
) {
169 if (((unsigned)t
->time
.tm_mday
) <= 0x31)
170 t
->time
.tm_mday
= BCD2BIN(t
->time
.tm_mday
);
172 t
->time
.tm_mday
= -1;
173 if (cmos
->mon_alrm
) {
174 if (((unsigned)t
->time
.tm_mon
) <= 0x12)
175 t
->time
.tm_mon
= BCD2BIN(t
->time
.tm_mon
) - 1;
180 t
->time
.tm_year
= -1;
182 t
->enabled
= !!(rtc_control
& RTC_AIE
);
188 static int cmos_set_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
190 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
191 unsigned char mon
, mday
, hrs
, min
, sec
;
192 unsigned char rtc_control
, rtc_intr
;
194 if (!is_valid_irq(cmos
->irq
))
197 /* REVISIT this assumes PC style usage: always BCD */
199 /* Writing 0xff means "don't care" or "match all". */
201 mon
= t
->time
.tm_mon
;
202 mon
= (mon
< 12) ? BIN2BCD(mon
) : 0xff;
205 mday
= t
->time
.tm_mday
;
206 mday
= (mday
>= 1 && mday
<= 31) ? BIN2BCD(mday
) : 0xff;
208 hrs
= t
->time
.tm_hour
;
209 hrs
= (hrs
< 24) ? BIN2BCD(hrs
) : 0xff;
211 min
= t
->time
.tm_min
;
212 min
= (min
< 60) ? BIN2BCD(min
) : 0xff;
214 sec
= t
->time
.tm_sec
;
215 sec
= (sec
< 60) ? BIN2BCD(sec
) : 0xff;
217 hpet_set_alarm_time(t
->time
.tm_hour
, t
->time
.tm_min
, t
->time
.tm_sec
);
218 spin_lock_irq(&rtc_lock
);
220 /* next rtc irq must not be from previous alarm setting */
221 rtc_control
= CMOS_READ(RTC_CONTROL
);
222 rtc_control
&= ~RTC_AIE
;
223 CMOS_WRITE(rtc_control
, RTC_CONTROL
);
224 rtc_intr
= CMOS_READ(RTC_INTR_FLAGS
);
225 rtc_intr
&= (rtc_control
& RTC_IRQMASK
) | RTC_IRQF
;
226 if (is_intr(rtc_intr
))
227 rtc_update_irq(cmos
->rtc
, 1, rtc_intr
);
230 CMOS_WRITE(hrs
, RTC_HOURS_ALARM
);
231 CMOS_WRITE(min
, RTC_MINUTES_ALARM
);
232 CMOS_WRITE(sec
, RTC_SECONDS_ALARM
);
234 /* the system may support an "enhanced" alarm */
235 if (cmos
->day_alrm
) {
236 CMOS_WRITE(mday
, cmos
->day_alrm
);
238 CMOS_WRITE(mon
, cmos
->mon_alrm
);
242 rtc_control
|= RTC_AIE
;
243 CMOS_WRITE(rtc_control
, RTC_CONTROL
);
244 rtc_intr
= CMOS_READ(RTC_INTR_FLAGS
);
245 rtc_intr
&= (rtc_control
& RTC_IRQMASK
) | RTC_IRQF
;
246 if (is_intr(rtc_intr
))
247 rtc_update_irq(cmos
->rtc
, 1, rtc_intr
);
250 spin_unlock_irq(&rtc_lock
);
255 static int cmos_irq_set_freq(struct device
*dev
, int freq
)
257 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
261 if (!is_valid_irq(cmos
->irq
))
264 /* 0 = no irqs; 1 = 2^15 Hz ... 15 = 2^0 Hz */
270 spin_lock_irqsave(&rtc_lock
, flags
);
271 if (!hpet_set_periodic_freq(freq
))
272 CMOS_WRITE(RTC_REF_CLCK_32KHZ
| f
, RTC_FREQ_SELECT
);
273 spin_unlock_irqrestore(&rtc_lock
, flags
);
278 static int cmos_irq_set_state(struct device
*dev
, int enabled
)
280 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
281 unsigned char rtc_control
, rtc_intr
;
284 if (!is_valid_irq(cmos
->irq
))
287 spin_lock_irqsave(&rtc_lock
, flags
);
288 rtc_control
= CMOS_READ(RTC_CONTROL
);
291 rtc_control
|= RTC_PIE
;
293 rtc_control
&= ~RTC_PIE
;
295 CMOS_WRITE(rtc_control
, RTC_CONTROL
);
297 rtc_intr
= CMOS_READ(RTC_INTR_FLAGS
);
298 rtc_intr
&= (rtc_control
& RTC_IRQMASK
) | RTC_IRQF
;
299 if (is_intr(rtc_intr
))
300 rtc_update_irq(cmos
->rtc
, 1, rtc_intr
);
302 spin_unlock_irqrestore(&rtc_lock
, flags
);
306 #if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE)
309 cmos_rtc_ioctl(struct device
*dev
, unsigned int cmd
, unsigned long arg
)
311 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
312 unsigned char rtc_control
, rtc_intr
;
322 if (!is_valid_irq(cmos
->irq
))
329 spin_lock_irqsave(&rtc_lock
, flags
);
330 rtc_control
= CMOS_READ(RTC_CONTROL
);
332 case RTC_AIE_OFF
: /* alarm off */
333 rtc_control
&= ~RTC_AIE
;
334 hpet_mask_rtc_irq_bit(RTC_AIE
);
336 case RTC_AIE_ON
: /* alarm on */
337 rtc_control
|= RTC_AIE
;
338 hpet_set_rtc_irq_bit(RTC_AIE
);
340 case RTC_UIE_OFF
: /* update off */
341 rtc_control
&= ~RTC_UIE
;
342 hpet_mask_rtc_irq_bit(RTC_UIE
);
344 case RTC_UIE_ON
: /* update on */
345 rtc_control
|= RTC_UIE
;
346 hpet_set_rtc_irq_bit(RTC_UIE
);
348 case RTC_PIE_OFF
: /* periodic off */
349 rtc_control
&= ~RTC_PIE
;
350 hpet_mask_rtc_irq_bit(RTC_PIE
);
352 case RTC_PIE_ON
: /* periodic on */
353 rtc_control
|= RTC_PIE
;
354 hpet_set_rtc_irq_bit(RTC_PIE
);
357 if (!is_hpet_enabled())
358 CMOS_WRITE(rtc_control
, RTC_CONTROL
);
360 rtc_intr
= CMOS_READ(RTC_INTR_FLAGS
);
361 rtc_intr
&= (rtc_control
& RTC_IRQMASK
) | RTC_IRQF
;
362 if (is_intr(rtc_intr
))
363 rtc_update_irq(cmos
->rtc
, 1, rtc_intr
);
365 spin_unlock_irqrestore(&rtc_lock
, flags
);
370 #define cmos_rtc_ioctl NULL
373 #if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
375 static int cmos_procfs(struct device
*dev
, struct seq_file
*seq
)
377 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
378 unsigned char rtc_control
, valid
;
380 spin_lock_irq(&rtc_lock
);
381 rtc_control
= CMOS_READ(RTC_CONTROL
);
382 valid
= CMOS_READ(RTC_VALID
);
383 spin_unlock_irq(&rtc_lock
);
385 /* NOTE: at least ICH6 reports battery status using a different
386 * (non-RTC) bit; and SQWE is ignored on many current systems.
388 return seq_printf(seq
,
389 "periodic_IRQ\t: %s\n"
391 "HPET_emulated\t: %s\n"
392 // "square_wave\t: %s\n"
395 "periodic_freq\t: %d\n"
396 "batt_status\t: %s\n",
397 (rtc_control
& RTC_PIE
) ? "yes" : "no",
398 (rtc_control
& RTC_UIE
) ? "yes" : "no",
399 is_hpet_enabled() ? "yes" : "no",
400 // (rtc_control & RTC_SQWE) ? "yes" : "no",
401 // (rtc_control & RTC_DM_BINARY) ? "no" : "yes",
402 (rtc_control
& RTC_DST_EN
) ? "yes" : "no",
404 (valid
& RTC_VRT
) ? "okay" : "dead");
408 #define cmos_procfs NULL
411 static const struct rtc_class_ops cmos_rtc_ops
= {
412 .ioctl
= cmos_rtc_ioctl
,
413 .read_time
= cmos_read_time
,
414 .set_time
= cmos_set_time
,
415 .read_alarm
= cmos_read_alarm
,
416 .set_alarm
= cmos_set_alarm
,
418 .irq_set_freq
= cmos_irq_set_freq
,
419 .irq_set_state
= cmos_irq_set_state
,
422 /*----------------------------------------------------------------*/
425 * All these chips have at least 64 bytes of address space, shared by
426 * RTC registers and NVRAM. Most of those bytes of NVRAM are used
427 * by boot firmware. Modern chips have 128 or 256 bytes.
430 #define NVRAM_OFFSET (RTC_REG_D + 1)
433 cmos_nvram_read(struct kobject
*kobj
, struct bin_attribute
*attr
,
434 char *buf
, loff_t off
, size_t count
)
438 if (unlikely(off
>= attr
->size
))
440 if ((off
+ count
) > attr
->size
)
441 count
= attr
->size
- off
;
443 spin_lock_irq(&rtc_lock
);
444 for (retval
= 0, off
+= NVRAM_OFFSET
; count
--; retval
++, off
++)
445 *buf
++ = CMOS_READ(off
);
446 spin_unlock_irq(&rtc_lock
);
452 cmos_nvram_write(struct kobject
*kobj
, struct bin_attribute
*attr
,
453 char *buf
, loff_t off
, size_t count
)
455 struct cmos_rtc
*cmos
;
458 cmos
= dev_get_drvdata(container_of(kobj
, struct device
, kobj
));
459 if (unlikely(off
>= attr
->size
))
461 if ((off
+ count
) > attr
->size
)
462 count
= attr
->size
- off
;
464 /* NOTE: on at least PCs and Ataris, the boot firmware uses a
465 * checksum on part of the NVRAM data. That's currently ignored
466 * here. If userspace is smart enough to know what fields of
467 * NVRAM to update, updating checksums is also part of its job.
469 spin_lock_irq(&rtc_lock
);
470 for (retval
= 0, off
+= NVRAM_OFFSET
; count
--; retval
++, off
++) {
471 /* don't trash RTC registers */
472 if (off
== cmos
->day_alrm
473 || off
== cmos
->mon_alrm
474 || off
== cmos
->century
)
477 CMOS_WRITE(*buf
++, off
);
479 spin_unlock_irq(&rtc_lock
);
484 static struct bin_attribute nvram
= {
487 .mode
= S_IRUGO
| S_IWUSR
,
488 .owner
= THIS_MODULE
,
491 .read
= cmos_nvram_read
,
492 .write
= cmos_nvram_write
,
493 /* size gets set up later */
496 /*----------------------------------------------------------------*/
498 static struct cmos_rtc cmos_rtc
;
500 static irqreturn_t
cmos_interrupt(int irq
, void *p
)
505 spin_lock(&rtc_lock
);
507 * In this case it is HPET RTC interrupt handler
508 * calling us, with the interrupt information
509 * passed as arg1, instead of irq.
511 if (is_hpet_enabled())
512 irqstat
= (unsigned long)irq
& 0xF0;
514 irqstat
= CMOS_READ(RTC_INTR_FLAGS
);
515 rtc_control
= CMOS_READ(RTC_CONTROL
);
516 irqstat
&= (rtc_control
& RTC_IRQMASK
) | RTC_IRQF
;
519 /* All Linux RTC alarms should be treated as if they were oneshot.
520 * Similar code may be needed in system wakeup paths, in case the
521 * alarm woke the system.
523 if (irqstat
& RTC_AIE
) {
524 rtc_control
= CMOS_READ(RTC_CONTROL
);
525 rtc_control
&= ~RTC_AIE
;
526 CMOS_WRITE(rtc_control
, RTC_CONTROL
);
527 CMOS_READ(RTC_INTR_FLAGS
);
529 spin_unlock(&rtc_lock
);
531 if (is_intr(irqstat
)) {
532 rtc_update_irq(p
, 1, irqstat
);
542 #define INITSECTION __init
545 static int INITSECTION
546 cmos_do_probe(struct device
*dev
, struct resource
*ports
, int rtc_irq
)
548 struct cmos_rtc_board_info
*info
= dev
->platform_data
;
550 unsigned char rtc_control
;
551 unsigned address_space
;
553 /* there can be only one ... */
560 /* Claim I/O ports ASAP, minimizing conflict with legacy driver.
562 * REVISIT non-x86 systems may instead use memory space resources
563 * (needing ioremap etc), not i/o space resources like this ...
565 ports
= request_region(ports
->start
,
566 ports
->end
+ 1 - ports
->start
,
569 dev_dbg(dev
, "i/o registers already in use\n");
573 cmos_rtc
.irq
= rtc_irq
;
574 cmos_rtc
.iomem
= ports
;
576 /* Heuristic to deduce NVRAM size ... do what the legacy NVRAM
577 * driver did, but don't reject unknown configs. Old hardware
578 * won't address 128 bytes, and for now we ignore the way newer
579 * chips can address 256 bytes (using two more i/o ports).
581 #if defined(CONFIG_ATARI)
583 #elif defined(__i386__) || defined(__x86_64__) || defined(__arm__)
586 #warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes.
590 /* For ACPI systems extension info comes from the FADT. On others,
591 * board specific setup provides it as appropriate. Systems where
592 * the alarm IRQ isn't automatically a wakeup IRQ (like ACPI, and
593 * some almost-clones) can provide hooks to make that behave.
595 * Note that ACPI doesn't preclude putting these registers into
596 * "extended" areas of the chip, including some that we won't yet
597 * expect CMOS_READ and friends to handle.
600 if (info
->rtc_day_alarm
&& info
->rtc_day_alarm
< 128)
601 cmos_rtc
.day_alrm
= info
->rtc_day_alarm
;
602 if (info
->rtc_mon_alarm
&& info
->rtc_mon_alarm
< 128)
603 cmos_rtc
.mon_alrm
= info
->rtc_mon_alarm
;
604 if (info
->rtc_century
&& info
->rtc_century
< 128)
605 cmos_rtc
.century
= info
->rtc_century
;
607 if (info
->wake_on
&& info
->wake_off
) {
608 cmos_rtc
.wake_on
= info
->wake_on
;
609 cmos_rtc
.wake_off
= info
->wake_off
;
613 cmos_rtc
.rtc
= rtc_device_register(driver_name
, dev
,
614 &cmos_rtc_ops
, THIS_MODULE
);
615 if (IS_ERR(cmos_rtc
.rtc
)) {
616 retval
= PTR_ERR(cmos_rtc
.rtc
);
621 dev_set_drvdata(dev
, &cmos_rtc
);
622 rename_region(ports
, cmos_rtc
.rtc
->dev
.bus_id
);
624 spin_lock_irq(&rtc_lock
);
626 /* force periodic irq to CMOS reset default of 1024Hz;
628 * REVISIT it's been reported that at least one x86_64 ALI mobo
629 * doesn't use 32KHz here ... for portability we might need to
630 * do something about other clock frequencies.
632 cmos_rtc
.rtc
->irq_freq
= 1024;
633 if (!hpet_set_periodic_freq(cmos_rtc
.rtc
->irq_freq
))
634 CMOS_WRITE(RTC_REF_CLCK_32KHZ
| 0x06, RTC_FREQ_SELECT
);
638 * NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
639 * allegedly some older rtcs need that to handle irqs properly
641 rtc_control
= CMOS_READ(RTC_CONTROL
);
642 rtc_control
&= ~(RTC_PIE
| RTC_AIE
| RTC_UIE
);
643 CMOS_WRITE(rtc_control
, RTC_CONTROL
);
644 CMOS_READ(RTC_INTR_FLAGS
);
646 spin_unlock_irq(&rtc_lock
);
648 /* FIXME teach the alarm code how to handle binary mode;
649 * <asm-generic/rtc.h> doesn't know 12-hour mode either.
651 if (!(rtc_control
& RTC_24H
) || (rtc_control
& (RTC_DM_BINARY
))) {
652 dev_dbg(dev
, "only 24-hr BCD mode supported\n");
657 if (is_valid_irq(rtc_irq
)) {
658 irq_handler_t rtc_cmos_int_handler
;
660 if (is_hpet_enabled()) {
663 rtc_cmos_int_handler
= hpet_rtc_interrupt
;
664 err
= hpet_register_irq_handler(cmos_interrupt
);
666 printk(KERN_WARNING
"hpet_register_irq_handler "
667 " failed in rtc_init().");
671 rtc_cmos_int_handler
= cmos_interrupt
;
673 retval
= request_irq(rtc_irq
, rtc_cmos_int_handler
,
674 IRQF_DISABLED
, cmos_rtc
.rtc
->dev
.bus_id
,
677 dev_dbg(dev
, "IRQ %d is already in use\n", rtc_irq
);
681 hpet_rtc_timer_init();
683 /* export at least the first block of NVRAM */
684 nvram
.size
= address_space
- NVRAM_OFFSET
;
685 retval
= sysfs_create_bin_file(&dev
->kobj
, &nvram
);
687 dev_dbg(dev
, "can't create nvram file? %d\n", retval
);
691 pr_info("%s: alarms up to one %s%s\n",
692 cmos_rtc
.rtc
->dev
.bus_id
,
693 is_valid_irq(rtc_irq
)
699 cmos_rtc
.century
? ", y3k" : ""
705 if (is_valid_irq(rtc_irq
))
706 free_irq(rtc_irq
, cmos_rtc
.rtc
);
709 rtc_device_unregister(cmos_rtc
.rtc
);
711 release_region(ports
->start
, ports
->end
+ 1 - ports
->start
);
715 static void cmos_do_shutdown(void)
717 unsigned char rtc_control
;
719 spin_lock_irq(&rtc_lock
);
720 rtc_control
= CMOS_READ(RTC_CONTROL
);
721 rtc_control
&= ~(RTC_PIE
|RTC_AIE
|RTC_UIE
);
722 CMOS_WRITE(rtc_control
, RTC_CONTROL
);
723 CMOS_READ(RTC_INTR_FLAGS
);
724 spin_unlock_irq(&rtc_lock
);
727 static void __exit
cmos_do_remove(struct device
*dev
)
729 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
730 struct resource
*ports
;
734 sysfs_remove_bin_file(&dev
->kobj
, &nvram
);
736 if (is_valid_irq(cmos
->irq
)) {
737 free_irq(cmos
->irq
, cmos
->rtc
);
738 hpet_unregister_irq_handler(cmos_interrupt
);
741 rtc_device_unregister(cmos
->rtc
);
745 release_region(ports
->start
, ports
->end
+ 1 - ports
->start
);
749 dev_set_drvdata(dev
, NULL
);
754 static int cmos_suspend(struct device
*dev
, pm_message_t mesg
)
756 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
757 int do_wake
= device_may_wakeup(dev
);
760 /* only the alarm might be a wakeup event source */
761 spin_lock_irq(&rtc_lock
);
762 cmos
->suspend_ctrl
= tmp
= CMOS_READ(RTC_CONTROL
);
763 if (tmp
& (RTC_PIE
|RTC_AIE
|RTC_UIE
)) {
764 unsigned char irqstat
;
767 tmp
&= ~(RTC_PIE
|RTC_UIE
);
769 tmp
&= ~(RTC_PIE
|RTC_AIE
|RTC_UIE
);
770 CMOS_WRITE(tmp
, RTC_CONTROL
);
771 irqstat
= CMOS_READ(RTC_INTR_FLAGS
);
772 irqstat
&= (tmp
& RTC_IRQMASK
) | RTC_IRQF
;
773 if (is_intr(irqstat
))
774 rtc_update_irq(cmos
->rtc
, 1, irqstat
);
776 spin_unlock_irq(&rtc_lock
);
779 cmos
->enabled_wake
= 1;
783 enable_irq_wake(cmos
->irq
);
786 pr_debug("%s: suspend%s, ctrl %02x\n",
787 cmos_rtc
.rtc
->dev
.bus_id
,
788 (tmp
& RTC_AIE
) ? ", alarm may wake" : "",
794 static int cmos_resume(struct device
*dev
)
796 struct cmos_rtc
*cmos
= dev_get_drvdata(dev
);
797 unsigned char tmp
= cmos
->suspend_ctrl
;
799 /* re-enable any irqs previously active */
800 if (tmp
& (RTC_PIE
|RTC_AIE
|RTC_UIE
)) {
802 if (cmos
->enabled_wake
) {
806 disable_irq_wake(cmos
->irq
);
807 cmos
->enabled_wake
= 0;
810 spin_lock_irq(&rtc_lock
);
811 CMOS_WRITE(tmp
, RTC_CONTROL
);
812 tmp
= CMOS_READ(RTC_INTR_FLAGS
);
813 tmp
&= (cmos
->suspend_ctrl
& RTC_IRQMASK
) | RTC_IRQF
;
815 rtc_update_irq(cmos
->rtc
, 1, tmp
);
816 spin_unlock_irq(&rtc_lock
);
819 pr_debug("%s: resume, ctrl %02x\n",
820 cmos_rtc
.rtc
->dev
.bus_id
,
828 #define cmos_suspend NULL
829 #define cmos_resume NULL
832 /*----------------------------------------------------------------*/
834 /* On non-x86 systems, a "CMOS" RTC lives most naturally on platform_bus.
835 * ACPI systems always list these as PNPACPI devices, and pre-ACPI PCs
836 * probably list them in similar PNPBIOS tables; so PNP is more common.
838 * We don't use legacy "poke at the hardware" probing. Ancient PCs that
839 * predate even PNPBIOS should set up platform_bus devices.
844 #include <linux/pnp.h>
847 cmos_pnp_probe(struct pnp_dev
*pnp
, const struct pnp_device_id
*id
)
849 /* REVISIT paranoia argues for a shutdown notifier, since PNP
850 * drivers can't provide shutdown() methods to disable IRQs.
851 * Or better yet, fix PNP to allow those methods...
853 if (pnp_port_start(pnp
,0) == 0x70 && !pnp_irq_valid(pnp
,0))
854 /* Some machines contain a PNP entry for the RTC, but
855 * don't define the IRQ. It should always be safe to
856 * hardcode it in these cases
858 return cmos_do_probe(&pnp
->dev
, &pnp
->res
.port_resource
[0], 8);
860 return cmos_do_probe(&pnp
->dev
,
861 &pnp
->res
.port_resource
[0],
862 pnp
->res
.irq_resource
[0].start
);
865 static void __exit
cmos_pnp_remove(struct pnp_dev
*pnp
)
867 cmos_do_remove(&pnp
->dev
);
872 static int cmos_pnp_suspend(struct pnp_dev
*pnp
, pm_message_t mesg
)
874 return cmos_suspend(&pnp
->dev
, mesg
);
877 static int cmos_pnp_resume(struct pnp_dev
*pnp
)
879 return cmos_resume(&pnp
->dev
);
883 #define cmos_pnp_suspend NULL
884 #define cmos_pnp_resume NULL
888 static const struct pnp_device_id rtc_ids
[] = {
889 { .id
= "PNP0b00", },
890 { .id
= "PNP0b01", },
891 { .id
= "PNP0b02", },
894 MODULE_DEVICE_TABLE(pnp
, rtc_ids
);
896 static struct pnp_driver cmos_pnp_driver
= {
897 .name
= (char *) driver_name
,
899 .probe
= cmos_pnp_probe
,
900 .remove
= __exit_p(cmos_pnp_remove
),
902 /* flag ensures resume() gets called, and stops syslog spam */
903 .flags
= PNP_DRIVER_RES_DO_NOT_CHANGE
,
904 .suspend
= cmos_pnp_suspend
,
905 .resume
= cmos_pnp_resume
,
908 static int __init
cmos_init(void)
910 return pnp_register_driver(&cmos_pnp_driver
);
912 module_init(cmos_init
);
914 static void __exit
cmos_exit(void)
916 pnp_unregister_driver(&cmos_pnp_driver
);
918 module_exit(cmos_exit
);
922 /*----------------------------------------------------------------*/
924 /* Platform setup should have set up an RTC device, when PNP is
925 * unavailable ... this could happen even on (older) PCs.
928 static int __init
cmos_platform_probe(struct platform_device
*pdev
)
930 return cmos_do_probe(&pdev
->dev
,
931 platform_get_resource(pdev
, IORESOURCE_IO
, 0),
932 platform_get_irq(pdev
, 0));
935 static int __exit
cmos_platform_remove(struct platform_device
*pdev
)
937 cmos_do_remove(&pdev
->dev
);
941 static void cmos_platform_shutdown(struct platform_device
*pdev
)
946 /* work with hotplug and coldplug */
947 MODULE_ALIAS("platform:rtc_cmos");
949 static struct platform_driver cmos_platform_driver
= {
950 .remove
= __exit_p(cmos_platform_remove
),
951 .shutdown
= cmos_platform_shutdown
,
953 .name
= (char *) driver_name
,
954 .suspend
= cmos_suspend
,
955 .resume
= cmos_resume
,
959 static int __init
cmos_init(void)
961 return platform_driver_probe(&cmos_platform_driver
,
962 cmos_platform_probe
);
964 module_init(cmos_init
);
966 static void __exit
cmos_exit(void)
968 platform_driver_unregister(&cmos_platform_driver
);
970 module_exit(cmos_exit
);
975 MODULE_AUTHOR("David Brownell");
976 MODULE_DESCRIPTION("Driver for PC-style 'CMOS' RTCs");
977 MODULE_LICENSE("GPL");