blob: 957365e4a746d9108eb3dcc2ee335481770ccd4f [file] [log] [blame]
David Brownell7be2c7c2007-02-10 01:46:02 -08001/*
2 * RTC class driver for "CMOS RTC": PCs, ACPI, etc
3 *
4 * Copyright (C) 1996 Paul Gortmaker (drivers/char/rtc.c)
5 * Copyright (C) 2006 David Brownell (convert to new framework)
6 *
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.
11 */
12
13/*
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.
20 *
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).
26 *
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.
30 */
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>
38
39/* this is for "generic access to PC-style RTC" using CMOS_READ/CMOS_WRITE */
40#include <asm-generic/rtc.h>
41
David Brownell7be2c7c2007-02-10 01:46:02 -080042struct cmos_rtc {
43 struct rtc_device *rtc;
44 struct device *dev;
45 int irq;
46 struct resource *iomem;
47
David Brownell87ac84f2007-05-08 00:34:00 -070048 void (*wake_on)(struct device *);
49 void (*wake_off)(struct device *);
50
51 u8 enabled_wake;
David Brownell7be2c7c2007-02-10 01:46:02 -080052 u8 suspend_ctrl;
53
54 /* newer hardware extends the original register set */
55 u8 day_alrm;
56 u8 mon_alrm;
57 u8 century;
58};
59
60/* both platform and pnp busses use negative numbers for invalid irqs */
61#define is_valid_irq(n) ((n) >= 0)
62
63static const char driver_name[] = "rtc_cmos";
64
David Brownellbcd9b892007-04-01 23:49:47 -070065/* The RTC_INTR register may have e.g. RTC_PF set even if RTC_PIE is clear;
66 * always mask it against the irq enable bits in RTC_CONTROL. Bit values
67 * are the same: PF==PIE, AF=AIE, UF=UIE; so RTC_IRQMASK works with both.
68 */
69#define RTC_IRQMASK (RTC_PF | RTC_AF | RTC_UF)
70
71static inline int is_intr(u8 rtc_intr)
72{
73 if (!(rtc_intr & RTC_IRQF))
74 return 0;
75 return rtc_intr & RTC_IRQMASK;
76}
77
David Brownell7be2c7c2007-02-10 01:46:02 -080078/*----------------------------------------------------------------*/
79
David Brownell35d3fdd2008-07-23 21:30:43 -070080/* Much modern x86 hardware has HPETs (10+ MHz timers) which, because
81 * many BIOS programmers don't set up "sane mode" IRQ routing, are mostly
82 * used in a broken "legacy replacement" mode. The breakage includes
83 * HPET #1 hijacking the IRQ for this RTC, and being unavailable for
84 * other (better) use.
85 *
86 * When that broken mode is in use, platform glue provides a partial
87 * emulation of hardware RTC IRQ facilities using HPET #1. We don't
88 * want to use HPET for anything except those IRQs though...
89 */
90#ifdef CONFIG_HPET_EMULATE_RTC
91#include <asm/hpet.h>
92#else
93
94static inline int is_hpet_enabled(void)
95{
96 return 0;
97}
98
99static inline int hpet_mask_rtc_irq_bit(unsigned long mask)
100{
101 return 0;
102}
103
104static inline int hpet_set_rtc_irq_bit(unsigned long mask)
105{
106 return 0;
107}
108
109static inline int
110hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
111{
112 return 0;
113}
114
115static inline int hpet_set_periodic_freq(unsigned long freq)
116{
117 return 0;
118}
119
120static inline int hpet_rtc_dropped_irq(void)
121{
122 return 0;
123}
124
125static inline int hpet_rtc_timer_init(void)
126{
127 return 0;
128}
129
130extern irq_handler_t hpet_rtc_interrupt;
131
132static inline int hpet_register_irq_handler(irq_handler_t handler)
133{
134 return 0;
135}
136
137static inline int hpet_unregister_irq_handler(irq_handler_t handler)
138{
139 return 0;
140}
141
142#endif
143
144/*----------------------------------------------------------------*/
145
David Brownellc8fc40c2008-10-18 20:27:47 -0700146#ifdef RTC_PORT
147
148/* Most newer x86 systems have two register banks, the first used
149 * for RTC and NVRAM and the second only for NVRAM. Caller must
150 * own rtc_lock ... and we won't worry about access during NMI.
151 */
152#define can_bank2 true
153
154static inline unsigned char cmos_read_bank2(unsigned char addr)
155{
156 outb(addr, RTC_PORT(2));
157 return inb(RTC_PORT(3));
158}
159
160static inline void cmos_write_bank2(unsigned char val, unsigned char addr)
161{
162 outb(addr, RTC_PORT(2));
163 outb(val, RTC_PORT(2));
164}
165
166#else
167
168#define can_bank2 false
169
170static inline unsigned char cmos_read_bank2(unsigned char addr)
171{
172 return 0;
173}
174
175static inline void cmos_write_bank2(unsigned char val, unsigned char addr)
176{
177}
178
179#endif
180
181/*----------------------------------------------------------------*/
182
David Brownell7be2c7c2007-02-10 01:46:02 -0800183static int cmos_read_time(struct device *dev, struct rtc_time *t)
184{
185 /* REVISIT: if the clock has a "century" register, use
186 * that instead of the heuristic in get_rtc_time().
187 * That'll make Y3K compatility (year > 2070) easy!
188 */
189 get_rtc_time(t);
190 return 0;
191}
192
193static int cmos_set_time(struct device *dev, struct rtc_time *t)
194{
195 /* REVISIT: set the "century" register if available
196 *
197 * NOTE: this ignores the issue whereby updating the seconds
198 * takes effect exactly 500ms after we write the register.
199 * (Also queueing and other delays before we get this far.)
200 */
201 return set_rtc_time(t);
202}
203
204static int cmos_read_alarm(struct device *dev, struct rtc_wkalrm *t)
205{
206 struct cmos_rtc *cmos = dev_get_drvdata(dev);
207 unsigned char rtc_control;
208
209 if (!is_valid_irq(cmos->irq))
210 return -EIO;
211
212 /* Basic alarms only support hour, minute, and seconds fields.
213 * Some also support day and month, for alarms up to a year in
214 * the future.
215 */
216 t->time.tm_mday = -1;
217 t->time.tm_mon = -1;
218
219 spin_lock_irq(&rtc_lock);
220 t->time.tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
221 t->time.tm_min = CMOS_READ(RTC_MINUTES_ALARM);
222 t->time.tm_hour = CMOS_READ(RTC_HOURS_ALARM);
223
224 if (cmos->day_alrm) {
Mark Lord615bb292007-11-03 22:04:03 -0400225 /* ignore upper bits on readback per ACPI spec */
226 t->time.tm_mday = CMOS_READ(cmos->day_alrm) & 0x3f;
David Brownell7be2c7c2007-02-10 01:46:02 -0800227 if (!t->time.tm_mday)
228 t->time.tm_mday = -1;
229
230 if (cmos->mon_alrm) {
231 t->time.tm_mon = CMOS_READ(cmos->mon_alrm);
232 if (!t->time.tm_mon)
233 t->time.tm_mon = -1;
234 }
235 }
236
237 rtc_control = CMOS_READ(RTC_CONTROL);
238 spin_unlock_irq(&rtc_lock);
239
240 /* REVISIT this assumes PC style usage: always BCD */
241
242 if (((unsigned)t->time.tm_sec) < 0x60)
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700243 t->time.tm_sec = bcd2bin(t->time.tm_sec);
David Brownell7be2c7c2007-02-10 01:46:02 -0800244 else
245 t->time.tm_sec = -1;
246 if (((unsigned)t->time.tm_min) < 0x60)
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700247 t->time.tm_min = bcd2bin(t->time.tm_min);
David Brownell7be2c7c2007-02-10 01:46:02 -0800248 else
249 t->time.tm_min = -1;
250 if (((unsigned)t->time.tm_hour) < 0x24)
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700251 t->time.tm_hour = bcd2bin(t->time.tm_hour);
David Brownell7be2c7c2007-02-10 01:46:02 -0800252 else
253 t->time.tm_hour = -1;
254
255 if (cmos->day_alrm) {
256 if (((unsigned)t->time.tm_mday) <= 0x31)
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700257 t->time.tm_mday = bcd2bin(t->time.tm_mday);
David Brownell7be2c7c2007-02-10 01:46:02 -0800258 else
259 t->time.tm_mday = -1;
260 if (cmos->mon_alrm) {
261 if (((unsigned)t->time.tm_mon) <= 0x12)
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700262 t->time.tm_mon = bcd2bin(t->time.tm_mon) - 1;
David Brownell7be2c7c2007-02-10 01:46:02 -0800263 else
264 t->time.tm_mon = -1;
265 }
266 }
267 t->time.tm_year = -1;
268
269 t->enabled = !!(rtc_control & RTC_AIE);
270 t->pending = 0;
271
272 return 0;
273}
274
David Brownell7e2a31d2008-07-23 21:30:47 -0700275static void cmos_checkintr(struct cmos_rtc *cmos, unsigned char rtc_control)
276{
277 unsigned char rtc_intr;
278
279 /* NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
280 * allegedly some older rtcs need that to handle irqs properly
281 */
282 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
283
284 if (is_hpet_enabled())
285 return;
286
287 rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
288 if (is_intr(rtc_intr))
289 rtc_update_irq(cmos->rtc, 1, rtc_intr);
290}
291
292static void cmos_irq_enable(struct cmos_rtc *cmos, unsigned char mask)
293{
294 unsigned char rtc_control;
295
296 /* flush any pending IRQ status, notably for update irqs,
297 * before we enable new IRQs
298 */
299 rtc_control = CMOS_READ(RTC_CONTROL);
300 cmos_checkintr(cmos, rtc_control);
301
302 rtc_control |= mask;
303 CMOS_WRITE(rtc_control, RTC_CONTROL);
304 hpet_set_rtc_irq_bit(mask);
305
306 cmos_checkintr(cmos, rtc_control);
307}
308
309static void cmos_irq_disable(struct cmos_rtc *cmos, unsigned char mask)
310{
311 unsigned char rtc_control;
312
313 rtc_control = CMOS_READ(RTC_CONTROL);
314 rtc_control &= ~mask;
315 CMOS_WRITE(rtc_control, RTC_CONTROL);
316 hpet_mask_rtc_irq_bit(mask);
317
318 cmos_checkintr(cmos, rtc_control);
319}
320
David Brownell7be2c7c2007-02-10 01:46:02 -0800321static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
322{
323 struct cmos_rtc *cmos = dev_get_drvdata(dev);
324 unsigned char mon, mday, hrs, min, sec;
David Brownell7be2c7c2007-02-10 01:46:02 -0800325
326 if (!is_valid_irq(cmos->irq))
327 return -EIO;
328
329 /* REVISIT this assumes PC style usage: always BCD */
330
331 /* Writing 0xff means "don't care" or "match all". */
332
Zhao Yakui2b653e02008-04-15 14:34:29 -0700333 mon = t->time.tm_mon + 1;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700334 mon = (mon <= 12) ? bin2bcd(mon) : 0xff;
David Brownell7be2c7c2007-02-10 01:46:02 -0800335
336 mday = t->time.tm_mday;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700337 mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
David Brownell7be2c7c2007-02-10 01:46:02 -0800338
339 hrs = t->time.tm_hour;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700340 hrs = (hrs < 24) ? bin2bcd(hrs) : 0xff;
David Brownell7be2c7c2007-02-10 01:46:02 -0800341
342 min = t->time.tm_min;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700343 min = (min < 60) ? bin2bcd(min) : 0xff;
David Brownell7be2c7c2007-02-10 01:46:02 -0800344
345 sec = t->time.tm_sec;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700346 sec = (sec < 60) ? bin2bcd(sec) : 0xff;
David Brownell7be2c7c2007-02-10 01:46:02 -0800347
348 spin_lock_irq(&rtc_lock);
349
350 /* next rtc irq must not be from previous alarm setting */
David Brownell7e2a31d2008-07-23 21:30:47 -0700351 cmos_irq_disable(cmos, RTC_AIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800352
353 /* update alarm */
354 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
355 CMOS_WRITE(min, RTC_MINUTES_ALARM);
356 CMOS_WRITE(sec, RTC_SECONDS_ALARM);
357
358 /* the system may support an "enhanced" alarm */
359 if (cmos->day_alrm) {
360 CMOS_WRITE(mday, cmos->day_alrm);
361 if (cmos->mon_alrm)
362 CMOS_WRITE(mon, cmos->mon_alrm);
363 }
364
David Brownell35d3fdd2008-07-23 21:30:43 -0700365 /* FIXME the HPET alarm glue currently ignores day_alrm
366 * and mon_alrm ...
367 */
368 hpet_set_alarm_time(t->time.tm_hour, t->time.tm_min, t->time.tm_sec);
369
David Brownell7e2a31d2008-07-23 21:30:47 -0700370 if (t->enabled)
371 cmos_irq_enable(cmos, RTC_AIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800372
373 spin_unlock_irq(&rtc_lock);
374
375 return 0;
376}
377
Alessandro Zummo57deb522007-07-19 01:49:21 -0700378static int cmos_irq_set_freq(struct device *dev, int freq)
David Brownell7be2c7c2007-02-10 01:46:02 -0800379{
380 struct cmos_rtc *cmos = dev_get_drvdata(dev);
381 int f;
382 unsigned long flags;
383
384 if (!is_valid_irq(cmos->irq))
385 return -ENXIO;
386
387 /* 0 = no irqs; 1 = 2^15 Hz ... 15 = 2^0 Hz */
388 f = ffs(freq);
David Brownell97144c62007-10-16 01:28:16 -0700389 if (f-- > 16)
390 return -EINVAL;
391 f = 16 - f;
David Brownell7be2c7c2007-02-10 01:46:02 -0800392
393 spin_lock_irqsave(&rtc_lock, flags);
David Brownell35d3fdd2008-07-23 21:30:43 -0700394 hpet_set_periodic_freq(freq);
395 CMOS_WRITE(RTC_REF_CLCK_32KHZ | f, RTC_FREQ_SELECT);
David Brownell7be2c7c2007-02-10 01:46:02 -0800396 spin_unlock_irqrestore(&rtc_lock, flags);
397
398 return 0;
399}
400
Alessandro Zummo57deb522007-07-19 01:49:21 -0700401static int cmos_irq_set_state(struct device *dev, int enabled)
402{
403 struct cmos_rtc *cmos = dev_get_drvdata(dev);
Alessandro Zummo57deb522007-07-19 01:49:21 -0700404 unsigned long flags;
405
406 if (!is_valid_irq(cmos->irq))
407 return -ENXIO;
408
409 spin_lock_irqsave(&rtc_lock, flags);
Alessandro Zummo57deb522007-07-19 01:49:21 -0700410
David Brownell7e2a31d2008-07-23 21:30:47 -0700411 if (enabled)
412 cmos_irq_enable(cmos, RTC_PIE);
413 else
414 cmos_irq_disable(cmos, RTC_PIE);
Alessandro Zummo57deb522007-07-19 01:49:21 -0700415
416 spin_unlock_irqrestore(&rtc_lock, flags);
417 return 0;
418}
419
David Brownell7be2c7c2007-02-10 01:46:02 -0800420#if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE)
421
422static int
423cmos_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
424{
425 struct cmos_rtc *cmos = dev_get_drvdata(dev);
David Brownell7be2c7c2007-02-10 01:46:02 -0800426 unsigned long flags;
427
428 switch (cmd) {
429 case RTC_AIE_OFF:
430 case RTC_AIE_ON:
431 case RTC_UIE_OFF:
432 case RTC_UIE_ON:
David Brownell7be2c7c2007-02-10 01:46:02 -0800433 if (!is_valid_irq(cmos->irq))
434 return -EINVAL;
435 break;
David Brownell35d3fdd2008-07-23 21:30:43 -0700436 /* PIE ON/OFF is handled by cmos_irq_set_state() */
David Brownell7be2c7c2007-02-10 01:46:02 -0800437 default:
438 return -ENOIOCTLCMD;
439 }
440
441 spin_lock_irqsave(&rtc_lock, flags);
David Brownell7be2c7c2007-02-10 01:46:02 -0800442 switch (cmd) {
443 case RTC_AIE_OFF: /* alarm off */
David Brownell7e2a31d2008-07-23 21:30:47 -0700444 cmos_irq_disable(cmos, RTC_AIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800445 break;
446 case RTC_AIE_ON: /* alarm on */
David Brownell7e2a31d2008-07-23 21:30:47 -0700447 cmos_irq_enable(cmos, RTC_AIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800448 break;
449 case RTC_UIE_OFF: /* update off */
David Brownell7e2a31d2008-07-23 21:30:47 -0700450 cmos_irq_disable(cmos, RTC_UIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800451 break;
452 case RTC_UIE_ON: /* update on */
David Brownell7e2a31d2008-07-23 21:30:47 -0700453 cmos_irq_enable(cmos, RTC_UIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800454 break;
David Brownell7be2c7c2007-02-10 01:46:02 -0800455 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800456 spin_unlock_irqrestore(&rtc_lock, flags);
457 return 0;
458}
459
460#else
461#define cmos_rtc_ioctl NULL
462#endif
463
464#if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
465
466static int cmos_procfs(struct device *dev, struct seq_file *seq)
467{
468 struct cmos_rtc *cmos = dev_get_drvdata(dev);
469 unsigned char rtc_control, valid;
470
471 spin_lock_irq(&rtc_lock);
472 rtc_control = CMOS_READ(RTC_CONTROL);
473 valid = CMOS_READ(RTC_VALID);
474 spin_unlock_irq(&rtc_lock);
475
476 /* NOTE: at least ICH6 reports battery status using a different
477 * (non-RTC) bit; and SQWE is ignored on many current systems.
478 */
479 return seq_printf(seq,
480 "periodic_IRQ\t: %s\n"
481 "update_IRQ\t: %s\n"
David Brownellc8626a12008-02-23 15:23:44 -0800482 "HPET_emulated\t: %s\n"
David Brownell7be2c7c2007-02-10 01:46:02 -0800483 // "square_wave\t: %s\n"
484 // "BCD\t\t: %s\n"
485 "DST_enable\t: %s\n"
486 "periodic_freq\t: %d\n"
487 "batt_status\t: %s\n",
488 (rtc_control & RTC_PIE) ? "yes" : "no",
489 (rtc_control & RTC_UIE) ? "yes" : "no",
David Brownellc8626a12008-02-23 15:23:44 -0800490 is_hpet_enabled() ? "yes" : "no",
David Brownell7be2c7c2007-02-10 01:46:02 -0800491 // (rtc_control & RTC_SQWE) ? "yes" : "no",
492 // (rtc_control & RTC_DM_BINARY) ? "no" : "yes",
493 (rtc_control & RTC_DST_EN) ? "yes" : "no",
494 cmos->rtc->irq_freq,
495 (valid & RTC_VRT) ? "okay" : "dead");
496}
497
498#else
499#define cmos_procfs NULL
500#endif
501
502static const struct rtc_class_ops cmos_rtc_ops = {
503 .ioctl = cmos_rtc_ioctl,
504 .read_time = cmos_read_time,
505 .set_time = cmos_set_time,
506 .read_alarm = cmos_read_alarm,
507 .set_alarm = cmos_set_alarm,
508 .proc = cmos_procfs,
Alessandro Zummo57deb522007-07-19 01:49:21 -0700509 .irq_set_freq = cmos_irq_set_freq,
510 .irq_set_state = cmos_irq_set_state,
David Brownell7be2c7c2007-02-10 01:46:02 -0800511};
512
513/*----------------------------------------------------------------*/
514
David Brownelle07e2322008-02-06 01:38:43 -0800515/*
516 * All these chips have at least 64 bytes of address space, shared by
517 * RTC registers and NVRAM. Most of those bytes of NVRAM are used
518 * by boot firmware. Modern chips have 128 or 256 bytes.
519 */
520
521#define NVRAM_OFFSET (RTC_REG_D + 1)
522
523static ssize_t
524cmos_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
525 char *buf, loff_t off, size_t count)
526{
527 int retval;
528
529 if (unlikely(off >= attr->size))
530 return 0;
David Brownellc8fc40c2008-10-18 20:27:47 -0700531 if (unlikely(off < 0))
532 return -EINVAL;
David Brownelle07e2322008-02-06 01:38:43 -0800533 if ((off + count) > attr->size)
534 count = attr->size - off;
535
David Brownellc8fc40c2008-10-18 20:27:47 -0700536 off += NVRAM_OFFSET;
David Brownelle07e2322008-02-06 01:38:43 -0800537 spin_lock_irq(&rtc_lock);
David Brownellc8fc40c2008-10-18 20:27:47 -0700538 for (retval = 0; count; count--, off++, retval++) {
539 if (off < 128)
540 *buf++ = CMOS_READ(off);
541 else if (can_bank2)
542 *buf++ = cmos_read_bank2(off);
543 else
544 break;
545 }
David Brownelle07e2322008-02-06 01:38:43 -0800546 spin_unlock_irq(&rtc_lock);
547
548 return retval;
549}
550
551static ssize_t
552cmos_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
553 char *buf, loff_t off, size_t count)
554{
555 struct cmos_rtc *cmos;
556 int retval;
557
558 cmos = dev_get_drvdata(container_of(kobj, struct device, kobj));
559 if (unlikely(off >= attr->size))
560 return -EFBIG;
David Brownellc8fc40c2008-10-18 20:27:47 -0700561 if (unlikely(off < 0))
562 return -EINVAL;
David Brownelle07e2322008-02-06 01:38:43 -0800563 if ((off + count) > attr->size)
564 count = attr->size - off;
565
566 /* NOTE: on at least PCs and Ataris, the boot firmware uses a
567 * checksum on part of the NVRAM data. That's currently ignored
568 * here. If userspace is smart enough to know what fields of
569 * NVRAM to update, updating checksums is also part of its job.
570 */
David Brownellc8fc40c2008-10-18 20:27:47 -0700571 off += NVRAM_OFFSET;
David Brownelle07e2322008-02-06 01:38:43 -0800572 spin_lock_irq(&rtc_lock);
David Brownellc8fc40c2008-10-18 20:27:47 -0700573 for (retval = 0; count; count--, off++, retval++) {
David Brownelle07e2322008-02-06 01:38:43 -0800574 /* don't trash RTC registers */
575 if (off == cmos->day_alrm
576 || off == cmos->mon_alrm
577 || off == cmos->century)
578 buf++;
David Brownellc8fc40c2008-10-18 20:27:47 -0700579 else if (off < 128)
David Brownelle07e2322008-02-06 01:38:43 -0800580 CMOS_WRITE(*buf++, off);
David Brownellc8fc40c2008-10-18 20:27:47 -0700581 else if (can_bank2)
582 cmos_write_bank2(*buf++, off);
583 else
584 break;
David Brownelle07e2322008-02-06 01:38:43 -0800585 }
586 spin_unlock_irq(&rtc_lock);
587
588 return retval;
589}
590
591static struct bin_attribute nvram = {
592 .attr = {
593 .name = "nvram",
594 .mode = S_IRUGO | S_IWUSR,
595 .owner = THIS_MODULE,
596 },
597
598 .read = cmos_nvram_read,
599 .write = cmos_nvram_write,
600 /* size gets set up later */
601};
602
603/*----------------------------------------------------------------*/
604
David Brownell7be2c7c2007-02-10 01:46:02 -0800605static struct cmos_rtc cmos_rtc;
606
607static irqreturn_t cmos_interrupt(int irq, void *p)
608{
609 u8 irqstat;
David Brownell8a0bdfd2008-02-06 01:38:45 -0800610 u8 rtc_control;
David Brownell7be2c7c2007-02-10 01:46:02 -0800611
612 spin_lock(&rtc_lock);
David Brownell35d3fdd2008-07-23 21:30:43 -0700613
614 /* When the HPET interrupt handler calls us, the interrupt
615 * status is passed as arg1 instead of the irq number. But
616 * always clear irq status, even when HPET is in the way.
617 *
618 * Note that HPET and RTC are almost certainly out of phase,
619 * giving different IRQ status ...
Bernhard Walle9d8af782008-02-06 01:38:52 -0800620 */
David Brownell35d3fdd2008-07-23 21:30:43 -0700621 irqstat = CMOS_READ(RTC_INTR_FLAGS);
622 rtc_control = CMOS_READ(RTC_CONTROL);
Bernhard Walle9d8af782008-02-06 01:38:52 -0800623 if (is_hpet_enabled())
624 irqstat = (unsigned long)irq & 0xF0;
David Brownell35d3fdd2008-07-23 21:30:43 -0700625 irqstat &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
David Brownell8a0bdfd2008-02-06 01:38:45 -0800626
627 /* All Linux RTC alarms should be treated as if they were oneshot.
628 * Similar code may be needed in system wakeup paths, in case the
629 * alarm woke the system.
630 */
631 if (irqstat & RTC_AIE) {
632 rtc_control &= ~RTC_AIE;
633 CMOS_WRITE(rtc_control, RTC_CONTROL);
David Brownell35d3fdd2008-07-23 21:30:43 -0700634 hpet_mask_rtc_irq_bit(RTC_AIE);
635
David Brownell8a0bdfd2008-02-06 01:38:45 -0800636 CMOS_READ(RTC_INTR_FLAGS);
637 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800638 spin_unlock(&rtc_lock);
639
David Brownellbcd9b892007-04-01 23:49:47 -0700640 if (is_intr(irqstat)) {
David Brownell7be2c7c2007-02-10 01:46:02 -0800641 rtc_update_irq(p, 1, irqstat);
642 return IRQ_HANDLED;
643 } else
644 return IRQ_NONE;
645}
646
Marko Vrh41ac8df2007-05-08 00:34:09 -0700647#ifdef CONFIG_PNP
David Brownell7be2c7c2007-02-10 01:46:02 -0800648#define INITSECTION
649
650#else
David Brownell7be2c7c2007-02-10 01:46:02 -0800651#define INITSECTION __init
652#endif
653
654static int INITSECTION
655cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
656{
657 struct cmos_rtc_board_info *info = dev->platform_data;
658 int retval = 0;
659 unsigned char rtc_control;
David Brownelle07e2322008-02-06 01:38:43 -0800660 unsigned address_space;
David Brownell7be2c7c2007-02-10 01:46:02 -0800661
662 /* there can be only one ... */
663 if (cmos_rtc.dev)
664 return -EBUSY;
665
666 if (!ports)
667 return -ENODEV;
668
David Brownell05440df2007-10-16 01:28:21 -0700669 /* Claim I/O ports ASAP, minimizing conflict with legacy driver.
670 *
671 * REVISIT non-x86 systems may instead use memory space resources
672 * (needing ioremap etc), not i/o space resources like this ...
673 */
674 ports = request_region(ports->start,
675 ports->end + 1 - ports->start,
676 driver_name);
677 if (!ports) {
678 dev_dbg(dev, "i/o registers already in use\n");
679 return -EBUSY;
680 }
681
David Brownell7be2c7c2007-02-10 01:46:02 -0800682 cmos_rtc.irq = rtc_irq;
683 cmos_rtc.iomem = ports;
684
David Brownelle07e2322008-02-06 01:38:43 -0800685 /* Heuristic to deduce NVRAM size ... do what the legacy NVRAM
686 * driver did, but don't reject unknown configs. Old hardware
David Brownellc8fc40c2008-10-18 20:27:47 -0700687 * won't address 128 bytes. Newer chips have multiple banks,
688 * though they may not be listed in one I/O resource.
David Brownelle07e2322008-02-06 01:38:43 -0800689 */
690#if defined(CONFIG_ATARI)
691 address_space = 64;
David S. Miller582defd2008-08-28 19:54:17 -0700692#elif defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__sparc__)
David Brownelle07e2322008-02-06 01:38:43 -0800693 address_space = 128;
694#else
695#warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes.
696 address_space = 128;
697#endif
David Brownellc8fc40c2008-10-18 20:27:47 -0700698 if (can_bank2 && ports->end > (ports->start + 1))
699 address_space = 256;
David Brownelle07e2322008-02-06 01:38:43 -0800700
David Brownell87ac84f2007-05-08 00:34:00 -0700701 /* For ACPI systems extension info comes from the FADT. On others,
702 * board specific setup provides it as appropriate. Systems where
703 * the alarm IRQ isn't automatically a wakeup IRQ (like ACPI, and
704 * some almost-clones) can provide hooks to make that behave.
David Brownelle07e2322008-02-06 01:38:43 -0800705 *
706 * Note that ACPI doesn't preclude putting these registers into
707 * "extended" areas of the chip, including some that we won't yet
708 * expect CMOS_READ and friends to handle.
David Brownell7be2c7c2007-02-10 01:46:02 -0800709 */
710 if (info) {
David Brownelle07e2322008-02-06 01:38:43 -0800711 if (info->rtc_day_alarm && info->rtc_day_alarm < 128)
712 cmos_rtc.day_alrm = info->rtc_day_alarm;
713 if (info->rtc_mon_alarm && info->rtc_mon_alarm < 128)
714 cmos_rtc.mon_alrm = info->rtc_mon_alarm;
715 if (info->rtc_century && info->rtc_century < 128)
716 cmos_rtc.century = info->rtc_century;
David Brownell87ac84f2007-05-08 00:34:00 -0700717
718 if (info->wake_on && info->wake_off) {
719 cmos_rtc.wake_on = info->wake_on;
720 cmos_rtc.wake_off = info->wake_off;
721 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800722 }
723
724 cmos_rtc.rtc = rtc_device_register(driver_name, dev,
725 &cmos_rtc_ops, THIS_MODULE);
David Brownell05440df2007-10-16 01:28:21 -0700726 if (IS_ERR(cmos_rtc.rtc)) {
727 retval = PTR_ERR(cmos_rtc.rtc);
728 goto cleanup0;
729 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800730
731 cmos_rtc.dev = dev;
732 dev_set_drvdata(dev, &cmos_rtc);
David Brownellcd966202007-05-08 00:33:40 -0700733 rename_region(ports, cmos_rtc.rtc->dev.bus_id);
David Brownell7be2c7c2007-02-10 01:46:02 -0800734
735 spin_lock_irq(&rtc_lock);
736
737 /* force periodic irq to CMOS reset default of 1024Hz;
738 *
739 * REVISIT it's been reported that at least one x86_64 ALI mobo
740 * doesn't use 32KHz here ... for portability we might need to
741 * do something about other clock frequencies.
742 */
David Brownell7be2c7c2007-02-10 01:46:02 -0800743 cmos_rtc.rtc->irq_freq = 1024;
David Brownell35d3fdd2008-07-23 21:30:43 -0700744 hpet_set_periodic_freq(cmos_rtc.rtc->irq_freq);
745 CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT);
David Brownell7be2c7c2007-02-10 01:46:02 -0800746
David Brownell7e2a31d2008-07-23 21:30:47 -0700747 /* disable irqs */
748 cmos_irq_disable(&cmos_rtc, RTC_PIE | RTC_AIE | RTC_UIE);
David Brownell35d3fdd2008-07-23 21:30:43 -0700749
David Brownell7e2a31d2008-07-23 21:30:47 -0700750 rtc_control = CMOS_READ(RTC_CONTROL);
David Brownell7be2c7c2007-02-10 01:46:02 -0800751
752 spin_unlock_irq(&rtc_lock);
753
754 /* FIXME teach the alarm code how to handle binary mode;
755 * <asm-generic/rtc.h> doesn't know 12-hour mode either.
756 */
David S. Miller582defd2008-08-28 19:54:17 -0700757 if (is_valid_irq(rtc_irq) &&
758 (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY)))) {
David Brownell7be2c7c2007-02-10 01:46:02 -0800759 dev_dbg(dev, "only 24-hr BCD mode supported\n");
760 retval = -ENXIO;
761 goto cleanup1;
762 }
763
Bernhard Walle9d8af782008-02-06 01:38:52 -0800764 if (is_valid_irq(rtc_irq)) {
765 irq_handler_t rtc_cmos_int_handler;
766
767 if (is_hpet_enabled()) {
768 int err;
769
770 rtc_cmos_int_handler = hpet_rtc_interrupt;
771 err = hpet_register_irq_handler(cmos_interrupt);
772 if (err != 0) {
773 printk(KERN_WARNING "hpet_register_irq_handler "
774 " failed in rtc_init().");
775 goto cleanup1;
776 }
777 } else
778 rtc_cmos_int_handler = cmos_interrupt;
779
780 retval = request_irq(rtc_irq, rtc_cmos_int_handler,
781 IRQF_DISABLED, cmos_rtc.rtc->dev.bus_id,
David Brownellab6a2d72007-05-08 00:33:30 -0700782 cmos_rtc.rtc);
Bernhard Walle9d8af782008-02-06 01:38:52 -0800783 if (retval < 0) {
784 dev_dbg(dev, "IRQ %d is already in use\n", rtc_irq);
785 goto cleanup1;
786 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800787 }
Bernhard Walle9d8af782008-02-06 01:38:52 -0800788 hpet_rtc_timer_init();
David Brownell7be2c7c2007-02-10 01:46:02 -0800789
David Brownelle07e2322008-02-06 01:38:43 -0800790 /* export at least the first block of NVRAM */
791 nvram.size = address_space - NVRAM_OFFSET;
792 retval = sysfs_create_bin_file(&dev->kobj, &nvram);
793 if (retval < 0) {
794 dev_dbg(dev, "can't create nvram file? %d\n", retval);
795 goto cleanup2;
796 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800797
David Brownellc8fc40c2008-10-18 20:27:47 -0700798 pr_info("%s: alarms up to one %s%s, %zd bytes nvram, %s irqs\n",
David Brownellcd966202007-05-08 00:33:40 -0700799 cmos_rtc.rtc->dev.bus_id,
David Brownell7be2c7c2007-02-10 01:46:02 -0800800 is_valid_irq(rtc_irq)
801 ? (cmos_rtc.mon_alrm
802 ? "year"
803 : (cmos_rtc.day_alrm
804 ? "month" : "day"))
805 : "no",
David Brownell35d3fdd2008-07-23 21:30:43 -0700806 cmos_rtc.century ? ", y3k" : "",
David Brownellc8fc40c2008-10-18 20:27:47 -0700807 nvram.size,
David Brownell35d3fdd2008-07-23 21:30:43 -0700808 is_hpet_enabled() ? ", hpet irqs" : "");
David Brownell7be2c7c2007-02-10 01:46:02 -0800809
810 return 0;
811
David Brownelle07e2322008-02-06 01:38:43 -0800812cleanup2:
813 if (is_valid_irq(rtc_irq))
814 free_irq(rtc_irq, cmos_rtc.rtc);
David Brownell7be2c7c2007-02-10 01:46:02 -0800815cleanup1:
David Brownell05440df2007-10-16 01:28:21 -0700816 cmos_rtc.dev = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800817 rtc_device_unregister(cmos_rtc.rtc);
David Brownell05440df2007-10-16 01:28:21 -0700818cleanup0:
819 release_region(ports->start, ports->end + 1 - ports->start);
David Brownell7be2c7c2007-02-10 01:46:02 -0800820 return retval;
821}
822
823static void cmos_do_shutdown(void)
824{
David Brownell7be2c7c2007-02-10 01:46:02 -0800825 spin_lock_irq(&rtc_lock);
David Brownell7e2a31d2008-07-23 21:30:47 -0700826 cmos_irq_disable(&cmos_rtc, RTC_IRQMASK);
David Brownell7be2c7c2007-02-10 01:46:02 -0800827 spin_unlock_irq(&rtc_lock);
828}
829
830static void __exit cmos_do_remove(struct device *dev)
831{
832 struct cmos_rtc *cmos = dev_get_drvdata(dev);
David Brownell05440df2007-10-16 01:28:21 -0700833 struct resource *ports;
David Brownell7be2c7c2007-02-10 01:46:02 -0800834
835 cmos_do_shutdown();
836
David Brownelle07e2322008-02-06 01:38:43 -0800837 sysfs_remove_bin_file(&dev->kobj, &nvram);
838
Bernhard Walle9d8af782008-02-06 01:38:52 -0800839 if (is_valid_irq(cmos->irq)) {
David Brownell05440df2007-10-16 01:28:21 -0700840 free_irq(cmos->irq, cmos->rtc);
Bernhard Walle9d8af782008-02-06 01:38:52 -0800841 hpet_unregister_irq_handler(cmos_interrupt);
842 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800843
David Brownell05440df2007-10-16 01:28:21 -0700844 rtc_device_unregister(cmos->rtc);
845 cmos->rtc = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800846
David Brownell05440df2007-10-16 01:28:21 -0700847 ports = cmos->iomem;
848 release_region(ports->start, ports->end + 1 - ports->start);
849 cmos->iomem = NULL;
850
851 cmos->dev = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800852 dev_set_drvdata(dev, NULL);
853}
854
855#ifdef CONFIG_PM
856
857static int cmos_suspend(struct device *dev, pm_message_t mesg)
858{
859 struct cmos_rtc *cmos = dev_get_drvdata(dev);
David Brownellbcd9b892007-04-01 23:49:47 -0700860 unsigned char tmp;
David Brownell7be2c7c2007-02-10 01:46:02 -0800861
862 /* only the alarm might be a wakeup event source */
863 spin_lock_irq(&rtc_lock);
864 cmos->suspend_ctrl = tmp = CMOS_READ(RTC_CONTROL);
865 if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
David Brownell35d3fdd2008-07-23 21:30:43 -0700866 unsigned char mask;
David Brownellbcd9b892007-04-01 23:49:47 -0700867
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700868 if (device_may_wakeup(dev))
David Brownell35d3fdd2008-07-23 21:30:43 -0700869 mask = RTC_IRQMASK & ~RTC_AIE;
David Brownell7be2c7c2007-02-10 01:46:02 -0800870 else
David Brownell35d3fdd2008-07-23 21:30:43 -0700871 mask = RTC_IRQMASK;
872 tmp &= ~mask;
David Brownell7be2c7c2007-02-10 01:46:02 -0800873 CMOS_WRITE(tmp, RTC_CONTROL);
David Brownell35d3fdd2008-07-23 21:30:43 -0700874 hpet_mask_rtc_irq_bit(mask);
875
David Brownell7e2a31d2008-07-23 21:30:47 -0700876 cmos_checkintr(cmos, tmp);
David Brownellbcd9b892007-04-01 23:49:47 -0700877 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800878 spin_unlock_irq(&rtc_lock);
879
David Brownell87ac84f2007-05-08 00:34:00 -0700880 if (tmp & RTC_AIE) {
881 cmos->enabled_wake = 1;
882 if (cmos->wake_on)
883 cmos->wake_on(dev);
884 else
885 enable_irq_wake(cmos->irq);
886 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800887
888 pr_debug("%s: suspend%s, ctrl %02x\n",
David Brownellcd966202007-05-08 00:33:40 -0700889 cmos_rtc.rtc->dev.bus_id,
David Brownell7be2c7c2007-02-10 01:46:02 -0800890 (tmp & RTC_AIE) ? ", alarm may wake" : "",
891 tmp);
892
893 return 0;
894}
895
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700896/* We want RTC alarms to wake us from e.g. ACPI G2/S5 "soft off", even
897 * after a detour through G3 "mechanical off", although the ACPI spec
898 * says wakeup should only work from G1/S4 "hibernate". To most users,
899 * distinctions between S4 and S5 are pointless. So when the hardware
900 * allows, don't draw that distinction.
901 */
902static inline int cmos_poweroff(struct device *dev)
903{
904 return cmos_suspend(dev, PMSG_HIBERNATE);
905}
906
David Brownell7be2c7c2007-02-10 01:46:02 -0800907static int cmos_resume(struct device *dev)
908{
909 struct cmos_rtc *cmos = dev_get_drvdata(dev);
910 unsigned char tmp = cmos->suspend_ctrl;
911
David Brownell7be2c7c2007-02-10 01:46:02 -0800912 /* re-enable any irqs previously active */
David Brownell35d3fdd2008-07-23 21:30:43 -0700913 if (tmp & RTC_IRQMASK) {
914 unsigned char mask;
David Brownell7be2c7c2007-02-10 01:46:02 -0800915
David Brownell87ac84f2007-05-08 00:34:00 -0700916 if (cmos->enabled_wake) {
917 if (cmos->wake_off)
918 cmos->wake_off(dev);
919 else
920 disable_irq_wake(cmos->irq);
921 cmos->enabled_wake = 0;
922 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800923
924 spin_lock_irq(&rtc_lock);
David Brownell35d3fdd2008-07-23 21:30:43 -0700925 do {
926 CMOS_WRITE(tmp, RTC_CONTROL);
927 hpet_set_rtc_irq_bit(tmp & RTC_IRQMASK);
928
929 mask = CMOS_READ(RTC_INTR_FLAGS);
930 mask &= (tmp & RTC_IRQMASK) | RTC_IRQF;
David Brownell7e2a31d2008-07-23 21:30:47 -0700931 if (!is_hpet_enabled() || !is_intr(mask))
David Brownell35d3fdd2008-07-23 21:30:43 -0700932 break;
933
934 /* force one-shot behavior if HPET blocked
935 * the wake alarm's irq
936 */
937 rtc_update_irq(cmos->rtc, 1, mask);
938 tmp &= ~RTC_AIE;
939 hpet_mask_rtc_irq_bit(RTC_AIE);
940 } while (mask & RTC_AIE);
David Brownellbcd9b892007-04-01 23:49:47 -0700941 spin_unlock_irq(&rtc_lock);
David Brownell7be2c7c2007-02-10 01:46:02 -0800942 }
943
944 pr_debug("%s: resume, ctrl %02x\n",
David Brownellcd966202007-05-08 00:33:40 -0700945 cmos_rtc.rtc->dev.bus_id,
David Brownell35d3fdd2008-07-23 21:30:43 -0700946 tmp);
David Brownell7be2c7c2007-02-10 01:46:02 -0800947
948 return 0;
949}
950
951#else
952#define cmos_suspend NULL
953#define cmos_resume NULL
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700954
955static inline int cmos_poweroff(struct device *dev)
956{
957 return -ENOSYS;
958}
959
David Brownell7be2c7c2007-02-10 01:46:02 -0800960#endif
961
962/*----------------------------------------------------------------*/
963
David Brownelle07e2322008-02-06 01:38:43 -0800964/* On non-x86 systems, a "CMOS" RTC lives most naturally on platform_bus.
965 * ACPI systems always list these as PNPACPI devices, and pre-ACPI PCs
966 * probably list them in similar PNPBIOS tables; so PNP is more common.
967 *
968 * We don't use legacy "poke at the hardware" probing. Ancient PCs that
969 * predate even PNPBIOS should set up platform_bus devices.
David Brownell7be2c7c2007-02-10 01:46:02 -0800970 */
971
Bjorn Helgaasa474aae2008-10-14 13:50:21 -0600972#ifdef CONFIG_ACPI
973
974#include <linux/acpi.h>
975
976#ifdef CONFIG_PM
977static u32 rtc_handler(void *context)
978{
979 acpi_clear_event(ACPI_EVENT_RTC);
980 acpi_disable_event(ACPI_EVENT_RTC, 0);
981 return ACPI_INTERRUPT_HANDLED;
982}
983
984static inline void rtc_wake_setup(void)
985{
986 acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
987 /*
988 * After the RTC handler is installed, the Fixed_RTC event should
989 * be disabled. Only when the RTC alarm is set will it be enabled.
990 */
991 acpi_clear_event(ACPI_EVENT_RTC);
992 acpi_disable_event(ACPI_EVENT_RTC, 0);
993}
994
995static void rtc_wake_on(struct device *dev)
996{
997 acpi_clear_event(ACPI_EVENT_RTC);
998 acpi_enable_event(ACPI_EVENT_RTC, 0);
999}
1000
1001static void rtc_wake_off(struct device *dev)
1002{
1003 acpi_disable_event(ACPI_EVENT_RTC, 0);
1004}
1005#else
1006#define rtc_wake_setup() do{}while(0)
1007#define rtc_wake_on NULL
1008#define rtc_wake_off NULL
1009#endif
1010
1011/* Every ACPI platform has a mc146818 compatible "cmos rtc". Here we find
1012 * its device node and pass extra config data. This helps its driver use
1013 * capabilities that the now-obsolete mc146818 didn't have, and informs it
1014 * that this board's RTC is wakeup-capable (per ACPI spec).
1015 */
1016static struct cmos_rtc_board_info acpi_rtc_info;
1017
1018static void __devinit
1019cmos_wake_setup(struct device *dev)
1020{
1021 if (acpi_disabled)
1022 return;
1023
1024 rtc_wake_setup();
1025 acpi_rtc_info.wake_on = rtc_wake_on;
1026 acpi_rtc_info.wake_off = rtc_wake_off;
1027
1028 /* workaround bug in some ACPI tables */
1029 if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
1030 dev_dbg(dev, "bogus FADT month_alarm (%d)\n",
1031 acpi_gbl_FADT.month_alarm);
1032 acpi_gbl_FADT.month_alarm = 0;
1033 }
1034
1035 acpi_rtc_info.rtc_day_alarm = acpi_gbl_FADT.day_alarm;
1036 acpi_rtc_info.rtc_mon_alarm = acpi_gbl_FADT.month_alarm;
1037 acpi_rtc_info.rtc_century = acpi_gbl_FADT.century;
1038
1039 /* NOTE: S4_RTC_WAKE is NOT currently useful to Linux */
1040 if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
1041 dev_info(dev, "RTC can wake from S4\n");
1042
1043 dev->platform_data = &acpi_rtc_info;
1044
1045 /* RTC always wakes from S1/S2/S3, and often S4/STD */
1046 device_init_wakeup(dev, 1);
1047}
1048
1049#else
1050
1051static void __devinit
1052cmos_wake_setup(struct device *dev)
1053{
1054}
1055
1056#endif
1057
Marko Vrh41ac8df2007-05-08 00:34:09 -07001058#ifdef CONFIG_PNP
David Brownell7be2c7c2007-02-10 01:46:02 -08001059
1060#include <linux/pnp.h>
1061
1062static int __devinit
1063cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
1064{
Bjorn Helgaasa474aae2008-10-14 13:50:21 -06001065 cmos_wake_setup(&pnp->dev);
1066
Matthew Garrett6cd8fa82007-06-01 00:46:51 -07001067 if (pnp_port_start(pnp,0) == 0x70 && !pnp_irq_valid(pnp,0))
1068 /* Some machines contain a PNP entry for the RTC, but
1069 * don't define the IRQ. It should always be safe to
1070 * hardcode it in these cases
1071 */
Bjorn Helgaas8766ad02008-04-28 16:34:27 -06001072 return cmos_do_probe(&pnp->dev,
1073 pnp_get_resource(pnp, IORESOURCE_IO, 0), 8);
Matthew Garrett6cd8fa82007-06-01 00:46:51 -07001074 else
1075 return cmos_do_probe(&pnp->dev,
Bjorn Helgaas8766ad02008-04-28 16:34:27 -06001076 pnp_get_resource(pnp, IORESOURCE_IO, 0),
1077 pnp_irq(pnp, 0));
David Brownell7be2c7c2007-02-10 01:46:02 -08001078}
1079
1080static void __exit cmos_pnp_remove(struct pnp_dev *pnp)
1081{
1082 cmos_do_remove(&pnp->dev);
1083}
1084
1085#ifdef CONFIG_PM
1086
1087static int cmos_pnp_suspend(struct pnp_dev *pnp, pm_message_t mesg)
1088{
1089 return cmos_suspend(&pnp->dev, mesg);
1090}
1091
1092static int cmos_pnp_resume(struct pnp_dev *pnp)
1093{
1094 return cmos_resume(&pnp->dev);
1095}
1096
1097#else
1098#define cmos_pnp_suspend NULL
1099#define cmos_pnp_resume NULL
1100#endif
1101
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001102static void cmos_pnp_shutdown(struct device *pdev)
1103{
1104 if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(pdev))
1105 return;
1106
1107 cmos_do_shutdown();
1108}
David Brownell7be2c7c2007-02-10 01:46:02 -08001109
1110static const struct pnp_device_id rtc_ids[] = {
1111 { .id = "PNP0b00", },
1112 { .id = "PNP0b01", },
1113 { .id = "PNP0b02", },
1114 { },
1115};
1116MODULE_DEVICE_TABLE(pnp, rtc_ids);
1117
1118static struct pnp_driver cmos_pnp_driver = {
1119 .name = (char *) driver_name,
1120 .id_table = rtc_ids,
1121 .probe = cmos_pnp_probe,
1122 .remove = __exit_p(cmos_pnp_remove),
1123
1124 /* flag ensures resume() gets called, and stops syslog spam */
1125 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
1126 .suspend = cmos_pnp_suspend,
1127 .resume = cmos_pnp_resume,
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001128 .driver = {
1129 .name = (char *)driver_name,
1130 .shutdown = cmos_pnp_shutdown,
1131 }
David Brownell7be2c7c2007-02-10 01:46:02 -08001132};
1133
Stas Sergeev1da2e3d2008-06-12 15:21:54 -07001134#endif /* CONFIG_PNP */
David Brownell7be2c7c2007-02-10 01:46:02 -08001135
1136/*----------------------------------------------------------------*/
1137
Marko Vrh41ac8df2007-05-08 00:34:09 -07001138/* Platform setup should have set up an RTC device, when PNP is
David Brownellbcd9b892007-04-01 23:49:47 -07001139 * unavailable ... this could happen even on (older) PCs.
David Brownell7be2c7c2007-02-10 01:46:02 -08001140 */
1141
1142static int __init cmos_platform_probe(struct platform_device *pdev)
1143{
Bjorn Helgaasa474aae2008-10-14 13:50:21 -06001144 cmos_wake_setup(&pdev->dev);
David Brownell7be2c7c2007-02-10 01:46:02 -08001145 return cmos_do_probe(&pdev->dev,
1146 platform_get_resource(pdev, IORESOURCE_IO, 0),
1147 platform_get_irq(pdev, 0));
1148}
1149
1150static int __exit cmos_platform_remove(struct platform_device *pdev)
1151{
1152 cmos_do_remove(&pdev->dev);
1153 return 0;
1154}
1155
1156static void cmos_platform_shutdown(struct platform_device *pdev)
1157{
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001158 if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(&pdev->dev))
1159 return;
1160
David Brownell7be2c7c2007-02-10 01:46:02 -08001161 cmos_do_shutdown();
1162}
1163
Kay Sieversad28a072008-04-10 21:29:25 -07001164/* work with hotplug and coldplug */
1165MODULE_ALIAS("platform:rtc_cmos");
1166
David Brownell7be2c7c2007-02-10 01:46:02 -08001167static struct platform_driver cmos_platform_driver = {
1168 .remove = __exit_p(cmos_platform_remove),
1169 .shutdown = cmos_platform_shutdown,
1170 .driver = {
1171 .name = (char *) driver_name,
1172 .suspend = cmos_suspend,
1173 .resume = cmos_resume,
1174 }
1175};
1176
1177static int __init cmos_init(void)
1178{
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001179 int retval = 0;
1180
Stas Sergeev1da2e3d2008-06-12 15:21:54 -07001181#ifdef CONFIG_PNP
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001182 pnp_register_driver(&cmos_pnp_driver);
1183#endif
1184
1185 if (!cmos_rtc.dev)
1186 retval = platform_driver_probe(&cmos_platform_driver,
1187 cmos_platform_probe);
1188
1189 if (retval == 0)
1190 return 0;
1191
1192#ifdef CONFIG_PNP
1193 pnp_unregister_driver(&cmos_pnp_driver);
1194#endif
1195 return retval;
David Brownell7be2c7c2007-02-10 01:46:02 -08001196}
1197module_init(cmos_init);
1198
1199static void __exit cmos_exit(void)
1200{
Stas Sergeev1da2e3d2008-06-12 15:21:54 -07001201#ifdef CONFIG_PNP
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001202 pnp_unregister_driver(&cmos_pnp_driver);
1203#endif
David Brownell7be2c7c2007-02-10 01:46:02 -08001204 platform_driver_unregister(&cmos_platform_driver);
1205}
1206module_exit(cmos_exit);
1207
1208
David Brownell7be2c7c2007-02-10 01:46:02 -08001209MODULE_AUTHOR("David Brownell");
1210MODULE_DESCRIPTION("Driver for PC-style 'CMOS' RTCs");
1211MODULE_LICENSE("GPL");