acpi_ec.c revision 189903
1/*-
2 * Copyright (c) 2003-2007 Nate Lawson
3 * Copyright (c) 2000 Michael Smith
4 * Copyright (c) 2000 BSDi
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: head/sys/dev/acpica/acpi_ec.c 189903 2009-03-17 00:48:11Z jkim $");
31
32#include "opt_acpi.h"
33#include <sys/param.h>
34#include <sys/kernel.h>
35#include <sys/bus.h>
36#include <sys/lock.h>
37#include <sys/malloc.h>
38#include <sys/module.h>
39#include <sys/sx.h>
40
41#include <machine/bus.h>
42#include <machine/resource.h>
43#include <sys/rman.h>
44
45#include <contrib/dev/acpica/acpi.h>
46#include <dev/acpica/acpivar.h>
47
48/* Hooks for the ACPI CA debugging infrastructure */
49#define _COMPONENT	ACPI_EC
50ACPI_MODULE_NAME("EC")
51
52/*
53 * EC_COMMAND:
54 * -----------
55 */
56typedef UINT8				EC_COMMAND;
57
58#define EC_COMMAND_UNKNOWN		((EC_COMMAND) 0x00)
59#define EC_COMMAND_READ			((EC_COMMAND) 0x80)
60#define EC_COMMAND_WRITE		((EC_COMMAND) 0x81)
61#define EC_COMMAND_BURST_ENABLE		((EC_COMMAND) 0x82)
62#define EC_COMMAND_BURST_DISABLE	((EC_COMMAND) 0x83)
63#define EC_COMMAND_QUERY		((EC_COMMAND) 0x84)
64
65/*
66 * EC_STATUS:
67 * ----------
68 * The encoding of the EC status register is illustrated below.
69 * Note that a set bit (1) indicates the property is TRUE
70 * (e.g. if bit 0 is set then the output buffer is full).
71 * +-+-+-+-+-+-+-+-+
72 * |7|6|5|4|3|2|1|0|
73 * +-+-+-+-+-+-+-+-+
74 *  | | | | | | | |
75 *  | | | | | | | +- Output Buffer Full?
76 *  | | | | | | +--- Input Buffer Full?
77 *  | | | | | +----- <reserved>
78 *  | | | | +------- Data Register is Command Byte?
79 *  | | | +--------- Burst Mode Enabled?
80 *  | | +----------- SCI Event?
81 *  | +------------- SMI Event?
82 *  +--------------- <reserved>
83 *
84 */
85typedef UINT8				EC_STATUS;
86
87#define EC_FLAG_OUTPUT_BUFFER		((EC_STATUS) 0x01)
88#define EC_FLAG_INPUT_BUFFER		((EC_STATUS) 0x02)
89#define EC_FLAG_DATA_IS_CMD		((EC_STATUS) 0x08)
90#define EC_FLAG_BURST_MODE		((EC_STATUS) 0x10)
91
92/*
93 * EC_EVENT:
94 * ---------
95 */
96typedef UINT8				EC_EVENT;
97
98#define EC_EVENT_UNKNOWN		((EC_EVENT) 0x00)
99#define EC_EVENT_OUTPUT_BUFFER_FULL	((EC_EVENT) 0x01)
100#define EC_EVENT_INPUT_BUFFER_EMPTY	((EC_EVENT) 0x02)
101#define EC_EVENT_SCI			((EC_EVENT) 0x20)
102#define EC_EVENT_SMI			((EC_EVENT) 0x40)
103
104/* Data byte returned after burst enable indicating it was successful. */
105#define EC_BURST_ACK			0x90
106
107/*
108 * Register access primitives
109 */
110#define EC_GET_DATA(sc)							\
111	bus_space_read_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0)
112
113#define EC_SET_DATA(sc, v)						\
114	bus_space_write_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0, (v))
115
116#define EC_GET_CSR(sc)							\
117	bus_space_read_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0)
118
119#define EC_SET_CSR(sc, v)						\
120	bus_space_write_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0, (v))
121
122/* Additional params to pass from the probe routine */
123struct acpi_ec_params {
124    int		glk;
125    int		gpe_bit;
126    ACPI_HANDLE	gpe_handle;
127    int		uid;
128};
129
130/* Indicate that this device has already been probed via ECDT. */
131#define DEV_ECDT(x)	(acpi_get_magic(x) == (uintptr_t)&acpi_ec_devclass)
132
133/*
134 * Driver softc.
135 */
136struct acpi_ec_softc {
137    device_t		ec_dev;
138    ACPI_HANDLE		ec_handle;
139    int			ec_uid;
140    ACPI_HANDLE		ec_gpehandle;
141    UINT8		ec_gpebit;
142
143    int			ec_data_rid;
144    struct resource	*ec_data_res;
145    bus_space_tag_t	ec_data_tag;
146    bus_space_handle_t	ec_data_handle;
147
148    int			ec_csr_rid;
149    struct resource	*ec_csr_res;
150    bus_space_tag_t	ec_csr_tag;
151    bus_space_handle_t	ec_csr_handle;
152
153    int			ec_glk;
154    int			ec_glkhandle;
155    int			ec_burstactive;
156    int			ec_sci_pend;
157    u_int		ec_gencount;
158    int			ec_suspending;
159};
160
161/*
162 * XXX njl
163 * I couldn't find it in the spec but other implementations also use a
164 * value of 1 ms for the time to acquire global lock.
165 */
166#define EC_LOCK_TIMEOUT	1000
167
168/* Default delay in microseconds between each run of the status polling loop. */
169#define EC_POLL_DELAY	5
170
171/* Total time in ms spent waiting for a response from EC. */
172#define EC_TIMEOUT	750
173
174#define EVENT_READY(event, status)			\
175	(((event) == EC_EVENT_OUTPUT_BUFFER_FULL &&	\
176	 ((status) & EC_FLAG_OUTPUT_BUFFER) != 0) ||	\
177	 ((event) == EC_EVENT_INPUT_BUFFER_EMPTY && 	\
178	 ((status) & EC_FLAG_INPUT_BUFFER) == 0))
179
180ACPI_SERIAL_DECL(ec, "ACPI embedded controller");
181
182SYSCTL_DECL(_debug_acpi);
183SYSCTL_NODE(_debug_acpi, OID_AUTO, ec, CTLFLAG_RD, NULL, "EC debugging");
184
185static int	ec_burst_mode;
186TUNABLE_INT("debug.acpi.ec.burst", &ec_burst_mode);
187SYSCTL_INT(_debug_acpi_ec, OID_AUTO, burst, CTLFLAG_RW, &ec_burst_mode, 0,
188    "Enable use of burst mode (faster for nearly all systems)");
189static int	ec_polled_mode;
190TUNABLE_INT("debug.acpi.ec.polled", &ec_polled_mode);
191SYSCTL_INT(_debug_acpi_ec, OID_AUTO, polled, CTLFLAG_RW, &ec_polled_mode, 0,
192    "Force use of polled mode (only if interrupt mode doesn't work)");
193static int	ec_timeout = EC_TIMEOUT;
194TUNABLE_INT("debug.acpi.ec.timeout", &ec_timeout);
195SYSCTL_INT(_debug_acpi_ec, OID_AUTO, timeout, CTLFLAG_RW, &ec_timeout,
196    EC_TIMEOUT, "Total time spent waiting for a response (poll+sleep)");
197
198static ACPI_STATUS
199EcLock(struct acpi_ec_softc *sc)
200{
201    ACPI_STATUS	status;
202
203    /* If _GLK is non-zero, acquire the global lock. */
204    status = AE_OK;
205    if (sc->ec_glk) {
206	status = AcpiAcquireGlobalLock(EC_LOCK_TIMEOUT, &sc->ec_glkhandle);
207	if (ACPI_FAILURE(status))
208	    return (status);
209    }
210    ACPI_SERIAL_BEGIN(ec);
211    return (status);
212}
213
214static void
215EcUnlock(struct acpi_ec_softc *sc)
216{
217    ACPI_SERIAL_END(ec);
218    if (sc->ec_glk)
219	AcpiReleaseGlobalLock(sc->ec_glkhandle);
220}
221
222static uint32_t		EcGpeHandler(void *Context);
223static ACPI_STATUS	EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function,
224				void *Context, void **return_Context);
225static ACPI_STATUS	EcSpaceHandler(UINT32 Function,
226				ACPI_PHYSICAL_ADDRESS Address,
227				UINT32 width, ACPI_INTEGER *Value,
228				void *Context, void *RegionContext);
229static ACPI_STATUS	EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event,
230				u_int gen_count);
231static ACPI_STATUS	EcCommand(struct acpi_ec_softc *sc, EC_COMMAND cmd);
232static ACPI_STATUS	EcRead(struct acpi_ec_softc *sc, UINT8 Address,
233				UINT8 *Data);
234static ACPI_STATUS	EcWrite(struct acpi_ec_softc *sc, UINT8 Address,
235				UINT8 *Data);
236static int		acpi_ec_probe(device_t dev);
237static int		acpi_ec_attach(device_t dev);
238static int		acpi_ec_suspend(device_t dev);
239static int		acpi_ec_resume(device_t dev);
240static int		acpi_ec_shutdown(device_t dev);
241static int		acpi_ec_read_method(device_t dev, u_int addr,
242				ACPI_INTEGER *val, int width);
243static int		acpi_ec_write_method(device_t dev, u_int addr,
244				ACPI_INTEGER val, int width);
245
246static device_method_t acpi_ec_methods[] = {
247    /* Device interface */
248    DEVMETHOD(device_probe,	acpi_ec_probe),
249    DEVMETHOD(device_attach,	acpi_ec_attach),
250    DEVMETHOD(device_suspend,	acpi_ec_suspend),
251    DEVMETHOD(device_resume,	acpi_ec_resume),
252    DEVMETHOD(device_shutdown,	acpi_ec_shutdown),
253
254    /* Embedded controller interface */
255    DEVMETHOD(acpi_ec_read,	acpi_ec_read_method),
256    DEVMETHOD(acpi_ec_write,	acpi_ec_write_method),
257
258    {0, 0}
259};
260
261static driver_t acpi_ec_driver = {
262    "acpi_ec",
263    acpi_ec_methods,
264    sizeof(struct acpi_ec_softc),
265};
266
267static devclass_t acpi_ec_devclass;
268DRIVER_MODULE(acpi_ec, acpi, acpi_ec_driver, acpi_ec_devclass, 0, 0);
269MODULE_DEPEND(acpi_ec, acpi, 1, 1, 1);
270
271/*
272 * Look for an ECDT and if we find one, set up default GPE and
273 * space handlers to catch attempts to access EC space before
274 * we have a real driver instance in place.
275 *
276 * TODO: Some old Gateway laptops need us to fake up an ECDT or
277 * otherwise attach early so that _REG methods can run.
278 */
279void
280acpi_ec_ecdt_probe(device_t parent)
281{
282    ACPI_TABLE_ECDT *ecdt;
283    ACPI_STATUS	     status;
284    device_t	     child;
285    ACPI_HANDLE	     h;
286    struct acpi_ec_params *params;
287
288    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
289
290    /* Find and validate the ECDT. */
291    status = AcpiGetTable(ACPI_SIG_ECDT, 1, (ACPI_TABLE_HEADER **)&ecdt);
292    if (ACPI_FAILURE(status) ||
293	ecdt->Control.BitWidth != 8 ||
294	ecdt->Data.BitWidth != 8) {
295	return;
296    }
297
298    /* Create the child device with the given unit number. */
299    child = BUS_ADD_CHILD(parent, 0, "acpi_ec", ecdt->Uid);
300    if (child == NULL) {
301	printf("%s: can't add child\n", __func__);
302	return;
303    }
304
305    /* Find and save the ACPI handle for this device. */
306    status = AcpiGetHandle(NULL, ecdt->Id, &h);
307    if (ACPI_FAILURE(status)) {
308	device_delete_child(parent, child);
309	printf("%s: can't get handle\n", __func__);
310	return;
311    }
312    acpi_set_handle(child, h);
313
314    /* Set the data and CSR register addresses. */
315    bus_set_resource(child, SYS_RES_IOPORT, 0, ecdt->Data.Address,
316	/*count*/1);
317    bus_set_resource(child, SYS_RES_IOPORT, 1, ecdt->Control.Address,
318	/*count*/1);
319
320    /*
321     * Store values for the probe/attach routines to use.  Store the
322     * ECDT GPE bit and set the global lock flag according to _GLK.
323     * Note that it is not perfectly correct to be evaluating a method
324     * before initializing devices, but in practice this function
325     * should be safe to call at this point.
326     */
327    params = malloc(sizeof(struct acpi_ec_params), M_TEMP, M_WAITOK | M_ZERO);
328    params->gpe_handle = NULL;
329    params->gpe_bit = ecdt->Gpe;
330    params->uid = ecdt->Uid;
331    acpi_GetInteger(h, "_GLK", &params->glk);
332    acpi_set_private(child, params);
333    acpi_set_magic(child, (uintptr_t)&acpi_ec_devclass);
334
335    /* Finish the attach process. */
336    if (device_probe_and_attach(child) != 0)
337	device_delete_child(parent, child);
338}
339
340static int
341acpi_ec_probe(device_t dev)
342{
343    ACPI_BUFFER buf;
344    ACPI_HANDLE h;
345    ACPI_OBJECT *obj;
346    ACPI_STATUS status;
347    device_t	peer;
348    char	desc[64];
349    int		ret;
350    struct acpi_ec_params *params;
351    static char *ec_ids[] = { "PNP0C09", NULL };
352
353    /* Check that this is a device and that EC is not disabled. */
354    if (acpi_get_type(dev) != ACPI_TYPE_DEVICE || acpi_disabled("ec"))
355	return (ENXIO);
356
357    /*
358     * If probed via ECDT, set description and continue.  Otherwise,
359     * we can access the namespace and make sure this is not a
360     * duplicate probe.
361     */
362    ret = ENXIO;
363    params = NULL;
364    buf.Pointer = NULL;
365    buf.Length = ACPI_ALLOCATE_BUFFER;
366    if (DEV_ECDT(dev)) {
367	params = acpi_get_private(dev);
368	ret = 0;
369    } else if (!acpi_disabled("ec") &&
370	ACPI_ID_PROBE(device_get_parent(dev), dev, ec_ids)) {
371	params = malloc(sizeof(struct acpi_ec_params), M_TEMP,
372			M_WAITOK | M_ZERO);
373	h = acpi_get_handle(dev);
374
375	/*
376	 * Read the unit ID to check for duplicate attach and the
377	 * global lock value to see if we should acquire it when
378	 * accessing the EC.
379	 */
380	status = acpi_GetInteger(h, "_UID", &params->uid);
381	if (ACPI_FAILURE(status))
382	    params->uid = 0;
383	status = acpi_GetInteger(h, "_GLK", &params->glk);
384	if (ACPI_FAILURE(status))
385	    params->glk = 0;
386
387	/*
388	 * Evaluate the _GPE method to find the GPE bit used by the EC to
389	 * signal status (SCI).  If it's a package, it contains a reference
390	 * and GPE bit, similar to _PRW.
391	 */
392	status = AcpiEvaluateObject(h, "_GPE", NULL, &buf);
393	if (ACPI_FAILURE(status)) {
394	    device_printf(dev, "can't evaluate _GPE - %s\n",
395			  AcpiFormatException(status));
396	    goto out;
397	}
398	obj = (ACPI_OBJECT *)buf.Pointer;
399	if (obj == NULL)
400	    goto out;
401
402	switch (obj->Type) {
403	case ACPI_TYPE_INTEGER:
404	    params->gpe_handle = NULL;
405	    params->gpe_bit = obj->Integer.Value;
406	    break;
407	case ACPI_TYPE_PACKAGE:
408	    if (!ACPI_PKG_VALID(obj, 2))
409		goto out;
410	    params->gpe_handle =
411		acpi_GetReference(NULL, &obj->Package.Elements[0]);
412	    if (params->gpe_handle == NULL ||
413		acpi_PkgInt32(obj, 1, &params->gpe_bit) != 0)
414		goto out;
415	    break;
416	default:
417	    device_printf(dev, "_GPE has invalid type %d\n", obj->Type);
418	    goto out;
419	}
420
421	/* Store the values we got from the namespace for attach. */
422	acpi_set_private(dev, params);
423
424	/*
425	 * Check for a duplicate probe.  This can happen when a probe
426	 * via ECDT succeeded already.  If this is a duplicate, disable
427	 * this device.
428	 */
429	peer = devclass_get_device(acpi_ec_devclass, params->uid);
430	if (peer == NULL || !device_is_alive(peer))
431	    ret = 0;
432	else
433	    device_disable(dev);
434    }
435
436out:
437    if (ret == 0) {
438	snprintf(desc, sizeof(desc), "Embedded Controller: GPE %#x%s%s",
439		 params->gpe_bit, (params->glk) ? ", GLK" : "",
440		 DEV_ECDT(dev) ? ", ECDT" : "");
441	device_set_desc_copy(dev, desc);
442    }
443
444    if (ret > 0 && params)
445	free(params, M_TEMP);
446    if (buf.Pointer)
447	AcpiOsFree(buf.Pointer);
448    return (ret);
449}
450
451static int
452acpi_ec_attach(device_t dev)
453{
454    struct acpi_ec_softc	*sc;
455    struct acpi_ec_params	*params;
456    ACPI_STATUS			Status;
457
458    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
459
460    /* Fetch/initialize softc (assumes softc is pre-zeroed). */
461    sc = device_get_softc(dev);
462    params = acpi_get_private(dev);
463    sc->ec_dev = dev;
464    sc->ec_handle = acpi_get_handle(dev);
465
466    /* Retrieve previously probed values via device ivars. */
467    sc->ec_glk = params->glk;
468    sc->ec_gpebit = params->gpe_bit;
469    sc->ec_gpehandle = params->gpe_handle;
470    sc->ec_uid = params->uid;
471    sc->ec_suspending = FALSE;
472    free(params, M_TEMP);
473
474    /* Attach bus resources for data and command/status ports. */
475    sc->ec_data_rid = 0;
476    sc->ec_data_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
477			&sc->ec_data_rid, RF_ACTIVE);
478    if (sc->ec_data_res == NULL) {
479	device_printf(dev, "can't allocate data port\n");
480	goto error;
481    }
482    sc->ec_data_tag = rman_get_bustag(sc->ec_data_res);
483    sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res);
484
485    sc->ec_csr_rid = 1;
486    sc->ec_csr_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
487			&sc->ec_csr_rid, RF_ACTIVE);
488    if (sc->ec_csr_res == NULL) {
489	device_printf(dev, "can't allocate command/status port\n");
490	goto error;
491    }
492    sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res);
493    sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res);
494
495    /*
496     * Install a handler for this EC's GPE bit.  We want edge-triggered
497     * behavior.
498     */
499    ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE handler\n"));
500    Status = AcpiInstallGpeHandler(sc->ec_gpehandle, sc->ec_gpebit,
501		ACPI_GPE_EDGE_TRIGGERED, &EcGpeHandler, sc);
502    if (ACPI_FAILURE(Status)) {
503	device_printf(dev, "can't install GPE handler for %s - %s\n",
504		      acpi_name(sc->ec_handle), AcpiFormatException(Status));
505	goto error;
506    }
507
508    /*
509     * Install address space handler
510     */
511    ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n"));
512    Status = AcpiInstallAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
513		&EcSpaceHandler, &EcSpaceSetup, sc);
514    if (ACPI_FAILURE(Status)) {
515	device_printf(dev, "can't install address space handler for %s - %s\n",
516		      acpi_name(sc->ec_handle), AcpiFormatException(Status));
517	goto error;
518    }
519
520    /* Enable runtime GPEs for the handler. */
521    Status = AcpiSetGpeType(sc->ec_gpehandle, sc->ec_gpebit,
522			    ACPI_GPE_TYPE_RUNTIME);
523    if (ACPI_FAILURE(Status)) {
524	device_printf(dev, "AcpiSetGpeType failed: %s\n",
525		      AcpiFormatException(Status));
526	goto error;
527    }
528    Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_NOT_ISR);
529    if (ACPI_FAILURE(Status)) {
530	device_printf(dev, "AcpiEnableGpe failed: %s\n",
531		      AcpiFormatException(Status));
532	goto error;
533    }
534
535    ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "acpi_ec_attach complete\n"));
536    return (0);
537
538error:
539    AcpiRemoveGpeHandler(sc->ec_gpehandle, sc->ec_gpebit, &EcGpeHandler);
540    AcpiRemoveAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
541	EcSpaceHandler);
542    if (sc->ec_csr_res)
543	bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_csr_rid,
544			     sc->ec_csr_res);
545    if (sc->ec_data_res)
546	bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_data_rid,
547			     sc->ec_data_res);
548    return (ENXIO);
549}
550
551static int
552acpi_ec_suspend(device_t dev)
553{
554    struct acpi_ec_softc	*sc;
555
556    sc = device_get_softc(dev);
557    sc->ec_suspending = TRUE;
558    return (0);
559}
560
561static int
562acpi_ec_resume(device_t dev)
563{
564    struct acpi_ec_softc	*sc;
565
566    sc = device_get_softc(dev);
567    sc->ec_suspending = FALSE;
568    return (0);
569}
570
571static int
572acpi_ec_shutdown(device_t dev)
573{
574    struct acpi_ec_softc	*sc;
575
576    /* Disable the GPE so we don't get EC events during shutdown. */
577    sc = device_get_softc(dev);
578    AcpiDisableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_NOT_ISR);
579    return (0);
580}
581
582/* Methods to allow other devices (e.g., smbat) to read/write EC space. */
583static int
584acpi_ec_read_method(device_t dev, u_int addr, ACPI_INTEGER *val, int width)
585{
586    struct acpi_ec_softc *sc;
587    ACPI_STATUS status;
588
589    sc = device_get_softc(dev);
590    status = EcSpaceHandler(ACPI_READ, addr, width * 8, val, sc, NULL);
591    if (ACPI_FAILURE(status))
592	return (ENXIO);
593    return (0);
594}
595
596static int
597acpi_ec_write_method(device_t dev, u_int addr, ACPI_INTEGER val, int width)
598{
599    struct acpi_ec_softc *sc;
600    ACPI_STATUS status;
601
602    sc = device_get_softc(dev);
603    status = EcSpaceHandler(ACPI_WRITE, addr, width * 8, &val, sc, NULL);
604    if (ACPI_FAILURE(status))
605	return (ENXIO);
606    return (0);
607}
608
609static void
610EcGpeQueryHandler(void *Context)
611{
612    struct acpi_ec_softc	*sc = (struct acpi_ec_softc *)Context;
613    UINT8			Data;
614    ACPI_STATUS			Status;
615    char			qxx[5];
616
617    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
618    KASSERT(Context != NULL, ("EcGpeQueryHandler called with NULL"));
619
620    /* Serialize user access with EcSpaceHandler(). */
621    Status = EcLock(sc);
622    if (ACPI_FAILURE(Status)) {
623	device_printf(sc->ec_dev, "GpeQuery lock error: %s\n",
624	    AcpiFormatException(Status));
625	return;
626    }
627
628    /*
629     * Send a query command to the EC to find out which _Qxx call it
630     * wants to make.  This command clears the SCI bit and also the
631     * interrupt source since we are edge-triggered.  To prevent the GPE
632     * that may arise from running the query from causing another query
633     * to be queued, we clear the pending flag only after running it.
634     */
635    Status = EcCommand(sc, EC_COMMAND_QUERY);
636    sc->ec_sci_pend = FALSE;
637    if (ACPI_FAILURE(Status)) {
638	EcUnlock(sc);
639	device_printf(sc->ec_dev, "GPE query failed: %s\n",
640	    AcpiFormatException(Status));
641	return;
642    }
643    Data = EC_GET_DATA(sc);
644
645    /*
646     * We have to unlock before running the _Qxx method below since that
647     * method may attempt to read/write from EC address space, causing
648     * recursive acquisition of the lock.
649     */
650    EcUnlock(sc);
651
652    /* Ignore the value for "no outstanding event". (13.3.5) */
653    CTR2(KTR_ACPI, "ec query ok,%s running _Q%02X", Data ? "" : " not", Data);
654    if (Data == 0)
655	return;
656
657    /* Evaluate _Qxx to respond to the controller. */
658    snprintf(qxx, sizeof(qxx), "_Q%02X", Data);
659    AcpiUtStrupr(qxx);
660    Status = AcpiEvaluateObject(sc->ec_handle, qxx, NULL, NULL);
661    if (ACPI_FAILURE(Status) && Status != AE_NOT_FOUND) {
662	device_printf(sc->ec_dev, "evaluation of query method %s failed: %s\n",
663	    qxx, AcpiFormatException(Status));
664    }
665}
666
667/*
668 * The GPE handler is called when IBE/OBF or SCI events occur.  We are
669 * called from an unknown lock context.
670 */
671static uint32_t
672EcGpeHandler(void *Context)
673{
674    struct acpi_ec_softc *sc = Context;
675    ACPI_STATUS		       Status;
676    EC_STATUS		       EcStatus;
677
678    KASSERT(Context != NULL, ("EcGpeHandler called with NULL"));
679    CTR0(KTR_ACPI, "ec gpe handler start");
680
681    /*
682     * Notify EcWaitEvent() that the status register is now fresh.  If we
683     * didn't do this, it wouldn't be possible to distinguish an old IBE
684     * from a new one, for example when doing a write transaction (writing
685     * address and then data values.)
686     */
687    atomic_add_int(&sc->ec_gencount, 1);
688    wakeup(&sc->ec_gencount);
689
690    /*
691     * If the EC_SCI bit of the status register is set, queue a query handler.
692     * It will run the query and _Qxx method later, under the lock.
693     */
694    EcStatus = EC_GET_CSR(sc);
695    if ((EcStatus & EC_EVENT_SCI) && !sc->ec_sci_pend) {
696	CTR0(KTR_ACPI, "ec gpe queueing query handler");
697	Status = AcpiOsExecute(OSL_GPE_HANDLER, EcGpeQueryHandler, Context);
698	if (ACPI_SUCCESS(Status))
699	    sc->ec_sci_pend = TRUE;
700	else
701	    printf("EcGpeHandler: queuing GPE query handler failed\n");
702    }
703    return (0);
704}
705
706static ACPI_STATUS
707EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context,
708	     void **RegionContext)
709{
710
711    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
712
713    /*
714     * If deactivating a region, always set the output to NULL.  Otherwise,
715     * just pass the context through.
716     */
717    if (Function == ACPI_REGION_DEACTIVATE)
718	*RegionContext = NULL;
719    else
720	*RegionContext = Context;
721
722    return_ACPI_STATUS (AE_OK);
723}
724
725static ACPI_STATUS
726EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width,
727	       ACPI_INTEGER *Value, void *Context, void *RegionContext)
728{
729    struct acpi_ec_softc	*sc = (struct acpi_ec_softc *)Context;
730    ACPI_STATUS			Status;
731    UINT8			EcAddr, EcData;
732    int				i;
733
734    ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Address);
735
736    if (width % 8 != 0 || Value == NULL || Context == NULL)
737	return_ACPI_STATUS (AE_BAD_PARAMETER);
738    if (Address + (width / 8) - 1 > 0xFF)
739	return_ACPI_STATUS (AE_BAD_ADDRESS);
740
741    if (Function == ACPI_READ)
742	*Value = 0;
743    EcAddr = Address;
744    Status = AE_ERROR;
745
746    /*
747     * If booting, check if we need to run the query handler.  If so, we
748     * we call it directly here since our thread taskq is not active yet.
749     */
750    if (cold || rebooting || sc->ec_suspending) {
751	if ((EC_GET_CSR(sc) & EC_EVENT_SCI)) {
752	    CTR0(KTR_ACPI, "ec running gpe handler directly");
753	    EcGpeQueryHandler(sc);
754	}
755    }
756
757    /* Serialize with EcGpeQueryHandler() at transaction granularity. */
758    Status = EcLock(sc);
759    if (ACPI_FAILURE(Status))
760	return_ACPI_STATUS (Status);
761
762    /* Perform the transaction(s), based on width. */
763    for (i = 0; i < width; i += 8, EcAddr++) {
764	switch (Function) {
765	case ACPI_READ:
766	    Status = EcRead(sc, EcAddr, &EcData);
767	    if (ACPI_SUCCESS(Status))
768		*Value |= ((ACPI_INTEGER)EcData) << i;
769	    break;
770	case ACPI_WRITE:
771	    EcData = (UINT8)((*Value) >> i);
772	    Status = EcWrite(sc, EcAddr, &EcData);
773	    break;
774	default:
775	    device_printf(sc->ec_dev, "invalid EcSpaceHandler function %d\n",
776			  Function);
777	    Status = AE_BAD_PARAMETER;
778	    break;
779	}
780	if (ACPI_FAILURE(Status))
781	    break;
782    }
783
784    EcUnlock(sc);
785    return_ACPI_STATUS (Status);
786}
787
788static ACPI_STATUS
789EcCheckStatus(struct acpi_ec_softc *sc, const char *msg, EC_EVENT event)
790{
791    ACPI_STATUS status;
792    EC_STATUS ec_status;
793
794    status = AE_NO_HARDWARE_RESPONSE;
795    ec_status = EC_GET_CSR(sc);
796    if (sc->ec_burstactive && !(ec_status & EC_FLAG_BURST_MODE)) {
797	CTR1(KTR_ACPI, "ec burst disabled in waitevent (%s)", msg);
798	sc->ec_burstactive = FALSE;
799    }
800    if (EVENT_READY(event, ec_status)) {
801	CTR2(KTR_ACPI, "ec %s wait ready, status %#x", msg, ec_status);
802	status = AE_OK;
803    }
804    return (status);
805}
806
807static ACPI_STATUS
808EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event, u_int gen_count)
809{
810    ACPI_STATUS	Status;
811    int		count, i, slp_ival;
812
813    ACPI_SERIAL_ASSERT(ec);
814    Status = AE_NO_HARDWARE_RESPONSE;
815    int need_poll = cold || rebooting || ec_polled_mode || sc->ec_suspending;
816    /*
817     * The main CPU should be much faster than the EC.  So the status should
818     * be "not ready" when we start waiting.  But if the main CPU is really
819     * slow, it's possible we see the current "ready" response.  Since that
820     * can't be distinguished from the previous response in polled mode,
821     * this is a potential issue.  We really should have interrupts enabled
822     * during boot so there is no ambiguity in polled mode.
823     *
824     * If this occurs, we add an additional delay before actually entering
825     * the status checking loop, hopefully to allow the EC to go to work
826     * and produce a non-stale status.
827     */
828    if (need_poll) {
829	static int	once;
830
831	if (EcCheckStatus(sc, "pre-check", Event) == AE_OK) {
832	    if (!once) {
833		device_printf(sc->ec_dev,
834		    "warning: EC done before starting event wait\n");
835		once = 1;
836	    }
837	    AcpiOsStall(10);
838	}
839    }
840
841    /* Wait for event by polling or GPE (interrupt). */
842    if (need_poll) {
843	count = (ec_timeout * 1000) / EC_POLL_DELAY;
844	if (count == 0)
845	    count = 1;
846	for (i = 0; i < count; i++) {
847	    Status = EcCheckStatus(sc, "poll", Event);
848	    if (Status == AE_OK)
849		break;
850	    AcpiOsStall(EC_POLL_DELAY);
851	}
852    } else {
853	slp_ival = hz / 1000;
854	if (slp_ival != 0) {
855	    count = ec_timeout;
856	} else {
857	    /* hz has less than 1 ms resolution so scale timeout. */
858	    slp_ival = 1;
859	    count = ec_timeout / (1000 / hz);
860	}
861
862	/*
863	 * Wait for the GPE to signal the status changed, checking the
864	 * status register each time we get one.  It's possible to get a
865	 * GPE for an event we're not interested in here (i.e., SCI for
866	 * EC query).
867	 */
868	for (i = 0; i < count; i++) {
869	    if (gen_count != sc->ec_gencount) {
870		/*
871		 * Record new generation count.  It's possible the GPE was
872		 * just to notify us that a query is needed and we need to
873		 * wait for a second GPE to signal the completion of the
874		 * event we are actually waiting for.
875		 */
876		gen_count = sc->ec_gencount;
877		Status = EcCheckStatus(sc, "sleep", Event);
878		if (Status == AE_OK)
879		    break;
880	    }
881	    tsleep(&sc->ec_gencount, PZERO, "ecgpe", slp_ival);
882	}
883
884	/*
885	 * We finished waiting for the GPE and it never arrived.  Try to
886	 * read the register once and trust whatever value we got.  This is
887	 * the best we can do at this point.  Then, force polled mode on
888	 * since this system doesn't appear to generate GPEs.
889	 */
890	if (Status != AE_OK) {
891	    Status = EcCheckStatus(sc, "sleep_end", Event);
892	    device_printf(sc->ec_dev,
893		"wait timed out (%sresponse), forcing polled mode\n",
894		Status == AE_OK ? "" : "no ");
895	    ec_polled_mode = TRUE;
896	}
897    }
898    if (Status != AE_OK)
899	    CTR0(KTR_ACPI, "error: ec wait timed out");
900    return (Status);
901}
902
903static ACPI_STATUS
904EcCommand(struct acpi_ec_softc *sc, EC_COMMAND cmd)
905{
906    ACPI_STATUS	status;
907    EC_EVENT	event;
908    EC_STATUS	ec_status;
909    u_int	gen_count;
910
911    ACPI_SERIAL_ASSERT(ec);
912
913    /* Don't use burst mode if user disabled it. */
914    if (!ec_burst_mode && cmd == EC_COMMAND_BURST_ENABLE)
915	return (AE_ERROR);
916
917    /* Decide what to wait for based on command type. */
918    switch (cmd) {
919    case EC_COMMAND_READ:
920    case EC_COMMAND_WRITE:
921    case EC_COMMAND_BURST_DISABLE:
922	event = EC_EVENT_INPUT_BUFFER_EMPTY;
923	break;
924    case EC_COMMAND_QUERY:
925    case EC_COMMAND_BURST_ENABLE:
926	event = EC_EVENT_OUTPUT_BUFFER_FULL;
927	break;
928    default:
929	device_printf(sc->ec_dev, "EcCommand: invalid command %#x\n", cmd);
930	return (AE_BAD_PARAMETER);
931    }
932
933    /* Run the command and wait for the chosen event. */
934    CTR1(KTR_ACPI, "ec running command %#x", cmd);
935    gen_count = sc->ec_gencount;
936    EC_SET_CSR(sc, cmd);
937    status = EcWaitEvent(sc, event, gen_count);
938    if (ACPI_SUCCESS(status)) {
939	/* If we succeeded, burst flag should now be present. */
940	if (cmd == EC_COMMAND_BURST_ENABLE) {
941	    ec_status = EC_GET_CSR(sc);
942	    if ((ec_status & EC_FLAG_BURST_MODE) == 0)
943		status = AE_ERROR;
944	}
945    } else
946	device_printf(sc->ec_dev, "EcCommand: no response to %#x\n", cmd);
947    return (status);
948}
949
950static ACPI_STATUS
951EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
952{
953    ACPI_STATUS	status;
954    UINT8 data;
955    u_int gen_count;
956
957    ACPI_SERIAL_ASSERT(ec);
958    CTR1(KTR_ACPI, "ec read from %#x", Address);
959
960    /* If we can't start burst mode, continue anyway. */
961    status = EcCommand(sc, EC_COMMAND_BURST_ENABLE);
962    if (status == AE_OK) {
963    	data = EC_GET_DATA(sc);
964	if (data == EC_BURST_ACK) {
965	    CTR0(KTR_ACPI, "ec burst enabled");
966	    sc->ec_burstactive = TRUE;
967	}
968    }
969
970    status = EcCommand(sc, EC_COMMAND_READ);
971    if (ACPI_FAILURE(status))
972	return (status);
973
974    gen_count = sc->ec_gencount;
975    EC_SET_DATA(sc, Address);
976    status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL, gen_count);
977    if (ACPI_FAILURE(status)) {
978	device_printf(sc->ec_dev, "EcRead: failed waiting to get data\n");
979	return (status);
980    }
981    *Data = EC_GET_DATA(sc);
982
983    if (sc->ec_burstactive) {
984	sc->ec_burstactive = FALSE;
985	status = EcCommand(sc, EC_COMMAND_BURST_DISABLE);
986	if (ACPI_FAILURE(status))
987	    return (status);
988	CTR0(KTR_ACPI, "ec disabled burst ok");
989    }
990
991    return (AE_OK);
992}
993
994static ACPI_STATUS
995EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
996{
997    ACPI_STATUS	status;
998    UINT8 data;
999    u_int gen_count;
1000
1001    ACPI_SERIAL_ASSERT(ec);
1002    CTR2(KTR_ACPI, "ec write to %#x, data %#x", Address, *Data);
1003
1004    /* If we can't start burst mode, continue anyway. */
1005    status = EcCommand(sc, EC_COMMAND_BURST_ENABLE);
1006    if (status == AE_OK) {
1007    	data = EC_GET_DATA(sc);
1008	if (data == EC_BURST_ACK) {
1009	    CTR0(KTR_ACPI, "ec burst enabled");
1010	    sc->ec_burstactive = TRUE;
1011	}
1012    }
1013
1014    status = EcCommand(sc, EC_COMMAND_WRITE);
1015    if (ACPI_FAILURE(status))
1016	return (status);
1017
1018    gen_count = sc->ec_gencount;
1019    EC_SET_DATA(sc, Address);
1020    status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY, gen_count);
1021    if (ACPI_FAILURE(status)) {
1022	device_printf(sc->ec_dev, "EcRead: failed waiting for sent address\n");
1023	return (status);
1024    }
1025
1026    gen_count = sc->ec_gencount;
1027    EC_SET_DATA(sc, *Data);
1028    status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY, gen_count);
1029    if (ACPI_FAILURE(status)) {
1030	device_printf(sc->ec_dev, "EcWrite: failed waiting for sent data\n");
1031	return (status);
1032    }
1033
1034    if (sc->ec_burstactive) {
1035	sc->ec_burstactive = FALSE;
1036	status = EcCommand(sc, EC_COMMAND_BURST_DISABLE);
1037	if (ACPI_FAILURE(status))
1038	    return (status);
1039	CTR0(KTR_ACPI, "ec disabled burst ok");
1040    }
1041
1042    return (AE_OK);
1043}
1044