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$ 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 156 ACPI_MODULE_NAME("EC") 157 158 /* 159 * EC_COMMAND: 160 * ----------- 161 */ 162 typedef 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 */ 191 typedef 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 */ 202 typedef 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) */ 225 typedef 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 */ 247 struct 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 291 static __inline ACPI_STATUS 292 EcLock(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 309 static __inline void 310 EcUnlock(struct acpi_ec_softc *sc) 311 { 312 if (sc->ec_glk) 313 AcpiReleaseGlobalLock(sc->ec_glkhandle); 314 mtx_unlock(&sc->ec_mtx); 315 } 316 317 static void EcGpeHandler(void *Context); 318 static ACPI_STATUS EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, 319 void *Context, void **return_Context); 320 static ACPI_STATUS EcSpaceHandler(UINT32 Function, 321 ACPI_PHYSICAL_ADDRESS Address, 322 UINT32 width, ACPI_INTEGER *Value, 323 void *Context, void *RegionContext); 324 static ACPI_STATUS EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event); 325 static ACPI_STATUS EcCommand(struct acpi_ec_softc *sc, EC_COMMAND cmd); 326 static ACPI_STATUS EcRead(struct acpi_ec_softc *sc, UINT8 Address, 327 UINT8 *Data); 328 static ACPI_STATUS EcWrite(struct acpi_ec_softc *sc, UINT8 Address, 329 UINT8 *Data); 330 static int acpi_ec_probe(device_t dev); 331 static int acpi_ec_attach(device_t dev); 332 333 static 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 341 static driver_t acpi_ec_driver = { 342 "acpi_ec", 343 acpi_ec_methods, 344 sizeof(struct acpi_ec_softc), 345 }; 346 347 static devclass_t acpi_ec_devclass; 348 DRIVER_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 */ 356 void 357 acpi_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 414 static int 415 acpi_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 504 static int 505 acpi_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 592 static void 593 EcGpeQueryHandler(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 652 re_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 */ 664 static void 665 EcGpeHandler(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 686 static ACPI_STATUS 687 EcSpaceSetup(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 701 static ACPI_STATUS 702 EcSpaceHandler(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 751 static ACPI_STATUS 752 EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event) 753 { 754 EC_STATUS EcStatus; 755 ACPI_STATUS Status; 756 int i, period, retval; 757 758 mtx_assert(&sc->ec_mtx, MA_OWNED); 759 Status = AE_NO_HARDWARE_RESPONSE; 760 761 /* 762 * Wait for 1 us before checking the CSR. Testing shows about 763 * 50% of requests complete in 1 us and 90% of them complete 764 * in 5 us or less. 765 */ 766 AcpiOsStall(1); 767 768 /* 769 * Poll the EC status register to detect completion of the last 770 * command. First, wait up to 1 ms in chunks of sc->ec_polldelay 771 * microseconds. 772 */ 773 for (i = 0; i < 1000 / sc->ec_polldelay; i++) { 774 EcStatus = EC_GET_CSR(sc); 775 if (EVENT_READY(Event, EcStatus)) { 776 Status = AE_OK; 777 break; 778 } 779 AcpiOsStall(sc->ec_polldelay); 780 } 781 782 /* Scale poll delay by the amount of time actually waited. */ 783 period = i * sc->ec_polldelay; 784 if (period <= 5) 785 sc->ec_polldelay = 1; 786 else if (period <= 20) 787 sc->ec_polldelay = 5; 788 else if (period <= 100) 789 sc->ec_polldelay = 10; 790 else 791 sc->ec_polldelay = 100; 792 793 /* 794 * If we still don't have a response, wait up to EC_POLL_TIMEOUT ms 795 * for completion, sleeping for chunks of 10 ms. 796 */ 797 if (Status != AE_OK) { 798 retval = -1; 799 for (i = 0; i < EC_POLL_TIMEOUT / 10; i++) { 800 if (retval != 0) 801 EcStatus = EC_GET_CSR(sc); 802 else 803 EcStatus = sc->ec_csrvalue; 804 if (EVENT_READY(Event, EcStatus)) { 805 Status = AE_OK; 806 break; 807 } 808 retval = msleep(&sc->ec_csrvalue, &sc->ec_mtx, PZERO, "ecpoll", 809 10/*ms*/); 810 } 811 } 812 813 return (Status); 814 } 815 816 static ACPI_STATUS 817 EcCommand(struct acpi_ec_softc *sc, EC_COMMAND cmd) 818 { 819 ACPI_STATUS Status; 820 EC_EVENT Event; 821 822 mtx_assert(&sc->ec_mtx, MA_OWNED); 823 824 /* Decide what to wait for based on command type. */ 825 switch (cmd) { 826 case EC_COMMAND_READ: 827 case EC_COMMAND_WRITE: 828 case EC_COMMAND_BURST_DISABLE: 829 Event = EC_EVENT_INPUT_BUFFER_EMPTY; 830 break; 831 case EC_COMMAND_QUERY: 832 case EC_COMMAND_BURST_ENABLE: 833 Event = EC_EVENT_OUTPUT_BUFFER_FULL; 834 break; 835 default: 836 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 837 "EcCommand: Invalid command %#x\n", cmd); 838 return (AE_BAD_PARAMETER); 839 } 840 841 /* Run the command and wait for the chosen event. */ 842 EC_SET_CSR(sc, cmd); 843 Status = EcWaitEvent(sc, Event); 844 if (ACPI_FAILURE(Status)) { 845 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 846 "EcCommand: no response to %#x\n", cmd); 847 } 848 849 return (Status); 850 } 851 852 static ACPI_STATUS 853 EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data) 854 { 855 ACPI_STATUS Status; 856 857 mtx_assert(&sc->ec_mtx, MA_OWNED); 858 859 #ifdef notyet 860 /* If we can't start burst mode, continue anyway. */ 861 EcCommand(sc, EC_COMMAND_BURST_ENABLE); 862 #endif 863 864 Status = EcCommand(sc, EC_COMMAND_READ); 865 if (ACPI_FAILURE(Status)) 866 return (Status); 867 868 EC_SET_DATA(sc, Address); 869 Status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL); 870 if (ACPI_FAILURE(Status)) { 871 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 872 "EcRead: Failed waiting for EC to send data.\n"); 873 return (Status); 874 } 875 876 *Data = EC_GET_DATA(sc); 877 878 #ifdef notyet 879 if (sc->ec_burstactive) { 880 Status = EcCommand(sc, EC_COMMAND_BURST_DISABLE); 881 if (ACPI_FAILURE(Status)) 882 return (Status); 883 } 884 #endif 885 886 return (AE_OK); 887 } 888 889 static ACPI_STATUS 890 EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data) 891 { 892 ACPI_STATUS Status; 893 894 mtx_assert(&sc->ec_mtx, MA_OWNED); 895 896 #ifdef notyet 897 /* If we can't start burst mode, continue anyway. */ 898 EcCommand(sc, EC_COMMAND_BURST_ENABLE); 899 #endif 900 901 Status = EcCommand(sc, EC_COMMAND_WRITE); 902 if (ACPI_FAILURE(Status)) 903 return (Status); 904 905 EC_SET_DATA(sc, Address); 906 Status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY); 907 if (ACPI_FAILURE(Status)) { 908 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 909 "EcRead: Failed waiting for EC to process address\n"); 910 return (Status); 911 } 912 913 EC_SET_DATA(sc, *Data); 914 Status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY); 915 if (ACPI_FAILURE(Status)) { 916 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 917 "EcWrite: Failed waiting for EC to process data\n"); 918 return (Status); 919 } 920 921 #ifdef notyet 922 if (sc->ec_burstactive) { 923 Status = EcCommand(sc, EC_COMMAND_BURST_DISABLE); 924 if (ACPI_FAILURE(Status)) 925 return (Status); 926 } 927 #endif 928 929 return (AE_OK); 930 } 931