sys/dev/acpi/acpi_ec.c

   1 /*      $NetBSD: acpi_ec.c,v 1.57 2009/09/16 10:47:54 mlelstv 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.57 2009/09/16 10:47:54 mlelstv Exp $");
  63
  64 #include <sys/param.h>
  65 #include <sys/systm.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
  72 #include <sys/bus.h>
  73
  74 #include <dev/acpi/acpireg.h>
  75 #include <dev/acpi/acpivar.h>
  76 #include <dev/acpi/acpi_ecvar.h>
  77
  78 #define _COMPONENT          ACPI_EC_COMPONENT
  79 ACPI_MODULE_NAME            ("acpi_ec")
  80
  81 /* Maximum time to wait for global ACPI lock in ms */
  82 #define EC_LOCK_TIMEOUT         5
  83
  84 /* Maximum time to poll for completion of a command  in ms */
  85 #define EC_POLL_TIMEOUT         5
  86
  87 /* Maximum time to give a single EC command in s */
  88 #define EC_CMD_TIMEOUT          10
  89
  90 /* From ACPI 3.0b, chapter 12.3 */
  91 #define EC_COMMAND_READ         0x80
  92 #define EC_COMMAND_WRITE        0x81
  93 #define EC_COMMAND_BURST_EN     0x82
  94 #define EC_COMMAND_BURST_DIS    0x83
  95 #define EC_COMMAND_QUERY        0x84
  96
  97 /* From ACPI 3.0b, chapter 12.2.1 */
  98 #define EC_STATUS_OBF           0x01
  99 #define EC_STATUS_IBF           0x02
 100 #define EC_STATUS_CMD           0x08
 101 #define EC_STATUS_BURST         0x10
 102 #define EC_STATUS_SCI           0x20
 103 #define EC_STATUS_SMI           0x40
 104
 105 static const char *ec_hid[] = {
 106         "PNP0C09",
 107         NULL,
 108 };
 109
 110 enum ec_state_t {
 111         EC_STATE_QUERY,
 112         EC_STATE_QUERY_VAL,
 113         EC_STATE_READ,
 114         EC_STATE_READ_ADDR,
 115         EC_STATE_READ_VAL,
 116         EC_STATE_WRITE,
 117         EC_STATE_WRITE_ADDR,
 118         EC_STATE_WRITE_VAL,
 119         EC_STATE_FREE
 120 };
 121
 122 struct acpiec_softc {
 123         ACPI_HANDLE sc_ech;
 124
 125         ACPI_HANDLE sc_gpeh;
 126         UINT8 sc_gpebit;
 127
 128         bus_space_tag_t sc_data_st;
 129         bus_space_handle_t sc_data_sh;
 130
 131         bus_space_tag_t sc_csr_st;
 132         bus_space_handle_t sc_csr_sh;
 133
 134         bool sc_need_global_lock;
 135         UINT32 sc_global_lock;
 136
 137         kmutex_t sc_mtx, sc_access_mtx;
 138         kcondvar_t sc_cv, sc_cv_sci;
 139         enum ec_state_t sc_state;
 140         bool sc_got_sci;
 141         callout_t sc_pseudo_intr;
 142
 143         uint8_t sc_cur_addr, sc_cur_val;
 144 };
 145
 146 static int acpiecdt_match(device_t, cfdata_t, void *);
 147 static void acpiecdt_attach(device_t, device_t, void *);
 148
 149 static int acpiec_match(device_t, cfdata_t, void *);
 150 static void acpiec_attach(device_t, device_t, void *);
 151
 152 static void acpiec_common_attach(device_t, device_t, ACPI_HANDLE,
 153     bus_addr_t, bus_addr_t, ACPI_HANDLE, uint8_t);
 154
 155 static bool acpiec_suspend(device_t, pmf_qual_t);
 156 static bool acpiec_resume(device_t, 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 acpiec_gpe_handler(void *);
 165 static ACPI_STATUS acpiec_space_setup(ACPI_HANDLE, UINT32, void *, void **);
 166 static ACPI_STATUS acpiec_space_handler(UINT32, ACPI_PHYSICAL_ADDRESS,
 167     UINT32, 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 (%d/%d)\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         ACPI_HANDLE ec_handle;
 230         bus_addr_t cmd_reg, data_reg;
 231         uint8_t gpebit;
 232
 233         if (!acpiecdt_find(parent, &ec_handle, &cmd_reg, &data_reg, &gpebit))
 234                 panic("ECDT disappeared");
 235
 236         aprint_naive("\n");
 237         aprint_normal(": ACPI Embedded Controller via ECDT\n");
 238
 239         acpiec_common_attach(parent, self, ec_handle, cmd_reg, data_reg,
 240             NULL, gpebit);
 241 }
 242
 243 static int
 244 acpiec_match(device_t parent, cfdata_t match, void *aux)
 245 {
 246         struct acpi_attach_args *aa = aux;
 247
 248         if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
 249                 return 0;
 250
 251         return acpi_match_hid(aa->aa_node->ad_devinfo, ec_hid);
 252 }
 253
 254 static void
 255 acpiec_attach(device_t parent, device_t self, void *aux)
 256 {
 257         struct acpi_attach_args *aa = aux;
 258         struct acpi_resources ec_res;
 259         struct acpi_io *io0, *io1;
 260         ACPI_HANDLE gpe_handle;
 261         uint8_t gpebit;
 262         ACPI_STATUS rv;
 263
 264         if (ec_singleton != NULL) {
 265                 aprint_naive(": using %s\n", device_xname(ec_singleton));
 266                 aprint_normal(": using %s\n", device_xname(ec_singleton));
 267                 if (!pmf_device_register(self, NULL, NULL))
 268                         aprint_error_dev(self, "couldn't establish power handler\n");
 269                 return;
 270         }
 271
 272         if (!acpiec_parse_gpe_package(self, aa->aa_node->ad_handle,
 273                                       &gpe_handle, &gpebit))
 274                 return;
 275
 276         rv = acpi_resource_parse(self, aa->aa_node->ad_handle, "_CRS",
 277             &ec_res, &acpi_resource_parse_ops_default);
 278         if (rv != AE_OK) {
 279                 aprint_error_dev(self, "resource parsing failed: %s\n",
 280                     AcpiFormatException(rv));
 281                 return;
 282         }
 283
 284         if ((io0 = acpi_res_io(&ec_res, 0)) == NULL) {
 285                 aprint_error_dev(self, "no data register resource\n");
 286                 goto free_res;
 287         }
 288         if ((io1 = acpi_res_io(&ec_res, 1)) == NULL) {
 289                 aprint_error_dev(self, "no CSR register resource\n");
 290                 goto free_res;
 291         }
 292
 293         acpiec_common_attach(parent, self, aa->aa_node->ad_handle,
 294             io1->ar_base, io0->ar_base, gpe_handle, gpebit);
 295
 296 free_res:
 297         acpi_resource_cleanup(&ec_res);
 298 }
 299
 300 static void
 301 acpiec_common_attach(device_t parent, device_t self,
 302     ACPI_HANDLE ec_handle, bus_addr_t cmd_reg, bus_addr_t data_reg,
 303     ACPI_HANDLE gpe_handle, uint8_t gpebit)
 304 {
 305         struct acpiec_softc *sc = device_private(self);
 306         ACPI_STATUS rv;
 307         ACPI_INTEGER val;
 308
 309         sc->sc_ech = ec_handle;
 310         sc->sc_gpeh = gpe_handle;
 311         sc->sc_gpebit = gpebit;
 312
 313         sc->sc_state = EC_STATE_FREE;
 314         mutex_init(&sc->sc_mtx, MUTEX_DRIVER, IPL_TTY);
 315         mutex_init(&sc->sc_access_mtx, MUTEX_DEFAULT, IPL_NONE);
 316         cv_init(&sc->sc_cv, "eccv");
 317         cv_init(&sc->sc_cv_sci, "ecsci");
 318
 319         if (bus_space_map(sc->sc_data_st, data_reg, 1, 0,
 320             &sc->sc_data_sh) != 0) {
 321                 aprint_error_dev(self, "unable to map data register\n");
 322                 return;
 323         }
 324
 325         if (bus_space_map(sc->sc_csr_st, cmd_reg, 1, 0, &sc->sc_csr_sh) != 0) {
 326                 aprint_error_dev(self, "unable to map CSR register\n");
 327                 goto post_data_map;
 328         }
 329
 330         rv = acpi_eval_integer(sc->sc_ech, "_GLK", &val);
 331         if (rv == AE_OK) {
 332                 sc->sc_need_global_lock = val != 0;
 333         } else if (rv != AE_NOT_FOUND) {
 334                 aprint_error_dev(self, "unable to evaluate _GLK: %s\n",
 335                     AcpiFormatException(rv));
 336                 goto post_csr_map;
 337         } else {
 338                 sc->sc_need_global_lock = false;
 339         }
 340         if (sc->sc_need_global_lock)
 341                 aprint_normal_dev(self, "using global ACPI lock\n");
 342
 343         callout_init(&sc->sc_pseudo_intr, CALLOUT_MPSAFE);
 344         callout_setfunc(&sc->sc_pseudo_intr, acpiec_callout, self);
 345
 346         rv = AcpiInstallAddressSpaceHandler(sc->sc_ech, ACPI_ADR_SPACE_EC,
 347             acpiec_space_handler, acpiec_space_setup, self);
 348         if (rv != AE_OK) {
 349                 aprint_error_dev(self,
 350                     "unable to install address space handler: %s\n",
 351                     AcpiFormatException(rv));
 352                 goto post_csr_map;
 353         }
 354
 355         rv = AcpiInstallGpeHandler(sc->sc_gpeh, sc->sc_gpebit,
 356             ACPI_GPE_EDGE_TRIGGERED, acpiec_gpe_handler, self);
 357         if (rv != AE_OK) {
 358                 aprint_error_dev(self, "unable to install GPE handler: %s\n",
 359                     AcpiFormatException(rv));
 360                 goto post_csr_map;
 361         }
 362
 363         rv = AcpiSetGpeType(sc->sc_gpeh, sc->sc_gpebit, ACPI_GPE_TYPE_RUNTIME);
 364         if (rv != AE_OK) {
 365                 aprint_error_dev(self, "unable to set GPE type: %s\n",
 366                     AcpiFormatException(rv));
 367                 goto post_csr_map;
 368         }
 369
 370         rv = AcpiEnableGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_ISR);
 371         if (rv != AE_OK) {
 372                 aprint_error_dev(self, "unable to enable GPE: %s\n",
 373                     AcpiFormatException(rv));
 374                 goto post_csr_map;
 375         }
 376
 377         if (kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, acpiec_gpe_query,
 378                            self, NULL, "acpiec sci thread")) {
 379                 aprint_error_dev(self, "unable to create query kthread\n");
 380                 goto post_csr_map;
 381         }
 382
 383         ec_singleton = self;
 384
 385         if (!pmf_device_register1(self, acpiec_suspend, acpiec_resume,
 386             acpiec_shutdown))
 387                 aprint_error_dev(self, "couldn't establish power handler\n");
 388
 389         return;
 390
 391 post_csr_map:
 392         (void)AcpiRemoveGpeHandler(sc->sc_gpeh, sc->sc_gpebit,
 393             acpiec_gpe_handler);
 394         (void)AcpiRemoveAddressSpaceHandler(sc->sc_ech,
 395             ACPI_ADR_SPACE_EC, acpiec_space_handler);
 396         bus_space_unmap(sc->sc_csr_st, sc->sc_csr_sh, 1);
 397 post_data_map:
 398         bus_space_unmap(sc->sc_data_st, sc->sc_data_sh, 1);
 399 }
 400
 401 static bool
 402 acpiec_suspend(device_t dv, pmf_qual_t qual)
 403 {
 404         acpiec_cold = true;
 405
 406         return true;
 407 }
 408
 409 static bool
 410 acpiec_resume(device_t dv, pmf_qual_t qual)
 411 {
 412         acpiec_cold = false;
 413
 414         return true;
 415 }
 416
 417 static bool
 418 acpiec_shutdown(device_t dv, int how)
 419 {
 420
 421         acpiec_cold = true;
 422         return true;
 423 }
 424
 425 static bool
 426 acpiec_parse_gpe_package(device_t self, ACPI_HANDLE ec_handle,
 427     ACPI_HANDLE *gpe_handle, uint8_t *gpebit)
 428 {
 429         ACPI_BUFFER buf;
 430         ACPI_OBJECT *p, *c;
 431         ACPI_STATUS rv;
 432
 433         rv = acpi_eval_struct(ec_handle, "_GPE", &buf);
 434         if (rv != AE_OK) {
 435                 aprint_error_dev(self, "unable to evaluate _GPE: %s\n",
 436                     AcpiFormatException(rv));
 437                 return false;
 438         }
 439
 440         p = buf.Pointer;
 441
 442         if (p->Type == ACPI_TYPE_INTEGER) {
 443                 *gpe_handle = NULL;
 444                 *gpebit = p->Integer.Value;
 445                 ACPI_FREE(p);
 446                 return true;
 447         }
 448
 449         if (p->Type != ACPI_TYPE_PACKAGE) {
 450                 aprint_error_dev(self, "_GPE is neither integer nor package\n");
 451                 ACPI_FREE(p);
 452                 return false;
 453         }
 454
 455         if (p->Package.Count != 2) {
 456                 aprint_error_dev(self, "_GPE package does not contain 2 elements\n");
 457                 ACPI_FREE(p);
 458                 return false;
 459         }
 460
 461         c = &p->Package.Elements[0];
 462         switch (c->Type) {
 463         case ACPI_TYPE_LOCAL_REFERENCE:
 464         case ACPI_TYPE_ANY:
 465                 *gpe_handle = c->Reference.Handle;
 466                 break;
 467         case ACPI_TYPE_STRING:
 468                 /* XXX should be using real scope here */
 469                 rv = AcpiGetHandle(NULL, p->String.Pointer, gpe_handle);
 470                 if (rv != AE_OK) {
 471                         aprint_error_dev(self,
 472                             "_GPE device reference unresolvable\n");
 473                         ACPI_FREE(p);
 474                         return false;
 475                 }
 476                 break;
 477         default:
 478                 aprint_error_dev(self, "_GPE device reference incorrect\n");
 479                 ACPI_FREE(p);
 480                 return false;
 481         }
 482         c = &p->Package.Elements[1];
 483         if (c->Type != ACPI_TYPE_INTEGER) {
 484                 aprint_error_dev(self,
 485                     "_GPE package needs integer as 2nd field\n");
 486                 ACPI_FREE(p);
 487                 return false;
 488         }
 489         *gpebit = c->Integer.Value;
 490         ACPI_FREE(p);
 491         return true;
 492 }
 493
 494 static uint8_t
 495 acpiec_read_data(struct acpiec_softc *sc)
 496 {
 497         return bus_space_read_1(sc->sc_data_st, sc->sc_data_sh, 0);
 498 }
 499
 500 static void
 501 acpiec_write_data(struct acpiec_softc *sc, uint8_t val)
 502 {
 503         bus_space_write_1(sc->sc_data_st, sc->sc_data_sh, 0, val);
 504 }
 505
 506 static uint8_t
 507 acpiec_read_status(struct acpiec_softc *sc)
 508 {
 509         return bus_space_read_1(sc->sc_csr_st, sc->sc_csr_sh, 0);
 510 }
 511
 512 static void
 513 acpiec_write_command(struct acpiec_softc *sc, uint8_t cmd)
 514 {
 515         bus_space_write_1(sc->sc_csr_st, sc->sc_csr_sh, 0, cmd);
 516 }
 517
 518 static ACPI_STATUS
 519 acpiec_space_setup(ACPI_HANDLE region, UINT32 func, void *arg,
 520     void **region_arg)
 521 {
 522         if (func == ACPI_REGION_DEACTIVATE)
 523                 *region_arg = NULL;
 524         else
 525                 *region_arg = arg;
 526
 527         return AE_OK;
 528 }
 529
 530 static void
 531 acpiec_lock(device_t dv)
 532 {
 533         struct acpiec_softc *sc = device_private(dv);
 534         ACPI_STATUS rv;
 535
 536         mutex_enter(&sc->sc_access_mtx);
 537
 538         if (sc->sc_need_global_lock) {
 539                 rv = AcpiAcquireGlobalLock(EC_LOCK_TIMEOUT, &sc->sc_global_lock);
 540                 if (rv != AE_OK) {
 541                         aprint_error_dev(dv, "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, "failed to release global lock: %s\n",
 558                             AcpiFormatException(rv));
 559                 }
 560         }
 561         mutex_exit(&sc->sc_access_mtx);
 562 }
 563
 564 static ACPI_STATUS
 565 acpiec_read(device_t dv, uint8_t addr, uint8_t *val)
 566 {
 567         struct acpiec_softc *sc = device_private(dv);
 568         int i, timeo = 1000 * EC_CMD_TIMEOUT;
 569
 570         acpiec_lock(dv);
 571         mutex_enter(&sc->sc_mtx);
 572
 573         sc->sc_cur_addr = addr;
 574         sc->sc_state = EC_STATE_READ;
 575
 576         for (i = 0; i < EC_POLL_TIMEOUT; ++i) {
 577                 acpiec_gpe_state_machine(dv);
 578                 if (sc->sc_state == EC_STATE_FREE)
 579                         goto done;
 580                 delay(1);
 581         }
 582
 583         if (cold || acpiec_cold) {
 584                 while (sc->sc_state != EC_STATE_FREE && timeo-- > 0) {
 585                         delay(1000);
 586                         acpiec_gpe_state_machine(dv);
 587                 }
 588                 if (sc->sc_state != EC_STATE_FREE) {
 589                         mutex_exit(&sc->sc_mtx);
 590                         AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_NOT_ISR);
 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                 AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_NOT_ISR);
 599                 acpiec_unlock(dv);
 600                 aprint_error_dev(dv, "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                         AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_NOT_ISR);
 640                         acpiec_unlock(dv);
 641                         aprint_error_dev(dv, "command timed out, state %d\n",
 642                             sc->sc_state);
 643                         return AE_ERROR;
 644                 }
 645         } else if (cv_timedwait(&sc->sc_cv, &sc->sc_mtx, EC_CMD_TIMEOUT * hz)) {
 646                 mutex_exit(&sc->sc_mtx);
 647                 AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_NOT_ISR);
 648                 acpiec_unlock(dv);
 649                 aprint_error_dev(dv, "command takes over %d sec...\n", EC_CMD_TIMEOUT);
 650                 return AE_ERROR;
 651         }
 652
 653 done:
 654         mutex_exit(&sc->sc_mtx);
 655         acpiec_unlock(dv);
 656         return AE_OK;
 657 }
 658
 659 static ACPI_STATUS
 660 acpiec_space_handler(UINT32 func, ACPI_PHYSICAL_ADDRESS paddr,
 661     UINT32 width, ACPI_INTEGER *value, void *arg, void *region_arg)
 662 {
 663         device_t dv;
 664         struct acpiec_softc *sc;
 665         ACPI_STATUS rv;
 666         uint8_t addr, reg;
 667         unsigned int i;
 668
 669         if (paddr > 0xff || width % 8 != 0 || value == NULL || arg == NULL ||
 670             paddr + width / 8 > 0xff)
 671                 return AE_BAD_PARAMETER;
 672
 673         addr = paddr;
 674         dv = arg;
 675         sc = device_private(dv);
 676
 677         rv = AE_OK;
 678
 679         switch (func) {
 680         case ACPI_READ:
 681                 *value = 0;
 682                 for (i = 0; i < width; i += 8, ++addr) {
 683                         rv = acpiec_read(dv, addr, &reg);
 684                         if (rv != AE_OK)
 685                                 break;
 686                         *value |= (ACPI_INTEGER)reg << i;
 687                 }
 688                 break;
 689         case ACPI_WRITE:
 690                 for (i = 0; i < width; i += 8, ++addr) {
 691                         reg = (*value >>i) & 0xff;
 692                         rv = acpiec_write(dv, addr, reg);
 693                         if (rv != AE_OK)
 694                                 break;
 695                 }
 696                 break;
 697         default:
 698                 aprint_error("%s: invalid Address Space function called: %x\n",
 699                     device_xname(dv), (unsigned int)func);
 700                 return AE_BAD_PARAMETER;
 701         }
 702
 703         return rv;
 704 }
 705
 706 static void
 707 acpiec_gpe_query(void *arg)
 708 {
 709         device_t dv = arg;
 710         struct acpiec_softc *sc = device_private(dv);
 711         uint8_t reg;
 712         char qxx[5];
 713         ACPI_STATUS rv;
 714         int i;
 715
 716 loop:
 717         mutex_enter(&sc->sc_mtx);
 718
 719         if (sc->sc_got_sci == false)
 720                 cv_wait(&sc->sc_cv_sci, &sc->sc_mtx);
 721         mutex_exit(&sc->sc_mtx);
 722
 723         acpiec_lock(dv);
 724         mutex_enter(&sc->sc_mtx);
 725
 726         /* The Query command can always be issued, so be defensive here. */
 727         sc->sc_got_sci = false;
 728         sc->sc_state = EC_STATE_QUERY;
 729
 730         for (i = 0; i < EC_POLL_TIMEOUT; ++i) {
 731                 acpiec_gpe_state_machine(dv);
 732                 if (sc->sc_state == EC_STATE_FREE)
 733                         goto done;
 734                 delay(1);
 735         }
 736
 737         cv_wait(&sc->sc_cv, &sc->sc_mtx);
 738
 739 done:
 740         reg = sc->sc_cur_val;
 741
 742         mutex_exit(&sc->sc_mtx);
 743         acpiec_unlock(dv);
 744
 745         if (reg == 0)
 746                 goto loop; /* Spurious query result */
 747
 748         /*
 749          * Evaluate _Qxx to respond to the controller.
 750          */
 751         snprintf(qxx, sizeof(qxx), "_Q%02X", (unsigned int)reg);
 752         rv = AcpiEvaluateObject(sc->sc_ech, qxx, NULL, NULL);
 753         if (rv != AE_OK && rv != AE_NOT_FOUND) {
 754                 aprint_error("%s: GPE query method %s failed: %s",
 755                     device_xname(dv), qxx, AcpiFormatException(rv));
 756         }
 757
 758         goto loop;
 759 }
 760
 761 static void
 762 acpiec_gpe_state_machine(device_t dv)
 763 {
 764         struct acpiec_softc *sc = device_private(dv);
 765         uint8_t reg;
 766
 767         reg = acpiec_read_status(sc);
 768
 769         if (reg & EC_STATUS_SCI)
 770                 sc->sc_got_sci = true;
 771
 772         switch (sc->sc_state) {
 773         case EC_STATE_QUERY:
 774                 if ((reg & EC_STATUS_IBF) != 0)
 775                         break; /* Nothing of interest here. */
 776                 acpiec_write_command(sc, EC_COMMAND_QUERY);
 777                 sc->sc_state = EC_STATE_QUERY_VAL;
 778                 break;
 779
 780         case EC_STATE_QUERY_VAL:
 781                 if ((reg & EC_STATUS_OBF) == 0)
 782                         break; /* Nothing of interest here. */
 783
 784                 sc->sc_cur_val = acpiec_read_data(sc);
 785                 sc->sc_state = EC_STATE_FREE;
 786
 787                 cv_signal(&sc->sc_cv);
 788                 break;
 789
 790         case EC_STATE_READ:
 791                 if ((reg & EC_STATUS_IBF) != 0)
 792                         break; /* Nothing of interest here. */
 793
 794                 acpiec_write_command(sc, EC_COMMAND_READ);
 795                 sc->sc_state = EC_STATE_READ_ADDR;
 796                 break;
 797
 798         case EC_STATE_READ_ADDR:
 799                 if ((reg & EC_STATUS_IBF) != 0)
 800                         break; /* Nothing of interest here. */
 801
 802                 acpiec_write_data(sc, sc->sc_cur_addr);
 803                 sc->sc_state = EC_STATE_READ_VAL;
 804                 break;
 805
 806         case EC_STATE_READ_VAL:
 807                 if ((reg & EC_STATUS_OBF) == 0)
 808                         break; /* Nothing of interest here. */
 809                 sc->sc_cur_val = acpiec_read_data(sc);
 810                 sc->sc_state = EC_STATE_FREE;
 811
 812                 cv_signal(&sc->sc_cv);
 813                 break;
 814
 815         case EC_STATE_WRITE:
 816                 if ((reg & EC_STATUS_IBF) != 0)
 817                         break; /* Nothing of interest here. */
 818
 819                 acpiec_write_command(sc, EC_COMMAND_WRITE);
 820                 sc->sc_state = EC_STATE_WRITE_ADDR;
 821                 break;
 822
 823         case EC_STATE_WRITE_ADDR:
 824                 if ((reg & EC_STATUS_IBF) != 0)
 825                         break; /* Nothing of interest here. */
 826                 acpiec_write_data(sc, sc->sc_cur_addr);
 827                 sc->sc_state = EC_STATE_WRITE_VAL;
 828                 break;
 829
 830         case EC_STATE_WRITE_VAL:
 831                 if ((reg & EC_STATUS_IBF) != 0)
 832                         break; /* Nothing of interest here. */
 833                 sc->sc_state = EC_STATE_FREE;
 834                 cv_signal(&sc->sc_cv);
 835
 836                 acpiec_write_data(sc, sc->sc_cur_val);
 837                 break;
 838
 839         case EC_STATE_FREE:
 840                 if (sc->sc_got_sci)
 841                         cv_signal(&sc->sc_cv_sci);
 842                 break;
 843         default:
 844                 panic("invalid state");
 845         }
 846
 847         if (sc->sc_state != EC_STATE_FREE)
 848                 callout_schedule(&sc->sc_pseudo_intr, 1);
 849 }
 850
 851 static void
 852 acpiec_callout(void *arg)
 853 {
 854         device_t dv = arg;
 855         struct acpiec_softc *sc = device_private(dv);
 856
 857         AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_NOT_ISR);
 858
 859         mutex_enter(&sc->sc_mtx);
 860         acpiec_gpe_state_machine(dv);
 861         mutex_exit(&sc->sc_mtx);
 862 }
 863
 864 static UINT32
 865 acpiec_gpe_handler(void *arg)
 866 {
 867         device_t dv = arg;
 868         struct acpiec_softc *sc = device_private(dv);
 869
 870         AcpiClearGpe(sc->sc_gpeh, sc->sc_gpebit, ACPI_ISR);
 871
 872         mutex_enter(&sc->sc_mtx);
 873         acpiec_gpe_state_machine(dv);
 874         mutex_exit(&sc->sc_mtx);
 875
 876         return 0;
 877 }
 878
 879 ACPI_STATUS
 880 acpiec_bus_read(device_t dv, u_int addr, ACPI_INTEGER *val, int width)
 881 {
 882         return acpiec_space_handler(ACPI_READ, addr, width * 8, val, dv, NULL);
 883 }
 884
 885 ACPI_STATUS
 886 acpiec_bus_write(device_t dv, u_int addr, ACPI_INTEGER val, int width)
 887 {
 888         return acpiec_space_handler(ACPI_WRITE, addr, width * 8, &val, dv, NULL);
 889 }
 890
 891 ACPI_HANDLE
 892 acpiec_get_handle(device_t dv)
 893 {
 894         struct acpiec_softc *sc = device_private(dv);
 895
 896         return sc->sc_ech;
 897 }