aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/rtc/Kconfig25
-rw-r--r--drivers/rtc/Makefile1
-rw-r--r--drivers/rtc/rtc-cmos.c725
3 files changed, 750 insertions, 1 deletions
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 09660e2ab051..4bbca500d3d2 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -1,4 +1,4 @@
1\# 1#
2# RTC class/drivers configuration 2# RTC class/drivers configuration
3# 3#
4 4
@@ -95,6 +95,29 @@ config RTC_INTF_DEV_UIE_EMUL
95comment "RTC drivers" 95comment "RTC drivers"
96 depends on RTC_CLASS 96 depends on RTC_CLASS
97 97
98# this 'CMOS' RTC driver is arch dependent because <asm-generic/rtc.h>
99# requires <asm/mc146818rtc.h> defining CMOS_READ/CMOS_WRITE, and a
100# global rtc_lock ... it's not yet just another platform_device.
101
102config RTC_DRV_CMOS
103 tristate "PC-style 'CMOS' real time clock"
104 depends on RTC_CLASS && (X86_PC || ALPHA || ARM26 || ARM \
105 || M32R || ATARI || POWERPC)
106 help
107 Say "yes" here to get direct support for the real time clock
108 found in every PC or ACPI-based system, and some other boards.
109 Specifically the original MC146818, compatibles like those in
110 PC south bridges, the DS12887 or M48T86, some multifunction
111 or LPC bus chips, and so on.
112
113 Your system will need to define the platform device used by
114 this driver, otherwise it won't be accessible. This means
115 you can safely enable this driver if you don't know whether
116 or not your board has this kind of hardware.
117
118 This driver can also be built as a module. If so, the module
119 will be called rtc-cmos.
120
98config RTC_DRV_X1205 121config RTC_DRV_X1205
99 tristate "Xicor/Intersil X1205" 122 tristate "Xicor/Intersil X1205"
100 depends on RTC_CLASS && I2C 123 depends on RTC_CLASS && I2C
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index e6beedacc966..92bfe1b3a5fa 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -15,6 +15,7 @@ obj-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o
15obj-$(CONFIG_RTC_INTF_PROC) += rtc-proc.o 15obj-$(CONFIG_RTC_INTF_PROC) += rtc-proc.o
16obj-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o 16obj-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o
17 17
18obj-$(CONFIG_RTC_DRV_CMOS) += rtc-cmos.o
18obj-$(CONFIG_RTC_DRV_X1205) += rtc-x1205.o 19obj-$(CONFIG_RTC_DRV_X1205) += rtc-x1205.o
19obj-$(CONFIG_RTC_DRV_ISL1208) += rtc-isl1208.o 20obj-$(CONFIG_RTC_DRV_ISL1208) += rtc-isl1208.o
20obj-$(CONFIG_RTC_DRV_TEST) += rtc-test.o 21obj-$(CONFIG_RTC_DRV_TEST) += rtc-test.o
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
new file mode 100644
index 000000000000..85bf795abdcc
--- /dev/null
+++ b/drivers/rtc/rtc-cmos.c
@@ -0,0 +1,725 @@
1/*
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
49 u8 suspend_ctrl;
50
51 /* newer hardware extends the original register set */
52 u8 day_alrm;
53 u8 mon_alrm;
54 u8 century;
55};
56
57/* both platform and pnp busses use negative numbers for invalid irqs */
58#define is_valid_irq(n) ((n) >= 0)
59
60static const char driver_name[] = "rtc_cmos";
61
62/*----------------------------------------------------------------*/
63
64static int cmos_read_time(struct device *dev, struct rtc_time *t)
65{
66 /* REVISIT: if the clock has a "century" register, use
67 * that instead of the heuristic in get_rtc_time().
68 * That'll make Y3K compatility (year > 2070) easy!
69 */
70 get_rtc_time(t);
71 return 0;
72}
73
74static int cmos_set_time(struct device *dev, struct rtc_time *t)
75{
76 /* REVISIT: set the "century" register if available
77 *
78 * NOTE: this ignores the issue whereby updating the seconds
79 * takes effect exactly 500ms after we write the register.
80 * (Also queueing and other delays before we get this far.)
81 */
82 return set_rtc_time(t);
83}
84
85static int cmos_read_alarm(struct device *dev, struct rtc_wkalrm *t)
86{
87 struct cmos_rtc *cmos = dev_get_drvdata(dev);
88 unsigned char rtc_control;
89
90 if (!is_valid_irq(cmos->irq))
91 return -EIO;
92
93 /* Basic alarms only support hour, minute, and seconds fields.
94 * Some also support day and month, for alarms up to a year in
95 * the future.
96 */
97 t->time.tm_mday = -1;
98 t->time.tm_mon = -1;
99
100 spin_lock_irq(&rtc_lock);
101 t->time.tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
102 t->time.tm_min = CMOS_READ(RTC_MINUTES_ALARM);
103 t->time.tm_hour = CMOS_READ(RTC_HOURS_ALARM);
104
105 if (cmos->day_alrm) {
106 t->time.tm_mday = CMOS_READ(cmos->day_alrm);
107 if (!t->time.tm_mday)
108 t->time.tm_mday = -1;
109
110 if (cmos->mon_alrm) {
111 t->time.tm_mon = CMOS_READ(cmos->mon_alrm);
112 if (!t->time.tm_mon)
113 t->time.tm_mon = -1;
114 }
115 }
116
117 rtc_control = CMOS_READ(RTC_CONTROL);
118 spin_unlock_irq(&rtc_lock);
119
120 /* REVISIT this assumes PC style usage: always BCD */
121
122 if (((unsigned)t->time.tm_sec) < 0x60)
123 t->time.tm_sec = BCD2BIN(t->time.tm_sec);
124 else
125 t->time.tm_sec = -1;
126 if (((unsigned)t->time.tm_min) < 0x60)
127 t->time.tm_min = BCD2BIN(t->time.tm_min);
128 else
129 t->time.tm_min = -1;
130 if (((unsigned)t->time.tm_hour) < 0x24)
131 t->time.tm_hour = BCD2BIN(t->time.tm_hour);
132 else
133 t->time.tm_hour = -1;
134
135 if (cmos->day_alrm) {
136 if (((unsigned)t->time.tm_mday) <= 0x31)
137 t->time.tm_mday = BCD2BIN(t->time.tm_mday);
138 else
139 t->time.tm_mday = -1;
140 if (cmos->mon_alrm) {
141 if (((unsigned)t->time.tm_mon) <= 0x12)
142 t->time.tm_mon = BCD2BIN(t->time.tm_mon) - 1;
143 else
144 t->time.tm_mon = -1;
145 }
146 }
147 t->time.tm_year = -1;
148
149 t->enabled = !!(rtc_control & RTC_AIE);
150 t->pending = 0;
151
152 return 0;
153}
154
155static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
156{
157 struct cmos_rtc *cmos = dev_get_drvdata(dev);
158 unsigned char mon, mday, hrs, min, sec;
159 unsigned char rtc_control, rtc_intr;
160
161 if (!is_valid_irq(cmos->irq))
162 return -EIO;
163
164 /* REVISIT this assumes PC style usage: always BCD */
165
166 /* Writing 0xff means "don't care" or "match all". */
167
168 mon = t->time.tm_mon;
169 mon = (mon < 12) ? BIN2BCD(mon) : 0xff;
170 mon++;
171
172 mday = t->time.tm_mday;
173 mday = (mday >= 1 && mday <= 31) ? BIN2BCD(mday) : 0xff;
174
175 hrs = t->time.tm_hour;
176 hrs = (hrs < 24) ? BIN2BCD(hrs) : 0xff;
177
178 min = t->time.tm_min;
179 min = (min < 60) ? BIN2BCD(min) : 0xff;
180
181 sec = t->time.tm_sec;
182 sec = (sec < 60) ? BIN2BCD(sec) : 0xff;
183
184 spin_lock_irq(&rtc_lock);
185
186 /* next rtc irq must not be from previous alarm setting */
187 rtc_control = CMOS_READ(RTC_CONTROL);
188 rtc_control &= ~RTC_AIE;
189 CMOS_WRITE(rtc_control, RTC_CONTROL);
190 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
191 if (rtc_intr)
192 rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr);
193
194 /* update alarm */
195 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
196 CMOS_WRITE(min, RTC_MINUTES_ALARM);
197 CMOS_WRITE(sec, RTC_SECONDS_ALARM);
198
199 /* the system may support an "enhanced" alarm */
200 if (cmos->day_alrm) {
201 CMOS_WRITE(mday, cmos->day_alrm);
202 if (cmos->mon_alrm)
203 CMOS_WRITE(mon, cmos->mon_alrm);
204 }
205
206 if (t->enabled) {
207 rtc_control |= RTC_AIE;
208 CMOS_WRITE(rtc_control, RTC_CONTROL);
209 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
210 if (rtc_intr)
211 rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr);
212 }
213
214 spin_unlock_irq(&rtc_lock);
215
216 return 0;
217}
218
219static int cmos_set_freq(struct device *dev, int freq)
220{
221 struct cmos_rtc *cmos = dev_get_drvdata(dev);
222 int f;
223 unsigned long flags;
224
225 if (!is_valid_irq(cmos->irq))
226 return -ENXIO;
227
228 /* 0 = no irqs; 1 = 2^15 Hz ... 15 = 2^0 Hz */
229 f = ffs(freq);
230 if (f != 0) {
231 if (f-- > 16 || freq != (1 << f))
232 return -EINVAL;
233 f = 16 - f;
234 }
235
236 spin_lock_irqsave(&rtc_lock, flags);
237 CMOS_WRITE(RTC_REF_CLCK_32KHZ | f, RTC_FREQ_SELECT);
238 spin_unlock_irqrestore(&rtc_lock, flags);
239
240 return 0;
241}
242
243#if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE)
244
245static int
246cmos_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
247{
248 struct cmos_rtc *cmos = dev_get_drvdata(dev);
249 unsigned char rtc_control, rtc_intr;
250 unsigned long flags;
251
252 switch (cmd) {
253 case RTC_AIE_OFF:
254 case RTC_AIE_ON:
255 case RTC_UIE_OFF:
256 case RTC_UIE_ON:
257 case RTC_PIE_OFF:
258 case RTC_PIE_ON:
259 if (!is_valid_irq(cmos->irq))
260 return -EINVAL;
261 break;
262 default:
263 return -ENOIOCTLCMD;
264 }
265
266 spin_lock_irqsave(&rtc_lock, flags);
267 rtc_control = CMOS_READ(RTC_CONTROL);
268 switch (cmd) {
269 case RTC_AIE_OFF: /* alarm off */
270 rtc_control &= ~RTC_AIE;
271 break;
272 case RTC_AIE_ON: /* alarm on */
273 rtc_control |= RTC_AIE;
274 break;
275 case RTC_UIE_OFF: /* update off */
276 rtc_control &= ~RTC_UIE;
277 break;
278 case RTC_UIE_ON: /* update on */
279 rtc_control |= RTC_UIE;
280 break;
281 case RTC_PIE_OFF: /* periodic off */
282 rtc_control &= ~RTC_PIE;
283 break;
284 case RTC_PIE_ON: /* periodic on */
285 rtc_control |= RTC_PIE;
286 break;
287 }
288 CMOS_WRITE(rtc_control, RTC_CONTROL);
289 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
290 if (rtc_intr)
291 rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr);
292 spin_unlock_irqrestore(&rtc_lock, flags);
293 return 0;
294}
295
296#else
297#define cmos_rtc_ioctl NULL
298#endif
299
300#if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
301
302static int cmos_procfs(struct device *dev, struct seq_file *seq)
303{
304 struct cmos_rtc *cmos = dev_get_drvdata(dev);
305 unsigned char rtc_control, valid;
306
307 spin_lock_irq(&rtc_lock);
308 rtc_control = CMOS_READ(RTC_CONTROL);
309 valid = CMOS_READ(RTC_VALID);
310 spin_unlock_irq(&rtc_lock);
311
312 /* NOTE: at least ICH6 reports battery status using a different
313 * (non-RTC) bit; and SQWE is ignored on many current systems.
314 */
315 return seq_printf(seq,
316 "periodic_IRQ\t: %s\n"
317 "update_IRQ\t: %s\n"
318 // "square_wave\t: %s\n"
319 // "BCD\t\t: %s\n"
320 "DST_enable\t: %s\n"
321 "periodic_freq\t: %d\n"
322 "batt_status\t: %s\n",
323 (rtc_control & RTC_PIE) ? "yes" : "no",
324 (rtc_control & RTC_UIE) ? "yes" : "no",
325 // (rtc_control & RTC_SQWE) ? "yes" : "no",
326 // (rtc_control & RTC_DM_BINARY) ? "no" : "yes",
327 (rtc_control & RTC_DST_EN) ? "yes" : "no",
328 cmos->rtc->irq_freq,
329 (valid & RTC_VRT) ? "okay" : "dead");
330}
331
332#else
333#define cmos_procfs NULL
334#endif
335
336static const struct rtc_class_ops cmos_rtc_ops = {
337 .ioctl = cmos_rtc_ioctl,
338 .read_time = cmos_read_time,
339 .set_time = cmos_set_time,
340 .read_alarm = cmos_read_alarm,
341 .set_alarm = cmos_set_alarm,
342 .proc = cmos_procfs,
343 .irq_set_freq = cmos_set_freq,
344};
345
346/*----------------------------------------------------------------*/
347
348static struct cmos_rtc cmos_rtc;
349
350static irqreturn_t cmos_interrupt(int irq, void *p)
351{
352 u8 irqstat;
353
354 spin_lock(&rtc_lock);
355 irqstat = CMOS_READ(RTC_INTR_FLAGS);
356 spin_unlock(&rtc_lock);
357
358 if (irqstat) {
359 /* NOTE: irqstat may have e.g. RTC_PF set
360 * even when RTC_PIE is clear...
361 */
362 rtc_update_irq(p, 1, irqstat);
363 return IRQ_HANDLED;
364 } else
365 return IRQ_NONE;
366}
367
368#ifdef CONFIG_PNPACPI
369#define is_pnpacpi() 1
370#define INITSECTION
371
372#else
373#define is_pnpacpi() 0
374#define INITSECTION __init
375#endif
376
377static int INITSECTION
378cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
379{
380 struct cmos_rtc_board_info *info = dev->platform_data;
381 int retval = 0;
382 unsigned char rtc_control;
383
384 /* there can be only one ... */
385 if (cmos_rtc.dev)
386 return -EBUSY;
387
388 if (!ports)
389 return -ENODEV;
390
391 cmos_rtc.irq = rtc_irq;
392 cmos_rtc.iomem = ports;
393
394 /* For ACPI systems the info comes from the FADT. On others,
395 * board specific setup provides it as appropriate.
396 */
397 if (info) {
398 cmos_rtc.day_alrm = info->rtc_day_alarm;
399 cmos_rtc.mon_alrm = info->rtc_mon_alarm;
400 cmos_rtc.century = info->rtc_century;
401 }
402
403 cmos_rtc.rtc = rtc_device_register(driver_name, dev,
404 &cmos_rtc_ops, THIS_MODULE);
405 if (IS_ERR(cmos_rtc.rtc))
406 return PTR_ERR(cmos_rtc.rtc);
407
408 cmos_rtc.dev = dev;
409 dev_set_drvdata(dev, &cmos_rtc);
410
411 /* platform and pnp busses handle resources incompatibly.
412 *
413 * REVISIT for non-x86 systems we may need to handle io memory
414 * resources: ioremap them, and request_mem_region().
415 */
416 if (is_pnpacpi()) {
417 retval = request_resource(&ioport_resource, ports);
418 if (retval < 0) {
419 dev_dbg(dev, "i/o registers already in use\n");
420 goto cleanup0;
421 }
422 }
423 rename_region(ports, cmos_rtc.rtc->class_dev.class_id);
424
425 spin_lock_irq(&rtc_lock);
426
427 /* force periodic irq to CMOS reset default of 1024Hz;
428 *
429 * REVISIT it's been reported that at least one x86_64 ALI mobo
430 * doesn't use 32KHz here ... for portability we might need to
431 * do something about other clock frequencies.
432 */
433 CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT);
434 cmos_rtc.rtc->irq_freq = 1024;
435
436 /* disable irqs.
437 *
438 * NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
439 * allegedly some older rtcs need that to handle irqs properly
440 */
441 rtc_control = CMOS_READ(RTC_CONTROL);
442 rtc_control &= ~(RTC_PIE | RTC_AIE | RTC_UIE);
443 CMOS_WRITE(rtc_control, RTC_CONTROL);
444 CMOS_READ(RTC_INTR_FLAGS);
445
446 spin_unlock_irq(&rtc_lock);
447
448 /* FIXME teach the alarm code how to handle binary mode;
449 * <asm-generic/rtc.h> doesn't know 12-hour mode either.
450 */
451 if (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY))) {
452 dev_dbg(dev, "only 24-hr BCD mode supported\n");
453 retval = -ENXIO;
454 goto cleanup1;
455 }
456
457 if (is_valid_irq(rtc_irq))
458 retval = request_irq(rtc_irq, cmos_interrupt, IRQF_DISABLED,
459 cmos_rtc.rtc->class_dev.class_id,
460 &cmos_rtc.rtc->class_dev);
461 if (retval < 0) {
462 dev_dbg(dev, "IRQ %d is already in use\n", rtc_irq);
463 goto cleanup1;
464 }
465
466 /* REVISIT optionally make 50 or 114 bytes NVRAM available,
467 * like rtc-ds1553, rtc-ds1742 ... this will often include
468 * registers for century, and day/month alarm.
469 */
470
471 pr_info("%s: alarms up to one %s%s\n",
472 cmos_rtc.rtc->class_dev.class_id,
473 is_valid_irq(rtc_irq)
474 ? (cmos_rtc.mon_alrm
475 ? "year"
476 : (cmos_rtc.day_alrm
477 ? "month" : "day"))
478 : "no",
479 cmos_rtc.century ? ", y3k" : ""
480 );
481
482 return 0;
483
484cleanup1:
485 rename_region(ports, NULL);
486cleanup0:
487 rtc_device_unregister(cmos_rtc.rtc);
488 return retval;
489}
490
491static void cmos_do_shutdown(void)
492{
493 unsigned char rtc_control;
494
495 spin_lock_irq(&rtc_lock);
496 rtc_control = CMOS_READ(RTC_CONTROL);
497 rtc_control &= ~(RTC_PIE|RTC_AIE|RTC_UIE);
498 CMOS_WRITE(rtc_control, RTC_CONTROL);
499 CMOS_READ(RTC_INTR_FLAGS);
500 spin_unlock_irq(&rtc_lock);
501}
502
503static void __exit cmos_do_remove(struct device *dev)
504{
505 struct cmos_rtc *cmos = dev_get_drvdata(dev);
506
507 cmos_do_shutdown();
508
509 if (is_pnpacpi())
510 release_resource(cmos->iomem);
511 rename_region(cmos->iomem, NULL);
512
513 if (is_valid_irq(cmos->irq))
514 free_irq(cmos->irq, &cmos_rtc.rtc->class_dev);
515
516 rtc_device_unregister(cmos_rtc.rtc);
517
518 cmos_rtc.dev = NULL;
519 dev_set_drvdata(dev, NULL);
520}
521
522#ifdef CONFIG_PM
523
524static int cmos_suspend(struct device *dev, pm_message_t mesg)
525{
526 struct cmos_rtc *cmos = dev_get_drvdata(dev);
527 int do_wake = device_may_wakeup(dev);
528 unsigned char tmp, irqstat;
529
530 /* only the alarm might be a wakeup event source */
531 spin_lock_irq(&rtc_lock);
532 cmos->suspend_ctrl = tmp = CMOS_READ(RTC_CONTROL);
533 if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
534 if (do_wake)
535 tmp &= ~(RTC_PIE|RTC_UIE);
536 else
537 tmp &= ~(RTC_PIE|RTC_AIE|RTC_UIE);
538 CMOS_WRITE(tmp, RTC_CONTROL);
539 irqstat = CMOS_READ(RTC_INTR_FLAGS);
540 } else
541 irqstat = 0;
542 spin_unlock_irq(&rtc_lock);
543
544 if (irqstat)
545 rtc_update_irq(&cmos->rtc->class_dev, 1, irqstat);
546
547 /* ACPI HOOK: enable ACPI_EVENT_RTC when (tmp & RTC_AIE)
548 * ... it'd be best if we could do that under rtc_lock.
549 */
550
551 pr_debug("%s: suspend%s, ctrl %02x\n",
552 cmos_rtc.rtc->class_dev.class_id,
553 (tmp & RTC_AIE) ? ", alarm may wake" : "",
554 tmp);
555
556 return 0;
557}
558
559static int cmos_resume(struct device *dev)
560{
561 struct cmos_rtc *cmos = dev_get_drvdata(dev);
562 unsigned char tmp = cmos->suspend_ctrl;
563
564 /* REVISIT: a mechanism to resync the system clock (jiffies)
565 * on resume should be portable between platforms ...
566 */
567
568 /* re-enable any irqs previously active */
569 if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
570
571 /* ACPI HOOK: disable ACPI_EVENT_RTC when (tmp & RTC_AIE) */
572
573 spin_lock_irq(&rtc_lock);
574 CMOS_WRITE(tmp, RTC_CONTROL);
575 tmp = CMOS_READ(RTC_INTR_FLAGS);
576 spin_unlock_irq(&rtc_lock);
577 if (tmp)
578 rtc_update_irq(&cmos->rtc->class_dev, 1, tmp);
579 }
580
581 pr_debug("%s: resume, ctrl %02x\n",
582 cmos_rtc.rtc->class_dev.class_id,
583 cmos->suspend_ctrl);
584
585
586 return 0;
587}
588
589#else
590#define cmos_suspend NULL
591#define cmos_resume NULL
592#endif
593
594/*----------------------------------------------------------------*/
595
596/* The "CMOS" RTC normally lives on the platform_bus. On ACPI systems,
597 * the device node may alternatively be created as a PNP device.
598 */
599
600#ifdef CONFIG_PNPACPI
601
602#include <linux/pnp.h>
603
604static int __devinit
605cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
606{
607 /* REVISIT paranoia argues for a shutdown notifier, since PNP
608 * drivers can't provide shutdown() methods to disable IRQs.
609 * Or better yet, fix PNP to allow those methods...
610 */
611 return cmos_do_probe(&pnp->dev,
612 &pnp->res.port_resource[0],
613 pnp->res.irq_resource[0].start);
614}
615
616static void __exit cmos_pnp_remove(struct pnp_dev *pnp)
617{
618 cmos_do_remove(&pnp->dev);
619}
620
621#ifdef CONFIG_PM
622
623static int cmos_pnp_suspend(struct pnp_dev *pnp, pm_message_t mesg)
624{
625 return cmos_suspend(&pnp->dev, mesg);
626}
627
628static int cmos_pnp_resume(struct pnp_dev *pnp)
629{
630 return cmos_resume(&pnp->dev);
631}
632
633#else
634#define cmos_pnp_suspend NULL
635#define cmos_pnp_resume NULL
636#endif
637
638
639static const struct pnp_device_id rtc_ids[] = {
640 { .id = "PNP0b00", },
641 { .id = "PNP0b01", },
642 { .id = "PNP0b02", },
643 { },
644};
645MODULE_DEVICE_TABLE(pnp, rtc_ids);
646
647static struct pnp_driver cmos_pnp_driver = {
648 .name = (char *) driver_name,
649 .id_table = rtc_ids,
650 .probe = cmos_pnp_probe,
651 .remove = __exit_p(cmos_pnp_remove),
652
653 /* flag ensures resume() gets called, and stops syslog spam */
654 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
655 .suspend = cmos_pnp_suspend,
656 .resume = cmos_pnp_resume,
657};
658
659static int __init cmos_init(void)
660{
661 return pnp_register_driver(&cmos_pnp_driver);
662}
663module_init(cmos_init);
664
665static void __exit cmos_exit(void)
666{
667 pnp_unregister_driver(&cmos_pnp_driver);
668}
669module_exit(cmos_exit);
670
671#else /* no PNPACPI */
672
673/*----------------------------------------------------------------*/
674
675/* Platform setup should have set up an RTC device, when PNPACPI is
676 * unavailable ... this is the normal case, common even on PCs.
677 */
678
679static int __init cmos_platform_probe(struct platform_device *pdev)
680{
681 return cmos_do_probe(&pdev->dev,
682 platform_get_resource(pdev, IORESOURCE_IO, 0),
683 platform_get_irq(pdev, 0));
684}
685
686static int __exit cmos_platform_remove(struct platform_device *pdev)
687{
688 cmos_do_remove(&pdev->dev);
689 return 0;
690}
691
692static void cmos_platform_shutdown(struct platform_device *pdev)
693{
694 cmos_do_shutdown();
695}
696
697static struct platform_driver cmos_platform_driver = {
698 .remove = __exit_p(cmos_platform_remove),
699 .shutdown = cmos_platform_shutdown,
700 .driver = {
701 .name = (char *) driver_name,
702 .suspend = cmos_suspend,
703 .resume = cmos_resume,
704 }
705};
706
707static int __init cmos_init(void)
708{
709 return platform_driver_probe(&cmos_platform_driver,
710 cmos_platform_probe);
711}
712module_init(cmos_init);
713
714static void __exit cmos_exit(void)
715{
716 platform_driver_unregister(&cmos_platform_driver);
717}
718module_exit(cmos_exit);
719
720
721#endif /* !PNPACPI */
722
723MODULE_AUTHOR("David Brownell");
724MODULE_DESCRIPTION("Driver for PC-style 'CMOS' RTCs");
725MODULE_LICENSE("GPL");