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 - 2020, 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 0x20201113 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 */ 248ACPI_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 */ 257ACPI_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 */ 264ACPI_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 */ 270ACPI_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 */ 280ACPI_INIT_GLOBAL (UINT8, AcpiGbl_EnableTableValidation, TRUE); 281 282/* 283 * Optionally enable output from the AML Debug Object. 284 */ 285ACPI_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 */ 293ACPI_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 */ 301ACPI_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 */ 311ACPI_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 */ 320ACPI_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 */ 328ACPI_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 */ 334ACPI_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 */ 340ACPI_INIT_GLOBAL (UINT8, AcpiGbl_DisableSsdtTableInstall, FALSE); 341 342/* 343 * Optionally enable runtime namespace override. 344 */ 345ACPI_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 */ 351ACPI_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 */ 358ACPI_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 */ 365ACPI_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 */ 375ACPI_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 */ 381ACPI_INIT_GLOBAL (UINT32, AcpiGbl_TraceFlags, 0); 382ACPI_INIT_GLOBAL (const char *, AcpiGbl_TraceMethodName, NULL); 383ACPI_INIT_GLOBAL (UINT32, AcpiGbl_TraceDbgLevel, ACPI_TRACE_LEVEL_DEFAULT); 384ACPI_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 392ACPI_INIT_GLOBAL (UINT32, AcpiDbgLevel, ACPI_DEBUG_DEFAULT); 393#else 394ACPI_INIT_GLOBAL (UINT32, AcpiDbgLevel, ACPI_NORMAL_DEFAULT); 395#endif 396ACPI_INIT_GLOBAL (UINT32, AcpiDbgLayer, ACPI_COMPONENT_DEFAULT); 397 398/* Optionally enable timer output with Debug Object output */ 399 400ACPI_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 407ACPI_INIT_GLOBAL (BOOLEAN, AcpiGbl_MethodExecuting, FALSE); 408ACPI_GLOBAL (char, AcpiGbl_DbLineBuf[ACPI_DB_LINE_BUFFER_SIZE]); 409#endif 410 411/* 412 * Other miscellaneous globals 413 */ 414ACPI_GLOBAL (ACPI_TABLE_FADT, AcpiGbl_FADT); 415ACPI_GLOBAL (UINT32, AcpiCurrentGpeCount); 416ACPI_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 */ 558ACPI_EXTERNAL_RETURN_STATUS ( 559ACPI_STATUS ACPI_INIT_FUNCTION 560AcpiInitializeTables ( 561 ACPI_TABLE_DESC *InitialStorage, 562 UINT32 InitialTableCount, 563 BOOLEAN AllowResize)) 564 565ACPI_EXTERNAL_RETURN_STATUS ( 566ACPI_STATUS ACPI_INIT_FUNCTION 567AcpiInitializeSubsystem ( 568 void)) 569 570ACPI_EXTERNAL_RETURN_STATUS ( 571ACPI_STATUS ACPI_INIT_FUNCTION 572AcpiEnableSubsystem ( 573 UINT32 Flags)) 574 575ACPI_EXTERNAL_RETURN_STATUS ( 576ACPI_STATUS ACPI_INIT_FUNCTION 577AcpiInitializeObjects ( 578 UINT32 Flags)) 579 580ACPI_EXTERNAL_RETURN_STATUS ( 581ACPI_STATUS ACPI_INIT_FUNCTION 582AcpiTerminate ( 583 void)) 584 585 586/* 587 * Miscellaneous global interfaces 588 */ 589ACPI_HW_DEPENDENT_RETURN_STATUS ( 590ACPI_STATUS 591AcpiEnable ( 592 void)) 593 594ACPI_HW_DEPENDENT_RETURN_STATUS ( 595ACPI_STATUS 596AcpiDisable ( 597 void)) 598 599ACPI_EXTERNAL_RETURN_STATUS ( 600ACPI_STATUS 601AcpiSubsystemStatus ( 602 void)) 603 604ACPI_EXTERNAL_RETURN_STATUS ( 605ACPI_STATUS 606AcpiGetSystemInfo ( 607 ACPI_BUFFER *RetBuffer)) 608 609ACPI_EXTERNAL_RETURN_STATUS ( 610ACPI_STATUS 611AcpiGetStatistics ( 612 ACPI_STATISTICS *Stats)) 613 614ACPI_EXTERNAL_RETURN_PTR ( 615const char * 616AcpiFormatException ( 617 ACPI_STATUS Exception)) 618 619ACPI_EXTERNAL_RETURN_STATUS ( 620ACPI_STATUS 621AcpiPurgeCachedObjects ( 622 void)) 623 624ACPI_EXTERNAL_RETURN_STATUS ( 625ACPI_STATUS 626AcpiInstallInterface ( 627 ACPI_STRING InterfaceName)) 628 629ACPI_EXTERNAL_RETURN_STATUS ( 630ACPI_STATUS 631AcpiRemoveInterface ( 632 ACPI_STRING InterfaceName)) 633 634ACPI_EXTERNAL_RETURN_STATUS ( 635ACPI_STATUS 636AcpiUpdateInterfaces ( 637 UINT8 Action)) 638 639ACPI_EXTERNAL_RETURN_UINT32 ( 640UINT32 641AcpiCheckAddressRange ( 642 ACPI_ADR_SPACE_TYPE SpaceId, 643 ACPI_PHYSICAL_ADDRESS Address, 644 ACPI_SIZE Length, 645 BOOLEAN Warn)) 646 647ACPI_EXTERNAL_RETURN_STATUS ( 648ACPI_STATUS 649AcpiDecodePldBuffer ( 650 UINT8 *InBuffer, 651 ACPI_SIZE Length, 652 ACPI_PLD_INFO **ReturnBuffer)) 653 654 655/* 656 * ACPI table load/unload interfaces 657 */ 658ACPI_EXTERNAL_RETURN_STATUS ( 659ACPI_STATUS ACPI_INIT_FUNCTION 660AcpiInstallTable ( 661 ACPI_PHYSICAL_ADDRESS Address, 662 BOOLEAN Physical)) 663 664ACPI_EXTERNAL_RETURN_STATUS ( 665ACPI_STATUS 666AcpiLoadTable ( 667 ACPI_TABLE_HEADER *Table, 668 UINT32 *TableIdx)) 669 670ACPI_EXTERNAL_RETURN_STATUS ( 671ACPI_STATUS 672AcpiUnloadTable ( 673 UINT32 TableIndex)) 674 675ACPI_EXTERNAL_RETURN_STATUS ( 676ACPI_STATUS 677AcpiUnloadParentTable ( 678 ACPI_HANDLE Object)) 679 680ACPI_EXTERNAL_RETURN_STATUS ( 681ACPI_STATUS ACPI_INIT_FUNCTION 682AcpiLoadTables ( 683 void)) 684 685 686/* 687 * ACPI table manipulation interfaces 688 */ 689ACPI_EXTERNAL_RETURN_STATUS ( 690ACPI_STATUS ACPI_INIT_FUNCTION 691AcpiReallocateRootTable ( 692 void)) 693 694ACPI_EXTERNAL_RETURN_STATUS ( 695ACPI_STATUS ACPI_INIT_FUNCTION 696AcpiFindRootPointer ( 697 ACPI_PHYSICAL_ADDRESS *RsdpAddress)) 698 699ACPI_EXTERNAL_RETURN_STATUS ( 700ACPI_STATUS 701AcpiGetTableHeader ( 702 ACPI_STRING Signature, 703 UINT32 Instance, 704 ACPI_TABLE_HEADER *OutTableHeader)) 705 706ACPI_EXTERNAL_RETURN_STATUS ( 707ACPI_STATUS 708AcpiGetTable ( 709 ACPI_STRING Signature, 710 UINT32 Instance, 711 ACPI_TABLE_HEADER **OutTable)) 712 713ACPI_EXTERNAL_RETURN_VOID ( 714void 715AcpiPutTable ( 716 ACPI_TABLE_HEADER *Table)) 717 718ACPI_EXTERNAL_RETURN_STATUS ( 719ACPI_STATUS 720AcpiGetTableByIndex ( 721 UINT32 TableIndex, 722 ACPI_TABLE_HEADER **OutTable)) 723 724ACPI_EXTERNAL_RETURN_STATUS ( 725ACPI_STATUS 726AcpiInstallTableHandler ( 727 ACPI_TABLE_HANDLER Handler, 728 void *Context)) 729 730ACPI_EXTERNAL_RETURN_STATUS ( 731ACPI_STATUS 732AcpiRemoveTableHandler ( 733 ACPI_TABLE_HANDLER Handler)) 734 735 736/* 737 * Namespace and name interfaces 738 */ 739ACPI_EXTERNAL_RETURN_STATUS ( 740ACPI_STATUS 741AcpiWalkNamespace ( 742 ACPI_OBJECT_TYPE Type, 743 ACPI_HANDLE StartObject, 744 UINT32 MaxDepth, 745 ACPI_WALK_CALLBACK DescendingCallback, 746 ACPI_WALK_CALLBACK AscendingCallback, 747 void *Context, 748 void **ReturnValue)) 749 750ACPI_EXTERNAL_RETURN_STATUS ( 751ACPI_STATUS 752AcpiGetDevices ( 753 char *HID, 754 ACPI_WALK_CALLBACK UserFunction, 755 void *Context, 756 void **ReturnValue)) 757 758ACPI_EXTERNAL_RETURN_STATUS ( 759ACPI_STATUS 760AcpiGetName ( 761 ACPI_HANDLE Object, 762 UINT32 NameType, 763 ACPI_BUFFER *RetPathPtr)) 764 765ACPI_EXTERNAL_RETURN_STATUS ( 766ACPI_STATUS 767AcpiGetHandle ( 768 ACPI_HANDLE Parent, 769 ACPI_STRING Pathname, 770 ACPI_HANDLE *RetHandle)) 771 772ACPI_EXTERNAL_RETURN_STATUS ( 773ACPI_STATUS 774AcpiAttachData ( 775 ACPI_HANDLE Object, 776 ACPI_OBJECT_HANDLER Handler, 777 void *Data)) 778 779ACPI_EXTERNAL_RETURN_STATUS ( 780ACPI_STATUS 781AcpiDetachData ( 782 ACPI_HANDLE Object, 783 ACPI_OBJECT_HANDLER Handler)) 784 785ACPI_EXTERNAL_RETURN_STATUS ( 786ACPI_STATUS 787AcpiGetData ( 788 ACPI_HANDLE Object, 789 ACPI_OBJECT_HANDLER Handler, 790 void **Data)) 791 792ACPI_EXTERNAL_RETURN_STATUS ( 793ACPI_STATUS 794AcpiDebugTrace ( 795 const char *Name, 796 UINT32 DebugLevel, 797 UINT32 DebugLayer, 798 UINT32 Flags)) 799 800 801/* 802 * Object manipulation and enumeration 803 */ 804ACPI_EXTERNAL_RETURN_STATUS ( 805ACPI_STATUS 806AcpiEvaluateObject ( 807 ACPI_HANDLE Object, 808 ACPI_STRING Pathname, 809 ACPI_OBJECT_LIST *ParameterObjects, 810 ACPI_BUFFER *ReturnObjectBuffer)) 811 812ACPI_EXTERNAL_RETURN_STATUS ( 813ACPI_STATUS 814AcpiEvaluateObjectTyped ( 815 ACPI_HANDLE Object, 816 ACPI_STRING Pathname, 817 ACPI_OBJECT_LIST *ExternalParams, 818 ACPI_BUFFER *ReturnBuffer, 819 ACPI_OBJECT_TYPE ReturnType)) 820 821ACPI_EXTERNAL_RETURN_STATUS ( 822ACPI_STATUS 823AcpiGetObjectInfo ( 824 ACPI_HANDLE Object, 825 ACPI_DEVICE_INFO **ReturnBuffer)) 826 827ACPI_EXTERNAL_RETURN_STATUS ( 828ACPI_STATUS 829AcpiInstallMethod ( 830 UINT8 *Buffer)) 831 832ACPI_EXTERNAL_RETURN_STATUS ( 833ACPI_STATUS 834AcpiGetNextObject ( 835 ACPI_OBJECT_TYPE Type, 836 ACPI_HANDLE Parent, 837 ACPI_HANDLE Child, 838 ACPI_HANDLE *OutHandle)) 839 840ACPI_EXTERNAL_RETURN_STATUS ( 841ACPI_STATUS 842AcpiGetType ( 843 ACPI_HANDLE Object, 844 ACPI_OBJECT_TYPE *OutType)) 845 846ACPI_EXTERNAL_RETURN_STATUS ( 847ACPI_STATUS 848AcpiGetParent ( 849 ACPI_HANDLE Object, 850 ACPI_HANDLE *OutHandle)) 851 852 853/* 854 * Handler interfaces 855 */ 856ACPI_EXTERNAL_RETURN_STATUS ( 857ACPI_STATUS 858AcpiInstallInitializationHandler ( 859 ACPI_INIT_HANDLER Handler, 860 UINT32 Function)) 861 862ACPI_HW_DEPENDENT_RETURN_STATUS ( 863ACPI_STATUS 864AcpiInstallSciHandler ( 865 ACPI_SCI_HANDLER Address, 866 void *Context)) 867 868ACPI_HW_DEPENDENT_RETURN_STATUS ( 869ACPI_STATUS 870AcpiRemoveSciHandler ( 871 ACPI_SCI_HANDLER Address)) 872 873ACPI_HW_DEPENDENT_RETURN_STATUS ( 874ACPI_STATUS 875AcpiInstallGlobalEventHandler ( 876 ACPI_GBL_EVENT_HANDLER Handler, 877 void *Context)) 878 879ACPI_HW_DEPENDENT_RETURN_STATUS ( 880ACPI_STATUS 881AcpiInstallFixedEventHandler ( 882 UINT32 AcpiEvent, 883 ACPI_EVENT_HANDLER Handler, 884 void *Context)) 885 886ACPI_HW_DEPENDENT_RETURN_STATUS ( 887ACPI_STATUS 888AcpiRemoveFixedEventHandler ( 889 UINT32 AcpiEvent, 890 ACPI_EVENT_HANDLER Handler)) 891 892ACPI_HW_DEPENDENT_RETURN_STATUS ( 893ACPI_STATUS 894AcpiInstallGpeHandler ( 895 ACPI_HANDLE GpeDevice, 896 UINT32 GpeNumber, 897 UINT32 Type, 898 ACPI_GPE_HANDLER Address, 899 void *Context)) 900 901ACPI_HW_DEPENDENT_RETURN_STATUS ( 902ACPI_STATUS 903AcpiInstallGpeRawHandler ( 904 ACPI_HANDLE GpeDevice, 905 UINT32 GpeNumber, 906 UINT32 Type, 907 ACPI_GPE_HANDLER Address, 908 void *Context)) 909 910ACPI_HW_DEPENDENT_RETURN_STATUS ( 911ACPI_STATUS 912AcpiRemoveGpeHandler ( 913 ACPI_HANDLE GpeDevice, 914 UINT32 GpeNumber, 915 ACPI_GPE_HANDLER Address)) 916 917ACPI_EXTERNAL_RETURN_STATUS ( 918ACPI_STATUS 919AcpiInstallNotifyHandler ( 920 ACPI_HANDLE Device, 921 UINT32 HandlerType, 922 ACPI_NOTIFY_HANDLER Handler, 923 void *Context)) 924 925ACPI_EXTERNAL_RETURN_STATUS ( 926ACPI_STATUS 927AcpiRemoveNotifyHandler ( 928 ACPI_HANDLE Device, 929 UINT32 HandlerType, 930 ACPI_NOTIFY_HANDLER Handler)) 931 932ACPI_EXTERNAL_RETURN_STATUS ( 933ACPI_STATUS 934AcpiInstallAddressSpaceHandler ( 935 ACPI_HANDLE Device, 936 ACPI_ADR_SPACE_TYPE SpaceId, 937 ACPI_ADR_SPACE_HANDLER Handler, 938 ACPI_ADR_SPACE_SETUP Setup, 939 void *Context)) 940 941ACPI_EXTERNAL_RETURN_STATUS ( 942ACPI_STATUS 943AcpiRemoveAddressSpaceHandler ( 944 ACPI_HANDLE Device, 945 ACPI_ADR_SPACE_TYPE SpaceId, 946 ACPI_ADR_SPACE_HANDLER Handler)) 947 948ACPI_EXTERNAL_RETURN_STATUS ( 949ACPI_STATUS 950AcpiInstallExceptionHandler ( 951 ACPI_EXCEPTION_HANDLER Handler)) 952 953ACPI_EXTERNAL_RETURN_STATUS ( 954ACPI_STATUS 955AcpiInstallInterfaceHandler ( 956 ACPI_INTERFACE_HANDLER Handler)) 957 958 959/* 960 * Global Lock interfaces 961 */ 962ACPI_HW_DEPENDENT_RETURN_STATUS ( 963ACPI_STATUS 964AcpiAcquireGlobalLock ( 965 UINT16 Timeout, 966 UINT32 *Handle)) 967 968ACPI_HW_DEPENDENT_RETURN_STATUS ( 969ACPI_STATUS 970AcpiReleaseGlobalLock ( 971 UINT32 Handle)) 972 973 974/* 975 * Interfaces to AML mutex objects 976 */ 977ACPI_EXTERNAL_RETURN_STATUS ( 978ACPI_STATUS 979AcpiAcquireMutex ( 980 ACPI_HANDLE Handle, 981 ACPI_STRING Pathname, 982 UINT16 Timeout)) 983 984ACPI_EXTERNAL_RETURN_STATUS ( 985ACPI_STATUS 986AcpiReleaseMutex ( 987 ACPI_HANDLE Handle, 988 ACPI_STRING Pathname)) 989 990 991/* 992 * Fixed Event interfaces 993 */ 994ACPI_HW_DEPENDENT_RETURN_STATUS ( 995ACPI_STATUS 996AcpiEnableEvent ( 997 UINT32 Event, 998 UINT32 Flags)) 999 1000ACPI_HW_DEPENDENT_RETURN_STATUS ( 1001ACPI_STATUS 1002AcpiDisableEvent ( 1003 UINT32 Event, 1004 UINT32 Flags)) 1005 1006ACPI_HW_DEPENDENT_RETURN_STATUS ( 1007ACPI_STATUS 1008AcpiClearEvent ( 1009 UINT32 Event)) 1010 1011ACPI_HW_DEPENDENT_RETURN_STATUS ( 1012ACPI_STATUS 1013AcpiGetEventStatus ( 1014 UINT32 Event, 1015 ACPI_EVENT_STATUS *EventStatus)) 1016 1017 1018/* 1019 * General Purpose Event (GPE) Interfaces 1020 */ 1021ACPI_HW_DEPENDENT_RETURN_STATUS ( 1022ACPI_STATUS 1023AcpiUpdateAllGpes ( 1024 void)) 1025 1026ACPI_HW_DEPENDENT_RETURN_STATUS ( 1027ACPI_STATUS 1028AcpiEnableGpe ( 1029 ACPI_HANDLE GpeDevice, 1030 UINT32 GpeNumber)) 1031 1032ACPI_HW_DEPENDENT_RETURN_STATUS ( 1033ACPI_STATUS 1034AcpiDisableGpe ( 1035 ACPI_HANDLE GpeDevice, 1036 UINT32 GpeNumber)) 1037 1038ACPI_HW_DEPENDENT_RETURN_STATUS ( 1039ACPI_STATUS 1040AcpiClearGpe ( 1041 ACPI_HANDLE GpeDevice, 1042 UINT32 GpeNumber)) 1043 1044ACPI_HW_DEPENDENT_RETURN_STATUS ( 1045ACPI_STATUS 1046AcpiSetGpe ( 1047 ACPI_HANDLE GpeDevice, 1048 UINT32 GpeNumber, 1049 UINT8 Action)) 1050 1051ACPI_HW_DEPENDENT_RETURN_STATUS ( 1052ACPI_STATUS 1053AcpiFinishGpe ( 1054 ACPI_HANDLE GpeDevice, 1055 UINT32 GpeNumber)) 1056 1057ACPI_HW_DEPENDENT_RETURN_STATUS ( 1058ACPI_STATUS 1059AcpiMaskGpe ( 1060 ACPI_HANDLE GpeDevice, 1061 UINT32 GpeNumber, 1062 BOOLEAN IsMasked)) 1063 1064ACPI_HW_DEPENDENT_RETURN_STATUS ( 1065ACPI_STATUS 1066AcpiMarkGpeForWake ( 1067 ACPI_HANDLE GpeDevice, 1068 UINT32 GpeNumber)) 1069 1070ACPI_HW_DEPENDENT_RETURN_STATUS ( 1071ACPI_STATUS 1072AcpiSetupGpeForWake ( 1073 ACPI_HANDLE ParentDevice, 1074 ACPI_HANDLE GpeDevice, 1075 UINT32 GpeNumber)) 1076 1077ACPI_HW_DEPENDENT_RETURN_STATUS ( 1078ACPI_STATUS 1079AcpiSetGpeWakeMask ( 1080 ACPI_HANDLE GpeDevice, 1081 UINT32 GpeNumber, 1082 UINT8 Action)) 1083 1084ACPI_HW_DEPENDENT_RETURN_STATUS ( 1085ACPI_STATUS 1086AcpiGetGpeStatus ( 1087 ACPI_HANDLE GpeDevice, 1088 UINT32 GpeNumber, 1089 ACPI_EVENT_STATUS *EventStatus)) 1090 1091ACPI_HW_DEPENDENT_RETURN_UINT32 ( 1092UINT32 1093AcpiDispatchGpe ( 1094 ACPI_HANDLE GpeDevice, 1095 UINT32 GpeNumber)) 1096 1097ACPI_HW_DEPENDENT_RETURN_STATUS ( 1098ACPI_STATUS 1099AcpiDisableAllGpes ( 1100 void)) 1101 1102ACPI_HW_DEPENDENT_RETURN_STATUS ( 1103ACPI_STATUS 1104AcpiEnableAllRuntimeGpes ( 1105 void)) 1106 1107ACPI_HW_DEPENDENT_RETURN_STATUS ( 1108ACPI_STATUS 1109AcpiEnableAllWakeupGpes ( 1110 void)) 1111 1112ACPI_HW_DEPENDENT_RETURN_UINT32 ( 1113 UINT32 AcpiAnyGpeStatusSet ( 1114 void)) 1115 1116ACPI_HW_DEPENDENT_RETURN_STATUS ( 1117ACPI_STATUS 1118AcpiGetGpeDevice ( 1119 UINT32 GpeIndex, 1120 ACPI_HANDLE *GpeDevice)) 1121 1122ACPI_HW_DEPENDENT_RETURN_STATUS ( 1123ACPI_STATUS 1124AcpiInstallGpeBlock ( 1125 ACPI_HANDLE GpeDevice, 1126 ACPI_GENERIC_ADDRESS *GpeBlockAddress, 1127 UINT32 RegisterCount, 1128 UINT32 InterruptNumber)) 1129 1130ACPI_HW_DEPENDENT_RETURN_STATUS ( 1131ACPI_STATUS 1132AcpiRemoveGpeBlock ( 1133 ACPI_HANDLE GpeDevice)) 1134 1135 1136/* 1137 * Resource interfaces 1138 */ 1139typedef 1140ACPI_STATUS (*ACPI_WALK_RESOURCE_CALLBACK) ( 1141 ACPI_RESOURCE *Resource, 1142 void *Context); 1143 1144ACPI_EXTERNAL_RETURN_STATUS ( 1145ACPI_STATUS 1146AcpiGetVendorResource ( 1147 ACPI_HANDLE Device, 1148 char *Name, 1149 ACPI_VENDOR_UUID *Uuid, 1150 ACPI_BUFFER *RetBuffer)) 1151 1152ACPI_EXTERNAL_RETURN_STATUS ( 1153ACPI_STATUS 1154AcpiGetCurrentResources ( 1155 ACPI_HANDLE Device, 1156 ACPI_BUFFER *RetBuffer)) 1157 1158ACPI_EXTERNAL_RETURN_STATUS ( 1159ACPI_STATUS 1160AcpiGetPossibleResources ( 1161 ACPI_HANDLE Device, 1162 ACPI_BUFFER *RetBuffer)) 1163 1164ACPI_EXTERNAL_RETURN_STATUS ( 1165ACPI_STATUS 1166AcpiGetEventResources ( 1167 ACPI_HANDLE DeviceHandle, 1168 ACPI_BUFFER *RetBuffer)) 1169 1170ACPI_EXTERNAL_RETURN_STATUS ( 1171ACPI_STATUS 1172AcpiWalkResourceBuffer ( 1173 ACPI_BUFFER *Buffer, 1174 ACPI_WALK_RESOURCE_CALLBACK UserFunction, 1175 void *Context)) 1176 1177ACPI_EXTERNAL_RETURN_STATUS ( 1178ACPI_STATUS 1179AcpiWalkResources ( 1180 ACPI_HANDLE Device, 1181 char *Name, 1182 ACPI_WALK_RESOURCE_CALLBACK UserFunction, 1183 void *Context)) 1184 1185ACPI_EXTERNAL_RETURN_STATUS ( 1186ACPI_STATUS 1187AcpiSetCurrentResources ( 1188 ACPI_HANDLE Device, 1189 ACPI_BUFFER *InBuffer)) 1190 1191ACPI_EXTERNAL_RETURN_STATUS ( 1192ACPI_STATUS 1193AcpiGetIrqRoutingTable ( 1194 ACPI_HANDLE Device, 1195 ACPI_BUFFER *RetBuffer)) 1196 1197ACPI_EXTERNAL_RETURN_STATUS ( 1198ACPI_STATUS 1199AcpiResourceToAddress64 ( 1200 ACPI_RESOURCE *Resource, 1201 ACPI_RESOURCE_ADDRESS64 *Out)) 1202 1203ACPI_EXTERNAL_RETURN_STATUS ( 1204ACPI_STATUS 1205AcpiBufferToResource ( 1206 UINT8 *AmlBuffer, 1207 UINT16 AmlBufferLength, 1208 ACPI_RESOURCE **ResourcePtr)) 1209 1210 1211/* 1212 * Hardware (ACPI device) interfaces 1213 */ 1214ACPI_EXTERNAL_RETURN_STATUS ( 1215ACPI_STATUS 1216AcpiReset ( 1217 void)) 1218 1219ACPI_EXTERNAL_RETURN_STATUS ( 1220ACPI_STATUS 1221AcpiRead ( 1222 UINT64 *Value, 1223 ACPI_GENERIC_ADDRESS *Reg)) 1224 1225ACPI_EXTERNAL_RETURN_STATUS ( 1226ACPI_STATUS 1227AcpiWrite ( 1228 UINT64 Value, 1229 ACPI_GENERIC_ADDRESS *Reg)) 1230 1231ACPI_HW_DEPENDENT_RETURN_STATUS ( 1232ACPI_STATUS 1233AcpiReadBitRegister ( 1234 UINT32 RegisterId, 1235 UINT32 *ReturnValue)) 1236 1237ACPI_HW_DEPENDENT_RETURN_STATUS ( 1238ACPI_STATUS 1239AcpiWriteBitRegister ( 1240 UINT32 RegisterId, 1241 UINT32 Value)) 1242 1243 1244/* 1245 * Sleep/Wake interfaces 1246 */ 1247ACPI_EXTERNAL_RETURN_STATUS ( 1248ACPI_STATUS 1249AcpiGetSleepTypeData ( 1250 UINT8 SleepState, 1251 UINT8 *Slp_TypA, 1252 UINT8 *Slp_TypB)) 1253 1254ACPI_EXTERNAL_RETURN_STATUS ( 1255ACPI_STATUS 1256AcpiEnterSleepStatePrep ( 1257 UINT8 SleepState)) 1258 1259ACPI_EXTERNAL_RETURN_STATUS ( 1260ACPI_STATUS 1261AcpiEnterSleepState ( 1262 UINT8 SleepState)) 1263 1264ACPI_HW_DEPENDENT_RETURN_STATUS ( 1265ACPI_STATUS 1266AcpiEnterSleepStateS4bios ( 1267 void)) 1268 1269ACPI_EXTERNAL_RETURN_STATUS ( 1270ACPI_STATUS 1271AcpiLeaveSleepStatePrep ( 1272 UINT8 SleepState)) 1273 1274ACPI_EXTERNAL_RETURN_STATUS ( 1275ACPI_STATUS 1276AcpiLeaveSleepState ( 1277 UINT8 SleepState)) 1278 1279ACPI_HW_DEPENDENT_RETURN_STATUS ( 1280ACPI_STATUS 1281AcpiSetFirmwareWakingVector ( 1282 ACPI_PHYSICAL_ADDRESS PhysicalAddress, 1283 ACPI_PHYSICAL_ADDRESS PhysicalAddress64)) 1284 1285 1286/* 1287 * ACPI Timer interfaces 1288 */ 1289ACPI_HW_DEPENDENT_RETURN_STATUS ( 1290ACPI_STATUS 1291AcpiGetTimerResolution ( 1292 UINT32 *Resolution)) 1293 1294ACPI_HW_DEPENDENT_RETURN_STATUS ( 1295ACPI_STATUS 1296AcpiGetTimer ( 1297 UINT32 *Ticks)) 1298 1299ACPI_HW_DEPENDENT_RETURN_STATUS ( 1300ACPI_STATUS 1301AcpiGetTimerDuration ( 1302 UINT32 StartTicks, 1303 UINT32 EndTicks, 1304 UINT32 *TimeElapsed)) 1305 1306 1307/* 1308 * Error/Warning output 1309 */ 1310ACPI_MSG_DEPENDENT_RETURN_VOID ( 1311ACPI_PRINTF_LIKE(3) 1312void ACPI_INTERNAL_VAR_XFACE 1313AcpiError ( 1314 const char *ModuleName, 1315 UINT32 LineNumber, 1316 const char *Format, 1317 ...)) 1318 1319ACPI_MSG_DEPENDENT_RETURN_VOID ( 1320ACPI_PRINTF_LIKE(4) 1321void ACPI_INTERNAL_VAR_XFACE 1322AcpiException ( 1323 const char *ModuleName, 1324 UINT32 LineNumber, 1325 ACPI_STATUS Status, 1326 const char *Format, 1327 ...)) 1328 1329ACPI_MSG_DEPENDENT_RETURN_VOID ( 1330ACPI_PRINTF_LIKE(3) 1331void ACPI_INTERNAL_VAR_XFACE 1332AcpiWarning ( 1333 const char *ModuleName, 1334 UINT32 LineNumber, 1335 const char *Format, 1336 ...)) 1337 1338ACPI_MSG_DEPENDENT_RETURN_VOID ( 1339ACPI_PRINTF_LIKE(1) 1340void ACPI_INTERNAL_VAR_XFACE 1341AcpiInfo ( 1342 const char *Format, 1343 ...)) 1344 1345ACPI_MSG_DEPENDENT_RETURN_VOID ( 1346ACPI_PRINTF_LIKE(3) 1347void ACPI_INTERNAL_VAR_XFACE 1348AcpiBiosError ( 1349 const char *ModuleName, 1350 UINT32 LineNumber, 1351 const char *Format, 1352 ...)) 1353 1354ACPI_MSG_DEPENDENT_RETURN_VOID ( 1355ACPI_PRINTF_LIKE(4) 1356void ACPI_INTERNAL_VAR_XFACE 1357AcpiBiosException ( 1358 const char *ModuleName, 1359 UINT32 LineNumber, 1360 ACPI_STATUS Status, 1361 const char *Format, 1362 ...)) 1363 1364ACPI_MSG_DEPENDENT_RETURN_VOID ( 1365ACPI_PRINTF_LIKE(3) 1366void ACPI_INTERNAL_VAR_XFACE 1367AcpiBiosWarning ( 1368 const char *ModuleName, 1369 UINT32 LineNumber, 1370 const char *Format, 1371 ...)) 1372 1373 1374/* 1375 * Debug output 1376 */ 1377ACPI_DBG_DEPENDENT_RETURN_VOID ( 1378ACPI_PRINTF_LIKE(6) 1379void ACPI_INTERNAL_VAR_XFACE 1380AcpiDebugPrint ( 1381 UINT32 RequestedDebugLevel, 1382 UINT32 LineNumber, 1383 const char *FunctionName, 1384 const char *ModuleName, 1385 UINT32 ComponentId, 1386 const char *Format, 1387 ...)) 1388 1389ACPI_DBG_DEPENDENT_RETURN_VOID ( 1390ACPI_PRINTF_LIKE(6) 1391void ACPI_INTERNAL_VAR_XFACE 1392AcpiDebugPrintRaw ( 1393 UINT32 RequestedDebugLevel, 1394 UINT32 LineNumber, 1395 const char *FunctionName, 1396 const char *ModuleName, 1397 UINT32 ComponentId, 1398 const char *Format, 1399 ...)) 1400 1401ACPI_DBG_DEPENDENT_RETURN_VOID ( 1402void 1403AcpiTracePoint ( 1404 ACPI_TRACE_EVENT_TYPE Type, 1405 BOOLEAN Begin, 1406 UINT8 *Aml, 1407 char *Pathname)) 1408 1409ACPI_STATUS 1410AcpiInitializeDebugger ( 1411 void); 1412 1413void 1414AcpiTerminateDebugger ( 1415 void); 1416 1417void 1418AcpiRunDebugger ( 1419 char *BatchBuffer); 1420 1421void 1422AcpiSetDebuggerThreadId ( 1423 ACPI_THREAD_ID ThreadId); 1424 1425#endif /* __ACXFACE_H__ */ 1426