acpi.c revision 1.21
1 /* $NetBSD: acpi.c,v 1.21 2002/12/30 09:33:25 matt Exp $ */ 2 3 /* 4 * Copyright 2001 Wasabi Systems, Inc. 5 * All rights reserved. 6 * 7 * Written by Jason R. Thorpe for Wasabi Systems, Inc. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed for the NetBSD Project by 20 * Wasabi Systems, Inc. 21 * 4. The name of Wasabi Systems, Inc. may not be used to endorse 22 * or promote products derived from this software without specific prior 23 * written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC 29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 /* 39 * Autoconfiguration support for the Intel ACPI Component Architecture 40 * ACPI reference implementation. 41 */ 42 43 #include <sys/cdefs.h> 44 __KERNEL_RCSID(0, "$NetBSD: acpi.c,v 1.21 2002/12/30 09:33:25 matt Exp $"); 45 46 #include <sys/param.h> 47 #include <sys/systm.h> 48 #include <sys/device.h> 49 #include <sys/malloc.h> 50 51 #include <dev/acpi/acpica.h> 52 #include <dev/acpi/acpireg.h> 53 #include <dev/acpi/acpivar.h> 54 #include <dev/acpi/acpi_osd.h> 55 56 #ifndef ACPI_PCI_FIXUP 57 #define ACPI_PCI_FIXUP 1 58 #endif 59 60 #ifndef ACPI_ACTIVATE_DEV 61 #define ACPI_ACTIVATE_DEV 0 62 #endif 63 64 #if ACPI_PCI_FIXUP 65 #include <dev/acpi/acpica/Subsystem/acnamesp.h> /* AcpiNsGetNodeByPath() */ 66 #include <dev/pci/pcidevs.h> 67 #endif 68 69 #include <machine/acpi_machdep.h> 70 71 #ifdef ENABLE_DEBUGGER 72 #define ACPI_DBGR_INIT 0x01 73 #define ACPI_DBGR_TABLES 0x02 74 #define ACPI_DBGR_ENABLE 0x04 75 #define ACPI_DBGR_PROBE 0x08 76 #define ACPI_DBGR_RUNNING 0x10 77 78 int acpi_dbgr = 0x00; 79 #endif 80 81 int acpi_match(struct device *, struct cfdata *, void *); 82 void acpi_attach(struct device *, struct device *, void *); 83 84 int acpi_print(void *aux, const char *); 85 86 extern struct cfdriver acpi_cd; 87 88 CFATTACH_DECL(acpi, sizeof(struct acpi_softc), 89 acpi_match, acpi_attach, NULL, NULL); 90 91 /* 92 * This is a flag we set when the ACPI subsystem is active. Machine 93 * dependent code may wish to skip other steps (such as attaching 94 * subsystems that ACPI supercedes) when ACPI is active. 95 */ 96 int acpi_active; 97 98 /* 99 * Pointer to the ACPI subsystem's state. There can be only 100 * one ACPI instance. 101 */ 102 struct acpi_softc *acpi_softc; 103 104 void acpi_shutdown(void *); 105 ACPI_STATUS acpi_disable(struct acpi_softc *sc); 106 void acpi_build_tree(struct acpi_softc *); 107 ACPI_STATUS acpi_make_devnode(ACPI_HANDLE, UINT32, void *, void **); 108 109 void acpi_enable_fixed_events(struct acpi_softc *); 110 #if ACPI_PCI_FIXUP 111 void acpi_pci_fixup(struct acpi_softc *); 112 #endif 113 #if ACPI_PCI_FIXUP || ACPI_ACTIVATE_DEV 114 ACPI_STATUS acpi_allocate_resources(ACPI_HANDLE handle); 115 #endif 116 117 /* 118 * acpi_probe: 119 * 120 * Probe for ACPI support. This is called by the 121 * machine-dependent ACPI front-end. All of the 122 * actual work is done by ACPICA. 123 * 124 * NOTE: This is not an autoconfiguration interface function. 125 */ 126 int 127 acpi_probe(void) 128 { 129 static int beenhere; 130 ACPI_STATUS rv; 131 132 if (beenhere != 0) 133 panic("acpi_probe: ACPI has already been probed"); 134 beenhere = 1; 135 136 /* 137 * Start up ACPICA. 138 */ 139 #ifdef ENABLE_DEBUGGER 140 if (acpi_dbgr & ACPI_DBGR_INIT) 141 acpi_osd_debugger(); 142 #endif 143 144 rv = AcpiInitializeSubsystem(); 145 if (rv != AE_OK) { 146 printf("ACPI: unable to initialize ACPICA: %d\n", rv); 147 return (0); 148 } 149 150 #ifdef ENABLE_DEBUGGER 151 if (acpi_dbgr & ACPI_DBGR_TABLES) 152 acpi_osd_debugger(); 153 #endif 154 155 rv = AcpiLoadTables(); 156 if (rv != AE_OK) { 157 printf("ACPI: unable to load tables: %d\n", rv); 158 return (0); 159 } 160 161 /* 162 * Looks like we have ACPI! 163 */ 164 165 return (1); 166 } 167 168 /* 169 * acpi_match: 170 * 171 * Autoconfiguration `match' routine. 172 */ 173 int 174 acpi_match(struct device *parent, struct cfdata *match, void *aux) 175 { 176 struct acpibus_attach_args *aa = aux; 177 178 if (strcmp(aa->aa_busname, acpi_cd.cd_name) != 0) 179 return (0); 180 181 /* 182 * XXX Check other locators? Hard to know -- machine 183 * dependent code has already checked for the presence 184 * of ACPI by calling acpi_probe(), so I suppose we 185 * don't really have to do anything else. 186 */ 187 return (1); 188 } 189 190 /* 191 * acpi_attach: 192 * 193 * Autoconfiguration `attach' routine. Finish initializing 194 * ACPICA (some initialization was done in acpi_probe(), 195 * which was required to check for the presence of ACPI), 196 * and enable the ACPI subsystem. 197 */ 198 void 199 acpi_attach(struct device *parent, struct device *self, void *aux) 200 { 201 struct acpi_softc *sc = (void *) self; 202 struct acpibus_attach_args *aa = aux; 203 ACPI_STATUS rv; 204 205 printf("\n"); 206 207 if (acpi_softc != NULL) 208 panic("acpi_attach: ACPI has already been attached"); 209 210 sc->sc_iot = aa->aa_iot; 211 sc->sc_memt = aa->aa_memt; 212 sc->sc_pc = aa->aa_pc; 213 sc->sc_pciflags = aa->aa_pciflags; 214 sc->sc_ic = aa->aa_ic; 215 216 acpi_softc = sc; 217 218 /* 219 * Install the default address space handlers. 220 */ 221 222 rv = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, 223 ACPI_ADR_SPACE_SYSTEM_MEMORY, ACPI_DEFAULT_HANDLER, NULL, NULL); 224 if (rv != AE_OK) { 225 printf("%s: unable to install SYSTEM MEMORY handler: %d\n", 226 sc->sc_dev.dv_xname, rv); 227 return; 228 } 229 230 rv = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, 231 ACPI_ADR_SPACE_SYSTEM_IO, ACPI_DEFAULT_HANDLER, NULL, NULL); 232 if (rv != AE_OK) { 233 printf("%s: unable to install SYSTEM IO handler: %d\n", 234 sc->sc_dev.dv_xname, rv); 235 return; 236 } 237 238 rv = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, 239 ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL); 240 if (rv != AE_OK) { 241 printf("%s: unable to install PCI CONFIG handler: %d\n", 242 sc->sc_dev.dv_xname, rv); 243 return; 244 } 245 246 /* 247 * Bring ACPI on-line. 248 * 249 * Note that we request that _STA (device init) and _INI (object init) 250 * methods not be run. 251 * 252 * XXX We need to arrange for the object init pass after we have 253 * XXX attached all of our children. 254 */ 255 #ifdef ENABLE_DEBUGGER 256 if (acpi_dbgr & ACPI_DBGR_ENABLE) 257 acpi_osd_debugger(); 258 #endif 259 rv = AcpiEnableSubsystem(ACPI_NO_DEVICE_INIT | ACPI_NO_OBJECT_INIT); 260 if (rv != AE_OK) { 261 printf("%s: unable to enable ACPI: %d\n", 262 sc->sc_dev.dv_xname, rv); 263 return; 264 } 265 acpi_active = 1; 266 267 /* 268 * Set up the default sleep state to enter when various 269 * switches are activated. 270 */ 271 sc->sc_switch_sleep[ACPI_SWITCH_POWERBUTTON] = ACPI_STATE_S5; 272 sc->sc_switch_sleep[ACPI_SWITCH_SLEEPBUTTON] = ACPI_STATE_S1; 273 sc->sc_switch_sleep[ACPI_SWITCH_LID] = ACPI_STATE_S1; 274 275 /* Our current state is "awake". */ 276 sc->sc_sleepstate = ACPI_STATE_S0; 277 278 /* Show SCI interrupt. */ 279 if (AcpiGbl_FADT != NULL) 280 printf("%s: SCI interrupting at irq %d\n", 281 sc->sc_dev.dv_xname, AcpiGbl_FADT->SciInt); 282 /* 283 * Check for fixed-hardware features. 284 */ 285 acpi_enable_fixed_events(sc); 286 287 /* 288 * Fix up PCI devices. 289 */ 290 #if ACPI_PCI_FIXUP 291 acpi_pci_fixup(sc); 292 #endif 293 294 /* 295 * Scan the namespace and build our device tree. 296 */ 297 #ifdef ENABLE_DEBUGGER 298 if (acpi_dbgr & ACPI_DBGR_PROBE) 299 acpi_osd_debugger(); 300 #endif 301 acpi_build_tree(sc); 302 303 /* 304 * Register a shutdown hook that disables certain ACPI 305 * events that might happen and confuse us while we're 306 * trying to shut down. 307 */ 308 sc->sc_sdhook = shutdownhook_establish(acpi_shutdown, sc); 309 if (sc->sc_sdhook == NULL) 310 printf("%s: WARNING: unable to register shutdown hook\n", 311 sc->sc_dev.dv_xname); 312 313 #ifdef ENABLE_DEBUGGER 314 if (acpi_dbgr & ACPI_DBGR_RUNNING) 315 acpi_osd_debugger(); 316 #endif 317 } 318 319 /* 320 * acpi_shutdown: 321 * 322 * Shutdown hook for ACPI -- disable some events that 323 * might confuse us. 324 */ 325 void 326 acpi_shutdown(void *arg) 327 { 328 struct acpi_softc *sc = arg; 329 330 if (acpi_disable(sc) != AE_OK) 331 printf("%s: WARNING: unable to disable ACPI\n", 332 sc->sc_dev.dv_xname); 333 } 334 335 /* 336 * acpi_disable: 337 * 338 * Disable ACPI. 339 */ 340 ACPI_STATUS 341 acpi_disable(struct acpi_softc *sc) 342 { 343 ACPI_STATUS rv = AE_OK; 344 345 if (acpi_active) { 346 rv = AcpiDisable(); 347 if (rv == AE_OK) 348 acpi_active = 0; 349 } 350 return (rv); 351 } 352 353 struct acpi_make_devnode_state { 354 struct acpi_softc *softc; 355 struct acpi_scope *scope; 356 }; 357 358 /* 359 * acpi_build_tree: 360 * 361 * Scan relevant portions of the ACPI namespace and attach 362 * child devices. 363 */ 364 void 365 acpi_build_tree(struct acpi_softc *sc) 366 { 367 static const char *scopes[] = { 368 "\\_PR_", /* ACPI 1.0 processor namespace */ 369 "\\_SB_", /* system bus namespace */ 370 "\\_SI_", /* system idicator namespace */ 371 "\\_TZ_", /* ACPI 1.0 thermal zone namespace */ 372 NULL, 373 }; 374 struct acpi_attach_args aa; 375 struct acpi_make_devnode_state state; 376 struct acpi_scope *as; 377 struct acpi_devnode *ad; 378 ACPI_HANDLE parent; 379 int i; 380 381 TAILQ_INIT(&sc->sc_scopes); 382 383 state.softc = sc; 384 385 /* 386 * Scan the namespace and build our tree. 387 */ 388 for (i = 0; scopes[i] != NULL; i++) { 389 as = malloc(sizeof(*as), M_DEVBUF, M_WAITOK); 390 as->as_name = scopes[i]; 391 TAILQ_INIT(&as->as_devnodes); 392 393 TAILQ_INSERT_TAIL(&sc->sc_scopes, as, as_list); 394 395 state.scope = as; 396 397 if (AcpiGetHandle(ACPI_ROOT_OBJECT, (char *) scopes[i], 398 &parent) == AE_OK) { 399 AcpiWalkNamespace(ACPI_TYPE_ANY, parent, 100, 400 acpi_make_devnode, &state, NULL); 401 } 402 403 /* Now, for this namespace, try and attach the devices. */ 404 TAILQ_FOREACH(ad, &as->as_devnodes, ad_list) { 405 aa.aa_node = ad; 406 aa.aa_iot = sc->sc_iot; 407 aa.aa_memt = sc->sc_memt; 408 aa.aa_pc = sc->sc_pc; 409 aa.aa_pciflags = sc->sc_pciflags; 410 aa.aa_ic = sc->sc_ic; 411 412 /* 413 * XXX We only attach devices which are: 414 * 415 * - present 416 * - enabled 417 * - functioning properly 418 * 419 * However, if enabled, it's decoding resources, 420 * so we should claim them, if possible. Requires 421 * changes to bus_space(9). 422 */ 423 if ((ad->ad_devinfo.CurrentStatus & 424 (ACPI_STA_DEV_PRESENT|ACPI_STA_DEV_ENABLED| 425 ACPI_STA_DEV_OK)) != 426 (ACPI_STA_DEV_PRESENT|ACPI_STA_DEV_ENABLED| 427 ACPI_STA_DEV_OK)) 428 continue; 429 430 /* 431 * XXX Same problem as above... 432 */ 433 if ((ad->ad_devinfo.Valid & ACPI_VALID_HID) == 0) 434 continue; 435 436 ad->ad_device = config_found(&sc->sc_dev, 437 &aa, acpi_print); 438 } 439 } 440 } 441 442 #if ACPI_ACTIVATE_DEV 443 static void 444 acpi_activate_device(ACPI_HANDLE handle, ACPI_DEVICE_INFO *di) 445 { 446 ACPI_STATUS rv; 447 448 #ifdef ACPI_DEBUG 449 printf("acpi_activate_device: %s, old status=%x\n", 450 di->HardwareId, di->CurrentStatus); 451 #endif 452 453 rv = acpi_allocate_resources(handle); 454 if (ACPI_FAILURE(rv)) { 455 printf("acpi: activate failed for %s\n", di->HardwareId); 456 } 457 458 (void)AcpiGetObjectInfo(handle, di); 459 #ifdef ACPI_DEBUG 460 printf("acpi_activate_device: %s, new status=%x\n", 461 di->HardwareId, di->CurrentStatus); 462 #endif 463 } 464 #endif /* ACPI_ACTIVATE_DEV */ 465 466 /* 467 * acpi_make_devnode: 468 * 469 * Make an ACPI devnode. 470 */ 471 ACPI_STATUS 472 acpi_make_devnode(ACPI_HANDLE handle, UINT32 level, void *context, 473 void **status) 474 { 475 struct acpi_make_devnode_state *state = context; 476 #if defined(ACPI_DEBUG) || defined(ACPI_EXTRA_DEBUG) 477 struct acpi_softc *sc = state->softc; 478 #endif 479 struct acpi_scope *as = state->scope; 480 struct acpi_devnode *ad; 481 ACPI_DEVICE_INFO devinfo; 482 ACPI_OBJECT_TYPE type; 483 ACPI_STATUS rv; 484 485 if (AcpiGetType(handle, &type) == AE_OK) { 486 rv = AcpiGetObjectInfo(handle, &devinfo); 487 if (rv != AE_OK) { 488 #ifdef ACPI_DEBUG 489 printf("%s: AcpiGetObjectInfo failed\n", 490 sc->sc_dev.dv_xname); 491 #endif 492 goto out; /* XXX why return OK */ 493 } 494 495 switch (type) { 496 case ACPI_TYPE_DEVICE: 497 #if ACPI_ACTIVATE_DEV 498 if ((devinfo.Valid & ACPI_VALID_STA) && 499 (devinfo.CurrentStatus & 500 (ACPI_STA_DEV_PRESENT|ACPI_STA_DEV_ENABLED)) == 501 ACPI_STA_DEV_PRESENT) 502 acpi_activate_device(handle, &devinfo); 503 /* FALLTHROUGH */ 504 #endif 505 506 case ACPI_TYPE_PROCESSOR: 507 case ACPI_TYPE_THERMAL: 508 case ACPI_TYPE_POWER: 509 ad = malloc(sizeof(*ad), M_DEVBUF, M_NOWAIT|M_ZERO); 510 if (ad == NULL) 511 return (AE_NO_MEMORY); 512 513 ad->ad_handle = handle; 514 ad->ad_level = level; 515 ad->ad_scope = as; 516 ad->ad_type = type; 517 518 TAILQ_INSERT_TAIL(&as->as_devnodes, ad, ad_list); 519 520 rv = AcpiGetObjectInfo(handle, &ad->ad_devinfo); 521 if (rv != AE_OK) 522 goto out; 523 524 if ((ad->ad_devinfo.Valid & ACPI_VALID_HID) == 0) 525 goto out; 526 527 #ifdef ACPI_EXTRA_DEBUG 528 printf("%s: HID %s found in scope %s level %d\n", 529 sc->sc_dev.dv_xname, ad->ad_devinfo.HardwareId, 530 as->as_name, ad->ad_level); 531 if (ad->ad_devinfo.Valid & ACPI_VALID_UID) 532 printf(" UID %s\n", 533 ad->ad_devinfo.UniqueId); 534 if (ad->ad_devinfo.Valid & ACPI_VALID_ADR) 535 printf(" ADR 0x%016qx\n", 536 ad->ad_devinfo.Address); 537 if (ad->ad_devinfo.Valid & ACPI_VALID_STA) 538 printf(" STA 0x%08x\n", 539 ad->ad_devinfo.CurrentStatus); 540 #endif 541 } 542 } 543 out: 544 return (AE_OK); 545 } 546 547 /* 548 * acpi_print: 549 * 550 * Autoconfiguration print routine. 551 */ 552 int 553 acpi_print(void *aux, const char *pnp) 554 { 555 struct acpi_attach_args *aa = aux; 556 #if 0 557 char *str; 558 #endif 559 560 if (pnp) { 561 printf("%s ", aa->aa_node->ad_devinfo.HardwareId); 562 #if 0 /* Not until we fix acpi_eval_string */ 563 if (acpi_eval_string(aa->aa_node->ad_handle, 564 "_STR", &str) == AE_OK) { 565 printf("[%s] ", str); 566 AcpiOsFree(str); 567 } 568 #endif 569 printf("at %s", pnp); 570 } else { 571 printf(" (%s", aa->aa_node->ad_devinfo.HardwareId); 572 if (aa->aa_node->ad_devinfo.Valid & ACPI_VALID_UID) 573 printf("-%s", aa->aa_node->ad_devinfo.UniqueId); 574 printf(")"); 575 } 576 577 return (UNCONF); 578 } 579 580 /***************************************************************************** 581 * ACPI fixed-hardware feature handlers 582 *****************************************************************************/ 583 584 UINT32 acpi_fixed_power_button_handler(void *); 585 UINT32 acpi_fixed_sleep_button_handler(void *); 586 587 /* 588 * acpi_enable_fixed_events: 589 * 590 * Enable any fixed-hardware feature handlers. 591 */ 592 void 593 acpi_enable_fixed_events(struct acpi_softc *sc) 594 { 595 static int beenhere; 596 ACPI_STATUS rv; 597 598 /* 599 * Check for fixed-hardware buttons. 600 */ 601 602 if (AcpiGbl_FADT != NULL && AcpiGbl_FADT->PwrButton == 0) { 603 if (beenhere == 0) 604 printf("%s: fixed-feature power button present\n", 605 sc->sc_dev.dv_xname); 606 rv = AcpiInstallFixedEventHandler(ACPI_EVENT_POWER_BUTTON, 607 acpi_fixed_power_button_handler, sc); 608 if (rv != AE_OK) 609 printf("%s: unable to install handler for fixed " 610 "power button: %d\n", sc->sc_dev.dv_xname, rv); 611 } 612 613 if (AcpiGbl_FADT != NULL && AcpiGbl_FADT->SleepButton == 0) { 614 if (beenhere == 0) 615 printf("%s: fixed-feature sleep button present\n", 616 sc->sc_dev.dv_xname); 617 rv = AcpiInstallFixedEventHandler(ACPI_EVENT_SLEEP_BUTTON, 618 acpi_fixed_sleep_button_handler, sc); 619 if (rv != AE_OK) 620 printf("%s: unable to install handler for fixed " 621 "power button: %d\n", sc->sc_dev.dv_xname, rv); 622 } 623 624 beenhere = 1; 625 } 626 627 /* 628 * acpi_fixed_power_button_handler: 629 * 630 * Fixed event handler for the power button. 631 */ 632 UINT32 633 acpi_fixed_power_button_handler(void *context) 634 { 635 struct acpi_softc *sc = context; 636 637 /* XXX XXX XXX */ 638 639 printf("%s: fixed power button pressed\n", sc->sc_dev.dv_xname); 640 641 return (ACPI_INTERRUPT_HANDLED); 642 } 643 644 /* 645 * acpi_fixed_sleep_button_handler: 646 * 647 * Fixed event handler for the sleep button. 648 */ 649 UINT32 650 acpi_fixed_sleep_button_handler(void *context) 651 { 652 struct acpi_softc *sc = context; 653 654 /* XXX XXX XXX */ 655 656 printf("%s: fixed sleep button pressed\n", sc->sc_dev.dv_xname); 657 658 return (ACPI_INTERRUPT_HANDLED); 659 } 660 661 /***************************************************************************** 662 * ACPI utility routines. 663 *****************************************************************************/ 664 665 /* 666 * acpi_eval_integer: 667 * 668 * Evaluate an integer object. 669 */ 670 ACPI_STATUS 671 acpi_eval_integer(ACPI_HANDLE handle, char *path, int *valp) 672 { 673 ACPI_STATUS rv; 674 ACPI_BUFFER buf; 675 ACPI_OBJECT param; 676 677 if (handle == NULL) 678 handle = ACPI_ROOT_OBJECT; 679 680 buf.Pointer = ¶m; 681 buf.Length = sizeof(param); 682 683 rv = AcpiEvaluateObject(handle, path, NULL, &buf); 684 if (rv == AE_OK) { 685 if (param.Type == ACPI_TYPE_INTEGER) 686 *valp = param.Integer.Value; 687 else 688 rv = AE_TYPE; 689 } 690 691 return (rv); 692 } 693 694 #if 0 695 /* 696 * acpi_eval_string: 697 * 698 * Evaluate a (Unicode) string object. 699 * XXX current API may leak memory, so don't use this. 700 */ 701 ACPI_STATUS 702 acpi_eval_string(ACPI_HANDLE handle, char *path, char **stringp) 703 { 704 ACPI_STATUS rv; 705 ACPI_BUFFER buf; 706 ACPI_OBJECT *param; 707 708 if (handle == NULL) 709 handle = ACPI_ROOT_OBJECT; 710 711 buf.Pointer = NULL; 712 buf.Length = 0; 713 714 rv = AcpiEvaluateObject(handle, path, NULL, &buf); 715 if (rv != AE_BUFFER_OVERFLOW) 716 return (rv); 717 718 buf.Pointer = AcpiOsAllocate(buf.Length); 719 if (buf.Pointer == NULL) 720 return (AE_NO_MEMORY); 721 722 rv = AcpiEvaluateObject(handle, path, NULL, &buf); 723 param = (ACPI_OBJECT *)buf.Pointer; 724 if (rv == AE_OK) { 725 if (param->Type == ACPI_TYPE_STRING) { 726 /* XXX may leak buf.Pointer!! */ 727 *stringp = param->String.Pointer; 728 return (AE_OK); 729 } 730 rv = AE_TYPE; 731 } 732 733 AcpiOsFree(buf.Pointer); 734 return (rv); 735 } 736 #endif 737 738 739 /* 740 * acpi_eval_struct: 741 * 742 * Evaluate a more complex structure. Caller must free buf.Pointer. 743 */ 744 ACPI_STATUS 745 acpi_eval_struct(ACPI_HANDLE handle, char *path, ACPI_BUFFER *bufp) 746 { 747 ACPI_STATUS rv; 748 749 if (handle == NULL) 750 handle = ACPI_ROOT_OBJECT; 751 752 bufp->Pointer = NULL; 753 bufp->Length = 0; 754 755 rv = AcpiEvaluateObject(handle, path, NULL, bufp); 756 if (rv != AE_BUFFER_OVERFLOW) 757 return (rv); 758 759 bufp->Pointer = AcpiOsAllocate(bufp->Length); 760 if (bufp->Pointer == NULL) 761 return (AE_NO_MEMORY); 762 763 rv = AcpiEvaluateObject(handle, path, NULL, bufp); 764 765 return (rv); 766 } 767 768 /* 769 * acpi_get: 770 * 771 * Fetch data info the specified (empty) ACPI buffer. 772 */ 773 ACPI_STATUS 774 acpi_get(ACPI_HANDLE handle, ACPI_BUFFER *buf, 775 ACPI_STATUS (*getit)(ACPI_HANDLE, ACPI_BUFFER *)) 776 { 777 ACPI_STATUS rv; 778 779 buf->Pointer = NULL; 780 buf->Length = 0; 781 782 rv = (*getit)(handle, buf); 783 if (rv != AE_BUFFER_OVERFLOW) 784 return (rv); 785 786 buf->Pointer = AcpiOsAllocate(buf->Length); 787 if (buf->Pointer == NULL) 788 return (AE_NO_MEMORY); 789 memset(buf->Pointer, 0, buf->Length); 790 791 return ((*getit)(handle, buf)); 792 } 793 794 795 /***************************************************************************** 796 * ACPI sleep support. 797 *****************************************************************************/ 798 799 static int 800 is_available_state(struct acpi_softc *sc, int state) 801 { 802 UINT8 type_a, type_b; 803 804 return (ACPI_SUCCESS(AcpiGetSleepTypeData((UINT8)state, 805 &type_a, &type_b))); 806 } 807 808 /* 809 * acpi_enter_sleep_state: 810 * 811 * enter to the specified sleep state. 812 */ 813 814 ACPI_STATUS 815 acpi_enter_sleep_state(struct acpi_softc *sc, int state) 816 { 817 int s; 818 ACPI_STATUS ret = AE_OK; 819 820 switch (state) { 821 case ACPI_STATE_S0: 822 break; 823 case ACPI_STATE_S1: 824 case ACPI_STATE_S2: 825 case ACPI_STATE_S3: 826 case ACPI_STATE_S4: 827 if (!is_available_state(sc, state)) { 828 printf("acpi: cannot enter the sleep state (%d).\n", 829 state); 830 break; 831 } 832 ret = AcpiEnterSleepStatePrep(state); 833 if (ACPI_FAILURE(ret)) { 834 printf("acpi: failed preparing to sleep (%s)\n", 835 AcpiFormatException(ret)); 836 break; 837 } 838 if (state==ACPI_STATE_S1) { 839 /* just enter the state */ 840 acpi_md_OsDisableInterrupt(); 841 AcpiEnterSleepState((UINT8)state); 842 AcpiUtReleaseMutex(ACPI_MTX_HARDWARE); 843 } else { 844 /* XXX: powerhooks(9) framework is too poor to 845 * support ACPI sleep state... 846 */ 847 dopowerhooks(PWR_SOFTSUSPEND); 848 s = splhigh(); 849 dopowerhooks(PWR_SUSPEND); 850 acpi_md_sleep(state); 851 dopowerhooks(PWR_RESUME); 852 splx(s); 853 dopowerhooks(PWR_SOFTRESUME); 854 if (state==ACPI_STATE_S4) 855 AcpiEnable(); 856 } 857 AcpiLeaveSleepState((UINT8)state); 858 break; 859 case ACPI_STATE_S5: 860 AcpiEnterSleepStatePrep(ACPI_STATE_S5); 861 acpi_md_OsDisableInterrupt(); 862 AcpiEnterSleepState(ACPI_STATE_S5); 863 printf("WARNING: powerdown failed!\n"); 864 break; 865 } 866 867 return (ret); 868 } 869 870 #if ACPI_PCI_FIXUP 871 ACPI_STATUS acpi_pci_fixup_bus(ACPI_HANDLE, UINT32, void *, void **); 872 /* 873 * acpi_pci_fixup: 874 * 875 * Set up PCI devices that BIOS didn't handle right. 876 * Iterate through all devices and try to get the _PTR 877 * (PCI Routing Table). If it exists then make sure all 878 * interrupt links that it uses are working. 879 */ 880 void 881 acpi_pci_fixup(struct acpi_softc *sc) 882 { 883 ACPI_HANDLE parent; 884 885 #ifdef ACPI_DEBUG 886 printf("acpi_pci_fixup starts:\n"); 887 #endif 888 if (AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_SB_", &parent) != AE_OK) 889 return; 890 sc->sc_pci_bus = 0; 891 AcpiWalkNamespace(ACPI_TYPE_DEVICE, parent, 100, 892 acpi_pci_fixup_bus, sc, NULL); 893 } 894 895 static ACPI_HANDLE 896 acpi_get_node(char *name) 897 { 898 ACPI_NAMESPACE_NODE *ObjDesc; 899 ACPI_STATUS Status; 900 901 Status = AcpiNsGetNodeByPath(name, NULL, 0, &ObjDesc); 902 if (ACPI_FAILURE (Status)) { 903 printf("acpi_get_node: could not find: %s\n", 904 AcpiFormatException (Status)); 905 return NULL; 906 } 907 return ObjDesc; 908 } 909 910 static uint 911 acpi_get_intr(ACPI_HANDLE handle) 912 { 913 ACPI_BUFFER ret; 914 ACPI_STATUS rv; 915 ACPI_RESOURCE *res; 916 ACPI_RESOURCE_IRQ *irq; 917 uint intr; 918 919 intr = -1; 920 rv = acpi_get(handle, &ret, AcpiGetCurrentResources); 921 if (ACPI_FAILURE(rv)) 922 return (intr); 923 for (res = ret.Pointer; res->Id != ACPI_RSTYPE_END_TAG; 924 res = ACPI_NEXT_RESOURCE(res)) { 925 if (res->Id == ACPI_RSTYPE_IRQ) { 926 irq = (ACPI_RESOURCE_IRQ *)&res->Data; 927 if (irq->NumberOfInterrupts == 1) 928 intr = irq->Interrupts[0]; 929 break; 930 } 931 } 932 free(ret.Pointer, M_DEVBUF); 933 return (intr); 934 } 935 936 static void 937 acpi_pci_set_line(int bus, int dev, int pin, int line) 938 { 939 ACPI_STATUS err; 940 ACPI_PCI_ID pid; 941 UINT32 intr, id, bhlc; 942 int func, nfunc; 943 944 pid.Bus = bus; 945 pid.Device = dev; 946 pid.Function = 0; 947 948 err = AcpiOsReadPciConfiguration(&pid, PCI_BHLC_REG, &bhlc, 32); 949 if (err) 950 return; 951 if (PCI_HDRTYPE_MULTIFN(bhlc)) 952 nfunc = 8; 953 else 954 nfunc = 1; 955 956 for (func = 0; func < nfunc; func++) { 957 pid.Function = func; 958 959 err = AcpiOsReadPciConfiguration(&pid, PCI_ID_REG, &id, 32); 960 if (err || PCI_VENDOR(id) == PCI_VENDOR_INVALID || 961 PCI_VENDOR(id) == 0) 962 continue; 963 964 err = AcpiOsReadPciConfiguration(&pid, PCI_INTERRUPT_REG, 965 &intr, 32); 966 if (err) { 967 printf("AcpiOsReadPciConfiguration failed %d\n", err); 968 return; 969 } 970 if (pin == PCI_INTERRUPT_PIN(intr) && 971 line != PCI_INTERRUPT_LINE(intr)) { 972 #ifdef ACPI_DEBUG 973 printf("acpi fixup pci intr: %d:%d:%d %c: %d -> %d\n", 974 bus, dev, func, 975 pin + '@', PCI_INTERRUPT_LINE(intr), 976 line); 977 #endif 978 intr &= ~(PCI_INTERRUPT_LINE_MASK << 979 PCI_INTERRUPT_LINE_SHIFT); 980 intr |= line << PCI_INTERRUPT_LINE_SHIFT; 981 err = AcpiOsWritePciConfiguration(&pid, 982 PCI_INTERRUPT_REG, intr, 32); 983 if (err) { 984 printf("AcpiOsWritePciConfiguration failed" 985 " %d\n", err); 986 return; 987 } 988 } 989 } 990 } 991 992 ACPI_STATUS 993 acpi_pci_fixup_bus(ACPI_HANDLE handle, UINT32 level, void *context, 994 void **status) 995 { 996 struct acpi_softc *sc = context; 997 ACPI_STATUS rv; 998 ACPI_BUFFER buf; 999 UINT8 *Buffer; 1000 ACPI_PCI_ROUTING_TABLE *PrtElement; 1001 ACPI_HANDLE link; 1002 uint line; 1003 1004 rv = acpi_get(handle, &buf, AcpiGetIrqRoutingTable); 1005 if (ACPI_FAILURE(rv)) 1006 return (AE_OK); 1007 1008 #ifdef ACPI_DEBUG 1009 printf("%s: fixing up PCI\n", sc->sc_dev.dv_xname); 1010 #endif 1011 1012 for (Buffer = buf.Pointer; ; Buffer += PrtElement->Length) { 1013 PrtElement = (ACPI_PCI_ROUTING_TABLE *)Buffer; 1014 if (PrtElement->Length == 0) 1015 break; 1016 if (PrtElement->Source == NULL) 1017 continue; 1018 1019 link = acpi_get_node(PrtElement->Source); 1020 if (link == NULL) 1021 continue; 1022 line = acpi_get_intr(link); 1023 if (line == -1) { 1024 #ifdef ACPI_DEBUG 1025 printf("%s: fixing up link %s\n", sc->sc_dev.dv_xname, 1026 PrtElement->Source); 1027 #endif 1028 rv = acpi_allocate_resources(link); 1029 if (ACPI_FAILURE(rv)) { 1030 printf("%s: interrupt allocation failed %s\n", 1031 sc->sc_dev.dv_xname, PrtElement->Source); 1032 continue; 1033 } 1034 line = acpi_get_intr(link); 1035 if (line == -1) { 1036 printf("%s: get intr failed %s\n", 1037 sc->sc_dev.dv_xname, PrtElement->Source); 1038 continue; 1039 } 1040 } 1041 1042 acpi_pci_set_line(sc->sc_pci_bus, PrtElement->Address >> 16, 1043 PrtElement->Pin + 1, line); 1044 } 1045 1046 sc->sc_pci_bus++; 1047 1048 free(buf.Pointer, M_DEVBUF); 1049 return (AE_OK); 1050 } 1051 #endif /* ACPI_PCI_FIXUP */ 1052 1053 #if ACPI_PCI_FIXUP || ACPI_ACTIVATE_DEV 1054 /* XXX This very incomplete */ 1055 ACPI_STATUS 1056 acpi_allocate_resources(ACPI_HANDLE handle) 1057 { 1058 ACPI_BUFFER bufp, bufc, bufn; 1059 ACPI_RESOURCE *resp, *resc, *resn; 1060 ACPI_RESOURCE_IRQ *irq; 1061 ACPI_STATUS rv; 1062 uint delta; 1063 1064 rv = acpi_get(handle, &bufp, AcpiGetPossibleResources); 1065 if (ACPI_FAILURE(rv)) 1066 goto out; 1067 rv = acpi_get(handle, &bufc, AcpiGetCurrentResources); 1068 if (ACPI_FAILURE(rv)) { 1069 goto out1; 1070 } 1071 1072 bufn.Length = 1000; 1073 bufn.Pointer = resn = malloc(bufn.Length, M_DEVBUF, M_WAITOK); 1074 resp = bufp.Pointer; 1075 resc = bufc.Pointer; 1076 while (resc->Id != ACPI_RSTYPE_END_TAG && 1077 resp->Id != ACPI_RSTYPE_END_TAG) { 1078 while (resc->Id != resp->Id && resp->Id != ACPI_RSTYPE_END_TAG) 1079 resp = ACPI_NEXT_RESOURCE(resp); 1080 if (resp->Id == ACPI_RSTYPE_END_TAG) 1081 break; 1082 /* Found identical Id */ 1083 resn->Id = resc->Id; 1084 switch (resc->Id) { 1085 case ACPI_RSTYPE_IRQ: 1086 memcpy(&resn->Data, &resp->Data, 1087 sizeof(ACPI_RESOURCE_IRQ)); 1088 irq = (ACPI_RESOURCE_IRQ *)&resn->Data; 1089 irq->Interrupts[0] = 1090 ((ACPI_RESOURCE_IRQ *)&resp->Data)-> 1091 Interrupts[irq->NumberOfInterrupts-1]; 1092 irq->NumberOfInterrupts = 1; 1093 resn->Length = ACPI_SIZEOF_RESOURCE(ACPI_RESOURCE_IRQ); 1094 break; 1095 case ACPI_RSTYPE_IO: 1096 memcpy(&resn->Data, &resp->Data, 1097 sizeof(ACPI_RESOURCE_IO)); 1098 resn->Length = resp->Length; 1099 break; 1100 default: 1101 printf("acpi_allocate_resources: res=%d\n", resc->Id); 1102 rv = AE_BAD_DATA; 1103 goto out2; 1104 } 1105 resc = ACPI_NEXT_RESOURCE(resc); 1106 resn = ACPI_NEXT_RESOURCE(resn); 1107 delta = (UINT8 *)resn - (UINT8 *)bufn.Pointer; 1108 if (delta >= bufn.Length-ACPI_SIZEOF_RESOURCE(ACPI_RESOURCE_DATA)) { 1109 bufn.Length *= 2; 1110 bufn.Pointer = realloc(bufn.Pointer, bufn.Length, 1111 M_DEVBUF, M_WAITOK); 1112 resn = (ACPI_RESOURCE *)((UINT8 *)bufn.Pointer + delta); 1113 } 1114 } 1115 if (resc->Id != ACPI_RSTYPE_END_TAG) { 1116 printf("acpi_allocate_resources: resc not exhausted\n"); 1117 rv = AE_BAD_DATA; 1118 goto out3; 1119 } 1120 1121 resn->Id = ACPI_RSTYPE_END_TAG; 1122 rv = AcpiSetCurrentResources(handle, &bufn); 1123 if (ACPI_FAILURE(rv)) { 1124 printf("acpi_allocate_resources: AcpiSetCurrentResources %s\n", 1125 AcpiFormatException(rv)); 1126 } 1127 1128 out3: 1129 free(bufn.Pointer, M_DEVBUF); 1130 out2: 1131 free(bufc.Pointer, M_DEVBUF); 1132 out1: 1133 free(bufp.Pointer, M_DEVBUF); 1134 out: 1135 return rv; 1136 } 1137 #endif /* ACPI_PCI_FIXUP || ACPI_ACTIVATE_DEV */ 1138
Indexes created Wed Oct 01 19:09:53 GMT 2025