The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/acpica/acpi_ec.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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$");
   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
   50 ACPI_MODULE_NAME("EC")
   51 
   52 /*
   53  * EC_COMMAND:
   54  * -----------
   55  */
   56 typedef 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  */
   85 typedef 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  */
   96 typedef 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 */
  123 struct 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  */
  136 struct 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 
  180 ACPI_SERIAL_DECL(ec, "ACPI embedded controller");
  181 
  182 SYSCTL_DECL(_debug_acpi);
  183 SYSCTL_NODE(_debug_acpi, OID_AUTO, ec, CTLFLAG_RD, NULL, "EC debugging");
  184 
  185 static int      ec_burst_mode;
  186 TUNABLE_INT("debug.acpi.ec.burst", &ec_burst_mode);
  187 SYSCTL_INT(_debug_acpi_ec, OID_AUTO, burst, CTLFLAG_RW, &ec_burst_mode, 0,
  188     "Enable use of burst mode (faster for nearly all systems)");
  189 static int      ec_polled_mode;
  190 TUNABLE_INT("debug.acpi.ec.polled", &ec_polled_mode);
  191 SYSCTL_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)");
  193 static int      ec_timeout = EC_TIMEOUT;
  194 TUNABLE_INT("debug.acpi.ec.timeout", &ec_timeout);
  195 SYSCTL_INT(_debug_acpi_ec, OID_AUTO, timeout, CTLFLAG_RW, &ec_timeout,
  196     EC_TIMEOUT, "Total time spent waiting for a response (poll+sleep)");
  197 
  198 static ACPI_STATUS
  199 EcLock(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 
  214 static void
  215 EcUnlock(struct acpi_ec_softc *sc)
  216 {
  217     ACPI_SERIAL_END(ec);
  218     if (sc->ec_glk)
  219         AcpiReleaseGlobalLock(sc->ec_glkhandle);
  220 }
  221 
  222 static uint32_t         EcGpeHandler(void *Context);
  223 static ACPI_STATUS      EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function,
  224                                 void *Context, void **return_Context);
  225 static ACPI_STATUS      EcSpaceHandler(UINT32 Function,
  226                                 ACPI_PHYSICAL_ADDRESS Address,
  227                                 UINT32 width, ACPI_INTEGER *Value,
  228                                 void *Context, void *RegionContext);
  229 static ACPI_STATUS      EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event,
  230                                 u_int gen_count);
  231 static ACPI_STATUS      EcCommand(struct acpi_ec_softc *sc, EC_COMMAND cmd);
  232 static ACPI_STATUS      EcRead(struct acpi_ec_softc *sc, UINT8 Address,
  233                                 UINT8 *Data);
  234 static ACPI_STATUS      EcWrite(struct acpi_ec_softc *sc, UINT8 Address,
  235                                 UINT8 *Data);
  236 static int              acpi_ec_probe(device_t dev);
  237 static int              acpi_ec_attach(device_t dev);
  238 static int              acpi_ec_suspend(device_t dev);
  239 static int              acpi_ec_resume(device_t dev);
  240 static int              acpi_ec_shutdown(device_t dev);
  241 static int              acpi_ec_read_method(device_t dev, u_int addr,
  242                                 ACPI_INTEGER *val, int width);
  243 static int              acpi_ec_write_method(device_t dev, u_int addr,
  244                                 ACPI_INTEGER val, int width);
  245 
  246 static 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 
  261 static driver_t acpi_ec_driver = {
  262     "acpi_ec",
  263     acpi_ec_methods,
  264     sizeof(struct acpi_ec_softc),
  265 };
  266 
  267 static devclass_t acpi_ec_devclass;
  268 DRIVER_MODULE(acpi_ec, acpi, acpi_ec_driver, acpi_ec_devclass, 0, 0);
  269 MODULE_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  */
  279 void
  280 acpi_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 
  340 static int
  341 acpi_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 
  436 out:
  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 
  451 static int
  452 acpi_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 
  538 error:
  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 
  551 static int
  552 acpi_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 
  561 static int
  562 acpi_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 
  571 static int
  572 acpi_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. */
  583 static int
  584 acpi_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 
  596 static int
  597 acpi_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 
  609 static void
  610 EcGpeQueryHandler(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  */
  671 static uint32_t
  672 EcGpeHandler(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 
  706 static ACPI_STATUS
  707 EcSpaceSetup(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 
  725 static ACPI_STATUS
  726 EcSpaceHandler(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) {
  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 
  788 static ACPI_STATUS
  789 EcCheckStatus(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 
  807 static ACPI_STATUS
  808 EcWaitEvent(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 
  903 static ACPI_STATUS
  904 EcCommand(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 
  950 static ACPI_STATUS
  951 EcRead(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 
  994 static ACPI_STATUS
  995 EcWrite(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 }

Cache object: 2fd85bacc4355cd890d9aae84231d6ce


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.