blob: 7e6ce626b7f1c9b84bb2915afa81f6d4a2ff3e76 [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
Arnaud Patard3804a892010-04-29 11:58:44 +0200241 if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
242 if (((unsigned)t->time.tm_sec) < 0x60)
243 t->time.tm_sec = bcd2bin(t->time.tm_sec);
David Brownell7be2c7c2007-02-10 01:46:02 -0800244 else
Arnaud Patard3804a892010-04-29 11:58:44 +0200245 t->time.tm_sec = -1;
246 if (((unsigned)t->time.tm_min) < 0x60)
247 t->time.tm_min = bcd2bin(t->time.tm_min);
248 else
249 t->time.tm_min = -1;
250 if (((unsigned)t->time.tm_hour) < 0x24)
251 t->time.tm_hour = bcd2bin(t->time.tm_hour);
252 else
253 t->time.tm_hour = -1;
254
255 if (cmos->day_alrm) {
256 if (((unsigned)t->time.tm_mday) <= 0x31)
257 t->time.tm_mday = bcd2bin(t->time.tm_mday);
David Brownell7be2c7c2007-02-10 01:46:02 -0800258 else
Arnaud Patard3804a892010-04-29 11:58:44 +0200259 t->time.tm_mday = -1;
260
261 if (cmos->mon_alrm) {
262 if (((unsigned)t->time.tm_mon) <= 0x12)
263 t->time.tm_mon = bcd2bin(t->time.tm_mon)-1;
264 else
265 t->time.tm_mon = -1;
266 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800267 }
268 }
269 t->time.tm_year = -1;
270
271 t->enabled = !!(rtc_control & RTC_AIE);
272 t->pending = 0;
273
274 return 0;
275}
276
David Brownell7e2a31d2008-07-23 21:30:47 -0700277static void cmos_checkintr(struct cmos_rtc *cmos, unsigned char rtc_control)
278{
279 unsigned char rtc_intr;
280
281 /* NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
282 * allegedly some older rtcs need that to handle irqs properly
283 */
284 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
285
286 if (is_hpet_enabled())
287 return;
288
289 rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
290 if (is_intr(rtc_intr))
291 rtc_update_irq(cmos->rtc, 1, rtc_intr);
292}
293
294static void cmos_irq_enable(struct cmos_rtc *cmos, unsigned char mask)
295{
296 unsigned char rtc_control;
297
298 /* flush any pending IRQ status, notably for update irqs,
299 * before we enable new IRQs
300 */
301 rtc_control = CMOS_READ(RTC_CONTROL);
302 cmos_checkintr(cmos, rtc_control);
303
304 rtc_control |= mask;
305 CMOS_WRITE(rtc_control, RTC_CONTROL);
306 hpet_set_rtc_irq_bit(mask);
307
308 cmos_checkintr(cmos, rtc_control);
309}
310
311static void cmos_irq_disable(struct cmos_rtc *cmos, unsigned char mask)
312{
313 unsigned char rtc_control;
314
315 rtc_control = CMOS_READ(RTC_CONTROL);
316 rtc_control &= ~mask;
317 CMOS_WRITE(rtc_control, RTC_CONTROL);
318 hpet_mask_rtc_irq_bit(mask);
319
320 cmos_checkintr(cmos, rtc_control);
321}
322
David Brownell7be2c7c2007-02-10 01:46:02 -0800323static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
324{
325 struct cmos_rtc *cmos = dev_get_drvdata(dev);
Arnaud Patard3804a892010-04-29 11:58:44 +0200326 unsigned char mon, mday, hrs, min, sec, rtc_control;
David Brownell7be2c7c2007-02-10 01:46:02 -0800327
328 if (!is_valid_irq(cmos->irq))
329 return -EIO;
330
Zhao Yakui2b653e02008-04-15 14:34:29 -0700331 mon = t->time.tm_mon + 1;
David Brownell7be2c7c2007-02-10 01:46:02 -0800332 mday = t->time.tm_mday;
David Brownell7be2c7c2007-02-10 01:46:02 -0800333 hrs = t->time.tm_hour;
David Brownell7be2c7c2007-02-10 01:46:02 -0800334 min = t->time.tm_min;
David Brownell7be2c7c2007-02-10 01:46:02 -0800335 sec = t->time.tm_sec;
Arnaud Patard3804a892010-04-29 11:58:44 +0200336
337 rtc_control = CMOS_READ(RTC_CONTROL);
338 if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
339 /* Writing 0xff means "don't care" or "match all". */
340 mon = (mon <= 12) ? bin2bcd(mon) : 0xff;
341 mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
342 hrs = (hrs < 24) ? bin2bcd(hrs) : 0xff;
343 min = (min < 60) ? bin2bcd(min) : 0xff;
344 sec = (sec < 60) ? bin2bcd(sec) : 0xff;
345 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800346
347 spin_lock_irq(&rtc_lock);
348
349 /* next rtc irq must not be from previous alarm setting */
David Brownell7e2a31d2008-07-23 21:30:47 -0700350 cmos_irq_disable(cmos, RTC_AIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800351
352 /* update alarm */
353 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
354 CMOS_WRITE(min, RTC_MINUTES_ALARM);
355 CMOS_WRITE(sec, RTC_SECONDS_ALARM);
356
357 /* the system may support an "enhanced" alarm */
358 if (cmos->day_alrm) {
359 CMOS_WRITE(mday, cmos->day_alrm);
360 if (cmos->mon_alrm)
361 CMOS_WRITE(mon, cmos->mon_alrm);
362 }
363
David Brownell35d3fdd2008-07-23 21:30:43 -0700364 /* FIXME the HPET alarm glue currently ignores day_alrm
365 * and mon_alrm ...
366 */
367 hpet_set_alarm_time(t->time.tm_hour, t->time.tm_min, t->time.tm_sec);
368
David Brownell7e2a31d2008-07-23 21:30:47 -0700369 if (t->enabled)
370 cmos_irq_enable(cmos, RTC_AIE);
David Brownell7be2c7c2007-02-10 01:46:02 -0800371
372 spin_unlock_irq(&rtc_lock);
373
374 return 0;
375}
376
Alessandro Zummo57deb522007-07-19 01:49:21 -0700377static int cmos_irq_set_freq(struct device *dev, int freq)
David Brownell7be2c7c2007-02-10 01:46:02 -0800378{
379 struct cmos_rtc *cmos = dev_get_drvdata(dev);
380 int f;
381 unsigned long flags;
382
383 if (!is_valid_irq(cmos->irq))
384 return -ENXIO;
385
Jonathan Cameron5d2a5032009-01-06 14:42:12 -0800386 if (!is_power_of_2(freq))
387 return -EINVAL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800388 /* 0 = no irqs; 1 = 2^15 Hz ... 15 = 2^0 Hz */
389 f = ffs(freq);
David Brownell97144c62007-10-16 01:28:16 -0700390 if (f-- > 16)
391 return -EINVAL;
392 f = 16 - f;
David Brownell7be2c7c2007-02-10 01:46:02 -0800393
394 spin_lock_irqsave(&rtc_lock, flags);
David Brownell35d3fdd2008-07-23 21:30:43 -0700395 hpet_set_periodic_freq(freq);
396 CMOS_WRITE(RTC_REF_CLCK_32KHZ | f, RTC_FREQ_SELECT);
David Brownell7be2c7c2007-02-10 01:46:02 -0800397 spin_unlock_irqrestore(&rtc_lock, flags);
398
399 return 0;
400}
401
Alessandro Zummo57deb522007-07-19 01:49:21 -0700402static int cmos_irq_set_state(struct device *dev, int enabled)
403{
404 struct cmos_rtc *cmos = dev_get_drvdata(dev);
Alessandro Zummo57deb522007-07-19 01:49:21 -0700405 unsigned long flags;
406
407 if (!is_valid_irq(cmos->irq))
408 return -ENXIO;
409
410 spin_lock_irqsave(&rtc_lock, flags);
Alessandro Zummo57deb522007-07-19 01:49:21 -0700411
David Brownell7e2a31d2008-07-23 21:30:47 -0700412 if (enabled)
413 cmos_irq_enable(cmos, RTC_PIE);
414 else
415 cmos_irq_disable(cmos, RTC_PIE);
Alessandro Zummo57deb522007-07-19 01:49:21 -0700416
417 spin_unlock_irqrestore(&rtc_lock, flags);
418 return 0;
419}
420
Herton Ronaldo Krzesinskia8462ef2009-12-15 16:45:56 -0800421static int cmos_alarm_irq_enable(struct device *dev, unsigned int enabled)
David Brownell7be2c7c2007-02-10 01:46:02 -0800422{
423 struct cmos_rtc *cmos = dev_get_drvdata(dev);
David Brownell7be2c7c2007-02-10 01:46:02 -0800424 unsigned long flags;
425
Herton Ronaldo Krzesinskia8462ef2009-12-15 16:45:56 -0800426 if (!is_valid_irq(cmos->irq))
427 return -EINVAL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800428
429 spin_lock_irqsave(&rtc_lock, flags);
Herton Ronaldo Krzesinskia8462ef2009-12-15 16:45:56 -0800430
431 if (enabled)
David Brownell7e2a31d2008-07-23 21:30:47 -0700432 cmos_irq_enable(cmos, RTC_AIE);
Herton Ronaldo Krzesinskia8462ef2009-12-15 16:45:56 -0800433 else
434 cmos_irq_disable(cmos, RTC_AIE);
435
David Brownell7be2c7c2007-02-10 01:46:02 -0800436 spin_unlock_irqrestore(&rtc_lock, flags);
437 return 0;
438}
439
Herton Ronaldo Krzesinskia8462ef2009-12-15 16:45:56 -0800440static int cmos_update_irq_enable(struct device *dev, unsigned int enabled)
441{
442 struct cmos_rtc *cmos = dev_get_drvdata(dev);
443 unsigned long flags;
444
445 if (!is_valid_irq(cmos->irq))
446 return -EINVAL;
447
448 spin_lock_irqsave(&rtc_lock, flags);
449
450 if (enabled)
451 cmos_irq_enable(cmos, RTC_UIE);
452 else
453 cmos_irq_disable(cmos, RTC_UIE);
454
455 spin_unlock_irqrestore(&rtc_lock, flags);
456 return 0;
457}
David Brownell7be2c7c2007-02-10 01:46:02 -0800458
459#if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
460
461static int cmos_procfs(struct device *dev, struct seq_file *seq)
462{
463 struct cmos_rtc *cmos = dev_get_drvdata(dev);
464 unsigned char rtc_control, valid;
465
466 spin_lock_irq(&rtc_lock);
467 rtc_control = CMOS_READ(RTC_CONTROL);
468 valid = CMOS_READ(RTC_VALID);
469 spin_unlock_irq(&rtc_lock);
470
471 /* NOTE: at least ICH6 reports battery status using a different
472 * (non-RTC) bit; and SQWE is ignored on many current systems.
473 */
474 return seq_printf(seq,
475 "periodic_IRQ\t: %s\n"
476 "update_IRQ\t: %s\n"
David Brownellc8626a12008-02-23 15:23:44 -0800477 "HPET_emulated\t: %s\n"
David Brownell7be2c7c2007-02-10 01:46:02 -0800478 // "square_wave\t: %s\n"
Arnaud Patard3804a892010-04-29 11:58:44 +0200479 "BCD\t\t: %s\n"
David Brownell7be2c7c2007-02-10 01:46:02 -0800480 "DST_enable\t: %s\n"
481 "periodic_freq\t: %d\n"
482 "batt_status\t: %s\n",
483 (rtc_control & RTC_PIE) ? "yes" : "no",
484 (rtc_control & RTC_UIE) ? "yes" : "no",
David Brownellc8626a12008-02-23 15:23:44 -0800485 is_hpet_enabled() ? "yes" : "no",
David Brownell7be2c7c2007-02-10 01:46:02 -0800486 // (rtc_control & RTC_SQWE) ? "yes" : "no",
Arnaud Patard3804a892010-04-29 11:58:44 +0200487 (rtc_control & RTC_DM_BINARY) ? "no" : "yes",
David Brownell7be2c7c2007-02-10 01:46:02 -0800488 (rtc_control & RTC_DST_EN) ? "yes" : "no",
489 cmos->rtc->irq_freq,
490 (valid & RTC_VRT) ? "okay" : "dead");
491}
492
493#else
494#define cmos_procfs NULL
495#endif
496
497static const struct rtc_class_ops cmos_rtc_ops = {
Herton Ronaldo Krzesinskia8462ef2009-12-15 16:45:56 -0800498 .read_time = cmos_read_time,
499 .set_time = cmos_set_time,
500 .read_alarm = cmos_read_alarm,
501 .set_alarm = cmos_set_alarm,
502 .proc = cmos_procfs,
503 .irq_set_freq = cmos_irq_set_freq,
504 .irq_set_state = cmos_irq_set_state,
505 .alarm_irq_enable = cmos_alarm_irq_enable,
506 .update_irq_enable = cmos_update_irq_enable,
David Brownell7be2c7c2007-02-10 01:46:02 -0800507};
508
509/*----------------------------------------------------------------*/
510
David Brownelle07e2322008-02-06 01:38:43 -0800511/*
512 * All these chips have at least 64 bytes of address space, shared by
513 * RTC registers and NVRAM. Most of those bytes of NVRAM are used
514 * by boot firmware. Modern chips have 128 or 256 bytes.
515 */
516
517#define NVRAM_OFFSET (RTC_REG_D + 1)
518
519static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700520cmos_nvram_read(struct file *filp, struct kobject *kobj,
521 struct bin_attribute *attr,
David Brownelle07e2322008-02-06 01:38:43 -0800522 char *buf, loff_t off, size_t count)
523{
524 int retval;
525
526 if (unlikely(off >= attr->size))
527 return 0;
David Brownellc8fc40c2008-10-18 20:27:47 -0700528 if (unlikely(off < 0))
529 return -EINVAL;
David Brownelle07e2322008-02-06 01:38:43 -0800530 if ((off + count) > attr->size)
531 count = attr->size - off;
532
David Brownellc8fc40c2008-10-18 20:27:47 -0700533 off += NVRAM_OFFSET;
David Brownelle07e2322008-02-06 01:38:43 -0800534 spin_lock_irq(&rtc_lock);
David Brownellc8fc40c2008-10-18 20:27:47 -0700535 for (retval = 0; count; count--, off++, retval++) {
536 if (off < 128)
537 *buf++ = CMOS_READ(off);
538 else if (can_bank2)
539 *buf++ = cmos_read_bank2(off);
540 else
541 break;
542 }
David Brownelle07e2322008-02-06 01:38:43 -0800543 spin_unlock_irq(&rtc_lock);
544
545 return retval;
546}
547
548static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700549cmos_nvram_write(struct file *filp, struct kobject *kobj,
550 struct bin_attribute *attr,
David Brownelle07e2322008-02-06 01:38:43 -0800551 char *buf, loff_t off, size_t count)
552{
553 struct cmos_rtc *cmos;
554 int retval;
555
556 cmos = dev_get_drvdata(container_of(kobj, struct device, kobj));
557 if (unlikely(off >= attr->size))
558 return -EFBIG;
David Brownellc8fc40c2008-10-18 20:27:47 -0700559 if (unlikely(off < 0))
560 return -EINVAL;
David Brownelle07e2322008-02-06 01:38:43 -0800561 if ((off + count) > attr->size)
562 count = attr->size - off;
563
564 /* NOTE: on at least PCs and Ataris, the boot firmware uses a
565 * checksum on part of the NVRAM data. That's currently ignored
566 * here. If userspace is smart enough to know what fields of
567 * NVRAM to update, updating checksums is also part of its job.
568 */
David Brownellc8fc40c2008-10-18 20:27:47 -0700569 off += NVRAM_OFFSET;
David Brownelle07e2322008-02-06 01:38:43 -0800570 spin_lock_irq(&rtc_lock);
David Brownellc8fc40c2008-10-18 20:27:47 -0700571 for (retval = 0; count; count--, off++, retval++) {
David Brownelle07e2322008-02-06 01:38:43 -0800572 /* don't trash RTC registers */
573 if (off == cmos->day_alrm
574 || off == cmos->mon_alrm
575 || off == cmos->century)
576 buf++;
David Brownellc8fc40c2008-10-18 20:27:47 -0700577 else if (off < 128)
David Brownelle07e2322008-02-06 01:38:43 -0800578 CMOS_WRITE(*buf++, off);
David Brownellc8fc40c2008-10-18 20:27:47 -0700579 else if (can_bank2)
580 cmos_write_bank2(*buf++, off);
581 else
582 break;
David Brownelle07e2322008-02-06 01:38:43 -0800583 }
584 spin_unlock_irq(&rtc_lock);
585
586 return retval;
587}
588
589static struct bin_attribute nvram = {
590 .attr = {
591 .name = "nvram",
592 .mode = S_IRUGO | S_IWUSR,
David Brownelle07e2322008-02-06 01:38:43 -0800593 },
594
595 .read = cmos_nvram_read,
596 .write = cmos_nvram_write,
597 /* size gets set up later */
598};
599
600/*----------------------------------------------------------------*/
601
David Brownell7be2c7c2007-02-10 01:46:02 -0800602static struct cmos_rtc cmos_rtc;
603
604static irqreturn_t cmos_interrupt(int irq, void *p)
605{
606 u8 irqstat;
David Brownell8a0bdfd2008-02-06 01:38:45 -0800607 u8 rtc_control;
David Brownell7be2c7c2007-02-10 01:46:02 -0800608
609 spin_lock(&rtc_lock);
David Brownell35d3fdd2008-07-23 21:30:43 -0700610
611 /* When the HPET interrupt handler calls us, the interrupt
612 * status is passed as arg1 instead of the irq number. But
613 * always clear irq status, even when HPET is in the way.
614 *
615 * Note that HPET and RTC are almost certainly out of phase,
616 * giving different IRQ status ...
Bernhard Walle9d8af782008-02-06 01:38:52 -0800617 */
David Brownell35d3fdd2008-07-23 21:30:43 -0700618 irqstat = CMOS_READ(RTC_INTR_FLAGS);
619 rtc_control = CMOS_READ(RTC_CONTROL);
Bernhard Walle9d8af782008-02-06 01:38:52 -0800620 if (is_hpet_enabled())
621 irqstat = (unsigned long)irq & 0xF0;
David Brownell35d3fdd2008-07-23 21:30:43 -0700622 irqstat &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
David Brownell8a0bdfd2008-02-06 01:38:45 -0800623
624 /* All Linux RTC alarms should be treated as if they were oneshot.
625 * Similar code may be needed in system wakeup paths, in case the
626 * alarm woke the system.
627 */
628 if (irqstat & RTC_AIE) {
629 rtc_control &= ~RTC_AIE;
630 CMOS_WRITE(rtc_control, RTC_CONTROL);
David Brownell35d3fdd2008-07-23 21:30:43 -0700631 hpet_mask_rtc_irq_bit(RTC_AIE);
632
David Brownell8a0bdfd2008-02-06 01:38:45 -0800633 CMOS_READ(RTC_INTR_FLAGS);
634 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800635 spin_unlock(&rtc_lock);
636
David Brownellbcd9b892007-04-01 23:49:47 -0700637 if (is_intr(irqstat)) {
David Brownell7be2c7c2007-02-10 01:46:02 -0800638 rtc_update_irq(p, 1, irqstat);
639 return IRQ_HANDLED;
640 } else
641 return IRQ_NONE;
642}
643
Marko Vrh41ac8df2007-05-08 00:34:09 -0700644#ifdef CONFIG_PNP
David Brownell7be2c7c2007-02-10 01:46:02 -0800645#define INITSECTION
646
647#else
David Brownell7be2c7c2007-02-10 01:46:02 -0800648#define INITSECTION __init
649#endif
650
651static int INITSECTION
652cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
653{
654 struct cmos_rtc_board_info *info = dev->platform_data;
655 int retval = 0;
656 unsigned char rtc_control;
David Brownelle07e2322008-02-06 01:38:43 -0800657 unsigned address_space;
David Brownell7be2c7c2007-02-10 01:46:02 -0800658
659 /* there can be only one ... */
660 if (cmos_rtc.dev)
661 return -EBUSY;
662
663 if (!ports)
664 return -ENODEV;
665
David Brownell05440df2007-10-16 01:28:21 -0700666 /* Claim I/O ports ASAP, minimizing conflict with legacy driver.
667 *
668 * REVISIT non-x86 systems may instead use memory space resources
669 * (needing ioremap etc), not i/o space resources like this ...
670 */
671 ports = request_region(ports->start,
672 ports->end + 1 - ports->start,
673 driver_name);
674 if (!ports) {
675 dev_dbg(dev, "i/o registers already in use\n");
676 return -EBUSY;
677 }
678
David Brownell7be2c7c2007-02-10 01:46:02 -0800679 cmos_rtc.irq = rtc_irq;
680 cmos_rtc.iomem = ports;
681
David Brownelle07e2322008-02-06 01:38:43 -0800682 /* Heuristic to deduce NVRAM size ... do what the legacy NVRAM
683 * driver did, but don't reject unknown configs. Old hardware
David Brownellc8fc40c2008-10-18 20:27:47 -0700684 * won't address 128 bytes. Newer chips have multiple banks,
685 * though they may not be listed in one I/O resource.
David Brownelle07e2322008-02-06 01:38:43 -0800686 */
687#if defined(CONFIG_ATARI)
688 address_space = 64;
Wu Zhangjin95abd0d2009-11-05 09:21:54 +0800689#elif defined(__i386__) || defined(__x86_64__) || defined(__arm__) \
Srikanth Krishnakar8cb7c712010-10-14 04:03:35 +0000690 || defined(__sparc__) || defined(__mips__) \
691 || defined(__powerpc__)
David Brownelle07e2322008-02-06 01:38:43 -0800692 address_space = 128;
693#else
694#warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes.
695 address_space = 128;
696#endif
David Brownellc8fc40c2008-10-18 20:27:47 -0700697 if (can_bank2 && ports->end > (ports->start + 1))
698 address_space = 256;
David Brownelle07e2322008-02-06 01:38:43 -0800699
David Brownell87ac84f2007-05-08 00:34:00 -0700700 /* For ACPI systems extension info comes from the FADT. On others,
701 * board specific setup provides it as appropriate. Systems where
702 * the alarm IRQ isn't automatically a wakeup IRQ (like ACPI, and
703 * some almost-clones) can provide hooks to make that behave.
David Brownelle07e2322008-02-06 01:38:43 -0800704 *
705 * Note that ACPI doesn't preclude putting these registers into
706 * "extended" areas of the chip, including some that we won't yet
707 * expect CMOS_READ and friends to handle.
David Brownell7be2c7c2007-02-10 01:46:02 -0800708 */
709 if (info) {
David Brownelle07e2322008-02-06 01:38:43 -0800710 if (info->rtc_day_alarm && info->rtc_day_alarm < 128)
711 cmos_rtc.day_alrm = info->rtc_day_alarm;
712 if (info->rtc_mon_alarm && info->rtc_mon_alarm < 128)
713 cmos_rtc.mon_alrm = info->rtc_mon_alarm;
714 if (info->rtc_century && info->rtc_century < 128)
715 cmos_rtc.century = info->rtc_century;
David Brownell87ac84f2007-05-08 00:34:00 -0700716
717 if (info->wake_on && info->wake_off) {
718 cmos_rtc.wake_on = info->wake_on;
719 cmos_rtc.wake_off = info->wake_off;
720 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800721 }
722
Dan Carpenter6ba8bcd2010-05-24 14:33:49 -0700723 cmos_rtc.dev = dev;
724 dev_set_drvdata(dev, &cmos_rtc);
725
David Brownell7be2c7c2007-02-10 01:46:02 -0800726 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
Kay Sieversd4afc762009-01-06 14:42:11 -0800733 rename_region(ports, dev_name(&cmos_rtc.rtc->dev));
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
Arnaud Patard3804a892010-04-29 11:58:44 +0200754 /* FIXME:
David Brownell7be2c7c2007-02-10 01:46:02 -0800755 * <asm-generic/rtc.h> doesn't know 12-hour mode either.
756 */
Arnaud Patard3804a892010-04-29 11:58:44 +0200757 if (is_valid_irq(rtc_irq) && !(rtc_control & RTC_24H)) {
758 dev_warn(dev, "only 24-hr supported\n");
David Brownell7be2c7c2007-02-10 01:46:02 -0800759 retval = -ENXIO;
760 goto cleanup1;
761 }
762
Bernhard Walle9d8af782008-02-06 01:38:52 -0800763 if (is_valid_irq(rtc_irq)) {
764 irq_handler_t rtc_cmos_int_handler;
765
766 if (is_hpet_enabled()) {
767 int err;
768
769 rtc_cmos_int_handler = hpet_rtc_interrupt;
770 err = hpet_register_irq_handler(cmos_interrupt);
771 if (err != 0) {
772 printk(KERN_WARNING "hpet_register_irq_handler "
773 " failed in rtc_init().");
774 goto cleanup1;
775 }
776 } else
777 rtc_cmos_int_handler = cmos_interrupt;
778
779 retval = request_irq(rtc_irq, rtc_cmos_int_handler,
Kay Sieversd4afc762009-01-06 14:42:11 -0800780 IRQF_DISABLED, dev_name(&cmos_rtc.rtc->dev),
David Brownellab6a2d72007-05-08 00:33:30 -0700781 cmos_rtc.rtc);
Bernhard Walle9d8af782008-02-06 01:38:52 -0800782 if (retval < 0) {
783 dev_dbg(dev, "IRQ %d is already in use\n", rtc_irq);
784 goto cleanup1;
785 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800786 }
Bernhard Walle9d8af782008-02-06 01:38:52 -0800787 hpet_rtc_timer_init();
David Brownell7be2c7c2007-02-10 01:46:02 -0800788
David Brownelle07e2322008-02-06 01:38:43 -0800789 /* export at least the first block of NVRAM */
790 nvram.size = address_space - NVRAM_OFFSET;
791 retval = sysfs_create_bin_file(&dev->kobj, &nvram);
792 if (retval < 0) {
793 dev_dbg(dev, "can't create nvram file? %d\n", retval);
794 goto cleanup2;
795 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800796
Krzysztof Halasa6d029b62009-04-21 12:24:49 -0700797 pr_info("%s: %s%s, %zd bytes nvram%s\n",
798 dev_name(&cmos_rtc.rtc->dev),
799 !is_valid_irq(rtc_irq) ? "no alarms" :
800 cmos_rtc.mon_alrm ? "alarms up to one year" :
801 cmos_rtc.day_alrm ? "alarms up to one month" :
802 "alarms up to one day",
803 cmos_rtc.century ? ", y3k" : "",
804 nvram.size,
805 is_hpet_enabled() ? ", hpet irqs" : "");
David Brownell7be2c7c2007-02-10 01:46:02 -0800806
807 return 0;
808
David Brownelle07e2322008-02-06 01:38:43 -0800809cleanup2:
810 if (is_valid_irq(rtc_irq))
811 free_irq(rtc_irq, cmos_rtc.rtc);
David Brownell7be2c7c2007-02-10 01:46:02 -0800812cleanup1:
David Brownell05440df2007-10-16 01:28:21 -0700813 cmos_rtc.dev = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800814 rtc_device_unregister(cmos_rtc.rtc);
David Brownell05440df2007-10-16 01:28:21 -0700815cleanup0:
816 release_region(ports->start, ports->end + 1 - ports->start);
David Brownell7be2c7c2007-02-10 01:46:02 -0800817 return retval;
818}
819
820static void cmos_do_shutdown(void)
821{
David Brownell7be2c7c2007-02-10 01:46:02 -0800822 spin_lock_irq(&rtc_lock);
David Brownell7e2a31d2008-07-23 21:30:47 -0700823 cmos_irq_disable(&cmos_rtc, RTC_IRQMASK);
David Brownell7be2c7c2007-02-10 01:46:02 -0800824 spin_unlock_irq(&rtc_lock);
825}
826
827static void __exit cmos_do_remove(struct device *dev)
828{
829 struct cmos_rtc *cmos = dev_get_drvdata(dev);
David Brownell05440df2007-10-16 01:28:21 -0700830 struct resource *ports;
David Brownell7be2c7c2007-02-10 01:46:02 -0800831
832 cmos_do_shutdown();
833
David Brownelle07e2322008-02-06 01:38:43 -0800834 sysfs_remove_bin_file(&dev->kobj, &nvram);
835
Bernhard Walle9d8af782008-02-06 01:38:52 -0800836 if (is_valid_irq(cmos->irq)) {
David Brownell05440df2007-10-16 01:28:21 -0700837 free_irq(cmos->irq, cmos->rtc);
Bernhard Walle9d8af782008-02-06 01:38:52 -0800838 hpet_unregister_irq_handler(cmos_interrupt);
839 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800840
David Brownell05440df2007-10-16 01:28:21 -0700841 rtc_device_unregister(cmos->rtc);
842 cmos->rtc = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800843
David Brownell05440df2007-10-16 01:28:21 -0700844 ports = cmos->iomem;
845 release_region(ports->start, ports->end + 1 - ports->start);
846 cmos->iomem = NULL;
847
848 cmos->dev = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800849 dev_set_drvdata(dev, NULL);
850}
851
852#ifdef CONFIG_PM
853
854static int cmos_suspend(struct device *dev, pm_message_t mesg)
855{
856 struct cmos_rtc *cmos = dev_get_drvdata(dev);
David Brownellbcd9b892007-04-01 23:49:47 -0700857 unsigned char tmp;
David Brownell7be2c7c2007-02-10 01:46:02 -0800858
859 /* only the alarm might be a wakeup event source */
860 spin_lock_irq(&rtc_lock);
861 cmos->suspend_ctrl = tmp = CMOS_READ(RTC_CONTROL);
862 if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
David Brownell35d3fdd2008-07-23 21:30:43 -0700863 unsigned char mask;
David Brownellbcd9b892007-04-01 23:49:47 -0700864
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700865 if (device_may_wakeup(dev))
David Brownell35d3fdd2008-07-23 21:30:43 -0700866 mask = RTC_IRQMASK & ~RTC_AIE;
David Brownell7be2c7c2007-02-10 01:46:02 -0800867 else
David Brownell35d3fdd2008-07-23 21:30:43 -0700868 mask = RTC_IRQMASK;
869 tmp &= ~mask;
David Brownell7be2c7c2007-02-10 01:46:02 -0800870 CMOS_WRITE(tmp, RTC_CONTROL);
David Brownell35d3fdd2008-07-23 21:30:43 -0700871
Maxim Levitskyd1b2efa2009-12-15 16:45:52 -0800872 /* shut down hpet emulation - we don't need it for alarm */
873 hpet_mask_rtc_irq_bit(RTC_PIE|RTC_AIE|RTC_UIE);
David Brownell7e2a31d2008-07-23 21:30:47 -0700874 cmos_checkintr(cmos, tmp);
David Brownellbcd9b892007-04-01 23:49:47 -0700875 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800876 spin_unlock_irq(&rtc_lock);
877
David Brownell87ac84f2007-05-08 00:34:00 -0700878 if (tmp & RTC_AIE) {
879 cmos->enabled_wake = 1;
880 if (cmos->wake_on)
881 cmos->wake_on(dev);
882 else
883 enable_irq_wake(cmos->irq);
884 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800885
886 pr_debug("%s: suspend%s, ctrl %02x\n",
Kay Sieversd4afc762009-01-06 14:42:11 -0800887 dev_name(&cmos_rtc.rtc->dev),
David Brownell7be2c7c2007-02-10 01:46:02 -0800888 (tmp & RTC_AIE) ? ", alarm may wake" : "",
889 tmp);
890
891 return 0;
892}
893
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700894/* We want RTC alarms to wake us from e.g. ACPI G2/S5 "soft off", even
895 * after a detour through G3 "mechanical off", although the ACPI spec
896 * says wakeup should only work from G1/S4 "hibernate". To most users,
897 * distinctions between S4 and S5 are pointless. So when the hardware
898 * allows, don't draw that distinction.
899 */
900static inline int cmos_poweroff(struct device *dev)
901{
902 return cmos_suspend(dev, PMSG_HIBERNATE);
903}
904
David Brownell7be2c7c2007-02-10 01:46:02 -0800905static int cmos_resume(struct device *dev)
906{
907 struct cmos_rtc *cmos = dev_get_drvdata(dev);
908 unsigned char tmp = cmos->suspend_ctrl;
909
David Brownell7be2c7c2007-02-10 01:46:02 -0800910 /* re-enable any irqs previously active */
David Brownell35d3fdd2008-07-23 21:30:43 -0700911 if (tmp & RTC_IRQMASK) {
912 unsigned char mask;
David Brownell7be2c7c2007-02-10 01:46:02 -0800913
David Brownell87ac84f2007-05-08 00:34:00 -0700914 if (cmos->enabled_wake) {
915 if (cmos->wake_off)
916 cmos->wake_off(dev);
917 else
918 disable_irq_wake(cmos->irq);
919 cmos->enabled_wake = 0;
920 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800921
922 spin_lock_irq(&rtc_lock);
David Brownell35d3fdd2008-07-23 21:30:43 -0700923 do {
924 CMOS_WRITE(tmp, RTC_CONTROL);
925 hpet_set_rtc_irq_bit(tmp & RTC_IRQMASK);
926
927 mask = CMOS_READ(RTC_INTR_FLAGS);
928 mask &= (tmp & RTC_IRQMASK) | RTC_IRQF;
David Brownell7e2a31d2008-07-23 21:30:47 -0700929 if (!is_hpet_enabled() || !is_intr(mask))
David Brownell35d3fdd2008-07-23 21:30:43 -0700930 break;
931
932 /* force one-shot behavior if HPET blocked
933 * the wake alarm's irq
934 */
935 rtc_update_irq(cmos->rtc, 1, mask);
936 tmp &= ~RTC_AIE;
937 hpet_mask_rtc_irq_bit(RTC_AIE);
938 } while (mask & RTC_AIE);
David Brownellbcd9b892007-04-01 23:49:47 -0700939 spin_unlock_irq(&rtc_lock);
David Brownell7be2c7c2007-02-10 01:46:02 -0800940 }
941
942 pr_debug("%s: resume, ctrl %02x\n",
Kay Sieversd4afc762009-01-06 14:42:11 -0800943 dev_name(&cmos_rtc.rtc->dev),
David Brownell35d3fdd2008-07-23 21:30:43 -0700944 tmp);
David Brownell7be2c7c2007-02-10 01:46:02 -0800945
946 return 0;
947}
948
949#else
950#define cmos_suspend NULL
951#define cmos_resume NULL
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700952
953static inline int cmos_poweroff(struct device *dev)
954{
955 return -ENOSYS;
956}
957
David Brownell7be2c7c2007-02-10 01:46:02 -0800958#endif
959
960/*----------------------------------------------------------------*/
961
David Brownelle07e2322008-02-06 01:38:43 -0800962/* On non-x86 systems, a "CMOS" RTC lives most naturally on platform_bus.
963 * ACPI systems always list these as PNPACPI devices, and pre-ACPI PCs
964 * probably list them in similar PNPBIOS tables; so PNP is more common.
965 *
966 * We don't use legacy "poke at the hardware" probing. Ancient PCs that
967 * predate even PNPBIOS should set up platform_bus devices.
David Brownell7be2c7c2007-02-10 01:46:02 -0800968 */
969
Bjorn Helgaasa474aae2008-10-14 13:50:21 -0600970#ifdef CONFIG_ACPI
971
972#include <linux/acpi.h>
973
Bjorn Helgaasa474aae2008-10-14 13:50:21 -0600974static u32 rtc_handler(void *context)
975{
976 acpi_clear_event(ACPI_EVENT_RTC);
977 acpi_disable_event(ACPI_EVENT_RTC, 0);
978 return ACPI_INTERRUPT_HANDLED;
979}
980
981static inline void rtc_wake_setup(void)
982{
983 acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
984 /*
985 * After the RTC handler is installed, the Fixed_RTC event should
986 * be disabled. Only when the RTC alarm is set will it be enabled.
987 */
988 acpi_clear_event(ACPI_EVENT_RTC);
989 acpi_disable_event(ACPI_EVENT_RTC, 0);
990}
991
992static void rtc_wake_on(struct device *dev)
993{
994 acpi_clear_event(ACPI_EVENT_RTC);
995 acpi_enable_event(ACPI_EVENT_RTC, 0);
996}
997
998static void rtc_wake_off(struct device *dev)
999{
1000 acpi_disable_event(ACPI_EVENT_RTC, 0);
1001}
Bjorn Helgaasa474aae2008-10-14 13:50:21 -06001002
1003/* Every ACPI platform has a mc146818 compatible "cmos rtc". Here we find
1004 * its device node and pass extra config data. This helps its driver use
1005 * capabilities that the now-obsolete mc146818 didn't have, and informs it
1006 * that this board's RTC is wakeup-capable (per ACPI spec).
1007 */
1008static struct cmos_rtc_board_info acpi_rtc_info;
1009
1010static void __devinit
1011cmos_wake_setup(struct device *dev)
1012{
1013 if (acpi_disabled)
1014 return;
1015
1016 rtc_wake_setup();
1017 acpi_rtc_info.wake_on = rtc_wake_on;
1018 acpi_rtc_info.wake_off = rtc_wake_off;
1019
1020 /* workaround bug in some ACPI tables */
1021 if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
1022 dev_dbg(dev, "bogus FADT month_alarm (%d)\n",
1023 acpi_gbl_FADT.month_alarm);
1024 acpi_gbl_FADT.month_alarm = 0;
1025 }
1026
1027 acpi_rtc_info.rtc_day_alarm = acpi_gbl_FADT.day_alarm;
1028 acpi_rtc_info.rtc_mon_alarm = acpi_gbl_FADT.month_alarm;
1029 acpi_rtc_info.rtc_century = acpi_gbl_FADT.century;
1030
1031 /* NOTE: S4_RTC_WAKE is NOT currently useful to Linux */
1032 if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
1033 dev_info(dev, "RTC can wake from S4\n");
1034
1035 dev->platform_data = &acpi_rtc_info;
1036
1037 /* RTC always wakes from S1/S2/S3, and often S4/STD */
1038 device_init_wakeup(dev, 1);
1039}
1040
1041#else
1042
1043static void __devinit
1044cmos_wake_setup(struct device *dev)
1045{
1046}
1047
1048#endif
1049
Marko Vrh41ac8df2007-05-08 00:34:09 -07001050#ifdef CONFIG_PNP
David Brownell7be2c7c2007-02-10 01:46:02 -08001051
1052#include <linux/pnp.h>
1053
1054static int __devinit
1055cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
1056{
Bjorn Helgaasa474aae2008-10-14 13:50:21 -06001057 cmos_wake_setup(&pnp->dev);
1058
Matthew Garrett6cd8fa82007-06-01 00:46:51 -07001059 if (pnp_port_start(pnp,0) == 0x70 && !pnp_irq_valid(pnp,0))
1060 /* Some machines contain a PNP entry for the RTC, but
1061 * don't define the IRQ. It should always be safe to
1062 * hardcode it in these cases
1063 */
Bjorn Helgaas8766ad02008-04-28 16:34:27 -06001064 return cmos_do_probe(&pnp->dev,
1065 pnp_get_resource(pnp, IORESOURCE_IO, 0), 8);
Matthew Garrett6cd8fa82007-06-01 00:46:51 -07001066 else
1067 return cmos_do_probe(&pnp->dev,
Bjorn Helgaas8766ad02008-04-28 16:34:27 -06001068 pnp_get_resource(pnp, IORESOURCE_IO, 0),
1069 pnp_irq(pnp, 0));
David Brownell7be2c7c2007-02-10 01:46:02 -08001070}
1071
1072static void __exit cmos_pnp_remove(struct pnp_dev *pnp)
1073{
1074 cmos_do_remove(&pnp->dev);
1075}
1076
1077#ifdef CONFIG_PM
1078
1079static int cmos_pnp_suspend(struct pnp_dev *pnp, pm_message_t mesg)
1080{
1081 return cmos_suspend(&pnp->dev, mesg);
1082}
1083
1084static int cmos_pnp_resume(struct pnp_dev *pnp)
1085{
1086 return cmos_resume(&pnp->dev);
1087}
1088
1089#else
1090#define cmos_pnp_suspend NULL
1091#define cmos_pnp_resume NULL
1092#endif
1093
OGAWA Hirofumi004731b2010-01-08 14:43:11 -08001094static void cmos_pnp_shutdown(struct pnp_dev *pnp)
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001095{
OGAWA Hirofumi004731b2010-01-08 14:43:11 -08001096 if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(&pnp->dev))
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001097 return;
1098
1099 cmos_do_shutdown();
1100}
David Brownell7be2c7c2007-02-10 01:46:02 -08001101
1102static const struct pnp_device_id rtc_ids[] = {
1103 { .id = "PNP0b00", },
1104 { .id = "PNP0b01", },
1105 { .id = "PNP0b02", },
1106 { },
1107};
1108MODULE_DEVICE_TABLE(pnp, rtc_ids);
1109
1110static struct pnp_driver cmos_pnp_driver = {
1111 .name = (char *) driver_name,
1112 .id_table = rtc_ids,
1113 .probe = cmos_pnp_probe,
1114 .remove = __exit_p(cmos_pnp_remove),
OGAWA Hirofumi004731b2010-01-08 14:43:11 -08001115 .shutdown = cmos_pnp_shutdown,
David Brownell7be2c7c2007-02-10 01:46:02 -08001116
1117 /* flag ensures resume() gets called, and stops syslog spam */
1118 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
1119 .suspend = cmos_pnp_suspend,
1120 .resume = cmos_pnp_resume,
1121};
1122
Stas Sergeev1da2e3d2008-06-12 15:21:54 -07001123#endif /* CONFIG_PNP */
David Brownell7be2c7c2007-02-10 01:46:02 -08001124
1125/*----------------------------------------------------------------*/
1126
Marko Vrh41ac8df2007-05-08 00:34:09 -07001127/* Platform setup should have set up an RTC device, when PNP is
David Brownellbcd9b892007-04-01 23:49:47 -07001128 * unavailable ... this could happen even on (older) PCs.
David Brownell7be2c7c2007-02-10 01:46:02 -08001129 */
1130
1131static int __init cmos_platform_probe(struct platform_device *pdev)
1132{
Bjorn Helgaasa474aae2008-10-14 13:50:21 -06001133 cmos_wake_setup(&pdev->dev);
David Brownell7be2c7c2007-02-10 01:46:02 -08001134 return cmos_do_probe(&pdev->dev,
1135 platform_get_resource(pdev, IORESOURCE_IO, 0),
1136 platform_get_irq(pdev, 0));
1137}
1138
1139static int __exit cmos_platform_remove(struct platform_device *pdev)
1140{
1141 cmos_do_remove(&pdev->dev);
1142 return 0;
1143}
1144
1145static void cmos_platform_shutdown(struct platform_device *pdev)
1146{
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001147 if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(&pdev->dev))
1148 return;
1149
David Brownell7be2c7c2007-02-10 01:46:02 -08001150 cmos_do_shutdown();
1151}
1152
Kay Sieversad28a072008-04-10 21:29:25 -07001153/* work with hotplug and coldplug */
1154MODULE_ALIAS("platform:rtc_cmos");
1155
David Brownell7be2c7c2007-02-10 01:46:02 -08001156static struct platform_driver cmos_platform_driver = {
1157 .remove = __exit_p(cmos_platform_remove),
1158 .shutdown = cmos_platform_shutdown,
1159 .driver = {
1160 .name = (char *) driver_name,
1161 .suspend = cmos_suspend,
1162 .resume = cmos_resume,
1163 }
1164};
1165
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001166#ifdef CONFIG_PNP
1167static bool pnp_driver_registered;
1168#endif
1169static bool platform_driver_registered;
1170
David Brownell7be2c7c2007-02-10 01:46:02 -08001171static int __init cmos_init(void)
1172{
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001173 int retval = 0;
1174
Stas Sergeev1da2e3d2008-06-12 15:21:54 -07001175#ifdef CONFIG_PNP
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001176 retval = pnp_register_driver(&cmos_pnp_driver);
1177 if (retval == 0)
1178 pnp_driver_registered = true;
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001179#endif
1180
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001181 if (!cmos_rtc.dev) {
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001182 retval = platform_driver_probe(&cmos_platform_driver,
1183 cmos_platform_probe);
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001184 if (retval == 0)
1185 platform_driver_registered = true;
1186 }
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001187
1188 if (retval == 0)
1189 return 0;
1190
1191#ifdef CONFIG_PNP
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001192 if (pnp_driver_registered)
1193 pnp_unregister_driver(&cmos_pnp_driver);
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001194#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
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001202 if (pnp_driver_registered)
1203 pnp_unregister_driver(&cmos_pnp_driver);
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001204#endif
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001205 if (platform_driver_registered)
1206 platform_driver_unregister(&cmos_platform_driver);
David Brownell7be2c7c2007-02-10 01:46:02 -08001207}
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");