blob: 5d760bb6c2cd2100e051dadc9d0bba00c0c8da33 [file] [log] [blame]
David Brownell7be2c7c2007-02-10 01:46:02 -08001/*
2 * RTC class driver for "CMOS RTC": PCs, ACPI, etc
3 *
4 * Copyright (C) 1996 Paul Gortmaker (drivers/char/rtc.c)
5 * Copyright (C) 2006 David Brownell (convert to new framework)
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 */
12
13/*
14 * The original "cmos clock" chip was an MC146818 chip, now obsolete.
15 * That defined the register interface now provided by all PCs, some
16 * non-PC systems, and incorporated into ACPI. Modern PC chipsets
17 * integrate an MC146818 clone in their southbridge, and boards use
18 * that instead of discrete clones like the DS12887 or M48T86. There
19 * are also clones that connect using the LPC bus.
20 *
21 * That register API is also used directly by various other drivers
22 * (notably for integrated NVRAM), infrastructure (x86 has code to
23 * bypass the RTC framework, directly reading the RTC during boot
24 * and updating minutes/seconds for systems using NTP synch) and
25 * utilities (like userspace 'hwclock', if no /dev node exists).
26 *
27 * So **ALL** calls to CMOS_READ and CMOS_WRITE must be done with
28 * interrupts disabled, holding the global rtc_lock, to exclude those
29 * other drivers and utilities on correctly configured systems.
30 */
31#include <linux/kernel.h>
32#include <linux/module.h>
33#include <linux/init.h>
34#include <linux/interrupt.h>
35#include <linux/spinlock.h>
36#include <linux/platform_device.h>
37#include <linux/mod_devicetable.h>
38
39/* this is for "generic access to PC-style RTC" using CMOS_READ/CMOS_WRITE */
40#include <asm-generic/rtc.h>
41
42
43struct 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 */
62#define is_valid_irq(n) ((n) >= 0)
63
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
81static int cmos_read_time(struct device *dev, struct rtc_time *t)
82{
83 /* REVISIT: if the clock has a "century" register, use
84 * that instead of the heuristic in get_rtc_time().
85 * That'll make Y3K compatility (year > 2070) easy!
86 */
87 get_rtc_time(t);
88 return 0;
89}
90
91static int cmos_set_time(struct device *dev, struct rtc_time *t)
92{
93 /* REVISIT: set the "century" register if available
94 *
95 * NOTE: this ignores the issue whereby updating the seconds
96 * takes effect exactly 500ms after we write the register.
97 * (Also queueing and other delays before we get this far.)
98 */
99 return set_rtc_time(t);
100}
101
102static int cmos_read_alarm(struct device *dev, struct rtc_wkalrm *t)
103{
104 struct cmos_rtc *cmos = dev_get_drvdata(dev);
105 unsigned char rtc_control;
106
107 if (!is_valid_irq(cmos->irq))
108 return -EIO;
109
110 /* Basic alarms only support hour, minute, and seconds fields.
111 * Some also support day and month, for alarms up to a year in
112 * the future.
113 */
114 t->time.tm_mday = -1;
115 t->time.tm_mon = -1;
116
117 spin_lock_irq(&rtc_lock);
118 t->time.tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
119 t->time.tm_min = CMOS_READ(RTC_MINUTES_ALARM);
120 t->time.tm_hour = CMOS_READ(RTC_HOURS_ALARM);
121
122 if (cmos->day_alrm) {
123 t->time.tm_mday = CMOS_READ(cmos->day_alrm);
124 if (!t->time.tm_mday)
125 t->time.tm_mday = -1;
126
127 if (cmos->mon_alrm) {
128 t->time.tm_mon = CMOS_READ(cmos->mon_alrm);
129 if (!t->time.tm_mon)
130 t->time.tm_mon = -1;
131 }
132 }
133
134 rtc_control = CMOS_READ(RTC_CONTROL);
135 spin_unlock_irq(&rtc_lock);
136
137 /* REVISIT this assumes PC style usage: always BCD */
138
139 if (((unsigned)t->time.tm_sec) < 0x60)
140 t->time.tm_sec = BCD2BIN(t->time.tm_sec);
141 else
142 t->time.tm_sec = -1;
143 if (((unsigned)t->time.tm_min) < 0x60)
144 t->time.tm_min = BCD2BIN(t->time.tm_min);
145 else
146 t->time.tm_min = -1;
147 if (((unsigned)t->time.tm_hour) < 0x24)
148 t->time.tm_hour = BCD2BIN(t->time.tm_hour);
149 else
150 t->time.tm_hour = -1;
151
152 if (cmos->day_alrm) {
153 if (((unsigned)t->time.tm_mday) <= 0x31)
154 t->time.tm_mday = BCD2BIN(t->time.tm_mday);
155 else
156 t->time.tm_mday = -1;
157 if (cmos->mon_alrm) {
158 if (((unsigned)t->time.tm_mon) <= 0x12)
159 t->time.tm_mon = BCD2BIN(t->time.tm_mon) - 1;
160 else
161 t->time.tm_mon = -1;
162 }
163 }
164 t->time.tm_year = -1;
165
166 t->enabled = !!(rtc_control & RTC_AIE);
167 t->pending = 0;
168
169 return 0;
170}
171
172static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
173{
174 struct cmos_rtc *cmos = dev_get_drvdata(dev);
175 unsigned char mon, mday, hrs, min, sec;
176 unsigned char rtc_control, rtc_intr;
177
178 if (!is_valid_irq(cmos->irq))
179 return -EIO;
180
181 /* REVISIT this assumes PC style usage: always BCD */
182
183 /* Writing 0xff means "don't care" or "match all". */
184
185 mon = t->time.tm_mon;
186 mon = (mon < 12) ? BIN2BCD(mon) : 0xff;
187 mon++;
188
189 mday = t->time.tm_mday;
190 mday = (mday >= 1 && mday <= 31) ? BIN2BCD(mday) : 0xff;
191
192 hrs = t->time.tm_hour;
193 hrs = (hrs < 24) ? BIN2BCD(hrs) : 0xff;
194
195 min = t->time.tm_min;
196 min = (min < 60) ? BIN2BCD(min) : 0xff;
197
198 sec = t->time.tm_sec;
199 sec = (sec < 60) ? BIN2BCD(sec) : 0xff;
200
201 spin_lock_irq(&rtc_lock);
202
203 /* next rtc irq must not be from previous alarm setting */
204 rtc_control = CMOS_READ(RTC_CONTROL);
205 rtc_control &= ~RTC_AIE;
206 CMOS_WRITE(rtc_control, RTC_CONTROL);
207 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
David Brownellbcd9b892007-04-01 23:49:47 -0700208 rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
209 if (is_intr(rtc_intr))
David Brownellab6a2d72007-05-08 00:33:30 -0700210 rtc_update_irq(cmos->rtc, 1, rtc_intr);
David Brownell7be2c7c2007-02-10 01:46:02 -0800211
212 /* update alarm */
213 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
214 CMOS_WRITE(min, RTC_MINUTES_ALARM);
215 CMOS_WRITE(sec, RTC_SECONDS_ALARM);
216
217 /* the system may support an "enhanced" alarm */
218 if (cmos->day_alrm) {
219 CMOS_WRITE(mday, cmos->day_alrm);
220 if (cmos->mon_alrm)
221 CMOS_WRITE(mon, cmos->mon_alrm);
222 }
223
224 if (t->enabled) {
225 rtc_control |= RTC_AIE;
226 CMOS_WRITE(rtc_control, RTC_CONTROL);
227 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
David Brownellbcd9b892007-04-01 23:49:47 -0700228 rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
229 if (is_intr(rtc_intr))
David Brownellab6a2d72007-05-08 00:33:30 -0700230 rtc_update_irq(cmos->rtc, 1, rtc_intr);
David Brownell7be2c7c2007-02-10 01:46:02 -0800231 }
232
233 spin_unlock_irq(&rtc_lock);
234
235 return 0;
236}
237
Alessandro Zummo57deb522007-07-19 01:49:21 -0700238static int cmos_irq_set_freq(struct device *dev, int freq)
David Brownell7be2c7c2007-02-10 01:46:02 -0800239{
240 struct cmos_rtc *cmos = dev_get_drvdata(dev);
241 int f;
242 unsigned long flags;
243
244 if (!is_valid_irq(cmos->irq))
245 return -ENXIO;
246
247 /* 0 = no irqs; 1 = 2^15 Hz ... 15 = 2^0 Hz */
248 f = ffs(freq);
249 if (f != 0) {
250 if (f-- > 16 || freq != (1 << f))
251 return -EINVAL;
252 f = 16 - f;
253 }
254
255 spin_lock_irqsave(&rtc_lock, flags);
256 CMOS_WRITE(RTC_REF_CLCK_32KHZ | f, RTC_FREQ_SELECT);
257 spin_unlock_irqrestore(&rtc_lock, flags);
258
259 return 0;
260}
261
Alessandro Zummo57deb522007-07-19 01:49:21 -0700262static int cmos_irq_set_state(struct device *dev, int enabled)
263{
264 struct cmos_rtc *cmos = dev_get_drvdata(dev);
265 unsigned char rtc_control, rtc_intr;
266 unsigned long flags;
267
268 if (!is_valid_irq(cmos->irq))
269 return -ENXIO;
270
271 spin_lock_irqsave(&rtc_lock, flags);
272 rtc_control = CMOS_READ(RTC_CONTROL);
273
274 if (enabled)
275 rtc_control |= RTC_PIE;
276 else
277 rtc_control &= ~RTC_PIE;
278
279 CMOS_WRITE(rtc_control, RTC_CONTROL);
280
281 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
282 rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
283 if (is_intr(rtc_intr))
284 rtc_update_irq(cmos->rtc, 1, rtc_intr);
285
286 spin_unlock_irqrestore(&rtc_lock, flags);
287 return 0;
288}
289
David Brownell7be2c7c2007-02-10 01:46:02 -0800290#if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE)
291
292static int
293cmos_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
294{
295 struct cmos_rtc *cmos = dev_get_drvdata(dev);
296 unsigned char rtc_control, rtc_intr;
297 unsigned long flags;
298
299 switch (cmd) {
300 case RTC_AIE_OFF:
301 case RTC_AIE_ON:
302 case RTC_UIE_OFF:
303 case RTC_UIE_ON:
304 case RTC_PIE_OFF:
305 case RTC_PIE_ON:
306 if (!is_valid_irq(cmos->irq))
307 return -EINVAL;
308 break;
309 default:
310 return -ENOIOCTLCMD;
311 }
312
313 spin_lock_irqsave(&rtc_lock, flags);
314 rtc_control = CMOS_READ(RTC_CONTROL);
315 switch (cmd) {
316 case RTC_AIE_OFF: /* alarm off */
317 rtc_control &= ~RTC_AIE;
318 break;
319 case RTC_AIE_ON: /* alarm on */
320 rtc_control |= RTC_AIE;
321 break;
322 case RTC_UIE_OFF: /* update off */
323 rtc_control &= ~RTC_UIE;
324 break;
325 case RTC_UIE_ON: /* update on */
326 rtc_control |= RTC_UIE;
327 break;
328 case RTC_PIE_OFF: /* periodic off */
329 rtc_control &= ~RTC_PIE;
330 break;
331 case RTC_PIE_ON: /* periodic on */
332 rtc_control |= RTC_PIE;
333 break;
334 }
335 CMOS_WRITE(rtc_control, RTC_CONTROL);
336 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
David Brownellbcd9b892007-04-01 23:49:47 -0700337 rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
338 if (is_intr(rtc_intr))
David Brownellab6a2d72007-05-08 00:33:30 -0700339 rtc_update_irq(cmos->rtc, 1, rtc_intr);
David Brownell7be2c7c2007-02-10 01:46:02 -0800340 spin_unlock_irqrestore(&rtc_lock, flags);
341 return 0;
342}
343
344#else
345#define cmos_rtc_ioctl NULL
346#endif
347
348#if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
349
350static int cmos_procfs(struct device *dev, struct seq_file *seq)
351{
352 struct cmos_rtc *cmos = dev_get_drvdata(dev);
353 unsigned char rtc_control, valid;
354
355 spin_lock_irq(&rtc_lock);
356 rtc_control = CMOS_READ(RTC_CONTROL);
357 valid = CMOS_READ(RTC_VALID);
358 spin_unlock_irq(&rtc_lock);
359
360 /* NOTE: at least ICH6 reports battery status using a different
361 * (non-RTC) bit; and SQWE is ignored on many current systems.
362 */
363 return seq_printf(seq,
364 "periodic_IRQ\t: %s\n"
365 "update_IRQ\t: %s\n"
366 // "square_wave\t: %s\n"
367 // "BCD\t\t: %s\n"
368 "DST_enable\t: %s\n"
369 "periodic_freq\t: %d\n"
370 "batt_status\t: %s\n",
371 (rtc_control & RTC_PIE) ? "yes" : "no",
372 (rtc_control & RTC_UIE) ? "yes" : "no",
373 // (rtc_control & RTC_SQWE) ? "yes" : "no",
374 // (rtc_control & RTC_DM_BINARY) ? "no" : "yes",
375 (rtc_control & RTC_DST_EN) ? "yes" : "no",
376 cmos->rtc->irq_freq,
377 (valid & RTC_VRT) ? "okay" : "dead");
378}
379
380#else
381#define cmos_procfs NULL
382#endif
383
384static const struct rtc_class_ops cmos_rtc_ops = {
385 .ioctl = cmos_rtc_ioctl,
386 .read_time = cmos_read_time,
387 .set_time = cmos_set_time,
388 .read_alarm = cmos_read_alarm,
389 .set_alarm = cmos_set_alarm,
390 .proc = cmos_procfs,
Alessandro Zummo57deb522007-07-19 01:49:21 -0700391 .irq_set_freq = cmos_irq_set_freq,
392 .irq_set_state = cmos_irq_set_state,
David Brownell7be2c7c2007-02-10 01:46:02 -0800393};
394
395/*----------------------------------------------------------------*/
396
397static struct cmos_rtc cmos_rtc;
398
399static irqreturn_t cmos_interrupt(int irq, void *p)
400{
401 u8 irqstat;
402
403 spin_lock(&rtc_lock);
404 irqstat = CMOS_READ(RTC_INTR_FLAGS);
David Brownellbcd9b892007-04-01 23:49:47 -0700405 irqstat &= (CMOS_READ(RTC_CONTROL) & RTC_IRQMASK) | RTC_IRQF;
David Brownell7be2c7c2007-02-10 01:46:02 -0800406 spin_unlock(&rtc_lock);
407
David Brownellbcd9b892007-04-01 23:49:47 -0700408 if (is_intr(irqstat)) {
David Brownell7be2c7c2007-02-10 01:46:02 -0800409 rtc_update_irq(p, 1, irqstat);
410 return IRQ_HANDLED;
411 } else
412 return IRQ_NONE;
413}
414
Marko Vrh41ac8df2007-05-08 00:34:09 -0700415#ifdef CONFIG_PNP
416#define is_pnp() 1
David Brownell7be2c7c2007-02-10 01:46:02 -0800417#define INITSECTION
418
419#else
Marko Vrh41ac8df2007-05-08 00:34:09 -0700420#define is_pnp() 0
David Brownell7be2c7c2007-02-10 01:46:02 -0800421#define INITSECTION __init
422#endif
423
424static int INITSECTION
425cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
426{
427 struct cmos_rtc_board_info *info = dev->platform_data;
428 int retval = 0;
429 unsigned char rtc_control;
430
431 /* there can be only one ... */
432 if (cmos_rtc.dev)
433 return -EBUSY;
434
435 if (!ports)
436 return -ENODEV;
437
438 cmos_rtc.irq = rtc_irq;
439 cmos_rtc.iomem = ports;
440
David Brownell87ac84f2007-05-08 00:34:00 -0700441 /* For ACPI systems extension info comes from the FADT. On others,
442 * board specific setup provides it as appropriate. Systems where
443 * the alarm IRQ isn't automatically a wakeup IRQ (like ACPI, and
444 * some almost-clones) can provide hooks to make that behave.
David Brownell7be2c7c2007-02-10 01:46:02 -0800445 */
446 if (info) {
447 cmos_rtc.day_alrm = info->rtc_day_alarm;
448 cmos_rtc.mon_alrm = info->rtc_mon_alarm;
449 cmos_rtc.century = info->rtc_century;
David Brownell87ac84f2007-05-08 00:34:00 -0700450
451 if (info->wake_on && info->wake_off) {
452 cmos_rtc.wake_on = info->wake_on;
453 cmos_rtc.wake_off = info->wake_off;
454 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800455 }
456
457 cmos_rtc.rtc = rtc_device_register(driver_name, dev,
458 &cmos_rtc_ops, THIS_MODULE);
459 if (IS_ERR(cmos_rtc.rtc))
460 return PTR_ERR(cmos_rtc.rtc);
461
462 cmos_rtc.dev = dev;
463 dev_set_drvdata(dev, &cmos_rtc);
464
465 /* platform and pnp busses handle resources incompatibly.
466 *
467 * REVISIT for non-x86 systems we may need to handle io memory
468 * resources: ioremap them, and request_mem_region().
469 */
Marko Vrh41ac8df2007-05-08 00:34:09 -0700470 if (is_pnp()) {
David Brownell7be2c7c2007-02-10 01:46:02 -0800471 retval = request_resource(&ioport_resource, ports);
472 if (retval < 0) {
473 dev_dbg(dev, "i/o registers already in use\n");
474 goto cleanup0;
475 }
476 }
David Brownellcd966202007-05-08 00:33:40 -0700477 rename_region(ports, cmos_rtc.rtc->dev.bus_id);
David Brownell7be2c7c2007-02-10 01:46:02 -0800478
479 spin_lock_irq(&rtc_lock);
480
481 /* force periodic irq to CMOS reset default of 1024Hz;
482 *
483 * REVISIT it's been reported that at least one x86_64 ALI mobo
484 * doesn't use 32KHz here ... for portability we might need to
485 * do something about other clock frequencies.
486 */
487 CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT);
488 cmos_rtc.rtc->irq_freq = 1024;
489
490 /* disable irqs.
491 *
492 * NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
493 * allegedly some older rtcs need that to handle irqs properly
494 */
495 rtc_control = CMOS_READ(RTC_CONTROL);
496 rtc_control &= ~(RTC_PIE | RTC_AIE | RTC_UIE);
497 CMOS_WRITE(rtc_control, RTC_CONTROL);
498 CMOS_READ(RTC_INTR_FLAGS);
499
500 spin_unlock_irq(&rtc_lock);
501
502 /* FIXME teach the alarm code how to handle binary mode;
503 * <asm-generic/rtc.h> doesn't know 12-hour mode either.
504 */
505 if (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY))) {
506 dev_dbg(dev, "only 24-hr BCD mode supported\n");
507 retval = -ENXIO;
508 goto cleanup1;
509 }
510
511 if (is_valid_irq(rtc_irq))
512 retval = request_irq(rtc_irq, cmos_interrupt, IRQF_DISABLED,
David Brownellcd966202007-05-08 00:33:40 -0700513 cmos_rtc.rtc->dev.bus_id,
David Brownellab6a2d72007-05-08 00:33:30 -0700514 cmos_rtc.rtc);
David Brownell7be2c7c2007-02-10 01:46:02 -0800515 if (retval < 0) {
516 dev_dbg(dev, "IRQ %d is already in use\n", rtc_irq);
517 goto cleanup1;
518 }
519
520 /* REVISIT optionally make 50 or 114 bytes NVRAM available,
521 * like rtc-ds1553, rtc-ds1742 ... this will often include
522 * registers for century, and day/month alarm.
523 */
524
525 pr_info("%s: alarms up to one %s%s\n",
David Brownellcd966202007-05-08 00:33:40 -0700526 cmos_rtc.rtc->dev.bus_id,
David Brownell7be2c7c2007-02-10 01:46:02 -0800527 is_valid_irq(rtc_irq)
528 ? (cmos_rtc.mon_alrm
529 ? "year"
530 : (cmos_rtc.day_alrm
531 ? "month" : "day"))
532 : "no",
533 cmos_rtc.century ? ", y3k" : ""
534 );
535
536 return 0;
537
538cleanup1:
539 rename_region(ports, NULL);
540cleanup0:
541 rtc_device_unregister(cmos_rtc.rtc);
542 return retval;
543}
544
545static void cmos_do_shutdown(void)
546{
547 unsigned char rtc_control;
548
549 spin_lock_irq(&rtc_lock);
550 rtc_control = CMOS_READ(RTC_CONTROL);
551 rtc_control &= ~(RTC_PIE|RTC_AIE|RTC_UIE);
552 CMOS_WRITE(rtc_control, RTC_CONTROL);
553 CMOS_READ(RTC_INTR_FLAGS);
554 spin_unlock_irq(&rtc_lock);
555}
556
557static void __exit cmos_do_remove(struct device *dev)
558{
559 struct cmos_rtc *cmos = dev_get_drvdata(dev);
560
561 cmos_do_shutdown();
562
Marko Vrh41ac8df2007-05-08 00:34:09 -0700563 if (is_pnp())
David Brownell7be2c7c2007-02-10 01:46:02 -0800564 release_resource(cmos->iomem);
565 rename_region(cmos->iomem, NULL);
566
567 if (is_valid_irq(cmos->irq))
David Brownellcd966202007-05-08 00:33:40 -0700568 free_irq(cmos->irq, cmos_rtc.rtc);
David Brownell7be2c7c2007-02-10 01:46:02 -0800569
570 rtc_device_unregister(cmos_rtc.rtc);
571
572 cmos_rtc.dev = NULL;
573 dev_set_drvdata(dev, NULL);
574}
575
576#ifdef CONFIG_PM
577
578static int cmos_suspend(struct device *dev, pm_message_t mesg)
579{
580 struct cmos_rtc *cmos = dev_get_drvdata(dev);
581 int do_wake = device_may_wakeup(dev);
David Brownellbcd9b892007-04-01 23:49:47 -0700582 unsigned char tmp;
David Brownell7be2c7c2007-02-10 01:46:02 -0800583
584 /* only the alarm might be a wakeup event source */
585 spin_lock_irq(&rtc_lock);
586 cmos->suspend_ctrl = tmp = CMOS_READ(RTC_CONTROL);
587 if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
David Brownellbcd9b892007-04-01 23:49:47 -0700588 unsigned char irqstat;
589
David Brownell7be2c7c2007-02-10 01:46:02 -0800590 if (do_wake)
591 tmp &= ~(RTC_PIE|RTC_UIE);
592 else
593 tmp &= ~(RTC_PIE|RTC_AIE|RTC_UIE);
594 CMOS_WRITE(tmp, RTC_CONTROL);
595 irqstat = CMOS_READ(RTC_INTR_FLAGS);
David Brownellbcd9b892007-04-01 23:49:47 -0700596 irqstat &= (tmp & RTC_IRQMASK) | RTC_IRQF;
597 if (is_intr(irqstat))
David Brownellab6a2d72007-05-08 00:33:30 -0700598 rtc_update_irq(cmos->rtc, 1, irqstat);
David Brownellbcd9b892007-04-01 23:49:47 -0700599 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800600 spin_unlock_irq(&rtc_lock);
601
David Brownell87ac84f2007-05-08 00:34:00 -0700602 if (tmp & RTC_AIE) {
603 cmos->enabled_wake = 1;
604 if (cmos->wake_on)
605 cmos->wake_on(dev);
606 else
607 enable_irq_wake(cmos->irq);
608 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800609
610 pr_debug("%s: suspend%s, ctrl %02x\n",
David Brownellcd966202007-05-08 00:33:40 -0700611 cmos_rtc.rtc->dev.bus_id,
David Brownell7be2c7c2007-02-10 01:46:02 -0800612 (tmp & RTC_AIE) ? ", alarm may wake" : "",
613 tmp);
614
615 return 0;
616}
617
618static int cmos_resume(struct device *dev)
619{
620 struct cmos_rtc *cmos = dev_get_drvdata(dev);
621 unsigned char tmp = cmos->suspend_ctrl;
622
David Brownell7be2c7c2007-02-10 01:46:02 -0800623 /* re-enable any irqs previously active */
624 if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
625
David Brownell87ac84f2007-05-08 00:34:00 -0700626 if (cmos->enabled_wake) {
627 if (cmos->wake_off)
628 cmos->wake_off(dev);
629 else
630 disable_irq_wake(cmos->irq);
631 cmos->enabled_wake = 0;
632 }
David Brownell7be2c7c2007-02-10 01:46:02 -0800633
634 spin_lock_irq(&rtc_lock);
635 CMOS_WRITE(tmp, RTC_CONTROL);
636 tmp = CMOS_READ(RTC_INTR_FLAGS);
David Brownellbcd9b892007-04-01 23:49:47 -0700637 tmp &= (cmos->suspend_ctrl & RTC_IRQMASK) | RTC_IRQF;
638 if (is_intr(tmp))
David Brownellab6a2d72007-05-08 00:33:30 -0700639 rtc_update_irq(cmos->rtc, 1, tmp);
David Brownellbcd9b892007-04-01 23:49:47 -0700640 spin_unlock_irq(&rtc_lock);
David Brownell7be2c7c2007-02-10 01:46:02 -0800641 }
642
643 pr_debug("%s: resume, ctrl %02x\n",
David Brownellcd966202007-05-08 00:33:40 -0700644 cmos_rtc.rtc->dev.bus_id,
David Brownell7be2c7c2007-02-10 01:46:02 -0800645 cmos->suspend_ctrl);
646
647
648 return 0;
649}
650
651#else
652#define cmos_suspend NULL
653#define cmos_resume NULL
654#endif
655
656/*----------------------------------------------------------------*/
657
658/* The "CMOS" RTC normally lives on the platform_bus. On ACPI systems,
David Brownellbcd9b892007-04-01 23:49:47 -0700659 * the device node will always be created as a PNPACPI device.
David Brownell7be2c7c2007-02-10 01:46:02 -0800660 */
661
Marko Vrh41ac8df2007-05-08 00:34:09 -0700662#ifdef CONFIG_PNP
David Brownell7be2c7c2007-02-10 01:46:02 -0800663
664#include <linux/pnp.h>
665
666static int __devinit
667cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
668{
669 /* REVISIT paranoia argues for a shutdown notifier, since PNP
670 * drivers can't provide shutdown() methods to disable IRQs.
671 * Or better yet, fix PNP to allow those methods...
672 */
Matthew Garrett6cd8fa82007-06-01 00:46:51 -0700673 if (pnp_port_start(pnp,0) == 0x70 && !pnp_irq_valid(pnp,0))
674 /* Some machines contain a PNP entry for the RTC, but
675 * don't define the IRQ. It should always be safe to
676 * hardcode it in these cases
677 */
678 return cmos_do_probe(&pnp->dev, &pnp->res.port_resource[0], 8);
679 else
680 return cmos_do_probe(&pnp->dev,
681 &pnp->res.port_resource[0],
682 pnp->res.irq_resource[0].start);
David Brownell7be2c7c2007-02-10 01:46:02 -0800683}
684
685static void __exit cmos_pnp_remove(struct pnp_dev *pnp)
686{
687 cmos_do_remove(&pnp->dev);
688}
689
690#ifdef CONFIG_PM
691
692static int cmos_pnp_suspend(struct pnp_dev *pnp, pm_message_t mesg)
693{
694 return cmos_suspend(&pnp->dev, mesg);
695}
696
697static int cmos_pnp_resume(struct pnp_dev *pnp)
698{
699 return cmos_resume(&pnp->dev);
700}
701
702#else
703#define cmos_pnp_suspend NULL
704#define cmos_pnp_resume NULL
705#endif
706
707
708static const struct pnp_device_id rtc_ids[] = {
709 { .id = "PNP0b00", },
710 { .id = "PNP0b01", },
711 { .id = "PNP0b02", },
712 { },
713};
714MODULE_DEVICE_TABLE(pnp, rtc_ids);
715
716static struct pnp_driver cmos_pnp_driver = {
717 .name = (char *) driver_name,
718 .id_table = rtc_ids,
719 .probe = cmos_pnp_probe,
720 .remove = __exit_p(cmos_pnp_remove),
721
722 /* flag ensures resume() gets called, and stops syslog spam */
723 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
724 .suspend = cmos_pnp_suspend,
725 .resume = cmos_pnp_resume,
726};
727
728static int __init cmos_init(void)
729{
730 return pnp_register_driver(&cmos_pnp_driver);
731}
732module_init(cmos_init);
733
734static void __exit cmos_exit(void)
735{
736 pnp_unregister_driver(&cmos_pnp_driver);
737}
738module_exit(cmos_exit);
739
Marko Vrh41ac8df2007-05-08 00:34:09 -0700740#else /* no PNP */
David Brownell7be2c7c2007-02-10 01:46:02 -0800741
742/*----------------------------------------------------------------*/
743
Marko Vrh41ac8df2007-05-08 00:34:09 -0700744/* Platform setup should have set up an RTC device, when PNP is
David Brownellbcd9b892007-04-01 23:49:47 -0700745 * unavailable ... this could happen even on (older) PCs.
David Brownell7be2c7c2007-02-10 01:46:02 -0800746 */
747
748static int __init cmos_platform_probe(struct platform_device *pdev)
749{
750 return cmos_do_probe(&pdev->dev,
751 platform_get_resource(pdev, IORESOURCE_IO, 0),
752 platform_get_irq(pdev, 0));
753}
754
755static int __exit cmos_platform_remove(struct platform_device *pdev)
756{
757 cmos_do_remove(&pdev->dev);
758 return 0;
759}
760
761static void cmos_platform_shutdown(struct platform_device *pdev)
762{
763 cmos_do_shutdown();
764}
765
766static struct platform_driver cmos_platform_driver = {
767 .remove = __exit_p(cmos_platform_remove),
768 .shutdown = cmos_platform_shutdown,
769 .driver = {
770 .name = (char *) driver_name,
771 .suspend = cmos_suspend,
772 .resume = cmos_resume,
773 }
774};
775
776static int __init cmos_init(void)
777{
778 return platform_driver_probe(&cmos_platform_driver,
779 cmos_platform_probe);
780}
781module_init(cmos_init);
782
783static void __exit cmos_exit(void)
784{
785 platform_driver_unregister(&cmos_platform_driver);
786}
787module_exit(cmos_exit);
788
789
Marko Vrh41ac8df2007-05-08 00:34:09 -0700790#endif /* !PNP */
David Brownell7be2c7c2007-02-10 01:46:02 -0800791
792MODULE_AUTHOR("David Brownell");
793MODULE_DESCRIPTION("Driver for PC-style 'CMOS' RTCs");
794MODULE_LICENSE("GPL");