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

Cache object: 799ecfdb13436c937583c822d305da54


[ 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.