sys/dev/acpica/acpi_ec.c

   1 /*-
   2  * Copyright (c) 2003 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  ******************************************************************************
  30  *
  31  * 1. Copyright Notice
  32  *
  33  * Some or all of this work - Copyright (c) 1999, Intel Corp.  All rights
  34  * reserved.
  35  *
  36  * 2. License
  37  *
  38  * 2.1. This is your license from Intel Corp. under its intellectual property
  39  * rights.  You may have additional license terms from the party that provided
  40  * you this software, covering your right to use that party's intellectual
  41  * property rights.
  42  *
  43  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  44  * copy of the source code appearing in this file ("Covered Code") an
  45  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  46  * base code distributed originally by Intel ("Original Intel Code") to copy,
  47  * make derivatives, distribute, use and display any portion of the Covered
  48  * Code in any form, with the right to sublicense such rights; and
  49  *
  50  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  51  * license (with the right to sublicense), under only those claims of Intel
  52  * patents that are infringed by the Original Intel Code, to make, use, sell,
  53  * offer to sell, and import the Covered Code and derivative works thereof
  54  * solely to the minimum extent necessary to exercise the above copyright
  55  * license, and in no event shall the patent license extend to any additions
  56  * to or modifications of the Original Intel Code.  No other license or right
  57  * is granted directly or by implication, estoppel or otherwise;
  58  *
  59  * The above copyright and patent license is granted only if the following
  60  * conditions are met:
  61  *
  62  * 3. Conditions
  63  *
  64  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  65  * Redistribution of source code of any substantial portion of the Covered
  66  * Code or modification with rights to further distribute source must include
  67  * the above Copyright Notice, the above License, this list of Conditions,
  68  * and the following Disclaimer and Export Compliance provision.  In addition,
  69  * Licensee must cause all Covered Code to which Licensee contributes to
  70  * contain a file documenting the changes Licensee made to create that Covered
  71  * Code and the date of any change.  Licensee must include in that file the
  72  * documentation of any changes made by any predecessor Licensee.  Licensee
  73  * must include a prominent statement that the modification is derived,
  74  * directly or indirectly, from Original Intel Code.
  75  *
  76  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  77  * Redistribution of source code of any substantial portion of the Covered
  78  * Code or modification without rights to further distribute source must
  79  * include the following Disclaimer and Export Compliance provision in the
  80  * documentation and/or other materials provided with distribution.  In
  81  * addition, Licensee may not authorize further sublicense of source of any
  82  * portion of the Covered Code, and must include terms to the effect that the
  83  * license from Licensee to its licensee is limited to the intellectual
  84  * property embodied in the software Licensee provides to its licensee, and
  85  * not to intellectual property embodied in modifications its licensee may
  86  * make.
  87  *
  88  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  89  * substantial portion of the Covered Code or modification must reproduce the
  90  * above Copyright Notice, and the following Disclaimer and Export Compliance
  91  * provision in the documentation and/or other materials provided with the
  92  * distribution.
  93  *
  94  * 3.4. Intel retains all right, title, and interest in and to the Original
  95  * Intel Code.
  96  *
  97  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  98  * Intel shall be used in advertising or otherwise to promote the sale, use or
  99  * other dealings in products derived from or relating to the Covered Code
 100  * without prior written authorization from Intel.
 101  *
 102  * 4. Disclaimer and Export Compliance
 103  *
 104  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
 105  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
 106  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
 107  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
 108  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
 109  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
 110  * PARTICULAR PURPOSE.
 111  *
 112  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
 113  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
 114  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
 115  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
 116  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
 117  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
 118  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
 119  * LIMITED REMEDY.
 120  *
 121  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 122  * software or system incorporating such software without first obtaining any
 123  * required license or other approval from the U. S. Department of Commerce or
 124  * any other agency or department of the United States Government.  In the
 125  * event Licensee exports any such software from the United States or
 126  * re-exports any such software from a foreign destination, Licensee shall
 127  * ensure that the distribution and export/re-export of the software is in
 128  * compliance with all laws, regulations, orders, or other restrictions of the
 129  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 130  * any of its subsidiaries will export/re-export any technical data, process,
 131  * software, or service, directly or indirectly, to any country for which the
 132  * United States government or any agency thereof requires an export license,
 133  * other governmental approval, or letter of assurance, without first obtaining
 134  * such license, approval or letter.
 135  *
 136  *****************************************************************************/
 137
 138 #include <sys/cdefs.h>
 139 __FBSDID("$FreeBSD$");
 140
 141 #include "opt_acpi.h"
 142 #include <sys/param.h>
 143 #include <sys/kernel.h>
 144 #include <sys/bus.h>
 145 #include <sys/lock.h>
 146 #include <sys/malloc.h>
 147 #include <sys/module.h>
 148 #include <sys/sx.h>
 149
 150 #include <machine/bus.h>
 151 #include <machine/resource.h>
 152 #include <sys/rman.h>
 153
 154 #include <contrib/dev/acpica/acpi.h>
 155 #include <dev/acpica/acpivar.h>
 156
 157 /* Hooks for the ACPI CA debugging infrastructure */
 158 #define _COMPONENT      ACPI_EC
 159 ACPI_MODULE_NAME("EC")
 160
 161 /*
 162  * EC_COMMAND:
 163  * -----------
 164  */
 165 typedef UINT8                           EC_COMMAND;
 166
 167 #define EC_COMMAND_UNKNOWN              ((EC_COMMAND) 0x00)
 168 #define EC_COMMAND_READ                 ((EC_COMMAND) 0x80)
 169 #define EC_COMMAND_WRITE                ((EC_COMMAND) 0x81)
 170 #define EC_COMMAND_BURST_ENABLE         ((EC_COMMAND) 0x82)
 171 #define EC_COMMAND_BURST_DISABLE        ((EC_COMMAND) 0x83)
 172 #define EC_COMMAND_QUERY                ((EC_COMMAND) 0x84)
 173
 174 /*
 175  * EC_STATUS:
 176  * ----------
 177  * The encoding of the EC status register is illustrated below.
 178  * Note that a set bit (1) indicates the property is TRUE
 179  * (e.g. if bit 0 is set then the output buffer is full).
 180  * +-+-+-+-+-+-+-+-+
 181  * |7|6|5|4|3|2|1|0|
 182  * +-+-+-+-+-+-+-+-+
 183  *  | | | | | | | |
 184  *  | | | | | | | +- Output Buffer Full?
 185  *  | | | | | | +--- Input Buffer Full?
 186  *  | | | | | +----- <reserved>
 187  *  | | | | +------- Data Register is Command Byte?
 188  *  | | | +--------- Burst Mode Enabled?
 189  *  | | +----------- SCI Event?
 190  *  | +------------- SMI Event?
 191  *  +--------------- <reserved>
 192  *
 193  */
 194 typedef UINT8                           EC_STATUS;
 195
 196 #define EC_FLAG_OUTPUT_BUFFER           ((EC_STATUS) 0x01)
 197 #define EC_FLAG_INPUT_BUFFER            ((EC_STATUS) 0x02)
 198 #define EC_FLAG_DATA_IS_CMD             ((EC_STATUS) 0x08)
 199 #define EC_FLAG_BURST_MODE              ((EC_STATUS) 0x10)
 200
 201 /*
 202  * EC_EVENT:
 203  * ---------
 204  */
 205 typedef UINT8                           EC_EVENT;
 206
 207 #define EC_EVENT_UNKNOWN                ((EC_EVENT) 0x00)
 208 #define EC_EVENT_OUTPUT_BUFFER_FULL     ((EC_EVENT) 0x01)
 209 #define EC_EVENT_INPUT_BUFFER_EMPTY     ((EC_EVENT) 0x02)
 210 #define EC_EVENT_SCI                    ((EC_EVENT) 0x20)
 211 #define EC_EVENT_SMI                    ((EC_EVENT) 0x40)
 212
 213 /* Data byte returned after burst enable indicating it was successful. */
 214 #define EC_BURST_ACK                    0x90
 215
 216 /*
 217  * Register access primitives
 218  */
 219 #define EC_GET_DATA(sc)                                                 \
 220         bus_space_read_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0)
 221
 222 #define EC_SET_DATA(sc, v)                                              \
 223         bus_space_write_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0, (v))
 224
 225 #define EC_GET_CSR(sc)                                                  \
 226         bus_space_read_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0)
 227
 228 #define EC_SET_CSR(sc, v)                                               \
 229         bus_space_write_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0, (v))
 230
 231 /* Additional params to pass from the probe routine */
 232 struct acpi_ec_params {
 233     int         glk;
 234     int         gpe_bit;
 235     ACPI_HANDLE gpe_handle;
 236     int         uid;
 237 };
 238
 239 /* Indicate that this device has already been probed via ECDT. */
 240 #define DEV_ECDT(x)             (acpi_get_magic(x) == (int)&acpi_ec_devclass)
 241
 242 /*
 243  * Driver softc.
 244  */
 245 struct acpi_ec_softc {
 246     device_t            ec_dev;
 247     ACPI_HANDLE         ec_handle;
 248     int                 ec_uid;
 249     ACPI_HANDLE         ec_gpehandle;
 250     UINT8               ec_gpebit;
 251     UINT8               ec_csrvalue;
 252
 253     int                 ec_data_rid;
 254     struct resource     *ec_data_res;
 255     bus_space_tag_t     ec_data_tag;
 256     bus_space_handle_t  ec_data_handle;
 257
 258     int                 ec_csr_rid;
 259     struct resource     *ec_csr_res;
 260     bus_space_tag_t     ec_csr_tag;
 261     bus_space_handle_t  ec_csr_handle;
 262
 263     struct mtx          ec_mtx;
 264     int                 ec_glk;
 265     int                 ec_glkhandle;
 266     int                 ec_burstactive;
 267     int                 ec_sci_pend;
 268 };
 269
 270 /*
 271  * XXX njl
 272  * I couldn't find it in the spec but other implementations also use a
 273  * value of 1 ms for the time to acquire global lock.
 274  */
 275 #define EC_LOCK_TIMEOUT 1000
 276
 277 /* Default delay in microseconds between each run of the status polling loop. */
 278 #define EC_POLL_DELAY   10
 279
 280 /* Default time in microseconds spent polling before sleep waiting. */
 281 #define EC_POLL_TIME    500
 282
 283 /* Total time in ms spent waiting for a response from EC. */
 284 #define EC_TIMEOUT      500
 285
 286 #define EVENT_READY(event, status)                      \
 287         (((event) == EC_EVENT_OUTPUT_BUFFER_FULL &&     \
 288          ((status) & EC_FLAG_OUTPUT_BUFFER) != 0) ||    \
 289          ((event) == EC_EVENT_INPUT_BUFFER_EMPTY &&     \
 290          ((status) & EC_FLAG_INPUT_BUFFER) == 0))
 291
 292 ACPI_SERIAL_DECL(ec, "ACPI embedded controller");
 293
 294 SYSCTL_DECL(_debug_acpi);
 295 SYSCTL_NODE(_debug_acpi, OID_AUTO, ec, CTLFLAG_RD, NULL, "EC debugging");
 296
 297 static int      ec_burst_mode;
 298 TUNABLE_INT("debug.acpi.ec.burst", &ec_burst_mode);
 299 SYSCTL_INT(_debug_acpi_ec, OID_AUTO, burst, CTLFLAG_RW, &ec_burst_mode, 0,
 300     "Enable use of burst mode (faster for nearly all systems)");
 301 static int      ec_poll_time = EC_POLL_TIME;
 302 TUNABLE_INT("debug.acpi.ec.poll_time", &ec_poll_time);
 303 SYSCTL_INT(_debug_acpi_ec, OID_AUTO, poll_time, CTLFLAG_RW, &ec_poll_time,
 304     EC_POLL_TIME, "Time spent polling vs. sleeping (CPU intensive)");
 305 static int      ec_timeout = EC_TIMEOUT;
 306 TUNABLE_INT("debug.acpi.ec.timeout", &ec_timeout);
 307 SYSCTL_INT(_debug_acpi_ec, OID_AUTO, timeout, CTLFLAG_RW, &ec_timeout,
 308     EC_TIMEOUT, "Total time spent waiting for a response (poll+sleep)");
 309
 310 static __inline ACPI_STATUS
 311 EcLock(struct acpi_ec_softc *sc, int serialize)
 312 {
 313     ACPI_STATUS status;
 314
 315     /*
 316      * If caller is executing a series of commands, acquire the exclusive lock
 317      * to serialize with other users.
 318      * To sync with bottom-half interrupt handler, always acquire the mutex.
 319      */
 320     status = AE_OK;
 321     if (serialize)
 322         ACPI_SERIAL_BEGIN(ec);
 323     mtx_lock(&sc->ec_mtx);
 324
 325     /* If _GLK is non-zero, also acquire the global lock. */
 326     if (sc->ec_glk) {
 327         status = AcpiAcquireGlobalLock(EC_LOCK_TIMEOUT, &sc->ec_glkhandle);
 328         if (ACPI_FAILURE(status)) {
 329             mtx_unlock(&sc->ec_mtx);
 330             if (serialize)
 331                 ACPI_SERIAL_END(ec);
 332         }
 333     }
 334
 335     return (status);
 336 }
 337
 338 static __inline void
 339 EcUnlock(struct acpi_ec_softc *sc)
 340 {
 341     if (sc->ec_glk)
 342         AcpiReleaseGlobalLock(sc->ec_glkhandle);
 343     mtx_unlock(&sc->ec_mtx);
 344     if (sx_xlocked(&ec_sxlock))
 345         ACPI_SERIAL_END(ec);
 346 }
 347
 348 static uint32_t         EcGpeHandler(void *Context);
 349 static ACPI_STATUS      EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function,
 350                                 void *Context, void **return_Context);
 351 static ACPI_STATUS      EcSpaceHandler(UINT32 Function,
 352                                 ACPI_PHYSICAL_ADDRESS Address,
 353                                 UINT32 width, ACPI_INTEGER *Value,
 354                                 void *Context, void *RegionContext);
 355 static ACPI_STATUS      EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event);
 356 static ACPI_STATUS      EcCommand(struct acpi_ec_softc *sc, EC_COMMAND cmd);
 357 static ACPI_STATUS      EcRead(struct acpi_ec_softc *sc, UINT8 Address,
 358                                 UINT8 *Data);
 359 static ACPI_STATUS      EcWrite(struct acpi_ec_softc *sc, UINT8 Address,
 360                                 UINT8 *Data);
 361 static int              acpi_ec_probe(device_t dev);
 362 static int              acpi_ec_attach(device_t dev);
 363 static int              acpi_ec_shutdown(device_t dev);
 364 static int              acpi_ec_read_method(device_t dev, u_int addr,
 365                                 ACPI_INTEGER *val, int width);
 366 static int              acpi_ec_write_method(device_t dev, u_int addr,
 367                                 ACPI_INTEGER val, int width);
 368
 369 static device_method_t acpi_ec_methods[] = {
 370     /* Device interface */
 371     DEVMETHOD(device_probe,     acpi_ec_probe),
 372     DEVMETHOD(device_attach,    acpi_ec_attach),
 373     DEVMETHOD(device_shutdown,  acpi_ec_shutdown),
 374
 375     /* Embedded controller interface */
 376     DEVMETHOD(acpi_ec_read,     acpi_ec_read_method),
 377     DEVMETHOD(acpi_ec_write,    acpi_ec_write_method),
 378
 379     {0, 0}
 380 };
 381
 382 static driver_t acpi_ec_driver = {
 383     "acpi_ec",
 384     acpi_ec_methods,
 385     sizeof(struct acpi_ec_softc),
 386 };
 387
 388 static devclass_t acpi_ec_devclass;
 389 DRIVER_MODULE(acpi_ec, acpi, acpi_ec_driver, acpi_ec_devclass, 0, 0);
 390 MODULE_DEPEND(acpi_ec, acpi, 1, 1, 1);
 391
 392 /*
 393  * Look for an ECDT and if we find one, set up default GPE and
 394  * space handlers to catch attempts to access EC space before
 395  * we have a real driver instance in place.
 396  * TODO: if people report invalid ECDTs, add a tunable to disable them.
 397  */
 398 void
 399 acpi_ec_ecdt_probe(device_t parent)
 400 {
 401     ACPI_TABLE_ECDT *ecdt;
 402     ACPI_STATUS      status;
 403     device_t         child;
 404     ACPI_HANDLE      h;
 405     struct acpi_ec_params *params;
 406
 407     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 408
 409     /* Find and validate the ECDT. */
 410     status = AcpiGetTable(ACPI_SIG_ECDT, 1, (ACPI_TABLE_HEADER **)&ecdt);
 411     if (ACPI_FAILURE(status) ||
 412         ecdt->Control.BitWidth != 8 ||
 413         ecdt->Data.BitWidth != 8) {
 414         return;
 415     }
 416
 417     /* Create the child device with the given unit number. */
 418     child = BUS_ADD_CHILD(parent, 0, "acpi_ec", ecdt->Uid);
 419     if (child == NULL) {
 420         printf("%s: can't add child\n", __func__);
 421         return;
 422     }
 423
 424     /* Find and save the ACPI handle for this device. */
 425     status = AcpiGetHandle(NULL, ecdt->Id, &h);
 426     if (ACPI_FAILURE(status)) {
 427         device_delete_child(parent, child);
 428         printf("%s: can't get handle\n", __func__);
 429         return;
 430     }
 431     acpi_set_handle(child, h);
 432
 433     /* Set the data and CSR register addresses. */
 434     bus_set_resource(child, SYS_RES_IOPORT, 0, ecdt->Data.Address,
 435         /*count*/1);
 436     bus_set_resource(child, SYS_RES_IOPORT, 1, ecdt->Control.Address,
 437         /*count*/1);
 438
 439     /*
 440      * Store values for the probe/attach routines to use.  Store the
 441      * ECDT GPE bit and set the global lock flag according to _GLK.
 442      * Note that it is not perfectly correct to be evaluating a method
 443      * before initializing devices, but in practice this function
 444      * should be safe to call at this point.
 445      */
 446     params = malloc(sizeof(struct acpi_ec_params), M_TEMP, M_WAITOK | M_ZERO);
 447     params->gpe_handle = NULL;
 448     params->gpe_bit = ecdt->Gpe;
 449     params->uid = ecdt->Uid;
 450     acpi_GetInteger(h, "_GLK", &params->glk);
 451     acpi_set_private(child, params);
 452     acpi_set_magic(child, (int)&acpi_ec_devclass);
 453
 454     /* Finish the attach process. */
 455     if (device_probe_and_attach(child) != 0)
 456         device_delete_child(parent, child);
 457 }
 458
 459 static int
 460 acpi_ec_probe(device_t dev)
 461 {
 462     ACPI_BUFFER buf;
 463     ACPI_HANDLE h;
 464     ACPI_OBJECT *obj;
 465     ACPI_STATUS status;
 466     device_t    peer;
 467     char        desc[64];
 468     int         ret;
 469     struct acpi_ec_params *params;
 470     static char *ec_ids[] = { "PNP0C09", NULL };
 471
 472     /* Check that this is a device and that EC is not disabled. */
 473     if (acpi_get_type(dev) != ACPI_TYPE_DEVICE || acpi_disabled("ec"))
 474         return (ENXIO);
 475
 476     /*
 477      * If probed via ECDT, set description and continue.  Otherwise,
 478      * we can access the namespace and make sure this is not a
 479      * duplicate probe.
 480      */
 481     ret = ENXIO;
 482     params = NULL;
 483     buf.Pointer = NULL;
 484     buf.Length = ACPI_ALLOCATE_BUFFER;
 485     if (DEV_ECDT(dev)) {
 486         params = acpi_get_private(dev);
 487         ret = 0;
 488     } else if (!acpi_disabled("ec") &&
 489         ACPI_ID_PROBE(device_get_parent(dev), dev, ec_ids)) {
 490         params = malloc(sizeof(struct acpi_ec_params), M_TEMP,
 491                         M_WAITOK | M_ZERO);
 492         h = acpi_get_handle(dev);
 493
 494         /*
 495          * Read the unit ID to check for duplicate attach and the
 496          * global lock value to see if we should acquire it when
 497          * accessing the EC.
 498          */
 499         status = acpi_GetInteger(h, "_UID", &params->uid);
 500         if (ACPI_FAILURE(status))
 501             params->uid = 0;
 502         status = acpi_GetInteger(h, "_GLK", &params->glk);
 503         if (ACPI_FAILURE(status))
 504             params->glk = 0;
 505
 506         /*
 507          * Evaluate the _GPE method to find the GPE bit used by the EC to
 508          * signal status (SCI).  If it's a package, it contains a reference
 509          * and GPE bit, similar to _PRW.
 510          */
 511         status = AcpiEvaluateObject(h, "_GPE", NULL, &buf);
 512         if (ACPI_FAILURE(status)) {
 513             device_printf(dev, "can't evaluate _GPE - %s\n",
 514                           AcpiFormatException(status));
 515             goto out;
 516         }
 517         obj = (ACPI_OBJECT *)buf.Pointer;
 518         if (obj == NULL)
 519             goto out;
 520
 521         switch (obj->Type) {
 522         case ACPI_TYPE_INTEGER:
 523             params->gpe_handle = NULL;
 524             params->gpe_bit = obj->Integer.Value;
 525             break;
 526         case ACPI_TYPE_PACKAGE:
 527             if (!ACPI_PKG_VALID(obj, 2))
 528                 goto out;
 529             params->gpe_handle =
 530                 acpi_GetReference(NULL, &obj->Package.Elements[0]);
 531             if (params->gpe_handle == NULL ||
 532                 acpi_PkgInt32(obj, 1, &params->gpe_bit) != 0)
 533                 goto out;
 534             break;
 535         default:
 536             device_printf(dev, "_GPE has invalid type %d\n", obj->Type);
 537             goto out;
 538         }
 539
 540         /* Store the values we got from the namespace for attach. */
 541         acpi_set_private(dev, params);
 542
 543         /*
 544          * Check for a duplicate probe.  This can happen when a probe
 545          * via ECDT succeeded already.  If this is a duplicate, disable
 546          * this device.
 547          */
 548         peer = devclass_get_device(acpi_ec_devclass, params->uid);
 549         if (peer == NULL || !device_is_alive(peer))
 550             ret = 0;
 551         else
 552             device_disable(dev);
 553     }
 554
 555 out:
 556     if (ret == 0) {
 557         snprintf(desc, sizeof(desc), "Embedded Controller: GPE %#x%s%s",
 558                  params->gpe_bit, (params->glk) ? ", GLK" : "",
 559                  DEV_ECDT(dev) ? ", ECDT" : "");
 560         device_set_desc_copy(dev, desc);
 561     }
 562
 563     if (ret > 0 && params)
 564         free(params, M_TEMP);
 565     if (buf.Pointer)
 566         AcpiOsFree(buf.Pointer);
 567     return (ret);
 568 }
 569
 570 static int
 571 acpi_ec_attach(device_t dev)
 572 {
 573     struct acpi_ec_softc        *sc;
 574     struct acpi_ec_params       *params;
 575     ACPI_STATUS                 Status;
 576
 577     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 578
 579     /* Fetch/initialize softc (assumes softc is pre-zeroed). */
 580     sc = device_get_softc(dev);
 581     params = acpi_get_private(dev);
 582     sc->ec_dev = dev;
 583     sc->ec_handle = acpi_get_handle(dev);
 584     mtx_init(&sc->ec_mtx, "ACPI EC lock", NULL, MTX_DEF);
 585
 586     /* Retrieve previously probed values via device ivars. */
 587     sc->ec_glk = params->glk;
 588     sc->ec_gpebit = params->gpe_bit;
 589     sc->ec_gpehandle = params->gpe_handle;
 590     sc->ec_uid = params->uid;
 591     free(params, M_TEMP);
 592
 593     /* Attach bus resources for data and command/status ports. */
 594     sc->ec_data_rid = 0;
 595     sc->ec_data_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
 596                         &sc->ec_data_rid, RF_ACTIVE);
 597     if (sc->ec_data_res == NULL) {
 598         device_printf(dev, "can't allocate data port\n");
 599         goto error;
 600     }
 601     sc->ec_data_tag = rman_get_bustag(sc->ec_data_res);
 602     sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res);
 603
 604     sc->ec_csr_rid = 1;
 605     sc->ec_csr_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
 606                         &sc->ec_csr_rid, RF_ACTIVE);
 607     if (sc->ec_csr_res == NULL) {
 608         device_printf(dev, "can't allocate command/status port\n");
 609         goto error;
 610     }
 611     sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res);
 612     sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res);
 613
 614     /*
 615      * Install a handler for this EC's GPE bit.  We want edge-triggered
 616      * behavior.
 617      */
 618     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE handler\n"));
 619     Status = AcpiInstallGpeHandler(sc->ec_gpehandle, sc->ec_gpebit,
 620                 ACPI_GPE_EDGE_TRIGGERED, &EcGpeHandler, sc);
 621     if (ACPI_FAILURE(Status)) {
 622         device_printf(dev, "can't install GPE handler for %s - %s\n",
 623                       acpi_name(sc->ec_handle), AcpiFormatException(Status));
 624         goto error;
 625     }
 626
 627     /*
 628      * Install address space handler
 629      */
 630     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n"));
 631     Status = AcpiInstallAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
 632                 &EcSpaceHandler, &EcSpaceSetup, sc);
 633     if (ACPI_FAILURE(Status)) {
 634         device_printf(dev, "can't install address space handler for %s - %s\n",
 635                       acpi_name(sc->ec_handle), AcpiFormatException(Status));
 636         goto error;
 637     }
 638
 639     /* Enable runtime GPEs for the handler. */
 640     Status = AcpiSetGpeType(sc->ec_gpehandle, sc->ec_gpebit,
 641                             ACPI_GPE_TYPE_RUNTIME);
 642     if (ACPI_FAILURE(Status)) {
 643         device_printf(dev, "AcpiSetGpeType failed: %s\n",
 644                       AcpiFormatException(Status));
 645         goto error;
 646     }
 647     Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_NOT_ISR);
 648     if (ACPI_FAILURE(Status)) {
 649         device_printf(dev, "AcpiEnableGpe failed: %s\n",
 650                       AcpiFormatException(Status));
 651         goto error;
 652     }
 653
 654     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "acpi_ec_attach complete\n"));
 655     return (0);
 656
 657 error:
 658     AcpiRemoveGpeHandler(sc->ec_gpehandle, sc->ec_gpebit, &EcGpeHandler);
 659     AcpiRemoveAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
 660         EcSpaceHandler);
 661     if (sc->ec_csr_res)
 662         bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_csr_rid,
 663                              sc->ec_csr_res);
 664     if (sc->ec_data_res)
 665         bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_data_rid,
 666                              sc->ec_data_res);
 667     mtx_destroy(&sc->ec_mtx);
 668     return (ENXIO);
 669 }
 670
 671 static int
 672 acpi_ec_shutdown(device_t dev)
 673 {
 674     struct acpi_ec_softc        *sc;
 675
 676     /* Disable the GPE so we don't get EC events during shutdown. */
 677     sc = device_get_softc(dev);
 678     AcpiDisableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_NOT_ISR);
 679     return (0);
 680 }
 681
 682 /* Methods to allow other devices (e.g., smbat) to read/write EC space. */
 683 static int
 684 acpi_ec_read_method(device_t dev, u_int addr, ACPI_INTEGER *val, int width)
 685 {
 686     struct acpi_ec_softc *sc;
 687     ACPI_STATUS status;
 688
 689     sc = device_get_softc(dev);
 690     status = EcSpaceHandler(ACPI_READ, addr, width * 8, val, sc, NULL);
 691     if (ACPI_FAILURE(status))
 692         return (ENXIO);
 693     return (0);
 694 }
 695
 696 static int
 697 acpi_ec_write_method(device_t dev, u_int addr, ACPI_INTEGER val, int width)
 698 {
 699     struct acpi_ec_softc *sc;
 700     ACPI_STATUS status;
 701
 702     sc = device_get_softc(dev);
 703     status = EcSpaceHandler(ACPI_WRITE, addr, width * 8, &val, sc, NULL);
 704     if (ACPI_FAILURE(status))
 705         return (ENXIO);
 706     return (0);
 707 }
 708
 709 static void
 710 EcGpeQueryHandler(void *Context)
 711 {
 712     struct acpi_ec_softc        *sc = (struct acpi_ec_softc *)Context;
 713     UINT8                       Data;
 714     ACPI_STATUS                 Status;
 715     char                        qxx[5];
 716
 717     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 718     KASSERT(Context != NULL, ("EcGpeQueryHandler called with NULL"));
 719
 720     /* Serialize user access with EcSpaceHandler(). */
 721     Status = EcLock(sc, TRUE);
 722     if (ACPI_FAILURE(Status)) {
 723         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 724                     "GpeQuery lock error: %s\n", AcpiFormatException(Status));
 725         return;
 726     }
 727
 728     /*
 729      * Send a query command to the EC to find out which _Qxx call it
 730      * wants to make.  This command clears the SCI bit and also the
 731      * interrupt source since we are edge-triggered.
 732      */
 733     Status = EcCommand(sc, EC_COMMAND_QUERY);
 734     if (ACPI_FAILURE(Status)) {
 735         EcUnlock(sc);
 736         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 737                     "GPE query failed - %s\n", AcpiFormatException(Status));
 738         goto re_enable;
 739     }
 740     Data = EC_GET_DATA(sc);
 741     sc->ec_sci_pend = FALSE;
 742
 743     /* Drop locks before evaluating _Qxx method since it may trigger GPEs. */
 744     EcUnlock(sc);
 745
 746     /* Ignore the value for "no outstanding event". (13.3.5) */
 747     CTR2(KTR_ACPI, "ec query ok,%s running _Q%02x", Data ? "" : " not", Data);
 748     if (Data == 0)
 749         goto re_enable;
 750
 751     /* Evaluate _Qxx to respond to the controller. */
 752     snprintf(qxx, sizeof(qxx), "_Q%02x", Data);
 753     AcpiUtStrupr(qxx);
 754     Status = AcpiEvaluateObject(sc->ec_handle, qxx, NULL, NULL);
 755     if (ACPI_FAILURE(Status) && Status != AE_NOT_FOUND) {
 756         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 757                     "evaluation of GPE query method %s failed - %s\n",
 758                     qxx, AcpiFormatException(Status));
 759     }
 760
 761 re_enable:
 762     /* Re-enable the GPE event so we'll get future requests. */
 763     Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_ISR);
 764     if (ACPI_FAILURE(Status))
 765         printf("EcGpeQueryHandler: AcpiEnableEvent failed\n");
 766 }
 767
 768 /*
 769  * Handle a GPE.  Currently we only handle SCI events as others must
 770  * be handled by polling in EcWaitEvent().  This is because some ECs
 771  * treat events as level when they should be edge-triggered.
 772  */
 773 static uint32_t
 774 EcGpeHandler(void *Context)
 775 {
 776     struct acpi_ec_softc *sc = Context;
 777     ACPI_STATUS                Status;
 778     EC_STATUS                  EcStatus;
 779     int                        query_pend;
 780
 781     KASSERT(Context != NULL, ("EcGpeHandler called with NULL"));
 782
 783     /*
 784      * Disable further GPEs while we handle this one.  Since we are directly
 785      * called by ACPI-CA and it may have unknown locks held, we specify the
 786      * ACPI_ISR flag to keep it from acquiring any more mutexes (although
 787      * sleeping would be ok since we're in an ithread.)
 788      */
 789     AcpiDisableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_ISR);
 790
 791     /* For interrupt (GPE) handler, don't acquire serialization lock. */
 792     Status = EcLock(sc, FALSE);
 793     if (ACPI_FAILURE(Status)) {
 794         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 795                     "GpeQuery lock error: %s\n", AcpiFormatException(Status));
 796         return (-1);
 797     }
 798
 799     /*
 800      * If burst was active, but the status bit was cleared, the EC had to
 801      * exit burst mode for some reason.  Record this for later.
 802      */
 803     EcStatus = EC_GET_CSR(sc);
 804     if (sc->ec_burstactive && (EcStatus & EC_FLAG_BURST_MODE) == 0) {
 805         CTR0(KTR_ACPI, "ec burst disabled in query handler");
 806         sc->ec_burstactive = FALSE;
 807     }
 808
 809     /*
 810      * If the EC_SCI bit of the status register is not set, then pass
 811      * it along to any potential waiters as it may be an IBE/OBF event.
 812      * If it is set, queue a query handler.
 813      */
 814     query_pend = FALSE;
 815     if ((EcStatus & EC_EVENT_SCI) == 0) {
 816         CTR1(KTR_ACPI, "ec event was IBE/OBF, status %#x", EcStatus);
 817         sc->ec_csrvalue = EcStatus;
 818         wakeup(&sc->ec_csrvalue);
 819     } else if (!sc->ec_sci_pend) {
 820         /* SCI bit set and no pending query handler, so schedule one. */
 821         CTR0(KTR_ACPI, "ec queueing gpe handler");
 822         Status = AcpiOsExecute(OSL_GPE_HANDLER, EcGpeQueryHandler, Context);
 823         if (ACPI_SUCCESS(Status)) {
 824             sc->ec_sci_pend = TRUE;
 825             query_pend = TRUE;
 826         } else
 827             printf("Queuing GPE query handler failed.\n");
 828     }
 829
 830     /*
 831      * If we didn't queue a query handler, which will eventually re-enable
 832      * the GPE, re-enable it right now so we can get more events.
 833      */
 834     if (!query_pend) {
 835         Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_ISR);
 836         if (ACPI_FAILURE(Status))
 837             printf("EcGpeHandler: AcpiEnableGpe failed\n");
 838     }
 839
 840     EcUnlock(sc);
 841     return (0);
 842 }
 843
 844 static ACPI_STATUS
 845 EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context,
 846              void **RegionContext)
 847 {
 848
 849     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 850
 851     /*
 852      * If deactivating a region, always set the output to NULL.  Otherwise,
 853      * just pass the context through.
 854      */
 855     if (Function == ACPI_REGION_DEACTIVATE)
 856         *RegionContext = NULL;
 857     else
 858         *RegionContext = Context;
 859
 860     return_ACPI_STATUS (AE_OK);
 861 }
 862
 863 static ACPI_STATUS
 864 EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width,
 865                ACPI_INTEGER *Value, void *Context, void *RegionContext)
 866 {
 867     struct acpi_ec_softc        *sc = (struct acpi_ec_softc *)Context;
 868     ACPI_STATUS                 Status;
 869     UINT8                       EcAddr, EcData;
 870     int                         i;
 871
 872     ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Address);
 873
 874     if (width % 8 != 0 || Value == NULL || Context == NULL)
 875         return_ACPI_STATUS (AE_BAD_PARAMETER);
 876     if (Address + (width / 8) - 1 > 0xFF)
 877         return_ACPI_STATUS (AE_BAD_ADDRESS);
 878
 879     if (Function == ACPI_READ)
 880         *Value = 0;
 881     EcAddr = Address;
 882     Status = AE_ERROR;
 883
 884     /* Grab serialization lock to hold across command sequence. */
 885     Status = EcLock(sc, TRUE);
 886     if (ACPI_FAILURE(Status))
 887         return_ACPI_STATUS (Status);
 888
 889     /* Perform the transaction(s), based on width. */
 890     for (i = 0; i < width; i += 8, EcAddr++) {
 891         switch (Function) {
 892         case ACPI_READ:
 893             Status = EcRead(sc, EcAddr, &EcData);
 894             if (ACPI_SUCCESS(Status))
 895                 *Value |= ((ACPI_INTEGER)EcData) << i;
 896             break;
 897         case ACPI_WRITE:
 898             EcData = (UINT8)((*Value) >> i);
 899             Status = EcWrite(sc, EcAddr, &EcData);
 900             break;
 901         default:
 902             device_printf(sc->ec_dev, "invalid EcSpaceHandler function %d\n",
 903                           Function);
 904             Status = AE_BAD_PARAMETER;
 905             break;
 906         }
 907         if (ACPI_FAILURE(Status))
 908             break;
 909     }
 910
 911     EcUnlock(sc);
 912     return_ACPI_STATUS (Status);
 913 }
 914
 915 static ACPI_STATUS
 916 EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event)
 917 {
 918     EC_STATUS   EcStatus;
 919     ACPI_STATUS Status;
 920     int         count, i, retval, slp_ival;
 921
 922     ACPI_SERIAL_ASSERT(ec);
 923     Status = AE_NO_HARDWARE_RESPONSE;
 924     EcStatus = 0;
 925
 926     /*
 927      * Poll for up to ec_poll_time microseconds since many ECs complete
 928      * the command quickly, especially if in burst mode.
 929      */
 930 #if 0 /* Enable this as a possible workaround if EC times out. */
 931     AcpiOsStall(EC_POLL_DELAY);
 932 #endif
 933     count = ec_poll_time / EC_POLL_DELAY;
 934     if (count <= 0)
 935         count = 1;
 936     for (i = 0; i < count; i++) {
 937         EcStatus = EC_GET_CSR(sc);
 938         if (sc->ec_burstactive && (EcStatus & EC_FLAG_BURST_MODE) == 0) {
 939             CTR0(KTR_ACPI, "ec burst disabled in waitevent (poll)");
 940             sc->ec_burstactive = FALSE;
 941         }
 942         if (EVENT_READY(Event, EcStatus)) {
 943             CTR1(KTR_ACPI, "ec poll wait ready, status %#x", EcStatus);
 944             Status = AE_OK;
 945             break;
 946         }
 947         AcpiOsStall(EC_POLL_DELAY);
 948     }
 949
 950     /*
 951      * If we still don't have a response and we're up and running, wait up
 952      * to ec_timeout ms for completion, sleeping for chunks of 1 ms or the
 953      * smallest resolution hz supports.
 954      */
 955     slp_ival = 0;
 956     if (Status != AE_OK) {
 957         retval = ENXIO;
 958         if (!cold) {
 959             slp_ival = hz / 1000;
 960             if (slp_ival != 0) {
 961                 count = ec_timeout / slp_ival;
 962             } else {
 963                 /* hz has less than 1000 Hz resolution so scale timeout. */
 964                 slp_ival = 1;
 965                 count = ec_timeout / (1000 / hz);
 966             }
 967         } else
 968             count = ec_timeout;
 969         for (i = 0; i < count; i++) {
 970             if (retval != 0)
 971                 EcStatus = EC_GET_CSR(sc);
 972             else
 973                 EcStatus = sc->ec_csrvalue;
 974             if (sc->ec_burstactive && (EcStatus & EC_FLAG_BURST_MODE) == 0) {
 975                 CTR0(KTR_ACPI, "ec burst disabled in waitevent (slp)");
 976                 sc->ec_burstactive = FALSE;
 977             }
 978             if (EVENT_READY(Event, EcStatus)) {
 979                 CTR1(KTR_ACPI, "ec sleep wait ready, status %#x", EcStatus);
 980                 Status = AE_OK;
 981                 break;
 982             }
 983             if (!cold) {
 984                 retval = msleep(&sc->ec_csrvalue, &sc->ec_mtx, PZERO, "ecpoll",
 985                     slp_ival);
 986             } else
 987                 AcpiOsStall(1000);
 988         }
 989     }
 990
 991     return (Status);
 992 }
 993
 994 static ACPI_STATUS
 995 EcCommand(struct acpi_ec_softc *sc, EC_COMMAND cmd)
 996 {
 997     ACPI_STATUS status;
 998     EC_EVENT    event;
 999     EC_STATUS   ec_status;
1000
1001     ACPI_SERIAL_ASSERT(ec);
1002
1003     /* Don't use burst mode if user disabled it. */
1004     if (!ec_burst_mode && cmd == EC_COMMAND_BURST_ENABLE)
1005         return (AE_ERROR);
1006
1007     /* Decide what to wait for based on command type. */
1008     switch (cmd) {
1009     case EC_COMMAND_READ:
1010     case EC_COMMAND_WRITE:
1011     case EC_COMMAND_BURST_DISABLE:
1012         event = EC_EVENT_INPUT_BUFFER_EMPTY;
1013         break;
1014     case EC_COMMAND_QUERY:
1015     case EC_COMMAND_BURST_ENABLE:
1016         event = EC_EVENT_OUTPUT_BUFFER_FULL;
1017         break;
1018     default:
1019         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
1020                     "EcCommand: Invalid command %#x\n", cmd);
1021         return (AE_BAD_PARAMETER);
1022     }
1023
1024     /* Run the command and wait for the chosen event. */
1025     CTR1(KTR_ACPI, "ec running command %#x", cmd);
1026     EC_SET_CSR(sc, cmd);
1027     status = EcWaitEvent(sc, event);
1028     if (ACPI_SUCCESS(status)) {
1029         /* If we succeeded, burst flag should now be present. */
1030         if (cmd == EC_COMMAND_BURST_ENABLE) {
1031             ec_status = EC_GET_CSR(sc);
1032             if ((ec_status & EC_FLAG_BURST_MODE) == 0)
1033                 status = AE_ERROR;
1034         }
1035     } else {
1036         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
1037                     "EcCommand: no response to %#x\n", cmd);
1038     }
1039
1040     return (status);
1041 }
1042
1043 static ACPI_STATUS
1044 EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
1045 {
1046     ACPI_STATUS status;
1047     UINT8 data;
1048
1049     ACPI_SERIAL_ASSERT(ec);
1050     CTR1(KTR_ACPI, "ec read from %#x", Address);
1051
1052     /* If we can't start burst mode, continue anyway. */
1053     status = EcCommand(sc, EC_COMMAND_BURST_ENABLE);
1054     if (status == AE_OK) {
1055         data = EC_GET_DATA(sc);
1056         if (data == EC_BURST_ACK) {
1057             CTR0(KTR_ACPI, "ec burst enabled");
1058             sc->ec_burstactive = TRUE;
1059         }
1060     }
1061
1062     status = EcCommand(sc, EC_COMMAND_READ);
1063     if (ACPI_FAILURE(status))
1064         return (status);
1065
1066     EC_SET_DATA(sc, Address);
1067     status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL);
1068     if (ACPI_FAILURE(status)) {
1069         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
1070                     "EcRead: Failed waiting for EC to send data.\n");
1071         return (status);
1072     }
1073
1074     *Data = EC_GET_DATA(sc);
1075
1076     if (sc->ec_burstactive) {
1077         status = EcCommand(sc, EC_COMMAND_BURST_DISABLE);
1078         if (ACPI_FAILURE(status))
1079             return (status);
1080         sc->ec_burstactive = FALSE;
1081         CTR0(KTR_ACPI, "ec disabled burst ok");
1082     }
1083
1084     return (AE_OK);
1085 }
1086
1087 static ACPI_STATUS
1088 EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
1089 {
1090     ACPI_STATUS status;
1091     UINT8 data;
1092
1093     ACPI_SERIAL_ASSERT(ec);
1094     CTR2(KTR_ACPI, "ec write to %#x, data %#x", Address, *Data);
1095
1096     /* If we can't start burst mode, continue anyway. */
1097     status = EcCommand(sc, EC_COMMAND_BURST_ENABLE);
1098     if (status == AE_OK) {
1099         data = EC_GET_DATA(sc);
1100         if (data == EC_BURST_ACK) {
1101             CTR0(KTR_ACPI, "ec burst enabled");
1102             sc->ec_burstactive = TRUE;
1103         }
1104     }
1105
1106     status = EcCommand(sc, EC_COMMAND_WRITE);
1107     if (ACPI_FAILURE(status))
1108         return (status);
1109
1110     EC_SET_DATA(sc, Address);
1111     status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY);
1112     if (ACPI_FAILURE(status)) {
1113         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
1114                     "EcRead: Failed waiting for EC to process address\n");
1115         return (status);
1116     }
1117
1118     EC_SET_DATA(sc, *Data);
1119     status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY);
1120     if (ACPI_FAILURE(status)) {
1121         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
1122                     "EcWrite: Failed waiting for EC to process data\n");
1123         return (status);
1124     }
1125
1126     if (sc->ec_burstactive) {
1127         status = EcCommand(sc, EC_COMMAND_BURST_DISABLE);
1128         if (ACPI_FAILURE(status))
1129             return (status);
1130         sc->ec_burstactive = FALSE;
1131         CTR0(KTR_ACPI, "ec disabled burst ok");
1132     }
1133
1134     return (AE_OK);
1135 }