blob: 11b8ea29d2b76ecf0e60e482195629d4d04d17f6 [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__) \
690 || defined(__sparc__) || defined(__mips__)
David Brownelle07e2322008-02-06 01:38:43 -0800691 address_space = 128;
692#else
693#warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes.
694 address_space = 128;
695#endif
David Brownellc8fc40c2008-10-18 20:27:47 -0700696 if (can_bank2 && ports->end > (ports->start + 1))
697 address_space = 256;
David Brownelle07e2322008-02-06 01:38:43 -0800698
David Brownell87ac84f2007-05-08 00:34:00 -0700699 /* For ACPI systems extension info comes from the FADT. On others,
700 * board specific setup provides it as appropriate. Systems where
701 * the alarm IRQ isn't automatically a wakeup IRQ (like ACPI, and
702 * some almost-clones) can provide hooks to make that behave.
David Brownelle07e2322008-02-06 01:38:43 -0800703 *
704 * Note that ACPI doesn't preclude putting these registers into
705 * "extended" areas of the chip, including some that we won't yet
706 * expect CMOS_READ and friends to handle.
David Brownell7be2c7c2007-02-10 01:46:02 -0800707 */
708 if (info) {
David Brownelle07e2322008-02-06 01:38:43 -0800709 if (info->rtc_day_alarm && info->rtc_day_alarm < 128)
710 cmos_rtc.day_alrm = info->rtc_day_alarm;
711 if (info->rtc_mon_alarm && info->rtc_mon_alarm < 128)
712 cmos_rtc.mon_alrm = info->rtc_mon_alarm;
713 if (info->rtc_century && info->rtc_century < 128)
714 cmos_rtc.century = info->rtc_century;
David Brownell87ac84f2007-05-08 00:34:00 -0700715
716 if (info->wake_on && info->wake_off) {
717 cmos_rtc.wake_on = info->wake_on;
718 cmos_rtc.wake_off = info->wake_off;
719 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800720 }
721
Dan Carpenter6ba8bcd2010-05-24 14:33:49 -0700722 cmos_rtc.dev = dev;
723 dev_set_drvdata(dev, &cmos_rtc);
724
David Brownell7be2c7c2007-02-10 01:46:02 -0800725 cmos_rtc.rtc = rtc_device_register(driver_name, dev,
726 &cmos_rtc_ops, THIS_MODULE);
David Brownell05440df2007-10-16 01:28:21 -0700727 if (IS_ERR(cmos_rtc.rtc)) {
728 retval = PTR_ERR(cmos_rtc.rtc);
729 goto cleanup0;
730 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800731
Kay Sieversd4afc762009-01-06 14:42:11 -0800732 rename_region(ports, dev_name(&cmos_rtc.rtc->dev));
David Brownell7be2c7c2007-02-10 01:46:02 -0800733
734 spin_lock_irq(&rtc_lock);
735
736 /* force periodic irq to CMOS reset default of 1024Hz;
737 *
738 * REVISIT it's been reported that at least one x86_64 ALI mobo
739 * doesn't use 32KHz here ... for portability we might need to
740 * do something about other clock frequencies.
741 */
David Brownell7be2c7c2007-02-10 01:46:02 -0800742 cmos_rtc.rtc->irq_freq = 1024;
David Brownell35d3fdd2008-07-23 21:30:43 -0700743 hpet_set_periodic_freq(cmos_rtc.rtc->irq_freq);
744 CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT);
David Brownell7be2c7c2007-02-10 01:46:02 -0800745
David Brownell7e2a31d2008-07-23 21:30:47 -0700746 /* disable irqs */
747 cmos_irq_disable(&cmos_rtc, RTC_PIE | RTC_AIE | RTC_UIE);
David Brownell35d3fdd2008-07-23 21:30:43 -0700748
David Brownell7e2a31d2008-07-23 21:30:47 -0700749 rtc_control = CMOS_READ(RTC_CONTROL);
David Brownell7be2c7c2007-02-10 01:46:02 -0800750
751 spin_unlock_irq(&rtc_lock);
752
Arnaud Patard3804a892010-04-29 11:58:44 +0200753 /* FIXME:
David Brownell7be2c7c2007-02-10 01:46:02 -0800754 * <asm-generic/rtc.h> doesn't know 12-hour mode either.
755 */
Arnaud Patard3804a892010-04-29 11:58:44 +0200756 if (is_valid_irq(rtc_irq) && !(rtc_control & RTC_24H)) {
757 dev_warn(dev, "only 24-hr supported\n");
David Brownell7be2c7c2007-02-10 01:46:02 -0800758 retval = -ENXIO;
759 goto cleanup1;
760 }
761
Bernhard Walle9d8af782008-02-06 01:38:52 -0800762 if (is_valid_irq(rtc_irq)) {
763 irq_handler_t rtc_cmos_int_handler;
764
765 if (is_hpet_enabled()) {
766 int err;
767
768 rtc_cmos_int_handler = hpet_rtc_interrupt;
769 err = hpet_register_irq_handler(cmos_interrupt);
770 if (err != 0) {
771 printk(KERN_WARNING "hpet_register_irq_handler "
772 " failed in rtc_init().");
773 goto cleanup1;
774 }
775 } else
776 rtc_cmos_int_handler = cmos_interrupt;
777
778 retval = request_irq(rtc_irq, rtc_cmos_int_handler,
Kay Sieversd4afc762009-01-06 14:42:11 -0800779 IRQF_DISABLED, dev_name(&cmos_rtc.rtc->dev),
David Brownellab6a2d72007-05-08 00:33:30 -0700780 cmos_rtc.rtc);
Bernhard Walle9d8af782008-02-06 01:38:52 -0800781 if (retval < 0) {
782 dev_dbg(dev, "IRQ %d is already in use\n", rtc_irq);
783 goto cleanup1;
784 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800785 }
Bernhard Walle9d8af782008-02-06 01:38:52 -0800786 hpet_rtc_timer_init();
David Brownell7be2c7c2007-02-10 01:46:02 -0800787
David Brownelle07e2322008-02-06 01:38:43 -0800788 /* export at least the first block of NVRAM */
789 nvram.size = address_space - NVRAM_OFFSET;
790 retval = sysfs_create_bin_file(&dev->kobj, &nvram);
791 if (retval < 0) {
792 dev_dbg(dev, "can't create nvram file? %d\n", retval);
793 goto cleanup2;
794 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800795
Krzysztof Halasa6d029b62009-04-21 12:24:49 -0700796 pr_info("%s: %s%s, %zd bytes nvram%s\n",
797 dev_name(&cmos_rtc.rtc->dev),
798 !is_valid_irq(rtc_irq) ? "no alarms" :
799 cmos_rtc.mon_alrm ? "alarms up to one year" :
800 cmos_rtc.day_alrm ? "alarms up to one month" :
801 "alarms up to one day",
802 cmos_rtc.century ? ", y3k" : "",
803 nvram.size,
804 is_hpet_enabled() ? ", hpet irqs" : "");
David Brownell7be2c7c2007-02-10 01:46:02 -0800805
806 return 0;
807
David Brownelle07e2322008-02-06 01:38:43 -0800808cleanup2:
809 if (is_valid_irq(rtc_irq))
810 free_irq(rtc_irq, cmos_rtc.rtc);
David Brownell7be2c7c2007-02-10 01:46:02 -0800811cleanup1:
David Brownell05440df2007-10-16 01:28:21 -0700812 cmos_rtc.dev = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800813 rtc_device_unregister(cmos_rtc.rtc);
David Brownell05440df2007-10-16 01:28:21 -0700814cleanup0:
815 release_region(ports->start, ports->end + 1 - ports->start);
David Brownell7be2c7c2007-02-10 01:46:02 -0800816 return retval;
817}
818
819static void cmos_do_shutdown(void)
820{
David Brownell7be2c7c2007-02-10 01:46:02 -0800821 spin_lock_irq(&rtc_lock);
David Brownell7e2a31d2008-07-23 21:30:47 -0700822 cmos_irq_disable(&cmos_rtc, RTC_IRQMASK);
David Brownell7be2c7c2007-02-10 01:46:02 -0800823 spin_unlock_irq(&rtc_lock);
824}
825
826static void __exit cmos_do_remove(struct device *dev)
827{
828 struct cmos_rtc *cmos = dev_get_drvdata(dev);
David Brownell05440df2007-10-16 01:28:21 -0700829 struct resource *ports;
David Brownell7be2c7c2007-02-10 01:46:02 -0800830
831 cmos_do_shutdown();
832
David Brownelle07e2322008-02-06 01:38:43 -0800833 sysfs_remove_bin_file(&dev->kobj, &nvram);
834
Bernhard Walle9d8af782008-02-06 01:38:52 -0800835 if (is_valid_irq(cmos->irq)) {
David Brownell05440df2007-10-16 01:28:21 -0700836 free_irq(cmos->irq, cmos->rtc);
Bernhard Walle9d8af782008-02-06 01:38:52 -0800837 hpet_unregister_irq_handler(cmos_interrupt);
838 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800839
David Brownell05440df2007-10-16 01:28:21 -0700840 rtc_device_unregister(cmos->rtc);
841 cmos->rtc = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800842
David Brownell05440df2007-10-16 01:28:21 -0700843 ports = cmos->iomem;
844 release_region(ports->start, ports->end + 1 - ports->start);
845 cmos->iomem = NULL;
846
847 cmos->dev = NULL;
David Brownell7be2c7c2007-02-10 01:46:02 -0800848 dev_set_drvdata(dev, NULL);
849}
850
851#ifdef CONFIG_PM
852
853static int cmos_suspend(struct device *dev, pm_message_t mesg)
854{
855 struct cmos_rtc *cmos = dev_get_drvdata(dev);
David Brownellbcd9b892007-04-01 23:49:47 -0700856 unsigned char tmp;
David Brownell7be2c7c2007-02-10 01:46:02 -0800857
858 /* only the alarm might be a wakeup event source */
859 spin_lock_irq(&rtc_lock);
860 cmos->suspend_ctrl = tmp = CMOS_READ(RTC_CONTROL);
861 if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
David Brownell35d3fdd2008-07-23 21:30:43 -0700862 unsigned char mask;
David Brownellbcd9b892007-04-01 23:49:47 -0700863
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700864 if (device_may_wakeup(dev))
David Brownell35d3fdd2008-07-23 21:30:43 -0700865 mask = RTC_IRQMASK & ~RTC_AIE;
David Brownell7be2c7c2007-02-10 01:46:02 -0800866 else
David Brownell35d3fdd2008-07-23 21:30:43 -0700867 mask = RTC_IRQMASK;
868 tmp &= ~mask;
David Brownell7be2c7c2007-02-10 01:46:02 -0800869 CMOS_WRITE(tmp, RTC_CONTROL);
David Brownell35d3fdd2008-07-23 21:30:43 -0700870
Maxim Levitskyd1b2efa2009-12-15 16:45:52 -0800871 /* shut down hpet emulation - we don't need it for alarm */
872 hpet_mask_rtc_irq_bit(RTC_PIE|RTC_AIE|RTC_UIE);
David Brownell7e2a31d2008-07-23 21:30:47 -0700873 cmos_checkintr(cmos, tmp);
David Brownellbcd9b892007-04-01 23:49:47 -0700874 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800875 spin_unlock_irq(&rtc_lock);
876
David Brownell87ac84f2007-05-08 00:34:00 -0700877 if (tmp & RTC_AIE) {
878 cmos->enabled_wake = 1;
879 if (cmos->wake_on)
880 cmos->wake_on(dev);
881 else
882 enable_irq_wake(cmos->irq);
883 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800884
885 pr_debug("%s: suspend%s, ctrl %02x\n",
Kay Sieversd4afc762009-01-06 14:42:11 -0800886 dev_name(&cmos_rtc.rtc->dev),
David Brownell7be2c7c2007-02-10 01:46:02 -0800887 (tmp & RTC_AIE) ? ", alarm may wake" : "",
888 tmp);
889
890 return 0;
891}
892
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700893/* We want RTC alarms to wake us from e.g. ACPI G2/S5 "soft off", even
894 * after a detour through G3 "mechanical off", although the ACPI spec
895 * says wakeup should only work from G1/S4 "hibernate". To most users,
896 * distinctions between S4 and S5 are pointless. So when the hardware
897 * allows, don't draw that distinction.
898 */
899static inline int cmos_poweroff(struct device *dev)
900{
901 return cmos_suspend(dev, PMSG_HIBERNATE);
902}
903
David Brownell7be2c7c2007-02-10 01:46:02 -0800904static int cmos_resume(struct device *dev)
905{
906 struct cmos_rtc *cmos = dev_get_drvdata(dev);
907 unsigned char tmp = cmos->suspend_ctrl;
908
David Brownell7be2c7c2007-02-10 01:46:02 -0800909 /* re-enable any irqs previously active */
David Brownell35d3fdd2008-07-23 21:30:43 -0700910 if (tmp & RTC_IRQMASK) {
911 unsigned char mask;
David Brownell7be2c7c2007-02-10 01:46:02 -0800912
David Brownell87ac84f2007-05-08 00:34:00 -0700913 if (cmos->enabled_wake) {
914 if (cmos->wake_off)
915 cmos->wake_off(dev);
916 else
917 disable_irq_wake(cmos->irq);
918 cmos->enabled_wake = 0;
919 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800920
921 spin_lock_irq(&rtc_lock);
David Brownell35d3fdd2008-07-23 21:30:43 -0700922 do {
923 CMOS_WRITE(tmp, RTC_CONTROL);
924 hpet_set_rtc_irq_bit(tmp & RTC_IRQMASK);
925
926 mask = CMOS_READ(RTC_INTR_FLAGS);
927 mask &= (tmp & RTC_IRQMASK) | RTC_IRQF;
David Brownell7e2a31d2008-07-23 21:30:47 -0700928 if (!is_hpet_enabled() || !is_intr(mask))
David Brownell35d3fdd2008-07-23 21:30:43 -0700929 break;
930
931 /* force one-shot behavior if HPET blocked
932 * the wake alarm's irq
933 */
934 rtc_update_irq(cmos->rtc, 1, mask);
935 tmp &= ~RTC_AIE;
936 hpet_mask_rtc_irq_bit(RTC_AIE);
937 } while (mask & RTC_AIE);
David Brownellbcd9b892007-04-01 23:49:47 -0700938 spin_unlock_irq(&rtc_lock);
David Brownell7be2c7c2007-02-10 01:46:02 -0800939 }
940
941 pr_debug("%s: resume, ctrl %02x\n",
Kay Sieversd4afc762009-01-06 14:42:11 -0800942 dev_name(&cmos_rtc.rtc->dev),
David Brownell35d3fdd2008-07-23 21:30:43 -0700943 tmp);
David Brownell7be2c7c2007-02-10 01:46:02 -0800944
945 return 0;
946}
947
948#else
949#define cmos_suspend NULL
950#define cmos_resume NULL
Rafael J. Wysocki74c46332008-09-02 14:36:11 -0700951
952static inline int cmos_poweroff(struct device *dev)
953{
954 return -ENOSYS;
955}
956
David Brownell7be2c7c2007-02-10 01:46:02 -0800957#endif
958
959/*----------------------------------------------------------------*/
960
David Brownelle07e2322008-02-06 01:38:43 -0800961/* On non-x86 systems, a "CMOS" RTC lives most naturally on platform_bus.
962 * ACPI systems always list these as PNPACPI devices, and pre-ACPI PCs
963 * probably list them in similar PNPBIOS tables; so PNP is more common.
964 *
965 * We don't use legacy "poke at the hardware" probing. Ancient PCs that
966 * predate even PNPBIOS should set up platform_bus devices.
David Brownell7be2c7c2007-02-10 01:46:02 -0800967 */
968
Bjorn Helgaasa474aae2008-10-14 13:50:21 -0600969#ifdef CONFIG_ACPI
970
971#include <linux/acpi.h>
972
973#ifdef CONFIG_PM
974static 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}
1002#else
1003#define rtc_wake_setup() do{}while(0)
1004#define rtc_wake_on NULL
1005#define rtc_wake_off NULL
1006#endif
1007
1008/* Every ACPI platform has a mc146818 compatible "cmos rtc". Here we find
1009 * its device node and pass extra config data. This helps its driver use
1010 * capabilities that the now-obsolete mc146818 didn't have, and informs it
1011 * that this board's RTC is wakeup-capable (per ACPI spec).
1012 */
1013static struct cmos_rtc_board_info acpi_rtc_info;
1014
1015static void __devinit
1016cmos_wake_setup(struct device *dev)
1017{
1018 if (acpi_disabled)
1019 return;
1020
1021 rtc_wake_setup();
1022 acpi_rtc_info.wake_on = rtc_wake_on;
1023 acpi_rtc_info.wake_off = rtc_wake_off;
1024
1025 /* workaround bug in some ACPI tables */
1026 if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
1027 dev_dbg(dev, "bogus FADT month_alarm (%d)\n",
1028 acpi_gbl_FADT.month_alarm);
1029 acpi_gbl_FADT.month_alarm = 0;
1030 }
1031
1032 acpi_rtc_info.rtc_day_alarm = acpi_gbl_FADT.day_alarm;
1033 acpi_rtc_info.rtc_mon_alarm = acpi_gbl_FADT.month_alarm;
1034 acpi_rtc_info.rtc_century = acpi_gbl_FADT.century;
1035
1036 /* NOTE: S4_RTC_WAKE is NOT currently useful to Linux */
1037 if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
1038 dev_info(dev, "RTC can wake from S4\n");
1039
1040 dev->platform_data = &acpi_rtc_info;
1041
1042 /* RTC always wakes from S1/S2/S3, and often S4/STD */
1043 device_init_wakeup(dev, 1);
1044}
1045
1046#else
1047
1048static void __devinit
1049cmos_wake_setup(struct device *dev)
1050{
1051}
1052
1053#endif
1054
Marko Vrh41ac8df2007-05-08 00:34:09 -07001055#ifdef CONFIG_PNP
David Brownell7be2c7c2007-02-10 01:46:02 -08001056
1057#include <linux/pnp.h>
1058
1059static int __devinit
1060cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
1061{
Bjorn Helgaasa474aae2008-10-14 13:50:21 -06001062 cmos_wake_setup(&pnp->dev);
1063
Matthew Garrett6cd8fa82007-06-01 00:46:51 -07001064 if (pnp_port_start(pnp,0) == 0x70 && !pnp_irq_valid(pnp,0))
1065 /* Some machines contain a PNP entry for the RTC, but
1066 * don't define the IRQ. It should always be safe to
1067 * hardcode it in these cases
1068 */
Bjorn Helgaas8766ad02008-04-28 16:34:27 -06001069 return cmos_do_probe(&pnp->dev,
1070 pnp_get_resource(pnp, IORESOURCE_IO, 0), 8);
Matthew Garrett6cd8fa82007-06-01 00:46:51 -07001071 else
1072 return cmos_do_probe(&pnp->dev,
Bjorn Helgaas8766ad02008-04-28 16:34:27 -06001073 pnp_get_resource(pnp, IORESOURCE_IO, 0),
1074 pnp_irq(pnp, 0));
David Brownell7be2c7c2007-02-10 01:46:02 -08001075}
1076
1077static void __exit cmos_pnp_remove(struct pnp_dev *pnp)
1078{
1079 cmos_do_remove(&pnp->dev);
1080}
1081
1082#ifdef CONFIG_PM
1083
1084static int cmos_pnp_suspend(struct pnp_dev *pnp, pm_message_t mesg)
1085{
1086 return cmos_suspend(&pnp->dev, mesg);
1087}
1088
1089static int cmos_pnp_resume(struct pnp_dev *pnp)
1090{
1091 return cmos_resume(&pnp->dev);
1092}
1093
1094#else
1095#define cmos_pnp_suspend NULL
1096#define cmos_pnp_resume NULL
1097#endif
1098
OGAWA Hirofumi004731b2010-01-08 14:43:11 -08001099static void cmos_pnp_shutdown(struct pnp_dev *pnp)
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001100{
OGAWA Hirofumi004731b2010-01-08 14:43:11 -08001101 if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(&pnp->dev))
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001102 return;
1103
1104 cmos_do_shutdown();
1105}
David Brownell7be2c7c2007-02-10 01:46:02 -08001106
1107static const struct pnp_device_id rtc_ids[] = {
1108 { .id = "PNP0b00", },
1109 { .id = "PNP0b01", },
1110 { .id = "PNP0b02", },
1111 { },
1112};
1113MODULE_DEVICE_TABLE(pnp, rtc_ids);
1114
1115static struct pnp_driver cmos_pnp_driver = {
1116 .name = (char *) driver_name,
1117 .id_table = rtc_ids,
1118 .probe = cmos_pnp_probe,
1119 .remove = __exit_p(cmos_pnp_remove),
OGAWA Hirofumi004731b2010-01-08 14:43:11 -08001120 .shutdown = cmos_pnp_shutdown,
David Brownell7be2c7c2007-02-10 01:46:02 -08001121
1122 /* flag ensures resume() gets called, and stops syslog spam */
1123 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
1124 .suspend = cmos_pnp_suspend,
1125 .resume = cmos_pnp_resume,
1126};
1127
Stas Sergeev1da2e3d2008-06-12 15:21:54 -07001128#endif /* CONFIG_PNP */
David Brownell7be2c7c2007-02-10 01:46:02 -08001129
1130/*----------------------------------------------------------------*/
1131
Marko Vrh41ac8df2007-05-08 00:34:09 -07001132/* Platform setup should have set up an RTC device, when PNP is
David Brownellbcd9b892007-04-01 23:49:47 -07001133 * unavailable ... this could happen even on (older) PCs.
David Brownell7be2c7c2007-02-10 01:46:02 -08001134 */
1135
1136static int __init cmos_platform_probe(struct platform_device *pdev)
1137{
Bjorn Helgaasa474aae2008-10-14 13:50:21 -06001138 cmos_wake_setup(&pdev->dev);
David Brownell7be2c7c2007-02-10 01:46:02 -08001139 return cmos_do_probe(&pdev->dev,
1140 platform_get_resource(pdev, IORESOURCE_IO, 0),
1141 platform_get_irq(pdev, 0));
1142}
1143
1144static int __exit cmos_platform_remove(struct platform_device *pdev)
1145{
1146 cmos_do_remove(&pdev->dev);
1147 return 0;
1148}
1149
1150static void cmos_platform_shutdown(struct platform_device *pdev)
1151{
Rafael J. Wysocki74c46332008-09-02 14:36:11 -07001152 if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(&pdev->dev))
1153 return;
1154
David Brownell7be2c7c2007-02-10 01:46:02 -08001155 cmos_do_shutdown();
1156}
1157
Kay Sieversad28a072008-04-10 21:29:25 -07001158/* work with hotplug and coldplug */
1159MODULE_ALIAS("platform:rtc_cmos");
1160
David Brownell7be2c7c2007-02-10 01:46:02 -08001161static struct platform_driver cmos_platform_driver = {
1162 .remove = __exit_p(cmos_platform_remove),
1163 .shutdown = cmos_platform_shutdown,
1164 .driver = {
1165 .name = (char *) driver_name,
1166 .suspend = cmos_suspend,
1167 .resume = cmos_resume,
1168 }
1169};
1170
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001171#ifdef CONFIG_PNP
1172static bool pnp_driver_registered;
1173#endif
1174static bool platform_driver_registered;
1175
David Brownell7be2c7c2007-02-10 01:46:02 -08001176static int __init cmos_init(void)
1177{
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001178 int retval = 0;
1179
Stas Sergeev1da2e3d2008-06-12 15:21:54 -07001180#ifdef CONFIG_PNP
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001181 retval = pnp_register_driver(&cmos_pnp_driver);
1182 if (retval == 0)
1183 pnp_driver_registered = true;
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001184#endif
1185
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001186 if (!cmos_rtc.dev) {
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001187 retval = platform_driver_probe(&cmos_platform_driver,
1188 cmos_platform_probe);
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001189 if (retval == 0)
1190 platform_driver_registered = true;
1191 }
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001192
1193 if (retval == 0)
1194 return 0;
1195
1196#ifdef CONFIG_PNP
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001197 if (pnp_driver_registered)
1198 pnp_unregister_driver(&cmos_pnp_driver);
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001199#endif
1200 return retval;
David Brownell7be2c7c2007-02-10 01:46:02 -08001201}
1202module_init(cmos_init);
1203
1204static void __exit cmos_exit(void)
1205{
Stas Sergeev1da2e3d2008-06-12 15:21:54 -07001206#ifdef CONFIG_PNP
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001207 if (pnp_driver_registered)
1208 pnp_unregister_driver(&cmos_pnp_driver);
Bjorn Helgaas72f22b12008-10-14 17:01:59 -06001209#endif
Thadeu Lima de Souza Cascardo65909812009-07-29 15:02:13 -07001210 if (platform_driver_registered)
1211 platform_driver_unregister(&cmos_platform_driver);
David Brownell7be2c7c2007-02-10 01:46:02 -08001212}
1213module_exit(cmos_exit);
1214
1215
David Brownell7be2c7c2007-02-10 01:46:02 -08001216MODULE_AUTHOR("David Brownell");
1217MODULE_DESCRIPTION("Driver for PC-style 'CMOS' RTCs");
1218MODULE_LICENSE("GPL");