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 #include <dev/acpica/acpi_ecreg.h> 151 152 /* 153 * Hooks for the ACPI CA debugging infrastructure 154 */ 155 #define _COMPONENT ACPI_EC 156 MODULE_NAME("EC") 157 158 struct acpi_ec_softc { 159 device_t ec_dev; 160 ACPI_HANDLE ec_handle; 161 UINT32 ec_gpebit; 162 163 int ec_data_rid; 164 struct resource *ec_data_res; 165 bus_space_tag_t ec_data_tag; 166 bus_space_handle_t ec_data_handle; 167 168 int ec_csr_rid; 169 struct resource *ec_csr_res; 170 bus_space_tag_t ec_csr_tag; 171 bus_space_handle_t ec_csr_handle; 172 173 int ec_locked; 174 int ec_pendquery; 175 int ec_csrvalue; 176 }; 177 178 #define EC_LOCK_TIMEOUT 1000 /* 1ms */ 179 180 static __inline ACPI_STATUS 181 EcLock(struct acpi_ec_softc *sc) 182 { 183 ACPI_STATUS status; 184 185 status = AcpiAcquireGlobalLock(); 186 (sc)->ec_locked = 1; 187 return(status); 188 } 189 190 static __inline void 191 EcUnlock(struct acpi_ec_softc *sc) 192 { 193 (sc)->ec_locked = 0; 194 AcpiReleaseGlobalLock(); 195 } 196 197 static __inline int 198 EcIsLocked(struct acpi_ec_softc *sc) 199 { 200 return((sc)->ec_locked != 0); 201 } 202 203 typedef struct 204 { 205 EC_COMMAND Command; 206 UINT8 Address; 207 UINT8 Data; 208 } EC_REQUEST; 209 210 static void EcGpeHandler(void *Context); 211 static ACPI_STATUS EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, 212 void *Context, void **return_Context); 213 static ACPI_STATUS EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width, UINT32 *Value, 214 void *Context, void *RegionContext); 215 216 static ACPI_STATUS EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event); 217 static ACPI_STATUS EcQuery(struct acpi_ec_softc *sc, UINT8 *Data); 218 static ACPI_STATUS EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest); 219 static ACPI_STATUS EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data); 220 static ACPI_STATUS EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data); 221 222 static void acpi_ec_identify(driver_t driver, device_t bus); 223 static int acpi_ec_probe(device_t dev); 224 static int acpi_ec_attach(device_t dev); 225 226 static device_method_t acpi_ec_methods[] = { 227 /* Device interface */ 228 DEVMETHOD(device_identify, acpi_ec_identify), 229 DEVMETHOD(device_probe, acpi_ec_probe), 230 DEVMETHOD(device_attach, acpi_ec_attach), 231 232 {0, 0} 233 }; 234 235 static driver_t acpi_ec_driver = { 236 "acpi_ec", 237 acpi_ec_methods, 238 sizeof(struct acpi_ec_softc), 239 }; 240 241 devclass_t acpi_ec_devclass; 242 DRIVER_MODULE(acpi_ec, acpi, acpi_ec_driver, acpi_ec_devclass, 0, 0); 243 244 /* 245 * Look for an ECDT table and if we find one, set up a default EC 246 * space handler to catch possible attempts to access EC space before 247 * we have a real driver instance in place. 248 * We're not really an identify routine, but because we get called 249 * before most other things, this works out OK. 250 */ 251 static void 252 acpi_ec_identify(driver_t driver, device_t bus) 253 { 254 FUNCTION_TRACE(__func__); 255 256 /* XXX implement - need an ACPI 2.0 system to test this */ 257 258 return_VOID; 259 } 260 261 /* 262 * We could setup resources in the probe routine in order to have them printed 263 * when the device is attached. 264 */ 265 static int 266 acpi_ec_probe(device_t dev) 267 { 268 269 if ((acpi_get_type(dev) == ACPI_TYPE_DEVICE) && 270 !acpi_disabled("ec") && 271 acpi_MatchHid(dev, "PNP0C09")) { 272 273 /* 274 * Set device description 275 */ 276 device_set_desc(dev, "embedded controller"); 277 278 return(0); 279 } 280 return(ENXIO); 281 } 282 283 static int 284 acpi_ec_attach(device_t dev) 285 { 286 struct acpi_ec_softc *sc; 287 ACPI_STATUS Status; 288 289 FUNCTION_TRACE(__func__); 290 291 /* 292 * Fetch/initialise softc 293 */ 294 sc = device_get_softc(dev); 295 bzero(sc, sizeof(*sc)); 296 sc->ec_dev = dev; 297 sc->ec_handle = acpi_get_handle(dev); 298 299 /* 300 * Evaluate resources 301 */ 302 DEBUG_PRINT(TRACE_RESOURCES, ("parsing EC resources\n")); 303 acpi_parse_resources(sc->ec_dev, sc->ec_handle, &acpi_res_parse_set); 304 305 /* 306 * Attach bus resources 307 */ 308 sc->ec_data_rid = 0; 309 if ((sc->ec_data_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, &sc->ec_data_rid, 310 0, ~0, 1, RF_ACTIVE)) == NULL) { 311 device_printf(dev, "can't allocate data port\n"); 312 return_VALUE(ENXIO); 313 } 314 sc->ec_data_tag = rman_get_bustag(sc->ec_data_res); 315 sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res); 316 317 sc->ec_csr_rid = 1; 318 if ((sc->ec_csr_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, &sc->ec_csr_rid, 319 0, ~0, 1, RF_ACTIVE)) == NULL) { 320 device_printf(dev, "can't allocate command/status port\n"); 321 return_VALUE(ENXIO); 322 } 323 sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res); 324 sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res); 325 326 /* 327 * Install GPE handler 328 * 329 * Evaluate the _GPE method to find the GPE bit used by the EC to signal 330 * status (SCI). 331 */ 332 DEBUG_PRINT(TRACE_RESOURCES, ("attaching GPE\n")); 333 if ((Status = acpi_EvaluateInteger(sc->ec_handle, "_GPE", &sc->ec_gpebit)) != AE_OK) { 334 device_printf(dev, "can't evaluate _GPE - %s\n", acpi_strerror(Status)); 335 return_VALUE(ENXIO); 336 } 337 338 /* 339 * Install a handler for this EC's GPE bit. Note that EC SCIs are 340 * treated as both edge- and level-triggered interrupts; in other words 341 * we clear the status bit immediately after getting an EC-SCI, then 342 * again after we're done processing the event. This guarantees that 343 * events we cause while performing a transaction (e.g. IBE/OBF) get 344 * cleared before re-enabling the GPE. 345 */ 346 if ((Status = AcpiInstallGpeHandler(sc->ec_gpebit, ACPI_EVENT_LEVEL_TRIGGERED | ACPI_EVENT_EDGE_TRIGGERED, 347 EcGpeHandler, sc)) != AE_OK) { 348 device_printf(dev, "can't install GPE handler for %s - %s\n", 349 acpi_name(sc->ec_handle), acpi_strerror(Status)); 350 return_VALUE(ENXIO); 351 } 352 353 /* 354 * Install address space handler 355 */ 356 DEBUG_PRINT(TRACE_RESOURCES, ("attaching address space handler\n")); 357 if ((Status = AcpiInstallAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC, 358 EcSpaceHandler, EcSpaceSetup, sc)) != AE_OK) { 359 device_printf(dev, "can't install address space handler for %s - %s\n", 360 acpi_name(sc->ec_handle), acpi_strerror(Status)); 361 panic("very suck"); 362 return_VALUE(ENXIO); 363 } 364 DEBUG_PRINT(TRACE_RESOURCES, ("attach complete\n")); 365 366 return_VALUE(0); 367 } 368 369 static void 370 EcGpeQueryHandler(void *Context) 371 { 372 struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context; 373 UINT8 Data; 374 ACPI_STATUS Status; 375 char qxx[5]; 376 377 FUNCTION_TRACE(__func__); 378 379 for (;;) { 380 381 /* 382 * Check EC_SCI. 383 * 384 * Bail out if the EC_SCI bit of the status register is not set. 385 * Note that this function should only be called when 386 * this bit is set (polling is used to detect IBE/OBF events). 387 * 388 * It is safe to do this without locking the controller, as it's 389 * OK to call EcQuery when there's no data ready; in the worst 390 * case we should just find nothing waiting for us and bail. 391 */ 392 if (!(EC_GET_CSR(sc) & EC_EVENT_SCI)) 393 break; 394 395 /* 396 * Find out why the EC is signalling us 397 */ 398 Status = EcQuery(sc, &Data); 399 400 /* 401 * If we failed to get anything from the EC, give up 402 */ 403 if (Status != AE_OK) { 404 device_printf(sc->ec_dev, "GPE query failed - %s\n", acpi_strerror(Status)); 405 break; 406 } 407 408 /* 409 * Evaluate _Qxx to respond to the controller. 410 */ 411 sprintf(qxx, "_Q%02x", Data); 412 strupr(qxx); 413 Status = AcpiEvaluateObject(sc->ec_handle, qxx, NULL, NULL); 414 /* 415 * Ignore spurious query requests. 416 */ 417 if (Status != AE_OK && (Data != 0 || Status != AE_NOT_FOUND)) { 418 device_printf(sc->ec_dev, "evaluation of GPE query method %s failed - %s\n", 419 qxx, acpi_strerror(Status)); 420 } 421 } 422 /* I know I request Level trigger cleanup */ 423 if(AcpiClearEvent(sc->ec_gpebit,ACPI_EVENT_GPE) != AE_OK) 424 printf("EcGpeQueryHandler:ClearEvent Failed\n"); 425 if(AcpiEnableEvent(sc->ec_gpebit,ACPI_EVENT_GPE) != AE_OK) 426 printf("EcGpeQueryHandler:EnableEvent Failed\n"); 427 return_VOID; 428 } 429 430 /* 431 * Handle a GPE sent to us. 432 */ 433 static void 434 EcGpeHandler(void *Context) 435 { 436 struct acpi_ec_softc *sc = Context; 437 int csrvalue; 438 439 /* 440 * If EC is locked, the intr must process EcRead/Write wait only. 441 * Query request must be pending. 442 */ 443 if (EcIsLocked(sc)){ 444 csrvalue = EC_GET_CSR(sc); 445 if (csrvalue & EC_EVENT_SCI) 446 sc->ec_pendquery = 1; 447 if ((csrvalue & EC_FLAG_OUTPUT_BUFFER) 448 || !(csrvalue & EC_FLAG_INPUT_BUFFER)) { 449 sc->ec_csrvalue = csrvalue; 450 wakeup((void *)&sc->ec_csrvalue); 451 } 452 }else{ 453 /* Queue GpeQuery Handler */ 454 if (AcpiOsQueueForExecution(OSD_PRIORITY_HIGH, 455 EcGpeQueryHandler,Context) != AE_OK){ 456 printf("QueryHandler Queuing Failed\n"); 457 } 458 } 459 return; 460 } 461 462 static ACPI_STATUS 463 EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context, void **RegionContext) 464 { 465 466 FUNCTION_TRACE(__func__); 467 468 /* 469 * Just pass the context through, there's nothing to do here. 470 */ 471 *RegionContext = Context; 472 473 return_ACPI_STATUS(AE_OK); 474 } 475 476 static ACPI_STATUS 477 EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width, UINT32 *Value, 478 void *Context, void *RegionContext) 479 { 480 struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context; 481 ACPI_STATUS Status = AE_OK; 482 EC_REQUEST EcRequest; 483 int i; 484 485 FUNCTION_TRACE_U32(__func__, (UINT32)Address); 486 487 if ((Address > 0xFF) || (width % 8 != 0) || (Value == NULL) || (Context == NULL)) 488 return_ACPI_STATUS(AE_BAD_PARAMETER); 489 490 switch (Function) { 491 case ACPI_READ_ADR_SPACE: 492 EcRequest.Command = EC_COMMAND_READ; 493 EcRequest.Address = Address; 494 (*Value) = 0; 495 break; 496 497 case ACPI_WRITE_ADR_SPACE: 498 EcRequest.Command = EC_COMMAND_WRITE; 499 EcRequest.Address = Address; 500 break; 501 502 default: 503 device_printf(sc->ec_dev, "invalid Address Space function %d\n", Function); 504 return_ACPI_STATUS(AE_BAD_PARAMETER); 505 } 506 507 /* 508 * Perform the transaction. 509 */ 510 for (i = 0; i < width; i += 8) { 511 if (Function == ACPI_READ_ADR_SPACE) 512 EcRequest.Data = 0; 513 else 514 EcRequest.Data = (UINT8)((*Value) >> i); 515 if ((Status = EcTransaction(sc, &EcRequest)) != AE_OK) 516 break; 517 (*Value) |= (UINT32)EcRequest.Data << i; 518 if (++EcRequest.Address == 0) 519 return_ACPI_STATUS(AE_BAD_PARAMETER); 520 } 521 return_ACPI_STATUS(Status); 522 } 523 524 /* 525 * Wait for an event interrupt for a specific condition. 526 */ 527 static ACPI_STATUS 528 EcWaitEventIntr(struct acpi_ec_softc *sc, EC_EVENT Event) 529 { 530 EC_STATUS EcStatus; 531 int i; 532 533 FUNCTION_TRACE_U32(__func__, (UINT32)Event); 534 535 /* XXX this should test whether interrupts are available some other way */ 536 if(cold) 537 return_ACPI_STATUS(EcWaitEvent(sc, Event)); 538 539 if (!EcIsLocked(sc)) 540 device_printf(sc->ec_dev, "EcWaitEventIntr called without EC lock!\n"); 541 542 EcStatus = EC_GET_CSR(sc); 543 544 /* XXX waiting too long? */ 545 for(i = 0; i < 10; i++){ 546 /* 547 * Check EC status against the desired event. 548 */ 549 if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) && 550 (EcStatus & EC_FLAG_OUTPUT_BUFFER)) 551 return_ACPI_STATUS(AE_OK); 552 553 if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) && 554 !(EcStatus & EC_FLAG_INPUT_BUFFER)) 555 return_ACPI_STATUS(AE_OK); 556 557 sc->ec_csrvalue = 0; 558 if (ACPI_MSLEEP(&sc->ec_csrvalue, &acpi_mutex, PZERO, "EcWait", 1) != EWOULDBLOCK){ 559 EcStatus = sc->ec_csrvalue; 560 }else{ 561 EcStatus = EC_GET_CSR(sc); 562 } 563 } 564 return_ACPI_STATUS(AE_ERROR); 565 } 566 567 static ACPI_STATUS 568 EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event) 569 { 570 EC_STATUS EcStatus; 571 UINT32 i = 0; 572 573 if (!EcIsLocked(sc)) 574 device_printf(sc->ec_dev, "EcWaitEvent called without EC lock!\n"); 575 576 /* 577 * Stall 1us: 578 * ---------- 579 * Stall for 1 microsecond before reading the status register 580 * for the first time. This allows the EC to set the IBF/OBF 581 * bit to its proper state. 582 * 583 * XXX it is not clear why we read the CSR twice. 584 */ 585 AcpiOsSleepUsec(1); 586 EcStatus = EC_GET_CSR(sc); 587 588 /* 589 * Wait For Event: 590 * --------------- 591 * Poll the EC status register to detect completion of the last 592 * command. Wait up to 10ms (in 10us chunks) for this to occur. 593 */ 594 for (i = 0; i < 1000; i++) { 595 EcStatus = EC_GET_CSR(sc); 596 597 if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) && 598 (EcStatus & EC_FLAG_OUTPUT_BUFFER)) 599 return(AE_OK); 600 601 if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) && 602 !(EcStatus & EC_FLAG_INPUT_BUFFER)) 603 return(AE_OK); 604 605 AcpiOsSleepUsec(10); 606 } 607 608 return(AE_ERROR); 609 } 610 611 static ACPI_STATUS 612 EcQuery(struct acpi_ec_softc *sc, UINT8 *Data) 613 { 614 ACPI_STATUS Status; 615 616 if ((Status = EcLock(sc)) != AE_OK) 617 return(Status); 618 619 EC_SET_CSR(sc, EC_COMMAND_QUERY); 620 Status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL); 621 if (Status == AE_OK) 622 *Data = EC_GET_DATA(sc); 623 624 EcUnlock(sc); 625 626 if (Status != AE_OK) 627 device_printf(sc->ec_dev, "timeout waiting for EC to respond to EC_COMMAND_QUERY\n"); 628 return(Status); 629 } 630 631 static ACPI_STATUS 632 EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest) 633 { 634 ACPI_STATUS Status; 635 636 /* 637 * Lock the EC 638 */ 639 if ((Status = EcLock(sc)) != AE_OK) 640 return(Status); 641 642 /* 643 * Perform the transaction. 644 */ 645 switch (EcRequest->Command) { 646 case EC_COMMAND_READ: 647 Status = EcRead(sc, EcRequest->Address, &(EcRequest->Data)); 648 break; 649 650 case EC_COMMAND_WRITE: 651 Status = EcWrite(sc, EcRequest->Address, &(EcRequest->Data)); 652 break; 653 654 default: 655 Status = AE_SUPPORT; 656 break; 657 } 658 659 /* 660 * Unlock the EC 661 */ 662 EcUnlock(sc); 663 664 /* 665 * Clear & Re-Enable the EC GPE: 666 * ----------------------------- 667 * 'Consume' any EC GPE events that we generated while performing 668 * the transaction (e.g. IBF/OBF). Clearing the GPE here shouldn't 669 * have an adverse affect on outstanding EC-SCI's, as the source 670 * (EC-SCI) will still be high and thus should trigger the GPE 671 * immediately after we re-enabling it. 672 */ 673 if (sc->ec_pendquery){ 674 if(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH, 675 EcGpeQueryHandler, sc) != AE_OK) 676 printf("Pend Query Queuing Failed\n"); 677 sc->ec_pendquery = 0; 678 } 679 680 if (AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE) != AE_OK) 681 device_printf(sc->ec_dev, "EcRequest: Unable to clear the EC GPE.\n"); 682 if (AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE) != AE_OK) 683 device_printf(sc->ec_dev, "EcRequest: Unable to re-enable the EC GPE.\n"); 684 685 return(Status); 686 } 687 688 689 static ACPI_STATUS 690 EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data) 691 { 692 ACPI_STATUS Status; 693 694 if (!EcIsLocked(sc)) 695 device_printf(sc->ec_dev, "EcRead called without EC lock!\n"); 696 697 /*EcBurstEnable(EmbeddedController);*/ 698 699 EC_SET_CSR(sc, EC_COMMAND_READ); 700 if ((Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) != AE_OK) { 701 device_printf(sc->ec_dev, "EcRead: Failed waiting for EC to process read command.\n"); 702 return(Status); 703 } 704 705 EC_SET_DATA(sc, Address); 706 if ((Status = EcWaitEventIntr(sc, EC_EVENT_OUTPUT_BUFFER_FULL)) != AE_OK) { 707 device_printf(sc->ec_dev, "EcRead: Failed waiting for EC to send data.\n"); 708 return(Status); 709 } 710 711 (*Data) = EC_GET_DATA(sc); 712 713 /*EcBurstDisable(EmbeddedController);*/ 714 715 return(AE_OK); 716 } 717 718 static ACPI_STATUS 719 EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data) 720 { 721 ACPI_STATUS Status; 722 723 if (!EcIsLocked(sc)) 724 device_printf(sc->ec_dev, "EcWrite called without EC lock!\n"); 725 726 /*EcBurstEnable(EmbeddedController);*/ 727 728 EC_SET_CSR(sc, EC_COMMAND_WRITE); 729 if ((Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) != AE_OK) { 730 device_printf(sc->ec_dev, "EcWrite: Failed waiting for EC to process write command.\n"); 731 return(Status); 732 } 733 734 EC_SET_DATA(sc, Address); 735 if ((Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) != AE_OK) { 736 device_printf(sc->ec_dev, "EcRead: Failed waiting for EC to process address.\n"); 737 return(Status); 738 } 739 740 EC_SET_DATA(sc, *Data); 741 if ((Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) != AE_OK) { 742 device_printf(sc->ec_dev, "EcWrite: Failed waiting for EC to process data.\n"); 743 return(Status); 744 } 745 746 /*EcBurstDisable(EmbeddedController);*/ 747 748 return(AE_OK); 749 } 750