rtc-cmos.c 36.8 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*
 * RTC class driver for "CMOS RTC":  PCs, ACPI, etc
 *
 * Copyright (C) 1996 Paul Gortmaker (drivers/char/rtc.c)
 * Copyright (C) 2006 David Brownell (convert to new framework)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

/*
 * The original "cmos clock" chip was an MC146818 chip, now obsolete.
 * That defined the register interface now provided by all PCs, some
 * non-PC systems, and incorporated into ACPI.  Modern PC chipsets
 * integrate an MC146818 clone in their southbridge, and boards use
 * that instead of discrete clones like the DS12887 or M48T86.  There
 * are also clones that connect using the LPC bus.
 *
 * That register API is also used directly by various other drivers
 * (notably for integrated NVRAM), infrastructure (x86 has code to
 * bypass the RTC framework, directly reading the RTC during boot
 * and updating minutes/seconds for systems using NTP synch) and
 * utilities (like userspace 'hwclock', if no /dev node exists).
 *
 * So **ALL** calls to CMOS_READ and CMOS_WRITE must be done with
 * interrupts disabled, holding the global rtc_lock, to exclude those
 * other drivers and utilities on correctly configured systems.
 */
31
32
33

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

34
35
36
37
38
39
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/platform_device.h>
40
#include <linux/log2.h>
Paul Fox's avatar
Paul Fox committed
41
#include <linux/pm.h>
42
43
#include <linux/of.h>
#include <linux/of_platform.h>
44
45
#ifdef CONFIG_X86
#include <asm/i8259.h>
46
47
#include <asm/processor.h>
#include <linux/dmi.h>
48
#endif
49
50

/* this is for "generic access to PC-style RTC" using CMOS_READ/CMOS_WRITE */
51
#include <linux/mc146818rtc.h>
52

53
#ifdef CONFIG_ACPI
54
55
56
57
58
59
60
61
62
63
64
/*
 * Use ACPI SCI to replace HPET interrupt for RTC Alarm event
 *
 * If cleared, ACPI SCI is only used to wake up the system from suspend
 *
 * If set, ACPI SCI is used to handle UIE/AIE and system wakeup
 */

static bool use_acpi_alarm;
module_param(use_acpi_alarm, bool, 0444);

65
66
67
68
69
70
71
72
73
74
75
76
static inline int cmos_use_acpi_alarm(void)
{
	return use_acpi_alarm;
}
#else /* !CONFIG_ACPI */

static inline int cmos_use_acpi_alarm(void)
{
	return 0;
}
#endif

77
78
79
80
81
struct cmos_rtc {
	struct rtc_device	*rtc;
	struct device		*dev;
	int			irq;
	struct resource		*iomem;
82
	time64_t		alarm_expires;
83

David Brownell's avatar
David Brownell committed
84
85
86
87
	void			(*wake_on)(struct device *);
	void			(*wake_off)(struct device *);

	u8			enabled_wake;
88
89
90
91
92
93
	u8			suspend_ctrl;

	/* newer hardware extends the original register set */
	u8			day_alrm;
	u8			mon_alrm;
	u8			century;
94
95

	struct rtc_wkalrm	saved_wkalrm;
96
97
98
};

/* both platform and pnp busses use negative numbers for invalid irqs */
99
#define is_valid_irq(n)		((n) > 0)
100
101
102

static const char driver_name[] = "rtc_cmos";

103
104
105
106
107
108
109
110
111
112
113
114
115
/* The RTC_INTR register may have e.g. RTC_PF set even if RTC_PIE is clear;
 * always mask it against the irq enable bits in RTC_CONTROL.  Bit values
 * are the same: PF==PIE, AF=AIE, UF=UIE; so RTC_IRQMASK works with both.
 */
#define	RTC_IRQMASK	(RTC_PF | RTC_AF | RTC_UF)

static inline int is_intr(u8 rtc_intr)
{
	if (!(rtc_intr & RTC_IRQF))
		return 0;
	return rtc_intr & RTC_IRQMASK;
}

116
117
/*----------------------------------------------------------------*/

118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
/* Much modern x86 hardware has HPETs (10+ MHz timers) which, because
 * many BIOS programmers don't set up "sane mode" IRQ routing, are mostly
 * used in a broken "legacy replacement" mode.  The breakage includes
 * HPET #1 hijacking the IRQ for this RTC, and being unavailable for
 * other (better) use.
 *
 * When that broken mode is in use, platform glue provides a partial
 * emulation of hardware RTC IRQ facilities using HPET #1.  We don't
 * want to use HPET for anything except those IRQs though...
 */
#ifdef CONFIG_HPET_EMULATE_RTC
#include <asm/hpet.h>
#else

static inline int is_hpet_enabled(void)
{
	return 0;
}

static inline int hpet_mask_rtc_irq_bit(unsigned long mask)
{
	return 0;
}

static inline int hpet_set_rtc_irq_bit(unsigned long mask)
{
	return 0;
}

static inline int
hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
{
	return 0;
}

static inline int hpet_set_periodic_freq(unsigned long freq)
{
	return 0;
}

static inline int hpet_rtc_dropped_irq(void)
{
	return 0;
}

static inline int hpet_rtc_timer_init(void)
{
	return 0;
}

extern irq_handler_t hpet_rtc_interrupt;

static inline int hpet_register_irq_handler(irq_handler_t handler)
{
	return 0;
}

static inline int hpet_unregister_irq_handler(irq_handler_t handler)
{
	return 0;
}

#endif

182
/* Don't use HPET for RTC Alarm event if ACPI Fixed event is used */
183
static inline int use_hpet_alarm(void)
184
{
185
	return is_hpet_enabled() && !cmos_use_acpi_alarm();
186
187
}

188
189
/*----------------------------------------------------------------*/

190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
#ifdef RTC_PORT

/* Most newer x86 systems have two register banks, the first used
 * for RTC and NVRAM and the second only for NVRAM.  Caller must
 * own rtc_lock ... and we won't worry about access during NMI.
 */
#define can_bank2	true

static inline unsigned char cmos_read_bank2(unsigned char addr)
{
	outb(addr, RTC_PORT(2));
	return inb(RTC_PORT(3));
}

static inline void cmos_write_bank2(unsigned char val, unsigned char addr)
{
	outb(addr, RTC_PORT(2));
207
	outb(val, RTC_PORT(3));
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
}

#else

#define can_bank2	false

static inline unsigned char cmos_read_bank2(unsigned char addr)
{
	return 0;
}

static inline void cmos_write_bank2(unsigned char val, unsigned char addr)
{
}

#endif

/*----------------------------------------------------------------*/

227
228
static int cmos_read_time(struct device *dev, struct rtc_time *t)
{
229
230
231
232
233
234
235
	/*
	 * If pm_trace abused the RTC for storage, set the timespec to 0,
	 * which tells the caller that this RTC value is unusable.
	 */
	if (!pm_trace_rtc_valid())
		return -EIO;

236
	/* REVISIT:  if the clock has a "century" register, use
237
	 * that instead of the heuristic in mc146818_get_time().
238
239
	 * That'll make Y3K compatility (year > 2070) easy!
	 */
240
	mc146818_get_time(t);
241
242
243
244
245
246
247
248
249
250
251
	return 0;
}

static int cmos_set_time(struct device *dev, struct rtc_time *t)
{
	/* REVISIT:  set the "century" register if available
	 *
	 * NOTE: this ignores the issue whereby updating the seconds
	 * takes effect exactly 500ms after we write the register.
	 * (Also queueing and other delays before we get this far.)
	 */
252
	return mc146818_set_time(t);
253
254
255
256
257
258
259
}

static int cmos_read_alarm(struct device *dev, struct rtc_wkalrm *t)
{
	struct cmos_rtc	*cmos = dev_get_drvdata(dev);
	unsigned char	rtc_control;

260
	/* This not only a rtc_op, but also called directly */
261
262
263
264
265
266
267
268
269
270
271
272
273
274
	if (!is_valid_irq(cmos->irq))
		return -EIO;

	/* Basic alarms only support hour, minute, and seconds fields.
	 * Some also support day and month, for alarms up to a year in
	 * the future.
	 */

	spin_lock_irq(&rtc_lock);
	t->time.tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
	t->time.tm_min = CMOS_READ(RTC_MINUTES_ALARM);
	t->time.tm_hour = CMOS_READ(RTC_HOURS_ALARM);

	if (cmos->day_alrm) {
275
276
		/* ignore upper bits on readback per ACPI spec */
		t->time.tm_mday = CMOS_READ(cmos->day_alrm) & 0x3f;
277
278
279
280
281
282
283
284
285
286
287
288
289
		if (!t->time.tm_mday)
			t->time.tm_mday = -1;

		if (cmos->mon_alrm) {
			t->time.tm_mon = CMOS_READ(cmos->mon_alrm);
			if (!t->time.tm_mon)
				t->time.tm_mon = -1;
		}
	}

	rtc_control = CMOS_READ(RTC_CONTROL);
	spin_unlock_irq(&rtc_lock);

290
291
292
	if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
		if (((unsigned)t->time.tm_sec) < 0x60)
			t->time.tm_sec = bcd2bin(t->time.tm_sec);
293
		else
294
295
296
297
298
299
300
301
302
303
304
305
306
			t->time.tm_sec = -1;
		if (((unsigned)t->time.tm_min) < 0x60)
			t->time.tm_min = bcd2bin(t->time.tm_min);
		else
			t->time.tm_min = -1;
		if (((unsigned)t->time.tm_hour) < 0x24)
			t->time.tm_hour = bcd2bin(t->time.tm_hour);
		else
			t->time.tm_hour = -1;

		if (cmos->day_alrm) {
			if (((unsigned)t->time.tm_mday) <= 0x31)
				t->time.tm_mday = bcd2bin(t->time.tm_mday);
307
			else
308
309
310
311
312
313
314
315
				t->time.tm_mday = -1;

			if (cmos->mon_alrm) {
				if (((unsigned)t->time.tm_mon) <= 0x12)
					t->time.tm_mon = bcd2bin(t->time.tm_mon)-1;
				else
					t->time.tm_mon = -1;
			}
316
317
318
319
320
321
322
323
324
		}
	}

	t->enabled = !!(rtc_control & RTC_AIE);
	t->pending = 0;

	return 0;
}

David Brownell's avatar
David Brownell committed
325
326
327
328
329
330
331
332
333
static void cmos_checkintr(struct cmos_rtc *cmos, unsigned char rtc_control)
{
	unsigned char	rtc_intr;

	/* NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
	 * allegedly some older rtcs need that to handle irqs properly
	 */
	rtc_intr = CMOS_READ(RTC_INTR_FLAGS);

334
	if (use_hpet_alarm())
David Brownell's avatar
David Brownell committed
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
		return;

	rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
	if (is_intr(rtc_intr))
		rtc_update_irq(cmos->rtc, 1, rtc_intr);
}

static void cmos_irq_enable(struct cmos_rtc *cmos, unsigned char mask)
{
	unsigned char	rtc_control;

	/* flush any pending IRQ status, notably for update irqs,
	 * before we enable new IRQs
	 */
	rtc_control = CMOS_READ(RTC_CONTROL);
	cmos_checkintr(cmos, rtc_control);

	rtc_control |= mask;
	CMOS_WRITE(rtc_control, RTC_CONTROL);
354
355
356
	if (use_hpet_alarm())
		hpet_set_rtc_irq_bit(mask);

357
	if ((mask & RTC_AIE) && cmos_use_acpi_alarm()) {
358
359
360
		if (cmos->wake_on)
			cmos->wake_on(cmos->dev);
	}
David Brownell's avatar
David Brownell committed
361
362
363
364
365
366
367
368
369
370
371

	cmos_checkintr(cmos, rtc_control);
}

static void cmos_irq_disable(struct cmos_rtc *cmos, unsigned char mask)
{
	unsigned char	rtc_control;

	rtc_control = CMOS_READ(RTC_CONTROL);
	rtc_control &= ~mask;
	CMOS_WRITE(rtc_control, RTC_CONTROL);
372
373
374
	if (use_hpet_alarm())
		hpet_mask_rtc_irq_bit(mask);

375
	if ((mask & RTC_AIE) && cmos_use_acpi_alarm()) {
376
377
378
		if (cmos->wake_off)
			cmos->wake_off(cmos->dev);
	}
David Brownell's avatar
David Brownell committed
379
380
381
382

	cmos_checkintr(cmos, rtc_control);
}

383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
static int cmos_validate_alarm(struct device *dev, struct rtc_wkalrm *t)
{
	struct cmos_rtc *cmos = dev_get_drvdata(dev);
	struct rtc_time now;

	cmos_read_time(dev, &now);

	if (!cmos->day_alrm) {
		time64_t t_max_date;
		time64_t t_alrm;

		t_max_date = rtc_tm_to_time64(&now);
		t_max_date += 24 * 60 * 60 - 1;
		t_alrm = rtc_tm_to_time64(&t->time);
		if (t_alrm > t_max_date) {
			dev_err(dev,
				"Alarms can be up to one day in the future\n");
			return -EINVAL;
		}
	} else if (!cmos->mon_alrm) {
		struct rtc_time max_date = now;
		time64_t t_max_date;
		time64_t t_alrm;
		int max_mday;

		if (max_date.tm_mon == 11) {
			max_date.tm_mon = 0;
			max_date.tm_year += 1;
		} else {
			max_date.tm_mon += 1;
		}
		max_mday = rtc_month_days(max_date.tm_mon, max_date.tm_year);
		if (max_date.tm_mday > max_mday)
			max_date.tm_mday = max_mday;

		t_max_date = rtc_tm_to_time64(&max_date);
		t_max_date -= 1;
		t_alrm = rtc_tm_to_time64(&t->time);
		if (t_alrm > t_max_date) {
			dev_err(dev,
				"Alarms can be up to one month in the future\n");
			return -EINVAL;
		}
	} else {
		struct rtc_time max_date = now;
		time64_t t_max_date;
		time64_t t_alrm;
		int max_mday;

		max_date.tm_year += 1;
		max_mday = rtc_month_days(max_date.tm_mon, max_date.tm_year);
		if (max_date.tm_mday > max_mday)
			max_date.tm_mday = max_mday;

		t_max_date = rtc_tm_to_time64(&max_date);
		t_max_date -= 1;
		t_alrm = rtc_tm_to_time64(&t->time);
		if (t_alrm > t_max_date) {
			dev_err(dev,
				"Alarms can be up to one year in the future\n");
			return -EINVAL;
		}
	}

	return 0;
}

450
451
452
static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
{
	struct cmos_rtc	*cmos = dev_get_drvdata(dev);
453
	unsigned char mon, mday, hrs, min, sec, rtc_control;
454
	int ret;
455

456
	/* This not only a rtc_op, but also called directly */
457
458
459
	if (!is_valid_irq(cmos->irq))
		return -EIO;

460
461
462
463
	ret = cmos_validate_alarm(dev, t);
	if (ret < 0)
		return ret;

464
	mon = t->time.tm_mon + 1;
465
466
467
468
	mday = t->time.tm_mday;
	hrs = t->time.tm_hour;
	min = t->time.tm_min;
	sec = t->time.tm_sec;
469
470
471
472
473
474
475
476
477
478

	rtc_control = CMOS_READ(RTC_CONTROL);
	if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
		/* Writing 0xff means "don't care" or "match all".  */
		mon = (mon <= 12) ? bin2bcd(mon) : 0xff;
		mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
		hrs = (hrs < 24) ? bin2bcd(hrs) : 0xff;
		min = (min < 60) ? bin2bcd(min) : 0xff;
		sec = (sec < 60) ? bin2bcd(sec) : 0xff;
	}
479
480
481
482

	spin_lock_irq(&rtc_lock);

	/* next rtc irq must not be from previous alarm setting */
David Brownell's avatar
David Brownell committed
483
	cmos_irq_disable(cmos, RTC_AIE);
484
485
486
487
488
489
490
491
492
493
494
495
496

	/* update alarm */
	CMOS_WRITE(hrs, RTC_HOURS_ALARM);
	CMOS_WRITE(min, RTC_MINUTES_ALARM);
	CMOS_WRITE(sec, RTC_SECONDS_ALARM);

	/* the system may support an "enhanced" alarm */
	if (cmos->day_alrm) {
		CMOS_WRITE(mday, cmos->day_alrm);
		if (cmos->mon_alrm)
			CMOS_WRITE(mon, cmos->mon_alrm);
	}

497
498
499
500
501
502
503
504
	if (use_hpet_alarm()) {
		/*
		 * FIXME the HPET alarm glue currently ignores day_alrm
		 * and mon_alrm ...
		 */
		hpet_set_alarm_time(t->time.tm_hour, t->time.tm_min,
				    t->time.tm_sec);
	}
505

David Brownell's avatar
David Brownell committed
506
507
	if (t->enabled)
		cmos_irq_enable(cmos, RTC_AIE);
508
509
510

	spin_unlock_irq(&rtc_lock);

511
512
	cmos->alarm_expires = rtc_tm_to_time64(&t->time);

513
514
515
	return 0;
}

516
static int cmos_alarm_irq_enable(struct device *dev, unsigned int enabled)
517
518
519
520
521
{
	struct cmos_rtc	*cmos = dev_get_drvdata(dev);
	unsigned long	flags;

	spin_lock_irqsave(&rtc_lock, flags);
522
523

	if (enabled)
David Brownell's avatar
David Brownell committed
524
		cmos_irq_enable(cmos, RTC_AIE);
525
526
527
	else
		cmos_irq_disable(cmos, RTC_AIE);

528
529
530
531
	spin_unlock_irqrestore(&rtc_lock, flags);
	return 0;
}

532
#if IS_ENABLED(CONFIG_RTC_INTF_PROC)
533
534
535
536
537
538
539
540
541
542
543
544
545
546

static int cmos_procfs(struct device *dev, struct seq_file *seq)
{
	struct cmos_rtc	*cmos = dev_get_drvdata(dev);
	unsigned char	rtc_control, valid;

	spin_lock_irq(&rtc_lock);
	rtc_control = CMOS_READ(RTC_CONTROL);
	valid = CMOS_READ(RTC_VALID);
	spin_unlock_irq(&rtc_lock);

	/* NOTE:  at least ICH6 reports battery status using a different
	 * (non-RTC) bit; and SQWE is ignored on many current systems.
	 */
547
548
549
550
551
552
553
554
555
556
557
	seq_printf(seq,
		   "periodic_IRQ\t: %s\n"
		   "update_IRQ\t: %s\n"
		   "HPET_emulated\t: %s\n"
		   // "square_wave\t: %s\n"
		   "BCD\t\t: %s\n"
		   "DST_enable\t: %s\n"
		   "periodic_freq\t: %d\n"
		   "batt_status\t: %s\n",
		   (rtc_control & RTC_PIE) ? "yes" : "no",
		   (rtc_control & RTC_UIE) ? "yes" : "no",
558
		   use_hpet_alarm() ? "yes" : "no",
559
560
561
562
563
564
565
		   // (rtc_control & RTC_SQWE) ? "yes" : "no",
		   (rtc_control & RTC_DM_BINARY) ? "no" : "yes",
		   (rtc_control & RTC_DST_EN) ? "yes" : "no",
		   cmos->rtc->irq_freq,
		   (valid & RTC_VRT) ? "okay" : "dead");

	return 0;
566
567
568
569
570
571
572
}

#else
#define	cmos_procfs	NULL
#endif

static const struct rtc_class_ops cmos_rtc_ops = {
573
574
575
576
577
578
	.read_time		= cmos_read_time,
	.set_time		= cmos_set_time,
	.read_alarm		= cmos_read_alarm,
	.set_alarm		= cmos_set_alarm,
	.proc			= cmos_procfs,
	.alarm_irq_enable	= cmos_alarm_irq_enable,
579
580
};

581
582
583
584
585
586
static const struct rtc_class_ops cmos_rtc_ops_no_alarm = {
	.read_time		= cmos_read_time,
	.set_time		= cmos_set_time,
	.proc			= cmos_procfs,
};

587
588
/*----------------------------------------------------------------*/

589
590
591
592
593
594
595
596
/*
 * All these chips have at least 64 bytes of address space, shared by
 * RTC registers and NVRAM.  Most of those bytes of NVRAM are used
 * by boot firmware.  Modern chips have 128 or 256 bytes.
 */

#define NVRAM_OFFSET	(RTC_REG_D + 1)

597
598
static int cmos_nvram_read(void *priv, unsigned int off, void *val,
			   size_t count)
599
{
600
	unsigned char *buf = val;
601
602
	int	retval;

603
	off += NVRAM_OFFSET;
604
	spin_lock_irq(&rtc_lock);
605
606
607
608
609
610
611
612
	for (retval = 0; count; count--, off++, retval++) {
		if (off < 128)
			*buf++ = CMOS_READ(off);
		else if (can_bank2)
			*buf++ = cmos_read_bank2(off);
		else
			break;
	}
613
614
615
616
617
	spin_unlock_irq(&rtc_lock);

	return retval;
}

618
619
static int cmos_nvram_write(void *priv, unsigned int off, void *val,
			    size_t count)
620
{
621
622
	struct cmos_rtc	*cmos = priv;
	unsigned char	*buf = val;
623
624
625
626
627
628
629
	int		retval;

	/* NOTE:  on at least PCs and Ataris, the boot firmware uses a
	 * checksum on part of the NVRAM data.  That's currently ignored
	 * here.  If userspace is smart enough to know what fields of
	 * NVRAM to update, updating checksums is also part of its job.
	 */
630
	off += NVRAM_OFFSET;
631
	spin_lock_irq(&rtc_lock);
632
	for (retval = 0; count; count--, off++, retval++) {
633
634
635
636
637
		/* don't trash RTC registers */
		if (off == cmos->day_alrm
				|| off == cmos->mon_alrm
				|| off == cmos->century)
			buf++;
638
		else if (off < 128)
639
			CMOS_WRITE(*buf++, off);
640
641
642
643
		else if (can_bank2)
			cmos_write_bank2(*buf++, off);
		else
			break;
644
645
646
647
648
649
650
651
	}
	spin_unlock_irq(&rtc_lock);

	return retval;
}

/*----------------------------------------------------------------*/

652
653
654
655
656
static struct cmos_rtc	cmos_rtc;

static irqreturn_t cmos_interrupt(int irq, void *p)
{
	u8		irqstat;
657
	u8		rtc_control;
658
659

	spin_lock(&rtc_lock);
660
661
662
663
664
665
666

	/* When the HPET interrupt handler calls us, the interrupt
	 * status is passed as arg1 instead of the irq number.  But
	 * always clear irq status, even when HPET is in the way.
	 *
	 * Note that HPET and RTC are almost certainly out of phase,
	 * giving different IRQ status ...
667
	 */
668
669
	irqstat = CMOS_READ(RTC_INTR_FLAGS);
	rtc_control = CMOS_READ(RTC_CONTROL);
670
	if (use_hpet_alarm())
671
		irqstat = (unsigned long)irq & 0xF0;
672
673
674
675
676
677
678
679

	/* If we were suspended, RTC_CONTROL may not be accurate since the
	 * bios may have cleared it.
	 */
	if (!cmos_rtc.suspend_ctrl)
		irqstat &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
	else
		irqstat &= (cmos_rtc.suspend_ctrl & RTC_IRQMASK) | RTC_IRQF;
680
681
682
683
684
685

	/* All Linux RTC alarms should be treated as if they were oneshot.
	 * Similar code may be needed in system wakeup paths, in case the
	 * alarm woke the system.
	 */
	if (irqstat & RTC_AIE) {
686
		cmos_rtc.suspend_ctrl &= ~RTC_AIE;
687
688
		rtc_control &= ~RTC_AIE;
		CMOS_WRITE(rtc_control, RTC_CONTROL);
689
690
		if (use_hpet_alarm())
			hpet_mask_rtc_irq_bit(RTC_AIE);
691
692
		CMOS_READ(RTC_INTR_FLAGS);
	}
693
694
	spin_unlock(&rtc_lock);

695
	if (is_intr(irqstat)) {
696
697
698
699
700
701
		rtc_update_irq(p, 1, irqstat);
		return IRQ_HANDLED;
	} else
		return IRQ_NONE;
}

702
#ifdef	CONFIG_PNP
703
704
705
706
707
708
709
710
711
#define	INITSECTION

#else
#define	INITSECTION	__init
#endif

static int INITSECTION
cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
{
712
	struct cmos_rtc_board_info	*info = dev_get_platdata(dev);
713
714
	int				retval = 0;
	unsigned char			rtc_control;
715
	unsigned			address_space;
716
	u32				flags = 0;
717
718
719
720
721
722
723
724
	struct nvmem_config nvmem_cfg = {
		.name = "cmos_nvram",
		.word_size = 1,
		.stride = 1,
		.reg_read = cmos_nvram_read,
		.reg_write = cmos_nvram_write,
		.priv = &cmos_rtc,
	};
725
726
727
728
729
730
731
732

	/* there can be only one ... */
	if (cmos_rtc.dev)
		return -EBUSY;

	if (!ports)
		return -ENODEV;

David Brownell's avatar
David Brownell committed
733
734
735
736
737
	/* Claim I/O ports ASAP, minimizing conflict with legacy driver.
	 *
	 * REVISIT non-x86 systems may instead use memory space resources
	 * (needing ioremap etc), not i/o space resources like this ...
	 */
738
739
740
741
742
743
	if (RTC_IOMAPPED)
		ports = request_region(ports->start, resource_size(ports),
				       driver_name);
	else
		ports = request_mem_region(ports->start, resource_size(ports),
					   driver_name);
David Brownell's avatar
David Brownell committed
744
745
746
747
748
	if (!ports) {
		dev_dbg(dev, "i/o registers already in use\n");
		return -EBUSY;
	}

749
750
751
	cmos_rtc.irq = rtc_irq;
	cmos_rtc.iomem = ports;

752
753
	/* Heuristic to deduce NVRAM size ... do what the legacy NVRAM
	 * driver did, but don't reject unknown configs.   Old hardware
754
755
	 * won't address 128 bytes.  Newer chips have multiple banks,
	 * though they may not be listed in one I/O resource.
756
757
758
	 */
#if	defined(CONFIG_ATARI)
	address_space = 64;
759
#elif defined(__i386__) || defined(__x86_64__) || defined(__arm__) \
760
			|| defined(__sparc__) || defined(__mips__) \
761
			|| defined(__powerpc__)
762
763
764
765
766
	address_space = 128;
#else
#warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes.
	address_space = 128;
#endif
767
768
	if (can_bank2 && ports->end > (ports->start + 1))
		address_space = 256;
769

David Brownell's avatar
David Brownell committed
770
771
772
773
	/* For ACPI systems extension info comes from the FADT.  On others,
	 * board specific setup provides it as appropriate.  Systems where
	 * the alarm IRQ isn't automatically a wakeup IRQ (like ACPI, and
	 * some almost-clones) can provide hooks to make that behave.
774
775
776
777
	 *
	 * Note that ACPI doesn't preclude putting these registers into
	 * "extended" areas of the chip, including some that we won't yet
	 * expect CMOS_READ and friends to handle.
778
779
	 */
	if (info) {
780
781
782
783
784
		if (info->flags)
			flags = info->flags;
		if (info->address_space)
			address_space = info->address_space;

785
786
787
788
789
790
		if (info->rtc_day_alarm && info->rtc_day_alarm < 128)
			cmos_rtc.day_alrm = info->rtc_day_alarm;
		if (info->rtc_mon_alarm && info->rtc_mon_alarm < 128)
			cmos_rtc.mon_alrm = info->rtc_mon_alarm;
		if (info->rtc_century && info->rtc_century < 128)
			cmos_rtc.century = info->rtc_century;
David Brownell's avatar
David Brownell committed
791
792
793
794
795

		if (info->wake_on && info->wake_off) {
			cmos_rtc.wake_on = info->wake_on;
			cmos_rtc.wake_off = info->wake_off;
		}
796
797
	}

798
799
800
	cmos_rtc.dev = dev;
	dev_set_drvdata(dev, &cmos_rtc);

801
	cmos_rtc.rtc = devm_rtc_allocate_device(dev);
David Brownell's avatar
David Brownell committed
802
803
804
805
	if (IS_ERR(cmos_rtc.rtc)) {
		retval = PTR_ERR(cmos_rtc.rtc);
		goto cleanup0;
	}
806

807
	rename_region(ports, dev_name(&cmos_rtc.rtc->dev));
808
809
810

	spin_lock_irq(&rtc_lock);

811
812
813
814
815
816
817
818
	if (!(flags & CMOS_RTC_FLAGS_NOFREQ)) {
		/* force periodic irq to CMOS reset default of 1024Hz;
		 *
		 * REVISIT it's been reported that at least one x86_64 ALI
		 * mobo doesn't use 32KHz here ... for portability we might
		 * need to do something about other clock frequencies.
		 */
		cmos_rtc.rtc->irq_freq = 1024;
819
820
		if (use_hpet_alarm())
			hpet_set_periodic_freq(cmos_rtc.rtc->irq_freq);
821
822
		CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT);
	}
823

David Brownell's avatar
David Brownell committed
824
	/* disable irqs */
825
826
	if (is_valid_irq(rtc_irq))
		cmos_irq_disable(&cmos_rtc, RTC_PIE | RTC_AIE | RTC_UIE);
827

David Brownell's avatar
David Brownell committed
828
	rtc_control = CMOS_READ(RTC_CONTROL);
829
830
831

	spin_unlock_irq(&rtc_lock);

832
	if (is_valid_irq(rtc_irq) && !(rtc_control & RTC_24H)) {
833
		dev_warn(dev, "only 24-hr supported\n");
834
835
836
837
		retval = -ENXIO;
		goto cleanup1;
	}

838
839
	if (use_hpet_alarm())
		hpet_rtc_timer_init();
840

841
842
843
	if (is_valid_irq(rtc_irq)) {
		irq_handler_t rtc_cmos_int_handler;

844
		if (use_hpet_alarm()) {
845
			rtc_cmos_int_handler = hpet_rtc_interrupt;
846
847
			retval = hpet_register_irq_handler(cmos_interrupt);
			if (retval) {
848
				hpet_mask_rtc_irq_bit(RTC_IRQMASK);
849
				dev_warn(dev, "hpet_register_irq_handler "
850
851
852
853
854
855
856
						" failed in rtc_init().");
				goto cleanup1;
			}
		} else
			rtc_cmos_int_handler = cmos_interrupt;

		retval = request_irq(rtc_irq, rtc_cmos_int_handler,
857
				IRQF_SHARED, dev_name(&cmos_rtc.rtc->dev),
858
				cmos_rtc.rtc);
859
860
861
862
		if (retval < 0) {
			dev_dbg(dev, "IRQ %d is already in use\n", rtc_irq);
			goto cleanup1;
		}
863
864
865
866

		cmos_rtc.rtc->ops = &cmos_rtc_ops;
	} else {
		cmos_rtc.rtc->ops = &cmos_rtc_ops_no_alarm;
867
868
	}

869
	cmos_rtc.rtc->nvram_old_abi = true;
870
871
	retval = rtc_register_device(cmos_rtc.rtc);
	if (retval)
872
		goto cleanup2;
873

874
875
876
877
878
879
880
881
882
883
884
885
	/* export at least the first block of NVRAM */
	nvmem_cfg.size = address_space - NVRAM_OFFSET;
	if (rtc_nvmem_register(cmos_rtc.rtc, &nvmem_cfg))
		dev_err(dev, "nvmem registration failed\n");

	dev_info(dev, "%s%s, %d bytes nvram%s\n",
		 !is_valid_irq(rtc_irq) ? "no alarms" :
		 cmos_rtc.mon_alrm ? "alarms up to one year" :
		 cmos_rtc.day_alrm ? "alarms up to one month" :
		 "alarms up to one day",
		 cmos_rtc.century ? ", y3k" : "",
		 nvmem_cfg.size,
886
		 use_hpet_alarm() ? ", hpet irqs" : "");
887
888
889

	return 0;

890
891
892
cleanup2:
	if (is_valid_irq(rtc_irq))
		free_irq(rtc_irq, cmos_rtc.rtc);
893
cleanup1:
David Brownell's avatar
David Brownell committed
894
895
	cmos_rtc.dev = NULL;
cleanup0:
896
897
898
899
	if (RTC_IOMAPPED)
		release_region(ports->start, resource_size(ports));
	else
		release_mem_region(ports->start, resource_size(ports));
900
901
902
	return retval;
}

903
static void cmos_do_shutdown(int rtc_irq)
904
905
{
	spin_lock_irq(&rtc_lock);
906
907
	if (is_valid_irq(rtc_irq))
		cmos_irq_disable(&cmos_rtc, RTC_IRQMASK);
908
909
910
	spin_unlock_irq(&rtc_lock);
}

911
static void cmos_do_remove(struct device *dev)
912
913
{
	struct cmos_rtc	*cmos = dev_get_drvdata(dev);
David Brownell's avatar
David Brownell committed
914
	struct resource *ports;
915

916
	cmos_do_shutdown(cmos->irq);
917

918
	if (is_valid_irq(cmos->irq)) {
David Brownell's avatar
David Brownell committed
919
		free_irq(cmos->irq, cmos->rtc);
920
921
		if (use_hpet_alarm())
			hpet_unregister_irq_handler(cmos_interrupt);
922
	}
923

David Brownell's avatar
David Brownell committed
924
	cmos->rtc = NULL;
925

David Brownell's avatar
David Brownell committed
926
	ports = cmos->iomem;
927
928
929
930
	if (RTC_IOMAPPED)
		release_region(ports->start, resource_size(ports));
	else
		release_mem_region(ports->start, resource_size(ports));
David Brownell's avatar
David Brownell committed
931
932
933
	cmos->iomem = NULL;

	cmos->dev = NULL;
934
935
}

936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
static int cmos_aie_poweroff(struct device *dev)
{
	struct cmos_rtc	*cmos = dev_get_drvdata(dev);
	struct rtc_time now;
	time64_t t_now;
	int retval = 0;
	unsigned char rtc_control;

	if (!cmos->alarm_expires)
		return -EINVAL;

	spin_lock_irq(&rtc_lock);
	rtc_control = CMOS_READ(RTC_CONTROL);
	spin_unlock_irq(&rtc_lock);

	/* We only care about the situation where AIE is disabled. */
	if (rtc_control & RTC_AIE)
		return -EBUSY;

	cmos_read_time(dev, &now);
	t_now = rtc_tm_to_time64(&now);

	/*
	 * When enabling "RTC wake-up" in BIOS setup, the machine reboots
	 * automatically right after shutdown on some buggy boxes.
	 * This automatic rebooting issue won't happen when the alarm
	 * time is larger than now+1 seconds.
	 *
	 * If the alarm time is equal to now+1 seconds, the issue can be
	 * prevented by cancelling the alarm.
	 */
	if (cmos->alarm_expires == t_now + 1) {
		struct rtc_wkalrm alarm;

		/* Cancel the AIE timer by configuring the past time. */
		rtc_time64_to_tm(t_now - 1, &alarm.time);
		alarm.enabled = 0;
		retval = cmos_set_alarm(dev, &alarm);
	} else if (cmos->alarm_expires > t_now + 1) {
		retval = -EBUSY;
	}

	return retval;
}

Paul Fox's avatar
Paul Fox committed
981
static int cmos_suspend(struct device *dev)
982
983
{
	struct cmos_rtc	*cmos = dev_get_drvdata(dev);
984
	unsigned char	tmp;
985
986
987
988
989

	/* only the alarm might be a wakeup event source */
	spin_lock_irq(&rtc_lock);
	cmos->suspend_ctrl = tmp = CMOS_READ(RTC_CONTROL);
	if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
990
		unsigned char	mask;
991

992
		if (device_may_wakeup(dev))
993
			mask = RTC_IRQMASK & ~RTC_AIE;
994
		else
995
996
			mask = RTC_IRQMASK;
		tmp &= ~mask;
997
		CMOS_WRITE(tmp, RTC_CONTROL);
998
999
		if (use_hpet_alarm())
			hpet_mask_rtc_irq_bit(mask);
David Brownell's avatar
David Brownell committed
1000
		cmos_checkintr(cmos, tmp);
1001
	}
1002
1003
	spin_unlock_irq(&rtc_lock);

1004
	if ((tmp & RTC_AIE) && !cmos_use_acpi_alarm()) {
David Brownell's avatar
David Brownell committed
1005
1006
1007
1008
1009
1010
		cmos->enabled_wake = 1;
		if (cmos->wake_on)
			cmos->wake_on(dev);
		else
			enable_irq_wake(cmos->irq);
	}
1011

1012
1013
	cmos_read_alarm(dev, &cmos->saved_wkalrm);

1014
	dev_dbg(dev, "suspend%s, ctrl %02x\n",
1015
1016
1017
1018
1019
1020
			(tmp & RTC_AIE) ? ", alarm may wake" : "",
			tmp);

	return 0;
}

1021
1022
1023
1024
1025
1026
1027
1028
/* We want RTC alarms to wake us from e.g. ACPI G2/S5 "soft off", even
 * after a detour through G3 "mechanical off", although the ACPI spec
 * says wakeup should only work from G1/S4 "hibernate".  To most users,
 * distinctions between S4 and S5 are pointless.  So when the hardware
 * allows, don't draw that distinction.
 */
static inline int cmos_poweroff(struct device *dev)
{
1029
1030
1031
	if (!IS_ENABLED(CONFIG_PM))
		return -ENOSYS;

Paul Fox's avatar
Paul Fox committed
1032
	return cmos_suspend(dev);
1033
1034
}

1035
1036
1037
1038
static void cmos_check_wkalrm(struct device *dev)
{
	struct cmos_rtc *cmos = dev_get_drvdata(dev);
	struct rtc_wkalrm current_alarm;
1039
	time64_t t_now;
1040
1041
	time64_t t_current_expires;
	time64_t t_saved_expires;
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
	struct rtc_time now;

	/* Check if we have RTC Alarm armed */
	if (!(cmos->suspend_ctrl & RTC_AIE))
		return;

	cmos_read_time(dev, &now);
	t_now = rtc_tm_to_time64(&now);

	/*
	 * ACPI RTC wake event is cleared after resume from STR,
	 * ACK the rtc irq here
	 */
1055
	if (t_now >= cmos->alarm_expires && cmos_use_acpi_alarm()) {
1056
1057
1058
		cmos_interrupt(0, (void *)cmos->rtc);
		return;
	}
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068

	cmos_read_alarm(dev, &current_alarm);
	t_current_expires = rtc_tm_to_time64(&current_alarm.time);
	t_saved_expires = rtc_tm_to_time64(&cmos->saved_wkalrm.time);
	if (t_current_expires != t_saved_expires ||
	    cmos->saved_wkalrm.enabled != current_alarm.enabled) {
		cmos_set_alarm(dev, &cmos->saved_wkalrm);
	}
}

1069
1070
1071
static void cmos_check_acpi_rtc_status(struct device *dev,
				       unsigned char *rtc_control);

1072
static int __maybe_unused cmos_resume(struct device *dev)
1073
1074
{
	struct cmos_rtc	*cmos = dev_get_drvdata(dev);
1075
1076
	unsigned char tmp;

1077
	if (cmos->enabled_wake && !cmos_use_acpi_alarm()) {
1078
1079
1080
1081
1082
1083
		if (cmos->wake_off)
			cmos->wake_off(dev);
		else
			disable_irq_wake(cmos->irq);
		cmos->enabled_wake = 0;
	}
1084

1085
1086
1087
	/* The BIOS might have changed the alarm, restore it */
	cmos_check_wkalrm(dev);

1088
1089
1090
	spin_lock_irq(&rtc_lock);
	tmp = cmos->suspend_ctrl;
	cmos->suspend_ctrl = 0;
1091
	/* re-enable any irqs previously active */
1092
1093
	if (tmp & RTC_IRQMASK) {
		unsigned char	mask;
1094

1095
		if (device_may_wakeup(dev) && use_hpet_alarm())
1096
1097
			hpet_rtc_timer_init();

1098
1099
		do {
			CMOS_WRITE(tmp, RTC_CONTROL);
1100
1101
			if (use_hpet_alarm())
				hpet_set_rtc_irq_bit(tmp & RTC_IRQMASK);
1102
1103
1104

			mask = CMOS_READ(RTC_INTR_FLAGS);
			mask &= (tmp & RTC_IRQMASK) | RTC_IRQF;
1105
			if (!use_hpet_alarm() || !is_intr(mask))
1106
1107
1108
1109
1110
1111
1112
1113
1114
				break;

			/* force one-shot behavior if HPET blocked
			 * the wake alarm's irq
			 */
			rtc_update_irq(cmos->rtc, 1, mask);
			tmp &= ~RTC_AIE;
			hpet_mask_rtc_irq_bit(RTC_AIE);
		} while (mask & RTC_AIE);
1115
1116
1117

		if (tmp & RTC_AIE)
			cmos_check_acpi_rtc_status(dev, &tmp);
1118
	}
1119
	spin_unlock_irq(&rtc_lock);
1120

1121
	dev_dbg(dev, "resume, ctrl %02x\n", tmp);
1122
1123
1124
1125

	return 0;
}

1126
1127
static SIMPLE_DEV_PM_OPS(cmos_pm_ops, cmos_suspend, cmos_resume);

1128
1129
/*----------------------------------------------------------------*/

1130
1131
1132
1133
1134
1135
/* On non-x86 systems, a "CMOS" RTC lives most naturally on platform_bus.
 * ACPI systems always list these as PNPACPI devices, and pre-ACPI PCs
 * probably list them in similar PNPBIOS tables; so PNP is more common.
 *
 * We don't use legacy "poke at the hardware" probing.  Ancient PCs that
 * predate even PNPBIOS should set up platform_bus devices.
1136
1137
 */

1138
1139
1140
1141
1142
1143
#ifdef	CONFIG_ACPI

#include <linux/acpi.h>

static u32 rtc_handler(void *context)
{
1144
	struct device *dev = context;
1145
1146
1147
	struct cmos_rtc *cmos = dev_get_drvdata(dev);
	unsigned char rtc_control = 0;
	unsigned char rtc_intr;
1148
	unsigned long flags;
1149

1150
1151
1152
1153
1154
1155

	/*
	 * Always update rtc irq when ACPI is used as RTC Alarm.
	 * Or else, ACPI SCI is enabled during suspend/resume only,
	 * update rtc irq in that case.
	 */
1156
	if (cmos_use_acpi_alarm())
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
		cmos_interrupt(0, (void *)cmos->rtc);
	else {
		/* Fix me: can we use cmos_interrupt() here as well? */
		spin_lock_irqsave(&rtc_lock, flags);
		if (cmos_rtc.suspend_ctrl)
			rtc_control = CMOS_READ(RTC_CONTROL);
		if (rtc_control & RTC_AIE) {
			cmos_rtc.suspend_ctrl &= ~RTC_AIE;
			CMOS_WRITE(rtc_control, RTC_CONTROL);
			rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
			rtc_update_irq(cmos->rtc, 1, rtc_intr);
		}
		spin_unlock_irqrestore(&rtc_lock, flags);
1170
	}
1171

1172
	pm_wakeup_hard_event(dev);
1173
1174
1175
1176
1177
	acpi_clear_event(ACPI_EVENT_RTC);
	acpi_disable_event(ACPI_EVENT_RTC, 0);
	return ACPI_INTERRUPT_HANDLED;
}

1178
static inline void rtc_wake_setup(struct device *dev)
1179
{
1180
	acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, dev);
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
	/*
	 * After the RTC handler is installed, the Fixed_RTC event should
	 * be disabled. Only when the RTC alarm is set will it be enabled.
	 */
	acpi_clear_event(ACPI_EVENT_RTC);
	acpi_disable_event(ACPI_EVENT_RTC, 0);
}

static void rtc_wake_on(struct device *dev)
{
	acpi_clear_event(ACPI_EVENT_RTC);
	acpi_enable_event(ACPI_EVENT_RTC, 0);
}

static void rtc_wake_off(struct device *dev)
{
	acpi_disable_event(ACPI_EVENT_RTC, 0);
}

1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
#ifdef CONFIG_X86
/* Enable use_acpi_alarm mode for Intel platforms no earlier than 2015 */
static void use_acpi_alarm_quirks(void)
{
	int year;

	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
		return;

	if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0))
		return;

	if (!is_hpet_enabled())
		return;

	if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year >= 2015)
		use_acpi_alarm = true;
}
#else
static inline void use_acpi_alarm_quirks(void) { }
#endif

1222
1223
1224
1225
1226
1227
1228
/* Every ACPI platform has a mc146818 compatible "cmos rtc".  Here we find
 * its device node and pass extra config data.  This helps its driver use
 * capabilities that the now-obsolete mc146818 didn't have, and informs it
 * that this board's RTC is wakeup-capable (per ACPI spec).
 */
static struct cmos_rtc_board_info acpi_rtc_info;

1229
static void cmos_wake_setup(struct device *dev)
1230
1231
1232
1233
{
	if (acpi_disabled)
		return;

1234
1235
	use_acpi_alarm_quirks();

1236
	rtc_wake_setup(dev);
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
	acpi_rtc_info.wake_on = rtc_wake_on;
	acpi_rtc_info.wake_off = rtc_wake_off;

	/* workaround bug in some ACPI tables */
	if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
		dev_dbg(dev, "bogus FADT month_alarm (%d)\n",
			acpi_gbl_FADT.month_alarm);
		acpi_gbl_FADT.month_alarm = 0;
	}

	acpi_rtc_info.rtc_day_alarm = acpi_gbl_FADT.day_alarm;
	acpi_rtc_info.rtc_mon_alarm = acpi_gbl_FADT.month_alarm;
	acpi_rtc_info.rtc_century = acpi_gbl_FADT.century;

	/* NOTE:  S4_RTC_WAKE is NOT currently useful to Linux */
	if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
		dev_info(dev, "RTC can wake from S4\n");

	dev->platform_data = &acpi_rtc_info;

	/* RTC always wakes from S1/S2/S3, and often S4/STD */
	device_init_wakeup(dev, 1);
}

1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
static void cmos_check_acpi_rtc_status(struct device *dev,
				       unsigned char *rtc_control)
{
	struct cmos_rtc *cmos = dev_get_drvdata(dev);
	acpi_event_status rtc_status;
	acpi_status status;

	if (acpi_gbl_FADT.flags & ACPI_FADT_FIXED_RTC)
		return;

	status = acpi_get_event_status(ACPI_EVENT_RTC, &rtc_status);
	if (ACPI_FAILURE(status)) {
		dev_err(dev, "Could not get RTC status\n");
	} else if (rtc_status & ACPI_EVENT_FLAG_SET) {
		unsigned char mask;
		*rtc_control &= ~RTC_AIE;
		CMOS_WRITE(*rtc_control, RTC_CONTROL);
		mask = CMOS_READ(RTC_INTR_FLAGS);
		rtc_update_irq(cmos->rtc, 1, mask);
	}
}

1283
1284
#else

1285
static void cmos_wake_setup(struct device *dev)
1286
1287
1288
{
}

1289
1290
1291
1292
1293
static void cmos_check_acpi_rtc_status(struct device *dev,
				       unsigned char *rtc_control)
{
}

1294
1295
#endif

1296
#ifdef	CONFIG_PNP
1297
1298
1299

#include <linux/pnp.h>

1300
static int cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
1301
{
1302
1303
	cmos_wake_setup(&pnp->dev);

1304
1305
1306
	if (pnp_port_start(pnp, 0) == 0x70 && !pnp_irq_valid(pnp, 0)) {
		unsigned int irq = 0;
#ifdef CONFIG_X86
1307
1308
		/* Some machines contain a PNP entry for the RTC, but
		 * don't define the IRQ. It should always be safe to
1309
		 * hardcode it on systems with a legacy PIC.
1310
		 */
1311
1312
1313
		if (nr_legacy_irqs())
			irq = 8;
#endif
1314
		return cmos_do_probe(&pnp->dev,
1315
1316
				pnp_get_resource(pnp, IORESOURCE_IO, 0), irq);
	} else {
1317
		return cmos_do_probe(&pnp->dev,
1318
1319
				pnp_get_resource(pnp, IORESOURCE_IO, 0),
				pnp_irq(pnp, 0));
1320
	}
1321
1322
}

1323
static void cmos_pnp_remove(struct pnp_dev *pnp)
1324
1325
1326
1327
{
	cmos_do_remove(&pnp->dev);
}

1328
static void cmos_pnp_shutdown(struct pnp_dev *pnp)
1329
{
1330
1331
1332
	struct device *dev = &pnp->dev;
	struct cmos_rtc	*cmos = dev_get_drvdata(dev);

1333
1334
1335
1336
1337
1338
	if (system_state == SYSTEM_POWER_OFF) {
		int retval = cmos_poweroff(dev);

		if (cmos_aie_poweroff(dev) < 0 && !retval)
			return;
	}
1339

1340
	cmos_do_shutdown(cmos->irq);
1341
}
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354

static const struct pnp_device_id rtc_ids[] = {
	{ .id = "PNP0b00", },
	{ .id = "PNP0b01", },
	{ .id = "PNP0b02", },
	{ },
};
MODULE_DEVICE_TABLE(pnp, rtc_ids);

static struct pnp_driver cmos_pnp_driver = {
	.name		= (char *) driver_name,
	.id_table	= rtc_ids,
	.probe		= cmos_pnp_probe,
1355
	.remove		= cmos_pnp_remove,
1356
	.shutdown	= cmos_pnp_shutdown,
1357
1358
1359

	/* flag ensures resume() gets called, and stops syslog spam */
	.flags		= PNP_DRIVER_RES_DO_NOT_CHANGE,
1360
1361
1362
	.driver		= {
			.pm = &cmos_pm_ops,
	},
1363
1364
};

1365
#endif	/* CONFIG_PNP */
1366

1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
#ifdef CONFIG_OF
static const struct of_device_id of_cmos_match[] = {
	{
		.compatible = "motorola,mc146818",
	},
	{ },
};
MODULE_DEVICE_TABLE(of, of_cmos_match);

static __init void cmos_of_init(struct platform_device *pdev)
{
	struct device_node *node = pdev->dev.of_node;
	const __be32 *val;

	if (!node)
		return;

	val = of_get_property(node, "ctrl-reg", NULL);
	if (val)
		CMOS_WRITE(be32_to_cpup(val), RTC_CONTROL);

	val = of_get_property(node, "freq-reg", NULL);
	if (val)
		CMOS_WRITE(be32_to_cpup(val), RTC_FREQ_SELECT);
}
#else
static inline void cmos_of_init(struct platform_device *pdev) {}
#endif
1395
1396
/*----------------------------------------------------------------*/

1397
/* Platform setup should have set up an RTC device, when PNP is
1398
 * unavailable ... this could happen even on (older) PCs.
1399
1400
1401
1402
 */

static int __init cmos_platform_probe(struct platform_device *pdev)
{
1403
1404
1405
	struct resource *resource;
	int irq;

1406
	cmos_of_init(pdev);
1407
	cmos_wake_setup(&pdev->dev);
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417

	if (RTC_IOMAPPED)
		resource = platform_get_resource(pdev, IORESOURCE_IO, 0);
	else
		resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	irq = platform_get_irq(pdev, 0);
	if (irq < 0)
		irq = -1;

	return cmos_do_probe(&pdev->dev, resource, irq);
1418
1419
}

1420
static int cmos_platform_remove(struct platform_device *pdev)
1421
1422
1423
1424
1425
1426
1427
{
	cmos_do_remove(&pdev->dev);
	return 0;
}

static void cmos_platform_shutdown(struct platform_device *pdev)
{
1428
1429
1430
	struct device *dev = &pdev->dev;
	struct cmos_rtc	*cmos = dev_get_drvdata(dev);