15db2f26eSSascha Wildner /*-
25db2f26eSSascha Wildner * Copyright (c) 2003-2007 Nate Lawson
35db2f26eSSascha Wildner * Copyright (c) 2000 Michael Smith
45db2f26eSSascha Wildner * Copyright (c) 2000 BSDi
55db2f26eSSascha Wildner * All rights reserved.
65db2f26eSSascha Wildner *
75db2f26eSSascha Wildner * Redistribution and use in source and binary forms, with or without
85db2f26eSSascha Wildner * modification, are permitted provided that the following conditions
95db2f26eSSascha Wildner * are met:
105db2f26eSSascha Wildner * 1. Redistributions of source code must retain the above copyright
115db2f26eSSascha Wildner * notice, this list of conditions and the following disclaimer.
125db2f26eSSascha Wildner * 2. Redistributions in binary form must reproduce the above copyright
135db2f26eSSascha Wildner * notice, this list of conditions and the following disclaimer in the
145db2f26eSSascha Wildner * documentation and/or other materials provided with the distribution.
155db2f26eSSascha Wildner *
165db2f26eSSascha Wildner * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
175db2f26eSSascha Wildner * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
185db2f26eSSascha Wildner * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
195db2f26eSSascha Wildner * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
205db2f26eSSascha Wildner * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
215db2f26eSSascha Wildner * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
225db2f26eSSascha Wildner * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
235db2f26eSSascha Wildner * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
245db2f26eSSascha Wildner * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
255db2f26eSSascha Wildner * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
265db2f26eSSascha Wildner * SUCH DAMAGE.
275db2f26eSSascha Wildner *
286836e2b4SSascha Wildner * $FreeBSD: head/sys/dev/acpica/acpi_ec.c 246128 2013-01-30 18:01:20Z sbz $
295db2f26eSSascha Wildner */
305db2f26eSSascha Wildner
315db2f26eSSascha Wildner #include "opt_acpi.h"
325db2f26eSSascha Wildner #include <sys/param.h>
335db2f26eSSascha Wildner #include <sys/kernel.h>
345db2f26eSSascha Wildner #include <sys/bus.h>
355db2f26eSSascha Wildner #include <sys/lock.h>
365db2f26eSSascha Wildner #include <sys/malloc.h>
375db2f26eSSascha Wildner #include <sys/module.h>
385db2f26eSSascha Wildner #include <sys/rman.h>
398a3a1024SSascha Wildner #include <sys/ktr.h>
405db2f26eSSascha Wildner
415db2f26eSSascha Wildner #include "acpi.h"
426836e2b4SSascha Wildner #include "accommon.h"
436836e2b4SSascha Wildner
445db2f26eSSascha Wildner #include <dev/acpica/acpivar.h>
455db2f26eSSascha Wildner
465db2f26eSSascha Wildner /* Hooks for the ACPICA debugging infrastructure */
475db2f26eSSascha Wildner #define _COMPONENT ACPI_EC
485db2f26eSSascha Wildner ACPI_MODULE_NAME("EC")
495db2f26eSSascha Wildner
505db2f26eSSascha Wildner #define rebooting 0
516836e2b4SSascha Wildner
525db2f26eSSascha Wildner /*
535db2f26eSSascha Wildner * EC_COMMAND:
545db2f26eSSascha Wildner * -----------
555db2f26eSSascha Wildner */
565db2f26eSSascha Wildner typedef UINT8 EC_COMMAND;
575db2f26eSSascha Wildner
585db2f26eSSascha Wildner #define EC_COMMAND_UNKNOWN ((EC_COMMAND) 0x00)
595db2f26eSSascha Wildner #define EC_COMMAND_READ ((EC_COMMAND) 0x80)
605db2f26eSSascha Wildner #define EC_COMMAND_WRITE ((EC_COMMAND) 0x81)
615db2f26eSSascha Wildner #define EC_COMMAND_BURST_ENABLE ((EC_COMMAND) 0x82)
625db2f26eSSascha Wildner #define EC_COMMAND_BURST_DISABLE ((EC_COMMAND) 0x83)
635db2f26eSSascha Wildner #define EC_COMMAND_QUERY ((EC_COMMAND) 0x84)
645db2f26eSSascha Wildner
655db2f26eSSascha Wildner /*
665db2f26eSSascha Wildner * EC_STATUS:
675db2f26eSSascha Wildner * ----------
685db2f26eSSascha Wildner * The encoding of the EC status register is illustrated below.
695db2f26eSSascha Wildner * Note that a set bit (1) indicates the property is TRUE
705db2f26eSSascha Wildner * (e.g. if bit 0 is set then the output buffer is full).
715db2f26eSSascha Wildner * +-+-+-+-+-+-+-+-+
725db2f26eSSascha Wildner * |7|6|5|4|3|2|1|0|
735db2f26eSSascha Wildner * +-+-+-+-+-+-+-+-+
745db2f26eSSascha Wildner * | | | | | | | |
755db2f26eSSascha Wildner * | | | | | | | +- Output Buffer Full?
765db2f26eSSascha Wildner * | | | | | | +--- Input Buffer Full?
775db2f26eSSascha Wildner * | | | | | +----- <reserved>
785db2f26eSSascha Wildner * | | | | +------- Data Register is Command Byte?
795db2f26eSSascha Wildner * | | | +--------- Burst Mode Enabled?
805db2f26eSSascha Wildner * | | +----------- SCI Event?
815db2f26eSSascha Wildner * | +------------- SMI Event?
825db2f26eSSascha Wildner * +--------------- <reserved>
835db2f26eSSascha Wildner *
845db2f26eSSascha Wildner */
855db2f26eSSascha Wildner typedef UINT8 EC_STATUS;
865db2f26eSSascha Wildner
875db2f26eSSascha Wildner #define EC_FLAG_OUTPUT_BUFFER ((EC_STATUS) 0x01)
885db2f26eSSascha Wildner #define EC_FLAG_INPUT_BUFFER ((EC_STATUS) 0x02)
895db2f26eSSascha Wildner #define EC_FLAG_DATA_IS_CMD ((EC_STATUS) 0x08)
905db2f26eSSascha Wildner #define EC_FLAG_BURST_MODE ((EC_STATUS) 0x10)
915db2f26eSSascha Wildner
925db2f26eSSascha Wildner /*
935db2f26eSSascha Wildner * EC_EVENT:
945db2f26eSSascha Wildner * ---------
955db2f26eSSascha Wildner */
965db2f26eSSascha Wildner typedef UINT8 EC_EVENT;
975db2f26eSSascha Wildner
985db2f26eSSascha Wildner #define EC_EVENT_UNKNOWN ((EC_EVENT) 0x00)
995db2f26eSSascha Wildner #define EC_EVENT_OUTPUT_BUFFER_FULL ((EC_EVENT) 0x01)
1005db2f26eSSascha Wildner #define EC_EVENT_INPUT_BUFFER_EMPTY ((EC_EVENT) 0x02)
1015db2f26eSSascha Wildner #define EC_EVENT_SCI ((EC_EVENT) 0x20)
1025db2f26eSSascha Wildner #define EC_EVENT_SMI ((EC_EVENT) 0x40)
1035db2f26eSSascha Wildner
1045db2f26eSSascha Wildner /* Data byte returned after burst enable indicating it was successful. */
1055db2f26eSSascha Wildner #define EC_BURST_ACK 0x90
1065db2f26eSSascha Wildner
1075db2f26eSSascha Wildner /*
1085db2f26eSSascha Wildner * Register access primitives
1095db2f26eSSascha Wildner */
1105db2f26eSSascha Wildner #define EC_GET_DATA(sc) \
1115db2f26eSSascha Wildner bus_space_read_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0)
1125db2f26eSSascha Wildner
1135db2f26eSSascha Wildner #define EC_SET_DATA(sc, v) \
1145db2f26eSSascha Wildner bus_space_write_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0, (v))
1155db2f26eSSascha Wildner
1165db2f26eSSascha Wildner #define EC_GET_CSR(sc) \
1175db2f26eSSascha Wildner bus_space_read_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0)
1185db2f26eSSascha Wildner
1195db2f26eSSascha Wildner #define EC_SET_CSR(sc, v) \
1205db2f26eSSascha Wildner bus_space_write_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0, (v))
1215db2f26eSSascha Wildner
1225db2f26eSSascha Wildner /* Additional params to pass from the probe routine */
1235db2f26eSSascha Wildner struct acpi_ec_params {
1245db2f26eSSascha Wildner int glk;
1255db2f26eSSascha Wildner int gpe_bit;
1265db2f26eSSascha Wildner ACPI_HANDLE gpe_handle;
1275db2f26eSSascha Wildner int uid;
1285db2f26eSSascha Wildner };
1295db2f26eSSascha Wildner
1305db2f26eSSascha Wildner /*
1315db2f26eSSascha Wildner * Driver softc.
1325db2f26eSSascha Wildner */
1335db2f26eSSascha Wildner struct acpi_ec_softc {
1345db2f26eSSascha Wildner device_t ec_dev;
1355db2f26eSSascha Wildner ACPI_HANDLE ec_handle;
1365db2f26eSSascha Wildner int ec_uid;
1375db2f26eSSascha Wildner ACPI_HANDLE ec_gpehandle;
1385db2f26eSSascha Wildner UINT8 ec_gpebit;
1395db2f26eSSascha Wildner
1405db2f26eSSascha Wildner int ec_data_rid;
1415db2f26eSSascha Wildner struct resource *ec_data_res;
1425db2f26eSSascha Wildner bus_space_tag_t ec_data_tag;
1435db2f26eSSascha Wildner bus_space_handle_t ec_data_handle;
1445db2f26eSSascha Wildner
1455db2f26eSSascha Wildner int ec_csr_rid;
1465db2f26eSSascha Wildner struct resource *ec_csr_res;
1475db2f26eSSascha Wildner bus_space_tag_t ec_csr_tag;
1485db2f26eSSascha Wildner bus_space_handle_t ec_csr_handle;
1495db2f26eSSascha Wildner
1505db2f26eSSascha Wildner int ec_glk;
1515db2f26eSSascha Wildner int ec_glkhandle;
1525db2f26eSSascha Wildner int ec_burstactive;
1535db2f26eSSascha Wildner int ec_sci_pend;
1545db2f26eSSascha Wildner volatile u_int ec_gencount;
1555db2f26eSSascha Wildner int ec_suspending;
1565db2f26eSSascha Wildner };
1575db2f26eSSascha Wildner
1585db2f26eSSascha Wildner /*
1595db2f26eSSascha Wildner * XXX njl
1605db2f26eSSascha Wildner * I couldn't find it in the spec but other implementations also use a
1615db2f26eSSascha Wildner * value of 1 ms for the time to acquire global lock.
1625db2f26eSSascha Wildner */
1635db2f26eSSascha Wildner #define EC_LOCK_TIMEOUT 1000
1645db2f26eSSascha Wildner
1655db2f26eSSascha Wildner /* Default delay in microseconds between each run of the status polling loop. */
1665db2f26eSSascha Wildner #define EC_POLL_DELAY 50
1675db2f26eSSascha Wildner
1685db2f26eSSascha Wildner /* Total time in ms spent waiting for a response from EC. */
1695db2f26eSSascha Wildner #define EC_TIMEOUT 750
170f872b7caSMatthew Dillon #define EC_TIMEOUT_BACKOFF 100
1715db2f26eSSascha Wildner
1725db2f26eSSascha Wildner #define EVENT_READY(event, status) \
1735db2f26eSSascha Wildner (((event) == EC_EVENT_OUTPUT_BUFFER_FULL && \
1745db2f26eSSascha Wildner ((status) & EC_FLAG_OUTPUT_BUFFER) != 0) || \
1755db2f26eSSascha Wildner ((event) == EC_EVENT_INPUT_BUFFER_EMPTY && \
1765db2f26eSSascha Wildner ((status) & EC_FLAG_INPUT_BUFFER) == 0))
1775db2f26eSSascha Wildner
1785db2f26eSSascha Wildner ACPI_SERIAL_DECL(ec, "ACPI embedded controller");
1795db2f26eSSascha Wildner
180f872b7caSMatthew Dillon extern int acpi_silence_all;
181f872b7caSMatthew Dillon
1826836e2b4SSascha Wildner static SYSCTL_NODE(_debug_acpi, OID_AUTO, ec, CTLFLAG_RD, NULL, "EC debugging");
1835db2f26eSSascha Wildner
1845db2f26eSSascha Wildner static int ec_burst_mode;
1855db2f26eSSascha Wildner TUNABLE_INT("debug.acpi.ec.burst", &ec_burst_mode);
1865db2f26eSSascha Wildner SYSCTL_INT(_debug_acpi_ec, OID_AUTO, burst, CTLFLAG_RW, &ec_burst_mode, 0,
1875db2f26eSSascha Wildner "Enable use of burst mode (faster for nearly all systems)");
1885db2f26eSSascha Wildner static int ec_polled_mode;
1895db2f26eSSascha Wildner TUNABLE_INT("debug.acpi.ec.polled", &ec_polled_mode);
1905db2f26eSSascha Wildner SYSCTL_INT(_debug_acpi_ec, OID_AUTO, polled, CTLFLAG_RW, &ec_polled_mode, 0,
1915db2f26eSSascha Wildner "Force use of polled mode (only if interrupt mode doesn't work)");
1925db2f26eSSascha Wildner static int ec_timeout = EC_TIMEOUT;
1935db2f26eSSascha Wildner TUNABLE_INT("debug.acpi.ec.timeout", &ec_timeout);
1945db2f26eSSascha Wildner SYSCTL_INT(_debug_acpi_ec, OID_AUTO, timeout, CTLFLAG_RW, &ec_timeout,
1955db2f26eSSascha Wildner EC_TIMEOUT, "Total time spent waiting for a response (poll+sleep)");
196f872b7caSMatthew Dillon static int ec_timeout_backoff = EC_TIMEOUT_BACKOFF;
1979337a6eaSSascha Wildner TUNABLE_INT("debug.acpi.ec.timeout_backoff", &ec_timeout_backoff);
198f872b7caSMatthew Dillon SYSCTL_INT(_debug_acpi_ec, OID_AUTO, timeout_backoff, CTLFLAG_RW,
199f872b7caSMatthew Dillon &ec_timeout_backoff, EC_TIMEOUT_BACKOFF,
200*5e6d2182SSascha Wildner "Total time spent retrying for a response (poll+sleep) in case of failure");
201f872b7caSMatthew Dillon static int ec_auto_silence = 10; /* silence after 10 errors */
202f872b7caSMatthew Dillon TUNABLE_INT("debug.acpi.ec.auto_silence", &ec_auto_silence);
203f872b7caSMatthew Dillon SYSCTL_INT(_debug_acpi_ec, OID_AUTO, auto_silence, CTLFLAG_RW,
204f872b7caSMatthew Dillon &ec_auto_silence, 1,
205*5e6d2182SSascha Wildner "Auto-silence ACPI messages after x retries in case of failure");
2065db2f26eSSascha Wildner
2076836e2b4SSascha Wildner #ifndef KTR_ACPI_EC
2086836e2b4SSascha Wildner #define KTR_ACPI_EC KTR_ALL
2096836e2b4SSascha Wildner #endif
2106836e2b4SSascha Wildner
2116836e2b4SSascha Wildner KTR_INFO_MASTER(acpi_ec);
2126836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, burstdis, 0,
2136836e2b4SSascha Wildner "ec burst disabled in waitevent (%s)", const char *msg);
2146836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, burstdisok, 1,
2156836e2b4SSascha Wildner "ec disabled burst ok");
2166836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, burstenl, 2,
2176836e2b4SSascha Wildner "ec burst enabled");
2186836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, cmdrun, 3,
21930730f99SSascha Wildner "ec running command %#hhx", EC_COMMAND cmd);
2206836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, gpehdlstart, 4,
2216836e2b4SSascha Wildner "ec gpe handler start");
2226836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, gpequeuehdl, 5,
2236836e2b4SSascha Wildner "ec gpe queueing query handler");
2246836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, gperun, 6,
2256836e2b4SSascha Wildner "ec running gpe handler directly");
2266836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, qryoknotrun, 7,
22730730f99SSascha Wildner "ec query ok, not running _Q%02hhX", uint8_t Data);
2286836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, qryokrun, 8,
22930730f99SSascha Wildner "ec query ok, running _Q%02hhX", uint8_t Data);
2306836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, readaddr, 9,
23130730f99SSascha Wildner "ec read from %#hhx", UINT8 Address);
2326836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, timeout, 10,
2336836e2b4SSascha Wildner "error: ec wait timed out");
2346836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, waitrdy, 11,
23530730f99SSascha Wildner "ec %s wait ready, status %#hhx", const char *msg, EC_STATUS ec_status);
2366836e2b4SSascha Wildner KTR_INFO(KTR_ACPI_EC, acpi_ec, writeaddr, 12,
23730730f99SSascha Wildner "ec write to %#hhx, data %#hhx", UINT8 Address, UINT8 Data);
2386836e2b4SSascha Wildner
2395db2f26eSSascha Wildner static ACPI_STATUS
EcLock(struct acpi_ec_softc * sc)2405db2f26eSSascha Wildner EcLock(struct acpi_ec_softc *sc)
2415db2f26eSSascha Wildner {
2425db2f26eSSascha Wildner ACPI_STATUS status;
2435db2f26eSSascha Wildner
2445db2f26eSSascha Wildner /* If _GLK is non-zero, acquire the global lock. */
2455db2f26eSSascha Wildner status = AE_OK;
2465db2f26eSSascha Wildner if (sc->ec_glk) {
2475db2f26eSSascha Wildner status = AcpiAcquireGlobalLock(EC_LOCK_TIMEOUT, &sc->ec_glkhandle);
2485db2f26eSSascha Wildner if (ACPI_FAILURE(status))
2496836e2b4SSascha Wildner return (status);
2505db2f26eSSascha Wildner }
2516836e2b4SSascha Wildner ACPI_SERIAL_BEGIN(ec);
2525db2f26eSSascha Wildner return (status);
2535db2f26eSSascha Wildner }
2545db2f26eSSascha Wildner
2555db2f26eSSascha Wildner static void
EcUnlock(struct acpi_ec_softc * sc)2565db2f26eSSascha Wildner EcUnlock(struct acpi_ec_softc *sc)
2575db2f26eSSascha Wildner {
2586836e2b4SSascha Wildner ACPI_SERIAL_END(ec);
2595db2f26eSSascha Wildner if (sc->ec_glk)
2605db2f26eSSascha Wildner AcpiReleaseGlobalLock(sc->ec_glkhandle);
2615db2f26eSSascha Wildner }
2625db2f26eSSascha Wildner
2636836e2b4SSascha Wildner static UINT32 EcGpeHandler(ACPI_HANDLE GpeDevice,
2645db2f26eSSascha Wildner UINT32 GpeNumber, void *Context);
2655db2f26eSSascha Wildner static ACPI_STATUS EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function,
2665db2f26eSSascha Wildner void *Context, void **return_Context);
2675db2f26eSSascha Wildner static ACPI_STATUS EcSpaceHandler(UINT32 Function,
2685db2f26eSSascha Wildner ACPI_PHYSICAL_ADDRESS Address,
2695db2f26eSSascha Wildner UINT32 Width, UINT64 *Value,
2705db2f26eSSascha Wildner void *Context, void *RegionContext);
2715db2f26eSSascha Wildner static ACPI_STATUS EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event,
2725db2f26eSSascha Wildner u_int gen_count);
2735db2f26eSSascha Wildner static ACPI_STATUS EcCommand(struct acpi_ec_softc *sc, EC_COMMAND cmd);
2745db2f26eSSascha Wildner static ACPI_STATUS EcRead(struct acpi_ec_softc *sc, UINT8 Address,
2755db2f26eSSascha Wildner UINT8 *Data);
2765db2f26eSSascha Wildner static ACPI_STATUS EcWrite(struct acpi_ec_softc *sc, UINT8 Address,
2775db2f26eSSascha Wildner UINT8 Data);
2785db2f26eSSascha Wildner static int acpi_ec_probe(device_t dev);
2795db2f26eSSascha Wildner static int acpi_ec_attach(device_t dev);
2805db2f26eSSascha Wildner static int acpi_ec_suspend(device_t dev);
2815db2f26eSSascha Wildner static int acpi_ec_resume(device_t dev);
2825db2f26eSSascha Wildner static int acpi_ec_shutdown(device_t dev);
2835db2f26eSSascha Wildner static int acpi_ec_read_method(device_t dev, u_int addr,
2845db2f26eSSascha Wildner UINT64 *val, int width);
2855db2f26eSSascha Wildner static int acpi_ec_write_method(device_t dev, u_int addr,
2865db2f26eSSascha Wildner UINT64 val, int width);
2875db2f26eSSascha Wildner
2885db2f26eSSascha Wildner static device_method_t acpi_ec_methods[] = {
2895db2f26eSSascha Wildner /* Device interface */
2905db2f26eSSascha Wildner DEVMETHOD(device_probe, acpi_ec_probe),
2915db2f26eSSascha Wildner DEVMETHOD(device_attach, acpi_ec_attach),
2925db2f26eSSascha Wildner DEVMETHOD(device_suspend, acpi_ec_suspend),
2935db2f26eSSascha Wildner DEVMETHOD(device_resume, acpi_ec_resume),
2945db2f26eSSascha Wildner DEVMETHOD(device_shutdown, acpi_ec_shutdown),
2955db2f26eSSascha Wildner
2965db2f26eSSascha Wildner /* Embedded controller interface */
2975db2f26eSSascha Wildner DEVMETHOD(acpi_ec_read, acpi_ec_read_method),
2985db2f26eSSascha Wildner DEVMETHOD(acpi_ec_write, acpi_ec_write_method),
2995db2f26eSSascha Wildner
300d3c9c58eSSascha Wildner DEVMETHOD_END
3015db2f26eSSascha Wildner };
3025db2f26eSSascha Wildner
3035db2f26eSSascha Wildner static driver_t acpi_ec_driver = {
3045db2f26eSSascha Wildner "acpi_ec",
3055db2f26eSSascha Wildner acpi_ec_methods,
3065db2f26eSSascha Wildner sizeof(struct acpi_ec_softc),
3075025fc65SMatthew Dillon .gpri = KOBJ_GPRI_ACPI
3085db2f26eSSascha Wildner };
3095db2f26eSSascha Wildner
3105db2f26eSSascha Wildner static devclass_t acpi_ec_devclass;
3115db2f26eSSascha Wildner DRIVER_MODULE(acpi_ec, acpi, acpi_ec_driver, acpi_ec_devclass, NULL, NULL);
3125db2f26eSSascha Wildner MODULE_DEPEND(acpi_ec, acpi, 1, 1, 1);
3135db2f26eSSascha Wildner
3145db2f26eSSascha Wildner /*
3155db2f26eSSascha Wildner * Look for an ECDT and if we find one, set up default GPE and
3165db2f26eSSascha Wildner * space handlers to catch attempts to access EC space before
3175db2f26eSSascha Wildner * we have a real driver instance in place.
3185db2f26eSSascha Wildner *
3195db2f26eSSascha Wildner * TODO: Some old Gateway laptops need us to fake up an ECDT or
3205db2f26eSSascha Wildner * otherwise attach early so that _REG methods can run.
3215db2f26eSSascha Wildner */
3225db2f26eSSascha Wildner void
acpi_ec_ecdt_probe(device_t parent)3235db2f26eSSascha Wildner acpi_ec_ecdt_probe(device_t parent)
3245db2f26eSSascha Wildner {
3255db2f26eSSascha Wildner ACPI_TABLE_ECDT *ecdt;
3265db2f26eSSascha Wildner ACPI_STATUS status;
3275db2f26eSSascha Wildner device_t child;
3285db2f26eSSascha Wildner ACPI_HANDLE h;
3295db2f26eSSascha Wildner struct acpi_ec_params *params;
3305db2f26eSSascha Wildner
3315db2f26eSSascha Wildner ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
3325db2f26eSSascha Wildner
3335db2f26eSSascha Wildner /* Find and validate the ECDT. */
3345db2f26eSSascha Wildner status = AcpiGetTable(ACPI_SIG_ECDT, 1, (ACPI_TABLE_HEADER **)&ecdt);
3355db2f26eSSascha Wildner if (ACPI_FAILURE(status) ||
3365db2f26eSSascha Wildner ecdt->Control.BitWidth != 8 ||
3375db2f26eSSascha Wildner ecdt->Data.BitWidth != 8) {
3385db2f26eSSascha Wildner return;
3395db2f26eSSascha Wildner }
3405db2f26eSSascha Wildner
3415db2f26eSSascha Wildner /* Create the child device with the given unit number. */
3425db2f26eSSascha Wildner child = BUS_ADD_CHILD(parent, parent, 0, "acpi_ec", ecdt->Uid);
3435db2f26eSSascha Wildner if (child == NULL) {
3445db2f26eSSascha Wildner kprintf("%s: can't add child\n", __func__);
3455db2f26eSSascha Wildner return;
3465db2f26eSSascha Wildner }
3475db2f26eSSascha Wildner
3485db2f26eSSascha Wildner /* Find and save the ACPI handle for this device. */
3495db2f26eSSascha Wildner status = AcpiGetHandle(NULL, ecdt->Id, &h);
3505db2f26eSSascha Wildner if (ACPI_FAILURE(status)) {
3515db2f26eSSascha Wildner device_delete_child(parent, child);
3525db2f26eSSascha Wildner kprintf("%s: can't get handle\n", __func__);
3535db2f26eSSascha Wildner return;
3545db2f26eSSascha Wildner }
3555db2f26eSSascha Wildner acpi_set_handle(child, h);
3565db2f26eSSascha Wildner
3575db2f26eSSascha Wildner /* Set the data and CSR register addresses. */
3585db2f26eSSascha Wildner bus_set_resource(child, SYS_RES_IOPORT, 0, ecdt->Data.Address,
3595db2f26eSSascha Wildner /*count*/1, -1);
3605db2f26eSSascha Wildner bus_set_resource(child, SYS_RES_IOPORT, 1, ecdt->Control.Address,
3615db2f26eSSascha Wildner /*count*/1, -1);
3625db2f26eSSascha Wildner
3635db2f26eSSascha Wildner /*
3645db2f26eSSascha Wildner * Store values for the probe/attach routines to use. Store the
3655db2f26eSSascha Wildner * ECDT GPE bit and set the global lock flag according to _GLK.
3665db2f26eSSascha Wildner * Note that it is not perfectly correct to be evaluating a method
3675db2f26eSSascha Wildner * before initializing devices, but in practice this function
3685db2f26eSSascha Wildner * should be safe to call at this point.
3695db2f26eSSascha Wildner */
3705db2f26eSSascha Wildner params = kmalloc(sizeof(struct acpi_ec_params), M_TEMP, M_WAITOK | M_ZERO);
3715db2f26eSSascha Wildner params->gpe_handle = NULL;
3725db2f26eSSascha Wildner params->gpe_bit = ecdt->Gpe;
3735db2f26eSSascha Wildner params->uid = ecdt->Uid;
3745db2f26eSSascha Wildner acpi_GetInteger(h, "_GLK", ¶ms->glk);
3755db2f26eSSascha Wildner acpi_set_private(child, params);
3765db2f26eSSascha Wildner
3775db2f26eSSascha Wildner /* Finish the attach process. */
3785db2f26eSSascha Wildner if (device_probe_and_attach(child) != 0)
3795db2f26eSSascha Wildner device_delete_child(parent, child);
3805db2f26eSSascha Wildner }
3815db2f26eSSascha Wildner
3825db2f26eSSascha Wildner static int
acpi_ec_probe(device_t dev)3835db2f26eSSascha Wildner acpi_ec_probe(device_t dev)
3845db2f26eSSascha Wildner {
3855db2f26eSSascha Wildner ACPI_BUFFER buf;
3865db2f26eSSascha Wildner ACPI_HANDLE h;
3875db2f26eSSascha Wildner ACPI_OBJECT *obj;
3885db2f26eSSascha Wildner ACPI_STATUS status;
3895db2f26eSSascha Wildner device_t peer;
3905db2f26eSSascha Wildner char desc[64];
3915db2f26eSSascha Wildner int ecdt;
3925db2f26eSSascha Wildner int ret;
3935db2f26eSSascha Wildner struct acpi_ec_params *params;
3945db2f26eSSascha Wildner static char *ec_ids[] = { "PNP0C09", NULL };
3955db2f26eSSascha Wildner
3965db2f26eSSascha Wildner /* Check that this is a device and that EC is not disabled. */
3975db2f26eSSascha Wildner if (acpi_get_type(dev) != ACPI_TYPE_DEVICE || acpi_disabled("ec"))
3985db2f26eSSascha Wildner return (ENXIO);
3995db2f26eSSascha Wildner
4005db2f26eSSascha Wildner /*
4015db2f26eSSascha Wildner * If probed via ECDT, set description and continue. Otherwise,
4025db2f26eSSascha Wildner * we can access the namespace and make sure this is not a
4035db2f26eSSascha Wildner * duplicate probe.
4045db2f26eSSascha Wildner */
4055db2f26eSSascha Wildner ret = ENXIO;
4065db2f26eSSascha Wildner ecdt = 0;
4075db2f26eSSascha Wildner buf.Pointer = NULL;
4085db2f26eSSascha Wildner buf.Length = ACPI_ALLOCATE_BUFFER;
4095db2f26eSSascha Wildner params = acpi_get_private(dev);
4105db2f26eSSascha Wildner if (params != NULL) {
4115db2f26eSSascha Wildner ecdt = 1;
4125db2f26eSSascha Wildner ret = 0;
4135db2f26eSSascha Wildner } else if (ACPI_ID_PROBE(device_get_parent(dev), dev, ec_ids)) {
4145db2f26eSSascha Wildner params = kmalloc(sizeof(struct acpi_ec_params), M_TEMP,
4155db2f26eSSascha Wildner M_WAITOK | M_ZERO);
4165db2f26eSSascha Wildner h = acpi_get_handle(dev);
4175db2f26eSSascha Wildner
4185db2f26eSSascha Wildner /*
4195db2f26eSSascha Wildner * Read the unit ID to check for duplicate attach and the
4205db2f26eSSascha Wildner * global lock value to see if we should acquire it when
4215db2f26eSSascha Wildner * accessing the EC.
4225db2f26eSSascha Wildner */
4235db2f26eSSascha Wildner status = acpi_GetInteger(h, "_UID", ¶ms->uid);
4245db2f26eSSascha Wildner if (ACPI_FAILURE(status))
4255db2f26eSSascha Wildner params->uid = 0;
4265db2f26eSSascha Wildner status = acpi_GetInteger(h, "_GLK", ¶ms->glk);
4275db2f26eSSascha Wildner if (ACPI_FAILURE(status))
4285db2f26eSSascha Wildner params->glk = 0;
4295db2f26eSSascha Wildner
4305db2f26eSSascha Wildner /*
4315db2f26eSSascha Wildner * Evaluate the _GPE method to find the GPE bit used by the EC to
4325db2f26eSSascha Wildner * signal status (SCI). If it's a package, it contains a reference
4335db2f26eSSascha Wildner * and GPE bit, similar to _PRW.
4345db2f26eSSascha Wildner */
4355db2f26eSSascha Wildner status = AcpiEvaluateObject(h, "_GPE", NULL, &buf);
4365db2f26eSSascha Wildner if (ACPI_FAILURE(status)) {
4375db2f26eSSascha Wildner device_printf(dev, "can't evaluate _GPE - %s\n",
4385db2f26eSSascha Wildner AcpiFormatException(status));
4395db2f26eSSascha Wildner goto out;
4405db2f26eSSascha Wildner }
4415db2f26eSSascha Wildner obj = (ACPI_OBJECT *)buf.Pointer;
4425db2f26eSSascha Wildner if (obj == NULL)
4435db2f26eSSascha Wildner goto out;
4445db2f26eSSascha Wildner
4455db2f26eSSascha Wildner switch (obj->Type) {
4465db2f26eSSascha Wildner case ACPI_TYPE_INTEGER:
4475db2f26eSSascha Wildner params->gpe_handle = NULL;
4485db2f26eSSascha Wildner params->gpe_bit = obj->Integer.Value;
4495db2f26eSSascha Wildner break;
4505db2f26eSSascha Wildner case ACPI_TYPE_PACKAGE:
4515db2f26eSSascha Wildner if (!ACPI_PKG_VALID(obj, 2))
4525db2f26eSSascha Wildner goto out;
4535db2f26eSSascha Wildner params->gpe_handle =
4545db2f26eSSascha Wildner acpi_GetReference(NULL, &obj->Package.Elements[0]);
4555db2f26eSSascha Wildner if (params->gpe_handle == NULL ||
4565db2f26eSSascha Wildner acpi_PkgInt32(obj, 1, ¶ms->gpe_bit) != 0)
4575db2f26eSSascha Wildner goto out;
4585db2f26eSSascha Wildner break;
4595db2f26eSSascha Wildner default:
4605db2f26eSSascha Wildner device_printf(dev, "_GPE has invalid type %d\n", obj->Type);
4615db2f26eSSascha Wildner goto out;
4625db2f26eSSascha Wildner }
4635db2f26eSSascha Wildner
4645db2f26eSSascha Wildner /* Store the values we got from the namespace for attach. */
4655db2f26eSSascha Wildner acpi_set_private(dev, params);
4665db2f26eSSascha Wildner
4675db2f26eSSascha Wildner /*
4685db2f26eSSascha Wildner * Check for a duplicate probe. This can happen when a probe
4695db2f26eSSascha Wildner * via ECDT succeeded already. If this is a duplicate, disable
4705db2f26eSSascha Wildner * this device.
4715db2f26eSSascha Wildner */
4725db2f26eSSascha Wildner peer = devclass_get_device(acpi_ec_devclass, params->uid);
4735db2f26eSSascha Wildner if (peer == NULL || !device_is_alive(peer))
4745db2f26eSSascha Wildner ret = 0;
4755db2f26eSSascha Wildner else
4765db2f26eSSascha Wildner device_disable(dev);
4775db2f26eSSascha Wildner }
4785db2f26eSSascha Wildner
4795db2f26eSSascha Wildner out:
4805db2f26eSSascha Wildner if (ret == 0) {
4815db2f26eSSascha Wildner ksnprintf(desc, sizeof(desc), "Embedded Controller: GPE %#x%s%s",
4825db2f26eSSascha Wildner params->gpe_bit, (params->glk) ? ", GLK" : "",
4835db2f26eSSascha Wildner ecdt ? ", ECDT" : "");
4845db2f26eSSascha Wildner device_set_desc_copy(dev, desc);
4855db2f26eSSascha Wildner }
4865db2f26eSSascha Wildner
4875db2f26eSSascha Wildner if (ret > 0 && params)
4885db2f26eSSascha Wildner kfree(params, M_TEMP);
4895db2f26eSSascha Wildner if (buf.Pointer)
4905db2f26eSSascha Wildner AcpiOsFree(buf.Pointer);
4915db2f26eSSascha Wildner return (ret);
4925db2f26eSSascha Wildner }
4935db2f26eSSascha Wildner
4945db2f26eSSascha Wildner static int
acpi_ec_attach(device_t dev)4955db2f26eSSascha Wildner acpi_ec_attach(device_t dev)
4965db2f26eSSascha Wildner {
4975db2f26eSSascha Wildner struct acpi_ec_softc *sc;
4985db2f26eSSascha Wildner struct acpi_ec_params *params;
4995db2f26eSSascha Wildner ACPI_STATUS Status;
5005db2f26eSSascha Wildner
5015db2f26eSSascha Wildner ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
5025db2f26eSSascha Wildner
5035db2f26eSSascha Wildner /* Fetch/initialize softc (assumes softc is pre-zeroed). */
5045db2f26eSSascha Wildner sc = device_get_softc(dev);
5055db2f26eSSascha Wildner params = acpi_get_private(dev);
5065db2f26eSSascha Wildner sc->ec_dev = dev;
5075db2f26eSSascha Wildner sc->ec_handle = acpi_get_handle(dev);
5085db2f26eSSascha Wildner ACPI_SERIAL_INIT(ec);
5095db2f26eSSascha Wildner
5105db2f26eSSascha Wildner /* Retrieve previously probed values via device ivars. */
5115db2f26eSSascha Wildner sc->ec_glk = params->glk;
5125db2f26eSSascha Wildner sc->ec_gpebit = params->gpe_bit;
5135db2f26eSSascha Wildner sc->ec_gpehandle = params->gpe_handle;
5145db2f26eSSascha Wildner sc->ec_uid = params->uid;
5155db2f26eSSascha Wildner sc->ec_suspending = FALSE;
5165db2f26eSSascha Wildner acpi_set_private(dev, NULL);
5175db2f26eSSascha Wildner kfree(params, M_TEMP);
5185db2f26eSSascha Wildner
5195db2f26eSSascha Wildner /* Attach bus resources for data and command/status ports. */
5205db2f26eSSascha Wildner sc->ec_data_rid = 0;
5215db2f26eSSascha Wildner sc->ec_data_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
5225db2f26eSSascha Wildner &sc->ec_data_rid, RF_ACTIVE);
5235db2f26eSSascha Wildner if (sc->ec_data_res == NULL) {
5245db2f26eSSascha Wildner device_printf(dev, "can't allocate data port\n");
5255db2f26eSSascha Wildner goto error;
5265db2f26eSSascha Wildner }
5275db2f26eSSascha Wildner sc->ec_data_tag = rman_get_bustag(sc->ec_data_res);
5285db2f26eSSascha Wildner sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res);
5295db2f26eSSascha Wildner
5305db2f26eSSascha Wildner sc->ec_csr_rid = 1;
5315db2f26eSSascha Wildner sc->ec_csr_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
5325db2f26eSSascha Wildner &sc->ec_csr_rid, RF_ACTIVE);
5335db2f26eSSascha Wildner if (sc->ec_csr_res == NULL) {
5345db2f26eSSascha Wildner device_printf(dev, "can't allocate command/status port\n");
5355db2f26eSSascha Wildner goto error;
5365db2f26eSSascha Wildner }
5375db2f26eSSascha Wildner sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res);
5385db2f26eSSascha Wildner sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res);
5395db2f26eSSascha Wildner
5405db2f26eSSascha Wildner /*
5415db2f26eSSascha Wildner * Install a handler for this EC's GPE bit. We want edge-triggered
5425db2f26eSSascha Wildner * behavior.
5435db2f26eSSascha Wildner */
5445db2f26eSSascha Wildner ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE handler\n"));
5455db2f26eSSascha Wildner Status = AcpiInstallGpeHandler(sc->ec_gpehandle, sc->ec_gpebit,
5466836e2b4SSascha Wildner ACPI_GPE_EDGE_TRIGGERED, EcGpeHandler, sc);
5475db2f26eSSascha Wildner if (ACPI_FAILURE(Status)) {
5485db2f26eSSascha Wildner device_printf(dev, "can't install GPE handler for %s - %s\n",
5495db2f26eSSascha Wildner acpi_name(sc->ec_handle), AcpiFormatException(Status));
5505db2f26eSSascha Wildner goto error;
5515db2f26eSSascha Wildner }
5525db2f26eSSascha Wildner
5535db2f26eSSascha Wildner /*
5545db2f26eSSascha Wildner * Install address space handler
5555db2f26eSSascha Wildner */
5565db2f26eSSascha Wildner ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n"));
5575db2f26eSSascha Wildner Status = AcpiInstallAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
5585db2f26eSSascha Wildner &EcSpaceHandler, &EcSpaceSetup, sc);
5595db2f26eSSascha Wildner if (ACPI_FAILURE(Status)) {
5605db2f26eSSascha Wildner device_printf(dev, "can't install address space handler for %s - %s\n",
5615db2f26eSSascha Wildner acpi_name(sc->ec_handle), AcpiFormatException(Status));
5625db2f26eSSascha Wildner goto error;
5635db2f26eSSascha Wildner }
5645db2f26eSSascha Wildner
5656836e2b4SSascha Wildner /* Enable runtime GPEs for the handler. */
5665db2f26eSSascha Wildner Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit);
5675db2f26eSSascha Wildner if (ACPI_FAILURE(Status)) {
5685db2f26eSSascha Wildner device_printf(dev, "AcpiEnableGpe failed: %s\n",
5695db2f26eSSascha Wildner AcpiFormatException(Status));
5705db2f26eSSascha Wildner goto error;
5715db2f26eSSascha Wildner }
5725db2f26eSSascha Wildner
5735db2f26eSSascha Wildner ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "acpi_ec_attach complete\n"));
5745db2f26eSSascha Wildner return (0);
5755db2f26eSSascha Wildner
5765db2f26eSSascha Wildner error:
5776836e2b4SSascha Wildner AcpiRemoveGpeHandler(sc->ec_gpehandle, sc->ec_gpebit, EcGpeHandler);
5785db2f26eSSascha Wildner AcpiRemoveAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
5795db2f26eSSascha Wildner EcSpaceHandler);
5805db2f26eSSascha Wildner if (sc->ec_csr_res)
5815db2f26eSSascha Wildner bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_csr_rid,
5825db2f26eSSascha Wildner sc->ec_csr_res);
5835db2f26eSSascha Wildner if (sc->ec_data_res)
5845db2f26eSSascha Wildner bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_data_rid,
5855db2f26eSSascha Wildner sc->ec_data_res);
5865db2f26eSSascha Wildner return (ENXIO);
5875db2f26eSSascha Wildner }
5885db2f26eSSascha Wildner
5895db2f26eSSascha Wildner static int
acpi_ec_suspend(device_t dev)5905db2f26eSSascha Wildner acpi_ec_suspend(device_t dev)
5915db2f26eSSascha Wildner {
5925db2f26eSSascha Wildner struct acpi_ec_softc *sc;
5935db2f26eSSascha Wildner
5945db2f26eSSascha Wildner sc = device_get_softc(dev);
5955db2f26eSSascha Wildner sc->ec_suspending = TRUE;
5965db2f26eSSascha Wildner return (0);
5975db2f26eSSascha Wildner }
5985db2f26eSSascha Wildner
5995db2f26eSSascha Wildner static int
acpi_ec_resume(device_t dev)6005db2f26eSSascha Wildner acpi_ec_resume(device_t dev)
6015db2f26eSSascha Wildner {
6025db2f26eSSascha Wildner struct acpi_ec_softc *sc;
6035db2f26eSSascha Wildner
6045db2f26eSSascha Wildner sc = device_get_softc(dev);
6055db2f26eSSascha Wildner sc->ec_suspending = FALSE;
6065db2f26eSSascha Wildner return (0);
6075db2f26eSSascha Wildner }
6085db2f26eSSascha Wildner
6095db2f26eSSascha Wildner static int
acpi_ec_shutdown(device_t dev)6105db2f26eSSascha Wildner acpi_ec_shutdown(device_t dev)
6115db2f26eSSascha Wildner {
6125db2f26eSSascha Wildner struct acpi_ec_softc *sc;
6135db2f26eSSascha Wildner
6145db2f26eSSascha Wildner /* Disable the GPE so we don't get EC events during shutdown. */
6155db2f26eSSascha Wildner sc = device_get_softc(dev);
6165db2f26eSSascha Wildner AcpiDisableGpe(sc->ec_gpehandle, sc->ec_gpebit);
6175db2f26eSSascha Wildner return (0);
6185db2f26eSSascha Wildner }
6195db2f26eSSascha Wildner
6205db2f26eSSascha Wildner /* Methods to allow other devices (e.g., smbat) to read/write EC space. */
6215db2f26eSSascha Wildner static int
acpi_ec_read_method(device_t dev,u_int addr,UINT64 * val,int width)6225db2f26eSSascha Wildner acpi_ec_read_method(device_t dev, u_int addr, UINT64 *val, int width)
6235db2f26eSSascha Wildner {
6245db2f26eSSascha Wildner struct acpi_ec_softc *sc;
6255db2f26eSSascha Wildner ACPI_STATUS status;
6265db2f26eSSascha Wildner
6275db2f26eSSascha Wildner sc = device_get_softc(dev);
6285db2f26eSSascha Wildner status = EcSpaceHandler(ACPI_READ, addr, width * 8, val, sc, NULL);
6295db2f26eSSascha Wildner if (ACPI_FAILURE(status))
6305db2f26eSSascha Wildner return (ENXIO);
6315db2f26eSSascha Wildner return (0);
6325db2f26eSSascha Wildner }
6335db2f26eSSascha Wildner
6345db2f26eSSascha Wildner static int
acpi_ec_write_method(device_t dev,u_int addr,UINT64 val,int width)6355db2f26eSSascha Wildner acpi_ec_write_method(device_t dev, u_int addr, UINT64 val, int width)
6365db2f26eSSascha Wildner {
6375db2f26eSSascha Wildner struct acpi_ec_softc *sc;
6385db2f26eSSascha Wildner ACPI_STATUS status;
6395db2f26eSSascha Wildner
6405db2f26eSSascha Wildner sc = device_get_softc(dev);
6415db2f26eSSascha Wildner status = EcSpaceHandler(ACPI_WRITE, addr, width * 8, &val, sc, NULL);
6425db2f26eSSascha Wildner if (ACPI_FAILURE(status))
6435db2f26eSSascha Wildner return (ENXIO);
6445db2f26eSSascha Wildner return (0);
6455db2f26eSSascha Wildner }
6465db2f26eSSascha Wildner
6475db2f26eSSascha Wildner static ACPI_STATUS
EcCheckStatus(struct acpi_ec_softc * sc,const char * msg,EC_EVENT event)6485db2f26eSSascha Wildner EcCheckStatus(struct acpi_ec_softc *sc, const char *msg, EC_EVENT event)
6495db2f26eSSascha Wildner {
6505db2f26eSSascha Wildner ACPI_STATUS status;
6515db2f26eSSascha Wildner EC_STATUS ec_status;
6525db2f26eSSascha Wildner
6535db2f26eSSascha Wildner status = AE_NO_HARDWARE_RESPONSE;
6545db2f26eSSascha Wildner ec_status = EC_GET_CSR(sc);
6555db2f26eSSascha Wildner if (sc->ec_burstactive && !(ec_status & EC_FLAG_BURST_MODE)) {
6566836e2b4SSascha Wildner KTR_LOG(acpi_ec_burstdis, msg);
6575db2f26eSSascha Wildner sc->ec_burstactive = FALSE;
6585db2f26eSSascha Wildner }
6595db2f26eSSascha Wildner if (EVENT_READY(event, ec_status)) {
6606836e2b4SSascha Wildner KTR_LOG(acpi_ec_waitrdy, msg, ec_status);
6615db2f26eSSascha Wildner status = AE_OK;
6625db2f26eSSascha Wildner }
6635db2f26eSSascha Wildner return (status);
6645db2f26eSSascha Wildner }
6655db2f26eSSascha Wildner
6665db2f26eSSascha Wildner static void
EcGpeQueryHandler(void * Context)6675db2f26eSSascha Wildner EcGpeQueryHandler(void *Context)
6685db2f26eSSascha Wildner {
6695db2f26eSSascha Wildner struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context;
6705db2f26eSSascha Wildner UINT8 Data;
6715db2f26eSSascha Wildner ACPI_STATUS Status;
6725db2f26eSSascha Wildner int retry, sci_enqueued;
6735db2f26eSSascha Wildner char qxx[5];
6745db2f26eSSascha Wildner
6755db2f26eSSascha Wildner ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
6765db2f26eSSascha Wildner KASSERT(Context != NULL, ("EcGpeQueryHandler called with NULL"));
6775db2f26eSSascha Wildner
6785db2f26eSSascha Wildner /* Serialize user access with EcSpaceHandler(). */
6795db2f26eSSascha Wildner Status = EcLock(sc);
6805db2f26eSSascha Wildner if (ACPI_FAILURE(Status)) {
6815db2f26eSSascha Wildner device_printf(sc->ec_dev, "GpeQuery lock error: %s\n",
6825db2f26eSSascha Wildner AcpiFormatException(Status));
6835db2f26eSSascha Wildner return;
6845db2f26eSSascha Wildner }
6855db2f26eSSascha Wildner
6865db2f26eSSascha Wildner /*
6875db2f26eSSascha Wildner * Send a query command to the EC to find out which _Qxx call it
6885db2f26eSSascha Wildner * wants to make. This command clears the SCI bit and also the
6895db2f26eSSascha Wildner * interrupt source since we are edge-triggered. To prevent the GPE
6905db2f26eSSascha Wildner * that may arise from running the query from causing another query
6915db2f26eSSascha Wildner * to be queued, we clear the pending flag only after running it.
6925db2f26eSSascha Wildner */
6935db2f26eSSascha Wildner sci_enqueued = sc->ec_sci_pend;
6945db2f26eSSascha Wildner for (retry = 0; retry < 2; retry++) {
6955db2f26eSSascha Wildner Status = EcCommand(sc, EC_COMMAND_QUERY);
6965db2f26eSSascha Wildner if (ACPI_SUCCESS(Status))
6975db2f26eSSascha Wildner break;
698b08525dbSSascha Wildner if (ACPI_SUCCESS(EcCheckStatus(sc, "retr_check",
699b08525dbSSascha Wildner EC_EVENT_INPUT_BUFFER_EMPTY)))
7005db2f26eSSascha Wildner continue;
7015db2f26eSSascha Wildner else
7025db2f26eSSascha Wildner break;
7035db2f26eSSascha Wildner }
7045db2f26eSSascha Wildner sc->ec_sci_pend = FALSE;
7055db2f26eSSascha Wildner if (ACPI_FAILURE(Status)) {
7065db2f26eSSascha Wildner EcUnlock(sc);
7075db2f26eSSascha Wildner device_printf(sc->ec_dev, "GPE query failed: %s\n",
7085db2f26eSSascha Wildner AcpiFormatException(Status));
7095db2f26eSSascha Wildner return;
7105db2f26eSSascha Wildner }
7115db2f26eSSascha Wildner Data = EC_GET_DATA(sc);
7125db2f26eSSascha Wildner
7135db2f26eSSascha Wildner /*
7145db2f26eSSascha Wildner * We have to unlock before running the _Qxx method below since that
7155db2f26eSSascha Wildner * method may attempt to read/write from EC address space, causing
7165db2f26eSSascha Wildner * recursive acquisition of the lock.
7175db2f26eSSascha Wildner */
7185db2f26eSSascha Wildner EcUnlock(sc);
7195db2f26eSSascha Wildner
7205db2f26eSSascha Wildner /* Ignore the value for "no outstanding event". (13.3.5) */
7216836e2b4SSascha Wildner if (Data == 0) {
7226836e2b4SSascha Wildner KTR_LOG(acpi_ec_qryoknotrun, Data);
7235db2f26eSSascha Wildner return;
7246836e2b4SSascha Wildner } else {
7256836e2b4SSascha Wildner KTR_LOG(acpi_ec_qryokrun, Data);
7266836e2b4SSascha Wildner }
7275db2f26eSSascha Wildner
7285db2f26eSSascha Wildner /* Evaluate _Qxx to respond to the controller. */
7295db2f26eSSascha Wildner ksnprintf(qxx, sizeof(qxx), "_Q%02X", Data);
7305db2f26eSSascha Wildner AcpiUtStrupr(qxx);
7315db2f26eSSascha Wildner Status = AcpiEvaluateObject(sc->ec_handle, qxx, NULL, NULL);
7325db2f26eSSascha Wildner if (ACPI_FAILURE(Status) && Status != AE_NOT_FOUND) {
7335db2f26eSSascha Wildner device_printf(sc->ec_dev, "evaluation of query method %s failed: %s\n",
7345db2f26eSSascha Wildner qxx, AcpiFormatException(Status));
7355db2f26eSSascha Wildner }
7365db2f26eSSascha Wildner
7375db2f26eSSascha Wildner /* Reenable runtime GPE if its execution was deferred. */
7385db2f26eSSascha Wildner if (sci_enqueued) {
7395db2f26eSSascha Wildner Status = AcpiFinishGpe(sc->ec_gpehandle, sc->ec_gpebit);
7405db2f26eSSascha Wildner if (ACPI_FAILURE(Status))
7415db2f26eSSascha Wildner device_printf(sc->ec_dev, "reenabling runtime GPE failed: %s\n",
7425db2f26eSSascha Wildner AcpiFormatException(Status));
7435db2f26eSSascha Wildner }
7445db2f26eSSascha Wildner }
7455db2f26eSSascha Wildner
7465db2f26eSSascha Wildner /*
7475db2f26eSSascha Wildner * The GPE handler is called when IBE/OBF or SCI events occur. We are
7485db2f26eSSascha Wildner * called from an unknown lock context.
7495db2f26eSSascha Wildner */
7506836e2b4SSascha Wildner static UINT32
EcGpeHandler(ACPI_HANDLE GpeDevice,UINT32 GpeNumber,void * Context)7515db2f26eSSascha Wildner EcGpeHandler(ACPI_HANDLE GpeDevice, UINT32 GpeNumber, void *Context)
7525db2f26eSSascha Wildner {
7535db2f26eSSascha Wildner struct acpi_ec_softc *sc = Context;
7545db2f26eSSascha Wildner ACPI_STATUS Status;
7555db2f26eSSascha Wildner EC_STATUS EcStatus;
7565db2f26eSSascha Wildner
7575db2f26eSSascha Wildner KASSERT(Context != NULL, ("EcGpeHandler called with NULL"));
7586836e2b4SSascha Wildner KTR_LOG(acpi_ec_gpehdlstart);
7595db2f26eSSascha Wildner /*
7605db2f26eSSascha Wildner * Notify EcWaitEvent() that the status register is now fresh. If we
7615db2f26eSSascha Wildner * didn't do this, it wouldn't be possible to distinguish an old IBE
7625db2f26eSSascha Wildner * from a new one, for example when doing a write transaction (writing
7635db2f26eSSascha Wildner * address and then data values.)
7645db2f26eSSascha Wildner */
7655db2f26eSSascha Wildner atomic_add_int(&sc->ec_gencount, 1);
7665db2f26eSSascha Wildner wakeup(sc);
7675db2f26eSSascha Wildner
7685db2f26eSSascha Wildner /*
7695db2f26eSSascha Wildner * If the EC_SCI bit of the status register is set, queue a query handler.
7705db2f26eSSascha Wildner * It will run the query and _Qxx method later, under the lock.
7715db2f26eSSascha Wildner */
7725db2f26eSSascha Wildner EcStatus = EC_GET_CSR(sc);
7735db2f26eSSascha Wildner if ((EcStatus & EC_EVENT_SCI) && !sc->ec_sci_pend) {
7746836e2b4SSascha Wildner KTR_LOG(acpi_ec_gpequeuehdl);
7755db2f26eSSascha Wildner Status = AcpiOsExecute(OSL_GPE_HANDLER, EcGpeQueryHandler, Context);
7765db2f26eSSascha Wildner if (ACPI_SUCCESS(Status)) {
7775db2f26eSSascha Wildner sc->ec_sci_pend = TRUE;
7785db2f26eSSascha Wildner return (0);
7795db2f26eSSascha Wildner } else {
7805db2f26eSSascha Wildner kprintf("EcGpeHandler: queuing GPE query handler failed\n");
7815db2f26eSSascha Wildner }
7825db2f26eSSascha Wildner }
7835db2f26eSSascha Wildner return (ACPI_REENABLE_GPE);
7845db2f26eSSascha Wildner }
7855db2f26eSSascha Wildner
7865db2f26eSSascha Wildner static ACPI_STATUS
EcSpaceSetup(ACPI_HANDLE Region,UINT32 Function,void * Context,void ** RegionContext)7875db2f26eSSascha Wildner EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context,
7885db2f26eSSascha Wildner void **RegionContext)
7895db2f26eSSascha Wildner {
7905db2f26eSSascha Wildner
7915db2f26eSSascha Wildner ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
7925db2f26eSSascha Wildner
7935db2f26eSSascha Wildner /*
7945db2f26eSSascha Wildner * If deactivating a region, always set the output to NULL. Otherwise,
7955db2f26eSSascha Wildner * just pass the context through.
7965db2f26eSSascha Wildner */
7975db2f26eSSascha Wildner if (Function == ACPI_REGION_DEACTIVATE)
7985db2f26eSSascha Wildner *RegionContext = NULL;
7995db2f26eSSascha Wildner else
8005db2f26eSSascha Wildner *RegionContext = Context;
8015db2f26eSSascha Wildner
8025db2f26eSSascha Wildner return_ACPI_STATUS (AE_OK);
8035db2f26eSSascha Wildner }
8045db2f26eSSascha Wildner
8055db2f26eSSascha Wildner static ACPI_STATUS
EcSpaceHandler(UINT32 Function,ACPI_PHYSICAL_ADDRESS Address,UINT32 Width,UINT64 * Value,void * Context,void * RegionContext)8065db2f26eSSascha Wildner EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 Width,
8075db2f26eSSascha Wildner UINT64 *Value, void *Context, void *RegionContext)
8085db2f26eSSascha Wildner {
8095db2f26eSSascha Wildner struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context;
8105db2f26eSSascha Wildner ACPI_PHYSICAL_ADDRESS EcAddr;
8115db2f26eSSascha Wildner UINT8 *EcData;
8125db2f26eSSascha Wildner ACPI_STATUS Status;
8135db2f26eSSascha Wildner
8145db2f26eSSascha Wildner ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Address);
8155db2f26eSSascha Wildner
8165db2f26eSSascha Wildner if (Function != ACPI_READ && Function != ACPI_WRITE)
8175db2f26eSSascha Wildner return_ACPI_STATUS (AE_BAD_PARAMETER);
8185db2f26eSSascha Wildner if (Width % 8 != 0 || Value == NULL || Context == NULL)
8195db2f26eSSascha Wildner return_ACPI_STATUS (AE_BAD_PARAMETER);
8205db2f26eSSascha Wildner if (Address + Width / 8 > 256)
8215db2f26eSSascha Wildner return_ACPI_STATUS (AE_BAD_ADDRESS);
8225db2f26eSSascha Wildner
8235db2f26eSSascha Wildner /*
8245db2f26eSSascha Wildner * If booting, check if we need to run the query handler. If so, we
8255db2f26eSSascha Wildner * we call it directly here since our thread taskq is not active yet.
8265db2f26eSSascha Wildner */
8275db2f26eSSascha Wildner if (cold || rebooting || sc->ec_suspending) {
8285db2f26eSSascha Wildner if ((EC_GET_CSR(sc) & EC_EVENT_SCI)) {
8296836e2b4SSascha Wildner KTR_LOG(acpi_ec_gperun);
8305db2f26eSSascha Wildner EcGpeQueryHandler(sc);
8315db2f26eSSascha Wildner }
8325db2f26eSSascha Wildner }
8335db2f26eSSascha Wildner
8345db2f26eSSascha Wildner /* Serialize with EcGpeQueryHandler() at transaction granularity. */
8355db2f26eSSascha Wildner Status = EcLock(sc);
8365db2f26eSSascha Wildner if (ACPI_FAILURE(Status))
8375db2f26eSSascha Wildner return_ACPI_STATUS (Status);
8385db2f26eSSascha Wildner
8395db2f26eSSascha Wildner /* If we can't start burst mode, continue anyway. */
8405db2f26eSSascha Wildner Status = EcCommand(sc, EC_COMMAND_BURST_ENABLE);
8415db2f26eSSascha Wildner if (ACPI_SUCCESS(Status)) {
8425db2f26eSSascha Wildner if (EC_GET_DATA(sc) == EC_BURST_ACK) {
8436836e2b4SSascha Wildner KTR_LOG(acpi_ec_burstenl);
8445db2f26eSSascha Wildner sc->ec_burstactive = TRUE;
8455db2f26eSSascha Wildner }
8465db2f26eSSascha Wildner }
8475db2f26eSSascha Wildner
8485db2f26eSSascha Wildner /* Perform the transaction(s), based on Width. */
8495db2f26eSSascha Wildner EcAddr = Address;
8505db2f26eSSascha Wildner EcData = (UINT8 *)Value;
8515db2f26eSSascha Wildner if (Function == ACPI_READ)
8525db2f26eSSascha Wildner *Value = 0;
8535db2f26eSSascha Wildner do {
8545db2f26eSSascha Wildner switch (Function) {
8555db2f26eSSascha Wildner case ACPI_READ:
8565db2f26eSSascha Wildner Status = EcRead(sc, EcAddr, EcData);
8575db2f26eSSascha Wildner break;
8585db2f26eSSascha Wildner case ACPI_WRITE:
8595db2f26eSSascha Wildner Status = EcWrite(sc, EcAddr, *EcData);
8605db2f26eSSascha Wildner break;
8615db2f26eSSascha Wildner }
8625db2f26eSSascha Wildner if (ACPI_FAILURE(Status))
8635db2f26eSSascha Wildner break;
8645db2f26eSSascha Wildner EcAddr++;
8655db2f26eSSascha Wildner EcData++;
8665db2f26eSSascha Wildner } while (EcAddr < Address + Width / 8);
8675db2f26eSSascha Wildner
8685db2f26eSSascha Wildner if (sc->ec_burstactive) {
8695db2f26eSSascha Wildner sc->ec_burstactive = FALSE;
8706836e2b4SSascha Wildner if (ACPI_SUCCESS(EcCommand(sc, EC_COMMAND_BURST_DISABLE)))
8716836e2b4SSascha Wildner KTR_LOG(acpi_ec_burstdisok);
8725db2f26eSSascha Wildner }
8735db2f26eSSascha Wildner
8745db2f26eSSascha Wildner EcUnlock(sc);
8755db2f26eSSascha Wildner return_ACPI_STATUS (Status);
8765db2f26eSSascha Wildner }
8775db2f26eSSascha Wildner
8785db2f26eSSascha Wildner static ACPI_STATUS
EcWaitEvent(struct acpi_ec_softc * sc,EC_EVENT Event,u_int gen_count)8795db2f26eSSascha Wildner EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event, u_int gen_count)
8805db2f26eSSascha Wildner {
8815db2f26eSSascha Wildner static int no_intr = 0;
8825db2f26eSSascha Wildner ACPI_STATUS Status;
8835db2f26eSSascha Wildner int count, i, need_poll, slp_ival;
8845db2f26eSSascha Wildner
8855db2f26eSSascha Wildner ACPI_SERIAL_ASSERT(ec);
8865db2f26eSSascha Wildner Status = AE_NO_HARDWARE_RESPONSE;
8875db2f26eSSascha Wildner need_poll = cold || rebooting || ec_polled_mode || sc->ec_suspending;
8885db2f26eSSascha Wildner
8895db2f26eSSascha Wildner /* Wait for event by polling or GPE (interrupt). */
8905db2f26eSSascha Wildner if (need_poll) {
8915db2f26eSSascha Wildner count = (ec_timeout * 1000) / EC_POLL_DELAY;
8925db2f26eSSascha Wildner if (count == 0)
8935db2f26eSSascha Wildner count = 1;
8945db2f26eSSascha Wildner DELAY(10);
8955db2f26eSSascha Wildner for (i = 0; i < count; i++) {
8965db2f26eSSascha Wildner Status = EcCheckStatus(sc, "poll", Event);
897b08525dbSSascha Wildner if (ACPI_SUCCESS(Status))
8985db2f26eSSascha Wildner break;
8995db2f26eSSascha Wildner DELAY(EC_POLL_DELAY);
9005db2f26eSSascha Wildner }
9015db2f26eSSascha Wildner } else {
9025db2f26eSSascha Wildner slp_ival = hz / 1000;
9035db2f26eSSascha Wildner if (slp_ival != 0) {
9045db2f26eSSascha Wildner count = ec_timeout;
9055db2f26eSSascha Wildner } else {
9065db2f26eSSascha Wildner /* hz has less than 1 ms resolution so scale timeout. */
9075db2f26eSSascha Wildner slp_ival = 1;
9085db2f26eSSascha Wildner count = ec_timeout / (1000 / hz);
9095db2f26eSSascha Wildner }
9105db2f26eSSascha Wildner
9115db2f26eSSascha Wildner /*
9125db2f26eSSascha Wildner * Wait for the GPE to signal the status changed, checking the
9135db2f26eSSascha Wildner * status register each time we get one. It's possible to get a
9145db2f26eSSascha Wildner * GPE for an event we're not interested in here (i.e., SCI for
9155db2f26eSSascha Wildner * EC query).
9165db2f26eSSascha Wildner */
9175db2f26eSSascha Wildner for (i = 0; i < count; i++) {
9185db2f26eSSascha Wildner if (gen_count == sc->ec_gencount)
9195db2f26eSSascha Wildner tsleep(sc, 0, "ecgpe", slp_ival);
9205db2f26eSSascha Wildner /*
9215db2f26eSSascha Wildner * Record new generation count. It's possible the GPE was
9225db2f26eSSascha Wildner * just to notify us that a query is needed and we need to
9235db2f26eSSascha Wildner * wait for a second GPE to signal the completion of the
9245db2f26eSSascha Wildner * event we are actually waiting for.
9255db2f26eSSascha Wildner */
9265db2f26eSSascha Wildner Status = EcCheckStatus(sc, "sleep", Event);
927b08525dbSSascha Wildner if (ACPI_SUCCESS(Status)) {
9285db2f26eSSascha Wildner if (gen_count == sc->ec_gencount)
9295db2f26eSSascha Wildner no_intr++;
9305db2f26eSSascha Wildner else
9315db2f26eSSascha Wildner no_intr = 0;
9325db2f26eSSascha Wildner break;
9335db2f26eSSascha Wildner }
9345db2f26eSSascha Wildner gen_count = sc->ec_gencount;
9355db2f26eSSascha Wildner }
9365db2f26eSSascha Wildner
9375db2f26eSSascha Wildner /*
9385db2f26eSSascha Wildner * We finished waiting for the GPE and it never arrived. Try to
9395db2f26eSSascha Wildner * read the register once and trust whatever value we got. This is
9405db2f26eSSascha Wildner * the best we can do at this point.
9415db2f26eSSascha Wildner */
942b08525dbSSascha Wildner if (ACPI_FAILURE(Status))
9435db2f26eSSascha Wildner Status = EcCheckStatus(sc, "sleep_end", Event);
9445db2f26eSSascha Wildner }
9455db2f26eSSascha Wildner if (!need_poll && no_intr > 10) {
9465db2f26eSSascha Wildner device_printf(sc->ec_dev,
9475db2f26eSSascha Wildner "not getting interrupts, switched to polled mode\n");
9485db2f26eSSascha Wildner ec_polled_mode = 1;
9495db2f26eSSascha Wildner }
950f872b7caSMatthew Dillon if (ACPI_FAILURE(Status)) {
951f872b7caSMatthew Dillon ec_timeout = ec_timeout_backoff;
952f872b7caSMatthew Dillon if (ec_auto_silence > 0) {
953f872b7caSMatthew Dillon if (--ec_auto_silence <= 0)
954f872b7caSMatthew Dillon acpi_silence_all = 1;
955f872b7caSMatthew Dillon }
9566836e2b4SSascha Wildner KTR_LOG(acpi_ec_timeout);
957f872b7caSMatthew Dillon }
9585db2f26eSSascha Wildner return (Status);
9595db2f26eSSascha Wildner }
9605db2f26eSSascha Wildner
9615db2f26eSSascha Wildner static ACPI_STATUS
EcCommand(struct acpi_ec_softc * sc,EC_COMMAND cmd)9625db2f26eSSascha Wildner EcCommand(struct acpi_ec_softc *sc, EC_COMMAND cmd)
9635db2f26eSSascha Wildner {
9645db2f26eSSascha Wildner ACPI_STATUS status;
9655db2f26eSSascha Wildner EC_EVENT event;
9665db2f26eSSascha Wildner EC_STATUS ec_status;
9675db2f26eSSascha Wildner u_int gen_count;
9685db2f26eSSascha Wildner
9695db2f26eSSascha Wildner ACPI_SERIAL_ASSERT(ec);
9705db2f26eSSascha Wildner
9715db2f26eSSascha Wildner /* Don't use burst mode if user disabled it. */
9725db2f26eSSascha Wildner if (!ec_burst_mode && cmd == EC_COMMAND_BURST_ENABLE)
9735db2f26eSSascha Wildner return (AE_ERROR);
9745db2f26eSSascha Wildner
9755db2f26eSSascha Wildner /* Decide what to wait for based on command type. */
9765db2f26eSSascha Wildner switch (cmd) {
9775db2f26eSSascha Wildner case EC_COMMAND_READ:
9785db2f26eSSascha Wildner case EC_COMMAND_WRITE:
9795db2f26eSSascha Wildner case EC_COMMAND_BURST_DISABLE:
9805db2f26eSSascha Wildner event = EC_EVENT_INPUT_BUFFER_EMPTY;
9815db2f26eSSascha Wildner break;
9825db2f26eSSascha Wildner case EC_COMMAND_QUERY:
9835db2f26eSSascha Wildner case EC_COMMAND_BURST_ENABLE:
9845db2f26eSSascha Wildner event = EC_EVENT_OUTPUT_BUFFER_FULL;
9855db2f26eSSascha Wildner break;
9865db2f26eSSascha Wildner default:
9875db2f26eSSascha Wildner device_printf(sc->ec_dev, "EcCommand: invalid command %#x\n", cmd);
9885db2f26eSSascha Wildner return (AE_BAD_PARAMETER);
9895db2f26eSSascha Wildner }
9905db2f26eSSascha Wildner
9915db2f26eSSascha Wildner /*
9925db2f26eSSascha Wildner * Ensure empty input buffer before issuing command.
9935db2f26eSSascha Wildner * Use generation count of zero to force a quick check.
9945db2f26eSSascha Wildner */
9955db2f26eSSascha Wildner status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY, 0);
9965db2f26eSSascha Wildner if (ACPI_FAILURE(status))
9975db2f26eSSascha Wildner return (status);
9985db2f26eSSascha Wildner
9995db2f26eSSascha Wildner /* Run the command and wait for the chosen event. */
10006836e2b4SSascha Wildner KTR_LOG(acpi_ec_cmdrun, cmd);
10015db2f26eSSascha Wildner gen_count = sc->ec_gencount;
10025db2f26eSSascha Wildner EC_SET_CSR(sc, cmd);
10035db2f26eSSascha Wildner status = EcWaitEvent(sc, event, gen_count);
10045db2f26eSSascha Wildner if (ACPI_SUCCESS(status)) {
10055db2f26eSSascha Wildner /* If we succeeded, burst flag should now be present. */
10065db2f26eSSascha Wildner if (cmd == EC_COMMAND_BURST_ENABLE) {
10075db2f26eSSascha Wildner ec_status = EC_GET_CSR(sc);
10085db2f26eSSascha Wildner if ((ec_status & EC_FLAG_BURST_MODE) == 0)
10095db2f26eSSascha Wildner status = AE_ERROR;
10105db2f26eSSascha Wildner }
10115db2f26eSSascha Wildner } else
10125db2f26eSSascha Wildner device_printf(sc->ec_dev, "EcCommand: no response to %#x\n", cmd);
10135db2f26eSSascha Wildner return (status);
10145db2f26eSSascha Wildner }
10155db2f26eSSascha Wildner
10165db2f26eSSascha Wildner static ACPI_STATUS
EcRead(struct acpi_ec_softc * sc,UINT8 Address,UINT8 * Data)10175db2f26eSSascha Wildner EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
10185db2f26eSSascha Wildner {
10195db2f26eSSascha Wildner ACPI_STATUS status;
10205db2f26eSSascha Wildner u_int gen_count;
10215db2f26eSSascha Wildner int retry;
10225db2f26eSSascha Wildner
10235db2f26eSSascha Wildner ACPI_SERIAL_ASSERT(ec);
10246836e2b4SSascha Wildner KTR_LOG(acpi_ec_readaddr, Address);
10255db2f26eSSascha Wildner
10265db2f26eSSascha Wildner for (retry = 0; retry < 2; retry++) {
10275db2f26eSSascha Wildner status = EcCommand(sc, EC_COMMAND_READ);
10285db2f26eSSascha Wildner if (ACPI_FAILURE(status))
10295db2f26eSSascha Wildner return (status);
10305db2f26eSSascha Wildner
10315db2f26eSSascha Wildner gen_count = sc->ec_gencount;
10325db2f26eSSascha Wildner EC_SET_DATA(sc, Address);
10335db2f26eSSascha Wildner status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL, gen_count);
10345db2f26eSSascha Wildner if (ACPI_FAILURE(status)) {
1035b08525dbSSascha Wildner if (ACPI_SUCCESS(EcCheckStatus(sc, "retr_check",
1036b08525dbSSascha Wildner EC_EVENT_INPUT_BUFFER_EMPTY)))
10375db2f26eSSascha Wildner continue;
10385db2f26eSSascha Wildner else
10395db2f26eSSascha Wildner break;
10405db2f26eSSascha Wildner }
10415db2f26eSSascha Wildner *Data = EC_GET_DATA(sc);
10425db2f26eSSascha Wildner return (AE_OK);
10435db2f26eSSascha Wildner }
10445db2f26eSSascha Wildner device_printf(sc->ec_dev, "EcRead: failed waiting to get data\n");
10455db2f26eSSascha Wildner return (status);
10465db2f26eSSascha Wildner }
10475db2f26eSSascha Wildner
10485db2f26eSSascha Wildner static ACPI_STATUS
EcWrite(struct acpi_ec_softc * sc,UINT8 Address,UINT8 Data)10495db2f26eSSascha Wildner EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 Data)
10505db2f26eSSascha Wildner {
10515db2f26eSSascha Wildner ACPI_STATUS status;
10525db2f26eSSascha Wildner u_int gen_count;
10535db2f26eSSascha Wildner
10545db2f26eSSascha Wildner ACPI_SERIAL_ASSERT(ec);
10556836e2b4SSascha Wildner KTR_LOG(acpi_ec_writeaddr, Address, Data);
10565db2f26eSSascha Wildner
10575db2f26eSSascha Wildner status = EcCommand(sc, EC_COMMAND_WRITE);
10585db2f26eSSascha Wildner if (ACPI_FAILURE(status))
10595db2f26eSSascha Wildner return (status);
10605db2f26eSSascha Wildner
10615db2f26eSSascha Wildner gen_count = sc->ec_gencount;
10625db2f26eSSascha Wildner EC_SET_DATA(sc, Address);
10635db2f26eSSascha Wildner status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY, gen_count);
10645db2f26eSSascha Wildner if (ACPI_FAILURE(status)) {
10655db2f26eSSascha Wildner device_printf(sc->ec_dev, "EcWrite: failed waiting for sent address\n");
10665db2f26eSSascha Wildner return (status);
10675db2f26eSSascha Wildner }
10685db2f26eSSascha Wildner
10695db2f26eSSascha Wildner gen_count = sc->ec_gencount;
10705db2f26eSSascha Wildner EC_SET_DATA(sc, Data);
10715db2f26eSSascha Wildner status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY, gen_count);
10725db2f26eSSascha Wildner if (ACPI_FAILURE(status)) {
10735db2f26eSSascha Wildner device_printf(sc->ec_dev, "EcWrite: failed waiting for sent data\n");
10745db2f26eSSascha Wildner return (status);
10755db2f26eSSascha Wildner }
10765db2f26eSSascha Wildner
10775db2f26eSSascha Wildner return (AE_OK);
10785db2f26eSSascha Wildner }
1079