1 /****************************************************************************** 2 * 3 * Name: acpixf.h - External interfaces to the ACPI subsystem 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2022, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 ***************************************************************************** 115 * 116 * Alternatively, you may choose to be licensed under the terms of the 117 * following license: 118 * 119 * Redistribution and use in source and binary forms, with or without 120 * modification, are permitted provided that the following conditions 121 * are met: 122 * 1. Redistributions of source code must retain the above copyright 123 * notice, this list of conditions, and the following disclaimer, 124 * without modification. 125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 126 * substantially similar to the "NO WARRANTY" disclaimer below 127 * ("Disclaimer") and any redistribution must be conditioned upon 128 * including a substantially similar Disclaimer requirement for further 129 * binary redistribution. 130 * 3. Neither the names of the above-listed copyright holders nor the names 131 * of any contributors may be used to endorse or promote products derived 132 * from this software without specific prior written permission. 133 * 134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 145 * 146 * Alternatively, you may choose to be licensed under the terms of the 147 * GNU General Public License ("GPL") version 2 as published by the Free 148 * Software Foundation. 149 * 150 *****************************************************************************/ 151 152 #ifndef __ACXFACE_H__ 153 #define __ACXFACE_H__ 154 155 /* Current ACPICA subsystem version in YYYYMMDD format */ 156 157 #define ACPI_CA_VERSION 0x20221020 158 159 #include <contrib/dev/acpica/include/acconfig.h> 160 #include <contrib/dev/acpica/include/actypes.h> 161 #include <contrib/dev/acpica/include/actbl.h> 162 #include <contrib/dev/acpica/include/acbuffer.h> 163 164 165 /***************************************************************************** 166 * 167 * Macros used for ACPICA globals and configuration 168 * 169 ****************************************************************************/ 170 171 /* 172 * Ensure that global variables are defined and initialized only once. 173 * 174 * The use of these macros allows for a single list of globals (here) 175 * in order to simplify maintenance of the code. 176 */ 177 #ifdef DEFINE_ACPI_GLOBALS 178 #define ACPI_GLOBAL(type,name) \ 179 extern type name; \ 180 type name 181 182 #define ACPI_INIT_GLOBAL(type,name,value) \ 183 type name=value 184 185 #else 186 #ifndef ACPI_GLOBAL 187 #define ACPI_GLOBAL(type,name) \ 188 extern type name 189 #endif 190 191 #ifndef ACPI_INIT_GLOBAL 192 #define ACPI_INIT_GLOBAL(type,name,value) \ 193 extern type name 194 #endif 195 #endif 196 197 /* 198 * These macros configure the various ACPICA interfaces. They are 199 * useful for generating stub inline functions for features that are 200 * configured out of the current kernel or ACPICA application. 201 */ 202 #ifndef ACPI_EXTERNAL_RETURN_STATUS 203 #define ACPI_EXTERNAL_RETURN_STATUS(Prototype) \ 204 Prototype; 205 #endif 206 207 #ifndef ACPI_EXTERNAL_RETURN_OK 208 #define ACPI_EXTERNAL_RETURN_OK(Prototype) \ 209 Prototype; 210 #endif 211 212 #ifndef ACPI_EXTERNAL_RETURN_VOID 213 #define ACPI_EXTERNAL_RETURN_VOID(Prototype) \ 214 Prototype; 215 #endif 216 217 #ifndef ACPI_EXTERNAL_RETURN_UINT32 218 #define ACPI_EXTERNAL_RETURN_UINT32(Prototype) \ 219 Prototype; 220 #endif 221 222 #ifndef ACPI_EXTERNAL_RETURN_PTR 223 #define ACPI_EXTERNAL_RETURN_PTR(Prototype) \ 224 Prototype; 225 #endif 226 227 228 /***************************************************************************** 229 * 230 * Public globals and runtime configuration options 231 * 232 ****************************************************************************/ 233 234 /* 235 * Enable "slack mode" of the AML interpreter? Default is FALSE, and the 236 * interpreter strictly follows the ACPI specification. Setting to TRUE 237 * allows the interpreter to ignore certain errors and/or bad AML constructs. 238 * 239 * Currently, these features are enabled by this flag: 240 * 241 * 1) Allow "implicit return" of last value in a control method 242 * 2) Allow access beyond the end of an operation region 243 * 3) Allow access to uninitialized locals/args (auto-init to integer 0) 244 * 4) Allow ANY object type to be a source operand for the Store() operator 245 * 5) Allow unresolved references (invalid target name) in package objects 246 * 6) Enable warning messages for behavior that is not ACPI spec compliant 247 */ 248 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_EnableInterpreterSlack, FALSE); 249 250 /* 251 * Automatically serialize all methods that create named objects? Default 252 * is TRUE, meaning that all NonSerialized methods are scanned once at 253 * table load time to determine those that create named objects. Methods 254 * that create named objects are marked Serialized in order to prevent 255 * possible run-time problems if they are entered by more than one thread. 256 */ 257 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_AutoSerializeMethods, TRUE); 258 259 /* 260 * Create the predefined _OSI method in the namespace? Default is TRUE 261 * because ACPICA is fully compatible with other ACPI implementations. 262 * Changing this will revert ACPICA (and machine ASL) to pre-OSI behavior. 263 */ 264 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_CreateOsiMethod, TRUE); 265 266 /* 267 * Optionally use default values for the ACPI register widths. Set this to 268 * TRUE to use the defaults, if an FADT contains incorrect widths/lengths. 269 */ 270 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_UseDefaultRegisterWidths, TRUE); 271 272 /* 273 * Whether or not to validate (map) an entire table to verify 274 * checksum/duplication in early stage before install. Set this to TRUE to 275 * allow early table validation before install it to the table manager. 276 * Note that enabling this option causes errors to happen in some OSPMs 277 * during early initialization stages. Default behavior is to allow such 278 * validation. 279 */ 280 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_EnableTableValidation, TRUE); 281 282 /* 283 * Optionally enable output from the AML Debug Object. 284 */ 285 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_EnableAmlDebugObject, FALSE); 286 287 /* 288 * Optionally copy the entire DSDT to local memory (instead of simply 289 * mapping it.) There are some BIOSs that corrupt or replace the original 290 * DSDT, creating the need for this option. Default is FALSE, do not copy 291 * the DSDT. 292 */ 293 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_CopyDsdtLocally, FALSE); 294 295 /* 296 * Optionally ignore an XSDT if present and use the RSDT instead. 297 * Although the ACPI specification requires that an XSDT be used instead 298 * of the RSDT, the XSDT has been found to be corrupt or ill-formed on 299 * some machines. Default behavior is to use the XSDT if present. 300 */ 301 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_DoNotUseXsdt, FALSE); 302 303 /* 304 * Optionally use 32-bit FADT addresses if and when there is a conflict 305 * (address mismatch) between the 32-bit and 64-bit versions of the 306 * address. Although ACPICA adheres to the ACPI specification which 307 * requires the use of the corresponding 64-bit address if it is non-zero, 308 * some machines have been found to have a corrupted non-zero 64-bit 309 * address. Default is FALSE, do not favor the 32-bit addresses. 310 */ 311 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_Use32BitFadtAddresses, FALSE); 312 313 /* 314 * Optionally use 32-bit FACS table addresses. 315 * It is reported that some platforms fail to resume from system suspending 316 * if 64-bit FACS table address is selected: 317 * https://bugzilla.kernel.org/show_bug.cgi?id=74021 318 * Default is TRUE, favor the 32-bit addresses. 319 */ 320 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_Use32BitFacsAddresses, TRUE); 321 322 /* 323 * Optionally truncate I/O addresses to 16 bits. Provides compatibility 324 * with other ACPI implementations. NOTE: During ACPICA initialization, 325 * this value is set to TRUE if any Windows OSI strings have been 326 * requested by the BIOS. 327 */ 328 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_TruncateIoAddresses, FALSE); 329 330 /* 331 * Disable runtime checking and repair of values returned by control methods. 332 * Use only if the repair is causing a problem on a particular machine. 333 */ 334 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_DisableAutoRepair, FALSE); 335 336 /* 337 * Optionally do not install any SSDTs from the RSDT/XSDT during initialization. 338 * This can be useful for debugging ACPI problems on some machines. 339 */ 340 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_DisableSsdtTableInstall, FALSE); 341 342 /* 343 * Optionally enable runtime namespace override. 344 */ 345 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_RuntimeNamespaceOverride, TRUE); 346 347 /* 348 * We keep track of the latest version of Windows that has been requested by 349 * the BIOS. ACPI 5.0. 350 */ 351 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_OsiData, 0); 352 353 /* 354 * ACPI 5.0 introduces the concept of a "reduced hardware platform", meaning 355 * that the ACPI hardware is no longer required. A flag in the FADT indicates 356 * a reduced HW machine, and that flag is duplicated here for convenience. 357 */ 358 ACPI_INIT_GLOBAL (BOOLEAN, AcpiGbl_ReducedHardware, FALSE); 359 360 /* 361 * Maximum timeout for While() loop iterations before forced method abort. 362 * This mechanism is intended to prevent infinite loops during interpreter 363 * execution within a host kernel. 364 */ 365 ACPI_INIT_GLOBAL (UINT32, AcpiGbl_MaxLoopIterations, ACPI_MAX_LOOP_TIMEOUT); 366 367 /* 368 * Optionally ignore AE_NOT_FOUND errors from named reference package elements 369 * during DSDT/SSDT table loading. This reduces error "noise" in platforms 370 * whose firmware is carrying around a bunch of unused package objects that 371 * refer to non-existent named objects. However, If the AML actually tries to 372 * use such a package, the unresolved element(s) will be replaced with NULL 373 * elements. 374 */ 375 ACPI_INIT_GLOBAL (BOOLEAN, AcpiGbl_IgnorePackageResolutionErrors, FALSE); 376 377 /* 378 * This mechanism is used to trace a specified AML method. The method is 379 * traced each time it is executed. 380 */ 381 ACPI_INIT_GLOBAL (UINT32, AcpiGbl_TraceFlags, 0); 382 ACPI_INIT_GLOBAL (const char *, AcpiGbl_TraceMethodName, NULL); 383 ACPI_INIT_GLOBAL (UINT32, AcpiGbl_TraceDbgLevel, ACPI_TRACE_LEVEL_DEFAULT); 384 ACPI_INIT_GLOBAL (UINT32, AcpiGbl_TraceDbgLayer, ACPI_TRACE_LAYER_DEFAULT); 385 386 /* 387 * Runtime configuration of debug output control masks. We want the debug 388 * switches statically initialized so they are already set when the debugger 389 * is entered. 390 */ 391 #ifdef ACPI_DEBUG_OUTPUT 392 ACPI_INIT_GLOBAL (UINT32, AcpiDbgLevel, ACPI_DEBUG_DEFAULT); 393 #else 394 ACPI_INIT_GLOBAL (UINT32, AcpiDbgLevel, ACPI_NORMAL_DEFAULT); 395 #endif 396 ACPI_INIT_GLOBAL (UINT32, AcpiDbgLayer, ACPI_COMPONENT_DEFAULT); 397 398 /* Optionally enable timer output with Debug Object output */ 399 400 ACPI_INIT_GLOBAL (UINT8, AcpiGbl_DisplayDebugTimer, FALSE); 401 402 /* 403 * Debugger command handshake globals. Host OSes need to access these 404 * variables to implement their own command handshake mechanism. 405 */ 406 #ifdef ACPI_DEBUGGER 407 ACPI_INIT_GLOBAL (BOOLEAN, AcpiGbl_MethodExecuting, FALSE); 408 ACPI_GLOBAL (char, AcpiGbl_DbLineBuf[ACPI_DB_LINE_BUFFER_SIZE]); 409 #endif 410 411 /* 412 * Other miscellaneous globals 413 */ 414 ACPI_GLOBAL (ACPI_TABLE_FADT, AcpiGbl_FADT); 415 ACPI_GLOBAL (UINT32, AcpiCurrentGpeCount); 416 ACPI_GLOBAL (BOOLEAN, AcpiGbl_SystemAwakeAndRunning); 417 418 419 /***************************************************************************** 420 * 421 * ACPICA public interface configuration. 422 * 423 * Interfaces that are configured out of the ACPICA build are replaced 424 * by inlined stubs by default. 425 * 426 ****************************************************************************/ 427 428 /* 429 * Hardware-reduced prototypes (default: Not hardware reduced). 430 * 431 * All ACPICA hardware-related interfaces that use these macros will be 432 * configured out of the ACPICA build if the ACPI_REDUCED_HARDWARE flag 433 * is set to TRUE. 434 * 435 * Note: This static build option for reduced hardware is intended to 436 * reduce ACPICA code size if desired or necessary. However, even if this 437 * option is not specified, the runtime behavior of ACPICA is dependent 438 * on the actual FADT reduced hardware flag (HW_REDUCED_ACPI). If set, 439 * the flag will enable similar behavior -- ACPICA will not attempt 440 * to access any ACPI-relate hardware (SCI, GPEs, Fixed Events, etc.) 441 */ 442 #if (!ACPI_REDUCED_HARDWARE) 443 #define ACPI_HW_DEPENDENT_RETURN_STATUS(Prototype) \ 444 ACPI_EXTERNAL_RETURN_STATUS(Prototype) 445 446 #define ACPI_HW_DEPENDENT_RETURN_OK(Prototype) \ 447 ACPI_EXTERNAL_RETURN_OK(Prototype) 448 449 #define ACPI_HW_DEPENDENT_RETURN_UINT32(prototype) \ 450 ACPI_EXTERNAL_RETURN_UINT32(prototype) 451 452 #define ACPI_HW_DEPENDENT_RETURN_VOID(Prototype) \ 453 ACPI_EXTERNAL_RETURN_VOID(Prototype) 454 455 #else 456 #define ACPI_HW_DEPENDENT_RETURN_STATUS(Prototype) \ 457 static ACPI_INLINE Prototype {return(AE_NOT_CONFIGURED);} 458 459 #define ACPI_HW_DEPENDENT_RETURN_OK(Prototype) \ 460 static ACPI_INLINE Prototype {return(AE_OK);} 461 462 #define ACPI_HW_DEPENDENT_RETURN_UINT32(prototype) \ 463 static ACPI_INLINE prototype {return(0);} 464 465 #define ACPI_HW_DEPENDENT_RETURN_VOID(Prototype) \ 466 static ACPI_INLINE Prototype {return;} 467 468 #endif /* !ACPI_REDUCED_HARDWARE */ 469 470 471 /* 472 * Error message prototypes (default: error messages enabled). 473 * 474 * All interfaces related to error and warning messages 475 * will be configured out of the ACPICA build if the 476 * ACPI_NO_ERROR_MESSAGE flag is defined. 477 */ 478 #ifndef ACPI_NO_ERROR_MESSAGES 479 #define ACPI_MSG_DEPENDENT_RETURN_VOID(Prototype) \ 480 Prototype; 481 482 #else 483 #define ACPI_MSG_DEPENDENT_RETURN_VOID(Prototype) \ 484 static ACPI_INLINE Prototype {return;} 485 486 #endif /* ACPI_NO_ERROR_MESSAGES */ 487 488 489 /* 490 * Debugging output prototypes (default: no debug output). 491 * 492 * All interfaces related to debug output messages 493 * will be configured out of the ACPICA build unless the 494 * ACPI_DEBUG_OUTPUT flag is defined. 495 */ 496 #ifdef ACPI_DEBUG_OUTPUT 497 #define ACPI_DBG_DEPENDENT_RETURN_VOID(Prototype) \ 498 Prototype; 499 500 #else 501 #define ACPI_DBG_DEPENDENT_RETURN_VOID(Prototype) \ 502 static ACPI_INLINE Prototype {return;} 503 504 #endif /* ACPI_DEBUG_OUTPUT */ 505 506 507 /* 508 * Application prototypes 509 * 510 * All interfaces used by application will be configured 511 * out of the ACPICA build unless the ACPI_APPLICATION 512 * flag is defined. 513 */ 514 #ifdef ACPI_APPLICATION 515 #define ACPI_APP_DEPENDENT_RETURN_VOID(Prototype) \ 516 Prototype; 517 518 #else 519 #define ACPI_APP_DEPENDENT_RETURN_VOID(Prototype) \ 520 static ACPI_INLINE Prototype {return;} 521 522 #endif /* ACPI_APPLICATION */ 523 524 525 /* 526 * Debugger prototypes 527 * 528 * All interfaces used by debugger will be configured 529 * out of the ACPICA build unless the ACPI_DEBUGGER 530 * flag is defined. 531 */ 532 #ifdef ACPI_DEBUGGER 533 #define ACPI_DBR_DEPENDENT_RETURN_OK(Prototype) \ 534 ACPI_EXTERNAL_RETURN_OK(Prototype) 535 536 #define ACPI_DBR_DEPENDENT_RETURN_VOID(Prototype) \ 537 ACPI_EXTERNAL_RETURN_VOID(Prototype) 538 539 #else 540 #define ACPI_DBR_DEPENDENT_RETURN_OK(Prototype) \ 541 static ACPI_INLINE Prototype {return(AE_OK);} 542 543 #define ACPI_DBR_DEPENDENT_RETURN_VOID(Prototype) \ 544 static ACPI_INLINE Prototype {return;} 545 546 #endif /* ACPI_DEBUGGER */ 547 548 549 /***************************************************************************** 550 * 551 * ACPICA public interface prototypes 552 * 553 ****************************************************************************/ 554 555 /* 556 * Initialization 557 */ 558 ACPI_EXTERNAL_RETURN_STATUS ( 559 ACPI_STATUS ACPI_INIT_FUNCTION 560 AcpiInitializeTables ( 561 ACPI_TABLE_DESC *InitialStorage, 562 UINT32 InitialTableCount, 563 BOOLEAN AllowResize)) 564 565 ACPI_EXTERNAL_RETURN_STATUS ( 566 ACPI_STATUS ACPI_INIT_FUNCTION 567 AcpiInitializeSubsystem ( 568 void)) 569 570 ACPI_EXTERNAL_RETURN_STATUS ( 571 ACPI_STATUS ACPI_INIT_FUNCTION 572 AcpiEnableSubsystem ( 573 UINT32 Flags)) 574 575 ACPI_EXTERNAL_RETURN_STATUS ( 576 ACPI_STATUS ACPI_INIT_FUNCTION 577 AcpiInitializeObjects ( 578 UINT32 Flags)) 579 580 ACPI_EXTERNAL_RETURN_STATUS ( 581 ACPI_STATUS ACPI_INIT_FUNCTION 582 AcpiTerminate ( 583 void)) 584 585 586 /* 587 * Miscellaneous global interfaces 588 */ 589 ACPI_HW_DEPENDENT_RETURN_STATUS ( 590 ACPI_STATUS 591 AcpiEnable ( 592 void)) 593 594 ACPI_HW_DEPENDENT_RETURN_STATUS ( 595 ACPI_STATUS 596 AcpiDisable ( 597 void)) 598 599 ACPI_EXTERNAL_RETURN_STATUS ( 600 ACPI_STATUS 601 AcpiSubsystemStatus ( 602 void)) 603 604 ACPI_EXTERNAL_RETURN_STATUS ( 605 ACPI_STATUS 606 AcpiGetSystemInfo ( 607 ACPI_BUFFER *RetBuffer)) 608 609 ACPI_EXTERNAL_RETURN_STATUS ( 610 ACPI_STATUS 611 AcpiGetStatistics ( 612 ACPI_STATISTICS *Stats)) 613 614 ACPI_EXTERNAL_RETURN_PTR ( 615 const char * 616 AcpiFormatException ( 617 ACPI_STATUS Exception)) 618 619 ACPI_EXTERNAL_RETURN_STATUS ( 620 ACPI_STATUS 621 AcpiPurgeCachedObjects ( 622 void)) 623 624 ACPI_EXTERNAL_RETURN_STATUS ( 625 ACPI_STATUS 626 AcpiInstallInterface ( 627 ACPI_STRING InterfaceName)) 628 629 ACPI_EXTERNAL_RETURN_STATUS ( 630 ACPI_STATUS 631 AcpiRemoveInterface ( 632 ACPI_STRING InterfaceName)) 633 634 ACPI_EXTERNAL_RETURN_STATUS ( 635 ACPI_STATUS 636 AcpiUpdateInterfaces ( 637 UINT8 Action)) 638 639 ACPI_EXTERNAL_RETURN_UINT32 ( 640 UINT32 641 AcpiCheckAddressRange ( 642 ACPI_ADR_SPACE_TYPE SpaceId, 643 ACPI_PHYSICAL_ADDRESS Address, 644 ACPI_SIZE Length, 645 BOOLEAN Warn)) 646 647 ACPI_EXTERNAL_RETURN_STATUS ( 648 ACPI_STATUS 649 AcpiDecodePldBuffer ( 650 UINT8 *InBuffer, 651 ACPI_SIZE Length, 652 ACPI_PLD_INFO **ReturnBuffer)) 653 654 655 /* 656 * ACPI table load/unload interfaces 657 */ 658 ACPI_EXTERNAL_RETURN_STATUS ( 659 ACPI_STATUS ACPI_INIT_FUNCTION 660 AcpiInstallTable ( 661 ACPI_TABLE_HEADER *Table)) 662 663 ACPI_EXTERNAL_RETURN_STATUS ( 664 ACPI_STATUS ACPI_INIT_FUNCTION 665 AcpiInstallPhysicalTable ( 666 ACPI_PHYSICAL_ADDRESS Address)) 667 668 ACPI_EXTERNAL_RETURN_STATUS ( 669 ACPI_STATUS 670 AcpiLoadTable ( 671 ACPI_TABLE_HEADER *Table, 672 UINT32 *TableIdx)) 673 674 ACPI_EXTERNAL_RETURN_STATUS ( 675 ACPI_STATUS 676 AcpiUnloadTable ( 677 UINT32 TableIndex)) 678 679 ACPI_EXTERNAL_RETURN_STATUS ( 680 ACPI_STATUS 681 AcpiUnloadParentTable ( 682 ACPI_HANDLE Object)) 683 684 ACPI_EXTERNAL_RETURN_STATUS ( 685 ACPI_STATUS ACPI_INIT_FUNCTION 686 AcpiLoadTables ( 687 void)) 688 689 690 /* 691 * ACPI table manipulation interfaces 692 */ 693 ACPI_EXTERNAL_RETURN_STATUS ( 694 ACPI_STATUS ACPI_INIT_FUNCTION 695 AcpiReallocateRootTable ( 696 void)) 697 698 ACPI_EXTERNAL_RETURN_STATUS ( 699 ACPI_STATUS ACPI_INIT_FUNCTION 700 AcpiFindRootPointer ( 701 ACPI_PHYSICAL_ADDRESS *RsdpAddress)) 702 703 ACPI_EXTERNAL_RETURN_STATUS ( 704 ACPI_STATUS 705 AcpiGetTableHeader ( 706 ACPI_STRING Signature, 707 UINT32 Instance, 708 ACPI_TABLE_HEADER *OutTableHeader)) 709 710 ACPI_EXTERNAL_RETURN_STATUS ( 711 ACPI_STATUS 712 AcpiGetTable ( 713 ACPI_STRING Signature, 714 UINT32 Instance, 715 ACPI_TABLE_HEADER **OutTable)) 716 717 ACPI_EXTERNAL_RETURN_VOID ( 718 void 719 AcpiPutTable ( 720 ACPI_TABLE_HEADER *Table)) 721 722 ACPI_EXTERNAL_RETURN_STATUS ( 723 ACPI_STATUS 724 AcpiGetTableByIndex ( 725 UINT32 TableIndex, 726 ACPI_TABLE_HEADER **OutTable)) 727 728 ACPI_EXTERNAL_RETURN_STATUS ( 729 ACPI_STATUS 730 AcpiInstallTableHandler ( 731 ACPI_TABLE_HANDLER Handler, 732 void *Context)) 733 734 ACPI_EXTERNAL_RETURN_STATUS ( 735 ACPI_STATUS 736 AcpiRemoveTableHandler ( 737 ACPI_TABLE_HANDLER Handler)) 738 739 740 /* 741 * Namespace and name interfaces 742 */ 743 ACPI_EXTERNAL_RETURN_STATUS ( 744 ACPI_STATUS 745 AcpiWalkNamespace ( 746 ACPI_OBJECT_TYPE Type, 747 ACPI_HANDLE StartObject, 748 UINT32 MaxDepth, 749 ACPI_WALK_CALLBACK DescendingCallback, 750 ACPI_WALK_CALLBACK AscendingCallback, 751 void *Context, 752 void **ReturnValue)) 753 754 ACPI_EXTERNAL_RETURN_STATUS ( 755 ACPI_STATUS 756 AcpiGetDevices ( 757 char *HID, 758 ACPI_WALK_CALLBACK UserFunction, 759 void *Context, 760 void **ReturnValue)) 761 762 ACPI_EXTERNAL_RETURN_STATUS ( 763 ACPI_STATUS 764 AcpiGetName ( 765 ACPI_HANDLE Object, 766 UINT32 NameType, 767 ACPI_BUFFER *RetPathPtr)) 768 769 ACPI_EXTERNAL_RETURN_STATUS ( 770 ACPI_STATUS 771 AcpiGetHandle ( 772 ACPI_HANDLE Parent, 773 ACPI_STRING Pathname, 774 ACPI_HANDLE *RetHandle)) 775 776 ACPI_EXTERNAL_RETURN_STATUS ( 777 ACPI_STATUS 778 AcpiAttachData ( 779 ACPI_HANDLE Object, 780 ACPI_OBJECT_HANDLER Handler, 781 void *Data)) 782 783 ACPI_EXTERNAL_RETURN_STATUS ( 784 ACPI_STATUS 785 AcpiDetachData ( 786 ACPI_HANDLE Object, 787 ACPI_OBJECT_HANDLER Handler)) 788 789 ACPI_EXTERNAL_RETURN_STATUS ( 790 ACPI_STATUS 791 AcpiGetData ( 792 ACPI_HANDLE Object, 793 ACPI_OBJECT_HANDLER Handler, 794 void **Data)) 795 796 ACPI_EXTERNAL_RETURN_STATUS ( 797 ACPI_STATUS 798 AcpiDebugTrace ( 799 const char *Name, 800 UINT32 DebugLevel, 801 UINT32 DebugLayer, 802 UINT32 Flags)) 803 804 805 /* 806 * Object manipulation and enumeration 807 */ 808 ACPI_EXTERNAL_RETURN_STATUS ( 809 ACPI_STATUS 810 AcpiEvaluateObject ( 811 ACPI_HANDLE Object, 812 ACPI_STRING Pathname, 813 ACPI_OBJECT_LIST *ParameterObjects, 814 ACPI_BUFFER *ReturnObjectBuffer)) 815 816 ACPI_EXTERNAL_RETURN_STATUS ( 817 ACPI_STATUS 818 AcpiEvaluateObjectTyped ( 819 ACPI_HANDLE Object, 820 ACPI_STRING Pathname, 821 ACPI_OBJECT_LIST *ExternalParams, 822 ACPI_BUFFER *ReturnBuffer, 823 ACPI_OBJECT_TYPE ReturnType)) 824 825 ACPI_EXTERNAL_RETURN_STATUS ( 826 ACPI_STATUS 827 AcpiGetObjectInfo ( 828 ACPI_HANDLE Object, 829 ACPI_DEVICE_INFO **ReturnBuffer)) 830 831 ACPI_EXTERNAL_RETURN_STATUS ( 832 ACPI_STATUS 833 AcpiInstallMethod ( 834 UINT8 *Buffer)) 835 836 ACPI_EXTERNAL_RETURN_STATUS ( 837 ACPI_STATUS 838 AcpiGetNextObject ( 839 ACPI_OBJECT_TYPE Type, 840 ACPI_HANDLE Parent, 841 ACPI_HANDLE Child, 842 ACPI_HANDLE *OutHandle)) 843 844 ACPI_EXTERNAL_RETURN_STATUS ( 845 ACPI_STATUS 846 AcpiGetType ( 847 ACPI_HANDLE Object, 848 ACPI_OBJECT_TYPE *OutType)) 849 850 ACPI_EXTERNAL_RETURN_STATUS ( 851 ACPI_STATUS 852 AcpiGetParent ( 853 ACPI_HANDLE Object, 854 ACPI_HANDLE *OutHandle)) 855 856 857 /* 858 * Handler interfaces 859 */ 860 ACPI_EXTERNAL_RETURN_STATUS ( 861 ACPI_STATUS 862 AcpiInstallInitializationHandler ( 863 ACPI_INIT_HANDLER Handler, 864 UINT32 Function)) 865 866 ACPI_HW_DEPENDENT_RETURN_STATUS ( 867 ACPI_STATUS 868 AcpiInstallSciHandler ( 869 ACPI_SCI_HANDLER Address, 870 void *Context)) 871 872 ACPI_HW_DEPENDENT_RETURN_STATUS ( 873 ACPI_STATUS 874 AcpiRemoveSciHandler ( 875 ACPI_SCI_HANDLER Address)) 876 877 ACPI_HW_DEPENDENT_RETURN_STATUS ( 878 ACPI_STATUS 879 AcpiInstallGlobalEventHandler ( 880 ACPI_GBL_EVENT_HANDLER Handler, 881 void *Context)) 882 883 ACPI_HW_DEPENDENT_RETURN_STATUS ( 884 ACPI_STATUS 885 AcpiInstallFixedEventHandler ( 886 UINT32 AcpiEvent, 887 ACPI_EVENT_HANDLER Handler, 888 void *Context)) 889 890 ACPI_HW_DEPENDENT_RETURN_STATUS ( 891 ACPI_STATUS 892 AcpiRemoveFixedEventHandler ( 893 UINT32 AcpiEvent, 894 ACPI_EVENT_HANDLER Handler)) 895 896 ACPI_HW_DEPENDENT_RETURN_STATUS ( 897 ACPI_STATUS 898 AcpiInstallGpeHandler ( 899 ACPI_HANDLE GpeDevice, 900 UINT32 GpeNumber, 901 UINT32 Type, 902 ACPI_GPE_HANDLER Address, 903 void *Context)) 904 905 ACPI_HW_DEPENDENT_RETURN_STATUS ( 906 ACPI_STATUS 907 AcpiInstallGpeRawHandler ( 908 ACPI_HANDLE GpeDevice, 909 UINT32 GpeNumber, 910 UINT32 Type, 911 ACPI_GPE_HANDLER Address, 912 void *Context)) 913 914 ACPI_HW_DEPENDENT_RETURN_STATUS ( 915 ACPI_STATUS 916 AcpiRemoveGpeHandler ( 917 ACPI_HANDLE GpeDevice, 918 UINT32 GpeNumber, 919 ACPI_GPE_HANDLER Address)) 920 921 ACPI_EXTERNAL_RETURN_STATUS ( 922 ACPI_STATUS 923 AcpiInstallNotifyHandler ( 924 ACPI_HANDLE Device, 925 UINT32 HandlerType, 926 ACPI_NOTIFY_HANDLER Handler, 927 void *Context)) 928 929 ACPI_EXTERNAL_RETURN_STATUS ( 930 ACPI_STATUS 931 AcpiRemoveNotifyHandler ( 932 ACPI_HANDLE Device, 933 UINT32 HandlerType, 934 ACPI_NOTIFY_HANDLER Handler)) 935 936 ACPI_EXTERNAL_RETURN_STATUS ( 937 ACPI_STATUS 938 AcpiInstallAddressSpaceHandler ( 939 ACPI_HANDLE Device, 940 ACPI_ADR_SPACE_TYPE SpaceId, 941 ACPI_ADR_SPACE_HANDLER Handler, 942 ACPI_ADR_SPACE_SETUP Setup, 943 void *Context)) 944 945 ACPI_EXTERNAL_RETURN_STATUS ( 946 ACPI_STATUS 947 AcpiRemoveAddressSpaceHandler ( 948 ACPI_HANDLE Device, 949 ACPI_ADR_SPACE_TYPE SpaceId, 950 ACPI_ADR_SPACE_HANDLER Handler)) 951 952 ACPI_EXTERNAL_RETURN_STATUS ( 953 ACPI_STATUS 954 AcpiInstallExceptionHandler ( 955 ACPI_EXCEPTION_HANDLER Handler)) 956 957 ACPI_EXTERNAL_RETURN_STATUS ( 958 ACPI_STATUS 959 AcpiInstallInterfaceHandler ( 960 ACPI_INTERFACE_HANDLER Handler)) 961 962 963 /* 964 * Global Lock interfaces 965 */ 966 ACPI_HW_DEPENDENT_RETURN_STATUS ( 967 ACPI_STATUS 968 AcpiAcquireGlobalLock ( 969 UINT16 Timeout, 970 UINT32 *Handle)) 971 972 ACPI_HW_DEPENDENT_RETURN_STATUS ( 973 ACPI_STATUS 974 AcpiReleaseGlobalLock ( 975 UINT32 Handle)) 976 977 978 /* 979 * Interfaces to AML mutex objects 980 */ 981 ACPI_EXTERNAL_RETURN_STATUS ( 982 ACPI_STATUS 983 AcpiAcquireMutex ( 984 ACPI_HANDLE Handle, 985 ACPI_STRING Pathname, 986 UINT16 Timeout)) 987 988 ACPI_EXTERNAL_RETURN_STATUS ( 989 ACPI_STATUS 990 AcpiReleaseMutex ( 991 ACPI_HANDLE Handle, 992 ACPI_STRING Pathname)) 993 994 995 /* 996 * Fixed Event interfaces 997 */ 998 ACPI_HW_DEPENDENT_RETURN_STATUS ( 999 ACPI_STATUS 1000 AcpiEnableEvent ( 1001 UINT32 Event, 1002 UINT32 Flags)) 1003 1004 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1005 ACPI_STATUS 1006 AcpiDisableEvent ( 1007 UINT32 Event, 1008 UINT32 Flags)) 1009 1010 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1011 ACPI_STATUS 1012 AcpiClearEvent ( 1013 UINT32 Event)) 1014 1015 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1016 ACPI_STATUS 1017 AcpiGetEventStatus ( 1018 UINT32 Event, 1019 ACPI_EVENT_STATUS *EventStatus)) 1020 1021 1022 /* 1023 * General Purpose Event (GPE) Interfaces 1024 */ 1025 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1026 ACPI_STATUS 1027 AcpiUpdateAllGpes ( 1028 void)) 1029 1030 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1031 ACPI_STATUS 1032 AcpiEnableGpe ( 1033 ACPI_HANDLE GpeDevice, 1034 UINT32 GpeNumber)) 1035 1036 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1037 ACPI_STATUS 1038 AcpiDisableGpe ( 1039 ACPI_HANDLE GpeDevice, 1040 UINT32 GpeNumber)) 1041 1042 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1043 ACPI_STATUS 1044 AcpiClearGpe ( 1045 ACPI_HANDLE GpeDevice, 1046 UINT32 GpeNumber)) 1047 1048 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1049 ACPI_STATUS 1050 AcpiSetGpe ( 1051 ACPI_HANDLE GpeDevice, 1052 UINT32 GpeNumber, 1053 UINT8 Action)) 1054 1055 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1056 ACPI_STATUS 1057 AcpiFinishGpe ( 1058 ACPI_HANDLE GpeDevice, 1059 UINT32 GpeNumber)) 1060 1061 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1062 ACPI_STATUS 1063 AcpiMaskGpe ( 1064 ACPI_HANDLE GpeDevice, 1065 UINT32 GpeNumber, 1066 BOOLEAN IsMasked)) 1067 1068 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1069 ACPI_STATUS 1070 AcpiMarkGpeForWake ( 1071 ACPI_HANDLE GpeDevice, 1072 UINT32 GpeNumber)) 1073 1074 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1075 ACPI_STATUS 1076 AcpiSetupGpeForWake ( 1077 ACPI_HANDLE ParentDevice, 1078 ACPI_HANDLE GpeDevice, 1079 UINT32 GpeNumber)) 1080 1081 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1082 ACPI_STATUS 1083 AcpiSetGpeWakeMask ( 1084 ACPI_HANDLE GpeDevice, 1085 UINT32 GpeNumber, 1086 UINT8 Action)) 1087 1088 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1089 ACPI_STATUS 1090 AcpiGetGpeStatus ( 1091 ACPI_HANDLE GpeDevice, 1092 UINT32 GpeNumber, 1093 ACPI_EVENT_STATUS *EventStatus)) 1094 1095 ACPI_HW_DEPENDENT_RETURN_UINT32 ( 1096 UINT32 1097 AcpiDispatchGpe ( 1098 ACPI_HANDLE GpeDevice, 1099 UINT32 GpeNumber)) 1100 1101 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1102 ACPI_STATUS 1103 AcpiDisableAllGpes ( 1104 void)) 1105 1106 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1107 ACPI_STATUS 1108 AcpiEnableAllRuntimeGpes ( 1109 void)) 1110 1111 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1112 ACPI_STATUS 1113 AcpiEnableAllWakeupGpes ( 1114 void)) 1115 1116 ACPI_HW_DEPENDENT_RETURN_UINT32 ( 1117 UINT32 AcpiAnyGpeStatusSet ( 1118 void)) 1119 1120 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1121 ACPI_STATUS 1122 AcpiGetGpeDevice ( 1123 UINT32 GpeIndex, 1124 ACPI_HANDLE *GpeDevice)) 1125 1126 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1127 ACPI_STATUS 1128 AcpiInstallGpeBlock ( 1129 ACPI_HANDLE GpeDevice, 1130 ACPI_GENERIC_ADDRESS *GpeBlockAddress, 1131 UINT32 RegisterCount, 1132 UINT32 InterruptNumber)) 1133 1134 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1135 ACPI_STATUS 1136 AcpiRemoveGpeBlock ( 1137 ACPI_HANDLE GpeDevice)) 1138 1139 1140 /* 1141 * Resource interfaces 1142 */ 1143 typedef 1144 ACPI_STATUS (*ACPI_WALK_RESOURCE_CALLBACK) ( 1145 ACPI_RESOURCE *Resource, 1146 void *Context); 1147 1148 ACPI_EXTERNAL_RETURN_STATUS ( 1149 ACPI_STATUS 1150 AcpiGetVendorResource ( 1151 ACPI_HANDLE Device, 1152 char *Name, 1153 ACPI_VENDOR_UUID *Uuid, 1154 ACPI_BUFFER *RetBuffer)) 1155 1156 ACPI_EXTERNAL_RETURN_STATUS ( 1157 ACPI_STATUS 1158 AcpiGetCurrentResources ( 1159 ACPI_HANDLE Device, 1160 ACPI_BUFFER *RetBuffer)) 1161 1162 ACPI_EXTERNAL_RETURN_STATUS ( 1163 ACPI_STATUS 1164 AcpiGetPossibleResources ( 1165 ACPI_HANDLE Device, 1166 ACPI_BUFFER *RetBuffer)) 1167 1168 ACPI_EXTERNAL_RETURN_STATUS ( 1169 ACPI_STATUS 1170 AcpiGetEventResources ( 1171 ACPI_HANDLE DeviceHandle, 1172 ACPI_BUFFER *RetBuffer)) 1173 1174 ACPI_EXTERNAL_RETURN_STATUS ( 1175 ACPI_STATUS 1176 AcpiWalkResourceBuffer ( 1177 ACPI_BUFFER *Buffer, 1178 ACPI_WALK_RESOURCE_CALLBACK UserFunction, 1179 void *Context)) 1180 1181 ACPI_EXTERNAL_RETURN_STATUS ( 1182 ACPI_STATUS 1183 AcpiWalkResources ( 1184 ACPI_HANDLE Device, 1185 char *Name, 1186 ACPI_WALK_RESOURCE_CALLBACK UserFunction, 1187 void *Context)) 1188 1189 ACPI_EXTERNAL_RETURN_STATUS ( 1190 ACPI_STATUS 1191 AcpiSetCurrentResources ( 1192 ACPI_HANDLE Device, 1193 ACPI_BUFFER *InBuffer)) 1194 1195 ACPI_EXTERNAL_RETURN_STATUS ( 1196 ACPI_STATUS 1197 AcpiGetIrqRoutingTable ( 1198 ACPI_HANDLE Device, 1199 ACPI_BUFFER *RetBuffer)) 1200 1201 ACPI_EXTERNAL_RETURN_STATUS ( 1202 ACPI_STATUS 1203 AcpiResourceToAddress64 ( 1204 ACPI_RESOURCE *Resource, 1205 ACPI_RESOURCE_ADDRESS64 *Out)) 1206 1207 ACPI_EXTERNAL_RETURN_STATUS ( 1208 ACPI_STATUS 1209 AcpiBufferToResource ( 1210 UINT8 *AmlBuffer, 1211 UINT16 AmlBufferLength, 1212 ACPI_RESOURCE **ResourcePtr)) 1213 1214 1215 /* 1216 * Hardware (ACPI device) interfaces 1217 */ 1218 ACPI_EXTERNAL_RETURN_STATUS ( 1219 ACPI_STATUS 1220 AcpiReset ( 1221 void)) 1222 1223 ACPI_EXTERNAL_RETURN_STATUS ( 1224 ACPI_STATUS 1225 AcpiRead ( 1226 UINT64 *Value, 1227 ACPI_GENERIC_ADDRESS *Reg)) 1228 1229 ACPI_EXTERNAL_RETURN_STATUS ( 1230 ACPI_STATUS 1231 AcpiWrite ( 1232 UINT64 Value, 1233 ACPI_GENERIC_ADDRESS *Reg)) 1234 1235 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1236 ACPI_STATUS 1237 AcpiReadBitRegister ( 1238 UINT32 RegisterId, 1239 UINT32 *ReturnValue)) 1240 1241 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1242 ACPI_STATUS 1243 AcpiWriteBitRegister ( 1244 UINT32 RegisterId, 1245 UINT32 Value)) 1246 1247 1248 /* 1249 * Sleep/Wake interfaces 1250 */ 1251 ACPI_EXTERNAL_RETURN_STATUS ( 1252 ACPI_STATUS 1253 AcpiGetSleepTypeData ( 1254 UINT8 SleepState, 1255 UINT8 *Slp_TypA, 1256 UINT8 *Slp_TypB)) 1257 1258 ACPI_EXTERNAL_RETURN_STATUS ( 1259 ACPI_STATUS 1260 AcpiEnterSleepStatePrep ( 1261 UINT8 SleepState)) 1262 1263 ACPI_EXTERNAL_RETURN_STATUS ( 1264 ACPI_STATUS 1265 AcpiEnterSleepState ( 1266 UINT8 SleepState)) 1267 1268 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1269 ACPI_STATUS 1270 AcpiEnterSleepStateS4bios ( 1271 void)) 1272 1273 ACPI_EXTERNAL_RETURN_STATUS ( 1274 ACPI_STATUS 1275 AcpiLeaveSleepStatePrep ( 1276 UINT8 SleepState)) 1277 1278 ACPI_EXTERNAL_RETURN_STATUS ( 1279 ACPI_STATUS 1280 AcpiLeaveSleepState ( 1281 UINT8 SleepState)) 1282 1283 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1284 ACPI_STATUS 1285 AcpiSetFirmwareWakingVector ( 1286 ACPI_PHYSICAL_ADDRESS PhysicalAddress, 1287 ACPI_PHYSICAL_ADDRESS PhysicalAddress64)) 1288 1289 1290 /* 1291 * ACPI Timer interfaces 1292 */ 1293 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1294 ACPI_STATUS 1295 AcpiGetTimerResolution ( 1296 UINT32 *Resolution)) 1297 1298 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1299 ACPI_STATUS 1300 AcpiGetTimer ( 1301 UINT32 *Ticks)) 1302 1303 ACPI_HW_DEPENDENT_RETURN_STATUS ( 1304 ACPI_STATUS 1305 AcpiGetTimerDuration ( 1306 UINT32 StartTicks, 1307 UINT32 EndTicks, 1308 UINT32 *TimeElapsed)) 1309 1310 1311 /* 1312 * Error/Warning output 1313 */ 1314 ACPI_MSG_DEPENDENT_RETURN_VOID ( 1315 ACPI_PRINTF_LIKE(3) 1316 void ACPI_INTERNAL_VAR_XFACE 1317 AcpiError ( 1318 const char *ModuleName, 1319 UINT32 LineNumber, 1320 const char *Format, 1321 ...)) 1322 1323 ACPI_MSG_DEPENDENT_RETURN_VOID ( 1324 ACPI_PRINTF_LIKE(4) 1325 void ACPI_INTERNAL_VAR_XFACE 1326 AcpiException ( 1327 const char *ModuleName, 1328 UINT32 LineNumber, 1329 ACPI_STATUS Status, 1330 const char *Format, 1331 ...)) 1332 1333 ACPI_MSG_DEPENDENT_RETURN_VOID ( 1334 ACPI_PRINTF_LIKE(3) 1335 void ACPI_INTERNAL_VAR_XFACE 1336 AcpiWarning ( 1337 const char *ModuleName, 1338 UINT32 LineNumber, 1339 const char *Format, 1340 ...)) 1341 1342 ACPI_MSG_DEPENDENT_RETURN_VOID ( 1343 ACPI_PRINTF_LIKE(1) 1344 void ACPI_INTERNAL_VAR_XFACE 1345 AcpiInfo ( 1346 const char *Format, 1347 ...)) 1348 1349 ACPI_MSG_DEPENDENT_RETURN_VOID ( 1350 ACPI_PRINTF_LIKE(3) 1351 void ACPI_INTERNAL_VAR_XFACE 1352 AcpiBiosError ( 1353 const char *ModuleName, 1354 UINT32 LineNumber, 1355 const char *Format, 1356 ...)) 1357 1358 ACPI_MSG_DEPENDENT_RETURN_VOID ( 1359 ACPI_PRINTF_LIKE(4) 1360 void ACPI_INTERNAL_VAR_XFACE 1361 AcpiBiosException ( 1362 const char *ModuleName, 1363 UINT32 LineNumber, 1364 ACPI_STATUS Status, 1365 const char *Format, 1366 ...)) 1367 1368 ACPI_MSG_DEPENDENT_RETURN_VOID ( 1369 ACPI_PRINTF_LIKE(3) 1370 void ACPI_INTERNAL_VAR_XFACE 1371 AcpiBiosWarning ( 1372 const char *ModuleName, 1373 UINT32 LineNumber, 1374 const char *Format, 1375 ...)) 1376 1377 1378 /* 1379 * Debug output 1380 */ 1381 ACPI_DBG_DEPENDENT_RETURN_VOID ( 1382 ACPI_PRINTF_LIKE(6) 1383 void ACPI_INTERNAL_VAR_XFACE 1384 AcpiDebugPrint ( 1385 UINT32 RequestedDebugLevel, 1386 UINT32 LineNumber, 1387 const char *FunctionName, 1388 const char *ModuleName, 1389 UINT32 ComponentId, 1390 const char *Format, 1391 ...)) 1392 1393 ACPI_DBG_DEPENDENT_RETURN_VOID ( 1394 ACPI_PRINTF_LIKE(6) 1395 void ACPI_INTERNAL_VAR_XFACE 1396 AcpiDebugPrintRaw ( 1397 UINT32 RequestedDebugLevel, 1398 UINT32 LineNumber, 1399 const char *FunctionName, 1400 const char *ModuleName, 1401 UINT32 ComponentId, 1402 const char *Format, 1403 ...)) 1404 1405 ACPI_DBG_DEPENDENT_RETURN_VOID ( 1406 void 1407 AcpiTracePoint ( 1408 ACPI_TRACE_EVENT_TYPE Type, 1409 BOOLEAN Begin, 1410 UINT8 *Aml, 1411 char *Pathname)) 1412 1413 ACPI_STATUS 1414 AcpiInitializeDebugger ( 1415 void); 1416 1417 void 1418 AcpiTerminateDebugger ( 1419 void); 1420 1421 void 1422 AcpiRunDebugger ( 1423 char *BatchBuffer); 1424 1425 void 1426 AcpiSetDebuggerThreadId ( 1427 ACPI_THREAD_ID ThreadId); 1428 1429 #endif /* __ACXFACE_H__ */ 1430