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/malloc.h>
 146 #include <sys/module.h>
 147 #include <sys/sx.h>
 148
 149 #include <machine/bus.h>
 150 #include <machine/resource.h>
 151 #include <sys/rman.h>
 152
 153 #include <contrib/dev/acpica/acpi.h>
 154 #include <dev/acpica/acpivar.h>
 155
 156 /* Hooks for the ACPI CA debugging infrastructure */
 157 #define _COMPONENT      ACPI_EC
 158 ACPI_MODULE_NAME("EC")
 159
 160 /*
 161  * EC_COMMAND:
 162  * -----------
 163  */
 164 typedef UINT8                           EC_COMMAND;
 165
 166 #define EC_COMMAND_UNKNOWN              ((EC_COMMAND) 0x00)
 167 #define EC_COMMAND_READ                 ((EC_COMMAND) 0x80)
 168 #define EC_COMMAND_WRITE                ((EC_COMMAND) 0x81)
 169 #define EC_COMMAND_BURST_ENABLE         ((EC_COMMAND) 0x82)
 170 #define EC_COMMAND_BURST_DISABLE        ((EC_COMMAND) 0x83)
 171 #define EC_COMMAND_QUERY                ((EC_COMMAND) 0x84)
 172
 173 /*
 174  * EC_STATUS:
 175  * ----------
 176  * The encoding of the EC status register is illustrated below.
 177  * Note that a set bit (1) indicates the property is TRUE
 178  * (e.g. if bit 0 is set then the output buffer is full).
 179  * +-+-+-+-+-+-+-+-+
 180  * |7|6|5|4|3|2|1|0|
 181  * +-+-+-+-+-+-+-+-+
 182  *  | | | | | | | |
 183  *  | | | | | | | +- Output Buffer Full?
 184  *  | | | | | | +--- Input Buffer Full?
 185  *  | | | | | +----- <reserved>
 186  *  | | | | +------- Data Register is Command Byte?
 187  *  | | | +--------- Burst Mode Enabled?
 188  *  | | +----------- SCI Event?
 189  *  | +------------- SMI Event?
 190  *  +--------------- <Reserved>
 191  *
 192  */
 193 typedef UINT8                           EC_STATUS;
 194
 195 #define EC_FLAG_OUTPUT_BUFFER           ((EC_STATUS) 0x01)
 196 #define EC_FLAG_INPUT_BUFFER            ((EC_STATUS) 0x02)
 197 #define EC_FLAG_BURST_MODE              ((EC_STATUS) 0x10)
 198 #define EC_FLAG_SCI                     ((EC_STATUS) 0x20)
 199
 200 /*
 201  * EC_EVENT:
 202  * ---------
 203  */
 204 typedef UINT8                           EC_EVENT;
 205
 206 #define EC_EVENT_UNKNOWN                ((EC_EVENT) 0x00)
 207 #define EC_EVENT_OUTPUT_BUFFER_FULL     ((EC_EVENT) 0x01)
 208 #define EC_EVENT_INPUT_BUFFER_EMPTY     ((EC_EVENT) 0x02)
 209 #define EC_EVENT_SCI                    ((EC_EVENT) 0x20)
 210
 211 /*
 212  * Register access primitives
 213  */
 214 #define EC_GET_DATA(sc)                                                 \
 215         bus_space_read_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0)
 216
 217 #define EC_SET_DATA(sc, v)                                              \
 218         bus_space_write_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0, (v))
 219
 220 #define EC_GET_CSR(sc)                                                  \
 221         bus_space_read_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0)
 222
 223 #define EC_SET_CSR(sc, v)                                               \
 224         bus_space_write_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0, (v))
 225
 226 /* Embedded Controller Boot Resources Table (ECDT) */
 227 typedef struct {
 228     ACPI_TABLE_HEADER           header;
 229     ACPI_GENERIC_ADDRESS        control;
 230     ACPI_GENERIC_ADDRESS        data;
 231     UINT32                      uid;
 232     UINT8                       gpe_bit;
 233     char                        ec_id[0];
 234 } ACPI_TABLE_ECDT;
 235
 236 /* Additional params to pass from the probe routine */
 237 struct acpi_ec_params {
 238     int         glk;
 239     int         gpe_bit;
 240     ACPI_HANDLE gpe_handle;
 241     int         uid;
 242 };
 243
 244 /* Indicate that this device has already been probed via ECDT. */
 245 #define DEV_ECDT(x)             (acpi_get_magic(x) == (int)&acpi_ec_devclass)
 246
 247 /*
 248  * Driver softc.
 249  */
 250 struct acpi_ec_softc {
 251     device_t            ec_dev;
 252     ACPI_HANDLE         ec_handle;
 253     int                 ec_uid;
 254     ACPI_HANDLE         ec_gpehandle;
 255     UINT8               ec_gpebit;
 256     UINT8               ec_csrvalue;
 257
 258     int                 ec_data_rid;
 259     struct resource     *ec_data_res;
 260     bus_space_tag_t     ec_data_tag;
 261     bus_space_handle_t  ec_data_handle;
 262
 263     int                 ec_csr_rid;
 264     struct resource     *ec_csr_res;
 265     bus_space_tag_t     ec_csr_tag;
 266     bus_space_handle_t  ec_csr_handle;
 267
 268     int                 ec_glk;
 269     int                 ec_glkhandle;
 270 };
 271
 272 /*
 273  * XXX njl
 274  * I couldn't find it in the spec but other implementations also use a
 275  * value of 1 ms for the time to acquire global lock.
 276  */
 277 #define EC_LOCK_TIMEOUT 1000
 278
 279 /* Default interval in microseconds for the status polling loop. */
 280 #define EC_POLL_DELAY   10
 281
 282 /* Total time in ms spent in the poll loop waiting for a response. */
 283 #define EC_POLL_TIMEOUT 100
 284
 285 #define EVENT_READY(event, status)                      \
 286         (((event) == EC_EVENT_OUTPUT_BUFFER_FULL &&     \
 287          ((status) & EC_FLAG_OUTPUT_BUFFER) != 0) ||    \
 288          ((event) == EC_EVENT_INPUT_BUFFER_EMPTY &&     \
 289          ((status) & EC_FLAG_INPUT_BUFFER) == 0))
 290
 291 static int      ec_poll_timeout = EC_POLL_TIMEOUT;
 292 TUNABLE_INT("hw.acpi.ec.poll_timeout", &ec_poll_timeout);
 293
 294 ACPI_SERIAL_DECL(ec, "ACPI embedded controller");
 295
 296 static __inline ACPI_STATUS
 297 EcLock(struct acpi_ec_softc *sc)
 298 {
 299     ACPI_STATUS status;
 300
 301     /* Always acquire the exclusive lock. */
 302     status = AE_OK;
 303     ACPI_SERIAL_BEGIN(ec);
 304
 305     /* If _GLK is non-zero, also acquire the global lock. */
 306     if (sc->ec_glk) {
 307         status = AcpiAcquireGlobalLock(EC_LOCK_TIMEOUT, &sc->ec_glkhandle);
 308         if (ACPI_FAILURE(status))
 309             ACPI_SERIAL_END(ec);
 310     }
 311
 312     return (status);
 313 }
 314
 315 static __inline void
 316 EcUnlock(struct acpi_ec_softc *sc)
 317 {
 318     if (sc->ec_glk)
 319         AcpiReleaseGlobalLock(sc->ec_glkhandle);
 320     ACPI_SERIAL_END(ec);
 321 }
 322
 323 static uint32_t         EcGpeHandler(void *Context);
 324 static ACPI_STATUS      EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function,
 325                                 void *Context, void **return_Context);
 326 static ACPI_STATUS      EcSpaceHandler(UINT32 Function,
 327                                 ACPI_PHYSICAL_ADDRESS Address,
 328                                 UINT32 width, ACPI_INTEGER *Value,
 329                                 void *Context, void *RegionContext);
 330 static ACPI_STATUS      EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event);
 331 static ACPI_STATUS      EcCommand(struct acpi_ec_softc *sc, EC_COMMAND cmd);
 332 static ACPI_STATUS      EcRead(struct acpi_ec_softc *sc, UINT8 Address,
 333                                 UINT8 *Data);
 334 static ACPI_STATUS      EcWrite(struct acpi_ec_softc *sc, UINT8 Address,
 335                                 UINT8 *Data);
 336 static int              acpi_ec_probe(device_t dev);
 337 static int              acpi_ec_attach(device_t dev);
 338 static int              acpi_ec_shutdown(device_t dev);
 339 static int              acpi_ec_read_method(device_t dev, u_int addr,
 340                                 ACPI_INTEGER *val, int width);
 341 static int              acpi_ec_write_method(device_t dev, u_int addr,
 342                                 ACPI_INTEGER val, int width);
 343
 344 static device_method_t acpi_ec_methods[] = {
 345     /* Device interface */
 346     DEVMETHOD(device_probe,     acpi_ec_probe),
 347     DEVMETHOD(device_attach,    acpi_ec_attach),
 348     DEVMETHOD(device_shutdown,  acpi_ec_shutdown),
 349
 350     /* Embedded controller interface */
 351     DEVMETHOD(acpi_ec_read,     acpi_ec_read_method),
 352     DEVMETHOD(acpi_ec_write,    acpi_ec_write_method),
 353
 354     {0, 0}
 355 };
 356
 357 static driver_t acpi_ec_driver = {
 358     "acpi_ec",
 359     acpi_ec_methods,
 360     sizeof(struct acpi_ec_softc),
 361 };
 362
 363 static devclass_t acpi_ec_devclass;
 364 DRIVER_MODULE(acpi_ec, acpi, acpi_ec_driver, acpi_ec_devclass, 0, 0);
 365 MODULE_DEPEND(acpi_ec, acpi, 1, 1, 1);
 366
 367 /*
 368  * Look for an ECDT and if we find one, set up default GPE and
 369  * space handlers to catch attempts to access EC space before
 370  * we have a real driver instance in place.
 371  * TODO: if people report invalid ECDTs, add a tunable to disable them.
 372  */
 373 void
 374 acpi_ec_ecdt_probe(device_t parent)
 375 {
 376     ACPI_TABLE_ECDT *ecdt;
 377     ACPI_TABLE_HEADER *hdr;
 378     ACPI_STATUS      status;
 379     device_t         child;
 380     ACPI_HANDLE      h;
 381     struct acpi_ec_params *params;
 382
 383     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 384
 385     /* Find and validate the ECDT. */
 386     status = AcpiGetFirmwareTable("ECDT", 1, ACPI_LOGICAL_ADDRESSING, &hdr);
 387     ecdt = (ACPI_TABLE_ECDT *)hdr;
 388     if (ACPI_FAILURE(status) ||
 389         ecdt->control.RegisterBitWidth != 8 ||
 390         ecdt->data.RegisterBitWidth != 8) {
 391         return;
 392     }
 393
 394     /* Create the child device with the given unit number. */
 395     child = BUS_ADD_CHILD(parent, 0, "acpi_ec", ecdt->uid);
 396     if (child == NULL) {
 397         printf("%s: can't add child\n", __func__);
 398         return;
 399     }
 400
 401     /* Find and save the ACPI handle for this device. */
 402     status = AcpiGetHandle(NULL, ecdt->ec_id, &h);
 403     if (ACPI_FAILURE(status)) {
 404         device_delete_child(parent, child);
 405         printf("%s: can't get handle\n", __func__);
 406         return;
 407     }
 408     acpi_set_handle(child, h);
 409
 410     /* Set the data and CSR register addresses. */
 411     bus_set_resource(child, SYS_RES_IOPORT, 0, ecdt->data.Address,
 412         /*count*/1);
 413     bus_set_resource(child, SYS_RES_IOPORT, 1, ecdt->control.Address,
 414         /*count*/1);
 415
 416     /*
 417      * Store values for the probe/attach routines to use.  Store the
 418      * ECDT GPE bit and set the global lock flag according to _GLK.
 419      * Note that it is not perfectly correct to be evaluating a method
 420      * before initializing devices, but in practice this function
 421      * should be safe to call at this point.
 422      */
 423     params = malloc(sizeof(struct acpi_ec_params), M_TEMP, M_WAITOK | M_ZERO);
 424     params->gpe_handle = NULL;
 425     params->gpe_bit = ecdt->gpe_bit;
 426     params->uid = ecdt->uid;
 427     acpi_GetInteger(h, "_GLK", &params->glk);
 428     acpi_set_private(child, params);
 429     acpi_set_magic(child, (int)&acpi_ec_devclass);
 430
 431     /* Finish the attach process. */
 432     if (device_probe_and_attach(child) != 0)
 433         device_delete_child(parent, child);
 434 }
 435
 436 static int
 437 acpi_ec_probe(device_t dev)
 438 {
 439     ACPI_BUFFER buf;
 440     ACPI_HANDLE h;
 441     ACPI_OBJECT *obj;
 442     ACPI_STATUS status;
 443     device_t    peer;
 444     char        desc[64];
 445     int         ret;
 446     struct acpi_ec_params *params;
 447     static char *ec_ids[] = { "PNP0C09", NULL };
 448
 449     /* Check that this is a device and that EC is not disabled. */
 450     if (acpi_get_type(dev) != ACPI_TYPE_DEVICE || acpi_disabled("ec"))
 451         return (ENXIO);
 452
 453     /*
 454      * If probed via ECDT, set description and continue.  Otherwise,
 455      * we can access the namespace and make sure this is not a
 456      * duplicate probe.
 457      */
 458     ret = ENXIO;
 459     params = NULL;
 460     buf.Pointer = NULL;
 461     buf.Length = ACPI_ALLOCATE_BUFFER;
 462     if (DEV_ECDT(dev)) {
 463         params = acpi_get_private(dev);
 464         ret = 0;
 465     } else if (!acpi_disabled("ec") &&
 466         ACPI_ID_PROBE(device_get_parent(dev), dev, ec_ids)) {
 467         params = malloc(sizeof(struct acpi_ec_params), M_TEMP,
 468                         M_WAITOK | M_ZERO);
 469         h = acpi_get_handle(dev);
 470
 471         /*
 472          * Read the unit ID to check for duplicate attach and the
 473          * global lock value to see if we should acquire it when
 474          * accessing the EC.
 475          */
 476         status = acpi_GetInteger(h, "_UID", &params->uid);
 477         if (ACPI_FAILURE(status))
 478             params->uid = 0;
 479         status = acpi_GetInteger(h, "_GLK", &params->glk);
 480         if (ACPI_FAILURE(status))
 481             params->glk = 0;
 482
 483         /*
 484          * Evaluate the _GPE method to find the GPE bit used by the EC to
 485          * signal status (SCI).  If it's a package, it contains a reference
 486          * and GPE bit, similar to _PRW.
 487          */
 488         status = AcpiEvaluateObject(h, "_GPE", NULL, &buf);
 489         if (ACPI_FAILURE(status)) {
 490             device_printf(dev, "can't evaluate _GPE - %s\n",
 491                           AcpiFormatException(status));
 492             goto out;
 493         }
 494         obj = (ACPI_OBJECT *)buf.Pointer;
 495         if (obj == NULL)
 496             goto out;
 497
 498         switch (obj->Type) {
 499         case ACPI_TYPE_INTEGER:
 500             params->gpe_handle = NULL;
 501             params->gpe_bit = obj->Integer.Value;
 502             break;
 503         case ACPI_TYPE_PACKAGE:
 504             if (!ACPI_PKG_VALID(obj, 2))
 505                 goto out;
 506             params->gpe_handle =
 507                 acpi_GetReference(NULL, &obj->Package.Elements[0]);
 508             if (params->gpe_handle == NULL ||
 509                 acpi_PkgInt32(obj, 1, &params->gpe_bit) != 0)
 510                 goto out;
 511             break;
 512         default:
 513             device_printf(dev, "_GPE has invalid type %d\n", obj->Type);
 514             goto out;
 515         }
 516
 517         /* Store the values we got from the namespace for attach. */
 518         acpi_set_private(dev, params);
 519
 520         /*
 521          * Check for a duplicate probe.  This can happen when a probe
 522          * via ECDT succeeded already.  If this is a duplicate, disable
 523          * this device.
 524          */
 525         peer = devclass_get_device(acpi_ec_devclass, params->uid);
 526         if (peer == NULL || !device_is_alive(peer))
 527             ret = 0;
 528         else
 529             device_disable(dev);
 530     }
 531
 532 out:
 533     if (ret == 0) {
 534         snprintf(desc, sizeof(desc), "Embedded Controller: GPE %#x%s%s",
 535                  params->gpe_bit, (params->glk) ? ", GLK" : "",
 536                  DEV_ECDT(dev) ? ", ECDT" : "");
 537         device_set_desc_copy(dev, desc);
 538     }
 539
 540     if (ret > 0 && params)
 541         free(params, M_TEMP);
 542     if (buf.Pointer)
 543         AcpiOsFree(buf.Pointer);
 544     return (ret);
 545 }
 546
 547 static int
 548 acpi_ec_attach(device_t dev)
 549 {
 550     struct acpi_ec_softc        *sc;
 551     struct acpi_ec_params       *params;
 552     ACPI_STATUS                 Status;
 553
 554     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 555
 556     /* Fetch/initialize softc (assumes softc is pre-zeroed). */
 557     sc = device_get_softc(dev);
 558     params = acpi_get_private(dev);
 559     sc->ec_dev = dev;
 560     sc->ec_handle = acpi_get_handle(dev);
 561
 562     /* Retrieve previously probed values via device ivars. */
 563     sc->ec_glk = params->glk;
 564     sc->ec_gpebit = params->gpe_bit;
 565     sc->ec_gpehandle = params->gpe_handle;
 566     sc->ec_uid = params->uid;
 567     free(params, M_TEMP);
 568
 569     /* Attach bus resources for data and command/status ports. */
 570     sc->ec_data_rid = 0;
 571     sc->ec_data_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
 572                         &sc->ec_data_rid, RF_ACTIVE);
 573     if (sc->ec_data_res == NULL) {
 574         device_printf(dev, "can't allocate data port\n");
 575         goto error;
 576     }
 577     sc->ec_data_tag = rman_get_bustag(sc->ec_data_res);
 578     sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res);
 579
 580     sc->ec_csr_rid = 1;
 581     sc->ec_csr_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
 582                         &sc->ec_csr_rid, RF_ACTIVE);
 583     if (sc->ec_csr_res == NULL) {
 584         device_printf(dev, "can't allocate command/status port\n");
 585         goto error;
 586     }
 587     sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res);
 588     sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res);
 589
 590     /*
 591      * Install a handler for this EC's GPE bit.  We want edge-triggered
 592      * behavior.
 593      */
 594     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE handler\n"));
 595     Status = AcpiInstallGpeHandler(sc->ec_gpehandle, sc->ec_gpebit,
 596                 ACPI_GPE_EDGE_TRIGGERED, &EcGpeHandler, sc);
 597     if (ACPI_FAILURE(Status)) {
 598         device_printf(dev, "can't install GPE handler for %s - %s\n",
 599                       acpi_name(sc->ec_handle), AcpiFormatException(Status));
 600         goto error;
 601     }
 602
 603     /*
 604      * Install address space handler
 605      */
 606     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n"));
 607     Status = AcpiInstallAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
 608                 &EcSpaceHandler, &EcSpaceSetup, sc);
 609     if (ACPI_FAILURE(Status)) {
 610         device_printf(dev, "can't install address space handler for %s - %s\n",
 611                       acpi_name(sc->ec_handle), AcpiFormatException(Status));
 612         goto error;
 613     }
 614
 615     /* Enable runtime GPEs for the handler. */
 616     Status = AcpiSetGpeType(sc->ec_gpehandle, sc->ec_gpebit,
 617                             ACPI_GPE_TYPE_RUNTIME);
 618     if (ACPI_FAILURE(Status)) {
 619         device_printf(dev, "AcpiSetGpeType failed: %s\n",
 620                       AcpiFormatException(Status));
 621         goto error;
 622     }
 623     Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_NOT_ISR);
 624     if (ACPI_FAILURE(Status)) {
 625         device_printf(dev, "AcpiEnableGpe failed: %s\n",
 626                       AcpiFormatException(Status));
 627         goto error;
 628     }
 629
 630     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "acpi_ec_attach complete\n"));
 631     return (0);
 632
 633 error:
 634     AcpiRemoveGpeHandler(sc->ec_gpehandle, sc->ec_gpebit, &EcGpeHandler);
 635     AcpiRemoveAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
 636         EcSpaceHandler);
 637     if (sc->ec_csr_res)
 638         bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_csr_rid,
 639                              sc->ec_csr_res);
 640     if (sc->ec_data_res)
 641         bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_data_rid,
 642                              sc->ec_data_res);
 643     return (ENXIO);
 644 }
 645
 646 static int
 647 acpi_ec_shutdown(device_t dev)
 648 {
 649     struct acpi_ec_softc        *sc;
 650
 651     /* Disable the GPE so we don't get EC events during shutdown. */
 652     sc = device_get_softc(dev);
 653     AcpiDisableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_NOT_ISR);
 654     return (0);
 655 }
 656
 657 /* Methods to allow other devices (e.g., smbat) to read/write EC space. */
 658 static int
 659 acpi_ec_read_method(device_t dev, u_int addr, ACPI_INTEGER *val, int width)
 660 {
 661     struct acpi_ec_softc *sc;
 662     ACPI_STATUS status;
 663
 664     sc = device_get_softc(dev);
 665     status = EcSpaceHandler(ACPI_READ, addr, width * 8, val, sc, NULL);
 666     if (ACPI_FAILURE(status))
 667         return (ENXIO);
 668     return (0);
 669 }
 670
 671 static int
 672 acpi_ec_write_method(device_t dev, u_int addr, ACPI_INTEGER val, int width)
 673 {
 674     struct acpi_ec_softc *sc;
 675     ACPI_STATUS status;
 676
 677     sc = device_get_softc(dev);
 678     status = EcSpaceHandler(ACPI_WRITE, addr, width * 8, &val, sc, NULL);
 679     if (ACPI_FAILURE(status))
 680         return (ENXIO);
 681     return (0);
 682 }
 683
 684 static void
 685 EcGpeQueryHandler(void *Context)
 686 {
 687     struct acpi_ec_softc        *sc = (struct acpi_ec_softc *)Context;
 688     UINT8                       Data;
 689     ACPI_STATUS                 Status;
 690     EC_STATUS                   EcStatus;
 691     char                        qxx[5];
 692
 693     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 694     KASSERT(Context != NULL, ("EcGpeQueryHandler called with NULL"));
 695
 696     Status = EcLock(sc);
 697     if (ACPI_FAILURE(Status)) {
 698         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 699                     "GpeQuery lock error: %s\n", AcpiFormatException(Status));
 700         return;
 701     }
 702
 703     /*
 704      * If the EC_SCI bit of the status register is not set, then pass
 705      * it along to any potential waiters as it may be an IBE/OBF event.
 706      */
 707     EcStatus = EC_GET_CSR(sc);
 708     if ((EcStatus & EC_EVENT_SCI) == 0) {
 709         CTR1(KTR_ACPI, "ec event was not SCI, status %#x", EcStatus);
 710         sc->ec_csrvalue = EcStatus;
 711         wakeup(&sc->ec_csrvalue);
 712         EcUnlock(sc);
 713         goto re_enable;
 714     }
 715
 716     /*
 717      * Send a query command to the EC to find out which _Qxx call it
 718      * wants to make.  This command clears the SCI bit and also the
 719      * interrupt source since we are edge-triggered.
 720      */
 721     Status = EcCommand(sc, EC_COMMAND_QUERY);
 722     if (ACPI_FAILURE(Status)) {
 723         EcUnlock(sc);
 724         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 725                     "GPE query failed - %s\n", AcpiFormatException(Status));
 726         goto re_enable;
 727     }
 728     Data = EC_GET_DATA(sc);
 729     EcUnlock(sc);
 730
 731     /* Ignore the value for "no outstanding event". (13.3.5) */
 732     CTR2(KTR_ACPI, "ec query ok,%s running _Q%02x", Data ? "" : " not", Data);
 733     if (Data == 0)
 734         goto re_enable;
 735
 736     /* Evaluate _Qxx to respond to the controller. */
 737     sprintf(qxx, "_Q%02x", Data);
 738     AcpiUtStrupr(qxx);
 739     Status = AcpiEvaluateObject(sc->ec_handle, qxx, NULL, NULL);
 740     if (ACPI_FAILURE(Status) && Status != AE_NOT_FOUND) {
 741         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 742                     "evaluation of GPE query method %s failed - %s\n",
 743                     qxx, AcpiFormatException(Status));
 744     }
 745
 746 re_enable:
 747     /* Re-enable the GPE event so we'll get future requests. */
 748     Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_NOT_ISR);
 749     if (ACPI_FAILURE(Status))
 750         printf("EcGpeQueryHandler: AcpiEnableEvent failed\n");
 751 }
 752
 753 /*
 754  * Handle a GPE.  Currently we only handle SCI events as others must
 755  * be handled by polling in EcWaitEvent().  This is because some ECs
 756  * treat events as level when they should be edge-triggered.
 757  */
 758 static uint32_t
 759 EcGpeHandler(void *Context)
 760 {
 761     struct acpi_ec_softc *sc = Context;
 762     ACPI_STATUS                Status;
 763
 764     KASSERT(Context != NULL, ("EcGpeHandler called with NULL"));
 765
 766     /*
 767      * Disable further GPEs while we handle this one.  Since we are directly
 768      * called by ACPI-CA and it may have unknown locks held, we specify the
 769      * ACPI_ISR flag to keep it from acquiring any more mutexes (which could
 770      * potentially sleep.)
 771      */
 772     AcpiDisableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_ISR);
 773
 774     /* Schedule the GPE query handler. */
 775     Status = AcpiOsQueueForExecution(OSD_PRIORITY_GPE, EcGpeQueryHandler,
 776                 Context);
 777     if (ACPI_FAILURE(Status)) {
 778         printf("Queuing GPE query handler failed.\n");
 779         Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_ISR);
 780         if (ACPI_FAILURE(Status))
 781             printf("EcGpeHandler: AcpiEnableEvent failed\n");
 782     }
 783
 784     return (0);
 785 }
 786
 787 static ACPI_STATUS
 788 EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context,
 789              void **RegionContext)
 790 {
 791
 792     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 793
 794     /*
 795      * If deactivating a region, always set the output to NULL.  Otherwise,
 796      * just pass the context through.
 797      */
 798     if (Function == ACPI_REGION_DEACTIVATE)
 799         *RegionContext = NULL;
 800     else
 801         *RegionContext = Context;
 802
 803     return_ACPI_STATUS (AE_OK);
 804 }
 805
 806 static ACPI_STATUS
 807 EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width,
 808                ACPI_INTEGER *Value, void *Context, void *RegionContext)
 809 {
 810     struct acpi_ec_softc        *sc = (struct acpi_ec_softc *)Context;
 811     ACPI_STATUS                 Status;
 812     UINT8                       EcAddr, EcData;
 813     int                         i;
 814
 815     ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Address);
 816
 817     if (width % 8 != 0 || Value == NULL || Context == NULL)
 818         return_ACPI_STATUS (AE_BAD_PARAMETER);
 819     if (Address + (width / 8) - 1 > 0xFF)
 820         return_ACPI_STATUS (AE_BAD_ADDRESS);
 821
 822     if (Function == ACPI_READ)
 823         *Value = 0;
 824     EcAddr = Address;
 825     Status = AE_ERROR;
 826
 827     Status = EcLock(sc);
 828     if (ACPI_FAILURE(Status))
 829         return_ACPI_STATUS (Status);
 830
 831     /* Perform the transaction(s), based on width. */
 832     for (i = 0; i < width; i += 8, EcAddr++) {
 833         switch (Function) {
 834         case ACPI_READ:
 835             Status = EcRead(sc, EcAddr, &EcData);
 836             if (ACPI_SUCCESS(Status))
 837                 *Value |= ((ACPI_INTEGER)EcData) << i;
 838             break;
 839         case ACPI_WRITE:
 840             EcData = (UINT8)((*Value) >> i);
 841             Status = EcWrite(sc, EcAddr, &EcData);
 842             break;
 843         default:
 844             device_printf(sc->ec_dev, "invalid EcSpaceHandler function %d\n",
 845                           Function);
 846             Status = AE_BAD_PARAMETER;
 847             break;
 848         }
 849         if (ACPI_FAILURE(Status))
 850             break;
 851     }
 852
 853     EcUnlock(sc);
 854     return_ACPI_STATUS (Status);
 855 }
 856
 857 static ACPI_STATUS
 858 EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event)
 859 {
 860     EC_STATUS   EcStatus;
 861     ACPI_STATUS Status;
 862     int         count, i, period, retval, slp_ival;
 863
 864     ACPI_SERIAL_ASSERT(ec);
 865     Status = AE_NO_HARDWARE_RESPONSE;
 866
 867     /*
 868      * Wait for 1 us before checking the CSR.  Testing shows about
 869      * 50% of requests complete in 1 us and 90% of them complete
 870      * in 5 us or less.
 871      */
 872     AcpiOsStall(1);
 873
 874     /*
 875      * Poll the EC status register for up to 1 ms in chunks of 10 us
 876      * to detect completion of the last command.
 877      */
 878     for (i = 0; i < 1000 / EC_POLL_DELAY; i++) {
 879         EcStatus = EC_GET_CSR(sc);
 880         if (EVENT_READY(Event, EcStatus)) {
 881             Status = AE_OK;
 882             break;
 883         }
 884         AcpiOsStall(EC_POLL_DELAY);
 885     }
 886     period = i * EC_POLL_DELAY;
 887
 888     /*
 889      * If we still don't have a response and we're up and running, wait up
 890      * to ec_poll_timeout ms for completion, sleeping for chunks of 10 ms.
 891      */
 892     slp_ival = 0;
 893     if (Status != AE_OK) {
 894         retval = ENXIO;
 895         count = ec_poll_timeout / 10;
 896         if (count == 0)
 897             count = 1;
 898         slp_ival = hz / 100;
 899         if (slp_ival == 0)
 900             slp_ival = 1;
 901         for (i = 0; i < count; i++) {
 902             if (retval != 0)
 903                 EcStatus = EC_GET_CSR(sc);
 904             else
 905                 EcStatus = sc->ec_csrvalue;
 906             if (EVENT_READY(Event, EcStatus)) {
 907                 Status = AE_OK;
 908                 break;
 909             }
 910             if (!cold)
 911                 retval = tsleep(&sc->ec_csrvalue, PZERO, "ecpoll", slp_ival);
 912             else
 913                 AcpiOsStall(10000);
 914         }
 915     }
 916
 917     /* Calculate new delay and log it. */
 918     if (slp_ival > 0)
 919         period += i * 10000;
 920     CTR2(KTR_ACPI, "ec got event %#x after %d us", EcStatus, period);
 921
 922     return (Status);
 923 }
 924
 925 static ACPI_STATUS
 926 EcCommand(struct acpi_ec_softc *sc, EC_COMMAND cmd)
 927 {
 928     ACPI_STATUS Status;
 929     EC_EVENT    Event;
 930
 931     ACPI_SERIAL_ASSERT(ec);
 932
 933     /* Decide what to wait for based on command type. */
 934     switch (cmd) {
 935     case EC_COMMAND_READ:
 936     case EC_COMMAND_WRITE:
 937     case EC_COMMAND_BURST_DISABLE:
 938         Event = EC_EVENT_INPUT_BUFFER_EMPTY;
 939         break;
 940     case EC_COMMAND_QUERY:
 941     case EC_COMMAND_BURST_ENABLE:
 942         Event = EC_EVENT_OUTPUT_BUFFER_FULL;
 943         break;
 944     default:
 945         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 946                     "EcCommand: Invalid command %#x\n", cmd);
 947         return (AE_BAD_PARAMETER);
 948     }
 949
 950     /* Run the command and wait for the chosen event. */
 951     EC_SET_CSR(sc, cmd);
 952     Status = EcWaitEvent(sc, Event);
 953     if (ACPI_FAILURE(Status)) {
 954         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 955                     "EcCommand: no response to %#x\n", cmd);
 956     }
 957
 958     return (Status);
 959 }
 960
 961 static ACPI_STATUS
 962 EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
 963 {
 964     ACPI_STATUS Status;
 965
 966     ACPI_SERIAL_ASSERT(ec);
 967     CTR1(KTR_ACPI, "ec read from %#x", Address);
 968
 969 #ifdef notyet
 970     /* If we can't start burst mode, continue anyway. */
 971     EcCommand(sc, EC_COMMAND_BURST_ENABLE);
 972 #endif
 973
 974     Status = EcCommand(sc, EC_COMMAND_READ);
 975     if (ACPI_FAILURE(Status))
 976         return (Status);
 977
 978     EC_SET_DATA(sc, Address);
 979     Status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL);
 980     if (ACPI_FAILURE(Status)) {
 981         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 982                     "EcRead: Failed waiting for EC to send data.\n");
 983         return (Status);
 984     }
 985
 986     *Data = EC_GET_DATA(sc);
 987
 988 #ifdef notyet
 989     if (sc->ec_burstactive) {
 990         Status = EcCommand(sc, EC_COMMAND_BURST_DISABLE);
 991         if (ACPI_FAILURE(Status))
 992             return (Status);
 993     }
 994 #endif
 995
 996     return (AE_OK);
 997 }
 998
 999 static ACPI_STATUS
1000 EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
1001 {
1002     ACPI_STATUS Status;
1003
1004     ACPI_SERIAL_ASSERT(ec);
1005     CTR2(KTR_ACPI, "ec write to %#x, data %#x", Address, *Data);
1006
1007 #ifdef notyet
1008     /* If we can't start burst mode, continue anyway. */
1009     EcCommand(sc, EC_COMMAND_BURST_ENABLE);
1010 #endif
1011
1012     Status = EcCommand(sc, EC_COMMAND_WRITE);
1013     if (ACPI_FAILURE(Status))
1014         return (Status);
1015
1016     EC_SET_DATA(sc, Address);
1017     Status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY);
1018     if (ACPI_FAILURE(Status)) {
1019         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
1020                     "EcRead: Failed waiting for EC to process address\n");
1021         return (Status);
1022     }
1023
1024     EC_SET_DATA(sc, *Data);
1025     Status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY);
1026     if (ACPI_FAILURE(Status)) {
1027         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
1028                     "EcWrite: Failed waiting for EC to process data\n");
1029         return (Status);
1030     }
1031
1032 #ifdef notyet
1033     if (sc->ec_burstactive) {
1034         Status = EcCommand(sc, EC_COMMAND_BURST_DISABLE);
1035         if (ACPI_FAILURE(Status))
1036             return (Status);
1037     }
1038 #endif
1039
1040     return (AE_OK);
1041 }