acpi_ec.c revision 1.51.4.4
1 /* $NetBSD: acpi_ec.c,v 1.51.4.4 2010/03/11 15:03:22 yamt Exp $ */ 2 3 /*- 4 * Copyright (c) 2007 Joerg Sonnenberger <joerg (at) NetBSD.org>. 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 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 22 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 26 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 27 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 28 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 /* 33 * The ACPI Embedded Controller (EC) driver serves two different purposes: 34 * - read and write access from ASL, e.g. to read battery state 35 * - notification of ASL of System Control Interrupts. 36 * 37 * Access to the EC is serialised by sc_access_mtx and optionally the 38 * ACPI global mutex. Both locks are held until the request is fulfilled. 39 * All access to the softc has to hold sc_mtx to serialise against the GPE 40 * handler and the callout. sc_mtx is also used for wakeup conditions. 41 * 42 * SCIs are processed in a kernel thread. Handling gets a bit complicated 43 * by the lock order (sc_mtx must be acquired after sc_access_mtx and the 44 * ACPI global mutex). 45 * 46 * Read and write requests spin around for a short time as many requests 47 * can be handled instantly by the EC. During normal processing interrupt 48 * mode is used exclusively. At boot and resume time interrupts are not 49 * working and the handlers just busy loop. 50 * 51 * A callout is scheduled to compensate for missing interrupts on some 52 * hardware. If the EC doesn't process a request for 5s, it is most likely 53 * in a wedged state. No method to reset the EC is currently known. 54 * 55 * Special care has to be taken to not poll the EC in a busy loop without 56 * delay. This can prevent processing of Power Button events. At least some 57 * Lenovo Thinkpads seem to be implement the Power Button Override in the EC 58 * and the only option to recover on those models is to cut off all power. 59 */ 60 61 #include <sys/cdefs.h> 62 __KERNEL_RCSID(0, "$NetBSD: acpi_ec.c,v 1.51.4.4 2010/03/11 15:03:22 yamt Exp $"); 63 64 #include <sys/param.h> 65 #include <sys/callout.h> 66 #include <sys/condvar.h> 67 #include <sys/device.h> 68 #include <sys/kernel.h> 69 #include <sys/kthread.h> 70 #include <sys/mutex.h> 71 #include <sys/systm.h> 72 73 #include <dev/acpi/acpireg.h> 74 #include <dev/acpi/acpivar.h> 75 #include <dev/acpi/acpi_ecvar.h> 76 77 #define _COMPONENT ACPI_EC_COMPONENT 78 ACPI_MODULE_NAME ("acpi_ec") 79 80 /* Maximum time to wait for global ACPI lock in ms */ 81 #define EC_LOCK_TIMEOUT 5 82 83 /* Maximum time to poll for completion of a command in ms */ 84 #define EC_POLL_TIMEOUT 5 85 86 /* Maximum time to give a single EC command in s */ 87 #define EC_CMD_TIMEOUT 10 88 89 /* From ACPI 3.0b, chapter 12.3 */ 90 #define EC_COMMAND_READ 0x80 91 #define EC_COMMAND_WRITE 0x81 92 #define EC_COMMAND_BURST_EN 0x82 93 #define EC_COMMAND_BURST_DIS 0x83 94 #define EC_COMMAND_QUERY 0x84 95 96 /* From ACPI 3.0b, chapter 12.2.1 */ 97 #define EC_STATUS_OBF 0x01 98 #define EC_STATUS_IBF 0x02 99 #define EC_STATUS_CMD 0x08 100 #define EC_STATUS_BURST 0x10 101 #define EC_STATUS_SCI 0x20 102 #define EC_STATUS_SMI 0x40 103 104 static const char *ec_hid[] = { 105 "PNP0C09", 106 NULL, 107 }; 108 109 enum ec_state_t { 110 EC_STATE_QUERY, 111 EC_STATE_QUERY_VAL, 112 EC_STATE_READ, 113 EC_STATE_READ_ADDR, 114 EC_STATE_READ_VAL, 115 EC_STATE_WRITE, 116 EC_STATE_WRITE_ADDR, 117 EC_STATE_WRITE_VAL, 118 EC_STATE_FREE 119 }; 120 121 struct acpiec_softc { 122 ACPI_HANDLE sc_ech; 123 124 ACPI_HANDLE sc_gpeh; 125 UINT8 sc_gpebit; 126 127 bus_space_tag_t sc_data_st; 128 bus_space_handle_t sc_data_sh; 129 130 bus_space_tag_t sc_csr_st; 131 bus_space_handle_t sc_csr_sh; 132 133 bool sc_need_global_lock; 134 UINT32 sc_global_lock; 135 136 kmutex_t sc_mtx, sc_access_mtx; 137 kcondvar_t sc_cv, sc_cv_sci; 138 enum ec_state_t sc_state; 139 bool sc_got_sci; 140 callout_t sc_pseudo_intr; 141 142 uint8_t sc_cur_addr, sc_cur_val; 143 }; 144 145 static int acpiecdt_match(device_t, cfdata_t, void *); 146 static void acpiecdt_attach(device_t, device_t, void *); 147 148 static int acpiec_match(device_t, cfdata_t, void *); 149 static void acpiec_attach(device_t, device_t, void *); 150 151 static void acpiec_common_attach(device_t, device_t, ACPI_HANDLE, 152 bus_addr_t, bus_addr_t, ACPI_HANDLE, uint8_t); 153 154 static bool acpiec_suspend(device_t, const pmf_qual_t *); 155 static bool acpiec_resume(device_t, const pmf_qual_t *); 156 static bool acpiec_shutdown(device_t, int); 157 158 static bool acpiec_parse_gpe_package(device_t, ACPI_HANDLE, 159 ACPI_HANDLE *, uint8_t *); 160 161 static void acpiec_callout(void *); 162 static void acpiec_gpe_query(void *); 163 static UINT32 acpiec_gpe_handler(void *); 164 static ACPI_STATUS acpiec_space_setup(ACPI_HANDLE, UINT32, void *, void **); 165 static ACPI_STATUS acpiec_space_handler(UINT32, ACPI_PHYSICAL_ADDRESS, 166 UINT32, ACPI_INTEGER *, void *, void *); 167 168 static void acpiec_gpe_state_machine(device_t); 169 170 CFATTACH_DECL_NEW(acpiec, sizeof(struct acpiec_softc), 171 acpiec_match, acpiec_attach, NULL, NULL); 172 173 CFATTACH_DECL_NEW(acpiecdt, sizeof(struct acpiec_softc), 174 acpiecdt_match, acpiecdt_attach, NULL, NULL); 175 176 static device_t ec_singleton = NULL; 177 static bool acpiec_cold = false; 178 179 static bool 180 acpiecdt_find(device_t parent, ACPI_HANDLE *ec_handle, 181 bus_addr_t *cmd_reg, bus_addr_t *data_reg, uint8_t *gpebit) 182 { 183 ACPI_TABLE_ECDT *ecdt; 184 ACPI_STATUS rv; 185 186 rv = AcpiGetTable(ACPI_SIG_ECDT, 1, (ACPI_TABLE_HEADER **)&ecdt); 187 if (ACPI_FAILURE(rv)) 188 return false; 189 190 if (ecdt->Control.BitWidth != 8 || ecdt->Data.BitWidth != 8) { 191 aprint_error_dev(parent, 192 "ECDT register width invalid (%u/%u)\n", 193 ecdt->Control.BitWidth, ecdt->Data.BitWidth); 194 return false; 195 } 196 197 rv = AcpiGetHandle(ACPI_ROOT_OBJECT, ecdt->Id, ec_handle); 198 if (ACPI_FAILURE(rv)) { 199 aprint_error_dev(parent, 200 "failed to look up EC object %s: %s\n", 201 ecdt->Id, AcpiFormatException(rv)); 202 return false; 203 } 204 205 *cmd_reg = ecdt->Control.Address; 206 *data_reg = ecdt->Data.Address; 207 *gpebit = ecdt->Gpe; 208 209 return true; 210 } 211 212 static int 213 acpiecdt_match(device_t parent, cfdata_t match, void *aux) 214 { 215 ACPI_HANDLE ec_handle; 216 bus_addr_t cmd_reg, data_reg; 217 uint8_t gpebit; 218 219 if (acpiecdt_find(parent, &ec_handle, &cmd_reg, &data_reg, &gpebit)) 220 return 1; 221 else 222 return 0; 223 } 224 225 static void 226 acpiecdt_attach(device_t parent, device_t self, void *aux) 227 { 228 ACPI_HANDLE ec_handle; 229 bus_addr_t cmd_reg, data_reg; 230 uint8_t gpebit; 231 232 if (!acpiecdt_find(parent, &ec_handle, &cmd_reg, &data_reg, &gpebit)) 233 panic("ECDT disappeared"); 234 235 aprint_naive("\n"); 236 aprint_normal(": ACPI Embedded Controller via ECDT\n"); 237 238 acpiec_common_attach(parent, self, ec_handle, cmd_reg, data_reg, 239 NULL, gpebit); 240 } 241 242 static int 243 acpiec_match(device_t parent, cfdata_t match, void *aux) 244 { 245 struct acpi_attach_args *aa = aux; 246 247 if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE) 248 return 0; 249 250 return acpi_match_hid(aa->aa_node->ad_devinfo, ec_hid); 251 } 252 253 static void 254 acpiec_attach(device_t parent, device_t self, void *aux) 255 { 256 struct acpi_attach_args *aa = aux; 257 struct acpi_resources ec_res; 258 struct acpi_io *io0, *io1; 259 ACPI_HANDLE gpe_handle; 260 uint8_t gpebit; 261 ACPI_STATUS rv; 262 263 if (ec_singleton != NULL) { 264 aprint_naive(": using %s\n", device_xname(ec_singleton)); 265 aprint_normal(": using %s\n", device_xname(ec_singleton)); 266 if (!pmf_device_register(self, NULL, NULL)) 267 aprint_error_dev(self, "couldn't establish power handler\n"); 268 return; 269 } 270 271 if (!acpiec_parse_gpe_package(self, aa->aa_node->ad_handle, 272 &gpe_handle, &gpebit)) 273 return; 274 275 rv = acpi_resource_parse(self, aa->aa_node->ad_handle, "_CRS", 276 &ec_res, &acpi_resource_parse_ops_default); 277 if (rv != AE_OK) { 278 aprint_error_dev(self, "resource parsing failed: %s\n", 279 AcpiFormatException(rv)); 280 return; 281 } 282 283 if ((io0 = acpi_res_io(&ec_res, 0)) == NULL) { 284 aprint_error_dev(self, "no data register resource\n"); 285 goto free_res; 286 } 287 if ((io1 = acpi_res_io(&ec_res, 1)) == NULL) { 288 aprint_error_dev(self, "no CSR register resource\n"); 289 goto free_res; 290 } 291 292 acpiec_common_attach(parent, self, aa->aa_node->ad_handle, 293 io1->ar_base, io0->ar_base, gpe_handle, gpebit); 294 295 free_res: 296 acpi_resource_cleanup(&ec_res); 297 } 298 299 static void 300 acpiec_common_attach(device_t parent, device_t self, 301 ACPI_HANDLE ec_handle, bus_addr_t cmd_reg, bus_addr_t data_reg, 302 ACPI_HANDLE gpe_handle, uint8_t gpebit) 303 { 304 struct acpiec_softc *sc = device_private(self); 305 ACPI_STATUS rv; 306 ACPI_INTEGER val; 307 308 sc->sc_ech = ec_handle; 309 sc->sc_gpeh = gpe_handle; 310 sc->sc_gpebit = gpebit; 311 312 sc->sc_state = EC_STATE_FREE; 313 mutex_init(&sc->sc_mtx, MUTEX_DRIVER, IPL_TTY); 314 mutex_init(&sc->sc_access_mtx, MUTEX_DEFAULT, IPL_NONE); 315 cv_init(&sc->sc_cv, "eccv"); 316 cv_init(&sc->sc_cv_sci, "ecsci"); 317 318 if (bus_space_map(sc->sc_data_st, data_reg, 1, 0, 319 &sc->sc_data_sh) != 0) { 320 aprint_error_dev(self, "unable to map data register\n"); 321 return; 322 } 323 324 if (bus_space_map(sc->sc_csr_st, cmd_reg, 1, 0, &sc->sc_csr_sh) != 0) { 325 aprint_error_dev(self, "unable to map CSR register\n"); 326 goto post_data_map; 327 } 328 329 rv = acpi_eval_integer(sc->sc_ech, "_GLK", &val); 330 if (rv == AE_OK) { 331 sc->sc_need_global_lock = val != 0; 332 } else if (rv != AE_NOT_FOUND) { 333 aprint_error_dev(self, "unable to evaluate _GLK: %s\n", 334 AcpiFormatException(rv)); 335 goto post_csr_map; 336 } else { 337 sc->sc_need_global_lock = false; 338 } 339 if (sc->sc_need_global_lock) 340 aprint_normal_dev(self, "using global ACPI lock\n"); 341 342 callout_init(&sc->sc_pseudo_intr, CALLOUT_MPSAFE); 343 callout_setfunc(&sc->sc_pseudo_intr, acpiec_callout, self); 344 345 rv = AcpiInstallAddressSpaceHandler(sc->sc_ech, ACPI_ADR_SPACE_EC, 346 acpiec_space_handler, acpiec_space_setup, self); 347 if (rv != AE_OK) { 348 aprint_error_dev(self, 349 "unable to install address space handler: %s\n", 350 AcpiFormatException(rv)); 351 goto post_csr_map; 352 } 353 354 rv = AcpiInstallGpeHandler(sc->sc_gpeh, sc->sc_gpebit, 355 ACPI_GPE_EDGE_TRIGGERED, acpiec_gpe_handler, self); 356 if (rv != AE_OK) { 357 aprint_error_dev(self, "unable to install GPE handler: %s\n", 358 AcpiFormatException(rv)); 359 goto post_csr_map; 360 } 361 362 rv = AcpiSetGpeType(sc->sc_gpeh, sc->sc_gpebit, ACPI_GPE_TYPE_RUNTIME); 363 if (rv != AE_OK) { 364 aprint_error_dev(self, "unable to set GPE type: %s\n", 365 AcpiFormatException(rv)); 366 goto post_csr_map; 367 } 368 369 rv = AcpiEnableGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_ISR); 370 if (rv != AE_OK) { 371 aprint_error_dev(self, "unable to enable GPE: %s\n", 372 AcpiFormatException(rv)); 373 goto post_csr_map; 374 } 375 376 if (kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, acpiec_gpe_query, 377 self, NULL, "acpiec sci thread")) { 378 aprint_error_dev(self, "unable to create query kthread\n"); 379 goto post_csr_map; 380 } 381 382 ec_singleton = self; 383 384 if (!pmf_device_register1(self, acpiec_suspend, acpiec_resume, 385 acpiec_shutdown)) 386 aprint_error_dev(self, "couldn't establish power handler\n"); 387 388 return; 389 390 post_csr_map: 391 (void)AcpiRemoveGpeHandler(sc->sc_gpeh, sc->sc_gpebit, 392 acpiec_gpe_handler); 393 (void)AcpiRemoveAddressSpaceHandler(sc->sc_ech, 394 ACPI_ADR_SPACE_EC, acpiec_space_handler); 395 bus_space_unmap(sc->sc_csr_st, sc->sc_csr_sh, 1); 396 post_data_map: 397 bus_space_unmap(sc->sc_data_st, sc->sc_data_sh, 1); 398 } 399 400 static bool 401 acpiec_suspend(device_t dv, const pmf_qual_t *qual) 402 { 403 acpiec_cold = true; 404 405 return true; 406 } 407 408 static bool 409 acpiec_resume(device_t dv, const pmf_qual_t *qual) 410 { 411 acpiec_cold = false; 412 413 return true; 414 } 415 416 static bool 417 acpiec_shutdown(device_t dv, int how) 418 { 419 420 acpiec_cold = true; 421 return true; 422 } 423 424 static bool 425 acpiec_parse_gpe_package(device_t self, ACPI_HANDLE ec_handle, 426 ACPI_HANDLE *gpe_handle, uint8_t *gpebit) 427 { 428 ACPI_BUFFER buf; 429 ACPI_OBJECT *p, *c; 430 ACPI_STATUS rv; 431 432 rv = acpi_eval_struct(ec_handle, "_GPE", &buf); 433 if (rv != AE_OK) { 434 aprint_error_dev(self, "unable to evaluate _GPE: %s\n", 435 AcpiFormatException(rv)); 436 return false; 437 } 438 439 p = buf.Pointer; 440 441 if (p->Type == ACPI_TYPE_INTEGER) { 442 *gpe_handle = NULL; 443 *gpebit = p->Integer.Value; 444 ACPI_FREE(p); 445 return true; 446 } 447 448 if (p->Type != ACPI_TYPE_PACKAGE) { 449 aprint_error_dev(self, "_GPE is neither integer nor package\n"); 450 ACPI_FREE(p); 451 return false; 452 } 453 454 if (p->Package.Count != 2) { 455 aprint_error_dev(self, "_GPE package does not contain 2 elements\n"); 456 ACPI_FREE(p); 457 return false; 458 } 459 460 c = &p->Package.Elements[0]; 461 rv = acpi_eval_reference_handle(c, gpe_handle); 462 463 if (ACPI_FAILURE(rv)) { 464 aprint_error_dev(self, "failed to evaluate _GPE handle\n"); 465 ACPI_FREE(p); 466 return false; 467 } 468 469 c = &p->Package.Elements[1]; 470 471 if (c->Type != ACPI_TYPE_INTEGER) { 472 aprint_error_dev(self, 473 "_GPE package needs integer as 2nd field\n"); 474 ACPI_FREE(p); 475 return false; 476 } 477 *gpebit = c->Integer.Value; 478 ACPI_FREE(p); 479 return true; 480 } 481 482 static uint8_t 483 acpiec_read_data(struct acpiec_softc *sc) 484 { 485 return bus_space_read_1(sc->sc_data_st, sc->sc_data_sh, 0); 486 } 487 488 static void 489 acpiec_write_data(struct acpiec_softc *sc, uint8_t val) 490 { 491 bus_space_write_1(sc->sc_data_st, sc->sc_data_sh, 0, val); 492 } 493 494 static uint8_t 495 acpiec_read_status(struct acpiec_softc *sc) 496 { 497 return bus_space_read_1(sc->sc_csr_st, sc->sc_csr_sh, 0); 498 } 499 500 static void 501 acpiec_write_command(struct acpiec_softc *sc, uint8_t cmd) 502 { 503 bus_space_write_1(sc->sc_csr_st, sc->sc_csr_sh, 0, cmd); 504 } 505 506 static ACPI_STATUS 507 acpiec_space_setup(ACPI_HANDLE region, UINT32 func, void *arg, 508 void **region_arg) 509 { 510 if (func == ACPI_REGION_DEACTIVATE) 511 *region_arg = NULL; 512 else 513 *region_arg = arg; 514 515 return AE_OK; 516 } 517 518 static void 519 acpiec_lock(device_t dv) 520 { 521 struct acpiec_softc *sc = device_private(dv); 522 ACPI_STATUS rv; 523 524 mutex_enter(&sc->sc_access_mtx); 525 526 if (sc->sc_need_global_lock) { 527 rv = AcpiAcquireGlobalLock(EC_LOCK_TIMEOUT, &sc->sc_global_lock); 528 if (rv != AE_OK) { 529 aprint_error_dev(dv, "failed to acquire global lock: %s\n", 530 AcpiFormatException(rv)); 531 return; 532 } 533 } 534 } 535 536 static void 537 acpiec_unlock(device_t dv) 538 { 539 struct acpiec_softc *sc = device_private(dv); 540 ACPI_STATUS rv; 541 542 if (sc->sc_need_global_lock) { 543 rv = AcpiReleaseGlobalLock(sc->sc_global_lock); 544 if (rv != AE_OK) { 545 aprint_error_dev(dv, "failed to release global lock: %s\n", 546 AcpiFormatException(rv)); 547 } 548 } 549 mutex_exit(&sc->sc_access_mtx); 550 } 551 552 static ACPI_STATUS 553 acpiec_read(device_t dv, uint8_t addr, uint8_t *val) 554 { 555 struct acpiec_softc *sc = device_private(dv); 556 int i, timeo = 1000 * EC_CMD_TIMEOUT; 557 558 acpiec_lock(dv); 559 mutex_enter(&sc->sc_mtx); 560 561 sc->sc_cur_addr = addr; 562 sc->sc_state = EC_STATE_READ; 563 564 for (i = 0; i < EC_POLL_TIMEOUT; ++i) { 565 acpiec_gpe_state_machine(dv); 566 if (sc->sc_state == EC_STATE_FREE) 567 goto done; 568 delay(1); 569 } 570 571 if (cold || acpiec_cold) { 572 while (sc->sc_state != EC_STATE_FREE && timeo-- > 0) { 573 delay(1000); 574 acpiec_gpe_state_machine(dv); 575 } 576 if (sc->sc_state != EC_STATE_FREE) { 577 mutex_exit(&sc->sc_mtx); 578 AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_NOT_ISR); 579 acpiec_unlock(dv); 580 aprint_error_dev(dv, "command timed out, state %d\n", 581 sc->sc_state); 582 return AE_ERROR; 583 } 584 } else if (cv_timedwait(&sc->sc_cv, &sc->sc_mtx, EC_CMD_TIMEOUT * hz)) { 585 mutex_exit(&sc->sc_mtx); 586 AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_NOT_ISR); 587 acpiec_unlock(dv); 588 aprint_error_dev(dv, "command takes over %d sec...\n", EC_CMD_TIMEOUT); 589 return AE_ERROR; 590 } 591 592 done: 593 *val = sc->sc_cur_val; 594 595 mutex_exit(&sc->sc_mtx); 596 acpiec_unlock(dv); 597 return AE_OK; 598 } 599 600 static ACPI_STATUS 601 acpiec_write(device_t dv, uint8_t addr, uint8_t val) 602 { 603 struct acpiec_softc *sc = device_private(dv); 604 int i, timeo = 1000 * EC_CMD_TIMEOUT; 605 606 acpiec_lock(dv); 607 mutex_enter(&sc->sc_mtx); 608 609 sc->sc_cur_addr = addr; 610 sc->sc_cur_val = val; 611 sc->sc_state = EC_STATE_WRITE; 612 613 for (i = 0; i < EC_POLL_TIMEOUT; ++i) { 614 acpiec_gpe_state_machine(dv); 615 if (sc->sc_state == EC_STATE_FREE) 616 goto done; 617 delay(1); 618 } 619 620 if (cold || acpiec_cold) { 621 while (sc->sc_state != EC_STATE_FREE && timeo-- > 0) { 622 delay(1000); 623 acpiec_gpe_state_machine(dv); 624 } 625 if (sc->sc_state != EC_STATE_FREE) { 626 mutex_exit(&sc->sc_mtx); 627 AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_NOT_ISR); 628 acpiec_unlock(dv); 629 aprint_error_dev(dv, "command timed out, state %d\n", 630 sc->sc_state); 631 return AE_ERROR; 632 } 633 } else if (cv_timedwait(&sc->sc_cv, &sc->sc_mtx, EC_CMD_TIMEOUT * hz)) { 634 mutex_exit(&sc->sc_mtx); 635 AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_NOT_ISR); 636 acpiec_unlock(dv); 637 aprint_error_dev(dv, "command takes over %d sec...\n", EC_CMD_TIMEOUT); 638 return AE_ERROR; 639 } 640 641 done: 642 mutex_exit(&sc->sc_mtx); 643 acpiec_unlock(dv); 644 return AE_OK; 645 } 646 647 static ACPI_STATUS 648 acpiec_space_handler(UINT32 func, ACPI_PHYSICAL_ADDRESS paddr, 649 UINT32 width, ACPI_INTEGER *value, void *arg, void *region_arg) 650 { 651 device_t dv; 652 struct acpiec_softc *sc; 653 ACPI_STATUS rv; 654 uint8_t addr, reg; 655 unsigned int i; 656 657 if (paddr > 0xff || width % 8 != 0 || value == NULL || arg == NULL || 658 paddr + width / 8 > 0xff) 659 return AE_BAD_PARAMETER; 660 661 addr = paddr; 662 dv = arg; 663 sc = device_private(dv); 664 665 rv = AE_OK; 666 667 switch (func) { 668 case ACPI_READ: 669 *value = 0; 670 for (i = 0; i < width; i += 8, ++addr) { 671 rv = acpiec_read(dv, addr, ®); 672 if (rv != AE_OK) 673 break; 674 *value |= (ACPI_INTEGER)reg << i; 675 } 676 break; 677 case ACPI_WRITE: 678 for (i = 0; i < width; i += 8, ++addr) { 679 reg = (*value >>i) & 0xff; 680 rv = acpiec_write(dv, addr, reg); 681 if (rv != AE_OK) 682 break; 683 } 684 break; 685 default: 686 aprint_error("%s: invalid Address Space function called: %x\n", 687 device_xname(dv), (unsigned int)func); 688 return AE_BAD_PARAMETER; 689 } 690 691 return rv; 692 } 693 694 static void 695 acpiec_gpe_query(void *arg) 696 { 697 device_t dv = arg; 698 struct acpiec_softc *sc = device_private(dv); 699 uint8_t reg; 700 char qxx[5]; 701 ACPI_STATUS rv; 702 int i; 703 704 loop: 705 mutex_enter(&sc->sc_mtx); 706 707 if (sc->sc_got_sci == false) 708 cv_wait(&sc->sc_cv_sci, &sc->sc_mtx); 709 mutex_exit(&sc->sc_mtx); 710 711 acpiec_lock(dv); 712 mutex_enter(&sc->sc_mtx); 713 714 /* The Query command can always be issued, so be defensive here. */ 715 sc->sc_got_sci = false; 716 sc->sc_state = EC_STATE_QUERY; 717 718 for (i = 0; i < EC_POLL_TIMEOUT; ++i) { 719 acpiec_gpe_state_machine(dv); 720 if (sc->sc_state == EC_STATE_FREE) 721 goto done; 722 delay(1); 723 } 724 725 cv_wait(&sc->sc_cv, &sc->sc_mtx); 726 727 done: 728 reg = sc->sc_cur_val; 729 730 mutex_exit(&sc->sc_mtx); 731 acpiec_unlock(dv); 732 733 if (reg == 0) 734 goto loop; /* Spurious query result */ 735 736 /* 737 * Evaluate _Qxx to respond to the controller. 738 */ 739 snprintf(qxx, sizeof(qxx), "_Q%02X", (unsigned int)reg); 740 rv = AcpiEvaluateObject(sc->sc_ech, qxx, NULL, NULL); 741 if (rv != AE_OK && rv != AE_NOT_FOUND) { 742 aprint_error("%s: GPE query method %s failed: %s", 743 device_xname(dv), qxx, AcpiFormatException(rv)); 744 } 745 746 goto loop; 747 } 748 749 static void 750 acpiec_gpe_state_machine(device_t dv) 751 { 752 struct acpiec_softc *sc = device_private(dv); 753 uint8_t reg; 754 755 reg = acpiec_read_status(sc); 756 757 if (reg & EC_STATUS_SCI) 758 sc->sc_got_sci = true; 759 760 switch (sc->sc_state) { 761 case EC_STATE_QUERY: 762 if ((reg & EC_STATUS_IBF) != 0) 763 break; /* Nothing of interest here. */ 764 acpiec_write_command(sc, EC_COMMAND_QUERY); 765 sc->sc_state = EC_STATE_QUERY_VAL; 766 break; 767 768 case EC_STATE_QUERY_VAL: 769 if ((reg & EC_STATUS_OBF) == 0) 770 break; /* Nothing of interest here. */ 771 772 sc->sc_cur_val = acpiec_read_data(sc); 773 sc->sc_state = EC_STATE_FREE; 774 775 cv_signal(&sc->sc_cv); 776 break; 777 778 case EC_STATE_READ: 779 if ((reg & EC_STATUS_IBF) != 0) 780 break; /* Nothing of interest here. */ 781 782 acpiec_write_command(sc, EC_COMMAND_READ); 783 sc->sc_state = EC_STATE_READ_ADDR; 784 break; 785 786 case EC_STATE_READ_ADDR: 787 if ((reg & EC_STATUS_IBF) != 0) 788 break; /* Nothing of interest here. */ 789 790 acpiec_write_data(sc, sc->sc_cur_addr); 791 sc->sc_state = EC_STATE_READ_VAL; 792 break; 793 794 case EC_STATE_READ_VAL: 795 if ((reg & EC_STATUS_OBF) == 0) 796 break; /* Nothing of interest here. */ 797 sc->sc_cur_val = acpiec_read_data(sc); 798 sc->sc_state = EC_STATE_FREE; 799 800 cv_signal(&sc->sc_cv); 801 break; 802 803 case EC_STATE_WRITE: 804 if ((reg & EC_STATUS_IBF) != 0) 805 break; /* Nothing of interest here. */ 806 807 acpiec_write_command(sc, EC_COMMAND_WRITE); 808 sc->sc_state = EC_STATE_WRITE_ADDR; 809 break; 810 811 case EC_STATE_WRITE_ADDR: 812 if ((reg & EC_STATUS_IBF) != 0) 813 break; /* Nothing of interest here. */ 814 acpiec_write_data(sc, sc->sc_cur_addr); 815 sc->sc_state = EC_STATE_WRITE_VAL; 816 break; 817 818 case EC_STATE_WRITE_VAL: 819 if ((reg & EC_STATUS_IBF) != 0) 820 break; /* Nothing of interest here. */ 821 sc->sc_state = EC_STATE_FREE; 822 cv_signal(&sc->sc_cv); 823 824 acpiec_write_data(sc, sc->sc_cur_val); 825 break; 826 827 case EC_STATE_FREE: 828 if (sc->sc_got_sci) 829 cv_signal(&sc->sc_cv_sci); 830 break; 831 default: 832 panic("invalid state"); 833 } 834 835 if (sc->sc_state != EC_STATE_FREE) 836 callout_schedule(&sc->sc_pseudo_intr, 1); 837 } 838 839 static void 840 acpiec_callout(void *arg) 841 { 842 device_t dv = arg; 843 struct acpiec_softc *sc = device_private(dv); 844 845 AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_NOT_ISR); 846 847 mutex_enter(&sc->sc_mtx); 848 acpiec_gpe_state_machine(dv); 849 mutex_exit(&sc->sc_mtx); 850 } 851 852 static UINT32 853 acpiec_gpe_handler(void *arg) 854 { 855 device_t dv = arg; 856 struct acpiec_softc *sc = device_private(dv); 857 858 AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_ISR); 859 860 mutex_enter(&sc->sc_mtx); 861 acpiec_gpe_state_machine(dv); 862 mutex_exit(&sc->sc_mtx); 863 864 return 0; 865 } 866 867 ACPI_STATUS 868 acpiec_bus_read(device_t dv, u_int addr, ACPI_INTEGER *val, int width) 869 { 870 return acpiec_space_handler(ACPI_READ, addr, width * 8, val, dv, NULL); 871 } 872 873 ACPI_STATUS 874 acpiec_bus_write(device_t dv, u_int addr, ACPI_INTEGER val, int width) 875 { 876 return acpiec_space_handler(ACPI_WRITE, addr, width * 8, &val, dv, NULL); 877 } 878 879 ACPI_HANDLE 880 acpiec_get_handle(device_t dv) 881 { 882 struct acpiec_softc *sc = device_private(dv); 883 884 return sc->sc_ech; 885 } 886
Indexes created Thu Oct 02 01:09:59 GMT 2025