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: src/sys/dev/acpica/acpi_ec.c,v 1.38.2.1 2003/08/22 20:49:20 jhb Exp $ 28 * $DragonFly: src/sys/dev/acpica/Attic/acpi_ec.c,v 1.1 2003/09/24 03:32:16 drhodus Exp $ 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 /* 225 * Driver softc. 226 */ 227 struct acpi_ec_softc { 228 device_t ec_dev; 229 ACPI_HANDLE ec_handle; 230 UINT32 ec_gpebit; 231 232 int ec_data_rid; 233 struct resource *ec_data_res; 234 bus_space_tag_t ec_data_tag; 235 bus_space_handle_t ec_data_handle; 236 237 int ec_csr_rid; 238 struct resource *ec_csr_res; 239 bus_space_tag_t ec_csr_tag; 240 bus_space_handle_t ec_csr_handle; 241 242 int ec_locked; 243 int ec_lockhandle; 244 int ec_pendquery; 245 int ec_csrvalue; 246 }; 247 248 static int acpi_ec_event_driven = 0; 249 TUNABLE_INT("hw.acpi.ec.event_driven", &acpi_ec_event_driven); 250 251 #define EC_LOCK_TIMEOUT 1000 /* 1ms */ 252 253 static __inline ACPI_STATUS 254 EcLock(struct acpi_ec_softc *sc) 255 { 256 ACPI_STATUS status; 257 258 /* XXX ACPI_WAIT_FOREVER is probably a bad idea, what is a better time? */ 259 status = AcpiAcquireGlobalLock(ACPI_WAIT_FOREVER, &sc->ec_lockhandle); 260 if (ACPI_SUCCESS(status)) 261 sc->ec_locked = 1; 262 263 return (status); 264 } 265 266 static __inline void 267 EcUnlock(struct acpi_ec_softc *sc) 268 { 269 sc->ec_locked = 0; 270 AcpiReleaseGlobalLock(sc->ec_lockhandle); 271 } 272 273 static __inline int 274 EcIsLocked(struct acpi_ec_softc *sc) 275 { 276 return (sc->ec_locked != 0); 277 } 278 279 typedef struct 280 { 281 EC_COMMAND Command; 282 UINT8 Address; 283 UINT8 Data; 284 } EC_REQUEST; 285 286 static void EcGpeHandler(void *Context); 287 static ACPI_STATUS EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, 288 void *Context, void **return_Context); 289 static ACPI_STATUS EcSpaceHandler(UINT32 Function, 290 ACPI_PHYSICAL_ADDRESS Address, 291 UINT32 width, ACPI_INTEGER *Value, 292 void *Context, void *RegionContext); 293 static ACPI_STATUS EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event); 294 static ACPI_STATUS EcQuery(struct acpi_ec_softc *sc, UINT8 *Data); 295 static ACPI_STATUS EcTransaction(struct acpi_ec_softc *sc, 296 EC_REQUEST *EcRequest); 297 static ACPI_STATUS EcRead(struct acpi_ec_softc *sc, UINT8 Address, 298 UINT8 *Data); 299 static ACPI_STATUS EcWrite(struct acpi_ec_softc *sc, UINT8 Address, 300 UINT8 *Data); 301 static void acpi_ec_identify(driver_t driver, device_t bus); 302 static int acpi_ec_probe(device_t dev); 303 static int acpi_ec_attach(device_t dev); 304 305 static device_method_t acpi_ec_methods[] = { 306 /* Device interface */ 307 DEVMETHOD(device_identify, acpi_ec_identify), 308 DEVMETHOD(device_probe, acpi_ec_probe), 309 DEVMETHOD(device_attach, acpi_ec_attach), 310 311 {0, 0} 312 }; 313 314 static driver_t acpi_ec_driver = { 315 "acpi_ec", 316 acpi_ec_methods, 317 sizeof(struct acpi_ec_softc), 318 }; 319 320 static devclass_t acpi_ec_devclass; 321 DRIVER_MODULE(acpi_ec, acpi, acpi_ec_driver, acpi_ec_devclass, 0, 0); 322 323 /* 324 * Look for an ECDT table and if we find one, set up a default EC 325 * space handler to catch possible attempts to access EC space before 326 * we have a real driver instance in place. 327 * We're not really an identify routine, but because we get called 328 * before most other things, this works out OK. 329 */ 330 static void 331 acpi_ec_identify(driver_t driver, device_t bus) 332 { 333 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 334 335 /* XXX implement - need an ACPI 2.0 system to test this */ 336 } 337 338 /* 339 * We could setup resources in the probe routine in order to have them printed 340 * when the device is attached. 341 */ 342 static int 343 acpi_ec_probe(device_t dev) 344 { 345 346 if (acpi_get_type(dev) == ACPI_TYPE_DEVICE && !acpi_disabled("ec") && 347 acpi_MatchHid(dev, "PNP0C09")) { 348 349 /* 350 * Set device description 351 */ 352 device_set_desc(dev, "embedded controller"); 353 return (0); 354 } 355 return (ENXIO); 356 } 357 358 static int 359 acpi_ec_attach(device_t dev) 360 { 361 struct acpi_ec_softc *sc; 362 ACPI_STATUS Status; 363 int errval = 0; 364 365 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 366 367 /* 368 * Fetch/initialise softc 369 */ 370 sc = device_get_softc(dev); 371 bzero(sc, sizeof(*sc)); 372 sc->ec_dev = dev; 373 sc->ec_handle = acpi_get_handle(dev); 374 375 /* 376 * Attach bus resources 377 */ 378 sc->ec_data_rid = 0; 379 sc->ec_data_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, 380 &sc->ec_data_rid, 0, ~0, 1, RF_ACTIVE); 381 if (sc->ec_data_res == NULL) { 382 device_printf(dev, "can't allocate data port\n"); 383 errval = ENXIO; 384 goto out; 385 } 386 sc->ec_data_tag = rman_get_bustag(sc->ec_data_res); 387 sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res); 388 389 sc->ec_csr_rid = 1; 390 sc->ec_csr_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, 391 &sc->ec_csr_rid, 0, ~0, 1, RF_ACTIVE); 392 if (sc->ec_csr_res == NULL) { 393 device_printf(dev, "can't allocate command/status port\n"); 394 errval = ENXIO; 395 goto out; 396 } 397 sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res); 398 sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res); 399 400 /* 401 * Install GPE handler 402 * 403 * Evaluate the _GPE method to find the GPE bit used by the EC to signal 404 * status (SCI). 405 */ 406 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE\n")); 407 Status = acpi_EvaluateInteger(sc->ec_handle, "_GPE", &sc->ec_gpebit); 408 if (ACPI_FAILURE(Status)) { 409 device_printf(dev, "can't evaluate _GPE - %s\n", 410 AcpiFormatException(Status)); 411 errval = ENXIO; 412 goto out; 413 } 414 415 /* 416 * Install a handler for this EC's GPE bit. Note that EC SCIs are 417 * treated as both edge- and level-triggered interrupts; in other words 418 * we clear the status bit immediately after getting an EC-SCI, then 419 * again after we're done processing the event. This guarantees that 420 * events we cause while performing a transaction (e.g. IBE/OBF) get 421 * cleared before re-enabling the GPE. 422 */ 423 Status = AcpiInstallGpeHandler(sc->ec_gpebit, 424 ACPI_EVENT_LEVEL_TRIGGERED | ACPI_EVENT_EDGE_TRIGGERED, 425 EcGpeHandler, sc); 426 if (ACPI_FAILURE(Status)) { 427 device_printf(dev, "can't install GPE handler for %s - %s\n", 428 acpi_name(sc->ec_handle), AcpiFormatException(Status)); 429 errval = ENXIO; 430 goto out; 431 } 432 433 /* 434 * Install address space handler 435 */ 436 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n")); 437 Status = AcpiInstallAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC, 438 EcSpaceHandler, EcSpaceSetup, sc); 439 if (ACPI_FAILURE(Status)) { 440 device_printf(dev, "can't install address space handler for %s - %s\n", 441 acpi_name(sc->ec_handle), AcpiFormatException(Status)); 442 panic("very suck"); 443 errval = ENXIO; 444 goto out; 445 } 446 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attach complete\n")); 447 return_VALUE (0); 448 449 out: 450 if (sc->ec_csr_res) 451 bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_csr_rid, 452 sc->ec_csr_res); 453 if (sc->ec_data_res) 454 bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_data_rid, 455 sc->ec_data_res); 456 return_VALUE (errval); 457 } 458 459 static void 460 EcGpeQueryHandler(void *Context) 461 { 462 struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context; 463 UINT8 Data; 464 ACPI_STATUS Status; 465 char qxx[5]; 466 467 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 468 469 for (;;) { 470 471 /* 472 * Check EC_SCI. 473 * 474 * Bail out if the EC_SCI bit of the status register is not set. 475 * Note that this function should only be called when 476 * this bit is set (polling is used to detect IBE/OBF events). 477 * 478 * It is safe to do this without locking the controller, as it's 479 * OK to call EcQuery when there's no data ready; in the worst 480 * case we should just find nothing waiting for us and bail. 481 */ 482 if ((EC_GET_CSR(sc) & EC_EVENT_SCI) == 0) 483 break; 484 485 /* 486 * Find out why the EC is signalling us 487 */ 488 Status = EcQuery(sc, &Data); 489 490 /* 491 * If we failed to get anything from the EC, give up 492 */ 493 if (ACPI_FAILURE(Status)) { 494 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 495 "GPE query failed - %s\n", AcpiFormatException(Status)); 496 break; 497 } 498 499 /* 500 * Evaluate _Qxx to respond to the controller. 501 */ 502 sprintf(qxx, "_Q%02x", Data); 503 strupr(qxx); 504 Status = AcpiEvaluateObject(sc->ec_handle, qxx, NULL, NULL); 505 /* 506 * Ignore spurious query requests. 507 */ 508 if (ACPI_FAILURE(Status) && (Data != 0 || Status != AE_NOT_FOUND)) { 509 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 510 "evaluation of GPE query method %s failed - %s\n", 511 qxx, AcpiFormatException(Status)); 512 } 513 } 514 /* I know I request Level trigger cleanup */ 515 if (ACPI_FAILURE(AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE))) 516 printf("EcGpeQueryHandler:ClearEvent Failed\n"); 517 if (ACPI_FAILURE(AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE, 0))) 518 printf("EcGpeQueryHandler:EnableEvent Failed\n"); 519 } 520 521 /* 522 * Handle a GPE sent to us. 523 */ 524 static void 525 EcGpeHandler(void *Context) 526 { 527 struct acpi_ec_softc *sc = Context; 528 int csrvalue; 529 530 /* 531 * If EC is locked, the intr must process EcRead/Write wait only. 532 * Query request must be pending. 533 */ 534 if (EcIsLocked(sc)) { 535 csrvalue = EC_GET_CSR(sc); 536 if (csrvalue & EC_EVENT_SCI) 537 sc->ec_pendquery = 1; 538 if ((csrvalue & EC_FLAG_OUTPUT_BUFFER) != 0 || 539 (csrvalue & EC_FLAG_INPUT_BUFFER) == 0) { 540 sc->ec_csrvalue = csrvalue; 541 wakeup(&sc->ec_csrvalue); 542 } 543 } else { 544 /* Queue GpeQuery Handler */ 545 if (ACPI_FAILURE(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH, 546 EcGpeQueryHandler,Context))) { 547 printf("QueryHandler Queuing Failed\n"); 548 } 549 } 550 } 551 552 static ACPI_STATUS 553 EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context, 554 void **RegionContext) 555 { 556 557 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 558 559 /* 560 * Just pass the context through, there's nothing to do here. 561 */ 562 *RegionContext = Context; 563 564 return_ACPI_STATUS (AE_OK); 565 } 566 567 static ACPI_STATUS 568 EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width, 569 ACPI_INTEGER *Value, void *Context, void *RegionContext) 570 { 571 struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context; 572 ACPI_STATUS Status = AE_OK; 573 EC_REQUEST EcRequest; 574 int i; 575 576 ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Address); 577 578 if (Address > 0xFF || width % 8 != 0 || Value == NULL || Context == NULL) 579 return_ACPI_STATUS (AE_BAD_PARAMETER); 580 581 switch (Function) { 582 case ACPI_READ: 583 EcRequest.Command = EC_COMMAND_READ; 584 EcRequest.Address = Address; 585 (*Value) = 0; 586 break; 587 case ACPI_WRITE: 588 EcRequest.Command = EC_COMMAND_WRITE; 589 EcRequest.Address = Address; 590 break; 591 default: 592 device_printf(sc->ec_dev, "invalid Address Space function %d\n", 593 Function); 594 return_ACPI_STATUS (AE_BAD_PARAMETER); 595 } 596 597 /* 598 * Perform the transaction. 599 */ 600 for (i = 0; i < width; i += 8) { 601 if (Function == ACPI_READ) 602 EcRequest.Data = 0; 603 else 604 EcRequest.Data = (UINT8)((*Value) >> i); 605 Status = EcTransaction(sc, &EcRequest); 606 if (ACPI_FAILURE(Status)) 607 break; 608 *Value |= (ACPI_INTEGER)EcRequest.Data << i; 609 if (++EcRequest.Address == 0) 610 return_ACPI_STATUS (AE_BAD_PARAMETER); 611 } 612 return_ACPI_STATUS (Status); 613 } 614 615 /* 616 * Wait for an event interrupt for a specific condition. 617 */ 618 static ACPI_STATUS 619 EcWaitEventIntr(struct acpi_ec_softc *sc, EC_EVENT Event) 620 { 621 EC_STATUS EcStatus; 622 int i; 623 624 ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Event); 625 626 /* XXX this should test whether interrupts are available some other way */ 627 if (cold || acpi_ec_event_driven) 628 return_ACPI_STATUS (EcWaitEvent(sc, Event)); 629 630 if (!EcIsLocked(sc)) { 631 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 632 "EcWaitEventIntr called without EC lock!\n"); 633 } 634 635 EcStatus = EC_GET_CSR(sc); 636 637 /* XXX waiting too long? */ 638 for (i = 0; i < 10; i++) { 639 /* 640 * Check EC status against the desired event. 641 */ 642 if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) && 643 (EcStatus & EC_FLAG_OUTPUT_BUFFER) != 0) 644 return_ACPI_STATUS (AE_OK); 645 646 if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) && 647 (EcStatus & EC_FLAG_INPUT_BUFFER) == 0) 648 return_ACPI_STATUS (AE_OK); 649 650 sc->ec_csrvalue = 0; 651 /* XXX sleeping with Acpi Global Lock held */ 652 if (tsleep(&sc->ec_csrvalue, 0, "EcWait", 1) != EWOULDBLOCK) { 653 EcStatus = sc->ec_csrvalue; 654 } else { 655 EcStatus = EC_GET_CSR(sc); 656 } 657 } 658 return_ACPI_STATUS (AE_ERROR); 659 } 660 661 static ACPI_STATUS 662 EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event) 663 { 664 EC_STATUS EcStatus; 665 UINT32 i = 0; 666 667 if (!EcIsLocked(sc)) { 668 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 669 "EcWaitEvent called without EC lock!\n"); 670 } 671 672 /* 673 * Stall 1us: 674 * ---------- 675 * Stall for 1 microsecond before reading the status register 676 * for the first time. This allows the EC to set the IBF/OBF 677 * bit to its proper state. 678 * 679 * XXX it is not clear why we read the CSR twice. 680 */ 681 AcpiOsStall(1); 682 EcStatus = EC_GET_CSR(sc); 683 684 /* 685 * Wait For Event: 686 * --------------- 687 * Poll the EC status register to detect completion of the last 688 * command. Wait up to 10ms (in 10us chunks) for this to occur. 689 */ 690 for (i = 0; i < 1000; i++) { 691 EcStatus = EC_GET_CSR(sc); 692 693 if (Event == EC_EVENT_OUTPUT_BUFFER_FULL && 694 (EcStatus & EC_FLAG_OUTPUT_BUFFER) != 0) 695 return (AE_OK); 696 697 if (Event == EC_EVENT_INPUT_BUFFER_EMPTY && 698 (EcStatus & EC_FLAG_INPUT_BUFFER) == 0) 699 return(AE_OK); 700 701 AcpiOsStall(10); 702 } 703 704 return (AE_ERROR); 705 } 706 707 static ACPI_STATUS 708 EcQuery(struct acpi_ec_softc *sc, UINT8 *Data) 709 { 710 ACPI_STATUS Status; 711 712 Status = EcLock(sc); 713 if (ACPI_FAILURE(Status)) 714 return (Status); 715 716 EC_SET_CSR(sc, EC_COMMAND_QUERY); 717 Status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL); 718 if (ACPI_SUCCESS(Status)) 719 *Data = EC_GET_DATA(sc); 720 721 EcUnlock(sc); 722 723 if (ACPI_FAILURE(Status)) { 724 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 725 "timeout waiting for EC to respond to EC_COMMAND_QUERY\n"); 726 } 727 return (Status); 728 } 729 730 static ACPI_STATUS 731 EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest) 732 { 733 ACPI_STATUS Status; 734 735 Status = EcLock(sc); 736 if (ACPI_FAILURE(Status)) 737 return (Status); 738 739 /* 740 * Perform the transaction. 741 */ 742 switch (EcRequest->Command) { 743 case EC_COMMAND_READ: 744 Status = EcRead(sc, EcRequest->Address, &EcRequest->Data); 745 break; 746 case EC_COMMAND_WRITE: 747 Status = EcWrite(sc, EcRequest->Address, &EcRequest->Data); 748 break; 749 default: 750 Status = AE_SUPPORT; 751 break; 752 } 753 754 EcUnlock(sc); 755 756 /* 757 * Clear & Re-Enable the EC GPE: 758 * ----------------------------- 759 * 'Consume' any EC GPE events that we generated while performing 760 * the transaction (e.g. IBF/OBF). Clearing the GPE here shouldn't 761 * have an adverse affect on outstanding EC-SCI's, as the source 762 * (EC-SCI) will still be high and thus should trigger the GPE 763 * immediately after we re-enabling it. 764 */ 765 if (sc->ec_pendquery) { 766 if (ACPI_FAILURE(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH, 767 EcGpeQueryHandler, sc))) 768 printf("Pend Query Queuing Failed\n"); 769 sc->ec_pendquery = 0; 770 } 771 772 if (ACPI_FAILURE(AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE))) { 773 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 774 "EcRequest: Unable to clear the EC GPE.\n"); 775 } 776 if (ACPI_FAILURE(AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE, 0))) { 777 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 778 "EcRequest: Unable to re-enable the EC GPE.\n"); 779 } 780 781 return (Status); 782 } 783 784 785 static ACPI_STATUS 786 EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data) 787 { 788 ACPI_STATUS Status; 789 790 if (!EcIsLocked(sc)) { 791 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 792 "EcRead called without EC lock!\n"); 793 } 794 795 /*EcBurstEnable(EmbeddedController);*/ 796 797 EC_SET_CSR(sc, EC_COMMAND_READ); 798 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY); 799 if (ACPI_FAILURE(Status)) { 800 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 801 "EcRead: Failed waiting for EC to process read command.\n"); 802 return (Status); 803 } 804 805 EC_SET_DATA(sc, Address); 806 Status = EcWaitEventIntr(sc, EC_EVENT_OUTPUT_BUFFER_FULL); 807 if (ACPI_FAILURE(Status)) { 808 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 809 "EcRead: Failed waiting for EC to send data.\n"); 810 return (Status); 811 } 812 813 *Data = EC_GET_DATA(sc); 814 815 /*EcBurstDisable(EmbeddedController);*/ 816 817 return (AE_OK); 818 } 819 820 static ACPI_STATUS 821 EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data) 822 { 823 ACPI_STATUS Status; 824 825 if (!EcIsLocked(sc)) { 826 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 827 "EcWrite called without EC lock!\n"); 828 } 829 830 /*EcBurstEnable(EmbeddedController);*/ 831 832 EC_SET_CSR(sc, EC_COMMAND_WRITE); 833 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY); 834 if (ACPI_FAILURE(Status)) { 835 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 836 "EcWrite: Failed waiting for EC to process write command.\n"); 837 return (Status); 838 } 839 840 EC_SET_DATA(sc, Address); 841 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY); 842 if (ACPI_FAILURE(Status)) { 843 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 844 "EcRead: Failed waiting for EC to process address.\n"); 845 return (Status); 846 } 847 848 EC_SET_DATA(sc, *Data); 849 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY); 850 if (ACPI_FAILURE(Status)) { 851 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 852 "EcWrite: Failed waiting for EC to process data.\n"); 853 return (Status); 854 } 855 856 /*EcBurstDisable(EmbeddedController);*/ 857 858 return (AE_OK); 859 } 860