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