1 /* $NetBSD: wmi_acpi.c,v 1.13 2011/07/17 02:46:01 jakllsch Exp $ */ 2 3 /*- 4 * Copyright (c) 2009, 2010 Jukka Ruohonen <jruohonen@iki.fi> 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 the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: wmi_acpi.c,v 1.13 2011/07/17 02:46:01 jakllsch Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/device.h> 34 #include <sys/endian.h> 35 #include <sys/kmem.h> 36 #include <sys/systm.h> 37 #include <sys/module.h> 38 39 #include <dev/acpi/acpireg.h> 40 #include <dev/acpi/acpivar.h> 41 #include <dev/acpi/acpi_ecvar.h> 42 #include <dev/acpi/wmi/wmi_acpivar.h> 43 44 #define _COMPONENT ACPI_RESOURCE_COMPONENT 45 ACPI_MODULE_NAME ("wmi_acpi") 46 47 /* 48 * This implements something called "Microsoft Windows Management 49 * Instrumentation" (WMI). This subset of ACPI is desribed in: 50 * 51 * http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx 52 * 53 * (Obtained on Thu Feb 12 18:21:44 EET 2009.) 54 */ 55 56 static int acpi_wmi_match(device_t, cfdata_t, void *); 57 static void acpi_wmi_attach(device_t, device_t, void *); 58 static int acpi_wmi_detach(device_t, int); 59 static int acpi_wmi_rescan(device_t, const char *, const int *); 60 static void acpi_wmi_childdet(device_t, device_t); 61 static int acpi_wmi_print(void *, const char *); 62 static bool acpi_wmi_init(struct acpi_wmi_softc *); 63 static void acpi_wmi_init_ec(struct acpi_wmi_softc *); 64 static bool acpi_wmi_add(struct acpi_wmi_softc *, ACPI_OBJECT *); 65 static void acpi_wmi_del(struct acpi_wmi_softc *); 66 static void acpi_wmi_dump(struct acpi_wmi_softc *); 67 static ACPI_STATUS acpi_wmi_guid_get(struct acpi_wmi_softc *, 68 const char *, struct wmi_t **); 69 static void acpi_wmi_event_add(struct acpi_wmi_softc *); 70 static void acpi_wmi_event_del(struct acpi_wmi_softc *); 71 static void acpi_wmi_event_handler(ACPI_HANDLE, uint32_t, void *); 72 static ACPI_STATUS acpi_wmi_ec_handler(uint32_t, ACPI_PHYSICAL_ADDRESS, 73 uint32_t, ACPI_INTEGER *, void *, void *); 74 static bool acpi_wmi_suspend(device_t, const pmf_qual_t *); 75 static bool acpi_wmi_resume(device_t, const pmf_qual_t *); 76 static ACPI_STATUS acpi_wmi_enable_event(ACPI_HANDLE, uint8_t, bool); 77 static ACPI_STATUS acpi_wmi_enable_collection(ACPI_HANDLE, const char *, bool); 78 static bool acpi_wmi_input(struct wmi_t *, uint8_t, uint8_t); 79 80 const char * const acpi_wmi_ids[] = { 81 "PNP0C14", 82 "pnp0c14", 83 NULL 84 }; 85 86 CFATTACH_DECL2_NEW(acpiwmi, sizeof(struct acpi_wmi_softc), 87 acpi_wmi_match, acpi_wmi_attach, acpi_wmi_detach, NULL, 88 acpi_wmi_rescan, acpi_wmi_childdet); 89 90 static int 91 acpi_wmi_match(device_t parent, cfdata_t match, void *aux) 92 { 93 struct acpi_attach_args *aa = aux; 94 95 if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE) 96 return 0; 97 98 return acpi_match_hid(aa->aa_node->ad_devinfo, acpi_wmi_ids); 99 } 100 101 static void 102 acpi_wmi_attach(device_t parent, device_t self, void *aux) 103 { 104 struct acpi_wmi_softc *sc = device_private(self); 105 struct acpi_attach_args *aa = aux; 106 107 sc->sc_dev = self; 108 sc->sc_node = aa->aa_node; 109 110 sc->sc_child = NULL; 111 sc->sc_ecdev = NULL; 112 sc->sc_handler = NULL; 113 114 aprint_naive("\n"); 115 aprint_normal(": ACPI WMI Interface\n"); 116 117 if (acpi_wmi_init(sc) != true) 118 return; 119 120 acpi_wmi_dump(sc); 121 acpi_wmi_init_ec(sc); 122 acpi_wmi_event_add(sc); 123 acpi_wmi_rescan(self, NULL, NULL); 124 125 (void)pmf_device_register(self, acpi_wmi_suspend, acpi_wmi_resume); 126 } 127 128 static int 129 acpi_wmi_detach(device_t self, int flags) 130 { 131 struct acpi_wmi_softc *sc = device_private(self); 132 133 acpi_wmi_event_del(sc); 134 135 if (sc->sc_ecdev != NULL) { 136 137 (void)AcpiRemoveAddressSpaceHandler(sc->sc_node->ad_handle, 138 ACPI_ADR_SPACE_EC, acpi_wmi_ec_handler); 139 } 140 141 if (sc->sc_child != NULL) 142 (void)config_detach(sc->sc_child, flags); 143 144 acpi_wmi_del(sc); 145 pmf_device_deregister(self); 146 147 return 0; 148 } 149 150 static int 151 acpi_wmi_rescan(device_t self, const char *ifattr, const int *locators) 152 { 153 struct acpi_wmi_softc *sc = device_private(self); 154 155 if (ifattr_match(ifattr, "acpiwmibus") && sc->sc_child == NULL) 156 sc->sc_child = config_found_ia(self, "acpiwmibus", 157 NULL, acpi_wmi_print); 158 159 return 0; 160 } 161 162 static void 163 acpi_wmi_childdet(device_t self, device_t child) 164 { 165 struct acpi_wmi_softc *sc = device_private(self); 166 167 if (sc->sc_child == child) 168 sc->sc_child = NULL; 169 } 170 171 static int 172 acpi_wmi_print(void *aux, const char *pnp) 173 { 174 175 if (pnp != NULL) 176 aprint_normal("acpiwmibus at %s", pnp); 177 178 return UNCONF; 179 } 180 181 static bool 182 acpi_wmi_init(struct acpi_wmi_softc *sc) 183 { 184 ACPI_OBJECT *obj; 185 ACPI_BUFFER buf; 186 ACPI_STATUS rv; 187 uint32_t len; 188 189 rv = acpi_eval_struct(sc->sc_node->ad_handle, "_WDG", &buf); 190 191 if (ACPI_FAILURE(rv)) 192 goto fail; 193 194 obj = buf.Pointer; 195 196 if (obj->Type != ACPI_TYPE_BUFFER) { 197 rv = AE_TYPE; 198 goto fail; 199 } 200 201 len = obj->Buffer.Length; 202 203 if (len != obj->Package.Count) { 204 rv = AE_BAD_VALUE; 205 goto fail; 206 } 207 208 CTASSERT(sizeof(struct guid_t) == 20); 209 210 if (len < sizeof(struct guid_t) || 211 len % sizeof(struct guid_t) != 0) { 212 rv = AE_BAD_DATA; 213 goto fail; 214 } 215 216 return acpi_wmi_add(sc, obj); 217 218 fail: 219 aprint_error_dev(sc->sc_dev, "failed to evaluate _WDG: %s\n", 220 AcpiFormatException(rv)); 221 222 if (buf.Pointer != NULL) 223 ACPI_FREE(buf.Pointer); 224 225 return false; 226 } 227 228 static bool 229 acpi_wmi_add(struct acpi_wmi_softc *sc, ACPI_OBJECT *obj) 230 { 231 struct wmi_t *wmi; 232 size_t i, n, offset, siz; 233 234 siz = sizeof(struct guid_t); 235 n = obj->Buffer.Length / siz; 236 237 SIMPLEQ_INIT(&sc->wmi_head); 238 239 for (i = offset = 0; i < n; ++i) { 240 241 if ((wmi = kmem_zalloc(sizeof(*wmi), KM_NOSLEEP)) == NULL) 242 goto fail; 243 244 (void)memcpy(&wmi->guid, obj->Buffer.Pointer + offset, siz); 245 246 wmi->eevent = false; 247 offset = offset + siz; 248 249 SIMPLEQ_INSERT_TAIL(&sc->wmi_head, wmi, wmi_link); 250 } 251 252 ACPI_FREE(obj); 253 254 return true; 255 256 fail: 257 ACPI_FREE(obj); 258 acpi_wmi_del(sc); 259 260 return false; 261 } 262 263 static void 264 acpi_wmi_del(struct acpi_wmi_softc *sc) 265 { 266 struct wmi_t *wmi; 267 268 if (SIMPLEQ_EMPTY(&sc->wmi_head) != 0) 269 return; 270 271 while (SIMPLEQ_FIRST(&sc->wmi_head) != NULL) { 272 273 wmi = SIMPLEQ_FIRST(&sc->wmi_head); 274 SIMPLEQ_REMOVE_HEAD(&sc->wmi_head, wmi_link); 275 276 KASSERT(wmi != NULL); 277 278 kmem_free(wmi, sizeof(*wmi)); 279 } 280 } 281 282 static void 283 acpi_wmi_dump(struct acpi_wmi_softc *sc) 284 { 285 struct wmi_t *wmi; 286 287 KASSERT(SIMPLEQ_EMPTY(&sc->wmi_head) == 0); 288 289 SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) { 290 291 aprint_debug_dev(sc->sc_dev, "{%08X-%04X-%04X-", 292 wmi->guid.data1, wmi->guid.data2, wmi->guid.data3); 293 294 aprint_debug("%02X%02X-%02X%02X%02X%02X%02X%02X} ", 295 wmi->guid.data4[0], wmi->guid.data4[1], 296 wmi->guid.data4[2], wmi->guid.data4[3], 297 wmi->guid.data4[4], wmi->guid.data4[5], 298 wmi->guid.data4[6], wmi->guid.data4[7]); 299 300 aprint_debug("oid %04X count %02X flags %02X\n", 301 UGET16(wmi->guid.oid), wmi->guid.count, wmi->guid.flags); 302 } 303 } 304 305 static void 306 acpi_wmi_init_ec(struct acpi_wmi_softc *sc) 307 { 308 ACPI_STATUS rv; 309 deviter_t i; 310 device_t d; 311 312 d = deviter_first(&i, DEVITER_F_ROOT_FIRST); 313 314 for (; d != NULL; d = deviter_next(&i)) { 315 316 if (device_is_a(d, "acpiec") != false || 317 device_is_a(d, "acpiecdt") != false) { 318 sc->sc_ecdev = d; 319 break; 320 } 321 } 322 323 deviter_release(&i); 324 325 if (sc->sc_ecdev == NULL) 326 return; 327 328 rv = AcpiInstallAddressSpaceHandler(sc->sc_node->ad_handle, 329 ACPI_ADR_SPACE_EC, acpi_wmi_ec_handler, NULL, sc); 330 331 if (ACPI_FAILURE(rv)) 332 sc->sc_ecdev = NULL; 333 } 334 335 static ACPI_STATUS 336 acpi_wmi_guid_get(struct acpi_wmi_softc *sc, 337 const char *src, struct wmi_t **out) 338 { 339 struct wmi_t *wmi; 340 struct guid_t *guid; 341 char bin[16]; 342 char hex[2]; 343 const char *ptr; 344 uint8_t i; 345 346 if (sc == NULL || src == NULL || strlen(src) != 36) 347 return AE_BAD_PARAMETER; 348 349 for (ptr = src, i = 0; i < 16; i++) { 350 351 if (*ptr == '-') 352 ptr++; 353 354 (void)memcpy(hex, ptr, 2); 355 356 if (HEXCHAR(hex[0]) == 0 || HEXCHAR(hex[1]) == 0) 357 return AE_BAD_HEX_CONSTANT; 358 359 bin[i] = strtoul(hex, NULL, 16) & 0xFF; 360 361 ptr++; 362 ptr++; 363 } 364 365 guid = (struct guid_t *)bin; 366 guid->data1 = be32toh(guid->data1); 367 guid->data2 = be16toh(guid->data2); 368 guid->data3 = be16toh(guid->data3); 369 370 SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) { 371 372 if (GUIDCMP(guid, &wmi->guid) != 0) { 373 374 if (out != NULL) 375 *out = wmi; 376 377 return AE_OK; 378 } 379 } 380 381 return AE_NOT_FOUND; 382 } 383 384 /* 385 * Checks if a GUID is present. Child devices 386 * can use this in their autoconf(9) routines. 387 */ 388 int 389 acpi_wmi_guid_match(device_t self, const char *guid) 390 { 391 struct acpi_wmi_softc *sc = device_private(self); 392 ACPI_STATUS rv; 393 394 rv = acpi_wmi_guid_get(sc, guid, NULL); 395 396 if (ACPI_SUCCESS(rv)) 397 return 1; 398 399 return 0; 400 } 401 402 /* 403 * Adds internal event handler. 404 */ 405 static void 406 acpi_wmi_event_add(struct acpi_wmi_softc *sc) 407 { 408 struct wmi_t *wmi; 409 ACPI_STATUS rv; 410 411 if (acpi_register_notify(sc->sc_node, acpi_wmi_event_handler) != true) 412 return; 413 414 /* 415 * Enable possible events, expensive or otherwise. 416 */ 417 SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) { 418 419 if ((wmi->guid.flags & ACPI_WMI_FLAG_EVENT) != 0) { 420 421 rv = acpi_wmi_enable_event(sc->sc_node->ad_handle, 422 wmi->guid.nid, true); 423 424 if (ACPI_SUCCESS(rv)) { 425 wmi->eevent = true; 426 continue; 427 } 428 429 aprint_debug_dev(sc->sc_dev, "failed to enable " 430 "expensive WExx: %s\n", AcpiFormatException(rv)); 431 } 432 } 433 } 434 435 /* 436 * Removes the internal event handler. 437 */ 438 static void 439 acpi_wmi_event_del(struct acpi_wmi_softc *sc) 440 { 441 struct wmi_t *wmi; 442 ACPI_STATUS rv; 443 444 acpi_deregister_notify(sc->sc_node); 445 446 SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) { 447 448 if (wmi->eevent != true) 449 continue; 450 451 KASSERT((wmi->guid.flags & ACPI_WMI_FLAG_EVENT) != 0); 452 453 rv = acpi_wmi_enable_event(sc->sc_node->ad_handle, 454 wmi->guid.nid, false); 455 456 if (ACPI_SUCCESS(rv)) { 457 wmi->eevent = false; 458 continue; 459 } 460 461 aprint_debug_dev(sc->sc_dev, "failed to disable " 462 "expensive WExx: %s\n", AcpiFormatException(rv)); 463 } 464 } 465 466 /* 467 * Returns extra information possibly associated with an event. 468 */ 469 ACPI_STATUS 470 acpi_wmi_event_get(device_t self, uint32_t event, ACPI_BUFFER *obuf) 471 { 472 struct acpi_wmi_softc *sc = device_private(self); 473 struct wmi_t *wmi; 474 ACPI_OBJECT_LIST arg; 475 ACPI_OBJECT obj; 476 ACPI_HANDLE hdl; 477 478 if (sc == NULL || obuf == NULL) 479 return AE_BAD_PARAMETER; 480 481 if (sc->sc_handler == NULL) 482 return AE_ABORT_METHOD; 483 484 hdl = sc->sc_node->ad_handle; 485 486 obj.Type = ACPI_TYPE_INTEGER; 487 obj.Integer.Value = event; 488 489 arg.Count = 0x01; 490 arg.Pointer = &obj; 491 492 obuf->Pointer = NULL; 493 obuf->Length = ACPI_ALLOCATE_LOCAL_BUFFER; 494 495 SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) { 496 497 if ((wmi->guid.flags & ACPI_WMI_FLAG_EVENT) == 0) 498 continue; 499 500 if (wmi->guid.nid != event) 501 continue; 502 503 return AcpiEvaluateObject(hdl, "_WED", &arg, obuf); 504 } 505 506 return AE_NOT_FOUND; 507 } 508 509 /* 510 * Forwards events to the external handler through the internal one. 511 */ 512 static void 513 acpi_wmi_event_handler(ACPI_HANDLE hdl, uint32_t evt, void *aux) 514 { 515 struct acpi_wmi_softc *sc; 516 device_t self = aux; 517 518 sc = device_private(self); 519 520 if (sc->sc_child == NULL) 521 return; 522 523 if (sc->sc_handler == NULL) 524 return; 525 526 (*sc->sc_handler)(NULL, evt, sc->sc_child); 527 } 528 529 ACPI_STATUS 530 acpi_wmi_event_register(device_t self, ACPI_NOTIFY_HANDLER handler) 531 { 532 struct acpi_wmi_softc *sc = device_private(self); 533 534 if (sc == NULL) 535 return AE_BAD_PARAMETER; 536 537 if (handler != NULL && sc->sc_handler != NULL) 538 return AE_ALREADY_EXISTS; 539 540 sc->sc_handler = handler; 541 542 return AE_OK; 543 } 544 545 ACPI_STATUS 546 acpi_wmi_event_deregister(device_t self) 547 { 548 return acpi_wmi_event_register(self, NULL); 549 } 550 551 /* 552 * Handler for EC regions, which may be embedded in WMI. 553 */ 554 static ACPI_STATUS 555 acpi_wmi_ec_handler(uint32_t func, ACPI_PHYSICAL_ADDRESS addr, 556 uint32_t width, ACPI_INTEGER *val, void *setup, void *aux) 557 { 558 struct acpi_wmi_softc *sc = aux; 559 560 if (aux == NULL || val == NULL) 561 return AE_BAD_PARAMETER; 562 563 if (addr > 0xFF || width % 8 != 0) 564 return AE_BAD_ADDRESS; 565 566 switch (func) { 567 568 case ACPI_READ: 569 (void)acpiec_bus_read(sc->sc_ecdev, addr, val, width); 570 break; 571 572 case ACPI_WRITE: 573 (void)acpiec_bus_write(sc->sc_ecdev, addr, *val, width); 574 break; 575 576 default: 577 return AE_BAD_PARAMETER; 578 } 579 580 return AE_OK; 581 } 582 583 /* 584 * As there is no prior knowledge about the expensive 585 * events that cause "significant overhead", try to 586 * disable (enable) these before suspending (resuming). 587 */ 588 static bool 589 acpi_wmi_suspend(device_t self, const pmf_qual_t *qual) 590 { 591 struct acpi_wmi_softc *sc = device_private(self); 592 593 acpi_wmi_event_del(sc); 594 595 return true; 596 } 597 598 static bool 599 acpi_wmi_resume(device_t self, const pmf_qual_t *qual) 600 { 601 struct acpi_wmi_softc *sc = device_private(self); 602 603 acpi_wmi_event_add(sc); 604 605 return true; 606 } 607 608 static ACPI_STATUS 609 acpi_wmi_enable_event(ACPI_HANDLE hdl, uint8_t nid, bool flag) 610 { 611 char path[5]; 612 613 snprintf(path, sizeof(path), "WE%02X", nid); 614 615 return acpi_eval_set_integer(hdl, path, (flag != false) ? 0x01 : 0x00); 616 } 617 618 static ACPI_STATUS 619 acpi_wmi_enable_collection(ACPI_HANDLE hdl, const char *oid, bool flag) 620 { 621 char path[5]; 622 623 strlcpy(path, "WC", sizeof(path)); 624 strlcat(path, oid, sizeof(path)); 625 626 return acpi_eval_set_integer(hdl, path, (flag != false) ? 0x01 : 0x00); 627 } 628 629 static bool 630 acpi_wmi_input(struct wmi_t *wmi, uint8_t flag, uint8_t idx) 631 { 632 633 if ((wmi->guid.flags & flag) == 0) 634 return false; 635 636 if (wmi->guid.count == 0x00) 637 return false; 638 639 if (wmi->guid.count < idx) 640 return false; 641 642 return true; 643 } 644 645 /* 646 * Makes a WMI data block query (WQxx). The corresponding control 647 * method for data collection will be invoked if it is available. 648 */ 649 ACPI_STATUS 650 acpi_wmi_data_query(device_t self, const char *guid, 651 uint8_t idx, ACPI_BUFFER *obuf) 652 { 653 struct acpi_wmi_softc *sc = device_private(self); 654 struct wmi_t *wmi; 655 char path[5] = "WQ"; 656 ACPI_OBJECT_LIST arg; 657 ACPI_STATUS rv, rvxx; 658 ACPI_OBJECT obj; 659 660 rvxx = AE_SUPPORT; 661 662 if (obuf == NULL) 663 return AE_BAD_PARAMETER; 664 665 rv = acpi_wmi_guid_get(sc, guid, &wmi); 666 667 if (ACPI_FAILURE(rv)) 668 return rv; 669 670 if (acpi_wmi_input(wmi, ACPI_WMI_FLAG_DATA, idx) != true) 671 return AE_BAD_DATA; 672 673 (void)strlcat(path, wmi->guid.oid, sizeof(path)); 674 675 obj.Type = ACPI_TYPE_INTEGER; 676 obj.Integer.Value = idx; 677 678 arg.Count = 0x01; 679 arg.Pointer = &obj; 680 681 obuf->Pointer = NULL; 682 obuf->Length = ACPI_ALLOCATE_LOCAL_BUFFER; 683 684 /* 685 * If the expensive flag is set, we should enable 686 * data collection before evaluating the WQxx buffer. 687 */ 688 if ((wmi->guid.flags & ACPI_WMI_FLAG_EXPENSIVE) != 0) { 689 690 rvxx = acpi_wmi_enable_collection(sc->sc_node->ad_handle, 691 wmi->guid.oid, true); 692 } 693 694 rv = AcpiEvaluateObject(sc->sc_node->ad_handle, path, &arg, obuf); 695 696 /* No longer needed. */ 697 if (ACPI_SUCCESS(rvxx)) { 698 699 (void)acpi_wmi_enable_collection(sc->sc_node->ad_handle, 700 wmi->guid.oid, false); 701 } 702 703 #ifdef DIAGNOSTIC 704 /* 705 * XXX: It appears that quite a few laptops have WQxx 706 * methods that are declared as expensive, but lack the 707 * corresponding WCxx control method. 708 * 709 * -- Acer Aspire One is one example <jruohonen@iki.fi>. 710 */ 711 if (ACPI_FAILURE(rvxx) && rvxx != AE_SUPPORT) 712 aprint_error_dev(sc->sc_dev, "failed to evaluate WCxx " 713 "for %s: %s\n", path, AcpiFormatException(rvxx)); 714 #endif 715 return rv; 716 } 717 718 /* 719 * Writes to a data block (WSxx). 720 */ 721 ACPI_STATUS 722 acpi_wmi_data_write(device_t self, const char *guid, 723 uint8_t idx, ACPI_BUFFER *ibuf) 724 { 725 struct acpi_wmi_softc *sc = device_private(self); 726 struct wmi_t *wmi; 727 ACPI_OBJECT_LIST arg; 728 ACPI_OBJECT obj[2]; 729 char path[5] = "WS"; 730 ACPI_STATUS rv; 731 732 if (ibuf == NULL) 733 return AE_BAD_PARAMETER; 734 735 rv = acpi_wmi_guid_get(sc, guid, &wmi); 736 737 if (ACPI_FAILURE(rv)) 738 return rv; 739 740 if (acpi_wmi_input(wmi, ACPI_WMI_FLAG_DATA, idx) != true) 741 return AE_BAD_DATA; 742 743 (void)strlcat(path, wmi->guid.oid, sizeof(path)); 744 745 obj[0].Integer.Value = idx; 746 obj[0].Type = ACPI_TYPE_INTEGER; 747 748 obj[1].Buffer.Length = ibuf->Length; 749 obj[1].Buffer.Pointer = ibuf->Pointer; 750 751 obj[1].Type = ((wmi->guid.flags & ACPI_WMI_FLAG_STRING) != 0) ? 752 ACPI_TYPE_STRING : ACPI_TYPE_BUFFER; 753 754 arg.Count = 0x02; 755 arg.Pointer = obj; 756 757 return AcpiEvaluateObject(sc->sc_node->ad_handle, path, &arg, NULL); 758 } 759 760 /* 761 * Executes a method (WMxx). 762 */ 763 ACPI_STATUS 764 acpi_wmi_method(device_t self, const char *guid, uint8_t idx, 765 uint32_t mid, ACPI_BUFFER *ibuf, ACPI_BUFFER *obuf) 766 { 767 struct acpi_wmi_softc *sc = device_private(self); 768 struct wmi_t *wmi; 769 ACPI_OBJECT_LIST arg; 770 ACPI_OBJECT obj[3]; 771 char path[5] = "WM"; 772 ACPI_STATUS rv; 773 774 if (ibuf == NULL || obuf == NULL) 775 return AE_BAD_PARAMETER; 776 777 rv = acpi_wmi_guid_get(sc, guid, &wmi); 778 779 if (ACPI_FAILURE(rv)) 780 return rv; 781 782 if (acpi_wmi_input(wmi, ACPI_WMI_FLAG_METHOD, idx) != true) 783 return AE_BAD_DATA; 784 785 (void)strlcat(path, wmi->guid.oid, sizeof(path)); 786 787 obj[0].Integer.Value = idx; 788 obj[1].Integer.Value = mid; 789 obj[0].Type = obj[1].Type = ACPI_TYPE_INTEGER; 790 791 obj[2].Buffer.Length = ibuf->Length; 792 obj[2].Buffer.Pointer = ibuf->Pointer; 793 794 obj[2].Type = ((wmi->guid.flags & ACPI_WMI_FLAG_STRING) != 0) ? 795 ACPI_TYPE_STRING : ACPI_TYPE_BUFFER; 796 797 arg.Count = 0x03; 798 arg.Pointer = obj; 799 800 obuf->Pointer = NULL; 801 obuf->Length = ACPI_ALLOCATE_LOCAL_BUFFER; 802 803 return AcpiEvaluateObject(sc->sc_node->ad_handle, path, &arg, obuf); 804 } 805 806 MODULE(MODULE_CLASS_DRIVER, acpiwmi, NULL); 807 808 #ifdef _MODULE 809 #include "ioconf.c" 810 #endif 811 812 static int 813 acpiwmi_modcmd(modcmd_t cmd, void *aux) 814 { 815 int rv = 0; 816 817 switch (cmd) { 818 819 case MODULE_CMD_INIT: 820 821 #ifdef _MODULE 822 rv = config_init_component(cfdriver_ioconf_acpiwmi, 823 cfattach_ioconf_acpiwmi, cfdata_ioconf_acpiwmi); 824 #endif 825 break; 826 827 case MODULE_CMD_FINI: 828 829 #ifdef _MODULE 830 rv = config_fini_component(cfdriver_ioconf_acpiwmi, 831 cfattach_ioconf_acpiwmi, cfdata_ioconf_acpiwmi); 832 #endif 833 break; 834 835 default: 836 rv = ENOTTY; 837 } 838 839 return rv; 840 } 841