wmi_acpi.c revision 1.14
1/* $NetBSD: wmi_acpi.c,v 1.14 2012/08/14 14:38:02 jruoho 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.14 2012/08/14 14:38:02 jruoho 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 45ACPI_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 56static int acpi_wmi_match(device_t, cfdata_t, void *); 57static void acpi_wmi_attach(device_t, device_t, void *); 58static int acpi_wmi_detach(device_t, int); 59static int acpi_wmi_rescan(device_t, const char *, const int *); 60static void acpi_wmi_childdet(device_t, device_t); 61static int acpi_wmi_print(void *, const char *); 62static bool acpi_wmi_init(struct acpi_wmi_softc *); 63static void acpi_wmi_init_ec(struct acpi_wmi_softc *); 64static bool acpi_wmi_add(struct acpi_wmi_softc *, ACPI_OBJECT *); 65static void acpi_wmi_del(struct acpi_wmi_softc *); 66static void acpi_wmi_dump(struct acpi_wmi_softc *); 67static ACPI_STATUS acpi_wmi_guid_get(struct acpi_wmi_softc *, 68 const char *, struct wmi_t **); 69static void acpi_wmi_event_add(struct acpi_wmi_softc *); 70static void acpi_wmi_event_del(struct acpi_wmi_softc *); 71static void acpi_wmi_event_handler(ACPI_HANDLE, uint32_t, void *); 72static ACPI_STATUS acpi_wmi_ec_handler(uint32_t, ACPI_PHYSICAL_ADDRESS, 73 uint32_t, ACPI_INTEGER *, void *, void *); 74static bool acpi_wmi_suspend(device_t, const pmf_qual_t *); 75static bool acpi_wmi_resume(device_t, const pmf_qual_t *); 76static ACPI_STATUS acpi_wmi_enable_event(ACPI_HANDLE, uint8_t, bool); 77static ACPI_STATUS acpi_wmi_enable_collection(ACPI_HANDLE, const char *, bool); 78static bool acpi_wmi_input(struct wmi_t *, uint8_t, uint8_t); 79 80const char * const acpi_wmi_ids[] = { 81 "PNP0C14", 82 "pnp0c14", 83 NULL 84}; 85 86CFATTACH_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 90static int 91acpi_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 101static void 102acpi_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 128static int 129acpi_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 150static int 151acpi_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 162static void 163acpi_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 171static int 172acpi_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 181static bool 182acpi_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 218fail: 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 228static bool 229acpi_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_SLEEP)) == 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 256fail: 257 ACPI_FREE(obj); 258 acpi_wmi_del(sc); 259 260 return false; 261} 262 263static void 264acpi_wmi_del(struct acpi_wmi_softc *sc) 265{ 266 struct wmi_t *wmi; 267 268 while (SIMPLEQ_FIRST(&sc->wmi_head) != NULL) { 269 wmi = SIMPLEQ_FIRST(&sc->wmi_head); 270 SIMPLEQ_REMOVE_HEAD(&sc->wmi_head, wmi_link); 271 kmem_free(wmi, sizeof(*wmi)); 272 } 273} 274 275static void 276acpi_wmi_dump(struct acpi_wmi_softc *sc) 277{ 278 struct wmi_t *wmi; 279 280 KASSERT(SIMPLEQ_EMPTY(&sc->wmi_head) == 0); 281 282 SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) { 283 284 aprint_debug_dev(sc->sc_dev, "{%08X-%04X-%04X-", 285 wmi->guid.data1, wmi->guid.data2, wmi->guid.data3); 286 287 aprint_debug("%02X%02X-%02X%02X%02X%02X%02X%02X} ", 288 wmi->guid.data4[0], wmi->guid.data4[1], 289 wmi->guid.data4[2], wmi->guid.data4[3], 290 wmi->guid.data4[4], wmi->guid.data4[5], 291 wmi->guid.data4[6], wmi->guid.data4[7]); 292 293 aprint_debug("oid %04X count %02X flags %02X\n", 294 UGET16(wmi->guid.oid), wmi->guid.count, wmi->guid.flags); 295 } 296} 297 298static void 299acpi_wmi_init_ec(struct acpi_wmi_softc *sc) 300{ 301 ACPI_STATUS rv; 302 deviter_t i; 303 device_t d; 304 305 d = deviter_first(&i, DEVITER_F_ROOT_FIRST); 306 307 for (; d != NULL; d = deviter_next(&i)) { 308 309 if (device_is_a(d, "acpiec") != false || 310 device_is_a(d, "acpiecdt") != false) { 311 sc->sc_ecdev = d; 312 break; 313 } 314 } 315 316 deviter_release(&i); 317 318 if (sc->sc_ecdev == NULL) 319 return; 320 321 rv = AcpiInstallAddressSpaceHandler(sc->sc_node->ad_handle, 322 ACPI_ADR_SPACE_EC, acpi_wmi_ec_handler, NULL, sc); 323 324 if (ACPI_FAILURE(rv)) 325 sc->sc_ecdev = NULL; 326} 327 328static ACPI_STATUS 329acpi_wmi_guid_get(struct acpi_wmi_softc *sc, 330 const char *src, struct wmi_t **out) 331{ 332 struct wmi_t *wmi; 333 struct guid_t *guid; 334 char bin[16]; 335 char hex[2]; 336 const char *ptr; 337 uint8_t i; 338 339 if (sc == NULL || src == NULL || strlen(src) != 36) 340 return AE_BAD_PARAMETER; 341 342 for (ptr = src, i = 0; i < 16; i++) { 343 344 if (*ptr == '-') 345 ptr++; 346 347 (void)memcpy(hex, ptr, 2); 348 349 if (HEXCHAR(hex[0]) == 0 || HEXCHAR(hex[1]) == 0) 350 return AE_BAD_HEX_CONSTANT; 351 352 bin[i] = strtoul(hex, NULL, 16) & 0xFF; 353 354 ptr++; 355 ptr++; 356 } 357 358 guid = (struct guid_t *)bin; 359 guid->data1 = be32toh(guid->data1); 360 guid->data2 = be16toh(guid->data2); 361 guid->data3 = be16toh(guid->data3); 362 363 SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) { 364 365 if (GUIDCMP(guid, &wmi->guid) != 0) { 366 367 if (out != NULL) 368 *out = wmi; 369 370 return AE_OK; 371 } 372 } 373 374 return AE_NOT_FOUND; 375} 376 377/* 378 * Checks if a GUID is present. Child devices 379 * can use this in their autoconf(9) routines. 380 */ 381int 382acpi_wmi_guid_match(device_t self, const char *guid) 383{ 384 struct acpi_wmi_softc *sc = device_private(self); 385 ACPI_STATUS rv; 386 387 rv = acpi_wmi_guid_get(sc, guid, NULL); 388 389 if (ACPI_SUCCESS(rv)) 390 return 1; 391 392 return 0; 393} 394 395/* 396 * Adds internal event handler. 397 */ 398static void 399acpi_wmi_event_add(struct acpi_wmi_softc *sc) 400{ 401 struct wmi_t *wmi; 402 ACPI_STATUS rv; 403 404 if (acpi_register_notify(sc->sc_node, acpi_wmi_event_handler) != true) 405 return; 406 407 /* 408 * Enable possible events, expensive or otherwise. 409 */ 410 SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) { 411 412 if ((wmi->guid.flags & ACPI_WMI_FLAG_EVENT) != 0) { 413 414 rv = acpi_wmi_enable_event(sc->sc_node->ad_handle, 415 wmi->guid.nid, true); 416 417 if (ACPI_SUCCESS(rv)) { 418 wmi->eevent = true; 419 continue; 420 } 421 422 aprint_debug_dev(sc->sc_dev, "failed to enable " 423 "expensive WExx: %s\n", AcpiFormatException(rv)); 424 } 425 } 426} 427 428/* 429 * Removes the internal event handler. 430 */ 431static void 432acpi_wmi_event_del(struct acpi_wmi_softc *sc) 433{ 434 struct wmi_t *wmi; 435 ACPI_STATUS rv; 436 437 acpi_deregister_notify(sc->sc_node); 438 439 SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) { 440 441 if (wmi->eevent != true) 442 continue; 443 444 KASSERT((wmi->guid.flags & ACPI_WMI_FLAG_EVENT) != 0); 445 446 rv = acpi_wmi_enable_event(sc->sc_node->ad_handle, 447 wmi->guid.nid, false); 448 449 if (ACPI_SUCCESS(rv)) { 450 wmi->eevent = false; 451 continue; 452 } 453 454 aprint_debug_dev(sc->sc_dev, "failed to disable " 455 "expensive WExx: %s\n", AcpiFormatException(rv)); 456 } 457} 458 459/* 460 * Returns extra information possibly associated with an event. 461 */ 462ACPI_STATUS 463acpi_wmi_event_get(device_t self, uint32_t event, ACPI_BUFFER *obuf) 464{ 465 struct acpi_wmi_softc *sc = device_private(self); 466 struct wmi_t *wmi; 467 ACPI_OBJECT_LIST arg; 468 ACPI_OBJECT obj; 469 ACPI_HANDLE hdl; 470 471 if (sc == NULL || obuf == NULL) 472 return AE_BAD_PARAMETER; 473 474 if (sc->sc_handler == NULL) 475 return AE_ABORT_METHOD; 476 477 hdl = sc->sc_node->ad_handle; 478 479 obj.Type = ACPI_TYPE_INTEGER; 480 obj.Integer.Value = event; 481 482 arg.Count = 0x01; 483 arg.Pointer = &obj; 484 485 obuf->Pointer = NULL; 486 obuf->Length = ACPI_ALLOCATE_LOCAL_BUFFER; 487 488 SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) { 489 490 if ((wmi->guid.flags & ACPI_WMI_FLAG_EVENT) == 0) 491 continue; 492 493 if (wmi->guid.nid != event) 494 continue; 495 496 return AcpiEvaluateObject(hdl, "_WED", &arg, obuf); 497 } 498 499 return AE_NOT_FOUND; 500} 501 502/* 503 * Forwards events to the external handler through the internal one. 504 */ 505static void 506acpi_wmi_event_handler(ACPI_HANDLE hdl, uint32_t evt, void *aux) 507{ 508 struct acpi_wmi_softc *sc; 509 device_t self = aux; 510 511 sc = device_private(self); 512 513 if (sc->sc_child == NULL) 514 return; 515 516 if (sc->sc_handler == NULL) 517 return; 518 519 (*sc->sc_handler)(NULL, evt, sc->sc_child); 520} 521 522ACPI_STATUS 523acpi_wmi_event_register(device_t self, ACPI_NOTIFY_HANDLER handler) 524{ 525 struct acpi_wmi_softc *sc = device_private(self); 526 527 if (sc == NULL) 528 return AE_BAD_PARAMETER; 529 530 if (handler != NULL && sc->sc_handler != NULL) 531 return AE_ALREADY_EXISTS; 532 533 sc->sc_handler = handler; 534 535 return AE_OK; 536} 537 538ACPI_STATUS 539acpi_wmi_event_deregister(device_t self) 540{ 541 return acpi_wmi_event_register(self, NULL); 542} 543 544/* 545 * Handler for EC regions, which may be embedded in WMI. 546 */ 547static ACPI_STATUS 548acpi_wmi_ec_handler(uint32_t func, ACPI_PHYSICAL_ADDRESS addr, 549 uint32_t width, ACPI_INTEGER *val, void *setup, void *aux) 550{ 551 struct acpi_wmi_softc *sc = aux; 552 553 if (aux == NULL || val == NULL) 554 return AE_BAD_PARAMETER; 555 556 if (addr > 0xFF || width % 8 != 0) 557 return AE_BAD_ADDRESS; 558 559 switch (func) { 560 561 case ACPI_READ: 562 (void)acpiec_bus_read(sc->sc_ecdev, addr, val, width); 563 break; 564 565 case ACPI_WRITE: 566 (void)acpiec_bus_write(sc->sc_ecdev, addr, *val, width); 567 break; 568 569 default: 570 return AE_BAD_PARAMETER; 571 } 572 573 return AE_OK; 574} 575 576/* 577 * As there is no prior knowledge about the expensive 578 * events that cause "significant overhead", try to 579 * disable (enable) these before suspending (resuming). 580 */ 581static bool 582acpi_wmi_suspend(device_t self, const pmf_qual_t *qual) 583{ 584 struct acpi_wmi_softc *sc = device_private(self); 585 586 acpi_wmi_event_del(sc); 587 588 return true; 589} 590 591static bool 592acpi_wmi_resume(device_t self, const pmf_qual_t *qual) 593{ 594 struct acpi_wmi_softc *sc = device_private(self); 595 596 acpi_wmi_event_add(sc); 597 598 return true; 599} 600 601static ACPI_STATUS 602acpi_wmi_enable_event(ACPI_HANDLE hdl, uint8_t nid, bool flag) 603{ 604 char path[5]; 605 606 snprintf(path, sizeof(path), "WE%02X", nid); 607 608 return acpi_eval_set_integer(hdl, path, (flag != false) ? 0x01 : 0x00); 609} 610 611static ACPI_STATUS 612acpi_wmi_enable_collection(ACPI_HANDLE hdl, const char *oid, bool flag) 613{ 614 char path[5]; 615 616 strlcpy(path, "WC", sizeof(path)); 617 strlcat(path, oid, sizeof(path)); 618 619 return acpi_eval_set_integer(hdl, path, (flag != false) ? 0x01 : 0x00); 620} 621 622static bool 623acpi_wmi_input(struct wmi_t *wmi, uint8_t flag, uint8_t idx) 624{ 625 626 if ((wmi->guid.flags & flag) == 0) 627 return false; 628 629 if (wmi->guid.count == 0x00) 630 return false; 631 632 if (wmi->guid.count < idx) 633 return false; 634 635 return true; 636} 637 638/* 639 * Makes a WMI data block query (WQxx). The corresponding control 640 * method for data collection will be invoked if it is available. 641 */ 642ACPI_STATUS 643acpi_wmi_data_query(device_t self, const char *guid, 644 uint8_t idx, ACPI_BUFFER *obuf) 645{ 646 struct acpi_wmi_softc *sc = device_private(self); 647 struct wmi_t *wmi; 648 char path[5] = "WQ"; 649 ACPI_OBJECT_LIST arg; 650 ACPI_STATUS rv, rvxx; 651 ACPI_OBJECT obj; 652 653 rvxx = AE_SUPPORT; 654 655 if (obuf == NULL) 656 return AE_BAD_PARAMETER; 657 658 rv = acpi_wmi_guid_get(sc, guid, &wmi); 659 660 if (ACPI_FAILURE(rv)) 661 return rv; 662 663 if (acpi_wmi_input(wmi, ACPI_WMI_FLAG_DATA, idx) != true) 664 return AE_BAD_DATA; 665 666 (void)strlcat(path, wmi->guid.oid, sizeof(path)); 667 668 obj.Type = ACPI_TYPE_INTEGER; 669 obj.Integer.Value = idx; 670 671 arg.Count = 0x01; 672 arg.Pointer = &obj; 673 674 obuf->Pointer = NULL; 675 obuf->Length = ACPI_ALLOCATE_LOCAL_BUFFER; 676 677 /* 678 * If the expensive flag is set, we should enable 679 * data collection before evaluating the WQxx buffer. 680 */ 681 if ((wmi->guid.flags & ACPI_WMI_FLAG_EXPENSIVE) != 0) { 682 683 rvxx = acpi_wmi_enable_collection(sc->sc_node->ad_handle, 684 wmi->guid.oid, true); 685 } 686 687 rv = AcpiEvaluateObject(sc->sc_node->ad_handle, path, &arg, obuf); 688 689 /* No longer needed. */ 690 if (ACPI_SUCCESS(rvxx)) { 691 692 (void)acpi_wmi_enable_collection(sc->sc_node->ad_handle, 693 wmi->guid.oid, false); 694 } 695 696#ifdef DIAGNOSTIC 697 /* 698 * XXX: It appears that quite a few laptops have WQxx 699 * methods that are declared as expensive, but lack the 700 * corresponding WCxx control method. 701 * 702 * -- Acer Aspire One is one example <jruohonen@iki.fi>. 703 */ 704 if (ACPI_FAILURE(rvxx) && rvxx != AE_SUPPORT) 705 aprint_error_dev(sc->sc_dev, "failed to evaluate WCxx " 706 "for %s: %s\n", path, AcpiFormatException(rvxx)); 707#endif 708 return rv; 709} 710 711/* 712 * Writes to a data block (WSxx). 713 */ 714ACPI_STATUS 715acpi_wmi_data_write(device_t self, const char *guid, 716 uint8_t idx, ACPI_BUFFER *ibuf) 717{ 718 struct acpi_wmi_softc *sc = device_private(self); 719 struct wmi_t *wmi; 720 ACPI_OBJECT_LIST arg; 721 ACPI_OBJECT obj[2]; 722 char path[5] = "WS"; 723 ACPI_STATUS rv; 724 725 if (ibuf == NULL) 726 return AE_BAD_PARAMETER; 727 728 rv = acpi_wmi_guid_get(sc, guid, &wmi); 729 730 if (ACPI_FAILURE(rv)) 731 return rv; 732 733 if (acpi_wmi_input(wmi, ACPI_WMI_FLAG_DATA, idx) != true) 734 return AE_BAD_DATA; 735 736 (void)strlcat(path, wmi->guid.oid, sizeof(path)); 737 738 obj[0].Integer.Value = idx; 739 obj[0].Type = ACPI_TYPE_INTEGER; 740 741 obj[1].Buffer.Length = ibuf->Length; 742 obj[1].Buffer.Pointer = ibuf->Pointer; 743 744 obj[1].Type = ((wmi->guid.flags & ACPI_WMI_FLAG_STRING) != 0) ? 745 ACPI_TYPE_STRING : ACPI_TYPE_BUFFER; 746 747 arg.Count = 0x02; 748 arg.Pointer = obj; 749 750 return AcpiEvaluateObject(sc->sc_node->ad_handle, path, &arg, NULL); 751} 752 753/* 754 * Executes a method (WMxx). 755 */ 756ACPI_STATUS 757acpi_wmi_method(device_t self, const char *guid, uint8_t idx, 758 uint32_t mid, ACPI_BUFFER *ibuf, ACPI_BUFFER *obuf) 759{ 760 struct acpi_wmi_softc *sc = device_private(self); 761 struct wmi_t *wmi; 762 ACPI_OBJECT_LIST arg; 763 ACPI_OBJECT obj[3]; 764 char path[5] = "WM"; 765 ACPI_STATUS rv; 766 767 if (ibuf == NULL || obuf == NULL) 768 return AE_BAD_PARAMETER; 769 770 rv = acpi_wmi_guid_get(sc, guid, &wmi); 771 772 if (ACPI_FAILURE(rv)) 773 return rv; 774 775 if (acpi_wmi_input(wmi, ACPI_WMI_FLAG_METHOD, idx) != true) 776 return AE_BAD_DATA; 777 778 (void)strlcat(path, wmi->guid.oid, sizeof(path)); 779 780 obj[0].Integer.Value = idx; 781 obj[1].Integer.Value = mid; 782 obj[0].Type = obj[1].Type = ACPI_TYPE_INTEGER; 783 784 obj[2].Buffer.Length = ibuf->Length; 785 obj[2].Buffer.Pointer = ibuf->Pointer; 786 787 obj[2].Type = ((wmi->guid.flags & ACPI_WMI_FLAG_STRING) != 0) ? 788 ACPI_TYPE_STRING : ACPI_TYPE_BUFFER; 789 790 arg.Count = 0x03; 791 arg.Pointer = obj; 792 793 obuf->Pointer = NULL; 794 obuf->Length = ACPI_ALLOCATE_LOCAL_BUFFER; 795 796 return AcpiEvaluateObject(sc->sc_node->ad_handle, path, &arg, obuf); 797} 798 799MODULE(MODULE_CLASS_DRIVER, acpiwmi, NULL); 800 801#ifdef _MODULE 802#include "ioconf.c" 803#endif 804 805static int 806acpiwmi_modcmd(modcmd_t cmd, void *aux) 807{ 808 int rv = 0; 809 810 switch (cmd) { 811 812 case MODULE_CMD_INIT: 813 814#ifdef _MODULE 815 rv = config_init_component(cfdriver_ioconf_acpiwmi, 816 cfattach_ioconf_acpiwmi, cfdata_ioconf_acpiwmi); 817#endif 818 break; 819 820 case MODULE_CMD_FINI: 821 822#ifdef _MODULE 823 rv = config_fini_component(cfdriver_ioconf_acpiwmi, 824 cfattach_ioconf_acpiwmi, cfdata_ioconf_acpiwmi); 825#endif 826 break; 827 828 default: 829 rv = ENOTTY; 830 } 831 832 return rv; 833} 834