blob: 23e10b6263d6f12b36791a5015c7958009b7b5d3 [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
Krzysztof Halasa6d029b62009-04-21 12:24:49 -0700800 pr_info("%s: %s%s, %zd bytes nvram%s\n",
801 dev_name(&cmos_rtc.rtc->dev),
802 !is_valid_irq(rtc_irq) ? "no alarms" :
803 cmos_rtc.mon_alrm ? "alarms up to one year" :
804 cmos_rtc.day_alrm ? "alarms up to one month" :
805 "alarms up to one day",
806 cmos_rtc.century ? ", y3k" : "",
807 nvram.size,
808 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",
Kay Sieversd4afc762009-01-06 14:42:11 -0800889 dev_name(&cmos_rtc.rtc->dev),
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",
Kay Sieversd4afc762009-01-06 14:42:11 -0800945 dev_name(&cmos_rtc.rtc->dev),
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");