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