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