blob: b6d35f50e40488141debded78ca4d5992f78288a [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>
Jonathan Cameron5d2a5032009-01-06 14:42:12 -080038#include <linux/log2.h>
David Brownell7be2c7c2007-02-10 01:46:02 -080039
40/* this is for "generic access to PC-style RTC" using CMOS_READ/CMOS_WRITE */
41#include <asm-generic/rtc.h>
42
David Brownell7be2c7c2007-02-10 01:46:02 -080043struct cmos_rtc {
44 struct rtc_device *rtc;
45 struct device *dev;
46 int irq;
47 struct resource *iomem;
48
David Brownell87ac84f2007-05-08 00:34:00 -070049 void (*wake_on)(struct device *);
50 void (*wake_off)(struct device *);
51
52 u8 enabled_wake;
David Brownell7be2c7c2007-02-10 01:46:02 -080053 u8 suspend_ctrl;
54
55 /* newer hardware extends the original register set */
56 u8 day_alrm;
57 u8 mon_alrm;
58 u8 century;
59};
60
61/* both platform and pnp busses use negative numbers for invalid irqs */
Anton Vorontsov2fac6672009-01-06 14:42:11 -080062#define is_valid_irq(n) ((n) > 0)
David Brownell7be2c7c2007-02-10 01:46:02 -080063
64static const char driver_name[] = "rtc_cmos";
65
David Brownellbcd9b892007-04-01 23:49:47 -070066/* The RTC_INTR register may have e.g. RTC_PF set even if RTC_PIE is clear;
67 * always mask it against the irq enable bits in RTC_CONTROL. Bit values
68 * are the same: PF==PIE, AF=AIE, UF=UIE; so RTC_IRQMASK works with both.
69 */
70#define RTC_IRQMASK (RTC_PF | RTC_AF | RTC_UF)
71
72static inline int is_intr(u8 rtc_intr)
73{
74 if (!(rtc_intr & RTC_IRQF))
75 return 0;
76 return rtc_intr & RTC_IRQMASK;
77}
78
David Brownell7be2c7c2007-02-10 01:46:02 -080079/*----------------------------------------------------------------*/
80
David Brownell35d3fdd2008-07-23 21:30:43 -070081/* Much modern x86 hardware has HPETs (10+ MHz timers) which, because
82 * many BIOS programmers don't set up "sane mode" IRQ routing, are mostly
83 * used in a broken "legacy replacement" mode. The breakage includes
84 * HPET #1 hijacking the IRQ for this RTC, and being unavailable for
85 * other (better) use.
86 *
87 * When that broken mode is in use, platform glue provides a partial
88 * emulation of hardware RTC IRQ facilities using HPET #1. We don't
89 * want to use HPET for anything except those IRQs though...
90 */
91#ifdef CONFIG_HPET_EMULATE_RTC
92#include <asm/hpet.h>
93#else
94
95static inline int is_hpet_enabled(void)
96{
97 return 0;
98}
99
100static inline int hpet_mask_rtc_irq_bit(unsigned long mask)
101{
102 return 0;
103}
104
105static inline int hpet_set_rtc_irq_bit(unsigned long mask)
106{
107 return 0;
108}
109
110static inline int
111hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
112{
113 return 0;
114}
115
116static inline int hpet_set_periodic_freq(unsigned long freq)
117{
118 return 0;
119}
120
121static inline int hpet_rtc_dropped_irq(void)
122{
123 return 0;
124}
125
126static inline int hpet_rtc_timer_init(void)
127{
128 return 0;
129}
130
131extern irq_handler_t hpet_rtc_interrupt;
132
133static inline int hpet_register_irq_handler(irq_handler_t handler)
134{
135 return 0;
136}
137
138static inline int hpet_unregister_irq_handler(irq_handler_t handler)
139{
140 return 0;
141}
142
143#endif
144
145/*----------------------------------------------------------------*/
146
David Brownellc8fc40c2008-10-18 20:27:47 -0700147#ifdef RTC_PORT
148
149/* Most newer x86 systems have two register banks, the first used
150 * for RTC and NVRAM and the second only for NVRAM. Caller must
151 * own rtc_lock ... and we won't worry about access during NMI.
152 */
153#define can_bank2 true
154
155static inline unsigned char cmos_read_bank2(unsigned char addr)
156{
157 outb(addr, RTC_PORT(2));
158 return inb(RTC_PORT(3));
159}
160
161static inline void cmos_write_bank2(unsigned char val, unsigned char addr)
162{
163 outb(addr, RTC_PORT(2));
164 outb(val, RTC_PORT(2));
165}
166
167#else
168
169#define can_bank2 false
170
171static inline unsigned char cmos_read_bank2(unsigned char addr)
172{
173 return 0;
174}
175
176static inline void cmos_write_bank2(unsigned char val, unsigned char addr)
177{
178}
179
180#endif
181
182/*----------------------------------------------------------------*/
183
David Brownell7be2c7c2007-02-10 01:46:02 -0800184static int cmos_read_time(struct device *dev, struct rtc_time *t)
185{
186 /* REVISIT: if the clock has a "century" register, use
187 * that instead of the heuristic in get_rtc_time().
188 * That'll make Y3K compatility (year > 2070) easy!
189 */
190 get_rtc_time(t);
191 return 0;
192}
193
194static int cmos_set_time(struct device *dev, struct rtc_time *t)
195{
196 /* REVISIT: set the "century" register if available
197 *
198 * NOTE: this ignores the issue whereby updating the seconds
199 * takes effect exactly 500ms after we write the register.
200 * (Also queueing and other delays before we get this far.)
201 */
202 return set_rtc_time(t);
203}
204
205static int cmos_read_alarm(struct device *dev, struct rtc_wkalrm *t)
206{
207 struct cmos_rtc *cmos = dev_get_drvdata(dev);
208 unsigned char rtc_control;
209
210 if (!is_valid_irq(cmos->irq))
211 return -EIO;
212
213 /* Basic alarms only support hour, minute, and seconds fields.
214 * Some also support day and month, for alarms up to a year in
215 * the future.
216 */
217 t->time.tm_mday = -1;
218 t->time.tm_mon = -1;
219
220 spin_lock_irq(&rtc_lock);
221 t->time.tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
222 t->time.tm_min = CMOS_READ(RTC_MINUTES_ALARM);
223 t->time.tm_hour = CMOS_READ(RTC_HOURS_ALARM);
224
225 if (cmos->day_alrm) {
Mark Lord615bb292007-11-03 22:04:03 -0400226 /* ignore upper bits on readback per ACPI spec */
227 t->time.tm_mday = CMOS_READ(cmos->day_alrm) & 0x3f;
David Brownell7be2c7c2007-02-10 01:46:02 -0800228 if (!t->time.tm_mday)
229 t->time.tm_mday = -1;
230
231 if (cmos->mon_alrm) {
232 t->time.tm_mon = CMOS_READ(cmos->mon_alrm);
233 if (!t->time.tm_mon)
234 t->time.tm_mon = -1;
235 }
236 }
237
238 rtc_control = CMOS_READ(RTC_CONTROL);
239 spin_unlock_irq(&rtc_lock);
240
241 /* REVISIT this assumes PC style usage: always BCD */
242
243 if (((unsigned)t->time.tm_sec) < 0x60)
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700244 t->time.tm_sec = bcd2bin(t->time.tm_sec);
David Brownell7be2c7c2007-02-10 01:46:02 -0800245 else
246 t->time.tm_sec = -1;
247 if (((unsigned)t->time.tm_min) < 0x60)
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700248 t->time.tm_min = bcd2bin(t->time.tm_min);
David Brownell7be2c7c2007-02-10 01:46:02 -0800249 else
250 t->time.tm_min = -1;
251 if (((unsigned)t->time.tm_hour) < 0x24)
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700252 t->time.tm_hour = bcd2bin(t->time.tm_hour);
David Brownell7be2c7c2007-02-10 01:46:02 -0800253 else
254 t->time.tm_hour = -1;
255
256 if (cmos->day_alrm) {
257 if (((unsigned)t->time.tm_mday) <= 0x31)
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700258 t->time.tm_mday = bcd2bin(t->time.tm_mday);
David Brownell7be2c7c2007-02-10 01:46:02 -0800259 else
260 t->time.tm_mday = -1;
261 if (cmos->mon_alrm) {
262 if (((unsigned)t->time.tm_mon) <= 0x12)
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700263 t->time.tm_mon = bcd2bin(t->time.tm_mon) - 1;
David Brownell7be2c7c2007-02-10 01:46:02 -0800264 else
265 t->time.tm_mon = -1;
266 }
267 }
268 t->time.tm_year = -1;
269
270 t->enabled = !!(rtc_control & RTC_AIE);
271 t->pending = 0;
272
273 return 0;
274}
275
David Brownell7e2a31d2008-07-23 21:30:47 -0700276static void cmos_checkintr(struct cmos_rtc *cmos, unsigned char rtc_control)
277{
278 unsigned char rtc_intr;
279
280 /* NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
281 * allegedly some older rtcs need that to handle irqs properly
282 */
283 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
284
285 if (is_hpet_enabled())
286 return;
287
288 rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
289 if (is_intr(rtc_intr))
290 rtc_update_irq(cmos->rtc, 1, rtc_intr);
291}
292
293static void cmos_irq_enable(struct cmos_rtc *cmos, unsigned char mask)
294{
295 unsigned char rtc_control;
296
297 /* flush any pending IRQ status, notably for update irqs,
298 * before we enable new IRQs
299 */
300 rtc_control = CMOS_READ(RTC_CONTROL);
301 cmos_checkintr(cmos, rtc_control);
302
303 rtc_control |= mask;
304 CMOS_WRITE(rtc_control, RTC_CONTROL);
305 hpet_set_rtc_irq_bit(mask);
306
307 cmos_checkintr(cmos, rtc_control);
308}
309
310static void cmos_irq_disable(struct cmos_rtc *cmos, unsigned char mask)
311{
312 unsigned char rtc_control;
313
314 rtc_control = CMOS_READ(RTC_CONTROL);
315 rtc_control &= ~mask;
316 CMOS_WRITE(rtc_control, RTC_CONTROL);
317 hpet_mask_rtc_irq_bit(mask);
318
319 cmos_checkintr(cmos, rtc_control);
320}
321
David Brownell7be2c7c2007-02-10 01:46:02 -0800322static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
323{
324 struct cmos_rtc *cmos = dev_get_drvdata(dev);
325 unsigned char mon, mday, hrs, min, sec;
David Brownell7be2c7c2007-02-10 01:46:02 -0800326
327 if (!is_valid_irq(cmos->irq))
328 return -EIO;
329
330 /* REVISIT this assumes PC style usage: always BCD */
331
332 /* Writing 0xff means "don't care" or "match all". */
333
Zhao Yakui2b653e02008-04-15 14:34:29 -0700334 mon = t->time.tm_mon + 1;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700335 mon = (mon <= 12) ? bin2bcd(mon) : 0xff;
David Brownell7be2c7c2007-02-10 01:46:02 -0800336
337 mday = t->time.tm_mday;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700338 mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
David Brownell7be2c7c2007-02-10 01:46:02 -0800339
340 hrs = t->time.tm_hour;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700341 hrs = (hrs < 24) ? bin2bcd(hrs) : 0xff;
David Brownell7be2c7c2007-02-10 01:46:02 -0800342
343 min = t->time.tm_min;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700344 min = (min < 60) ? bin2bcd(min) : 0xff;
David Brownell7be2c7c2007-02-10 01:46:02 -0800345
346 sec = t->time.tm_sec;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700347 sec = (sec < 60) ? bin2bcd(sec) : 0xff;
David Brownell7be2c7c2007-02-10 01:46:02 -0800348
349 spin_lock_irq(&rtc_lock);
350
351 /* next rtc irq must not be from previous alarm setting */
David Brownell7e2a31d2008-07-23 21:30:47 -0700352 cmos_irq_disable(cmos, RTC_AIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800353
354 /* update alarm */
355 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
356 CMOS_WRITE(min, RTC_MINUTES_ALARM);
357 CMOS_WRITE(sec, RTC_SECONDS_ALARM);
358
359 /* the system may support an "enhanced" alarm */
360 if (cmos->day_alrm) {
361 CMOS_WRITE(mday, cmos->day_alrm);
362 if (cmos->mon_alrm)
363 CMOS_WRITE(mon, cmos->mon_alrm);
364 }
365
David Brownell35d3fdd2008-07-23 21:30:43 -0700366 /* FIXME the HPET alarm glue currently ignores day_alrm
367 * and mon_alrm ...
368 */
369 hpet_set_alarm_time(t->time.tm_hour, t->time.tm_min, t->time.tm_sec);
370
David Brownell7e2a31d2008-07-23 21:30:47 -0700371 if (t->enabled)
372 cmos_irq_enable(cmos, RTC_AIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800373
374 spin_unlock_irq(&rtc_lock);
375
376 return 0;
377}
378
Alessandro Zummo57deb522007-07-19 01:49:21 -0700379static int cmos_irq_set_freq(struct device *dev, int freq)
David Brownell7be2c7c2007-02-10 01:46:02 -0800380{
381 struct cmos_rtc *cmos = dev_get_drvdata(dev);
382 int f;
383 unsigned long flags;
384
385 if (!is_valid_irq(cmos->irq))
386 return -ENXIO;
387
Jonathan Cameron5d2a5032009-01-06 14:42:12 -0800388 if (!is_power_of_2(freq))
389 return -EINVAL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800390 /* 0 = no irqs; 1 = 2^15 Hz ... 15 = 2^0 Hz */
391 f = ffs(freq);
David Brownell97144c62007-10-16 01:28:16 -0700392 if (f-- > 16)
393 return -EINVAL;
394 f = 16 - f;
David Brownell7be2c7c2007-02-10 01:46:02 -0800395
396 spin_lock_irqsave(&rtc_lock, flags);
David Brownell35d3fdd2008-07-23 21:30:43 -0700397 hpet_set_periodic_freq(freq);
398 CMOS_WRITE(RTC_REF_CLCK_32KHZ | f, RTC_FREQ_SELECT);
David Brownell7be2c7c2007-02-10 01:46:02 -0800399 spin_unlock_irqrestore(&rtc_lock, flags);
400
401 return 0;
402}
403
Alessandro Zummo57deb522007-07-19 01:49:21 -0700404static int cmos_irq_set_state(struct device *dev, int enabled)
405{
406 struct cmos_rtc *cmos = dev_get_drvdata(dev);
Alessandro Zummo57deb522007-07-19 01:49:21 -0700407 unsigned long flags;
408
409 if (!is_valid_irq(cmos->irq))
410 return -ENXIO;
411
412 spin_lock_irqsave(&rtc_lock, flags);
Alessandro Zummo57deb522007-07-19 01:49:21 -0700413
David Brownell7e2a31d2008-07-23 21:30:47 -0700414 if (enabled)
415 cmos_irq_enable(cmos, RTC_PIE);
416 else
417 cmos_irq_disable(cmos, RTC_PIE);
Alessandro Zummo57deb522007-07-19 01:49:21 -0700418
419 spin_unlock_irqrestore(&rtc_lock, flags);
420 return 0;
421}
422
David Brownell7be2c7c2007-02-10 01:46:02 -0800423#if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE)
424
425static int
426cmos_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
427{
428 struct cmos_rtc *cmos = dev_get_drvdata(dev);
David Brownell7be2c7c2007-02-10 01:46:02 -0800429 unsigned long flags;
430
431 switch (cmd) {
432 case RTC_AIE_OFF:
433 case RTC_AIE_ON:
434 case RTC_UIE_OFF:
435 case RTC_UIE_ON:
David Brownell7be2c7c2007-02-10 01:46:02 -0800436 if (!is_valid_irq(cmos->irq))
437 return -EINVAL;
438 break;
David Brownell35d3fdd2008-07-23 21:30:43 -0700439 /* PIE ON/OFF is handled by cmos_irq_set_state() */
David Brownell7be2c7c2007-02-10 01:46:02 -0800440 default:
441 return -ENOIOCTLCMD;
442 }
443
444 spin_lock_irqsave(&rtc_lock, flags);
David Brownell7be2c7c2007-02-10 01:46:02 -0800445 switch (cmd) {
446 case RTC_AIE_OFF: /* alarm off */
David Brownell7e2a31d2008-07-23 21:30:47 -0700447 cmos_irq_disable(cmos, RTC_AIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800448 break;
449 case RTC_AIE_ON: /* alarm on */
David Brownell7e2a31d2008-07-23 21:30:47 -0700450 cmos_irq_enable(cmos, RTC_AIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800451 break;
452 case RTC_UIE_OFF: /* update off */
David Brownell7e2a31d2008-07-23 21:30:47 -0700453 cmos_irq_disable(cmos, RTC_UIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800454 break;
455 case RTC_UIE_ON: /* update on */
David Brownell7e2a31d2008-07-23 21:30:47 -0700456 cmos_irq_enable(cmos, RTC_UIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800457 break;
David Brownell7be2c7c2007-02-10 01:46:02 -0800458 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800459 spin_unlock_irqrestore(&rtc_lock, flags);
460 return 0;
461}
462
463#else
464#define cmos_rtc_ioctl NULL
465#endif
466
467#if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
468
469static int cmos_procfs(struct device *dev, struct seq_file *seq)
470{
471 struct cmos_rtc *cmos = dev_get_drvdata(dev);
472 unsigned char rtc_control, valid;
473
474 spin_lock_irq(&rtc_lock);
475 rtc_control = CMOS_READ(RTC_CONTROL);
476 valid = CMOS_READ(RTC_VALID);
477 spin_unlock_irq(&rtc_lock);
478
479 /* NOTE: at least ICH6 reports battery status using a different
480 * (non-RTC) bit; and SQWE is ignored on many current systems.
481 */
482 return seq_printf(seq,
483 "periodic_IRQ\t: %s\n"
484 "update_IRQ\t: %s\n"
David Brownellc8626a12008-02-23 15:23:44 -0800485 "HPET_emulated\t: %s\n"
David Brownell7be2c7c2007-02-10 01:46:02 -0800486 // "square_wave\t: %s\n"
487 // "BCD\t\t: %s\n"
488 "DST_enable\t: %s\n"
489 "periodic_freq\t: %d\n"
490 "batt_status\t: %s\n",
491 (rtc_control & RTC_PIE) ? "yes" : "no",
492 (rtc_control & RTC_UIE) ? "yes" : "no",
David Brownellc8626a12008-02-23 15:23:44 -0800493 is_hpet_enabled() ? "yes" : "no",
David Brownell7be2c7c2007-02-10 01:46:02 -0800494 // (rtc_control & RTC_SQWE) ? "yes" : "no",
495 // (rtc_control & RTC_DM_BINARY) ? "no" : "yes",
496 (rtc_control & RTC_DST_EN) ? "yes" : "no",
497 cmos->rtc->irq_freq,
498 (valid & RTC_VRT) ? "okay" : "dead");
499}
500
501#else
502#define cmos_procfs NULL
503#endif
504
505static const struct rtc_class_ops cmos_rtc_ops = {
506 .ioctl = cmos_rtc_ioctl,
507 .read_time = cmos_read_time,
508 .set_time = cmos_set_time,
509 .read_alarm = cmos_read_alarm,
510 .set_alarm = cmos_set_alarm,
511 .proc = cmos_procfs,
Alessandro Zummo57deb522007-07-19 01:49:21 -0700512 .irq_set_freq = cmos_irq_set_freq,
513 .irq_set_state = cmos_irq_set_state,
David Brownell7be2c7c2007-02-10 01:46:02 -0800514};
515
516/*----------------------------------------------------------------*/
517
David Brownelle07e2322008-02-06 01:38:43 -0800518/*
519 * All these chips have at least 64 bytes of address space, shared by
520 * RTC registers and NVRAM. Most of those bytes of NVRAM are used
521 * by boot firmware. Modern chips have 128 or 256 bytes.
522 */
523
524#define NVRAM_OFFSET (RTC_REG_D + 1)
525
526static ssize_t
527cmos_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
528 char *buf, loff_t off, size_t count)
529{
530 int retval;
531
532 if (unlikely(off >= attr->size))
533 return 0;
David Brownellc8fc40c2008-10-18 20:27:47 -0700534 if (unlikely(off < 0))
535 return -EINVAL;
David Brownelle07e2322008-02-06 01:38:43 -0800536 if ((off + count) > attr->size)
537 count = attr->size - off;
538
David Brownellc8fc40c2008-10-18 20:27:47 -0700539 off += NVRAM_OFFSET;
David Brownelle07e2322008-02-06 01:38:43 -0800540 spin_lock_irq(&rtc_lock);
David Brownellc8fc40c2008-10-18 20:27:47 -0700541 for (retval = 0; count; count--, off++, retval++) {
542 if (off < 128)
543 *buf++ = CMOS_READ(off);
544 else if (can_bank2)
545 *buf++ = cmos_read_bank2(off);
546 else
547 break;
548 }
David Brownelle07e2322008-02-06 01:38:43 -0800549 spin_unlock_irq(&rtc_lock);
550
551 return retval;
552}
553
554static ssize_t
555cmos_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
556 char *buf, loff_t off, size_t count)
557{
558 struct cmos_rtc *cmos;
559 int retval;
560
561 cmos = dev_get_drvdata(container_of(kobj, struct device, kobj));
562 if (unlikely(off >= attr->size))
563 return -EFBIG;
David Brownellc8fc40c2008-10-18 20:27:47 -0700564 if (unlikely(off < 0))
565 return -EINVAL;
David Brownelle07e2322008-02-06 01:38:43 -0800566 if ((off + count) > attr->size)
567 count = attr->size - off;
568
569 /* NOTE: on at least PCs and Ataris, the boot firmware uses a
570 * checksum on part of the NVRAM data. That's currently ignored
571 * here. If userspace is smart enough to know what fields of
572 * NVRAM to update, updating checksums is also part of its job.
573 */
David Brownellc8fc40c2008-10-18 20:27:47 -0700574 off += NVRAM_OFFSET;
David Brownelle07e2322008-02-06 01:38:43 -0800575 spin_lock_irq(&rtc_lock);
David Brownellc8fc40c2008-10-18 20:27:47 -0700576 for (retval = 0; count; count--, off++, retval++) {
David Brownelle07e2322008-02-06 01:38:43 -0800577 /* don't trash RTC registers */
578 if (off == cmos->day_alrm
579 || off == cmos->mon_alrm
580 || off == cmos->century)
581 buf++;
David Brownellc8fc40c2008-10-18 20:27:47 -0700582 else if (off < 128)
David Brownelle07e2322008-02-06 01:38:43 -0800583 CMOS_WRITE(*buf++, off);
David Brownellc8fc40c2008-10-18 20:27:47 -0700584 else if (can_bank2)
585 cmos_write_bank2(*buf++, off);
586 else
587 break;
David Brownelle07e2322008-02-06 01:38:43 -0800588 }
589 spin_unlock_irq(&rtc_lock);
590
591 return retval;
592}
593
594static struct bin_attribute nvram = {
595 .attr = {
596 .name = "nvram",
597 .mode = S_IRUGO | S_IWUSR,
David Brownelle07e2322008-02-06 01:38:43 -0800598 },
599
600 .read = cmos_nvram_read,
601 .write = cmos_nvram_write,
602 /* size gets set up later */
603};
604
605/*----------------------------------------------------------------*/
606
David Brownell7be2c7c2007-02-10 01:46:02 -0800607static struct cmos_rtc cmos_rtc;
608
609static irqreturn_t cmos_interrupt(int irq, void *p)
610{
611 u8 irqstat;
David Brownell8a0bdfd2008-02-06 01:38:45 -0800612 u8 rtc_control;
David Brownell7be2c7c2007-02-10 01:46:02 -0800613
614 spin_lock(&rtc_lock);
David Brownell35d3fdd2008-07-23 21:30:43 -0700615
616 /* When the HPET interrupt handler calls us, the interrupt
617 * status is passed as arg1 instead of the irq number. But
618 * always clear irq status, even when HPET is in the way.
619 *
620 * Note that HPET and RTC are almost certainly out of phase,
621 * giving different IRQ status ...
Bernhard Walle9d8af782008-02-06 01:38:52 -0800622 */
David Brownell35d3fdd2008-07-23 21:30:43 -0700623 irqstat = CMOS_READ(RTC_INTR_FLAGS);
624 rtc_control = CMOS_READ(RTC_CONTROL);
Bernhard Walle9d8af782008-02-06 01:38:52 -0800625 if (is_hpet_enabled())
626 irqstat = (unsigned long)irq & 0xF0;
David Brownell35d3fdd2008-07-23 21:30:43 -0700627 irqstat &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
David Brownell8a0bdfd2008-02-06 01:38:45 -0800628
629 /* All Linux RTC alarms should be treated as if they were oneshot.
630 * Similar code may be needed in system wakeup paths, in case the
631 * alarm woke the system.
632 */
633 if (irqstat & RTC_AIE) {
634 rtc_control &= ~RTC_AIE;
635 CMOS_WRITE(rtc_control, RTC_CONTROL);
David Brownell35d3fdd2008-07-23 21:30:43 -0700636 hpet_mask_rtc_irq_bit(RTC_AIE);
637
David Brownell8a0bdfd2008-02-06 01:38:45 -0800638 CMOS_READ(RTC_INTR_FLAGS);
639 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800640 spin_unlock(&rtc_lock);
641
David Brownellbcd9b892007-04-01 23:49:47 -0700642 if (is_intr(irqstat)) {
David Brownell7be2c7c2007-02-10 01:46:02 -0800643 rtc_update_irq(p, 1, irqstat);
644 return IRQ_HANDLED;
645 } else
646 return IRQ_NONE;
647}
648
Marko Vrh41ac8df2007-05-08 00:34:09 -0700649#ifdef CONFIG_PNP
David Brownell7be2c7c2007-02-10 01:46:02 -0800650#define INITSECTION
651
652#else
David Brownell7be2c7c2007-02-10 01:46:02 -0800653#define INITSECTION __init
654#endif
655
656static int INITSECTION
657cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
658{
659 struct cmos_rtc_board_info *info = dev->platform_data;
660 int retval = 0;
661 unsigned char rtc_control;
David Brownelle07e2322008-02-06 01:38:43 -0800662 unsigned address_space;
David Brownell7be2c7c2007-02-10 01:46:02 -0800663
664 /* there can be only one ... */
665 if (cmos_rtc.dev)
666 return -EBUSY;
667
668 if (!ports)
669 return -ENODEV;
670
David Brownell05440df2007-10-16 01:28:21 -0700671 /* Claim I/O ports ASAP, minimizing conflict with legacy driver.
672 *
673 * REVISIT non-x86 systems may instead use memory space resources
674 * (needing ioremap etc), not i/o space resources like this ...
675 */
676 ports = request_region(ports->start,
677 ports->end + 1 - ports->start,
678 driver_name);
679 if (!ports) {
680 dev_dbg(dev, "i/o registers already in use\n");
681 return -EBUSY;
682 }
683
David Brownell7be2c7c2007-02-10 01:46:02 -0800684 cmos_rtc.irq = rtc_irq;
685 cmos_rtc.iomem = ports;
686
David Brownelle07e2322008-02-06 01:38:43 -0800687 /* Heuristic to deduce NVRAM size ... do what the legacy NVRAM
688 * driver did, but don't reject unknown configs. Old hardware
David Brownellc8fc40c2008-10-18 20:27:47 -0700689 * won't address 128 bytes. Newer chips have multiple banks,
690 * though they may not be listed in one I/O resource.
David Brownelle07e2322008-02-06 01:38:43 -0800691 */
692#if defined(CONFIG_ATARI)
693 address_space = 64;
David S. Miller582defd2008-08-28 19:54:17 -0700694#elif defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__sparc__)
David Brownelle07e2322008-02-06 01:38:43 -0800695 address_space = 128;
696#else
697#warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes.
698 address_space = 128;
699#endif
David Brownellc8fc40c2008-10-18 20:27:47 -0700700 if (can_bank2 && ports->end > (ports->start + 1))
701 address_space = 256;
David Brownelle07e2322008-02-06 01:38:43 -0800702
David Brownell87ac84f2007-05-08 00:34:00 -0700703 /* For ACPI systems extension info comes from the FADT. On others,
704 * board specific setup provides it as appropriate. Systems where
705 * the alarm IRQ isn't automatically a wakeup IRQ (like ACPI, and
706 * some almost-clones) can provide hooks to make that behave.
David Brownelle07e2322008-02-06 01:38:43 -0800707 *
708 * Note that ACPI doesn't preclude putting these registers into
709 * "extended" areas of the chip, including some that we won't yet
710 * expect CMOS_READ and friends to handle.
David Brownell7be2c7c2007-02-10 01:46:02 -0800711 */
712 if (info) {
David Brownelle07e2322008-02-06 01:38:43 -0800713 if (info->rtc_day_alarm && info->rtc_day_alarm < 128)
714 cmos_rtc.day_alrm = info->rtc_day_alarm;
715 if (info->rtc_mon_alarm && info->rtc_mon_alarm < 128)
716 cmos_rtc.mon_alrm = info->rtc_mon_alarm;
717 if (info->rtc_century && info->rtc_century < 128)
718 cmos_rtc.century = info->rtc_century;
David Brownell87ac84f2007-05-08 00:34:00 -0700719
720 if (info->wake_on && info->wake_off) {
721 cmos_rtc.wake_on = info->wake_on;
722 cmos_rtc.wake_off = info->wake_off;
723 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800724 }
725
726 cmos_rtc.rtc = rtc_device_register(driver_name, dev,
727 &cmos_rtc_ops, THIS_MODULE);
David Brownell05440df2007-10-16 01:28:21 -0700728 if (IS_ERR(cmos_rtc.rtc)) {
729 retval = PTR_ERR(cmos_rtc.rtc);
730 goto cleanup0;
731 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800732
733 cmos_rtc.dev = dev;
734 dev_set_drvdata(dev, &cmos_rtc);
Kay Sieversd4afc762009-01-06 14:42:11 -0800735 rename_region(ports, dev_name(&cmos_rtc.rtc->dev));
David Brownell7be2c7c2007-02-10 01:46:02 -0800736
737 spin_lock_irq(&rtc_lock);
738
739 /* force periodic irq to CMOS reset default of 1024Hz;
740 *
741 * REVISIT it's been reported that at least one x86_64 ALI mobo
742 * doesn't use 32KHz here ... for portability we might need to
743 * do something about other clock frequencies.
744 */
David Brownell7be2c7c2007-02-10 01:46:02 -0800745 cmos_rtc.rtc->irq_freq = 1024;
David Brownell35d3fdd2008-07-23 21:30:43 -0700746 hpet_set_periodic_freq(cmos_rtc.rtc->irq_freq);
747 CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT);
David Brownell7be2c7c2007-02-10 01:46:02 -0800748
David Brownell7e2a31d2008-07-23 21:30:47 -0700749 /* disable irqs */
750 cmos_irq_disable(&cmos_rtc, RTC_PIE | RTC_AIE | RTC_UIE);
David Brownell35d3fdd2008-07-23 21:30:43 -0700751
David Brownell7e2a31d2008-07-23 21:30:47 -0700752 rtc_control = CMOS_READ(RTC_CONTROL);
David Brownell7be2c7c2007-02-10 01:46:02 -0800753
754 spin_unlock_irq(&rtc_lock);
755
756 /* FIXME teach the alarm code how to handle binary mode;
757 * <asm-generic/rtc.h> doesn't know 12-hour mode either.
758 */
David S. Miller582defd2008-08-28 19:54:17 -0700759 if (is_valid_irq(rtc_irq) &&
760 (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY)))) {
David Brownell7be2c7c2007-02-10 01:46:02 -0800761 dev_dbg(dev, "only 24-hr BCD mode supported\n");
762 retval = -ENXIO;
763 goto cleanup1;
764 }
765
Bernhard Walle9d8af782008-02-06 01:38:52 -0800766 if (is_valid_irq(rtc_irq)) {
767 irq_handler_t rtc_cmos_int_handler;
768
769 if (is_hpet_enabled()) {
770 int err;
771
772 rtc_cmos_int_handler = hpet_rtc_interrupt;
773 err = hpet_register_irq_handler(cmos_interrupt);
774 if (err != 0) {
775 printk(KERN_WARNING "hpet_register_irq_handler "
776 " failed in rtc_init().");
777 goto cleanup1;
778 }
779 } else
780 rtc_cmos_int_handler = cmos_interrupt;
781
782 retval = request_irq(rtc_irq, rtc_cmos_int_handler,
Kay Sieversd4afc762009-01-06 14:42:11 -0800783 IRQF_DISABLED, dev_name(&cmos_rtc.rtc->dev),
David Brownellab6a2d72007-05-08 00:33:30 -0700784 cmos_rtc.rtc);
Bernhard Walle9d8af782008-02-06 01:38:52 -0800785 if (retval < 0) {
786 dev_dbg(dev, "IRQ %d is already in use\n", rtc_irq);
787 goto cleanup1;
788 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800789 }
Bernhard Walle9d8af782008-02-06 01:38:52 -0800790 hpet_rtc_timer_init();
David Brownell7be2c7c2007-02-10 01:46:02 -0800791
David Brownelle07e2322008-02-06 01:38:43 -0800792 /* export at least the first block of NVRAM */
793 nvram.size = address_space - NVRAM_OFFSET;
794 retval = sysfs_create_bin_file(&dev->kobj, &nvram);
795 if (retval < 0) {
796 dev_dbg(dev, "can't create nvram file? %d\n", retval);
797 goto cleanup2;
798 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800799
Frans Pop80bb26d2008-11-06 12:53:41 -0800800 pr_info("%s: alarms up to one %s%s, %zd bytes nvram%s\n",
Kay Sieversd4afc762009-01-06 14:42:11 -0800801 dev_name(&cmos_rtc.rtc->dev),
David Brownell7be2c7c2007-02-10 01:46:02 -0800802 is_valid_irq(rtc_irq)
803 ? (cmos_rtc.mon_alrm
804 ? "year"
805 : (cmos_rtc.day_alrm
806 ? "month" : "day"))
807 : "no",
David Brownell35d3fdd2008-07-23 21:30:43 -0700808 cmos_rtc.century ? ", y3k" : "",
David Brownellc8fc40c2008-10-18 20:27:47 -0700809 nvram.size,
David Brownell35d3fdd2008-07-23 21:30:43 -0700810 is_hpet_enabled() ? ", hpet irqs" : "");
David Brownell7be2c7c2007-02-10 01:46:02 -0800811
812 return 0;
813
David Brownelle07e2322008-02-06 01:38:43 -0800814cleanup2:
815 if (is_valid_irq(rtc_irq))
816 free_irq(rtc_irq, cmos_rtc.rtc);
David Brownell7be2c7c2007-02-10 01:46:02 -0800817cleanup1:
David Brownell05440df2007-10-16 01:28:21 -0700818 cmos_rtc.dev = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800819 rtc_device_unregister(cmos_rtc.rtc);
David Brownell05440df2007-10-16 01:28:21 -0700820cleanup0:
821 release_region(ports->start, ports->end + 1 - ports->start);
David Brownell7be2c7c2007-02-10 01:46:02 -0800822 return retval;
823}
824
825static void cmos_do_shutdown(void)
826{
David Brownell7be2c7c2007-02-10 01:46:02 -0800827 spin_lock_irq(&rtc_lock);
David Brownell7e2a31d2008-07-23 21:30:47 -0700828 cmos_irq_disable(&cmos_rtc, RTC_IRQMASK);
David Brownell7be2c7c2007-02-10 01:46:02 -0800829 spin_unlock_irq(&rtc_lock);
830}
831
832static void __exit cmos_do_remove(struct device *dev)
833{
834 struct cmos_rtc *cmos = dev_get_drvdata(dev);
David Brownell05440df2007-10-16 01:28:21 -0700835 struct resource *ports;
David Brownell7be2c7c2007-02-10 01:46:02 -0800836
837 cmos_do_shutdown();
838
David Brownelle07e2322008-02-06 01:38:43 -0800839 sysfs_remove_bin_file(&dev->kobj, &nvram);
840
Bernhard Walle9d8af782008-02-06 01:38:52 -0800841 if (is_valid_irq(cmos->irq)) {
David Brownell05440df2007-10-16 01:28:21 -0700842 free_irq(cmos->irq, cmos->rtc);
Bernhard Walle9d8af782008-02-06 01:38:52 -0800843 hpet_unregister_irq_handler(cmos_interrupt);
844 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800845
David Brownell05440df2007-10-16 01:28:21 -0700846 rtc_device_unregister(cmos->rtc);
847 cmos->rtc = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800848
David Brownell05440df2007-10-16 01:28:21 -0700849 ports = cmos->iomem;
850 release_region(ports->start, ports->end + 1 - ports->start);
851 cmos->iomem = NULL;
852
853 cmos->dev = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800854 dev_set_drvdata(dev, NULL);
855}
856
857#ifdef CONFIG_PM
858
859static int cmos_suspend(struct device *dev, pm_message_t mesg)
860{
861 struct cmos_rtc *cmos = dev_get_drvdata(dev);
David Brownellbcd9b892007-04-01 23:49:47 -0700862 unsigned char tmp;
David Brownell7be2c7c2007-02-10 01:46:02 -0800863
864 /* only the alarm might be a wakeup event source */
865 spin_lock_irq(&rtc_lock);
866 cmos->suspend_ctrl = tmp = CMOS_READ(RTC_CONTROL);
867 if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
David Brownell35d3fdd2008-07-23 21:30:43 -0700868 unsigned char mask;
David Brownellbcd9b892007-04-01 23:49:47 -0700869
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700870 if (device_may_wakeup(dev))
David Brownell35d3fdd2008-07-23 21:30:43 -0700871 mask = RTC_IRQMASK & ~RTC_AIE;
David Brownell7be2c7c2007-02-10 01:46:02 -0800872 else
David Brownell35d3fdd2008-07-23 21:30:43 -0700873 mask = RTC_IRQMASK;
874 tmp &= ~mask;
David Brownell7be2c7c2007-02-10 01:46:02 -0800875 CMOS_WRITE(tmp, RTC_CONTROL);
David Brownell35d3fdd2008-07-23 21:30:43 -0700876 hpet_mask_rtc_irq_bit(mask);
877
David Brownell7e2a31d2008-07-23 21:30:47 -0700878 cmos_checkintr(cmos, tmp);
David Brownellbcd9b892007-04-01 23:49:47 -0700879 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800880 spin_unlock_irq(&rtc_lock);
881
David Brownell87ac84f2007-05-08 00:34:00 -0700882 if (tmp & RTC_AIE) {
883 cmos->enabled_wake = 1;
884 if (cmos->wake_on)
885 cmos->wake_on(dev);
886 else
887 enable_irq_wake(cmos->irq);
888 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800889
890 pr_debug("%s: suspend%s, ctrl %02x\n",
Kay Sieversd4afc762009-01-06 14:42:11 -0800891 dev_name(&cmos_rtc.rtc->dev),
David Brownell7be2c7c2007-02-10 01:46:02 -0800892 (tmp & RTC_AIE) ? ", alarm may wake" : "",
893 tmp);
894
895 return 0;
896}
897
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700898/* We want RTC alarms to wake us from e.g. ACPI G2/S5 "soft off", even
899 * after a detour through G3 "mechanical off", although the ACPI spec
900 * says wakeup should only work from G1/S4 "hibernate". To most users,
901 * distinctions between S4 and S5 are pointless. So when the hardware
902 * allows, don't draw that distinction.
903 */
904static inline int cmos_poweroff(struct device *dev)
905{
906 return cmos_suspend(dev, PMSG_HIBERNATE);
907}
908
David Brownell7be2c7c2007-02-10 01:46:02 -0800909static int cmos_resume(struct device *dev)
910{
911 struct cmos_rtc *cmos = dev_get_drvdata(dev);
912 unsigned char tmp = cmos->suspend_ctrl;
913
David Brownell7be2c7c2007-02-10 01:46:02 -0800914 /* re-enable any irqs previously active */
David Brownell35d3fdd2008-07-23 21:30:43 -0700915 if (tmp & RTC_IRQMASK) {
916 unsigned char mask;
David Brownell7be2c7c2007-02-10 01:46:02 -0800917
David Brownell87ac84f2007-05-08 00:34:00 -0700918 if (cmos->enabled_wake) {
919 if (cmos->wake_off)
920 cmos->wake_off(dev);
921 else
922 disable_irq_wake(cmos->irq);
923 cmos->enabled_wake = 0;
924 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800925
926 spin_lock_irq(&rtc_lock);
David Brownell35d3fdd2008-07-23 21:30:43 -0700927 do {
928 CMOS_WRITE(tmp, RTC_CONTROL);
929 hpet_set_rtc_irq_bit(tmp & RTC_IRQMASK);
930
931 mask = CMOS_READ(RTC_INTR_FLAGS);
932 mask &= (tmp & RTC_IRQMASK) | RTC_IRQF;
David Brownell7e2a31d2008-07-23 21:30:47 -0700933 if (!is_hpet_enabled() || !is_intr(mask))
David Brownell35d3fdd2008-07-23 21:30:43 -0700934 break;
935
936 /* force one-shot behavior if HPET blocked
937 * the wake alarm's irq
938 */
939 rtc_update_irq(cmos->rtc, 1, mask);
940 tmp &= ~RTC_AIE;
941 hpet_mask_rtc_irq_bit(RTC_AIE);
942 } while (mask & RTC_AIE);
David Brownellbcd9b892007-04-01 23:49:47 -0700943 spin_unlock_irq(&rtc_lock);
David Brownell7be2c7c2007-02-10 01:46:02 -0800944 }
945
946 pr_debug("%s: resume, ctrl %02x\n",
Kay Sieversd4afc762009-01-06 14:42:11 -0800947 dev_name(&cmos_rtc.rtc->dev),
David Brownell35d3fdd2008-07-23 21:30:43 -0700948 tmp);
David Brownell7be2c7c2007-02-10 01:46:02 -0800949
950 return 0;
951}
952
953#else
954#define cmos_suspend NULL
955#define cmos_resume NULL
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700956
957static inline int cmos_poweroff(struct device *dev)
958{
959 return -ENOSYS;
960}
961
David Brownell7be2c7c2007-02-10 01:46:02 -0800962#endif
963
964/*----------------------------------------------------------------*/
965
David Brownelle07e2322008-02-06 01:38:43 -0800966/* On non-x86 systems, a "CMOS" RTC lives most naturally on platform_bus.
967 * ACPI systems always list these as PNPACPI devices, and pre-ACPI PCs
968 * probably list them in similar PNPBIOS tables; so PNP is more common.
969 *
970 * We don't use legacy "poke at the hardware" probing. Ancient PCs that
971 * predate even PNPBIOS should set up platform_bus devices.
David Brownell7be2c7c2007-02-10 01:46:02 -0800972 */
973
Bjorn Helgaasa474aae2008-10-14 13:50:21 -0600974#ifdef CONFIG_ACPI
975
976#include <linux/acpi.h>
977
978#ifdef CONFIG_PM
979static u32 rtc_handler(void *context)
980{
981 acpi_clear_event(ACPI_EVENT_RTC);
982 acpi_disable_event(ACPI_EVENT_RTC, 0);
983 return ACPI_INTERRUPT_HANDLED;
984}
985
986static inline void rtc_wake_setup(void)
987{
988 acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
989 /*
990 * After the RTC handler is installed, the Fixed_RTC event should
991 * be disabled. Only when the RTC alarm is set will it be enabled.
992 */
993 acpi_clear_event(ACPI_EVENT_RTC);
994 acpi_disable_event(ACPI_EVENT_RTC, 0);
995}
996
997static void rtc_wake_on(struct device *dev)
998{
999 acpi_clear_event(ACPI_EVENT_RTC);
1000 acpi_enable_event(ACPI_EVENT_RTC, 0);
1001}
1002
1003static void rtc_wake_off(struct device *dev)
1004{
1005 acpi_disable_event(ACPI_EVENT_RTC, 0);
1006}
1007#else
1008#define rtc_wake_setup() do{}while(0)
1009#define rtc_wake_on NULL
1010#define rtc_wake_off NULL
1011#endif
1012
1013/* Every ACPI platform has a mc146818 compatible "cmos rtc". Here we find
1014 * its device node and pass extra config data. This helps its driver use
1015 * capabilities that the now-obsolete mc146818 didn't have, and informs it
1016 * that this board's RTC is wakeup-capable (per ACPI spec).
1017 */
1018static struct cmos_rtc_board_info acpi_rtc_info;
1019
1020static void __devinit
1021cmos_wake_setup(struct device *dev)
1022{
1023 if (acpi_disabled)
1024 return;
1025
1026 rtc_wake_setup();
1027 acpi_rtc_info.wake_on = rtc_wake_on;
1028 acpi_rtc_info.wake_off = rtc_wake_off;
1029
1030 /* workaround bug in some ACPI tables */
1031 if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
1032 dev_dbg(dev, "bogus FADT month_alarm (%d)\n",
1033 acpi_gbl_FADT.month_alarm);
1034 acpi_gbl_FADT.month_alarm = 0;
1035 }
1036
1037 acpi_rtc_info.rtc_day_alarm = acpi_gbl_FADT.day_alarm;
1038 acpi_rtc_info.rtc_mon_alarm = acpi_gbl_FADT.month_alarm;
1039 acpi_rtc_info.rtc_century = acpi_gbl_FADT.century;
1040
1041 /* NOTE: S4_RTC_WAKE is NOT currently useful to Linux */
1042 if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
1043 dev_info(dev, "RTC can wake from S4\n");
1044
1045 dev->platform_data = &acpi_rtc_info;
1046
1047 /* RTC always wakes from S1/S2/S3, and often S4/STD */
1048 device_init_wakeup(dev, 1);
1049}
1050
1051#else
1052
1053static void __devinit
1054cmos_wake_setup(struct device *dev)
1055{
1056}
1057
1058#endif
1059
Marko Vrh41ac8df2007-05-08 00:34:09 -07001060#ifdef CONFIG_PNP
David Brownell7be2c7c2007-02-10 01:46:02 -08001061
1062#include <linux/pnp.h>
1063
1064static int __devinit
1065cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
1066{
Bjorn Helgaasa474aae2008-10-14 13:50:21 -06001067 cmos_wake_setup(&pnp->dev);
1068
Matthew Garrett6cd8fa82007-06-01 00:46:51 -07001069 if (pnp_port_start(pnp,0) == 0x70 && !pnp_irq_valid(pnp,0))
1070 /* Some machines contain a PNP entry for the RTC, but
1071 * don't define the IRQ. It should always be safe to
1072 * hardcode it in these cases
1073 */
Bjorn Helgaas8766ad02008-04-28 16:34:27 -06001074 return cmos_do_probe(&pnp->dev,
1075 pnp_get_resource(pnp, IORESOURCE_IO, 0), 8);
Matthew Garrett6cd8fa82007-06-01 00:46:51 -07001076 else
1077 return cmos_do_probe(&pnp->dev,
Bjorn Helgaas8766ad02008-04-28 16:34:27 -06001078 pnp_get_resource(pnp, IORESOURCE_IO, 0),
1079 pnp_irq(pnp, 0));
David Brownell7be2c7c2007-02-10 01:46:02 -08001080}
1081
1082static void __exit cmos_pnp_remove(struct pnp_dev *pnp)
1083{
1084 cmos_do_remove(&pnp->dev);
1085}
1086
1087#ifdef CONFIG_PM
1088
1089static int cmos_pnp_suspend(struct pnp_dev *pnp, pm_message_t mesg)
1090{
1091 return cmos_suspend(&pnp->dev, mesg);
1092}
1093
1094static int cmos_pnp_resume(struct pnp_dev *pnp)
1095{
1096 return cmos_resume(&pnp->dev);
1097}
1098
1099#else
1100#define cmos_pnp_suspend NULL
1101#define cmos_pnp_resume NULL
1102#endif
1103
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001104static void cmos_pnp_shutdown(struct device *pdev)
1105{
1106 if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(pdev))
1107 return;
1108
1109 cmos_do_shutdown();
1110}
David Brownell7be2c7c2007-02-10 01:46:02 -08001111
1112static const struct pnp_device_id rtc_ids[] = {
1113 { .id = "PNP0b00", },
1114 { .id = "PNP0b01", },
1115 { .id = "PNP0b02", },
1116 { },
1117};
1118MODULE_DEVICE_TABLE(pnp, rtc_ids);
1119
1120static struct pnp_driver cmos_pnp_driver = {
1121 .name = (char *) driver_name,
1122 .id_table = rtc_ids,
1123 .probe = cmos_pnp_probe,
1124 .remove = __exit_p(cmos_pnp_remove),
1125
1126 /* flag ensures resume() gets called, and stops syslog spam */
1127 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
1128 .suspend = cmos_pnp_suspend,
1129 .resume = cmos_pnp_resume,
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001130 .driver = {
1131 .name = (char *)driver_name,
1132 .shutdown = cmos_pnp_shutdown,
1133 }
David Brownell7be2c7c2007-02-10 01:46:02 -08001134};
1135
Stas Sergeev1da2e3d2008-06-12 15:21:54 -07001136#endif /* CONFIG_PNP */
David Brownell7be2c7c2007-02-10 01:46:02 -08001137
1138/*----------------------------------------------------------------*/
1139
Marko Vrh41ac8df2007-05-08 00:34:09 -07001140/* Platform setup should have set up an RTC device, when PNP is
David Brownellbcd9b892007-04-01 23:49:47 -07001141 * unavailable ... this could happen even on (older) PCs.
David Brownell7be2c7c2007-02-10 01:46:02 -08001142 */
1143
1144static int __init cmos_platform_probe(struct platform_device *pdev)
1145{
Bjorn Helgaasa474aae2008-10-14 13:50:21 -06001146 cmos_wake_setup(&pdev->dev);
David Brownell7be2c7c2007-02-10 01:46:02 -08001147 return cmos_do_probe(&pdev->dev,
1148 platform_get_resource(pdev, IORESOURCE_IO, 0),
1149 platform_get_irq(pdev, 0));
1150}
1151
1152static int __exit cmos_platform_remove(struct platform_device *pdev)
1153{
1154 cmos_do_remove(&pdev->dev);
1155 return 0;
1156}
1157
1158static void cmos_platform_shutdown(struct platform_device *pdev)
1159{
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001160 if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(&pdev->dev))
1161 return;
1162
David Brownell7be2c7c2007-02-10 01:46:02 -08001163 cmos_do_shutdown();
1164}
1165
Kay Sieversad28a072008-04-10 21:29:25 -07001166/* work with hotplug and coldplug */
1167MODULE_ALIAS("platform:rtc_cmos");
1168
David Brownell7be2c7c2007-02-10 01:46:02 -08001169static struct platform_driver cmos_platform_driver = {
1170 .remove = __exit_p(cmos_platform_remove),
1171 .shutdown = cmos_platform_shutdown,
1172 .driver = {
1173 .name = (char *) driver_name,
1174 .suspend = cmos_suspend,
1175 .resume = cmos_resume,
1176 }
1177};
1178
1179static int __init cmos_init(void)
1180{
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001181 int retval = 0;
1182
Stas Sergeev1da2e3d2008-06-12 15:21:54 -07001183#ifdef CONFIG_PNP
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001184 pnp_register_driver(&cmos_pnp_driver);
1185#endif
1186
1187 if (!cmos_rtc.dev)
1188 retval = platform_driver_probe(&cmos_platform_driver,
1189 cmos_platform_probe);
1190
1191 if (retval == 0)
1192 return 0;
1193
1194#ifdef CONFIG_PNP
1195 pnp_unregister_driver(&cmos_pnp_driver);
1196#endif
1197 return retval;
David Brownell7be2c7c2007-02-10 01:46:02 -08001198}
1199module_init(cmos_init);
1200
1201static void __exit cmos_exit(void)
1202{
Stas Sergeev1da2e3d2008-06-12 15:21:54 -07001203#ifdef CONFIG_PNP
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001204 pnp_unregister_driver(&cmos_pnp_driver);
1205#endif
David Brownell7be2c7c2007-02-10 01:46:02 -08001206 platform_driver_unregister(&cmos_platform_driver);
1207}
1208module_exit(cmos_exit);
1209
1210
David Brownell7be2c7c2007-02-10 01:46:02 -08001211MODULE_AUTHOR("David Brownell");
1212MODULE_DESCRIPTION("Driver for PC-style 'CMOS' RTCs");
1213MODULE_LICENSE("GPL");