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

Cache object: b7b5ebd54a61cf1627cb0f151f4ea0c5


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