1 /* $NetBSD: acpi_ec.c,v 1.86 2021/12/31 17:22:25 riastradh Exp $ */ 2 3 /*- 4 * Copyright (c) 2007 Joerg Sonnenberger <joerg@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.86 2021/12/31 17:22:25 riastradh 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 struct device_compatible_entry compat_data[] = { 105 { .compat = "PNP0C09" }, 106 DEVICE_COMPAT_EOL 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_t 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_t 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_space_tag_t, bus_addr_t, bus_space_tag_t, bus_addr_t, 153 ACPI_HANDLE, uint8_t); 154 155 static bool acpiec_suspend(device_t, const pmf_qual_t *); 156 static bool acpiec_resume(device_t, const pmf_qual_t *); 157 static bool acpiec_shutdown(device_t, int); 158 159 static bool acpiec_parse_gpe_package(device_t, ACPI_HANDLE, 160 ACPI_HANDLE *, uint8_t *); 161 162 static void acpiec_callout(void *); 163 static void acpiec_gpe_query(void *); 164 static uint32_t acpiec_gpe_handler(ACPI_HANDLE, uint32_t, void *); 165 static ACPI_STATUS acpiec_space_setup(ACPI_HANDLE, uint32_t, void *, void **); 166 static ACPI_STATUS acpiec_space_handler(uint32_t, ACPI_PHYSICAL_ADDRESS, 167 uint32_t, ACPI_INTEGER *, void *, void *); 168 169 static void acpiec_gpe_state_machine(device_t); 170 171 CFATTACH_DECL_NEW(acpiec, sizeof(struct acpiec_softc), 172 acpiec_match, acpiec_attach, NULL, NULL); 173 174 CFATTACH_DECL_NEW(acpiecdt, sizeof(struct acpiec_softc), 175 acpiecdt_match, acpiecdt_attach, NULL, NULL); 176 177 static device_t ec_singleton = NULL; 178 static bool acpiec_cold = false; 179 180 static bool 181 acpiecdt_find(device_t parent, ACPI_HANDLE *ec_handle, 182 bus_addr_t *cmd_reg, bus_addr_t *data_reg, uint8_t *gpebit) 183 { 184 ACPI_TABLE_ECDT *ecdt; 185 ACPI_STATUS rv; 186 187 rv = AcpiGetTable(ACPI_SIG_ECDT, 1, (ACPI_TABLE_HEADER **)&ecdt); 188 if (ACPI_FAILURE(rv)) 189 return false; 190 191 if (ecdt->Control.BitWidth != 8 || ecdt->Data.BitWidth != 8) { 192 aprint_error_dev(parent, 193 "ECDT register width invalid (%u/%u)\n", 194 ecdt->Control.BitWidth, ecdt->Data.BitWidth); 195 return false; 196 } 197 198 rv = AcpiGetHandle(ACPI_ROOT_OBJECT, ecdt->Id, ec_handle); 199 if (ACPI_FAILURE(rv)) { 200 aprint_error_dev(parent, 201 "failed to look up EC object %s: %s\n", 202 ecdt->Id, AcpiFormatException(rv)); 203 return false; 204 } 205 206 *cmd_reg = ecdt->Control.Address; 207 *data_reg = ecdt->Data.Address; 208 *gpebit = ecdt->Gpe; 209 210 return true; 211 } 212 213 static int 214 acpiecdt_match(device_t parent, cfdata_t match, void *aux) 215 { 216 ACPI_HANDLE ec_handle; 217 bus_addr_t cmd_reg, data_reg; 218 uint8_t gpebit; 219 220 if (acpiecdt_find(parent, &ec_handle, &cmd_reg, &data_reg, &gpebit)) 221 return 1; 222 else 223 return 0; 224 } 225 226 static void 227 acpiecdt_attach(device_t parent, device_t self, void *aux) 228 { 229 struct acpibus_attach_args *aa = aux; 230 ACPI_HANDLE ec_handle; 231 bus_addr_t cmd_reg, data_reg; 232 uint8_t gpebit; 233 234 if (!acpiecdt_find(parent, &ec_handle, &cmd_reg, &data_reg, &gpebit)) 235 panic("ECDT disappeared"); 236 237 aprint_naive("\n"); 238 aprint_normal(": ACPI Embedded Controller via ECDT\n"); 239 240 acpiec_common_attach(parent, self, ec_handle, aa->aa_iot, cmd_reg, 241 aa->aa_iot, data_reg, NULL, gpebit); 242 } 243 244 static int 245 acpiec_match(device_t parent, cfdata_t match, void *aux) 246 { 247 struct acpi_attach_args *aa = aux; 248 249 return acpi_compatible_match(aa, compat_data); 250 } 251 252 static void 253 acpiec_attach(device_t parent, device_t self, void *aux) 254 { 255 struct acpi_attach_args *aa = aux; 256 struct acpi_resources ec_res; 257 struct acpi_io *io0, *io1; 258 ACPI_HANDLE gpe_handle; 259 uint8_t gpebit; 260 ACPI_STATUS rv; 261 262 if (ec_singleton != NULL) { 263 aprint_naive(": using %s\n", device_xname(ec_singleton)); 264 aprint_normal(": using %s\n", device_xname(ec_singleton)); 265 goto fail0; 266 } 267 268 if (!acpi_device_present(aa->aa_node->ad_handle)) { 269 aprint_normal(": not present\n"); 270 goto fail0; 271 } 272 273 if (!acpiec_parse_gpe_package(self, aa->aa_node->ad_handle, 274 &gpe_handle, &gpebit)) 275 goto fail0; 276 277 rv = acpi_resource_parse(self, aa->aa_node->ad_handle, "_CRS", 278 &ec_res, &acpi_resource_parse_ops_default); 279 if (rv != AE_OK) { 280 aprint_error_dev(self, "resource parsing failed: %s\n", 281 AcpiFormatException(rv)); 282 goto fail0; 283 } 284 285 if ((io0 = acpi_res_io(&ec_res, 0)) == NULL) { 286 aprint_error_dev(self, "no data register resource\n"); 287 goto fail1; 288 } 289 if ((io1 = acpi_res_io(&ec_res, 1)) == NULL) { 290 aprint_error_dev(self, "no CSR register resource\n"); 291 goto fail1; 292 } 293 294 acpiec_common_attach(parent, self, aa->aa_node->ad_handle, 295 aa->aa_iot, io1->ar_base, aa->aa_iot, io0->ar_base, 296 gpe_handle, gpebit); 297 298 acpi_resource_cleanup(&ec_res); 299 return; 300 301 fail1: acpi_resource_cleanup(&ec_res); 302 fail0: if (!pmf_device_register(self, NULL, NULL)) 303 aprint_error_dev(self, "couldn't establish power handler\n"); 304 } 305 306 static void 307 acpiec_common_attach(device_t parent, device_t self, 308 ACPI_HANDLE ec_handle, bus_space_tag_t cmdt, bus_addr_t cmd_reg, 309 bus_space_tag_t datat, bus_addr_t data_reg, 310 ACPI_HANDLE gpe_handle, uint8_t gpebit) 311 { 312 struct acpiec_softc *sc = device_private(self); 313 ACPI_STATUS rv; 314 ACPI_INTEGER val; 315 316 sc->sc_csr_st = cmdt; 317 sc->sc_data_st = datat; 318 319 sc->sc_ech = ec_handle; 320 sc->sc_gpeh = gpe_handle; 321 sc->sc_gpebit = gpebit; 322 323 sc->sc_state = EC_STATE_FREE; 324 mutex_init(&sc->sc_mtx, MUTEX_DRIVER, IPL_TTY); 325 mutex_init(&sc->sc_access_mtx, MUTEX_DEFAULT, IPL_NONE); 326 cv_init(&sc->sc_cv, "eccv"); 327 cv_init(&sc->sc_cv_sci, "ecsci"); 328 329 if (bus_space_map(sc->sc_data_st, data_reg, 1, 0, 330 &sc->sc_data_sh) != 0) { 331 aprint_error_dev(self, "unable to map data register\n"); 332 return; 333 } 334 335 if (bus_space_map(sc->sc_csr_st, cmd_reg, 1, 0, &sc->sc_csr_sh) != 0) { 336 aprint_error_dev(self, "unable to map CSR register\n"); 337 goto post_data_map; 338 } 339 340 rv = acpi_eval_integer(sc->sc_ech, "_GLK", &val); 341 if (rv == AE_OK) { 342 sc->sc_need_global_lock = val != 0; 343 } else if (rv != AE_NOT_FOUND) { 344 aprint_error_dev(self, "unable to evaluate _GLK: %s\n", 345 AcpiFormatException(rv)); 346 goto post_csr_map; 347 } else { 348 sc->sc_need_global_lock = false; 349 } 350 if (sc->sc_need_global_lock) 351 aprint_normal_dev(self, "using global ACPI lock\n"); 352 353 callout_init(&sc->sc_pseudo_intr, CALLOUT_MPSAFE); 354 callout_setfunc(&sc->sc_pseudo_intr, acpiec_callout, self); 355 356 rv = AcpiInstallAddressSpaceHandler(sc->sc_ech, ACPI_ADR_SPACE_EC, 357 acpiec_space_handler, acpiec_space_setup, self); 358 if (rv != AE_OK) { 359 aprint_error_dev(self, 360 "unable to install address space handler: %s\n", 361 AcpiFormatException(rv)); 362 goto post_csr_map; 363 } 364 365 rv = AcpiInstallGpeHandler(sc->sc_gpeh, sc->sc_gpebit, 366 ACPI_GPE_EDGE_TRIGGERED, acpiec_gpe_handler, self); 367 if (rv != AE_OK) { 368 aprint_error_dev(self, "unable to install GPE handler: %s\n", 369 AcpiFormatException(rv)); 370 goto post_csr_map; 371 } 372 373 rv = AcpiEnableGpe(sc->sc_gpeh, sc->sc_gpebit); 374 if (rv != AE_OK) { 375 aprint_error_dev(self, "unable to enable GPE: %s\n", 376 AcpiFormatException(rv)); 377 goto post_csr_map; 378 } 379 380 if (kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, acpiec_gpe_query, 381 self, NULL, "acpiec sci thread")) { 382 aprint_error_dev(self, "unable to create query kthread\n"); 383 goto post_csr_map; 384 } 385 386 ec_singleton = self; 387 388 if (!pmf_device_register1(self, acpiec_suspend, acpiec_resume, 389 acpiec_shutdown)) 390 aprint_error_dev(self, "couldn't establish power handler\n"); 391 392 return; 393 394 post_csr_map: 395 (void)AcpiRemoveGpeHandler(sc->sc_gpeh, sc->sc_gpebit, 396 acpiec_gpe_handler); 397 (void)AcpiRemoveAddressSpaceHandler(sc->sc_ech, 398 ACPI_ADR_SPACE_EC, acpiec_space_handler); 399 bus_space_unmap(sc->sc_csr_st, sc->sc_csr_sh, 1); 400 post_data_map: 401 bus_space_unmap(sc->sc_data_st, sc->sc_data_sh, 1); 402 if (!pmf_device_register(self, NULL, NULL)) 403 aprint_error_dev(self, "couldn't establish power handler\n"); 404 } 405 406 static bool 407 acpiec_suspend(device_t dv, const pmf_qual_t *qual) 408 { 409 410 acpiec_cold = true; 411 412 return true; 413 } 414 415 static bool 416 acpiec_resume(device_t dv, const pmf_qual_t *qual) 417 { 418 419 acpiec_cold = false; 420 421 return true; 422 } 423 424 static bool 425 acpiec_shutdown(device_t dv, int how) 426 { 427 428 acpiec_cold = true; 429 return true; 430 } 431 432 static bool 433 acpiec_parse_gpe_package(device_t self, ACPI_HANDLE ec_handle, 434 ACPI_HANDLE *gpe_handle, uint8_t *gpebit) 435 { 436 ACPI_BUFFER buf; 437 ACPI_OBJECT *p, *c; 438 ACPI_STATUS rv; 439 440 rv = acpi_eval_struct(ec_handle, "_GPE", &buf); 441 if (rv != AE_OK) { 442 aprint_error_dev(self, "unable to evaluate _GPE: %s\n", 443 AcpiFormatException(rv)); 444 return false; 445 } 446 447 p = buf.Pointer; 448 449 if (p->Type == ACPI_TYPE_INTEGER) { 450 *gpe_handle = NULL; 451 *gpebit = p->Integer.Value; 452 ACPI_FREE(p); 453 return true; 454 } 455 456 if (p->Type != ACPI_TYPE_PACKAGE) { 457 aprint_error_dev(self, "_GPE is neither integer nor package\n"); 458 ACPI_FREE(p); 459 return false; 460 } 461 462 if (p->Package.Count != 2) { 463 aprint_error_dev(self, 464 "_GPE package does not contain 2 elements\n"); 465 ACPI_FREE(p); 466 return false; 467 } 468 469 c = &p->Package.Elements[0]; 470 rv = acpi_eval_reference_handle(c, gpe_handle); 471 472 if (ACPI_FAILURE(rv)) { 473 aprint_error_dev(self, "failed to evaluate _GPE handle\n"); 474 ACPI_FREE(p); 475 return false; 476 } 477 478 c = &p->Package.Elements[1]; 479 480 if (c->Type != ACPI_TYPE_INTEGER) { 481 aprint_error_dev(self, 482 "_GPE package needs integer as 2nd field\n"); 483 ACPI_FREE(p); 484 return false; 485 } 486 *gpebit = c->Integer.Value; 487 ACPI_FREE(p); 488 return true; 489 } 490 491 static uint8_t 492 acpiec_read_data(struct acpiec_softc *sc) 493 { 494 return bus_space_read_1(sc->sc_data_st, sc->sc_data_sh, 0); 495 } 496 497 static void 498 acpiec_write_data(struct acpiec_softc *sc, uint8_t val) 499 { 500 bus_space_write_1(sc->sc_data_st, sc->sc_data_sh, 0, val); 501 } 502 503 static uint8_t 504 acpiec_read_status(struct acpiec_softc *sc) 505 { 506 return bus_space_read_1(sc->sc_csr_st, sc->sc_csr_sh, 0); 507 } 508 509 static void 510 acpiec_write_command(struct acpiec_softc *sc, uint8_t cmd) 511 { 512 bus_space_write_1(sc->sc_csr_st, sc->sc_csr_sh, 0, cmd); 513 } 514 515 static ACPI_STATUS 516 acpiec_space_setup(ACPI_HANDLE region, uint32_t func, void *arg, 517 void **region_arg) 518 { 519 520 if (func == ACPI_REGION_DEACTIVATE) 521 *region_arg = NULL; 522 else 523 *region_arg = arg; 524 525 return AE_OK; 526 } 527 528 static void 529 acpiec_lock(device_t dv) 530 { 531 struct acpiec_softc *sc = device_private(dv); 532 ACPI_STATUS rv; 533 534 mutex_enter(&sc->sc_access_mtx); 535 536 if (sc->sc_need_global_lock) { 537 rv = AcpiAcquireGlobalLock(EC_LOCK_TIMEOUT, 538 &sc->sc_global_lock); 539 if (rv != AE_OK) { 540 aprint_error_dev(dv, 541 "failed to acquire global lock: %s\n", 542 AcpiFormatException(rv)); 543 return; 544 } 545 } 546 } 547 548 static void 549 acpiec_unlock(device_t dv) 550 { 551 struct acpiec_softc *sc = device_private(dv); 552 ACPI_STATUS rv; 553 554 if (sc->sc_need_global_lock) { 555 rv = AcpiReleaseGlobalLock(sc->sc_global_lock); 556 if (rv != AE_OK) { 557 aprint_error_dev(dv, 558 "failed to release global lock: %s\n", 559 AcpiFormatException(rv)); 560 } 561 } 562 mutex_exit(&sc->sc_access_mtx); 563 } 564 565 static ACPI_STATUS 566 acpiec_read(device_t dv, uint8_t addr, uint8_t *val) 567 { 568 struct acpiec_softc *sc = device_private(dv); 569 int i, timeo = 1000 * EC_CMD_TIMEOUT; 570 571 acpiec_lock(dv); 572 mutex_enter(&sc->sc_mtx); 573 574 sc->sc_cur_addr = addr; 575 sc->sc_state = EC_STATE_READ; 576 577 for (i = 0; i < EC_POLL_TIMEOUT; ++i) { 578 acpiec_gpe_state_machine(dv); 579 if (sc->sc_state == EC_STATE_FREE) 580 goto done; 581 delay(1); 582 } 583 584 if (cold || acpiec_cold) { 585 while (sc->sc_state != EC_STATE_FREE && timeo-- > 0) { 586 delay(1000); 587 acpiec_gpe_state_machine(dv); 588 } 589 if (sc->sc_state != EC_STATE_FREE) { 590 mutex_exit(&sc->sc_mtx); 591 acpiec_unlock(dv); 592 aprint_error_dev(dv, "command timed out, state %d\n", 593 sc->sc_state); 594 return AE_ERROR; 595 } 596 } else if (cv_timedwait(&sc->sc_cv, &sc->sc_mtx, EC_CMD_TIMEOUT * hz)) { 597 mutex_exit(&sc->sc_mtx); 598 acpiec_unlock(dv); 599 aprint_error_dev(dv, 600 "command takes over %d sec...\n", EC_CMD_TIMEOUT); 601 return AE_ERROR; 602 } 603 604 done: 605 *val = sc->sc_cur_val; 606 607 mutex_exit(&sc->sc_mtx); 608 acpiec_unlock(dv); 609 return AE_OK; 610 } 611 612 static ACPI_STATUS 613 acpiec_write(device_t dv, uint8_t addr, uint8_t val) 614 { 615 struct acpiec_softc *sc = device_private(dv); 616 int i, timeo = 1000 * EC_CMD_TIMEOUT; 617 618 acpiec_lock(dv); 619 mutex_enter(&sc->sc_mtx); 620 621 sc->sc_cur_addr = addr; 622 sc->sc_cur_val = val; 623 sc->sc_state = EC_STATE_WRITE; 624 625 for (i = 0; i < EC_POLL_TIMEOUT; ++i) { 626 acpiec_gpe_state_machine(dv); 627 if (sc->sc_state == EC_STATE_FREE) 628 goto done; 629 delay(1); 630 } 631 632 if (cold || acpiec_cold) { 633 while (sc->sc_state != EC_STATE_FREE && timeo-- > 0) { 634 delay(1000); 635 acpiec_gpe_state_machine(dv); 636 } 637 if (sc->sc_state != EC_STATE_FREE) { 638 mutex_exit(&sc->sc_mtx); 639 acpiec_unlock(dv); 640 aprint_error_dev(dv, "command timed out, state %d\n", 641 sc->sc_state); 642 return AE_ERROR; 643 } 644 } else if (cv_timedwait(&sc->sc_cv, &sc->sc_mtx, EC_CMD_TIMEOUT * hz)) { 645 mutex_exit(&sc->sc_mtx); 646 acpiec_unlock(dv); 647 aprint_error_dev(dv, 648 "command takes over %d sec...\n", EC_CMD_TIMEOUT); 649 return AE_ERROR; 650 } 651 652 done: 653 mutex_exit(&sc->sc_mtx); 654 acpiec_unlock(dv); 655 return AE_OK; 656 } 657 658 /* 659 * acpiec_space_handler(func, paddr, bitwidth, value, arg, region_arg) 660 * 661 * Transfer bitwidth/8 bytes of data between paddr and *value: 662 * from paddr to *value when func is ACPI_READ, and the other way 663 * when func is ACPI_WRITE. arg is the acpiec(4) or acpiecdt(4) 664 * device. region_arg is ignored (XXX why? determined by 665 * acpiec_space_setup but never used by anything that I can see). 666 * 667 * The caller always provides storage at *value large enough for 668 * an ACPI_INTEGER object, i.e., a 64-bit integer. However, 669 * bitwidth may be larger; in this case the caller provides larger 670 * storage at *value, e.g. 128 bits as documented in 671 * <https://gnats.netbsd.org/55206>. 672 * 673 * On reads, this fully initializes one ACPI_INTEGER's worth of 674 * data at *value, even if bitwidth < 64. The integer is 675 * interpreted in host byte order; in other words, bytes of data 676 * are transferred in order between paddr and (uint8_t *)value. 677 * The transfer is not atomic; it may go byte-by-byte. 678 * 679 * XXX This only really makes sense on little-endian systems. 680 * E.g., thinkpad_acpi.c assumes that a single byte is transferred 681 * in the low-order bits of the result. A big-endian system could 682 * read a 64-bit integer in big-endian (and it did for a while!), 683 * but what should it do for larger reads? Unclear! 684 * 685 * XXX It's not clear whether the object at *value is always 686 * _aligned_ adequately for an ACPI_INTEGER object. Currently it 687 * always is as long as malloc, used by AcpiOsAllocate, returns 688 * 64-bit-aligned data. 689 */ 690 static ACPI_STATUS 691 acpiec_space_handler(uint32_t func, ACPI_PHYSICAL_ADDRESS paddr, 692 uint32_t width, ACPI_INTEGER *value, void *arg, void *region_arg) 693 { 694 device_t dv; 695 ACPI_STATUS rv; 696 uint8_t addr, *buf; 697 unsigned int i; 698 699 if (paddr > 0xff || width % 8 != 0 || 700 value == NULL || arg == NULL || paddr + width / 8 > 0x100) 701 return AE_BAD_PARAMETER; 702 703 addr = paddr; 704 dv = arg; 705 buf = (uint8_t *)value; 706 707 rv = AE_OK; 708 709 switch (func) { 710 case ACPI_READ: 711 for (i = 0; i < width; i += 8, ++addr, ++buf) { 712 rv = acpiec_read(dv, addr, buf); 713 if (rv != AE_OK) 714 break; 715 } 716 /* 717 * Make sure to fully initialize at least an 718 * ACPI_INTEGER-sized object. 719 */ 720 for (; i < sizeof(*value)*8; i += 8, ++buf) 721 *buf = 0; 722 break; 723 case ACPI_WRITE: 724 for (i = 0; i < width; i += 8, ++addr, ++buf) { 725 rv = acpiec_write(dv, addr, *buf); 726 if (rv != AE_OK) 727 break; 728 } 729 break; 730 default: 731 aprint_error("%s: invalid Address Space function called: %x\n", 732 device_xname(dv), (unsigned int)func); 733 return AE_BAD_PARAMETER; 734 } 735 736 return rv; 737 } 738 739 static void 740 acpiec_gpe_query(void *arg) 741 { 742 device_t dv = arg; 743 struct acpiec_softc *sc = device_private(dv); 744 uint8_t reg; 745 char qxx[5]; 746 ACPI_STATUS rv; 747 int i; 748 749 loop: 750 mutex_enter(&sc->sc_mtx); 751 752 if (sc->sc_got_sci == false) 753 cv_wait(&sc->sc_cv_sci, &sc->sc_mtx); 754 mutex_exit(&sc->sc_mtx); 755 756 acpiec_lock(dv); 757 mutex_enter(&sc->sc_mtx); 758 759 /* The Query command can always be issued, so be defensive here. */ 760 sc->sc_got_sci = false; 761 sc->sc_state = EC_STATE_QUERY; 762 763 for (i = 0; i < EC_POLL_TIMEOUT; ++i) { 764 acpiec_gpe_state_machine(dv); 765 if (sc->sc_state == EC_STATE_FREE) 766 goto done; 767 delay(1); 768 } 769 770 cv_wait(&sc->sc_cv, &sc->sc_mtx); 771 772 done: 773 reg = sc->sc_cur_val; 774 775 mutex_exit(&sc->sc_mtx); 776 acpiec_unlock(dv); 777 778 if (reg == 0) 779 goto loop; /* Spurious query result */ 780 781 /* 782 * Evaluate _Qxx to respond to the controller. 783 */ 784 snprintf(qxx, sizeof(qxx), "_Q%02X", (unsigned int)reg); 785 rv = AcpiEvaluateObject(sc->sc_ech, qxx, NULL, NULL); 786 if (rv != AE_OK && rv != AE_NOT_FOUND) { 787 aprint_error_dev(dv, "GPE query method %s failed: %s", 788 qxx, AcpiFormatException(rv)); 789 } 790 791 goto loop; 792 } 793 794 static void 795 acpiec_gpe_state_machine(device_t dv) 796 { 797 struct acpiec_softc *sc = device_private(dv); 798 uint8_t reg; 799 800 reg = acpiec_read_status(sc); 801 802 if (reg & EC_STATUS_SCI) 803 sc->sc_got_sci = true; 804 805 switch (sc->sc_state) { 806 case EC_STATE_QUERY: 807 if ((reg & EC_STATUS_IBF) != 0) 808 break; /* Nothing of interest here. */ 809 acpiec_write_command(sc, EC_COMMAND_QUERY); 810 sc->sc_state = EC_STATE_QUERY_VAL; 811 break; 812 813 case EC_STATE_QUERY_VAL: 814 if ((reg & EC_STATUS_OBF) == 0) 815 break; /* Nothing of interest here. */ 816 817 sc->sc_cur_val = acpiec_read_data(sc); 818 sc->sc_state = EC_STATE_FREE; 819 820 cv_signal(&sc->sc_cv); 821 break; 822 823 case EC_STATE_READ: 824 if ((reg & EC_STATUS_IBF) != 0) 825 break; /* Nothing of interest here. */ 826 827 acpiec_write_command(sc, EC_COMMAND_READ); 828 sc->sc_state = EC_STATE_READ_ADDR; 829 break; 830 831 case EC_STATE_READ_ADDR: 832 if ((reg & EC_STATUS_IBF) != 0) 833 break; /* Nothing of interest here. */ 834 835 acpiec_write_data(sc, sc->sc_cur_addr); 836 sc->sc_state = EC_STATE_READ_VAL; 837 break; 838 839 case EC_STATE_READ_VAL: 840 if ((reg & EC_STATUS_OBF) == 0) 841 break; /* Nothing of interest here. */ 842 sc->sc_cur_val = acpiec_read_data(sc); 843 sc->sc_state = EC_STATE_FREE; 844 845 cv_signal(&sc->sc_cv); 846 break; 847 848 case EC_STATE_WRITE: 849 if ((reg & EC_STATUS_IBF) != 0) 850 break; /* Nothing of interest here. */ 851 852 acpiec_write_command(sc, EC_COMMAND_WRITE); 853 sc->sc_state = EC_STATE_WRITE_ADDR; 854 break; 855 856 case EC_STATE_WRITE_ADDR: 857 if ((reg & EC_STATUS_IBF) != 0) 858 break; /* Nothing of interest here. */ 859 acpiec_write_data(sc, sc->sc_cur_addr); 860 sc->sc_state = EC_STATE_WRITE_VAL; 861 break; 862 863 case EC_STATE_WRITE_VAL: 864 if ((reg & EC_STATUS_IBF) != 0) 865 break; /* Nothing of interest here. */ 866 sc->sc_state = EC_STATE_FREE; 867 cv_signal(&sc->sc_cv); 868 869 acpiec_write_data(sc, sc->sc_cur_val); 870 break; 871 872 case EC_STATE_FREE: 873 if (sc->sc_got_sci) 874 cv_signal(&sc->sc_cv_sci); 875 break; 876 default: 877 panic("invalid state"); 878 } 879 880 if (sc->sc_state != EC_STATE_FREE) 881 callout_schedule(&sc->sc_pseudo_intr, 1); 882 } 883 884 static void 885 acpiec_callout(void *arg) 886 { 887 device_t dv = arg; 888 struct acpiec_softc *sc = device_private(dv); 889 890 mutex_enter(&sc->sc_mtx); 891 acpiec_gpe_state_machine(dv); 892 mutex_exit(&sc->sc_mtx); 893 } 894 895 static uint32_t 896 acpiec_gpe_handler(ACPI_HANDLE hdl, uint32_t gpebit, void *arg) 897 { 898 device_t dv = arg; 899 struct acpiec_softc *sc = device_private(dv); 900 901 mutex_enter(&sc->sc_mtx); 902 acpiec_gpe_state_machine(dv); 903 mutex_exit(&sc->sc_mtx); 904 905 return ACPI_INTERRUPT_HANDLED | ACPI_REENABLE_GPE; 906 } 907 908 ACPI_STATUS 909 acpiec_bus_read(device_t dv, u_int addr, ACPI_INTEGER *val, int width) 910 { 911 return acpiec_space_handler(ACPI_READ, addr, width * 8, val, dv, NULL); 912 } 913 914 ACPI_STATUS 915 acpiec_bus_write(device_t dv, u_int addr, ACPI_INTEGER val, int width) 916 { 917 return acpiec_space_handler(ACPI_WRITE, addr, width * 8, &val, dv, 918 NULL); 919 } 920 921 ACPI_HANDLE 922 acpiec_get_handle(device_t dv) 923 { 924 struct acpiec_softc *sc = device_private(dv); 925 926 return sc->sc_ech; 927 } 928