atrtc.c 16.4 KB
Newer Older
1
/*-
2
3
 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
 *
4
 * Copyright (c) 2008 Poul-Henning Kamp
5
 * Copyright (c) 2010 Alexander Motin <mav@FreeBSD.org>
6
7
8
9
10
11
12
13
14
15
16
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21
22
23
24
25
26
27
28
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
29
 * $FreeBSD$
30
31
 */

David E. O'Brien's avatar
David E. O'Brien committed
32
33
34
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

35
#include "opt_acpi.h"
36
#include "opt_isa.h"
37

38
39
#include <sys/param.h>
#include <sys/systm.h>
40
#include <sys/bus.h>
41
#include <sys/clock.h>
42
#include <sys/lock.h>
43
#include <sys/mutex.h>
44
#include <sys/kdb.h>
45
#include <sys/kernel.h>
46
#include <sys/module.h>
47
48
49
#include <sys/proc.h>
#include <sys/rman.h>
#include <sys/timeet.h>
50

51
#include <isa/rtc.h>
52
#ifdef DEV_ISA
53
#include <isa/isareg.h>
54
#include <isa/isavar.h>
55
#endif
56
57
#include <machine/intr_machdep.h>
#include "clock_if.h"
58
#ifdef DEV_ACPI
59
#include <contrib/dev/acpica/include/acpi.h>
60
61
#include <contrib/dev/acpica/include/accommon.h>
#include <dev/acpica/acpivar.h>
62
#include <machine/md_var.h>
63
#endif
64

65
/*
66
67
68
 * atrtc_lock protects low-level access to individual hardware registers.
 * atrtc_time_lock protects the entire sequence of accessing multiple registers
 * to read or write the date and time.
69
 */
70
static struct mtx atrtc_lock;
71
MTX_SYSINIT(atrtc_lock_init, &atrtc_lock, "atrtc", MTX_SPIN);
72

73
74
75
76
/* Force RTC enabled/disabled. */
static int atrtc_enabled = -1;
TUNABLE_INT("hw.atrtc.enabled", &atrtc_enabled);

77
struct mtx atrtc_time_lock;
78
MTX_SYSINIT(atrtc_time_lock_init, &atrtc_time_lock, "atrtc_time", MTX_DEF);
79

80
81
int	atrtcclock_disable = 0;

82
static	int	rtc_century = 0;
83
static	int	rtc_reg = -1;
84
static	u_char	rtc_statusa = RTCSA_DIVIDER | RTCSA_NOPROF;
85
static	u_char	rtc_statusb = RTCSB_24HR;
86

87
88
89
90
91
#ifdef DEV_ACPI
#define	_COMPONENT	ACPI_TIMER
ACPI_MODULE_NAME("ATRTC")
#endif

92
93
94
95
/*
 * RTC support routines
 */

96
97
static inline u_char
rtcin_locked(int reg)
Bruce Evans's avatar
Bruce Evans committed
98
99
{

100
101
102
103
104
105
	if (rtc_reg != reg) {
		inb(0x84);
		outb(IO_RTC, reg);
		rtc_reg = reg;
		inb(0x84);
	}
106
	return (inb(IO_RTC + 1));
Bruce Evans's avatar
Bruce Evans committed
107
108
}

109
110
static inline void
rtcout_locked(int reg, u_char val)
111
{
112

113
114
115
116
117
118
	if (rtc_reg != reg) {
		inb(0x84);
		outb(IO_RTC, reg);
		rtc_reg = reg;
		inb(0x84);
	}
Bruce Evans's avatar
icu.s:    
Bruce Evans committed
119
	outb(IO_RTC + 1, val);
120
	inb(0x84);
121
122
123
124
125
126
127
}

int
rtcin(int reg)
{
	u_char val;

128
	mtx_lock_spin(&atrtc_lock);
129
	val = rtcin_locked(reg);
130
	mtx_unlock_spin(&atrtc_lock);
131
132
133
134
135
136
137
	return (val);
}

void
writertc(int reg, u_char val)
{

138
	mtx_lock_spin(&atrtc_lock);
139
	rtcout_locked(reg, val);
140
	mtx_unlock_spin(&atrtc_lock);
141
142
}

143
static void
144
atrtc_start(void)
145
{
146

147
148
149
150
	mtx_lock_spin(&atrtc_lock);
	rtcout_locked(RTC_STATUSA, rtc_statusa);
	rtcout_locked(RTC_STATUSB, RTCSB_24HR);
	mtx_unlock_spin(&atrtc_lock);
151
152
}

153
static void
154
atrtc_rate(unsigned rate)
155
156
{

157
	rtc_statusa = RTCSA_DIVIDER | rate;
Bruce Evans's avatar
icu.s:    
Bruce Evans committed
158
	writertc(RTC_STATUSA, rtc_statusa);
159
160
}

161
static void
162
atrtc_enable_intr(void)
163
{
164

165
	rtc_statusb |= RTCSB_PINTR;
166
167
168
169
	mtx_lock_spin(&atrtc_lock);
	rtcout_locked(RTC_STATUSB, rtc_statusb);
	rtcin_locked(RTC_INTR);
	mtx_unlock_spin(&atrtc_lock);
170
171
}

172
173
174
175
176
static void
atrtc_disable_intr(void)
{

	rtc_statusb &= ~RTCSB_PINTR;
177
178
179
180
	mtx_lock_spin(&atrtc_lock);
	rtcout_locked(RTC_STATUSB, rtc_statusb);
	rtcin_locked(RTC_INTR);
	mtx_unlock_spin(&atrtc_lock);
181
182
}

183
void
184
atrtc_restore(void)
185
186
{

187
	/* Restore all of the RTC's "status" (actually, control) registers. */
188
189
190
191
192
193
194
	mtx_lock_spin(&atrtc_lock);
	rtcin_locked(RTC_STATUSA);	/* dummy to get rtc_reg set */
	rtcout_locked(RTC_STATUSB, RTCSB_24HR);
	rtcout_locked(RTC_STATUSA, rtc_statusa);
	rtcout_locked(RTC_STATUSB, rtc_statusb);
	rtcin_locked(RTC_INTR);
	mtx_unlock_spin(&atrtc_lock);
195
196
}

197
198
199
200
201
202
203
204
/**********************************************************************
 * RTC driver for subr_rtc
 */

struct atrtc_softc {
	int port_rid, intr_rid;
	struct resource *port_res;
	struct resource *intr_res;
205
206
	void *intr_handler;
	struct eventtimer et;
207
208
209
#ifdef DEV_ACPI
	ACPI_HANDLE acpi_handle;
#endif
210
211
};

212
static int
Alexander Motin's avatar
Alexander Motin committed
213
rtc_start(struct eventtimer *et, sbintime_t first, sbintime_t period)
214
215
{

Alexander Motin's avatar
Alexander Motin committed
216
	atrtc_rate(max(fls(period + (period >> 1)) - 17, 1));
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
	atrtc_enable_intr();
	return (0);
}

static int
rtc_stop(struct eventtimer *et)
{

	atrtc_disable_intr();
	return (0);
}

/*
 * This routine receives statistical clock interrupts from the RTC.
 * As explained above, these occur at 128 interrupts per second.
 * When profiling, we receive interrupts at a rate of 1024 Hz.
 *
 * This does not actually add as much overhead as it sounds, because
 * when the statistical clock is active, the hardclock driver no longer
 * needs to keep (inaccurate) statistics on its own.  This decouples
 * statistics gathering from scheduling interrupts.
 *
 * The RTC chip requires that we read status register C (RTC_INTR)
 * to acknowledge an interrupt, before it will generate the next one.
 * Under high interrupt load, rtcintr() can be indefinitely delayed and
 * the clock can tick immediately after the read from RTC_INTR.  In this
 * case, the mc146818A interrupt signal will not drop for long enough
 * to register with the 8259 PIC.  If an interrupt is missed, the stat
 * clock will halt, considerably degrading system performance.  This is
 * why we use 'while' rather than a more straightforward 'if' below.
 * Stat clock ticks can still be lost, causing minor loss of accuracy
 * in the statistics, but the stat clock will no longer stop.
 */
static int
rtc_intr(void *arg)
{
	struct atrtc_softc *sc = (struct atrtc_softc *)arg;
	int flag = 0;

	while (rtcin(RTC_INTR) & RTCIR_PERIOD) {
		flag = 1;
258
259
		if (sc->et.et_active)
			sc->et.et_event_cb(&sc->et, sc->et.et_arg);
260
261
262
263
	}
	return(flag ? FILTER_HANDLED : FILTER_STRAY);
}

264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
#ifdef DEV_ACPI
/*
 *  ACPI RTC CMOS address space handler
 */
#define	ATRTC_LAST_REG	0x40

static void
rtcin_region(int reg, void *buf, int len)
{
	u_char *ptr = buf;

	/* Drop lock after each IO as intr and settime have greater priority */
	while (len-- > 0)
		*ptr++ = rtcin(reg++) & 0xff;
}

static void
rtcout_region(int reg, const void *buf, int len)
{
	const u_char *ptr = buf;

	while (len-- > 0)
		writertc(reg++, *ptr++);
}

static bool
atrtc_check_cmos_access(bool is_read, ACPI_PHYSICAL_ADDRESS addr, UINT32 len)
{

	/* Block address space wrapping on out-of-bound access */
	if (addr >= ATRTC_LAST_REG || addr + len > ATRTC_LAST_REG)
		return (false);

	if (is_read) {
		/* Reading 0x0C will muck with interrupts */
		if (addr <= RTC_INTR && addr + len > RTC_INTR)
			return (false);
	} else {
		/*
		 * Allow single-byte writes to alarm registers and
		 * multi-byte writes to addr >= 0x30, else deny.
		 */
		if (!((len == 1 && (addr == RTC_SECALRM ||
				    addr == RTC_MINALRM ||
				    addr == RTC_HRSALRM)) ||
		      addr >= 0x30))
			return (false);
	}
	return (true);
}

static ACPI_STATUS
atrtc_acpi_cmos_handler(UINT32 func, ACPI_PHYSICAL_ADDRESS addr,
    UINT32 bitwidth, UINT64 *value, void *context, void *region_context)
{
	device_t dev = context;
	UINT32 bytewidth = howmany(bitwidth, 8);
	bool is_read = func == ACPI_READ;

	/* ACPICA is very verbose on CMOS handler failures, so we, too */
#define	CMOS_HANDLER_ERR(fmt, ...) \
	device_printf(dev, "ACPI [SystemCMOS] handler: " fmt, ##__VA_ARGS__)

	ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);

	if (value == NULL) {
		CMOS_HANDLER_ERR("NULL parameter\n");
		return (AE_BAD_PARAMETER);
	}
	if (bitwidth == 0 || (bitwidth & 0x07) != 0) {
		CMOS_HANDLER_ERR("Invalid bitwidth: %u\n", bitwidth);
		return (AE_BAD_PARAMETER);
	}
	if (!atrtc_check_cmos_access(is_read, addr, bytewidth)) {
		CMOS_HANDLER_ERR("%s access rejected: addr=%#04jx, len=%u\n",
		    is_read ? "Read" : "Write", (uintmax_t)addr, bytewidth);
		return (AE_BAD_PARAMETER);
	}

	switch (func) {
	case ACPI_READ:
		rtcin_region(addr, value, bytewidth);
		break;
	case ACPI_WRITE:
		rtcout_region(addr, value, bytewidth);
		break;
	default:
		CMOS_HANDLER_ERR("Invalid function: %u\n", func);
		return (AE_BAD_PARAMETER);
	}

	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),
	    "ACPI RTC CMOS %s access: addr=%#04x, len=%u, val=%*D\n",
	    is_read ? "read" : "write", (unsigned)addr, bytewidth,
	    bytewidth, value, " ");

	return (AE_OK);
}

static int
atrtc_reg_acpi_cmos_handler(device_t dev)
{
	struct atrtc_softc *sc = device_get_softc(dev);

	ACPI_FUNCTION_TRACE((char *)(uintptr_t) __func__);

	/* Don't handle address space events if driver is disabled. */
	if (acpi_disabled("atrtc"))
		return (ENXIO);

	sc->acpi_handle = acpi_get_handle(dev);
	if (sc->acpi_handle == NULL ||
	    ACPI_FAILURE(AcpiInstallAddressSpaceHandler(sc->acpi_handle,
	      ACPI_ADR_SPACE_CMOS, atrtc_acpi_cmos_handler, NULL, dev))) {
		sc->acpi_handle = NULL;
		device_printf(dev,
		    "Can't register ACPI CMOS address space handler\n");
		return (ENXIO);
        }

        return (0);
}

static int
atrtc_unreg_acpi_cmos_handler(device_t dev)
{
	struct atrtc_softc *sc = device_get_softc(dev);

	ACPI_FUNCTION_TRACE((char *)(uintptr_t) __func__);

	if (sc->acpi_handle != NULL)
		AcpiRemoveAddressSpaceHandler(sc->acpi_handle,
		    ACPI_ADR_SPACE_CMOS, atrtc_acpi_cmos_handler);

	return (0);
}
#endif	/* DEV_ACPI */

402
403
404
405
406
407
408
409
/*
 * Attach to the ISA PnP descriptors for the timer and realtime clock.
 */
static struct isa_pnp_id atrtc_ids[] = {
	{ 0x000bd041 /* PNP0B00 */, "AT realtime clock" },
	{ 0 }
};

410
411
412
static bool
atrtc_acpi_disabled(void)
{
413
#ifdef DEV_ACPI
414
415
	uint16_t flags;

416
	if (!acpi_get_fadt_bootflags(&flags))
417
		return (false);
418
	return ((flags & ACPI_FADT_NO_CMOS_RTC) != 0);
419
420
421
#else
	return (false);
#endif
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
static int
rtc_acpi_century_get(void)
{
#ifdef DEV_ACPI
	ACPI_TABLE_FADT *fadt;
	vm_paddr_t physaddr;
	int century;

	physaddr = acpi_find_table(ACPI_SIG_FADT);
	if (physaddr == 0)
		return (0);

	fadt = acpi_map_table(physaddr, ACPI_SIG_FADT);
	if (fadt == NULL)
		return (0);

	century = fadt->Century;
	acpi_unmap_table(fadt);

	return (century);
#else
	return (0);
#endif
}

449
450
451
452
static int
atrtc_probe(device_t dev)
{
	int result;
453
454
455
456
457

	if ((atrtc_enabled == -1 && atrtc_acpi_disabled()) ||
	    (atrtc_enabled == 0))
		return (ENXIO);

458
	result = ISA_PNP_PROBE(device_get_parent(dev), dev, atrtc_ids);
459
460
461
462
463
	/* ENOENT means no PnP-ID, device is hinted. */
	if (result == ENOENT) {
		device_set_desc(dev, "AT realtime clock");
		return (BUS_PROBE_LOW_PRIORITY);
	}
464
	rtc_century = rtc_acpi_century_get();
465
	return (result);
466
467
468
469
470
471
}

static int
atrtc_attach(device_t dev)
{
	struct atrtc_softc *sc;
472
	rman_res_t s;
473
	int i;
474
475

	sc = device_get_softc(dev);
John Baldwin's avatar
John Baldwin committed
476
477
478
479
	sc->port_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &sc->port_rid,
	    IO_RTC, IO_RTC + 1, 2, RF_ACTIVE);
	if (sc->port_res == NULL)
		device_printf(dev, "Warning: Couldn't map I/O.\n");
480
	atrtc_start();
481
	clock_register(dev, 1000000);
482
	bzero(&sc->et, sizeof(struct eventtimer));
483
	if (!atrtcclock_disable &&
484
485
	    (resource_int_value(device_get_name(dev), device_get_unit(dev),
	     "clock", &i) != 0 || i != 0)) {
Alexander Motin's avatar
Alexander Motin committed
486
		sc->intr_rid = 0;
487
488
489
		while (bus_get_resource(dev, SYS_RES_IRQ, sc->intr_rid,
		    &s, NULL) == 0 && s != 8)
			sc->intr_rid++;
John Baldwin's avatar
John Baldwin committed
490
491
492
493
		sc->intr_res = bus_alloc_resource(dev, SYS_RES_IRQ,
		    &sc->intr_rid, 8, 8, 1, RF_ACTIVE);
		if (sc->intr_res == NULL) {
			device_printf(dev, "Can't map interrupt.\n");
494
			return (0);
John Baldwin's avatar
John Baldwin committed
495
496
		} else if ((bus_setup_intr(dev, sc->intr_res, INTR_TYPE_CLK,
		    rtc_intr, NULL, sc, &sc->intr_handler))) {
497
498
499
500
501
502
			device_printf(dev, "Can't setup interrupt.\n");
			return (0);
		} else { 
			/* Bind IRQ to BSP to avoid live migration. */
			bus_bind_intr(dev, sc->intr_res, 0);
		}
503
		sc->et.et_name = "RTC";
504
		sc->et.et_flags = ET_FLAGS_PERIODIC | ET_FLAGS_POW2DIV;
505
506
		sc->et.et_quality = 0;
		sc->et.et_frequency = 32768;
Alexander Motin's avatar
Alexander Motin committed
507
508
		sc->et.et_min_period = 0x00080000;
		sc->et.et_max_period = 0x80000000;
509
510
511
512
513
		sc->et.et_start = rtc_start;
		sc->et.et_stop = rtc_stop;
		sc->et.et_priv = dev;
		et_register(&sc->et);
	}
514
515
516
	return(0);
}

517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
static int
atrtc_isa_attach(device_t dev)
{

	return (atrtc_attach(dev));
}

#ifdef DEV_ACPI
static int
atrtc_acpi_attach(device_t dev)
{
	int ret;

	ret = atrtc_attach(dev);
	if (ret)
		return (ret);

	(void)atrtc_reg_acpi_cmos_handler(dev);

	return (0);
}

static int
atrtc_acpi_detach(device_t dev)
{

	(void)atrtc_unreg_acpi_cmos_handler(dev);
	return (0);
}
#endif	/* DEV_ACPI */

548
549
550
551
552
553
554
static int
atrtc_resume(device_t dev)
{

	atrtc_restore();
	return(0);
}
555
556
557
558

static int
atrtc_settime(device_t dev __unused, struct timespec *ts)
{
559
560
561
	struct bcd_clocktime bct;

	clock_ts_to_bcd(ts, &bct, false);
562
	clock_dbgprint_bcd(dev, CLOCK_DBG_WRITE, &bct);
563

564
	mtx_lock(&atrtc_time_lock);
565
	mtx_lock_spin(&atrtc_lock);
566
567
568
569
570
571
572
573
574
575
576
577

	/* Disable RTC updates and interrupts.  */
	rtcout_locked(RTC_STATUSB, RTCSB_HALT | RTCSB_24HR);

	/* Write all the time registers. */
	rtcout_locked(RTC_SEC,   bct.sec);
	rtcout_locked(RTC_MIN,   bct.min);
	rtcout_locked(RTC_HRS,   bct.hour);
	rtcout_locked(RTC_WDAY,  bct.dow + 1);
	rtcout_locked(RTC_DAY,   bct.day);
	rtcout_locked(RTC_MONTH, bct.mon);
	rtcout_locked(RTC_YEAR,  bct.year & 0xff);
578
579
	if (rtc_century)
		rtcout_locked(rtc_century, bct.year >> 8);
580
581
582
583
584
585
586

	/*
	 * Re-enable RTC updates and interrupts.
	 */
	rtcout_locked(RTC_STATUSB, rtc_statusb);
	rtcin_locked(RTC_INTR);

587
	mtx_unlock_spin(&atrtc_lock);
588
	mtx_unlock(&atrtc_time_lock);
589
590
591
592
593
594
595

	return (0);
}

static int
atrtc_gettime(device_t dev, struct timespec *ts)
{
596
	struct bcd_clocktime bct;
597
598
599
600
601
602
603

	/* Look if we have a RTC present and the time is valid */
	if (!(rtcin(RTC_STATUSD) & RTCSD_PWR)) {
		device_printf(dev, "WARNING: Battery failure indication\n");
		return (EINVAL);
	}

604
605
606
607
608
609
610
	/*
	 * wait for time update to complete
	 * If RTCSA_TUP is zero, we have at least 244us before next update.
	 * This is fast enough on most hardware, but a refinement would be
	 * to make sure that no more than 240us pass after we start reading,
	 * and try again if so.
	 */
611
	mtx_lock(&atrtc_time_lock);
612
613
	while (rtcin(RTC_STATUSA) & RTCSA_TUP)
		continue;
614
	mtx_lock_spin(&atrtc_lock);
615
616
617
618
619
620
	bct.sec  = rtcin_locked(RTC_SEC);
	bct.min  = rtcin_locked(RTC_MIN);
	bct.hour = rtcin_locked(RTC_HRS);
	bct.day  = rtcin_locked(RTC_DAY);
	bct.mon  = rtcin_locked(RTC_MONTH);
	bct.year = rtcin_locked(RTC_YEAR);
621
622
	if (rtc_century)
		bct.year |= rtcin_locked(rtc_century) << 8;
623
	mtx_unlock_spin(&atrtc_lock);
624
	mtx_unlock(&atrtc_time_lock);
625
	/* dow is unused in timespec conversion and we have no nsec info. */
626
627
	bct.dow  = 0;
	bct.nsec = 0;
628
	clock_dbgprint_bcd(dev, CLOCK_DBG_READ, &bct);
629
	return (clock_bcd_to_ts(&bct, ts, false));
630
631
}

632
static device_method_t atrtc_isa_methods[] = {
633
634
	/* Device interface */
	DEVMETHOD(device_probe,		atrtc_probe),
635
	DEVMETHOD(device_attach,	atrtc_isa_attach),
636
637
638
639
	DEVMETHOD(device_detach,	bus_generic_detach),
	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
	DEVMETHOD(device_suspend,	bus_generic_suspend),
		/* XXX stop statclock? */
640
	DEVMETHOD(device_resume,	atrtc_resume),
641
642
643
644
645
646
647

	/* clock interface */
	DEVMETHOD(clock_gettime,	atrtc_gettime),
	DEVMETHOD(clock_settime,	atrtc_settime),
	{ 0, 0 }
};

648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
static driver_t atrtc_isa_driver = {
	"atrtc",
	atrtc_isa_methods,
	sizeof(struct atrtc_softc),
};

#ifdef DEV_ACPI
static device_method_t atrtc_acpi_methods[] = {
	/* Device interface */
	DEVMETHOD(device_probe,		atrtc_probe),
	DEVMETHOD(device_attach,	atrtc_acpi_attach),
	DEVMETHOD(device_detach,	atrtc_acpi_detach),
		/* XXX stop statclock? */
	DEVMETHOD(device_resume,	atrtc_resume),

	/* clock interface */
	DEVMETHOD(clock_gettime,	atrtc_gettime),
	DEVMETHOD(clock_settime,	atrtc_settime),
	{ 0, 0 }
};

static driver_t atrtc_acpi_driver = {
670
	"atrtc",
671
	atrtc_acpi_methods,
672
673
	sizeof(struct atrtc_softc),
};
674
#endif	/* DEV_ACPI */
675
676
677

static devclass_t atrtc_devclass;

678
679
680
681
DRIVER_MODULE(atrtc, isa, atrtc_isa_driver, atrtc_devclass, 0, 0);
#ifdef DEV_ACPI
DRIVER_MODULE(atrtc, acpi, atrtc_acpi_driver, atrtc_devclass, 0, 0);
#endif
682
ISA_PNP_INFO(atrtc_ids);