sys/dev/acpica/acpi_ec.c

   1 /*-
   2  * Copyright (c) 2000 Michael Smith
   3  * Copyright (c) 2000 BSDi
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  *      $FreeBSD$
  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 "opt_acpi.h"
 139 #include <sys/param.h>
 140 #include <sys/kernel.h>
 141 #include <sys/bus.h>
 142
 143 #include <machine/bus.h>
 144 #include <machine/resource.h>
 145 #include <sys/rman.h>
 146
 147 #include "acpi.h"
 148
 149 #include <dev/acpica/acpivar.h>
 150
 151 /*
 152  * Hooks for the ACPI CA debugging infrastructure
 153  */
 154 #define _COMPONENT      ACPI_EC
 155 ACPI_MODULE_NAME("EC")
 156
 157 /*
 158  * EC_COMMAND:
 159  * -----------
 160  */
 161 typedef UINT8                           EC_COMMAND;
 162
 163 #define EC_COMMAND_UNKNOWN              ((EC_COMMAND) 0x00)
 164 #define EC_COMMAND_READ                 ((EC_COMMAND) 0x80)
 165 #define EC_COMMAND_WRITE                ((EC_COMMAND) 0x81)
 166 #define EC_COMMAND_BURST_ENABLE         ((EC_COMMAND) 0x82)
 167 #define EC_COMMAND_BURST_DISABLE        ((EC_COMMAND) 0x83)
 168 #define EC_COMMAND_QUERY                ((EC_COMMAND) 0x84)
 169
 170 /*
 171  * EC_STATUS:
 172  * ----------
 173  * The encoding of the EC status register is illustrated below.
 174  * Note that a set bit (1) indicates the property is TRUE
 175  * (e.g. if bit 0 is set then the output buffer is full).
 176  * +-+-+-+-+-+-+-+-+
 177  * |7|6|5|4|3|2|1|0|
 178  * +-+-+-+-+-+-+-+-+
 179  *  | | | | | | | |
 180  *  | | | | | | | +- Output Buffer Full?
 181  *  | | | | | | +--- Input Buffer Full?
 182  *  | | | | | +----- <reserved>
 183  *  | | | | +------- Data Register is Command Byte?
 184  *  | | | +--------- Burst Mode Enabled?
 185  *  | | +----------- SCI Event?
 186  *  | +------------- SMI Event?
 187  *  +--------------- <Reserved>
 188  *
 189  */
 190 typedef UINT8                           EC_STATUS;
 191
 192 #define EC_FLAG_OUTPUT_BUFFER           ((EC_STATUS) 0x01)
 193 #define EC_FLAG_INPUT_BUFFER            ((EC_STATUS) 0x02)
 194 #define EC_FLAG_BURST_MODE              ((EC_STATUS) 0x10)
 195 #define EC_FLAG_SCI                     ((EC_STATUS) 0x20)
 196
 197 /*
 198  * EC_EVENT:
 199  * ---------
 200  */
 201 typedef UINT8                           EC_EVENT;
 202
 203 #define EC_EVENT_UNKNOWN                ((EC_EVENT) 0x00)
 204 #define EC_EVENT_OUTPUT_BUFFER_FULL     ((EC_EVENT) 0x01)
 205 #define EC_EVENT_INPUT_BUFFER_EMPTY     ((EC_EVENT) 0x02)
 206 #define EC_EVENT_SCI                    ((EC_EVENT) 0x20)
 207
 208 /*
 209  * Register access primitives
 210  */
 211 #define EC_GET_DATA(sc)                                                 \
 212         bus_space_read_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0)
 213
 214 #define EC_SET_DATA(sc, v)                                              \
 215         bus_space_write_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0, (v))
 216
 217 #define EC_GET_CSR(sc)                                                  \
 218         bus_space_read_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0)
 219
 220 #define EC_SET_CSR(sc, v)                                               \
 221         bus_space_write_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0, (v))
 222
 223 /*
 224  * Driver softc.
 225  */
 226 struct acpi_ec_softc {
 227     device_t            ec_dev;
 228     ACPI_HANDLE         ec_handle;
 229     UINT32              ec_gpebit;
 230
 231     int                 ec_data_rid;
 232     struct resource     *ec_data_res;
 233     bus_space_tag_t     ec_data_tag;
 234     bus_space_handle_t  ec_data_handle;
 235
 236     int                 ec_csr_rid;
 237     struct resource     *ec_csr_res;
 238     bus_space_tag_t     ec_csr_tag;
 239     bus_space_handle_t  ec_csr_handle;
 240
 241     int                 ec_locked;
 242     int                 ec_lockhandle;
 243     int                 ec_pendquery;
 244     int                 ec_csrvalue;
 245 };
 246
 247 #define EC_LOCK_TIMEOUT 1000    /* 1ms */
 248
 249 static __inline ACPI_STATUS
 250 EcLock(struct acpi_ec_softc *sc)
 251 {
 252     ACPI_STATUS status;
 253
 254     /* XXX WAIT_FOREVER is probably a bad idea, what is a better time? */
 255     if (ACPI_SUCCESS(status = AcpiAcquireGlobalLock(WAIT_FOREVER, &sc->ec_lockhandle)))
 256         (sc)->ec_locked = 1;
 257
 258     return(status);
 259 }
 260
 261 static __inline void
 262 EcUnlock(struct acpi_ec_softc *sc)
 263 {
 264     (sc)->ec_locked = 0;
 265     AcpiReleaseGlobalLock(sc->ec_lockhandle);
 266 }
 267
 268 static __inline int
 269 EcIsLocked(struct acpi_ec_softc *sc)
 270 {
 271     return((sc)->ec_locked != 0);
 272 }
 273
 274 typedef struct
 275 {
 276     EC_COMMAND              Command;
 277     UINT8                   Address;
 278     UINT8                   Data;
 279 } EC_REQUEST;
 280
 281 static void             EcGpeHandler(void *Context);
 282 static ACPI_STATUS      EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function,
 283                                            void *Context, void **return_Context);
 284 static ACPI_STATUS      EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width, ACPI_INTEGER *Value,
 285                                       void *Context, void *RegionContext);
 286
 287 static ACPI_STATUS      EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event);
 288 static ACPI_STATUS      EcQuery(struct acpi_ec_softc *sc, UINT8 *Data);
 289 static ACPI_STATUS      EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest);
 290 static ACPI_STATUS      EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data);
 291 static ACPI_STATUS      EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data);
 292
 293 static void             acpi_ec_identify(driver_t driver, device_t bus);
 294 static int              acpi_ec_probe(device_t dev);
 295 static int              acpi_ec_attach(device_t dev);
 296
 297 static device_method_t acpi_ec_methods[] = {
 298     /* Device interface */
 299     DEVMETHOD(device_identify,  acpi_ec_identify),
 300     DEVMETHOD(device_probe,     acpi_ec_probe),
 301     DEVMETHOD(device_attach,    acpi_ec_attach),
 302
 303     {0, 0}
 304 };
 305
 306 static driver_t acpi_ec_driver = {
 307     "acpi_ec",
 308     acpi_ec_methods,
 309     sizeof(struct acpi_ec_softc),
 310 };
 311
 312 static devclass_t acpi_ec_devclass;
 313 DRIVER_MODULE(acpi_ec, acpi, acpi_ec_driver, acpi_ec_devclass, 0, 0);
 314
 315 /*
 316  * Look for an ECDT table and if we find one, set up a default EC
 317  * space handler to catch possible attempts to access EC space before
 318  * we have a real driver instance in place.
 319  * We're not really an identify routine, but because we get called
 320  * before most other things, this works out OK.
 321  */
 322 static void
 323 acpi_ec_identify(driver_t driver, device_t bus)
 324 {
 325     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 326
 327     /* XXX implement - need an ACPI 2.0 system to test this */
 328
 329     return_VOID;
 330 }
 331
 332 /*
 333  * We could setup resources in the probe routine in order to have them printed
 334  * when the device is attached.
 335  */
 336 static int
 337 acpi_ec_probe(device_t dev)
 338 {
 339
 340     if ((acpi_get_type(dev) == ACPI_TYPE_DEVICE) &&
 341         !acpi_disabled("ec") &&
 342         acpi_MatchHid(dev, "PNP0C09")) {
 343
 344         /*
 345          * Set device description
 346          */
 347         device_set_desc(dev, "embedded controller");
 348
 349         return(0);
 350     }
 351     return(ENXIO);
 352 }
 353
 354 static int
 355 acpi_ec_attach(device_t dev)
 356 {
 357     struct acpi_ec_softc        *sc;
 358     ACPI_STATUS                 Status;
 359     int errval = 0;
 360
 361     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 362
 363     /*
 364      * Fetch/initialise softc
 365      */
 366     sc = device_get_softc(dev);
 367     bzero(sc, sizeof(*sc));
 368     sc->ec_dev = dev;
 369     sc->ec_handle = acpi_get_handle(dev);
 370
 371     /*
 372      * Attach bus resources
 373      */
 374     sc->ec_data_rid = 0;
 375     if ((sc->ec_data_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, &sc->ec_data_rid,
 376                                               0, ~0, 1, RF_ACTIVE)) == NULL) {
 377         device_printf(dev, "can't allocate data port\n");
 378         errval = ENXIO;
 379         goto out;
 380     }
 381     sc->ec_data_tag = rman_get_bustag(sc->ec_data_res);
 382     sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res);
 383
 384     sc->ec_csr_rid = 1;
 385     if ((sc->ec_csr_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, &sc->ec_csr_rid,
 386                                              0, ~0, 1, RF_ACTIVE)) == NULL) {
 387         device_printf(dev, "can't allocate command/status port\n");
 388         errval = ENXIO;
 389         goto out;
 390     }
 391     sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res);
 392     sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res);
 393
 394     /*
 395      * Install GPE handler
 396      *
 397      * Evaluate the _GPE method to find the GPE bit used by the EC to signal
 398      * status (SCI).
 399      */
 400     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE\n"));
 401     if (ACPI_FAILURE(Status = acpi_EvaluateInteger(sc->ec_handle, "_GPE", &sc->ec_gpebit))) {
 402         device_printf(dev, "can't evaluate _GPE - %s\n", AcpiFormatException(Status));
 403         errval =ENXIO;
 404         goto out;
 405     }
 406
 407     /*
 408      * Install a handler for this EC's GPE bit.  Note that EC SCIs are
 409      * treated as both edge- and level-triggered interrupts; in other words
 410      * we clear the status bit immediately after getting an EC-SCI, then
 411      * again after we're done processing the event.  This guarantees that
 412      * events we cause while performing a transaction (e.g. IBE/OBF) get
 413      * cleared before re-enabling the GPE.
 414      */
 415     if (ACPI_FAILURE(Status = AcpiInstallGpeHandler(sc->ec_gpebit,
 416                                                     ACPI_EVENT_LEVEL_TRIGGERED |
 417                                                     ACPI_EVENT_EDGE_TRIGGERED,
 418                                                     EcGpeHandler, sc))) {
 419         device_printf(dev, "can't install GPE handler for %s - %s\n",
 420                       acpi_name(sc->ec_handle), AcpiFormatException(Status));
 421         errval = ENXIO;
 422         goto out;
 423     }
 424
 425     /*
 426      * Install address space handler
 427      */
 428     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n"));
 429     if (ACPI_FAILURE(Status = AcpiInstallAddressSpaceHandler(sc->ec_handle,
 430                                                              ACPI_ADR_SPACE_EC,
 431                                                              EcSpaceHandler,
 432                                                              EcSpaceSetup,
 433                                                              sc))) {
 434         device_printf(dev, "can't install address space handler for %s - %s\n",
 435                       acpi_name(sc->ec_handle), AcpiFormatException(Status));
 436         panic("very suck");
 437         errval = ENXIO;
 438         goto out;
 439     }
 440     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attach complete\n"));
 441     return_VALUE(0);
 442  out:
 443     if(sc->ec_csr_res)
 444         bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_csr_rid,
 445                              sc->ec_csr_res);
 446     if(sc->ec_data_res)
 447         bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_data_rid,
 448                              sc->ec_data_res);
 449     return_VALUE(errval);
 450 }
 451
 452 static void
 453 EcGpeQueryHandler(void *Context)
 454 {
 455     struct acpi_ec_softc        *sc = (struct acpi_ec_softc *)Context;
 456     UINT8                       Data;
 457     ACPI_STATUS                 Status;
 458     char                        qxx[5];
 459
 460     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 461
 462     for (;;) {
 463
 464         /*
 465          * Check EC_SCI.
 466          *
 467          * Bail out if the EC_SCI bit of the status register is not set.
 468          * Note that this function should only be called when
 469          * this bit is set (polling is used to detect IBE/OBF events).
 470          *
 471          * It is safe to do this without locking the controller, as it's
 472          * OK to call EcQuery when there's no data ready; in the worst
 473          * case we should just find nothing waiting for us and bail.
 474          */
 475         if (!(EC_GET_CSR(sc) & EC_EVENT_SCI))
 476             break;
 477
 478         /*
 479          * Find out why the EC is signalling us
 480          */
 481         Status = EcQuery(sc, &Data);
 482
 483         /*
 484          * If we failed to get anything from the EC, give up
 485          */
 486         if (ACPI_FAILURE(Status)) {
 487             ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 488                 "GPE query failed - %s\n", AcpiFormatException(Status));
 489             break;
 490         }
 491
 492         /*
 493          * Evaluate _Qxx to respond to the controller.
 494          */
 495         sprintf(qxx, "_Q%02x", Data);
 496         strupr(qxx);
 497         Status = AcpiEvaluateObject(sc->ec_handle, qxx, NULL, NULL);
 498         /*
 499          * Ignore spurious query requests.
 500          */
 501         if (ACPI_FAILURE(Status) && (Data != 0 || Status != AE_NOT_FOUND)) {
 502             ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 503                 "evaluation of GPE query method %s failed - %s\n",
 504                         qxx, AcpiFormatException(Status));
 505         }
 506     }
 507         /* I know I request Level trigger cleanup */
 508     if (ACPI_FAILURE(AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE)))
 509             printf("EcGpeQueryHandler:ClearEvent Failed\n");
 510     if (ACPI_FAILURE(AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE, 0)))
 511             printf("EcGpeQueryHandler:EnableEvent Failed\n");
 512     return_VOID;
 513 }
 514
 515 /*
 516  * Handle a GPE sent to us.
 517  */
 518 static void
 519 EcGpeHandler(void *Context)
 520 {
 521     struct acpi_ec_softc *sc = Context;
 522     int csrvalue;
 523
 524     /*
 525      * If EC is locked, the intr must process EcRead/Write wait only.
 526      * Query request must be pending.
 527      */
 528     if (EcIsLocked(sc)){
 529         csrvalue = EC_GET_CSR(sc);
 530         if (csrvalue & EC_EVENT_SCI)
 531             sc->ec_pendquery = 1;
 532         if ((csrvalue & EC_FLAG_OUTPUT_BUFFER)
 533             || !(csrvalue & EC_FLAG_INPUT_BUFFER)) {
 534             sc->ec_csrvalue = csrvalue;
 535             wakeup((void *)&sc->ec_csrvalue);
 536         }
 537     }else{
 538         /* Queue GpeQuery Handler */
 539         if (ACPI_FAILURE(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH,
 540                                     EcGpeQueryHandler,Context))) {
 541             printf("QueryHandler Queuing Failed\n");
 542         }
 543     }
 544     return;
 545 }
 546
 547 static ACPI_STATUS
 548 EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context, void **RegionContext)
 549 {
 550
 551     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 552
 553     /*
 554      * Just pass the context through, there's nothing to do here.
 555      */
 556     *RegionContext = Context;
 557
 558     return_ACPI_STATUS(AE_OK);
 559 }
 560
 561 static ACPI_STATUS
 562 EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width, ACPI_INTEGER *Value,
 563                void *Context, void *RegionContext)
 564 {
 565     struct acpi_ec_softc        *sc = (struct acpi_ec_softc *)Context;
 566     ACPI_STATUS                 Status = AE_OK;
 567     EC_REQUEST                  EcRequest;
 568     int                         i;
 569
 570     ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Address);
 571
 572     if ((Address > 0xFF) || (width % 8 != 0) || (Value == NULL) || (Context == NULL))
 573         return_ACPI_STATUS(AE_BAD_PARAMETER);
 574
 575     switch (Function) {
 576     case ACPI_READ:
 577         EcRequest.Command = EC_COMMAND_READ;
 578         EcRequest.Address = Address;
 579         (*Value) = 0;
 580         break;
 581
 582     case ACPI_WRITE:
 583         EcRequest.Command = EC_COMMAND_WRITE;
 584         EcRequest.Address = Address;
 585         break;
 586
 587     default:
 588         device_printf(sc->ec_dev, "invalid Address Space function %d\n", Function);
 589         return_ACPI_STATUS(AE_BAD_PARAMETER);
 590     }
 591
 592     /*
 593      * Perform the transaction.
 594      */
 595     for (i = 0; i < width; i += 8) {
 596         if (Function == ACPI_READ)
 597             EcRequest.Data = 0;
 598         else
 599             EcRequest.Data = (UINT8)((*Value) >> i);
 600         if (ACPI_FAILURE(Status = EcTransaction(sc, &EcRequest)))
 601             break;
 602         (*Value) |= (ACPI_INTEGER)EcRequest.Data << i;
 603         if (++EcRequest.Address == 0)
 604             return_ACPI_STATUS(AE_BAD_PARAMETER);
 605     }
 606     return_ACPI_STATUS(Status);
 607 }
 608
 609 /*
 610  * Wait for an event interrupt for a specific condition.
 611  */
 612 static ACPI_STATUS
 613 EcWaitEventIntr(struct acpi_ec_softc *sc, EC_EVENT Event)
 614 {
 615     EC_STATUS   EcStatus;
 616     int         i;
 617
 618     ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Event);
 619
 620     /* XXX this should test whether interrupts are available some other way */
 621 #ifdef ACPI_EC_EVENT_DRIVEN
 622     if(cold)
 623 #endif
 624         return_ACPI_STATUS(EcWaitEvent(sc, Event));
 625
 626     if (!EcIsLocked(sc))
 627         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 628             "EcWaitEventIntr called without EC lock!\n");
 629
 630     EcStatus = EC_GET_CSR(sc);
 631
 632     /* XXX waiting too long? */
 633     for(i = 0; i < 10; i++){
 634         /*
 635          * Check EC status against the desired event.
 636          */
 637         if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) &&
 638             (EcStatus & EC_FLAG_OUTPUT_BUFFER))
 639             return_ACPI_STATUS(AE_OK);
 640
 641         if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) &&
 642             !(EcStatus & EC_FLAG_INPUT_BUFFER))
 643             return_ACPI_STATUS(AE_OK);
 644
 645         sc->ec_csrvalue = 0;
 646         if (ACPI_MSLEEP(&sc->ec_csrvalue, &acpi_mutex, PZERO, "EcWait", 1) != EWOULDBLOCK){
 647             EcStatus = sc->ec_csrvalue;
 648         }else{
 649             EcStatus = EC_GET_CSR(sc);
 650         }
 651     }
 652     return_ACPI_STATUS(AE_ERROR);
 653 }
 654
 655 static ACPI_STATUS
 656 EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event)
 657 {
 658     EC_STATUS   EcStatus;
 659     UINT32      i = 0;
 660
 661     if (!EcIsLocked(sc))
 662         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 663             "EcWaitEvent called without EC lock!\n");
 664
 665     /*
 666      * Stall 1us:
 667      * ----------
 668      * Stall for 1 microsecond before reading the status register
 669      * for the first time.  This allows the EC to set the IBF/OBF
 670      * bit to its proper state.
 671      *
 672      * XXX it is not clear why we read the CSR twice.
 673      */
 674     AcpiOsStall(1);
 675     EcStatus = EC_GET_CSR(sc);
 676
 677     /*
 678      * Wait For Event:
 679      * ---------------
 680      * Poll the EC status register to detect completion of the last
 681      * command.  Wait up to 10ms (in 10us chunks) for this to occur.
 682      */
 683     for (i = 0; i < 1000; i++) {
 684         EcStatus = EC_GET_CSR(sc);
 685
 686         if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) &&
 687             (EcStatus & EC_FLAG_OUTPUT_BUFFER))
 688             return(AE_OK);
 689
 690         if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) &&
 691             !(EcStatus & EC_FLAG_INPUT_BUFFER))
 692             return(AE_OK);
 693
 694         AcpiOsStall(10);
 695     }
 696
 697     return(AE_ERROR);
 698 }
 699
 700 static ACPI_STATUS
 701 EcQuery(struct acpi_ec_softc *sc, UINT8 *Data)
 702 {
 703     ACPI_STATUS Status;
 704
 705     if (ACPI_FAILURE(Status = EcLock(sc)))
 706         return(Status);
 707
 708     EC_SET_CSR(sc, EC_COMMAND_QUERY);
 709     if (ACPI_SUCCESS(Status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL)))
 710         *Data = EC_GET_DATA(sc);
 711
 712     EcUnlock(sc);
 713
 714     if (ACPI_FAILURE(Status))
 715         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 716             "timeout waiting for EC to respond to EC_COMMAND_QUERY\n");
 717     return(Status);
 718 }
 719
 720 static ACPI_STATUS
 721 EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest)
 722 {
 723     ACPI_STATUS Status;
 724
 725     /*
 726      * Lock the EC
 727      */
 728     if (ACPI_FAILURE(Status = EcLock(sc)))
 729         return(Status);
 730
 731     /*
 732      * Perform the transaction.
 733      */
 734     switch (EcRequest->Command) {
 735     case EC_COMMAND_READ:
 736         Status = EcRead(sc, EcRequest->Address, &(EcRequest->Data));
 737         break;
 738
 739     case EC_COMMAND_WRITE:
 740         Status = EcWrite(sc, EcRequest->Address, &(EcRequest->Data));
 741         break;
 742
 743     default:
 744         Status = AE_SUPPORT;
 745         break;
 746     }
 747
 748     /*
 749      * Unlock the EC
 750      */
 751     EcUnlock(sc);
 752
 753     /*
 754      * Clear & Re-Enable the EC GPE:
 755      * -----------------------------
 756      * 'Consume' any EC GPE events that we generated while performing
 757      * the transaction (e.g. IBF/OBF).  Clearing the GPE here shouldn't
 758      * have an adverse affect on outstanding EC-SCI's, as the source
 759      * (EC-SCI) will still be high and thus should trigger the GPE
 760      * immediately after we re-enabling it.
 761      */
 762     if (sc->ec_pendquery){
 763         if (ACPI_FAILURE(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH,
 764                                                  EcGpeQueryHandler, sc)))
 765             printf("Pend Query Queuing Failed\n");
 766         sc->ec_pendquery = 0;
 767     }
 768
 769     if (ACPI_FAILURE(AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE)))
 770         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 771             "EcRequest: Unable to clear the EC GPE.\n");
 772     if (ACPI_FAILURE(AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE, 0)))
 773         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 774             "EcRequest: Unable to re-enable the EC GPE.\n");
 775
 776     return(Status);
 777 }
 778
 779
 780 static ACPI_STATUS
 781 EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
 782 {
 783     ACPI_STATUS Status;
 784
 785     if (!EcIsLocked(sc))
 786         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 787             "EcRead called without EC lock!\n");
 788
 789     /*EcBurstEnable(EmbeddedController);*/
 790
 791     EC_SET_CSR(sc, EC_COMMAND_READ);
 792     if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY))) {
 793         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 794             "EcRead: Failed waiting for EC to process read command.\n");
 795         return(Status);
 796     }
 797
 798     EC_SET_DATA(sc, Address);
 799     if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_OUTPUT_BUFFER_FULL))) {
 800         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 801             "EcRead: Failed waiting for EC to send data.\n");
 802         return(Status);
 803     }
 804
 805     (*Data) = EC_GET_DATA(sc);
 806
 807     /*EcBurstDisable(EmbeddedController);*/
 808
 809     return(AE_OK);
 810 }
 811
 812 static ACPI_STATUS
 813 EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
 814 {
 815     ACPI_STATUS Status;
 816
 817     if (!EcIsLocked(sc))
 818         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 819             "EcWrite called without EC lock!\n");
 820
 821     /*EcBurstEnable(EmbeddedController);*/
 822
 823     EC_SET_CSR(sc, EC_COMMAND_WRITE);
 824     if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY))) {
 825         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 826             "EcWrite: Failed waiting for EC to process write command.\n");
 827         return(Status);
 828     }
 829
 830     EC_SET_DATA(sc, Address);
 831     if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY))) {
 832         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 833             "EcRead: Failed waiting for EC to process address.\n");
 834         return(Status);
 835     }
 836
 837     EC_SET_DATA(sc, *Data);
 838     if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY))) {
 839         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
 840             "EcWrite: Failed waiting for EC to process data.\n");
 841         return(Status);
 842     }
 843
 844     /*EcBurstDisable(EmbeddedController);*/
 845
 846     return(AE_OK);
 847 }