Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/acconfig.h =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/acconfig.h (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/acconfig.h (revision 82367) @@ -1,249 +1,249 @@ /****************************************************************************** * * Name: acconfig.h - Global configuration constants - * $Revision: 66 $ + * $Revision: 68 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #ifndef _ACCONFIG_H #define _ACCONFIG_H /****************************************************************************** * * Compile-time options * *****************************************************************************/ /* * ACPI_DEBUG - This switch enables all the debug facilities of the ACPI * subsystem. This includes the DEBUG_PRINT output statements * When disabled, all DEBUG_PRINT statements are compiled out. * * ACPI_APPLICATION - Use this switch if the subsystem is going to be run * at the application level. * */ /****************************************************************************** * * Subsystem Constants * *****************************************************************************/ /* Version string */ -#define ACPI_CA_VERSION 0x20010717 +#define ACPI_CA_VERSION 0x20010816 /* Maximum objects in the various object caches */ #define MAX_STATE_CACHE_DEPTH 64 /* State objects for stacks */ #define MAX_PARSE_CACHE_DEPTH 96 /* Parse tree objects */ #define MAX_EXTPARSE_CACHE_DEPTH 64 /* Parse tree objects */ #define MAX_OBJECT_CACHE_DEPTH 64 /* Interpreter operand objects */ -#define MAX_WALK_CACHE_DEPTH 2 /* Objects for parse tree walks (method execution) */ +#define MAX_WALK_CACHE_DEPTH 4 /* Objects for parse tree walks (method execution) */ /* String size constants */ #define MAX_STRING_LENGTH 512 #define PATHNAME_MAX 256 /* A full namespace pathname */ /* Maximum count for a semaphore object */ #define MAX_SEMAPHORE_COUNT 256 /* Max reference count (for debug only) */ #define MAX_REFERENCE_COUNT 0x200 /* Size of cached memory mapping for system memory operation region */ #define SYSMEM_REGION_WINDOW_SIZE 4096 /* * Debugger threading model * Use single threaded if the entire subsystem is contained in an application * Use multiple threaded when the subsystem is running in the kernel. * * By default the model is single threaded if ACPI_APPLICATION is set, * multi-threaded if ACPI_APPLICATION is not set. */ #define DEBUGGER_SINGLE_THREADED 0 #define DEBUGGER_MULTI_THREADED 1 #ifdef ACPI_APPLICATION #define DEBUGGER_THREADING DEBUGGER_SINGLE_THREADED #else #define DEBUGGER_THREADING DEBUGGER_MULTI_THREADED #endif /****************************************************************************** * * ACPI Specification constants (Do not change unless the specification changes) * *****************************************************************************/ /* * Method info (in WALK_STATE), containing local variables and argumetns */ #define MTH_NUM_LOCALS 8 #define MTH_MAX_LOCAL 7 #define MTH_NUM_ARGS 7 #define MTH_MAX_ARG 6 /* Maximum length of resulting string when converting from a buffer */ #define ACPI_MAX_STRING_CONVERSION 200 /* * Operand Stack (in WALK_STATE), Must be large enough to contain MTH_MAX_ARG */ #define OBJ_NUM_OPERANDS 8 #define OBJ_MAX_OPERAND 7 /* Names within the namespace are 4 bytes long */ #define ACPI_NAME_SIZE 4 #define PATH_SEGMENT_LENGTH 5 /* 4 chars for name + 1 INT8 for separator */ #define PATH_SEPARATOR '.' /* Constants used in searching for the RSDP in low memory */ #define LO_RSDP_WINDOW_BASE 0 /* Physical Address */ #define HI_RSDP_WINDOW_BASE 0xE0000 /* Physical Address */ #define LO_RSDP_WINDOW_SIZE 0x400 #define HI_RSDP_WINDOW_SIZE 0x20000 #define RSDP_SCAN_STEP 16 /* Maximum SpaceIds for Operation Regions */ #define ACPI_MAX_ADDRESS_SPACE 255 #define ACPI_NUM_ADDRESS_SPACES 256 #endif /* _ACCONFIG_H */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/acglobal.h =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/acglobal.h (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/acglobal.h (revision 82367) @@ -1,377 +1,328 @@ /****************************************************************************** * * Name: acglobal.h - Declarations for global variables - * $Revision: 102 $ + * $Revision: 103 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #ifndef __ACGLOBAL_H__ #define __ACGLOBAL_H__ /* * Ensure that the globals are actually defined only once. * * The use of these defines allows a single list of globals (here) in order * to simplify maintenance of the code. */ #ifdef DEFINE_ACPI_GLOBALS #define ACPI_EXTERN #else #define ACPI_EXTERN extern #endif extern NATIVE_CHAR *MsgAcpiErrorBreak; /***************************************************************************** * * Debug support * ****************************************************************************/ /* Runtime configuration of debug print levels */ extern UINT32 AcpiDbgLevel; extern UINT32 AcpiDbgLayer; /* Procedure nesting level for debug output */ extern UINT32 AcpiGbl_NestingLevel; /***************************************************************************** * * ACPI Table globals * ****************************************************************************/ /* * Table pointers. * Although these pointers are somewhat redundant with the global AcpiTable, * they are convenient because they are typed pointers. * * These tables are single-table only; meaning that there can be at most one * of each in the system. Each global points to the actual table. * */ ACPI_EXTERN RSDP_DESCRIPTOR *AcpiGbl_RSDP; ACPI_EXTERN XSDT_DESCRIPTOR *AcpiGbl_XSDT; ACPI_EXTERN FADT_DESCRIPTOR *AcpiGbl_FADT; ACPI_EXTERN ACPI_TABLE_HEADER *AcpiGbl_DSDT; ACPI_EXTERN ACPI_COMMON_FACS *AcpiGbl_FACS; /* * Since there may be multiple SSDTs and PSDTS, a single pointer is not * sufficient; Therefore, there isn't one! */ /* * ACPI Table info arrays */ extern ACPI_TABLE_DESC AcpiGbl_AcpiTables[NUM_ACPI_TABLES]; extern ACPI_TABLE_SUPPORT AcpiGbl_AcpiTableData[NUM_ACPI_TABLES]; /* * Predefined mutex objects. This array contains the * actual OS mutex handles, indexed by the local ACPI_MUTEX_HANDLEs. * (The table maps local handles to the real OS handles) */ ACPI_EXTERN ACPI_MUTEX_INFO AcpiGbl_AcpiMutexInfo [NUM_MTX]; /***************************************************************************** * * Miscellaneous globals * ****************************************************************************/ +ACPI_EXTERN ACPI_MEMORY_LIST AcpiGbl_MemoryLists[ACPI_NUM_MEM_LISTS]; +ACPI_EXTERN ACPI_OBJECT_NOTIFY_HANDLER AcpiGbl_DrvNotify; +ACPI_EXTERN ACPI_OBJECT_NOTIFY_HANDLER AcpiGbl_SysNotify; ACPI_EXTERN UINT8 *AcpiGbl_Gpe0EnableRegisterSave; ACPI_EXTERN UINT8 *AcpiGbl_Gpe1EnableRegisterSave; ACPI_EXTERN ACPI_WALK_STATE *AcpiGbl_BreakpointWalk; -ACPI_EXTERN ACPI_GENERIC_STATE *AcpiGbl_GenericStateCache; -ACPI_EXTERN ACPI_PARSE_OBJECT *AcpiGbl_ParseCache; -ACPI_EXTERN ACPI_PARSE2_OBJECT *AcpiGbl_ExtParseCache; -ACPI_EXTERN ACPI_OPERAND_OBJECT *AcpiGbl_ObjectCache; -ACPI_EXTERN ACPI_WALK_STATE *AcpiGbl_WalkStateCache; ACPI_EXTERN ACPI_HANDLE AcpiGbl_GlobalLockSemaphore; - ACPI_EXTERN UINT32 AcpiGbl_GlobalLockThreadCount; ACPI_EXTERN UINT32 AcpiGbl_RestoreAcpiChipset; ACPI_EXTERN UINT32 AcpiGbl_OriginalMode; ACPI_EXTERN UINT32 AcpiGbl_EdgeLevelSave; ACPI_EXTERN UINT32 AcpiGbl_IrqEnableSave; ACPI_EXTERN UINT32 AcpiGbl_RsdpOriginalLocation; - -ACPI_EXTERN UINT32 AcpiGbl_StateCacheRequests; -ACPI_EXTERN UINT32 AcpiGbl_StateCacheHits; -ACPI_EXTERN UINT32 AcpiGbl_ParseCacheRequests; -ACPI_EXTERN UINT32 AcpiGbl_ParseCacheHits; -ACPI_EXTERN UINT32 AcpiGbl_ExtParseCacheRequests; -ACPI_EXTERN UINT32 AcpiGbl_ExtParseCacheHits; -ACPI_EXTERN UINT32 AcpiGbl_ObjectCacheRequests; -ACPI_EXTERN UINT32 AcpiGbl_ObjectCacheHits; -ACPI_EXTERN UINT32 AcpiGbl_WalkStateCacheRequests; -ACPI_EXTERN UINT32 AcpiGbl_WalkStateCacheHits; ACPI_EXTERN UINT32 AcpiGbl_NsLookupCount; ACPI_EXTERN UINT32 AcpiGbl_PsFindCount; - - -ACPI_EXTERN UINT16 AcpiGbl_GenericStateCacheDepth; -ACPI_EXTERN UINT16 AcpiGbl_ParseCacheDepth; -ACPI_EXTERN UINT16 AcpiGbl_ExtParseCacheDepth; -ACPI_EXTERN UINT16 AcpiGbl_ObjectCacheDepth; -ACPI_EXTERN UINT16 AcpiGbl_WalkStateCacheDepth; ACPI_EXTERN UINT16 AcpiGbl_Pm1EnableRegisterSave; ACPI_EXTERN UINT16 AcpiGbl_NextTableOwnerId; ACPI_EXTERN UINT16 AcpiGbl_NextMethodOwnerId; - ACPI_EXTERN UINT8 AcpiGbl_DebuggerConfiguration; ACPI_EXTERN BOOLEAN AcpiGbl_GlobalLockAcquired; ACPI_EXTERN BOOLEAN AcpiGbl_StepToNextCall; ACPI_EXTERN BOOLEAN AcpiGbl_AcpiHardwarePresent; ACPI_EXTERN BOOLEAN AcpiGbl_GlobalLockPresent; -ACPI_EXTERN ACPI_OBJECT_NOTIFY_HANDLER AcpiGbl_DrvNotify; -ACPI_EXTERN ACPI_OBJECT_NOTIFY_HANDLER AcpiGbl_SysNotify; - - extern BOOLEAN AcpiGbl_Shutdown; extern UINT32 AcpiGbl_SystemFlags; extern UINT32 AcpiGbl_StartupFlags; extern UINT8 AcpiGbl_DecodeTo8bit[8]; extern NATIVE_CHAR AcpiGbl_HexToAscii[16]; /***************************************************************************** * * Namespace globals * ****************************************************************************/ #define NUM_NS_TYPES INTERNAL_TYPE_INVALID+1 #define NUM_PREDEFINED_NAMES 9 ACPI_EXTERN ACPI_NAMESPACE_NODE AcpiGbl_RootNodeStruct; ACPI_EXTERN ACPI_NAMESPACE_NODE *AcpiGbl_RootNode; extern UINT8 AcpiGbl_NsProperties[NUM_NS_TYPES]; extern PREDEFINED_NAMES AcpiGbl_PreDefinedNames [NUM_PREDEFINED_NAMES]; - -/* Used to detect memory leaks (DEBUG ONLY) */ - #ifdef ACPI_DEBUG -ACPI_EXTERN ACPI_ALLOCATION_INFO *AcpiGbl_HeadAllocPtr; -ACPI_EXTERN ACPI_ALLOCATION_INFO *AcpiGbl_TailAllocPtr; +ACPI_EXTERN UINT32 AcpiGbl_CurrentNodeCount; +ACPI_EXTERN UINT32 AcpiGbl_CurrentNodeSize; +ACPI_EXTERN UINT32 AcpiGbl_MaxConcurrentNodeCount; #endif - /***************************************************************************** * * Interpreter globals * ****************************************************************************/ ACPI_EXTERN ACPI_WALK_LIST *AcpiGbl_CurrentWalkList; /* * Table of Address Space handlers */ ACPI_EXTERN ACPI_ADR_SPACE_INFO AcpiGbl_AddressSpaces[ACPI_NUM_ADDRESS_SPACES]; /* Control method single step flag */ ACPI_EXTERN UINT8 AcpiGbl_CmSingleStep; /***************************************************************************** * * Parser globals * ****************************************************************************/ ACPI_EXTERN ACPI_PARSE_OBJECT *AcpiGbl_ParsedNamespaceRoot; /***************************************************************************** * * Event globals * ****************************************************************************/ ACPI_EXTERN ACPI_FIXED_EVENT_INFO AcpiGbl_FixedEventHandlers[ACPI_NUM_FIXED_EVENTS]; ACPI_EXTERN ACPI_HANDLE AcpiGbl_GpeObjHandle; ACPI_EXTERN UINT32 AcpiGbl_GpeRegisterCount; ACPI_EXTERN ACPI_GPE_REGISTERS *AcpiGbl_GpeRegisters; ACPI_EXTERN ACPI_GPE_LEVEL_INFO *AcpiGbl_GpeInfo; /* * Gpe validation and translation table * Indexed by the GPE number, returns GPE_INVALID if the GPE is not supported. * Otherwise, returns a valid index into the global GPE table. * * This table is needed because the GPE numbers supported by block 1 do not * have to be contiguous with the GPE numbers supported by block 0. */ ACPI_EXTERN UINT8 AcpiGbl_GpeValid [ACPI_NUM_GPE]; /* AcpiEvent counter for debug only */ #ifdef ACPI_DEBUG ACPI_EXTERN UINT32 AcpiGbl_EventCount[ACPI_NUM_FIXED_EVENTS]; #endif /***************************************************************************** * * Debugger globals * ****************************************************************************/ #ifdef ENABLE_DEBUGGER ACPI_EXTERN BOOLEAN AcpiGbl_MethodExecuting; ACPI_EXTERN BOOLEAN AcpiGbl_DbTerminateThreads; #endif -/* Memory allocation metrics - Debug Only! */ -#ifdef ACPI_DEBUG - -ACPI_EXTERN UINT32 AcpiGbl_CurrentAllocSize; -ACPI_EXTERN UINT32 AcpiGbl_CurrentAllocCount; -ACPI_EXTERN UINT32 AcpiGbl_RunningAllocSize; -ACPI_EXTERN UINT32 AcpiGbl_RunningAllocCount; -ACPI_EXTERN UINT32 AcpiGbl_MaxConcurrentAllocSize; -ACPI_EXTERN UINT32 AcpiGbl_MaxConcurrentAllocCount; -ACPI_EXTERN UINT32 AcpiGbl_CurrentObjectCount; -ACPI_EXTERN UINT32 AcpiGbl_CurrentObjectSize; -ACPI_EXTERN UINT32 AcpiGbl_MaxConcurrentObjectCount; -ACPI_EXTERN UINT32 AcpiGbl_MaxConcurrentObjectSize; -ACPI_EXTERN UINT32 AcpiGbl_RunningObjectCount; -ACPI_EXTERN UINT32 AcpiGbl_RunningObjectSize; -ACPI_EXTERN UINT32 AcpiGbl_CurrentNodeCount; -ACPI_EXTERN UINT32 AcpiGbl_CurrentNodeSize; -ACPI_EXTERN UINT32 AcpiGbl_MaxConcurrentNodeCount; - -#endif #endif /* __ACGLOBAL_H__ */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/acinterp.h =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/acinterp.h (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/acinterp.h (revision 82367) @@ -1,759 +1,760 @@ /****************************************************************************** * * Name: acinterp.h - Interpreter subcomponent prototypes and defines - * $Revision: 105 $ + * $Revision: 106 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #ifndef __ACINTERP_H__ #define __ACINTERP_H__ #define WALK_OPERANDS &(WalkState->Operands [WalkState->NumOperands -1]) /* Interpreter constants */ #define AML_END_OF_BLOCK -1 #define PUSH_PKG_LENGTH 1 #define DO_NOT_PUSH_PKG_LENGTH 0 #define STACK_TOP 0 #define STACK_BOTTOM (UINT32) -1 /* Constants for global "WhenToParseMethods" */ #define METHOD_PARSE_AT_INIT 0x0 #define METHOD_PARSE_JUST_IN_TIME 0x1 #define METHOD_DELETE_AT_COMPLETION 0x2 ACPI_STATUS AcpiExResolveOperands ( UINT16 Opcode, ACPI_OPERAND_OBJECT **StackPtr, ACPI_WALK_STATE *WalkState); /* * amxface - External interpreter interfaces */ ACPI_STATUS AcpiExLoadTable ( ACPI_TABLE_TYPE TableId); ACPI_STATUS AcpiExExecuteMethod ( ACPI_NAMESPACE_NODE *MethodNode, ACPI_OPERAND_OBJECT **Params, ACPI_OPERAND_OBJECT **ReturnObjDesc); /* * amconvrt - object conversion */ ACPI_STATUS AcpiExConvertToInteger ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExConvertToBuffer ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExConvertToString ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc, + UINT32 Base, UINT32 MaxLength, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExConvertToTargetType ( ACPI_OBJECT_TYPE8 DestinationType, ACPI_OPERAND_OBJECT **ObjDesc, ACPI_WALK_STATE *WalkState); /* * amfield - ACPI AML (p-code) execution - field manipulation */ ACPI_STATUS AcpiExExtractFromField ( ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength); ACPI_STATUS AcpiExInsertIntoField ( ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength); ACPI_STATUS AcpiExSetupField ( ACPI_OPERAND_OBJECT *ObjDesc, UINT32 FieldByteOffset); ACPI_STATUS AcpiExReadFieldDatum ( ACPI_OPERAND_OBJECT *ObjDesc, UINT32 FieldByteOffset, UINT32 *Value); ACPI_STATUS AcpiExCommonAccessField ( UINT32 Mode, ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength); ACPI_STATUS AcpiExAccessIndexField ( UINT32 Mode, ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength); ACPI_STATUS AcpiExAccessBankField ( UINT32 Mode, ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength); ACPI_STATUS AcpiExAccessRegionField ( UINT32 Mode, ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength); ACPI_STATUS AcpiExAccessBufferField ( UINT32 Mode, ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength); ACPI_STATUS AcpiExReadDataFromField ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **RetBufferDesc); ACPI_STATUS AcpiExWriteDataToField ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *ObjDesc); /* * ammisc - ACPI AML (p-code) execution - specific opcodes */ ACPI_STATUS AcpiExTriadic ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc); ACPI_STATUS AcpiExHexadic ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc); ACPI_STATUS AcpiExCreateBufferField ( UINT8 *AmlPtr, UINT32 AmlLength, ACPI_NAMESPACE_NODE *Node, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExReconfiguration ( UINT16 Opcode, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExCreateMutex ( ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExCreateProcessor ( ACPI_PARSE_OBJECT *Op, ACPI_NAMESPACE_NODE *ProcessorNode); ACPI_STATUS AcpiExCreatePowerResource ( ACPI_PARSE_OBJECT *Op, ACPI_NAMESPACE_NODE *PowerNode); ACPI_STATUS AcpiExCreateRegion ( UINT8 *AmlPtr, UINT32 AmlLength, UINT8 RegionSpace, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExCreateEvent ( ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExCreateAlias ( ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExCreateMethod ( UINT8 *AmlPtr, UINT32 AmlLength, UINT32 MethodFlags, ACPI_NAMESPACE_NODE *Method); /* * ammutex - mutex support */ ACPI_STATUS AcpiExAcquireMutex ( ACPI_OPERAND_OBJECT *TimeDesc, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExReleaseMutex ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExReleaseAllMutexes ( ACPI_OPERAND_OBJECT *MutexList); void AcpiExUnlinkMutex ( ACPI_OPERAND_OBJECT *ObjDesc); /* * amprep - ACPI AML (p-code) execution - prep utilities */ ACPI_STATUS AcpiExPrepCommonFieldObject ( ACPI_OPERAND_OBJECT *ObjDesc, UINT8 FieldFlags, UINT32 FieldPosition, UINT32 FieldLength); ACPI_STATUS AcpiExPrepRegionFieldValue ( ACPI_NAMESPACE_NODE *Node, ACPI_HANDLE Region, UINT8 FieldFlags, UINT32 FieldPosition, UINT32 FieldLength); ACPI_STATUS AcpiExPrepBankFieldValue ( ACPI_NAMESPACE_NODE *Node, ACPI_NAMESPACE_NODE *RegionNode, ACPI_NAMESPACE_NODE *BankRegisterNode, UINT32 BankVal, UINT8 FieldFlags, UINT32 FieldPosition, UINT32 FieldLength); ACPI_STATUS AcpiExPrepIndexFieldValue ( ACPI_NAMESPACE_NODE *Node, ACPI_NAMESPACE_NODE *IndexReg, ACPI_NAMESPACE_NODE *DataReg, UINT8 FieldFlags, UINT32 FieldPosition, UINT32 FieldLength); /* * amsystem - Interface to OS services */ ACPI_STATUS AcpiExSystemDoNotifyOp ( ACPI_OPERAND_OBJECT *Value, ACPI_OPERAND_OBJECT *ObjDesc); void AcpiExSystemDoSuspend( UINT32 Time); void AcpiExSystemDoStall ( UINT32 Time); ACPI_STATUS AcpiExSystemAcquireMutex( ACPI_OPERAND_OBJECT *Time, ACPI_OPERAND_OBJECT *ObjDesc); ACPI_STATUS AcpiExSystemReleaseMutex( ACPI_OPERAND_OBJECT *ObjDesc); ACPI_STATUS AcpiExSystemSignalEvent( ACPI_OPERAND_OBJECT *ObjDesc); ACPI_STATUS AcpiExSystemWaitEvent( ACPI_OPERAND_OBJECT *Time, ACPI_OPERAND_OBJECT *ObjDesc); ACPI_STATUS AcpiExSystemResetEvent( ACPI_OPERAND_OBJECT *ObjDesc); ACPI_STATUS AcpiExSystemWaitSemaphore ( ACPI_HANDLE Semaphore, UINT32 Timeout); /* * ammonadic - ACPI AML (p-code) execution, monadic operators */ ACPI_STATUS AcpiExMonadic1 ( UINT16 Opcode, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExMonadic2 ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc); ACPI_STATUS AcpiExMonadic2R ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc); /* * amdyadic - ACPI AML (p-code) execution, dyadic operators */ ACPI_STATUS AcpiExDyadic1 ( UINT16 Opcode, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExDyadic2 ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc); ACPI_STATUS AcpiExDyadic2R ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc); ACPI_STATUS AcpiExDyadic2S ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc); /* * amresolv - Object resolution and get value functions */ ACPI_STATUS AcpiExResolveToValue ( ACPI_OPERAND_OBJECT **StackPtr, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExResolveNodeToValue ( ACPI_NAMESPACE_NODE **StackPtr, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExResolveObjectToValue ( ACPI_OPERAND_OBJECT **StackPtr, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExGetBufferFieldValue ( ACPI_OPERAND_OBJECT *FieldDesc, ACPI_OPERAND_OBJECT *ResultDesc); /* * amdump - Scanner debug output routines */ void AcpiExShowHexValue ( UINT32 ByteCount, UINT8 *AmlPtr, UINT32 LeadSpace); ACPI_STATUS AcpiExDumpOperand ( ACPI_OPERAND_OBJECT *EntryDesc); void AcpiExDumpOperands ( ACPI_OPERAND_OBJECT **Operands, OPERATING_MODE InterpreterMode, NATIVE_CHAR *Ident, UINT32 NumLevels, NATIVE_CHAR *Note, NATIVE_CHAR *ModuleName, UINT32 LineNumber); void AcpiExDumpObjectDescriptor ( ACPI_OPERAND_OBJECT *Object, UINT32 Flags); void AcpiExDumpNode ( ACPI_NAMESPACE_NODE *Node, UINT32 Flags); /* * amnames - interpreter/scanner name load/execute */ NATIVE_CHAR * AcpiExAllocateNameString ( UINT32 PrefixCount, UINT32 NumNameSegs); UINT32 AcpiExGoodChar ( UINT32 Character); ACPI_STATUS AcpiExNameSegment ( UINT8 **InAmlAddress, NATIVE_CHAR *NameString); ACPI_STATUS AcpiExGetNameString ( ACPI_OBJECT_TYPE8 DataType, UINT8 *InAmlAddress, NATIVE_CHAR **OutNameString, UINT32 *OutNameLength); ACPI_STATUS AcpiExDoName ( ACPI_OBJECT_TYPE DataType, OPERATING_MODE LoadExecMode); /* * amstore - Object store support */ ACPI_STATUS AcpiExStore ( ACPI_OPERAND_OBJECT *ValDesc, ACPI_OPERAND_OBJECT *DestDesc, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExStoreObjectToIndex ( ACPI_OPERAND_OBJECT *ValDesc, ACPI_OPERAND_OBJECT *DestDesc, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExStoreObjectToNode ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_NAMESPACE_NODE *Node, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExStoreObjectToObject ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *DestDesc, ACPI_WALK_STATE *WalkState); /* * */ ACPI_STATUS AcpiExResolveObject ( ACPI_OPERAND_OBJECT **SourceDescPtr, ACPI_OBJECT_TYPE8 TargetType, ACPI_WALK_STATE *WalkState); ACPI_STATUS AcpiExStoreObject ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OBJECT_TYPE8 TargetType, ACPI_OPERAND_OBJECT **TargetDescPtr, ACPI_WALK_STATE *WalkState); /* * amcopy - object copy */ ACPI_STATUS AcpiExCopyBufferToBuffer ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc); ACPI_STATUS AcpiExCopyStringToString ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc); ACPI_STATUS AcpiExCopyIntegerToIndexField ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc); ACPI_STATUS AcpiExCopyIntegerToBankField ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc); ACPI_STATUS AcpiExCopyDataToNamedField ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_NAMESPACE_NODE *Node); ACPI_STATUS AcpiExCopyIntegerToBufferField ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc); /* * amutils - interpreter/scanner utilities */ ACPI_STATUS AcpiExEnterInterpreter ( void); void AcpiExExitInterpreter ( void); void AcpiExTruncateFor32bitTable ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState); BOOLEAN AcpiExValidateObjectType ( ACPI_OBJECT_TYPE Type); BOOLEAN AcpiExAcquireGlobalLock ( UINT32 Rule); ACPI_STATUS AcpiExReleaseGlobalLock ( BOOLEAN Locked); UINT32 AcpiExDigitsNeeded ( ACPI_INTEGER Value, UINT32 Base); ACPI_STATUS AcpiExEisaIdToString ( UINT32 NumericId, NATIVE_CHAR *OutString); ACPI_STATUS AcpiExUnsignedIntegerToString ( ACPI_INTEGER Value, NATIVE_CHAR *OutString); /* * amregion - default OpRegion handlers */ ACPI_STATUS AcpiExSystemMemorySpaceHandler ( UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT32 *Value, void *HandlerContext, void *RegionContext); ACPI_STATUS AcpiExSystemIoSpaceHandler ( UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT32 *Value, void *HandlerContext, void *RegionContext); ACPI_STATUS AcpiExPciConfigSpaceHandler ( UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT32 *Value, void *HandlerContext, void *RegionContext); ACPI_STATUS AcpiExEmbeddedControllerSpaceHandler ( UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT32 *Value, void *HandlerContext, void *RegionContext); ACPI_STATUS AcpiExSmBusSpaceHandler ( UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT32 *Value, void *HandlerContext, void *RegionContext); #endif /* __INTERP_H__ */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/aclocal.h =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/aclocal.h (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/aclocal.h (revision 82367) @@ -1,966 +1,1025 @@ /****************************************************************************** * * Name: aclocal.h - Internal data types used across the ACPI subsystem - * $Revision: 124 $ + * $Revision: 127 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #ifndef __ACLOCAL_H__ #define __ACLOCAL_H__ #define WAIT_FOREVER ((UINT32) -1) typedef void* ACPI_MUTEX; typedef UINT32 ACPI_MUTEX_HANDLE; #define ACPI_MEMORY_MODE 0x01 #define ACPI_LOGICAL_ADDRESSING 0x00 #define ACPI_PHYSICAL_ADDRESSING 0x01 /* Object descriptor types */ #define ACPI_CACHED_OBJECT 0x11 /* ORed in when object is cached */ #define ACPI_DESC_TYPE_STATE 0x22 #define ACPI_DESC_TYPE_WALK 0x44 #define ACPI_DESC_TYPE_PARSER 0x66 #define ACPI_DESC_TYPE_INTERNAL 0x88 #define ACPI_DESC_TYPE_NAMED 0xAA /***************************************************************************** * * Mutex typedefs and structs * ****************************************************************************/ /* * Predefined handles for the mutex objects used within the subsystem * All mutex objects are automatically created by AcpiUtMutexInitialize. * * The acquire/release ordering protocol is implied via this list. Mutexes * with a lower value must be acquired before mutexes with a higher value. * * NOTE: any changes here must be reflected in the AcpiGbl_MutexNames table also! */ #define ACPI_MTX_EXECUTE 0 #define ACPI_MTX_INTERPRETER 1 #define ACPI_MTX_PARSER 2 #define ACPI_MTX_DISPATCHER 3 #define ACPI_MTX_TABLES 4 #define ACPI_MTX_OP_REGIONS 5 #define ACPI_MTX_NAMESPACE 6 #define ACPI_MTX_EVENTS 7 #define ACPI_MTX_HARDWARE 8 #define ACPI_MTX_CACHES 9 #define ACPI_MTX_MEMORY 10 #define ACPI_MTX_DEBUG_CMD_COMPLETE 11 #define ACPI_MTX_DEBUG_CMD_READY 12 #define MAX_MTX 12 #define NUM_MTX MAX_MTX+1 #if defined(ACPI_DEBUG) || defined(ENABLE_DEBUGGER) #ifdef DEFINE_ACPI_GLOBALS /* Names for the mutexes used in the subsystem */ static NATIVE_CHAR *AcpiGbl_MutexNames[] = { "ACPI_MTX_Execute", "ACPI_MTX_Interpreter", "ACPI_MTX_Parser", "ACPI_MTX_Dispatcher", "ACPI_MTX_Tables", "ACPI_MTX_OpRegions", "ACPI_MTX_Namespace", "ACPI_MTX_Events", "ACPI_MTX_Hardware", "ACPI_MTX_Caches", "ACPI_MTX_Memory", "ACPI_MTX_DebugCmdComplete", "ACPI_MTX_DebugCmdReady", }; #endif #endif /* Table for the global mutexes */ typedef struct AcpiMutexInfo { ACPI_MUTEX Mutex; UINT32 UseCount; UINT32 OwnerId; } ACPI_MUTEX_INFO; /* This owner ID means that the mutex is not in use (unlocked) */ #define ACPI_MUTEX_NOT_ACQUIRED (UINT32) (-1) /* Lock flag parameter for various interfaces */ #define ACPI_MTX_DO_NOT_LOCK 0 #define ACPI_MTX_LOCK 1 typedef UINT16 ACPI_OWNER_ID; #define OWNER_TYPE_TABLE 0x0 #define OWNER_TYPE_METHOD 0x1 #define FIRST_METHOD_ID 0x0000 #define FIRST_TABLE_ID 0x8000 /* TBD: [Restructure] get rid of the need for this! */ #define TABLE_ID_DSDT (ACPI_OWNER_ID) 0x8000 /* Field access granularities */ #define ACPI_FIELD_BYTE_GRANULARITY 1 #define ACPI_FIELD_WORD_GRANULARITY 2 #define ACPI_FIELD_DWORD_GRANULARITY 4 #define ACPI_FIELD_QWORD_GRANULARITY 8 /***************************************************************************** * * Namespace typedefs and structs * ****************************************************************************/ /* Operational modes of the AML interpreter/scanner */ typedef enum { IMODE_LOAD_PASS1 = 0x01, IMODE_LOAD_PASS2 = 0x02, IMODE_EXECUTE = 0x0E } OPERATING_MODE; /* * The Node describes a named object that appears in the AML * An AcpiNode is used to store Nodes. * * DataType is used to differentiate between internal descriptors, and MUST * be the first byte in this structure. */ typedef struct acpi_node { UINT8 DataType; UINT8 Type; /* Type associated with this name */ UINT16 OwnerId; UINT32 Name; /* ACPI Name, always 4 chars per ACPI spec */ void *Object; /* Pointer to attached ACPI object (optional) */ struct acpi_node *Child; /* first child */ struct acpi_node *Peer; /* Next peer*/ UINT16 ReferenceCount; /* Current count of references and children */ UINT8 Flags; } ACPI_NAMESPACE_NODE; #define ENTRY_NOT_FOUND NULL /* Node flags */ #define ANOBJ_AML_ATTACHMENT 0x01 #define ANOBJ_END_OF_PEER_LIST 0x02 #define ANOBJ_DATA_WIDTH_32 0x04 /* Parent table is 64-bits */ #define ANOBJ_METHOD_ARG 0x08 #define ANOBJ_METHOD_LOCAL 0x10 #define ANOBJ_METHOD_NO_RETVAL 0x20 #define ANOBJ_METHOD_SOME_NO_RETVAL 0x40 #define ANOBJ_IS_BIT_OFFSET 0x80 /* * ACPI Table Descriptor. One per ACPI table */ typedef struct AcpiTableDesc { struct AcpiTableDesc *Prev; struct AcpiTableDesc *Next; struct AcpiTableDesc *InstalledDesc; ACPI_TABLE_HEADER *Pointer; void *BasePointer; UINT8 *AmlPointer; UINT64 PhysicalAddress; UINT32 AmlLength; UINT32 Length; UINT32 Count; ACPI_OWNER_ID TableId; UINT8 Type; UINT8 Allocation; BOOLEAN LoadedIntoNamespace; } ACPI_TABLE_DESC; typedef struct { NATIVE_CHAR *SearchFor; ACPI_HANDLE *List; UINT32 *Count; } FIND_CONTEXT; typedef struct { ACPI_NAMESPACE_NODE *Node; } NS_SEARCH_DATA; /* * Predefined Namespace items */ typedef struct { NATIVE_CHAR *Name; ACPI_OBJECT_TYPE8 Type; NATIVE_CHAR *Val; } PREDEFINED_NAMES; /* Object types used during package copies */ #define ACPI_COPY_TYPE_SIMPLE 0 #define ACPI_COPY_TYPE_PACKAGE 1 /* Info structure used to convert external<->internal namestrings */ typedef struct acpi_namestring_info { NATIVE_CHAR *ExternalName; NATIVE_CHAR *NextExternalChar; NATIVE_CHAR *InternalName; UINT32 Length; UINT32 NumSegments; UINT32 NumCarats; BOOLEAN FullyQualified; } ACPI_NAMESTRING_INFO; /***************************************************************************** * * Event typedefs and structs * ****************************************************************************/ /* Status bits. */ #define ACPI_STATUS_PMTIMER 0x0001 +#define ACPI_STATUS_BUSMASTER 0x0010 #define ACPI_STATUS_GLOBAL 0x0020 #define ACPI_STATUS_POWER_BUTTON 0x0100 #define ACPI_STATUS_SLEEP_BUTTON 0x0200 #define ACPI_STATUS_RTC_ALARM 0x0400 /* Enable bits. */ #define ACPI_ENABLE_PMTIMER 0x0001 #define ACPI_ENABLE_GLOBAL 0x0020 #define ACPI_ENABLE_POWER_BUTTON 0x0100 #define ACPI_ENABLE_SLEEP_BUTTON 0x0200 #define ACPI_ENABLE_RTC_ALARM 0x0400 /* * Entry in the AddressSpace (AKA Operation Region) table */ typedef struct { ACPI_ADR_SPACE_HANDLER Handler; void *Context; } ACPI_ADR_SPACE_INFO; /* Values and addresses of the GPE registers (both banks) */ typedef struct { UINT8 Status; /* Current value of status reg */ UINT8 Enable; /* Current value of enable reg */ UINT16 StatusAddr; /* Address of status reg */ UINT16 EnableAddr; /* Address of enable reg */ UINT8 GpeBase; /* Base GPE number */ } ACPI_GPE_REGISTERS; #define ACPI_GPE_LEVEL_TRIGGERED 1 #define ACPI_GPE_EDGE_TRIGGERED 2 /* Information about each particular GPE level */ typedef struct { UINT8 Type; /* Level or Edge */ ACPI_HANDLE MethodHandle; /* Method handle for direct (fast) execution */ ACPI_GPE_HANDLER Handler; /* Address of handler, if any */ void *Context; /* Context to be passed to handler */ } ACPI_GPE_LEVEL_INFO; /* Information about each particular fixed event */ typedef struct { ACPI_EVENT_HANDLER Handler; /* Address of handler. */ void *Context; /* Context to be passed to handler */ } ACPI_FIXED_EVENT_INFO; /* Information used during field processing */ typedef struct { UINT8 SkipField; UINT8 FieldFlag; UINT32 PkgLength; } ACPI_FIELD_INFO; /***************************************************************************** * * Generic "state" object for stacks * ****************************************************************************/ #define CONTROL_NORMAL 0xC0 #define CONTROL_CONDITIONAL_EXECUTING 0xC1 #define CONTROL_PREDICATE_EXECUTING 0xC2 #define CONTROL_PREDICATE_FALSE 0xC3 #define CONTROL_PREDICATE_TRUE 0xC4 /* Forward declarations */ struct acpi_walk_state; struct acpi_walk_list; struct acpi_parse_obj; struct acpi_obj_mutex; #define ACPI_STATE_COMMON /* Two 32-bit fields and a pointer */\ UINT8 DataType; /* To differentiate various internal objs */\ UINT8 Flags; \ UINT16 Value; \ UINT16 State; \ UINT16 AcpiEval; \ void *Next; \ typedef struct acpi_common_state { ACPI_STATE_COMMON } ACPI_COMMON_STATE; /* * Update state - used to traverse complex objects such as packages */ typedef struct acpi_update_state { ACPI_STATE_COMMON union acpi_operand_obj *Object; } ACPI_UPDATE_STATE; /* * Pkg state - used to traverse nested package structures */ typedef struct acpi_pkg_state { ACPI_STATE_COMMON union acpi_operand_obj *SourceObject; union acpi_operand_obj *DestObject; struct acpi_walk_state *WalkState; void *ThisTargetObj; UINT32 NumPackages; UINT16 Index; } ACPI_PKG_STATE; /* * Control state - one per if/else and while constructs. * Allows nesting of these constructs */ typedef struct acpi_control_state { ACPI_STATE_COMMON struct acpi_parse_obj *PredicateOp; UINT8 *AmlPredicateStart; /* Start of if/while predicate */ } ACPI_CONTROL_STATE; /* * Scope state - current scope during namespace lookups */ typedef struct acpi_scope_state { ACPI_STATE_COMMON ACPI_NAMESPACE_NODE *Node; } ACPI_SCOPE_STATE; typedef struct acpi_pscope_state { ACPI_STATE_COMMON struct acpi_parse_obj *Op; /* current op being parsed */ UINT8 *ArgEnd; /* current argument end */ UINT8 *PkgEnd; /* current package end */ UINT32 ArgList; /* next argument to parse */ UINT32 ArgCount; /* Number of fixed arguments */ } ACPI_PSCOPE_STATE; /* * Result values - used to accumulate the results of nested * AML arguments */ typedef struct acpi_result_values { ACPI_STATE_COMMON union acpi_operand_obj *ObjDesc [OBJ_NUM_OPERANDS]; UINT8 NumResults; UINT8 LastInsert; } ACPI_RESULT_VALUES; /* * Notify info - used to pass info to the deferred notify * handler/dispatcher. */ typedef struct acpi_notify_info { ACPI_STATE_COMMON ACPI_NAMESPACE_NODE *Node; union acpi_operand_obj *HandlerObj; } ACPI_NOTIFY_INFO; /* Generic state is union of structs above */ typedef union acpi_gen_state { ACPI_COMMON_STATE Common; ACPI_CONTROL_STATE Control; ACPI_UPDATE_STATE Update; ACPI_SCOPE_STATE Scope; ACPI_PSCOPE_STATE ParseScope; ACPI_PKG_STATE Pkg; ACPI_RESULT_VALUES Results; ACPI_NOTIFY_INFO Notify; } ACPI_GENERIC_STATE; typedef ACPI_STATUS (*ACPI_PARSE_DOWNWARDS) ( UINT16 Opcode, struct acpi_parse_obj *Op, struct acpi_walk_state *WalkState, struct acpi_parse_obj **OutOp); typedef ACPI_STATUS (*ACPI_PARSE_UPWARDS) ( struct acpi_walk_state *WalkState, struct acpi_parse_obj *Op); /***************************************************************************** * * Parser typedefs and structs * ****************************************************************************/ #define ACPI_OP_CLASS_MASK 0x1F #define ACPI_OP_ARGS_MASK 0x20 #define ACPI_OP_TYPE_MASK 0xC0 #define ACPI_OP_TYPE_OPCODE 0x00 #define ACPI_OP_TYPE_ASCII 0x40 #define ACPI_OP_TYPE_PREFIX 0x80 #define ACPI_OP_TYPE_UNKNOWN 0xC0 #define ACPI_GET_OP_CLASS(a) ((a)->Flags & ACPI_OP_CLASS_MASK) #define ACPI_GET_OP_ARGS(a) ((a)->Flags & ACPI_OP_ARGS_MASK) #define ACPI_GET_OP_TYPE(a) ((a)->Flags & ACPI_OP_TYPE_MASK) /* * AML opcode, name, and argument layout */ typedef struct acpi_opcode_info { UINT8 Flags; /* Opcode type, HasArgs flag */ UINT32 ParseArgs; /* Grammar/Parse time arguments */ UINT32 RuntimeArgs; /* Interpret time arguments */ #ifdef _OPCODE_NAMES NATIVE_CHAR *Name; /* op name (debug only) */ #endif } ACPI_OPCODE_INFO; typedef union acpi_parse_val { - UINT32 Integer; /* integer constant */ + ACPI_INTEGER Integer; /* integer constant (Up to 64 bits) */ + UINT64_STRUCT Integer64; /* Structure overlay for 2 32-bit Dwords */ + UINT32 Integer32; /* integer constant, 32 bits only */ + UINT16 Integer16; /* integer constant, 16 bits only */ + UINT8 Integer8; /* integer constant, 8 bits only */ UINT32 Size; /* bytelist or field size */ NATIVE_CHAR *String; /* NULL terminated string */ UINT8 *Buffer; /* buffer or string */ NATIVE_CHAR *Name; /* NULL terminated string */ struct acpi_parse_obj *Arg; /* arguments and contained ops */ } ACPI_PARSE_VALUE; #define ACPI_PARSE_COMMON \ UINT8 DataType; /* To differentiate various internal objs */\ UINT8 Flags; /* Type of Op */\ UINT16 Opcode; /* AML opcode */\ UINT32 AmlOffset; /* offset of declaration in AML */\ struct acpi_parse_obj *Parent; /* parent op */\ struct acpi_parse_obj *Next; /* next op */\ DEBUG_ONLY_MEMBERS (\ NATIVE_CHAR OpName[16]) /* op name (debug only) */\ /* NON-DEBUG members below: */\ ACPI_NAMESPACE_NODE *Node; /* for use by interpreter */\ ACPI_PARSE_VALUE Value; /* Value or args associated with the opcode */\ /* * generic operation (eg. If, While, Store) */ typedef struct acpi_parse_obj { ACPI_PARSE_COMMON } ACPI_PARSE_OBJECT; /* * Extended Op for named ops (Scope, Method, etc.), deferred ops (Methods and OpRegions), * and bytelists. */ typedef struct acpi_parse2_obj { ACPI_PARSE_COMMON UINT8 *Data; /* AML body or bytelist data */ UINT32 Length; /* AML length */ UINT32 Name; /* 4-byte name or zero if no name */ } ACPI_PARSE2_OBJECT; /* * Parse state - one state per parser invocation and each control * method. */ typedef struct acpi_parse_state { UINT8 *AmlStart; /* first AML byte */ UINT8 *Aml; /* next AML byte */ UINT8 *AmlEnd; /* (last + 1) AML byte */ UINT8 *PkgStart; /* current package begin */ UINT8 *PkgEnd; /* current package end */ ACPI_PARSE_OBJECT *StartOp; /* root of parse tree */ struct acpi_node *StartNode; ACPI_GENERIC_STATE *Scope; /* current scope */ struct acpi_parse_state *Next; } ACPI_PARSE_STATE; /***************************************************************************** * * Hardware and PNP * ****************************************************************************/ /* PCI */ #define PCI_ROOT_HID_STRING "PNP0A03" /* * The #define's and enum below establish an abstract way of identifying what * register block and register is to be accessed. Do not change any of the * values as they are used in switch statements and offset calculations. */ #define REGISTER_BLOCK_MASK 0xFF00 /* Register Block Id */ #define BIT_IN_REGISTER_MASK 0x00FF /* Bit Id in the Register Block Id */ #define BYTE_IN_REGISTER_MASK 0x00FF /* Register Offset in the Register Block */ #define REGISTER_BLOCK_ID(RegId) (RegId & REGISTER_BLOCK_MASK) #define REGISTER_BIT_ID(RegId) (RegId & BIT_IN_REGISTER_MASK) #define REGISTER_OFFSET(RegId) (RegId & BYTE_IN_REGISTER_MASK) /* * Access Rule * To access a Register Bit: * -> Use Bit Name (= Register Block Id | Bit Id) defined in the enum. * * To access a Register: * -> Use Register Id (= Register Block Id | Register Offset) */ /* * Register Block Id */ #define PM1_STS 0x0100 #define PM1_EN 0x0200 #define PM1_CONTROL 0x0300 #define PM1A_CONTROL 0x0400 #define PM1B_CONTROL 0x0500 #define PM2_CONTROL 0x0600 #define PM_TIMER 0x0700 #define PROCESSOR_BLOCK 0x0800 #define GPE0_STS_BLOCK 0x0900 #define GPE0_EN_BLOCK 0x0A00 #define GPE1_STS_BLOCK 0x0B00 #define GPE1_EN_BLOCK 0x0C00 #define SMI_CMD_BLOCK 0x0D00 /* * Address space bitmasks for mmio or io spaces */ #define SMI_CMD_ADDRESS_SPACE 0x01 #define PM1_BLK_ADDRESS_SPACE 0x02 #define PM2_CNT_BLK_ADDRESS_SPACE 0x04 #define PM_TMR_BLK_ADDRESS_SPACE 0x08 #define GPE0_BLK_ADDRESS_SPACE 0x10 #define GPE1_BLK_ADDRESS_SPACE 0x20 /* * Control bit definitions */ #define TMR_STS (PM1_STS | 0x01) #define BM_STS (PM1_STS | 0x02) #define GBL_STS (PM1_STS | 0x03) #define PWRBTN_STS (PM1_STS | 0x04) #define SLPBTN_STS (PM1_STS | 0x05) #define RTC_STS (PM1_STS | 0x06) #define WAK_STS (PM1_STS | 0x07) #define TMR_EN (PM1_EN | 0x01) /* no BM_EN */ #define GBL_EN (PM1_EN | 0x03) #define PWRBTN_EN (PM1_EN | 0x04) #define SLPBTN_EN (PM1_EN | 0x05) #define RTC_EN (PM1_EN | 0x06) #define WAK_EN (PM1_EN | 0x07) #define SCI_EN (PM1_CONTROL | 0x01) #define BM_RLD (PM1_CONTROL | 0x02) #define GBL_RLS (PM1_CONTROL | 0x03) #define SLP_TYPE_A (PM1_CONTROL | 0x04) #define SLP_TYPE_B (PM1_CONTROL | 0x05) #define SLP_EN (PM1_CONTROL | 0x06) #define ARB_DIS (PM2_CONTROL | 0x01) #define TMR_VAL (PM_TIMER | 0x01) #define GPE0_STS (GPE0_STS_BLOCK | 0x01) #define GPE0_EN (GPE0_EN_BLOCK | 0x01) #define GPE1_STS (GPE1_STS_BLOCK | 0x01) #define GPE1_EN (GPE1_EN_BLOCK | 0x01) #define TMR_STS_MASK 0x0001 #define BM_STS_MASK 0x0010 #define GBL_STS_MASK 0x0020 #define PWRBTN_STS_MASK 0x0100 #define SLPBTN_STS_MASK 0x0200 #define RTC_STS_MASK 0x0400 #define WAK_STS_MASK 0x8000 #define ALL_FIXED_STS_BITS (TMR_STS_MASK | BM_STS_MASK | GBL_STS_MASK \ | PWRBTN_STS_MASK | SLPBTN_STS_MASK \ | RTC_STS_MASK | WAK_STS_MASK) #define TMR_EN_MASK 0x0001 #define GBL_EN_MASK 0x0020 #define PWRBTN_EN_MASK 0x0100 #define SLPBTN_EN_MASK 0x0200 #define RTC_EN_MASK 0x0400 #define SCI_EN_MASK 0x0001 #define BM_RLD_MASK 0x0002 #define GBL_RLS_MASK 0x0004 #define SLP_TYPE_X_MASK 0x1C00 #define SLP_EN_MASK 0x2000 #define ARB_DIS_MASK 0x0001 #define TMR_VAL_MASK 0xFFFFFFFF #define GPE0_STS_MASK #define GPE0_EN_MASK #define GPE1_STS_MASK #define GPE1_EN_MASK #define ACPI_READ 1 #define ACPI_WRITE 2 /***************************************************************************** * * Resource descriptors * ****************************************************************************/ /* ResourceType values */ #define RESOURCE_TYPE_MEMORY_RANGE 0 #define RESOURCE_TYPE_IO_RANGE 1 #define RESOURCE_TYPE_BUS_NUMBER_RANGE 2 /* Resource descriptor types and masks */ #define RESOURCE_DESC_TYPE_LARGE 0x80 #define RESOURCE_DESC_TYPE_SMALL 0x00 #define RESOURCE_DESC_TYPE_MASK 0x80 #define RESOURCE_DESC_SMALL_MASK 0x78 /* Only bits 6:3 contain the type */ /* * Small resource descriptor types * Note: The 3 length bits (2:0) must be zero */ #define RESOURCE_DESC_IRQ_FORMAT 0x20 #define RESOURCE_DESC_DMA_FORMAT 0x28 #define RESOURCE_DESC_START_DEPENDENT 0x30 #define RESOURCE_DESC_END_DEPENDENT 0x38 #define RESOURCE_DESC_IO_PORT 0x40 #define RESOURCE_DESC_FIXED_IO_PORT 0x48 #define RESOURCE_DESC_SMALL_VENDOR 0x70 #define RESOURCE_DESC_END_TAG 0x78 /* * Large resource descriptor types */ #define RESOURCE_DESC_MEMORY_24 0x81 #define RESOURCE_DESC_GENERAL_REGISTER 0x82 #define RESOURCE_DESC_LARGE_VENDOR 0x84 #define RESOURCE_DESC_MEMORY_32 0x85 #define RESOURCE_DESC_FIXED_MEMORY_32 0x86 #define RESOURCE_DESC_DWORD_ADDRESS_SPACE 0x87 #define RESOURCE_DESC_WORD_ADDRESS_SPACE 0x88 #define RESOURCE_DESC_EXTENDED_XRUPT 0x89 #define RESOURCE_DESC_QWORD_ADDRESS_SPACE 0x8A /* String version of device HIDs and UIDs */ #define ACPI_DEVICE_ID_LENGTH 0x09 typedef struct { - NATIVE_CHAR Buffer[ACPI_DEVICE_ID_LENGTH]; + char Buffer[ACPI_DEVICE_ID_LENGTH]; } ACPI_DEVICE_ID; /***************************************************************************** * + * Miscellaneous + * + ****************************************************************************/ + +#define ASCII_ZERO 0x30 + +/***************************************************************************** + * * Debugger * ****************************************************************************/ typedef struct dbmethodinfo { ACPI_HANDLE ThreadGate; NATIVE_CHAR *Name; NATIVE_CHAR **Args; UINT32 Flags; UINT32 NumLoops; NATIVE_CHAR Pathname[128]; } DB_METHOD_INFO; /***************************************************************************** * * Debug * ****************************************************************************/ /* Entry for a memory allocation (debug only) */ -#ifdef ACPI_DEBUG #define MEM_MALLOC 0 #define MEM_CALLOC 1 #define MAX_MODULE_NAME 16 -typedef struct AcpiAllocationInfo -{ - struct AcpiAllocationInfo *Previous; - struct AcpiAllocationInfo *Next; - void *Address; - UINT32 Size; - UINT32 Component; - UINT32 Line; - NATIVE_CHAR Module[MAX_MODULE_NAME]; +#define ACPI_COMMON_DEBUG_MEM_HEADER \ + struct AcpiDebugMemBlock *Previous; \ + struct AcpiDebugMemBlock *Next; \ + UINT32 Size; \ + UINT32 Component; \ + UINT32 Line; \ + NATIVE_CHAR Module[MAX_MODULE_NAME]; \ UINT8 AllocType; -} ACPI_ALLOCATION_INFO; +typedef struct +{ + ACPI_COMMON_DEBUG_MEM_HEADER + +} ACPI_DEBUG_MEM_HEADER; + +typedef struct AcpiDebugMemBlock +{ + ACPI_COMMON_DEBUG_MEM_HEADER + UINT64 UserSpace; + +} ACPI_DEBUG_MEM_BLOCK; + + + +#define ACPI_MEM_LIST_GLOBAL 0 +#define ACPI_MEM_LIST_NSNODE 1 + +#define ACPI_MEM_LIST_FIRST_CACHE_LIST 2 +#define ACPI_MEM_LIST_STATE 2 +#define ACPI_MEM_LIST_PSNODE 3 +#define ACPI_MEM_LIST_PSNODE_EXT 4 +#define ACPI_MEM_LIST_OPERAND 5 +#define ACPI_MEM_LIST_WALK 6 +#define ACPI_MEM_LIST_MAX 6 +#define ACPI_NUM_MEM_LISTS 7 + + +typedef struct +{ + void *ListHead; + UINT16 LinkOffset; + UINT16 MaxCacheDepth; + UINT16 CacheDepth; + UINT16 ObjectSize; + +#ifdef ACPI_DBG_TRACK_ALLOCATIONS + + /* Statistics for debug memory tracking only */ + + UINT32 TotalAllocated; + UINT32 TotalFreed; + UINT32 CurrentTotalSize; + UINT32 CacheRequests; + UINT32 CacheHits; + char *ListName; #endif + +} ACPI_MEMORY_LIST; + + #endif /* __ACLOCAL_H__ */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/acmacros.h =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/acmacros.h (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/acmacros.h (revision 82367) @@ -1,727 +1,681 @@ /****************************************************************************** * * Name: acmacros.h - C macros for the entire subsystem. - * $Revision: 80 $ + * $Revision: 86 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #ifndef __ACMACROS_H__ #define __ACMACROS_H__ /* * Data manipulation macros */ #ifndef LOWORD #define LOWORD(l) ((UINT16)(NATIVE_UINT)(l)) #endif #ifndef HIWORD #define HIWORD(l) ((UINT16)((((NATIVE_UINT)(l)) >> 16) & 0xFFFF)) #endif #ifndef LOBYTE #define LOBYTE(l) ((UINT8)(UINT16)(l)) #endif #ifndef HIBYTE #define HIBYTE(l) ((UINT8)((((UINT16)(l)) >> 8) & 0xFF)) #endif #define BIT0(x) ((((x) & 0x01) > 0) ? 1 : 0) #define BIT1(x) ((((x) & 0x02) > 0) ? 1 : 0) #define BIT2(x) ((((x) & 0x04) > 0) ? 1 : 0) #define BIT3(x) ((((x) & 0x08) > 0) ? 1 : 0) #define BIT4(x) ((((x) & 0x10) > 0) ? 1 : 0) #define BIT5(x) ((((x) & 0x20) > 0) ? 1 : 0) #define BIT6(x) ((((x) & 0x40) > 0) ? 1 : 0) #define BIT7(x) ((((x) & 0x80) > 0) ? 1 : 0) #define LOW_BASE(w) ((UINT16) ((w) & 0x0000FFFF)) #define MID_BASE(b) ((UINT8) (((b) & 0x00FF0000) >> 16)) #define HI_BASE(b) ((UINT8) (((b) & 0xFF000000) >> 24)) #define LOW_LIMIT(w) ((UINT16) ((w) & 0x0000FFFF)) #define HI_LIMIT(b) ((UINT8) (((b) & 0x00FF0000) >> 16)) #ifdef _IA16 /* * For 16-bit addresses, we have to assume that the upper 32 bits * are zero. */ #ifndef LODWORD #define LODWORD(l) (l) #endif #ifndef HIDWORD #define HIDWORD(l) (0) #endif #define ACPI_GET_ADDRESS(a) ((a).Lo) #define ACPI_STORE_ADDRESS(a,b) {(a).Hi=0;(a).Lo=(b);} #define ACPI_VALID_ADDRESS(a) ((a).Hi | (a).Lo) #else +#ifdef ACPI_NO_INTEGER64_SUPPORT /* - * Full 64-bit address on 32-bit and 64-bit platforms + * ACPI_INTEGER is 32-bits, no 64-bit support on this platform */ #ifndef LODWORD +#define LODWORD(l) ((UINT32)(l)) +#endif + +#ifndef HIDWORD +#define HIDWORD(l) (0) +#endif + +#define ACPI_GET_ADDRESS(a) (a) +#define ACPI_STORE_ADDRESS(a,b) ((a)=(b)) +#define ACPI_VALID_ADDRESS(a) (a) + +#else + +/* + * Full 64-bit address/integer on both 32-bit and 64-bit platforms + */ +#ifndef LODWORD #define LODWORD(l) ((UINT32)(UINT64)(l)) #endif #ifndef HIDWORD -#define HIDWORD(l) ((UINT32)((((UINT64)(l)) >> 32) & 0xFFFFFFFF)) +#define HIDWORD(l) ((UINT32)(((*(UINT64_STRUCT *)(&l))).Hi)) #endif #define ACPI_GET_ADDRESS(a) (a) #define ACPI_STORE_ADDRESS(a,b) ((a)=(b)) #define ACPI_VALID_ADDRESS(a) (a) #endif +#endif /* * Extract a byte of data using a pointer. Any more than a byte and we * get into potential aligment issues -- see the STORE macros below */ #define GET8(addr) (*(UINT8*)(addr)) /* Pointer arithmetic */ #define POINTER_ADD(t,a,b) (t *) ((NATIVE_UINT)(a) + (NATIVE_UINT)(b)) #define POINTER_DIFF(a,b) ((UINT32) ((NATIVE_UINT)(a) - (NATIVE_UINT)(b))) /* * Macros for moving data around to/from buffers that are possibly unaligned. * If the hardware supports the transfer of unaligned data, just do the store. * Otherwise, we have to move one byte at a time. */ #ifdef _HW_ALIGNMENT_SUPPORT /* The hardware supports unaligned transfers, just do the move */ #define MOVE_UNALIGNED16_TO_16(d,s) *(UINT16*)(d) = *(UINT16*)(s) #define MOVE_UNALIGNED32_TO_32(d,s) *(UINT32*)(d) = *(UINT32*)(s) #define MOVE_UNALIGNED16_TO_32(d,s) *(UINT32*)(d) = *(UINT16*)(s) #define MOVE_UNALIGNED64_TO_64(d,s) *(UINT64*)(d) = *(UINT64*)(s) #else /* * The hardware does not support unaligned transfers. We must move the * data one byte at a time. These macros work whether the source or * the destination (or both) is/are unaligned. */ #define MOVE_UNALIGNED16_TO_16(d,s) {((UINT8 *)(d))[0] = ((UINT8 *)(s))[0];\ ((UINT8 *)(d))[1] = ((UINT8 *)(s))[1];} #define MOVE_UNALIGNED32_TO_32(d,s) {((UINT8 *)(d))[0] = ((UINT8 *)(s))[0];\ ((UINT8 *)(d))[1] = ((UINT8 *)(s))[1];\ ((UINT8 *)(d))[2] = ((UINT8 *)(s))[2];\ ((UINT8 *)(d))[3] = ((UINT8 *)(s))[3];} #define MOVE_UNALIGNED16_TO_32(d,s) {(*(UINT32*)(d)) = 0; MOVE_UNALIGNED16_TO_16(d,s);} #define MOVE_UNALIGNED64_TO_64(d,s) {((UINT8 *)(d))[0] = ((UINT8 *)(s))[0];\ ((UINT8 *)(d))[1] = ((UINT8 *)(s))[1];\ ((UINT8 *)(d))[2] = ((UINT8 *)(s))[2];\ ((UINT8 *)(d))[3] = ((UINT8 *)(s))[3];\ ((UINT8 *)(d))[4] = ((UINT8 *)(s))[4];\ ((UINT8 *)(d))[5] = ((UINT8 *)(s))[5];\ ((UINT8 *)(d))[6] = ((UINT8 *)(s))[6];\ ((UINT8 *)(d))[7] = ((UINT8 *)(s))[7];} #endif /* * Fast power-of-two math macros for non-optimized compilers */ #define _DIV(value,PowerOf2) ((UINT32) ((value) >> (PowerOf2))) #define _MUL(value,PowerOf2) ((UINT32) ((value) << (PowerOf2))) #define _MOD(value,Divisor) ((UINT32) ((value) & ((Divisor) -1))) #define DIV_2(a) _DIV(a,1) #define MUL_2(a) _MUL(a,1) #define MOD_2(a) _MOD(a,2) #define DIV_4(a) _DIV(a,2) #define MUL_4(a) _MUL(a,2) #define MOD_4(a) _MOD(a,4) #define DIV_8(a) _DIV(a,3) #define MUL_8(a) _MUL(a,3) #define MOD_8(a) _MOD(a,8) #define DIV_16(a) _DIV(a,4) #define MUL_16(a) _MUL(a,4) #define MOD_16(a) _MOD(a,16) /* * Divide and Modulo */ #define ACPI_DIVIDE(n,d) ((n) / (d)) #define ACPI_MODULO(n,d) ((n) % (d)) /* * Rounding macros (Power of two boundaries only) */ #define ROUND_DOWN(value,boundary) ((value) & (~((boundary)-1))) #define ROUND_UP(value,boundary) (((value) + ((boundary)-1)) & (~((boundary)-1))) #define ROUND_DOWN_TO_32_BITS(a) ROUND_DOWN(a,4) #define ROUND_DOWN_TO_64_BITS(a) ROUND_DOWN(a,8) #define ROUND_DOWN_TO_NATIVE_WORD(a) ROUND_DOWN(a,ALIGNED_ADDRESS_BOUNDARY) #define ROUND_UP_TO_32BITS(a) ROUND_UP(a,4) #define ROUND_UP_TO_64BITS(a) ROUND_UP(a,8) #define ROUND_UP_TO_NATIVE_WORD(a) ROUND_UP(a,ALIGNED_ADDRESS_BOUNDARY) #define ROUND_PTR_UP_TO_4(a,b) ((b *)(((NATIVE_UINT)(a) + 3) & ~3)) #define ROUND_PTR_UP_TO_8(a,b) ((b *)(((NATIVE_UINT)(a) + 7) & ~7)) #define ROUND_BITS_UP_TO_BYTES(a) DIV_8((a) + 7) #define ROUND_BITS_DOWN_TO_BYTES(a) DIV_8((a)) #define ROUND_UP_TO_1K(a) (((a) + 1023) >> 10) /* Generic (non-power-of-two) rounding */ #define ROUND_UP_TO(value,boundary) (((value) + ((boundary)-1)) / (boundary)) /* * Bitmask creation * Bit positions start at zero. * MASK_BITS_ABOVE creates a mask starting AT the position and above * MASK_BITS_BELOW creates a mask starting one bit BELOW the position */ #define MASK_BITS_ABOVE(position) (~(((UINT32)(-1)) << ((UINT32) (position)))) #define MASK_BITS_BELOW(position) (((UINT32)(-1)) << ((UINT32) (position))) /* Macros for GAS addressing */ #ifndef _IA16 #define ACPI_PCI_DEVICE_MASK (UINT64) 0x0000FFFF00000000 #define ACPI_PCI_FUNCTION_MASK (UINT64) 0x00000000FFFF0000 #define ACPI_PCI_REGISTER_MASK (UINT64) 0x000000000000FFFF #define ACPI_PCI_FUNCTION(a) (UINT16) ((((a) & ACPI_PCI_FUNCTION_MASK) >> 16)) #define ACPI_PCI_DEVICE(a) (UINT16) ((((a) & ACPI_PCI_DEVICE_MASK) >> 32)) #define ACPI_PCI_REGISTER(a) (UINT16) (((a) & ACPI_PCI_REGISTER_MASK)) #else /* No support for GAS and PCI IDs in 16-bit mode */ #define ACPI_PCI_FUNCTION(a) (UINT16) ((a) & 0xFFFF0000) #define ACPI_PCI_DEVICE(a) (UINT16) ((a) & 0x0000FFFF) #define ACPI_PCI_REGISTER(a) (UINT16) ((a) & 0x0000FFFF) #endif /* * An ACPI_HANDLE (which is actually an ACPI_NAMESPACE_NODE *) can appear in some contexts, * such as on apObjStack, where a pointer to an ACPI_OPERAND_OBJECT can also * appear. This macro is used to distinguish them. * * The DataType field is the first field in both structures. */ #define VALID_DESCRIPTOR_TYPE(d,t) (((ACPI_NAMESPACE_NODE *)d)->DataType == t) /* Macro to test the object type */ #define IS_THIS_OBJECT_TYPE(d,t) (((ACPI_OPERAND_OBJECT *)d)->Common.Type == (UINT8)t) /* Macro to check the table flags for SINGLE or MULTIPLE tables are allowed */ #define IS_SINGLE_TABLE(x) (((x) & 0x01) == ACPI_TABLE_SINGLE ? 1 : 0) /* Check if ACPI has been initialized properly */ #define ACPI_IS_INITIALIZATION_COMPLETE(s) {if (AcpiGbl_RootNode) s = AE_OK; else s=AE_NO_NAMESPACE;} /* * Macro to check if a pointer is within an ACPI table. * Parameter (a) is the pointer to check. Parameter (b) must be defined * as a pointer to an ACPI_TABLE_HEADER. (b+1) then points past the header, * and ((UINT8 *)b+b->Length) points one byte past the end of the table. */ #ifndef _IA16 #define IS_IN_ACPI_TABLE(a,b) (((UINT8 *)(a) >= (UINT8 *)(b + 1)) &&\ ((UINT8 *)(a) < ((UINT8 *)b + b->Length))) #else #define IS_IN_ACPI_TABLE(a,b) (_segment)(a) == (_segment)(b) &&\ (((UINT8 *)(a) >= (UINT8 *)(b + 1)) &&\ ((UINT8 *)(a) < ((UINT8 *)b + b->Length))) #endif /* * Macros for the master AML opcode table */ #ifdef ACPI_DEBUG #define OP_INFO_ENTRY(Flags,Name,PArgs,IArgs) {Flags,PArgs,IArgs,Name} #else #define OP_INFO_ENTRY(Flags,Name,PArgs,IArgs) {Flags,PArgs,IArgs} #endif #define ARG_TYPE_WIDTH 5 #define ARG_1(x) ((UINT32)(x)) #define ARG_2(x) ((UINT32)(x) << (1 * ARG_TYPE_WIDTH)) #define ARG_3(x) ((UINT32)(x) << (2 * ARG_TYPE_WIDTH)) #define ARG_4(x) ((UINT32)(x) << (3 * ARG_TYPE_WIDTH)) #define ARG_5(x) ((UINT32)(x) << (4 * ARG_TYPE_WIDTH)) #define ARG_6(x) ((UINT32)(x) << (5 * ARG_TYPE_WIDTH)) #define ARGI_LIST1(a) (ARG_1(a)) #define ARGI_LIST2(a,b) (ARG_1(b)|ARG_2(a)) #define ARGI_LIST3(a,b,c) (ARG_1(c)|ARG_2(b)|ARG_3(a)) #define ARGI_LIST4(a,b,c,d) (ARG_1(d)|ARG_2(c)|ARG_3(b)|ARG_4(a)) #define ARGI_LIST5(a,b,c,d,e) (ARG_1(e)|ARG_2(d)|ARG_3(c)|ARG_4(b)|ARG_5(a)) #define ARGI_LIST6(a,b,c,d,e,f) (ARG_1(f)|ARG_2(e)|ARG_3(d)|ARG_4(c)|ARG_5(b)|ARG_6(a)) #define ARGP_LIST1(a) (ARG_1(a)) #define ARGP_LIST2(a,b) (ARG_1(a)|ARG_2(b)) #define ARGP_LIST3(a,b,c) (ARG_1(a)|ARG_2(b)|ARG_3(c)) #define ARGP_LIST4(a,b,c,d) (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)) #define ARGP_LIST5(a,b,c,d,e) (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)|ARG_5(e)) #define ARGP_LIST6(a,b,c,d,e,f) (ARG_1(a)|ARG_2(b)|ARG_3(c)|ARG_4(d)|ARG_5(e)|ARG_6(f)) #define GET_CURRENT_ARG_TYPE(List) (List & ((UINT32) 0x1F)) #define INCREMENT_ARG_LIST(List) (List >>= ((UINT32) ARG_TYPE_WIDTH)) /* * Build a GAS structure from earlier ACPI table entries (V1.0 and 0.71 extensions) * * 1) Address space * 2) Length in bytes -- convert to length in bits * 3) Bit offset is zero * 4) Reserved field is zero * 5) Expand address to 64 bits */ #define ASL_BUILD_GAS_FROM_ENTRY(a,b,c,d) {a.AddressSpaceId = (UINT8) d;\ a.RegisterBitWidth = (UINT8) MUL_8 (b);\ a.RegisterBitOffset = 0;\ a.Reserved = 0;\ ACPI_STORE_ADDRESS (a.Address,c);} /* ACPI V1.0 entries -- address space is always I/O */ #define ASL_BUILD_GAS_FROM_V1_ENTRY(a,b,c) ASL_BUILD_GAS_FROM_ENTRY(a,b,c,ACPI_ADR_SPACE_SYSTEM_IO) /* * Reporting macros that are never compiled out */ #define PARAM_LIST(pl) pl /* * Error reporting. These versions add callers module and line#. Since * _THIS_MODULE gets compiled out when ACPI_DEBUG isn't defined, only * use it in debug mode. */ #ifdef ACPI_DEBUG #define REPORT_INFO(fp) {_ReportInfo(_THIS_MODULE,__LINE__,_COMPONENT); \ - DebugPrintRaw PARAM_LIST(fp);} + AcpiOsPrintf PARAM_LIST(fp);} #define REPORT_ERROR(fp) {_ReportError(_THIS_MODULE,__LINE__,_COMPONENT); \ - DebugPrintRaw PARAM_LIST(fp);} + AcpiOsPrintf PARAM_LIST(fp);} #define REPORT_WARNING(fp) {_ReportWarning(_THIS_MODULE,__LINE__,_COMPONENT); \ - DebugPrintRaw PARAM_LIST(fp);} + AcpiOsPrintf PARAM_LIST(fp);} #else #define REPORT_INFO(fp) {_ReportInfo("ACPI",__LINE__,_COMPONENT); \ - DebugPrintRaw PARAM_LIST(fp);} + AcpiOsPrintf PARAM_LIST(fp);} #define REPORT_ERROR(fp) {_ReportError("ACPI",__LINE__,_COMPONENT); \ - DebugPrintRaw PARAM_LIST(fp);} + AcpiOsPrintf PARAM_LIST(fp);} #define REPORT_WARNING(fp) {_ReportWarning("ACPI",__LINE__,_COMPONENT); \ - DebugPrintRaw PARAM_LIST(fp);} + AcpiOsPrintf PARAM_LIST(fp);} #endif /* Error reporting. These versions pass thru the module and line# */ #define _REPORT_INFO(a,b,c,fp) {_ReportInfo(a,b,c); \ - DebugPrintRaw PARAM_LIST(fp);} + AcpiOsPrintf PARAM_LIST(fp);} #define _REPORT_ERROR(a,b,c,fp) {_ReportError(a,b,c); \ - DebugPrintRaw PARAM_LIST(fp);} + AcpiOsPrintf PARAM_LIST(fp);} #define _REPORT_WARNING(a,b,c,fp) {_ReportWarning(a,b,c); \ - DebugPrintRaw PARAM_LIST(fp);} + AcpiOsPrintf PARAM_LIST(fp);} /* Buffer dump macros */ #define DUMP_BUFFER(a,b) AcpiUtDumpBuffer((UINT8 *)a,b,DB_BYTE_DISPLAY,_COMPONENT) /* * Debug macros that are conditionally compiled */ #ifdef ACPI_DEBUG #define MODULE_NAME(name) static char *_THIS_MODULE = name; /* * Function entry tracing. * The first parameter should be the procedure name as a quoted string. This is declared * as a local string ("_ProcName) so that it can be also used by the function exit macros below. */ #define PROC_NAME(a) char * _ProcName = a; #define FUNCTION_TRACE(a) char * _ProcName = a;\ FunctionTrace(_THIS_MODULE,__LINE__,_COMPONENT,a) #define FUNCTION_TRACE_PTR(a,b) char * _ProcName = a;\ FunctionTracePtr(_THIS_MODULE,__LINE__,_COMPONENT,a,(void *)b) #define FUNCTION_TRACE_U32(a,b) char * _ProcName = a;\ FunctionTraceU32(_THIS_MODULE,__LINE__,_COMPONENT,a,(UINT32)b) #define FUNCTION_TRACE_STR(a,b) char * _ProcName = a;\ FunctionTraceStr(_THIS_MODULE,__LINE__,_COMPONENT,a,(NATIVE_CHAR *)b) /* * Function exit tracing. * WARNING: These macros include a return statement. This is usually considered * bad form, but having a separate exit macro is very ugly and difficult to maintain. * One of the FUNCTION_TRACE macros above must be used in conjunction with these macros * so that "_ProcName" is defined. */ #define return_VOID {FunctionExit(_THIS_MODULE,__LINE__,_COMPONENT,_ProcName);return;} #define return_ACPI_STATUS(s) {FunctionStatusExit(_THIS_MODULE,__LINE__,_COMPONENT,_ProcName,s);return(s);} #define return_VALUE(s) {FunctionValueExit(_THIS_MODULE,__LINE__,_COMPONENT,_ProcName,s);return(s);} #define return_PTR(s) {FunctionPtrExit(_THIS_MODULE,__LINE__,_COMPONENT,_ProcName,(UINT8 *)s);return(s);} /* Conditional execution */ #define DEBUG_EXEC(a) a #define NORMAL_EXEC(a) #define DEBUG_DEFINE(a) a; #define DEBUG_ONLY_MEMBERS(a) a; #define _OPCODE_NAMES #define _VERBOSE_STRUCTURES /* Stack and buffer dumping */ #define DUMP_STACK_ENTRY(a) AcpiExDumpOperand(a) #define DUMP_OPERANDS(a,b,c,d,e) AcpiExDumpOperands(a,b,c,d,e,_THIS_MODULE,__LINE__) #define DUMP_ENTRY(a,b) AcpiNsDumpEntry (a,b) #define DUMP_TABLES(a,b) AcpiNsDumpTables(a,b) #define DUMP_PATHNAME(a,b,c,d) AcpiNsDumpPathname(a,b,c,d) #define DUMP_RESOURCE_LIST(a) AcpiRsDumpResourceList(a) #define BREAK_MSG(a) AcpiOsSignal (ACPI_SIGNAL_BREAKPOINT,(a)) /* * Generate INT3 on ACPI_ERROR (Debug only!) */ #define ERROR_BREAK #ifdef ERROR_BREAK #define BREAK_ON_ERROR(lvl) if ((lvl)&ACPI_ERROR) AcpiOsSignal(ACPI_SIGNAL_BREAKPOINT,"Fatal error encountered\n") #else #define BREAK_ON_ERROR(lvl) #endif /* * Master debug print macros * Print iff: * 1) Debug print for the current component is enabled * 2) Debug error level or trace level for the print statement is enabled - * */ -#define TEST_DEBUG_SWITCH(lvl) if (((lvl) & AcpiDbgLevel) && (_COMPONENT & AcpiDbgLayer)) +#define ACPI_DEBUG_PRINT(pl) AcpiUtDebugPrint PARAM_LIST(pl) +#define ACPI_DEBUG_PRINT_RAW(pl) AcpiUtDebugPrintRaw PARAM_LIST(pl) -#define DEBUG_PRINT(lvl,fp) TEST_DEBUG_SWITCH(lvl) {\ - DebugPrintPrefix (_THIS_MODULE,__LINE__);\ - DebugPrintRaw PARAM_LIST(fp);\ - BREAK_ON_ERROR(lvl);} -#define DEBUG_PRINTP(lvl,fp) TEST_DEBUG_SWITCH(lvl) {\ - DebugPrintPrefix (_THIS_MODULE,__LINE__);\ - DebugPrintRaw ("%s: ",_ProcName);\ - DebugPrintRaw PARAM_LIST(fp);\ - BREAK_ON_ERROR(lvl);} - -#define DEBUG_PRINT_RAW(lvl,fp) TEST_DEBUG_SWITCH(lvl) {\ - DebugPrintRaw PARAM_LIST(fp);} - #else /* * This is the non-debug case -- make everything go away, * leaving no executable debug code! */ #define MODULE_NAME(name) #define _THIS_MODULE "" #define DEBUG_EXEC(a) #define NORMAL_EXEC(a) a; #define DEBUG_DEFINE(a) #define DEBUG_ONLY_MEMBERS(a) #define PROC_NAME(a) #define FUNCTION_TRACE(a) #define FUNCTION_TRACE_PTR(a,b) #define FUNCTION_TRACE_U32(a,b) #define FUNCTION_TRACE_STR(a,b) #define FUNCTION_EXIT #define FUNCTION_STATUS_EXIT(s) #define FUNCTION_VALUE_EXIT(s) #define DUMP_STACK_ENTRY(a) #define DUMP_OPERANDS(a,b,c,d,e) #define DUMP_ENTRY(a,b) #define DUMP_TABLES(a,b) #define DUMP_PATHNAME(a,b,c,d) #define DUMP_RESOURCE_LIST(a) -#define DEBUG_PRINT(l,f) -#define DEBUG_PRINTP(l,f) -#define DEBUG_PRINT_RAW(l,f) +#define ACPI_DEBUG_PRINT(pl) +#define ACPI_DEBUG_PRINT_RAW(pl) #define BREAK_MSG(a) #define return_VOID return #define return_ACPI_STATUS(s) return(s) #define return_VALUE(s) return(s) #define return_PTR(s) return(s) #endif /* * Some code only gets executed when the debugger is built in. * Note that this is entirely independent of whether the * DEBUG_PRINT stuff (set by ACPI_DEBUG) is on, or not. */ #ifdef ENABLE_DEBUGGER #define DEBUGGER_EXEC(a) a #else #define DEBUGGER_EXEC(a) #endif /* * For 16-bit code, we want to shrink some things even though * we are using ACPI_DEBUG to get the debug output */ #ifdef _IA16 #undef DEBUG_ONLY_MEMBERS #undef _VERBOSE_STRUCTURES #define DEBUG_ONLY_MEMBERS(a) #endif #ifdef ACPI_DEBUG /* * 1) Set name to blanks * 2) Copy the object name */ #define ADD_OBJECT_NAME(a,b) MEMSET (a->Common.Name, ' ', sizeof (a->Common.Name));\ STRNCPY (a->Common.Name, AcpiGbl_NsTypeNames[b], sizeof (a->Common.Name)) #else #define ADD_OBJECT_NAME(a,b) #endif /* * Memory allocation tracking (DEBUG ONLY) */ #ifndef ACPI_DBG_TRACK_ALLOCATIONS /* Memory allocation */ #define ACPI_MEM_ALLOCATE(a) AcpiOsAllocate(a) #define ACPI_MEM_CALLOCATE(a) AcpiOsCallocate(a) #define ACPI_MEM_FREE(a) AcpiOsFree(a) +#define ACPI_MEM_TRACKING(a) -#define DECREMENT_OBJECT_METRICS(a) -#define INCREMENT_OBJECT_METRICS(a) -#define INITIALIZE_ALLOCATION_METRICS() -#define DECREMENT_NAME_TABLE_METRICS(a) -#define INCREMENT_NAME_TABLE_METRICS(a) - #else /* Memory allocation */ #define ACPI_MEM_ALLOCATE(a) AcpiUtAllocate(a,_COMPONENT,_THIS_MODULE,__LINE__) #define ACPI_MEM_CALLOCATE(a) AcpiUtCallocate(a, _COMPONENT,_THIS_MODULE,__LINE__) #define ACPI_MEM_FREE(a) AcpiUtFree(a,_COMPONENT,_THIS_MODULE,__LINE__) +#define ACPI_MEM_TRACKING(a) a -#define INITIALIZE_ALLOCATION_METRICS() \ - AcpiGbl_CurrentObjectCount = 0; \ - AcpiGbl_CurrentObjectSize = 0; \ - AcpiGbl_RunningObjectCount = 0; \ - AcpiGbl_RunningObjectSize = 0; \ - AcpiGbl_MaxConcurrentObjectCount = 0; \ - AcpiGbl_MaxConcurrentObjectSize = 0; \ - AcpiGbl_CurrentAllocSize = 0; \ - AcpiGbl_CurrentAllocCount = 0; \ - AcpiGbl_RunningAllocSize = 0; \ - AcpiGbl_RunningAllocCount = 0; \ - AcpiGbl_MaxConcurrentAllocSize = 0; \ - AcpiGbl_MaxConcurrentAllocCount = 0; \ - AcpiGbl_CurrentNodeCount = 0; \ - AcpiGbl_CurrentNodeSize = 0; \ - AcpiGbl_MaxConcurrentNodeCount = 0 - - -#define DECREMENT_OBJECT_METRICS(a) \ - AcpiGbl_CurrentObjectCount--; \ - AcpiGbl_CurrentObjectSize -= a - -#define INCREMENT_OBJECT_METRICS(a) \ - AcpiGbl_CurrentObjectCount++; \ - AcpiGbl_RunningObjectCount++; \ - if (AcpiGbl_MaxConcurrentObjectCount < AcpiGbl_CurrentObjectCount) \ - { \ - AcpiGbl_MaxConcurrentObjectCount = AcpiGbl_CurrentObjectCount; \ - } \ - AcpiGbl_RunningObjectSize += a; \ - AcpiGbl_CurrentObjectSize += a; \ - if (AcpiGbl_MaxConcurrentObjectSize < AcpiGbl_CurrentObjectSize) \ - { \ - AcpiGbl_MaxConcurrentObjectSize = AcpiGbl_CurrentObjectSize; \ - } - -#define DECREMENT_NAME_TABLE_METRICS(a) \ - AcpiGbl_CurrentNodeCount--; \ - AcpiGbl_CurrentNodeSize -= (a) - -#define INCREMENT_NAME_TABLE_METRICS(a) \ - AcpiGbl_CurrentNodeCount++; \ - AcpiGbl_CurrentNodeSize+= (a); \ - if (AcpiGbl_MaxConcurrentNodeCount < AcpiGbl_CurrentNodeCount) \ - { \ - AcpiGbl_MaxConcurrentNodeCount = AcpiGbl_CurrentNodeCount; \ - } #endif /* ACPI_DBG_TRACK_ALLOCATIONS */ #endif /* ACMACROS_H */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/acobject.h =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/acobject.h (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/acobject.h (revision 82367) @@ -1,536 +1,538 @@ /****************************************************************************** * * Name: acobject.h - Definition of ACPI_OPERAND_OBJECT (Internal object only) - * $Revision: 89 $ + * $Revision: 90 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #ifndef _ACOBJECT_H #define _ACOBJECT_H /* * The ACPI_OPERAND_OBJECT is used to pass AML operands from the dispatcher * to the interpreter, and to keep track of the various handlers such as * address space handlers and notify handlers. The object is a constant * size in order to allow them to be cached and reused. * * All variants of the ACPI_OPERAND_OBJECT are defined with the same * sequence of field types, with fields that are not used in a particular * variant being named "Reserved". This is not strictly necessary, but * may in some circumstances simplify understanding if these structures * need to be displayed in a debugger having limited (or no) support for * union types. It also simplifies some debug code in DumpTable() which * dumps multi-level values: fetching Buffer.Pointer suffices to pick up * the value or next level for any of several types. */ /****************************************************************************** * * Common Descriptors * *****************************************************************************/ /* * Common area for all objects. * * DataType is used to differentiate between internal descriptors, and MUST * be the first byte in this structure. */ #define ACPI_OBJECT_COMMON_HEADER /* SIZE/ALIGNMENT: 32-bits plus trailing 8-bit flag */\ UINT8 DataType; /* To differentiate various internal objs */\ UINT8 Type; /* ACPI_OBJECT_TYPE */\ UINT16 ReferenceCount; /* For object deletion management */\ UINT8 Flags; \ /* Defines for flag byte above */ #define AOPOBJ_STATIC_ALLOCATION 0x1 -#define AOPOBJ_DATA_VALID 0x2 -#define AOPOBJ_INITIALIZED 0x4 +#define AOPOBJ_STATIC_POINTER 0x2 +#define AOPOBJ_DATA_VALID 0x4 +#define AOPOBJ_ZERO_CONST 0x4 +#define AOPOBJ_INITIALIZED 0x8 /* * Common bitfield for the field objects * "Field Datum" -- a datum from the actual field object * "Buffer Datum" -- a datum from a user buffer, read from or to be written to the field */ #define ACPI_COMMON_FIELD_INFO /* SIZE/ALIGNMENT: 24 bits + three 32-bit values */\ UINT8 AccessFlags;\ UINT16 BitLength; /* Length of field in bits */\ UINT32 BaseByteOffset; /* Byte offset within containing object */\ UINT8 AccessBitWidth; /* Read/Write size in bits (from ASL AccessType)*/\ UINT8 AccessByteWidth; /* Read/Write size in bytes */\ UINT8 UpdateRule; /* How neighboring field bits are handled */\ UINT8 LockRule; /* Global Lock: 1 = "Must Lock" */\ UINT8 StartFieldBitOffset;/* Bit offset within first field datum (0-63) */\ UINT8 DatumValidBits; /* Valid bit in first "Field datum" */\ UINT8 EndFieldValidBits; /* Valid bits in the last "field datum" */\ UINT8 EndBufferValidBits; /* Valid bits in the last "buffer datum" */\ UINT32 Value; /* Value to store into the Bank or Index register */ /* Access flag bits */ #define AFIELD_SINGLE_DATUM 0x1 /****************************************************************************** * * Individual Object Descriptors * *****************************************************************************/ typedef struct /* COMMON */ { ACPI_OBJECT_COMMON_HEADER } ACPI_OBJECT_COMMON; typedef struct /* CACHE_LIST */ { ACPI_OBJECT_COMMON_HEADER union acpi_operand_obj *Next; /* Link for object cache and internal lists*/ } ACPI_OBJECT_CACHE_LIST; typedef struct /* NUMBER - has value */ { ACPI_OBJECT_COMMON_HEADER ACPI_INTEGER Value; } ACPI_OBJECT_INTEGER; typedef struct /* STRING - has length and pointer - Null terminated, ASCII characters only */ { ACPI_OBJECT_COMMON_HEADER UINT32 Length; NATIVE_CHAR *Pointer; /* String value in AML stream or in allocated space */ } ACPI_OBJECT_STRING; typedef struct /* BUFFER - has length and pointer - not null terminated */ { ACPI_OBJECT_COMMON_HEADER UINT32 Length; UINT8 *Pointer; /* points to the buffer in allocated space */ } ACPI_OBJECT_BUFFER; typedef struct /* PACKAGE - has count, elements, next element */ { ACPI_OBJECT_COMMON_HEADER UINT32 Count; /* # of elements in package */ union acpi_operand_obj **Elements; /* Array of pointers to AcpiObjects */ union acpi_operand_obj **NextElement; /* used only while initializing */ } ACPI_OBJECT_PACKAGE; typedef struct /* DEVICE - has handle and notification handler/context */ { ACPI_OBJECT_COMMON_HEADER union acpi_operand_obj *SysHandler; /* Handler for system notifies */ union acpi_operand_obj *DrvHandler; /* Handler for driver notifies */ union acpi_operand_obj *AddrHandler; /* Handler for Address space */ } ACPI_OBJECT_DEVICE; typedef struct /* EVENT */ { ACPI_OBJECT_COMMON_HEADER void *Semaphore; } ACPI_OBJECT_EVENT; #define INFINITE_CONCURRENCY 0xFF typedef struct /* METHOD */ { ACPI_OBJECT_COMMON_HEADER UINT8 MethodFlags; UINT8 ParamCount; UINT32 PcodeLength; void *Semaphore; UINT8 *Pcode; UINT8 Concurrency; UINT8 ThreadCount; ACPI_OWNER_ID OwningId; } ACPI_OBJECT_METHOD; typedef struct acpi_obj_mutex /* MUTEX */ { ACPI_OBJECT_COMMON_HEADER UINT16 SyncLevel; UINT16 AcquisitionDepth; void *Semaphore; void *Owner; union acpi_operand_obj *Prev; /* Link for list of acquired mutexes */ union acpi_operand_obj *Next; /* Link for list of acquired mutexes */ } ACPI_OBJECT_MUTEX; typedef struct /* REGION */ { ACPI_OBJECT_COMMON_HEADER UINT8 SpaceId; UINT32 Length; ACPI_PHYSICAL_ADDRESS Address; union acpi_operand_obj *Extra; /* Pointer to executable AML (in region definition) */ union acpi_operand_obj *AddrHandler; /* Handler for system notifies */ ACPI_NAMESPACE_NODE *Node; /* containing object */ union acpi_operand_obj *Next; } ACPI_OBJECT_REGION; typedef struct /* POWER RESOURCE - has Handle and notification handler/context*/ { ACPI_OBJECT_COMMON_HEADER UINT32 SystemLevel; UINT32 ResourceOrder; union acpi_operand_obj *SysHandler; /* Handler for system notifies */ union acpi_operand_obj *DrvHandler; /* Handler for driver notifies */ } ACPI_OBJECT_POWER_RESOURCE; typedef struct /* PROCESSOR - has Handle and notification handler/context*/ { ACPI_OBJECT_COMMON_HEADER UINT32 ProcId; UINT32 Length; ACPI_IO_ADDRESS Address; union acpi_operand_obj *SysHandler; /* Handler for system notifies */ union acpi_operand_obj *DrvHandler; /* Handler for driver notifies */ union acpi_operand_obj *AddrHandler; /* Handler for Address space */ } ACPI_OBJECT_PROCESSOR; typedef struct /* THERMAL ZONE - has Handle and Handler/Context */ { ACPI_OBJECT_COMMON_HEADER union acpi_operand_obj *SysHandler; /* Handler for system notifies */ union acpi_operand_obj *DrvHandler; /* Handler for driver notifies */ union acpi_operand_obj *AddrHandler; /* Handler for Address space */ } ACPI_OBJECT_THERMAL_ZONE; /* * Fields. All share a common header/info field. */ typedef struct /* COMMON FIELD (for BUFFER, REGION, BANK, and INDEX fields) */ { ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_obj *RegionObj; /* Containing Operation Region object */ /* (REGION/BANK fields only) */ } ACPI_OBJECT_FIELD_COMMON; typedef struct /* REGION FIELD */ { ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_obj *RegionObj; /* Containing OpRegion object */ } ACPI_OBJECT_REGION_FIELD; typedef struct /* BANK FIELD */ { ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_obj *RegionObj; /* Containing OpRegion object */ union acpi_operand_obj *BankRegisterObj; /* BankSelect Register object */ } ACPI_OBJECT_BANK_FIELD; typedef struct /* INDEX FIELD */ { ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO /* * No "RegionObj" pointer needed since the Index and Data registers * are each field definitions unto themselves. */ union acpi_operand_obj *IndexObj; /* Index register */ union acpi_operand_obj *DataObj; /* Data register */ } ACPI_OBJECT_INDEX_FIELD; /* The BufferField is different in that it is part of a Buffer, not an OpRegion */ typedef struct /* BUFFER FIELD */ { ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_obj *Extra; /* Pointer to executable AML (in field definition) */ ACPI_NAMESPACE_NODE *Node; /* Parent (containing) object node */ union acpi_operand_obj *BufferObj; /* Containing Buffer object */ } ACPI_OBJECT_BUFFER_FIELD; /* * Handlers */ typedef struct /* NOTIFY HANDLER */ { ACPI_OBJECT_COMMON_HEADER ACPI_NAMESPACE_NODE *Node; /* Parent device */ ACPI_NOTIFY_HANDLER Handler; void *Context; } ACPI_OBJECT_NOTIFY_HANDLER; /* Flags for address handler */ #define ADDR_HANDLER_DEFAULT_INSTALLED 0x1 typedef struct /* ADDRESS HANDLER */ { ACPI_OBJECT_COMMON_HEADER UINT8 SpaceId; UINT16 Hflags; ACPI_ADR_SPACE_HANDLER Handler; ACPI_NAMESPACE_NODE *Node; /* Parent device */ void *Context; ACPI_ADR_SPACE_SETUP Setup; union acpi_operand_obj *RegionList; /* regions using this handler */ union acpi_operand_obj *Next; } ACPI_OBJECT_ADDR_HANDLER; /* * The Reference object type is used for these opcodes: * Arg[0-6], Local[0-7], IndexOp, NameOp, ZeroOp, OneOp, OnesOp, DebugOp */ typedef struct /* Reference - Local object type */ { ACPI_OBJECT_COMMON_HEADER UINT8 TargetType; /* Used for IndexOp */ UINT16 Opcode; UINT32 Offset; /* Used for ArgOp, LocalOp, and IndexOp */ void *Object; /* NameOp=>HANDLE to obj, IndexOp=>ACPI_OPERAND_OBJECT */ ACPI_NAMESPACE_NODE *Node; union acpi_operand_obj **Where; } ACPI_OBJECT_REFERENCE; /* * Extra object is used as additional storage for types that * have AML code in their declarations (TermArgs) that must be * evaluated at run time. * * Currently: Region and FieldUnit types */ typedef struct /* EXTRA */ { ACPI_OBJECT_COMMON_HEADER UINT8 ByteFill1; UINT16 WordFill1; UINT32 PcodeLength; UINT8 *Pcode; ACPI_NAMESPACE_NODE *Method_REG; /* _REG method for this region (if any) */ void *RegionContext; /* Region-specific data */ } ACPI_OBJECT_EXTRA; /****************************************************************************** * * ACPI_OPERAND_OBJECT Descriptor - a giant union of all of the above * *****************************************************************************/ typedef union acpi_operand_obj { ACPI_OBJECT_COMMON Common; ACPI_OBJECT_CACHE_LIST Cache; ACPI_OBJECT_INTEGER Integer; ACPI_OBJECT_STRING String; ACPI_OBJECT_BUFFER Buffer; ACPI_OBJECT_PACKAGE Package; ACPI_OBJECT_BUFFER_FIELD BufferField; ACPI_OBJECT_DEVICE Device; ACPI_OBJECT_EVENT Event; ACPI_OBJECT_METHOD Method; ACPI_OBJECT_MUTEX Mutex; ACPI_OBJECT_REGION Region; ACPI_OBJECT_POWER_RESOURCE PowerResource; ACPI_OBJECT_PROCESSOR Processor; ACPI_OBJECT_THERMAL_ZONE ThermalZone; ACPI_OBJECT_FIELD_COMMON CommonField; ACPI_OBJECT_REGION_FIELD Field; ACPI_OBJECT_BANK_FIELD BankField; ACPI_OBJECT_INDEX_FIELD IndexField; ACPI_OBJECT_REFERENCE Reference; ACPI_OBJECT_NOTIFY_HANDLER NotifyHandler; ACPI_OBJECT_ADDR_HANDLER AddrHandler; ACPI_OBJECT_EXTRA Extra; } ACPI_OPERAND_OBJECT; #endif /* _ACOBJECT_H */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/acoutput.h =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/acoutput.h (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/acoutput.h (revision 82367) @@ -1,222 +1,267 @@ /****************************************************************************** * * Name: acoutput.h -- debug output - * $Revision: 80 $ + * $Revision: 81 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #ifndef __ACOUTPUT_H__ #define __ACOUTPUT_H__ /* * Debug levels and component IDs. These are used to control the * granularity of the output of the DEBUG_PRINT macro -- on a per- * component basis and a per-exception-type basis. */ -/* Component IDs -- used in the global "DebugLayer" */ +/* Component IDs are used in the global "DebugLayer" */ #define ACPI_UTILITIES 0x00000001 #define ACPI_HARDWARE 0x00000002 #define ACPI_EVENTS 0x00000004 #define ACPI_TABLES 0x00000008 #define ACPI_NAMESPACE 0x00000010 #define ACPI_PARSER 0x00000020 #define ACPI_DISPATCHER 0x00000040 #define ACPI_EXECUTER 0x00000080 #define ACPI_RESOURCES 0x00000100 #define ACPI_DEBUGGER 0x00000200 #define ACPI_OS_SERVICES 0x00000400 #define ACPI_BUS 0x00010000 #define ACPI_SYSTEM 0x00020000 #define ACPI_POWER 0x00040000 #define ACPI_EC 0x00080000 #define ACPI_AC_ADAPTER 0x00100000 #define ACPI_BATTERY 0x00200000 #define ACPI_BUTTON 0x00400000 #define ACPI_PROCESSOR 0x00800000 #define ACPI_THERMAL 0x01000000 #define ACPI_FAN 0x02000000 #define ACPI_ALL_COMPONENTS 0x0FFFFFFF #define ACPI_COMPONENT_DEFAULT (ACPI_ALL_COMPONENTS) #define ACPI_COMPILER 0x10000000 #define ACPI_TOOLS 0x20000000 +/* + * Raw debug output levels, do not use these in the DEBUG_PRINT macros + */ + +#define ACPI_LV_OK 0x00000001 +#define ACPI_LV_INFO 0x00000002 +#define ACPI_LV_WARN 0x00000004 +#define ACPI_LV_ERROR 0x00000008 +#define ACPI_LV_FATAL 0x00000010 +#define ACPI_LV_DEBUG_OBJECT 0x00000020 +#define ACPI_LV_ALL_EXCEPTIONS 0x0000003F + + +/* Trace level -- also used in the global "DebugLevel" */ + +#define ACPI_LV_THREADS 0x00000080 +#define ACPI_LV_PARSE 0x00000100 +#define ACPI_LV_DISPATCH 0x00000200 +#define ACPI_LV_LOAD 0x00000400 +#define ACPI_LV_EXEC 0x00000800 +#define ACPI_LV_NAMES 0x00001000 +#define ACPI_LV_OPREGION 0x00002000 +#define ACPI_LV_BFIELD 0x00004000 +#define ACPI_LV_TRASH 0x00008000 +#define ACPI_LV_TABLES 0x00010000 +#define ACPI_LV_FUNCTIONS 0x00020000 +#define ACPI_LV_VALUES 0x00040000 +#define ACPI_LV_OBJECTS 0x00080000 +#define ACPI_LV_ALLOCATIONS 0x00100000 +#define ACPI_LV_RESOURCES 0x00200000 +#define ACPI_LV_IO 0x00400000 +#define ACPI_LV_INTERRUPTS 0x00800000 +#define ACPI_LV_USER_REQUESTS 0x01000000 +#define ACPI_LV_PACKAGE 0x02000000 +#define ACPI_LV_MUTEX 0x04000000 +#define ACPI_LV_INIT 0x08000000 +#define ACPI_LV_ALL 0x0FFFFF80 + + +/* + * Debug level macros that are used in the DEBUG_PRINT macros + */ + +#define ACPI_DEBUG_LEVEL(val) val,_COMPONENT,_ProcName,_THIS_MODULE,__LINE__ + /* Exception level -- used in the global "DebugLevel" */ -#define ACPI_OK 0x00000001 -#define ACPI_INFO 0x00000002 -#define ACPI_WARN 0x00000004 -#define ACPI_ERROR 0x00000008 -#define ACPI_FATAL 0x00000010 -#define ACPI_DEBUG_OBJECT 0x00000020 -#define ACPI_ALL 0x0000003F +#define ACPI_DB_OK ACPI_DEBUG_LEVEL (ACPI_LV_OK) +#define ACPI_DB_INFO ACPI_DEBUG_LEVEL (ACPI_LV_INFO) +#define ACPI_DB_WARN ACPI_DEBUG_LEVEL (ACPI_LV_WARN) +#define ACPI_DB_ERROR ACPI_DEBUG_LEVEL (ACPI_LV_ERROR) +#define ACPI_DB_FATAL ACPI_DEBUG_LEVEL (ACPI_LV_FATAL) +#define ACPI_DB_DEBUG_OBJECT ACPI_DEBUG_LEVEL (ACPI_LV_DEBUG_OBJECT) +#define ACPI_DB_ALL_EXCEPTIONS ACPI_DEBUG_LEVEL (ACPI_LV_ALL_EXCEPTIONS) /* Trace level -- also used in the global "DebugLevel" */ -#define TRACE_THREADS 0x00000080 -#define TRACE_PARSE 0x00000100 -#define TRACE_DISPATCH 0x00000200 -#define TRACE_LOAD 0x00000400 -#define TRACE_EXEC 0x00000800 -#define TRACE_NAMES 0x00001000 -#define TRACE_OPREGION 0x00002000 -#define TRACE_BFIELD 0x00004000 -#define TRACE_TRASH 0x00008000 -#define TRACE_TABLES 0x00010000 -#define TRACE_FUNCTIONS 0x00020000 -#define TRACE_VALUES 0x00040000 -#define TRACE_OBJECTS 0x00080000 -#define TRACE_ALLOCATIONS 0x00100000 -#define TRACE_RESOURCES 0x00200000 -#define TRACE_IO 0x00400000 -#define TRACE_INTERRUPTS 0x00800000 -#define TRACE_USER_REQUESTS 0x01000000 -#define TRACE_PACKAGE 0x02000000 -#define TRACE_MUTEX 0x04000000 -#define TRACE_INIT 0x08000000 +#define ACPI_DB_THREADS ACPI_DEBUG_LEVEL (ACPI_LV_THREADS) +#define ACPI_DB_PARSE ACPI_DEBUG_LEVEL (ACPI_LV_PARSE) +#define ACPI_DB_DISPATCH ACPI_DEBUG_LEVEL (ACPI_LV_DISPATCH) +#define ACPI_DB_LOAD ACPI_DEBUG_LEVEL (ACPI_LV_LOAD) +#define ACPI_DB_EXEC ACPI_DEBUG_LEVEL (ACPI_LV_EXEC) +#define ACPI_DB_NAMES ACPI_DEBUG_LEVEL (ACPI_LV_NAMES) +#define ACPI_DB_OPREGION ACPI_DEBUG_LEVEL (ACPI_LV_OPREGION) +#define ACPI_DB_BFIELD ACPI_DEBUG_LEVEL (ACPI_LV_BFIELD) +#define ACPI_DB_TRASH ACPI_DEBUG_LEVEL (ACPI_LV_TRASH) +#define ACPI_DB_TABLES ACPI_DEBUG_LEVEL (ACPI_LV_TABLES) +#define ACPI_DB_FUNCTIONS ACPI_DEBUG_LEVEL (ACPI_LV_FUNCTIONS) +#define ACPI_DB_VALUES ACPI_DEBUG_LEVEL (ACPI_LV_VALUES) +#define ACPI_DB_OBJECTS ACPI_DEBUG_LEVEL (ACPI_LV_OBJECTS) +#define ACPI_DB_ALLOCATIONS ACPI_DEBUG_LEVEL (ACPI_LV_ALLOCATIONS) +#define ACPI_DB_RESOURCES ACPI_DEBUG_LEVEL (ACPI_LV_RESOURCES) +#define ACPI_DB_IO ACPI_DEBUG_LEVEL (ACPI_LV_IO) +#define ACPI_DB_INTERRUPTS ACPI_DEBUG_LEVEL (ACPI_LV_INTERRUPTS) +#define ACPI_DB_USER_REQUESTS ACPI_DEBUG_LEVEL (ACPI_LV_USER_REQUESTS) +#define ACPI_DB_PACKAGE ACPI_DEBUG_LEVEL (ACPI_LV_PACKAGE) +#define ACPI_DB_MUTEX ACPI_DEBUG_LEVEL (ACPI_LV_MUTEX) +#define ACPI_DB_INIT ACPI_DEBUG_LEVEL (ACPI_LV_INIT) -#define TRACE_ALL 0x0FFFFF80 +#define ACPI_DB_ALL ACPI_DEBUG_LEVEL (0x0FFFFF80) /* Exceptionally verbose output -- also used in the global "DebugLevel" */ -#define VERBOSE_AML_DISASSEMBLE 0x10000000 -#define VERBOSE_INFO 0x20000000 -#define VERBOSE_TABLES 0x40000000 -#define VERBOSE_EVENTS 0x80000000 +#define ACPI_DB_AML_DISASSEMBLE 0x10000000 +#define ACPI_DB_VERBOSE_INFO 0x20000000 +#define ACPI_DB_FULL_TABLES 0x40000000 +#define ACPI_DB_EVENTS 0x80000000 -#define VERBOSE_ALL 0xF0000000 +#define ACPI_DB_VERBOSE 0xF0000000 /* Defaults for DebugLevel, debug and normal */ -#define DEBUG_DEFAULT (ACPI_OK | ACPI_WARN | ACPI_ERROR | ACPI_DEBUG_OBJECT) -#define NORMAL_DEFAULT (ACPI_OK | ACPI_WARN | ACPI_ERROR | ACPI_DEBUG_OBJECT) -#define DEBUG_ALL (VERBOSE_AML_DISASSEMBLE | TRACE_ALL | ACPI_ALL) +#define DEBUG_DEFAULT (ACPI_LV_OK | ACPI_LV_WARN | ACPI_LV_ERROR | ACPI_LV_DEBUG_OBJECT) +#define NORMAL_DEFAULT (ACPI_LV_OK | ACPI_LV_WARN | ACPI_LV_ERROR | ACPI_LV_DEBUG_OBJECT) +#define DEBUG_ALL (ACPI_LV_AML_DISASSEMBLE | ACPI_LV_ALL_EXCEPTIONS | ACPI_LV_ALL) /* Misc defines */ #define HEX 0x01 #define ASCII 0x02 #define FULL_ADDRESS 0x04 #define CHARS_PER_LINE 16 /* used in DumpBuf function */ #endif /* __ACOUTPUT_H__ */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/acpixf.h =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/acpixf.h (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/acpixf.h (revision 82367) @@ -1,442 +1,415 @@ /****************************************************************************** * * Name: acpixf.h - External interfaces to the ACPI subsystem * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #ifndef __ACXFACE_H__ #define __ACXFACE_H__ #include "actypes.h" #include "actbl.h" /* * Global interfaces */ ACPI_STATUS AcpiInitializeSubsystem ( void); ACPI_STATUS AcpiEnableSubsystem ( UINT32 Flags); ACPI_STATUS AcpiTerminate ( void); ACPI_STATUS AcpiSubsystemStatus ( void); ACPI_STATUS AcpiEnable ( void); ACPI_STATUS AcpiDisable ( void); ACPI_STATUS AcpiGetSystemInfo ( ACPI_BUFFER *RetBuffer); const char * AcpiFormatException ( ACPI_STATUS Exception); /* * ACPI Memory manager */ void * AcpiAllocate ( UINT32 Size); void * AcpiCallocate ( UINT32 Size); void AcpiFree ( void *Address); /* * ACPI table manipulation interfaces */ ACPI_STATUS AcpiFindRootPointer ( UINT32 Flags, ACPI_PHYSICAL_ADDRESS *RsdpPhysicalAddress); ACPI_STATUS AcpiLoadTables ( void); ACPI_STATUS AcpiLoadTable ( ACPI_TABLE_HEADER *TablePtr); ACPI_STATUS AcpiUnloadTable ( ACPI_TABLE_TYPE TableType); ACPI_STATUS AcpiGetTableHeader ( ACPI_TABLE_TYPE TableType, UINT32 Instance, ACPI_TABLE_HEADER *OutTableHeader); ACPI_STATUS AcpiGetTable ( ACPI_TABLE_TYPE TableType, UINT32 Instance, ACPI_BUFFER *RetBuffer); ACPI_STATUS AcpiGetFirmwareTable ( ACPI_STRING Signature, UINT32 Instance, UINT32 Flags, ACPI_TABLE_HEADER **TablePointer); /* * Namespace and name interfaces */ ACPI_STATUS AcpiWalkNamespace ( ACPI_OBJECT_TYPE Type, ACPI_HANDLE StartObject, UINT32 MaxDepth, ACPI_WALK_CALLBACK UserFunction, void *Context, void * *ReturnValue); ACPI_STATUS AcpiGetDevices ( NATIVE_CHAR *HID, ACPI_WALK_CALLBACK UserFunction, void *Context, void **ReturnValue); ACPI_STATUS AcpiGetName ( ACPI_HANDLE Handle, UINT32 NameType, ACPI_BUFFER *RetPathPtr); ACPI_STATUS AcpiGetHandle ( ACPI_HANDLE Parent, ACPI_STRING Pathname, ACPI_HANDLE *RetHandle); /* * Object manipulation and enumeration */ ACPI_STATUS AcpiEvaluateObject ( ACPI_HANDLE Object, ACPI_STRING Pathname, ACPI_OBJECT_LIST *ParameterObjects, ACPI_BUFFER *ReturnObjectBuffer); ACPI_STATUS AcpiGetObjectInfo ( ACPI_HANDLE Device, ACPI_DEVICE_INFO *Info); ACPI_STATUS AcpiGetNextObject ( ACPI_OBJECT_TYPE Type, ACPI_HANDLE Parent, ACPI_HANDLE Child, ACPI_HANDLE *OutHandle); ACPI_STATUS AcpiGetType ( ACPI_HANDLE Object, ACPI_OBJECT_TYPE *OutType); ACPI_STATUS AcpiGetParent ( ACPI_HANDLE Object, ACPI_HANDLE *OutHandle); /* * Event handler interfaces */ ACPI_STATUS AcpiInstallFixedEventHandler ( UINT32 AcpiEvent, ACPI_EVENT_HANDLER Handler, void *Context); ACPI_STATUS AcpiRemoveFixedEventHandler ( UINT32 AcpiEvent, ACPI_EVENT_HANDLER Handler); ACPI_STATUS AcpiInstallNotifyHandler ( ACPI_HANDLE Device, UINT32 HandlerType, ACPI_NOTIFY_HANDLER Handler, void *Context); ACPI_STATUS AcpiRemoveNotifyHandler ( ACPI_HANDLE Device, UINT32 HandlerType, ACPI_NOTIFY_HANDLER Handler); ACPI_STATUS AcpiInstallAddressSpaceHandler ( ACPI_HANDLE Device, ACPI_ADR_SPACE_TYPE SpaceId, ACPI_ADR_SPACE_HANDLER Handler, ACPI_ADR_SPACE_SETUP Setup, void *Context); ACPI_STATUS AcpiRemoveAddressSpaceHandler ( ACPI_HANDLE Device, ACPI_ADR_SPACE_TYPE SpaceId, ACPI_ADR_SPACE_HANDLER Handler); ACPI_STATUS AcpiInstallGpeHandler ( UINT32 GpeNumber, UINT32 Type, ACPI_GPE_HANDLER Handler, void *Context); ACPI_STATUS AcpiAcquireGlobalLock ( void); ACPI_STATUS AcpiReleaseGlobalLock ( void); ACPI_STATUS AcpiRemoveGpeHandler ( UINT32 GpeNumber, ACPI_GPE_HANDLER Handler); ACPI_STATUS AcpiEnableEvent ( UINT32 AcpiEvent, UINT32 Type); ACPI_STATUS AcpiDisableEvent ( UINT32 AcpiEvent, UINT32 Type); ACPI_STATUS AcpiClearEvent ( UINT32 AcpiEvent, UINT32 Type); ACPI_STATUS AcpiGetEventStatus ( UINT32 AcpiEvent, UINT32 Type, ACPI_EVENT_STATUS *EventStatus); /* * Resource interfaces */ ACPI_STATUS AcpiGetCurrentResources( ACPI_HANDLE DeviceHandle, ACPI_BUFFER *RetBuffer); ACPI_STATUS AcpiGetPossibleResources( ACPI_HANDLE DeviceHandle, ACPI_BUFFER *RetBuffer); ACPI_STATUS AcpiSetCurrentResources ( ACPI_HANDLE DeviceHandle, ACPI_BUFFER *InBuffer); ACPI_STATUS AcpiGetIrqRoutingTable ( ACPI_HANDLE BusDeviceHandle, ACPI_BUFFER *RetBuffer); /* * Hardware (ACPI device) interfaces */ ACPI_STATUS AcpiSetFirmwareWakingVector ( ACPI_PHYSICAL_ADDRESS PhysicalAddress); ACPI_STATUS AcpiGetFirmwareWakingVector ( ACPI_PHYSICAL_ADDRESS *PhysicalAddress); ACPI_STATUS AcpiEnterSleepState ( UINT8 SleepState); ACPI_STATUS -AcpiGetProcessorThrottlingInfo ( - ACPI_HANDLE ProcessorHandle, - ACPI_BUFFER *UserBuffer); - -ACPI_STATUS -AcpiSetProcessorThrottlingState ( - ACPI_HANDLE ProcessorHandle, - UINT32 ThrottleState); - -ACPI_STATUS -AcpiGetProcessorThrottlingState ( - ACPI_HANDLE ProcessorHandle, - UINT32 *ThrottleState); - -ACPI_STATUS -AcpiGetProcessorCxInfo ( - ACPI_HANDLE ProcessorHandle, - ACPI_BUFFER *UserBuffer); - -ACPI_STATUS -AcpiSetProcessorSleepState ( - ACPI_HANDLE ProcessorHandle, - UINT32 CxState); - -ACPI_STATUS -AcpiProcessorSleep ( - ACPI_HANDLE ProcessorHandle, - UINT32 *PmTimerTicks); - +AcpiLeaveSleepState ( + UINT8 SleepState); #endif /* __ACXFACE_H__ */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/actypes.h =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/actypes.h (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/actypes.h (revision 82367) @@ -1,1164 +1,1173 @@ /****************************************************************************** * * Name: actypes.h - Common data types for the entire ACPI subsystem - * $Revision: 184 $ + * $Revision: 186 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #ifndef __ACTYPES_H__ #define __ACTYPES_H__ /*! [Begin] no source code translation (keep the typedefs) */ /* * Data types - Fixed across all compilation models * * BOOLEAN Logical Boolean. * 1 byte value containing a 0 for FALSE or a 1 for TRUE. * Other values are undefined. * * INT8 8-bit (1 byte) signed value * UINT8 8-bit (1 byte) unsigned value * INT16 16-bit (2 byte) signed value * UINT16 16-bit (2 byte) unsigned value * INT32 32-bit (4 byte) signed value * UINT32 32-bit (4 byte) unsigned value * INT64 64-bit (8 byte) signed value * UINT64 64-bit (8 byte) unsigned value * NATIVE_INT 32-bit on IA-32, 64-bit on IA-64 signed value * NATIVE_UINT 32-bit on IA-32, 64-bit on IA-64 unsigned value * UCHAR Character. 1 byte unsigned value. */ #ifdef _IA64 /* * 64-bit type definitions */ typedef unsigned char UINT8; typedef unsigned char BOOLEAN; typedef unsigned char UCHAR; typedef unsigned short UINT16; typedef int INT32; typedef unsigned int UINT32; typedef COMPILER_DEPENDENT_UINT64 UINT64; typedef UINT64 NATIVE_UINT; typedef INT64 NATIVE_INT; typedef NATIVE_UINT ACPI_TBLPTR; typedef UINT64 ACPI_IO_ADDRESS; typedef UINT64 ACPI_PHYSICAL_ADDRESS; #define ALIGNED_ADDRESS_BOUNDARY 0x00000008 /* (No hardware alignment support in IA64) */ #elif _IA16 /* * 16-bit type definitions */ typedef unsigned char UINT8; typedef unsigned char BOOLEAN; typedef unsigned char UCHAR; typedef unsigned int UINT16; typedef long INT32; typedef int INT16; typedef unsigned long UINT32; typedef struct { UINT32 Lo; UINT32 Hi; } UINT64; typedef UINT16 NATIVE_UINT; typedef INT16 NATIVE_INT; typedef UINT32 ACPI_TBLPTR; typedef UINT32 ACPI_IO_ADDRESS; typedef char *ACPI_PHYSICAL_ADDRESS; #define ALIGNED_ADDRESS_BOUNDARY 0x00000002 #define _HW_ALIGNMENT_SUPPORT /* * (16-bit only) internal integers must be 32-bits, so * 64-bit integers cannot be supported */ #define ACPI_NO_INTEGER64_SUPPORT #else /* * 32-bit type definitions (default) */ typedef unsigned char UINT8; typedef unsigned char BOOLEAN; typedef unsigned char UCHAR; typedef unsigned short UINT16; typedef int INT32; typedef unsigned int UINT32; typedef COMPILER_DEPENDENT_UINT64 UINT64; typedef UINT32 NATIVE_UINT; typedef INT32 NATIVE_INT; typedef NATIVE_UINT ACPI_TBLPTR; typedef UINT32 ACPI_IO_ADDRESS; typedef UINT64 ACPI_PHYSICAL_ADDRESS; #define ALIGNED_ADDRESS_BOUNDARY 0x00000004 #define _HW_ALIGNMENT_SUPPORT #endif /* * Miscellaneous common types */ typedef UINT32 UINT32_BIT; typedef NATIVE_UINT ACPI_PTRDIFF; typedef char NATIVE_CHAR; /* * Data type ranges */ #define ACPI_UINT8_MAX (UINT8) 0xFF #define ACPI_UINT16_MAX (UINT16) 0xFFFF #define ACPI_UINT32_MAX (UINT32) 0xFFFFFFFF #define ACPI_UINT64_MAX (UINT64) 0xFFFFFFFFFFFFFFFF #ifdef DEFINE_ALTERNATE_TYPES /* * Types used only in translated source */ typedef INT32 s32; typedef UINT8 u8; typedef UINT16 u16; typedef UINT32 u32; typedef UINT64 u64; #endif /*! [End] no source code translation !*/ /* * Useful defines */ #ifdef FALSE #undef FALSE #endif #define FALSE (1 == 0) #ifdef TRUE #undef TRUE #endif #define TRUE (1 == 1) #ifndef NULL #define NULL (void *) 0 #endif /* * Local datatypes */ typedef UINT32 ACPI_STATUS; /* All ACPI Exceptions */ typedef UINT32 ACPI_NAME; /* 4-byte ACPI name */ typedef char* ACPI_STRING; /* Null terminated ASCII string */ typedef void* ACPI_HANDLE; /* Actually a ptr to an Node */ +typedef struct +{ + UINT32 Lo; + UINT32 Hi; +} UINT64_STRUCT; + + /* * Acpi integer width. In ACPI version 1, integers are * 32 bits. In ACPI version 2, integers are 64 bits. * Note that this pertains to the ACPI integer type only, not * other integers used in the implementation of the ACPI CA * subsystem. */ #ifdef ACPI_NO_INTEGER64_SUPPORT /* 32-bit integers only, no 64-bit support */ typedef UINT32 ACPI_INTEGER; #define ACPI_INTEGER_MAX ACPI_UINT32_MAX #define ACPI_INTEGER_BIT_SIZE 32 #define ACPI_MAX_BCD_VALUE 99999999 #define ACPI_MAX_BCD_DIGITS 8 +#define ACPI_MAX_DECIMAL_DIGITS 10 #else /* 64-bit integers */ typedef UINT64 ACPI_INTEGER; #define ACPI_INTEGER_MAX ACPI_UINT64_MAX #define ACPI_INTEGER_BIT_SIZE 64 #define ACPI_MAX_BCD_VALUE 9999999999999999 #define ACPI_MAX_BCD_DIGITS 16 +#define ACPI_MAX_DECIMAL_DIGITS 19 #endif /* * Constants with special meanings */ #define ACPI_ROOT_OBJECT (ACPI_HANDLE)(-1) /* * Initialization sequence */ #define ACPI_FULL_INITIALIZATION 0x00 #define ACPI_NO_ADDRESS_SPACE_INIT 0x01 #define ACPI_NO_HARDWARE_INIT 0x02 #define ACPI_NO_EVENT_INIT 0x04 #define ACPI_NO_ACPI_ENABLE 0x08 #define ACPI_NO_DEVICE_INIT 0x10 #define ACPI_NO_OBJECT_INIT 0x20 /* * Initialization state */ #define ACPI_INITIALIZED_OK 0x01 /* * Power state values */ #define ACPI_STATE_UNKNOWN (UINT8) 0xFF #define ACPI_STATE_S0 (UINT8) 0 #define ACPI_STATE_S1 (UINT8) 1 #define ACPI_STATE_S2 (UINT8) 2 #define ACPI_STATE_S3 (UINT8) 3 #define ACPI_STATE_S4 (UINT8) 4 #define ACPI_STATE_S5 (UINT8) 5 #define ACPI_S_STATES_MAX ACPI_STATE_S5 #define ACPI_S_STATE_COUNT 6 #define ACPI_STATE_D0 (UINT8) 0 #define ACPI_STATE_D1 (UINT8) 1 #define ACPI_STATE_D2 (UINT8) 2 #define ACPI_STATE_D3 (UINT8) 3 #define ACPI_D_STATES_MAX ACPI_STATE_D3 #define ACPI_D_STATE_COUNT 4 /* * Standard notify values */ #define ACPI_NOTIFY_BUS_CHECK (UINT8) 0 #define ACPI_NOTIFY_DEVICE_CHECK (UINT8) 1 #define ACPI_NOTIFY_DEVICE_WAKE (UINT8) 2 #define ACPI_NOTIFY_EJECT_REQUEST (UINT8) 3 #define ACPI_NOTIFY_DEVICE_CHECK_LIGHT (UINT8) 4 #define ACPI_NOTIFY_FREQUENCY_MISMATCH (UINT8) 5 #define ACPI_NOTIFY_BUS_MODE_MISMATCH (UINT8) 6 #define ACPI_NOTIFY_POWER_FAULT (UINT8) 7 /* * Table types. These values are passed to the table related APIs */ typedef UINT32 ACPI_TABLE_TYPE; #define ACPI_TABLE_RSDP (ACPI_TABLE_TYPE) 0 #define ACPI_TABLE_DSDT (ACPI_TABLE_TYPE) 1 #define ACPI_TABLE_FADT (ACPI_TABLE_TYPE) 2 #define ACPI_TABLE_FACS (ACPI_TABLE_TYPE) 3 #define ACPI_TABLE_PSDT (ACPI_TABLE_TYPE) 4 #define ACPI_TABLE_SSDT (ACPI_TABLE_TYPE) 5 #define ACPI_TABLE_XSDT (ACPI_TABLE_TYPE) 6 #define ACPI_TABLE_MAX 6 #define NUM_ACPI_TABLES (ACPI_TABLE_MAX+1) /* * Types associated with names. The first group of * values correspond to the definition of the ACPI * ObjectType operator (See the ACPI Spec). Therefore, * only add to the first group if the spec changes! * * Types must be kept in sync with the AcpiNsProperties * and AcpiNsTypeNames arrays */ typedef UINT32 ACPI_OBJECT_TYPE; typedef UINT8 ACPI_OBJECT_TYPE8; #define ACPI_TYPE_ANY 0 /* 0x00 */ #define ACPI_TYPE_INTEGER 1 /* 0x01 Byte/Word/Dword/Zero/One/Ones */ #define ACPI_TYPE_STRING 2 /* 0x02 */ #define ACPI_TYPE_BUFFER 3 /* 0x03 */ #define ACPI_TYPE_PACKAGE 4 /* 0x04 ByteConst, multiple DataTerm/Constant/SuperName */ #define ACPI_TYPE_FIELD_UNIT 5 /* 0x05 */ #define ACPI_TYPE_DEVICE 6 /* 0x06 Name, multiple Node */ #define ACPI_TYPE_EVENT 7 /* 0x07 */ #define ACPI_TYPE_METHOD 8 /* 0x08 Name, ByteConst, multiple Code */ #define ACPI_TYPE_MUTEX 9 /* 0x09 */ #define ACPI_TYPE_REGION 10 /* 0x0A */ #define ACPI_TYPE_POWER 11 /* 0x0B Name,ByteConst,WordConst,multi Node */ #define ACPI_TYPE_PROCESSOR 12 /* 0x0C Name,ByteConst,DWordConst,ByteConst,multi NmO */ #define ACPI_TYPE_THERMAL 13 /* 0x0D Name, multiple Node */ #define ACPI_TYPE_BUFFER_FIELD 14 /* 0x0E */ #define ACPI_TYPE_DDB_HANDLE 15 /* 0x0F */ #define ACPI_TYPE_DEBUG_OBJECT 16 /* 0x10 */ #define ACPI_TYPE_MAX 16 /* * This section contains object types that do not relate to the ACPI ObjectType operator. * They are used for various internal purposes only. If new predefined ACPI_TYPEs are * added (via the ACPI specification), these internal types must move upwards. * Also, values exceeding the largest official ACPI ObjectType must not overlap with * defined AML opcodes. */ #define INTERNAL_TYPE_BEGIN 17 #define INTERNAL_TYPE_REGION_FIELD 17 /* 0x11 */ #define INTERNAL_TYPE_BANK_FIELD 18 /* 0x12 */ #define INTERNAL_TYPE_INDEX_FIELD 19 /* 0x13 */ #define INTERNAL_TYPE_REFERENCE 20 /* 0x14 Arg#, Local#, Name, Debug; used only in descriptors */ #define INTERNAL_TYPE_ALIAS 21 /* 0x15 */ #define INTERNAL_TYPE_NOTIFY 22 /* 0x16 */ #define INTERNAL_TYPE_ADDRESS_HANDLER 23 /* 0x17 */ #define INTERNAL_TYPE_RESOURCE 24 /* 0x18 */ #define INTERNAL_TYPE_RESOURCE_FIELD 25 /* 0x19 */ #define INTERNAL_TYPE_NODE_MAX 25 /* These are pseudo-types because there are never any namespace nodes with these types */ #define INTERNAL_TYPE_FIELD_DEFN 26 /* 0x1A Name, ByteConst, multiple FieldElement */ #define INTERNAL_TYPE_BANK_FIELD_DEFN 27 /* 0x1B 2 Name,DWordConst,ByteConst,multi FieldElement */ #define INTERNAL_TYPE_INDEX_FIELD_DEFN 28 /* 0x1C 2 Name, ByteConst, multiple FieldElement */ #define INTERNAL_TYPE_IF 29 /* 0x1D */ #define INTERNAL_TYPE_ELSE 30 /* 0x1E */ #define INTERNAL_TYPE_WHILE 31 /* 0x1F */ #define INTERNAL_TYPE_SCOPE 32 /* 0x20 Name, multiple Node */ #define INTERNAL_TYPE_DEF_ANY 33 /* 0x21 type is Any, suppress search of enclosing scopes */ #define INTERNAL_TYPE_EXTRA 34 /* 0x22 */ #define INTERNAL_TYPE_MAX 34 #define INTERNAL_TYPE_INVALID 35 #define ACPI_TYPE_NOT_FOUND 0xFF /* * Bitmapped ACPI types * Used internally only */ #define ACPI_BTYPE_ANY 0x00000000 #define ACPI_BTYPE_INTEGER 0x00000001 #define ACPI_BTYPE_STRING 0x00000002 #define ACPI_BTYPE_BUFFER 0x00000004 #define ACPI_BTYPE_PACKAGE 0x00000008 #define ACPI_BTYPE_FIELD_UNIT 0x00000010 #define ACPI_BTYPE_DEVICE 0x00000020 #define ACPI_BTYPE_EVENT 0x00000040 #define ACPI_BTYPE_METHOD 0x00000080 #define ACPI_BTYPE_MUTEX 0x00000100 #define ACPI_BTYPE_REGION 0x00000200 #define ACPI_BTYPE_POWER 0x00000400 #define ACPI_BTYPE_PROCESSOR 0x00000800 #define ACPI_BTYPE_THERMAL 0x00001000 #define ACPI_BTYPE_BUFFER_FIELD 0x00002000 #define ACPI_BTYPE_DDB_HANDLE 0x00004000 #define ACPI_BTYPE_DEBUG_OBJECT 0x00008000 #define ACPI_BTYPE_REFERENCE 0x00010000 #define ACPI_BTYPE_RESOURCE 0x00020000 #define ACPI_BTYPE_COMPUTE_DATA (ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER) #define ACPI_BTYPE_DATA (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_PACKAGE) #define ACPI_BTYPE_DATA_REFERENCE (ACPI_BTYPE_DATA | ACPI_BTYPE_REFERENCE | ACPI_BTYPE_DDB_HANDLE) #define ACPI_BTYPE_DEVICE_OBJECTS (ACPI_BTYPE_DEVICE | ACPI_BTYPE_THERMAL | ACPI_BTYPE_PROCESSOR) #define ACPI_BTYPE_OBJECTS_AND_REFS 0x0001FFFF /* ARG or LOCAL */ #define ACPI_BTYPE_ALL_OBJECTS 0x0000FFFF /* * AcpiEvent Types: * ------------ * Fixed & general purpose... */ typedef UINT32 ACPI_EVENT_TYPE; #define ACPI_EVENT_FIXED (ACPI_EVENT_TYPE) 0 #define ACPI_EVENT_GPE (ACPI_EVENT_TYPE) 1 /* * Fixed events */ #define ACPI_EVENT_PMTIMER (ACPI_EVENT_TYPE) 0 /* * There's no bus master event so index 1 is used for IRQ's that are not * handled by the SCI handler */ #define ACPI_EVENT_NOT_USED (ACPI_EVENT_TYPE) 1 #define ACPI_EVENT_GLOBAL (ACPI_EVENT_TYPE) 2 #define ACPI_EVENT_POWER_BUTTON (ACPI_EVENT_TYPE) 3 #define ACPI_EVENT_SLEEP_BUTTON (ACPI_EVENT_TYPE) 4 #define ACPI_EVENT_RTC (ACPI_EVENT_TYPE) 5 #define ACPI_EVENT_GENERAL (ACPI_EVENT_TYPE) 6 #define ACPI_EVENT_MAX 6 #define ACPI_NUM_FIXED_EVENTS (ACPI_EVENT_TYPE) 7 #define ACPI_GPE_INVALID 0xFF #define ACPI_GPE_MAX 0xFF #define ACPI_NUM_GPE 256 #define ACPI_EVENT_LEVEL_TRIGGERED (ACPI_EVENT_TYPE) 1 #define ACPI_EVENT_EDGE_TRIGGERED (ACPI_EVENT_TYPE) 2 /* * AcpiEvent Status: * ------------- * The encoding of ACPI_EVENT_STATUS is illustrated below. * Note that a set bit (1) indicates the property is TRUE * (e.g. if bit 0 is set then the event is enabled). * +---------------+-+-+ * | Bits 31:2 |1|0| * +---------------+-+-+ * | | | * | | +- Enabled? * | +--- Set? * +----------- */ typedef UINT32 ACPI_EVENT_STATUS; #define ACPI_EVENT_FLAG_DISABLED (ACPI_EVENT_STATUS) 0x00 #define ACPI_EVENT_FLAG_ENABLED (ACPI_EVENT_STATUS) 0x01 #define ACPI_EVENT_FLAG_SET (ACPI_EVENT_STATUS) 0x02 /* Notify types */ #define ACPI_SYSTEM_NOTIFY 0 #define ACPI_DEVICE_NOTIFY 1 #define ACPI_MAX_NOTIFY_HANDLER_TYPE 1 #define MAX_SYS_NOTIFY 0x7f /* Address Space (Operation Region) Types */ typedef UINT8 ACPI_ADR_SPACE_TYPE; #define ACPI_ADR_SPACE_SYSTEM_MEMORY (ACPI_ADR_SPACE_TYPE) 0 #define ACPI_ADR_SPACE_SYSTEM_IO (ACPI_ADR_SPACE_TYPE) 1 #define ACPI_ADR_SPACE_PCI_CONFIG (ACPI_ADR_SPACE_TYPE) 2 #define ACPI_ADR_SPACE_EC (ACPI_ADR_SPACE_TYPE) 3 #define ACPI_ADR_SPACE_SMBUS (ACPI_ADR_SPACE_TYPE) 4 #define ACPI_ADR_SPACE_CMOS (ACPI_ADR_SPACE_TYPE) 5 #define ACPI_ADR_SPACE_PCI_BAR_TARGET (ACPI_ADR_SPACE_TYPE) 6 /* * External ACPI object definition */ typedef union AcpiObj { ACPI_OBJECT_TYPE Type; /* See definition of AcpiNsType for values */ struct { ACPI_OBJECT_TYPE Type; ACPI_INTEGER Value; /* The actual number */ } Integer; struct { ACPI_OBJECT_TYPE Type; UINT32 Length; /* # of bytes in string, excluding trailing null */ NATIVE_CHAR *Pointer; /* points to the string value */ } String; struct { ACPI_OBJECT_TYPE Type; UINT32 Length; /* # of bytes in buffer */ UINT8 *Pointer; /* points to the buffer */ } Buffer; struct { ACPI_OBJECT_TYPE Type; UINT32 Fill1; ACPI_HANDLE Handle; /* object reference */ } Reference; struct { ACPI_OBJECT_TYPE Type; UINT32 Count; /* # of elements in package */ union AcpiObj *Elements; /* Pointer to an array of ACPI_OBJECTs */ } Package; struct { ACPI_OBJECT_TYPE Type; UINT32 ProcId; ACPI_IO_ADDRESS PblkAddress; UINT32 PblkLength; } Processor; struct { ACPI_OBJECT_TYPE Type; UINT32 SystemLevel; UINT32 ResourceOrder; } PowerResource; } ACPI_OBJECT, *PACPI_OBJECT; /* * List of objects, used as a parameter list for control method evaluation */ typedef struct AcpiObjList { UINT32 Count; ACPI_OBJECT *Pointer; } ACPI_OBJECT_LIST, *PACPI_OBJECT_LIST; /* * Miscellaneous common Data Structures used by the interfaces */ typedef struct { UINT32 Length; /* Length in bytes of the buffer */ void *Pointer; /* pointer to buffer */ } ACPI_BUFFER; /* * NameType for AcpiGetName */ #define ACPI_FULL_PATHNAME 0 #define ACPI_SINGLE_NAME 1 #define ACPI_NAME_TYPE_MAX 1 /* * Structure and flags for AcpiGetSystemInfo */ #define SYS_MODE_UNKNOWN 0x0000 #define SYS_MODE_ACPI 0x0001 #define SYS_MODE_LEGACY 0x0002 #define SYS_MODES_MASK 0x0003 /* * ACPI Table Info. One per ACPI table _type_ */ typedef struct AcpiTableInfo { UINT32 Count; } ACPI_TABLE_INFO; /* * System info returned by AcpiGetSystemInfo() */ typedef struct _AcpiSysInfo { UINT32 AcpiCaVersion; UINT32 Flags; UINT32 TimerResolution; UINT32 Reserved1; UINT32 Reserved2; UINT32 DebugLevel; UINT32 DebugLayer; UINT32 NumTableTypes; ACPI_TABLE_INFO TableInfo [NUM_ACPI_TABLES]; } ACPI_SYSTEM_INFO; /* * Various handlers and callback procedures */ typedef UINT32 (*ACPI_EVENT_HANDLER) ( void *Context); typedef void (*ACPI_GPE_HANDLER) ( void *Context); typedef void (*ACPI_NOTIFY_HANDLER) ( ACPI_HANDLE Device, UINT32 Value, void *Context); /* Address Spaces (Operation Regions */ #define ACPI_READ_ADR_SPACE 1 #define ACPI_WRITE_ADR_SPACE 2 typedef ACPI_STATUS (*ACPI_ADR_SPACE_HANDLER) ( UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT32 *Value, void *HandlerContext, void *RegionContext); #define ACPI_DEFAULT_HANDLER ((ACPI_ADR_SPACE_HANDLER) NULL) typedef ACPI_STATUS (*ACPI_ADR_SPACE_SETUP) ( ACPI_HANDLE RegionHandle, UINT32 Function, void *HandlerContext, void **RegionContext); #define ACPI_REGION_ACTIVATE 0 #define ACPI_REGION_DEACTIVATE 1 typedef ACPI_STATUS (*ACPI_WALK_CALLBACK) ( ACPI_HANDLE ObjHandle, UINT32 NestingLevel, void *Context, void **ReturnValue); /* Interrupt handler return values */ #define INTERRUPT_NOT_HANDLED 0x00 #define INTERRUPT_HANDLED 0x01 /* Structure and flags for AcpiGetDeviceInfo */ #define ACPI_VALID_HID 0x1 #define ACPI_VALID_UID 0x2 #define ACPI_VALID_ADR 0x4 #define ACPI_VALID_STA 0x8 #define ACPI_COMMON_OBJ_INFO \ ACPI_OBJECT_TYPE Type; /* ACPI object type */ \ ACPI_NAME Name /* ACPI object Name */ typedef struct { ACPI_COMMON_OBJ_INFO; } ACPI_OBJ_INFO_HEADER; typedef struct { ACPI_COMMON_OBJ_INFO; UINT32 Valid; /* Are the next bits legit? */ NATIVE_CHAR HardwareId[9]; /* _HID value if any */ NATIVE_CHAR UniqueId[9]; /* _UID value if any */ ACPI_INTEGER Address; /* _ADR value if any */ UINT32 CurrentStatus; /* _STA value */ } ACPI_DEVICE_INFO; /* Context structs for address space handlers */ typedef struct { UINT16 Segment; UINT16 Bus; UINT16 Device; UINT16 Function; } ACPI_PCI_ID; typedef struct { ACPI_PHYSICAL_ADDRESS MappedPhysicalAddress; UINT8 *MappedLogicalAddress; UINT32 MappedLength; } ACPI_MEM_SPACE_CONTEXT; /* * Definitions for Resource Attributes */ /* * Memory Attributes */ #define READ_ONLY_MEMORY (UINT8) 0x00 #define READ_WRITE_MEMORY (UINT8) 0x01 #define NON_CACHEABLE_MEMORY (UINT8) 0x00 #define CACHABLE_MEMORY (UINT8) 0x01 #define WRITE_COMBINING_MEMORY (UINT8) 0x02 #define PREFETCHABLE_MEMORY (UINT8) 0x03 /* * IO Attributes * The ISA IO ranges are: n000-n0FFh, n400-n4FFh, n800-n8FFh, nC00-nCFFh. * The non-ISA IO ranges are: n100-n3FFh, n500-n7FFh, n900-nBFFh, nCD0-nFFFh. */ #define NON_ISA_ONLY_RANGES (UINT8) 0x01 #define ISA_ONLY_RANGES (UINT8) 0x02 #define ENTIRE_RANGE (NON_ISA_ONLY_RANGES | ISA_ONLY_RANGES) /* * IO Port Descriptor Decode */ #define DECODE_10 (UINT8) 0x00 /* 10-bit IO address decode */ #define DECODE_16 (UINT8) 0x01 /* 16-bit IO address decode */ /* * IRQ Attributes */ #define EDGE_SENSITIVE (UINT8) 0x00 #define LEVEL_SENSITIVE (UINT8) 0x01 #define ACTIVE_HIGH (UINT8) 0x00 #define ACTIVE_LOW (UINT8) 0x01 #define EXCLUSIVE (UINT8) 0x00 #define SHARED (UINT8) 0x01 /* * DMA Attributes */ #define COMPATIBILITY (UINT8) 0x00 #define TYPE_A (UINT8) 0x01 #define TYPE_B (UINT8) 0x02 #define TYPE_F (UINT8) 0x03 #define NOT_BUS_MASTER (UINT8) 0x00 #define BUS_MASTER (UINT8) 0x01 #define TRANSFER_8 (UINT8) 0x00 #define TRANSFER_8_16 (UINT8) 0x01 #define TRANSFER_16 (UINT8) 0x02 /* * Start Dependent Functions Priority definitions */ #define GOOD_CONFIGURATION (UINT8) 0x00 #define ACCEPTABLE_CONFIGURATION (UINT8) 0x01 #define SUB_OPTIMAL_CONFIGURATION (UINT8) 0x02 /* * 16, 32 and 64-bit Address Descriptor resource types */ #define MEMORY_RANGE (UINT8) 0x00 #define IO_RANGE (UINT8) 0x01 #define BUS_NUMBER_RANGE (UINT8) 0x02 #define ADDRESS_NOT_FIXED (UINT8) 0x00 #define ADDRESS_FIXED (UINT8) 0x01 #define POS_DECODE (UINT8) 0x00 #define SUB_DECODE (UINT8) 0x01 #define PRODUCER (UINT8) 0x00 #define CONSUMER (UINT8) 0x01 /* * Structures used to describe device resources */ typedef struct { UINT32 EdgeLevel; UINT32 ActiveHighLow; UINT32 SharedExclusive; UINT32 NumberOfInterrupts; UINT32 Interrupts[1]; } ACPI_RESOURCE_IRQ; typedef struct { UINT32 Type; UINT32 BusMaster; UINT32 Transfer; UINT32 NumberOfChannels; UINT32 Channels[1]; } ACPI_RESOURCE_DMA; typedef struct { UINT32 CompatibilityPriority; UINT32 PerformanceRobustness; } ACPI_RESOURCE_START_DPF; /* * END_DEPENDENT_FUNCTIONS_RESOURCE struct is not * needed because it has no fields */ typedef struct { UINT32 IoDecode; UINT32 MinBaseAddress; UINT32 MaxBaseAddress; UINT32 Alignment; UINT32 RangeLength; } ACPI_RESOURCE_IO; typedef struct { UINT32 BaseAddress; UINT32 RangeLength; } ACPI_RESOURCE_FIXED_IO; typedef struct { UINT32 Length; UINT8 Reserved[1]; } ACPI_RESOURCE_VENDOR; typedef struct { UINT32 ReadWriteAttribute; UINT32 MinBaseAddress; UINT32 MaxBaseAddress; UINT32 Alignment; UINT32 RangeLength; } ACPI_RESOURCE_MEM24; typedef struct { UINT32 ReadWriteAttribute; UINT32 MinBaseAddress; UINT32 MaxBaseAddress; UINT32 Alignment; UINT32 RangeLength; } ACPI_RESOURCE_MEM32; typedef struct { UINT32 ReadWriteAttribute; UINT32 RangeBaseAddress; UINT32 RangeLength; } ACPI_RESOURCE_FIXED_MEM32; typedef struct { UINT16 CacheAttribute; UINT16 ReadWriteAttribute; } ACPI_MEMORY_ATTRIBUTE; typedef struct { UINT16 RangeAttribute; UINT16 Reserved; } ACPI_IO_ATTRIBUTE; typedef struct { UINT16 Reserved1; UINT16 Reserved2; } ACPI_BUS_ATTRIBUTE; typedef union { ACPI_MEMORY_ATTRIBUTE Memory; ACPI_IO_ATTRIBUTE Io; ACPI_BUS_ATTRIBUTE Bus; } ACPI_RESOURCE_ATTRIBUTE; typedef struct { UINT32 Index; UINT32 StringLength; NATIVE_CHAR *StringPtr; } ACPI_RESOURCE_SOURCE; typedef struct { UINT32 ResourceType; UINT32 ProducerConsumer; UINT32 Decode; UINT32 MinAddressFixed; UINT32 MaxAddressFixed; ACPI_RESOURCE_ATTRIBUTE Attribute; UINT32 Granularity; UINT32 MinAddressRange; UINT32 MaxAddressRange; UINT32 AddressTranslationOffset; UINT32 AddressLength; ACPI_RESOURCE_SOURCE ResourceSource; } ACPI_RESOURCE_ADDRESS16; typedef struct { UINT32 ResourceType; UINT32 ProducerConsumer; UINT32 Decode; UINT32 MinAddressFixed; UINT32 MaxAddressFixed; ACPI_RESOURCE_ATTRIBUTE Attribute; UINT32 Granularity; UINT32 MinAddressRange; UINT32 MaxAddressRange; UINT32 AddressTranslationOffset; UINT32 AddressLength; ACPI_RESOURCE_SOURCE ResourceSource; } ACPI_RESOURCE_ADDRESS32; typedef struct { UINT32 ResourceType; UINT32 ProducerConsumer; UINT32 Decode; UINT32 MinAddressFixed; UINT32 MaxAddressFixed; ACPI_RESOURCE_ATTRIBUTE Attribute; UINT64 Granularity; UINT64 MinAddressRange; UINT64 MaxAddressRange; UINT64 AddressTranslationOffset; UINT64 AddressLength; ACPI_RESOURCE_SOURCE ResourceSource; } ACPI_RESOURCE_ADDRESS64; typedef struct { UINT32 ProducerConsumer; UINT32 EdgeLevel; UINT32 ActiveHighLow; UINT32 SharedExclusive; UINT32 NumberOfInterrupts; ACPI_RESOURCE_SOURCE ResourceSource; UINT32 Interrupts[1]; } ACPI_RESOURCE_EXT_IRQ; /* ACPI_RESOURCE_TYPEs */ #define ACPI_RSTYPE_IRQ 0 #define ACPI_RSTYPE_DMA 1 #define ACPI_RSTYPE_START_DPF 2 #define ACPI_RSTYPE_END_DPF 3 #define ACPI_RSTYPE_IO 4 #define ACPI_RSTYPE_FIXED_IO 5 #define ACPI_RSTYPE_VENDOR 6 #define ACPI_RSTYPE_END_TAG 7 #define ACPI_RSTYPE_MEM24 8 #define ACPI_RSTYPE_MEM32 9 #define ACPI_RSTYPE_FIXED_MEM32 10 #define ACPI_RSTYPE_ADDRESS16 11 #define ACPI_RSTYPE_ADDRESS32 12 #define ACPI_RSTYPE_ADDRESS64 13 #define ACPI_RSTYPE_EXT_IRQ 14 typedef UINT32 ACPI_RESOURCE_TYPE; typedef union { ACPI_RESOURCE_IRQ Irq; ACPI_RESOURCE_DMA Dma; ACPI_RESOURCE_START_DPF StartDpf; ACPI_RESOURCE_IO Io; ACPI_RESOURCE_FIXED_IO FixedIo; ACPI_RESOURCE_VENDOR VendorSpecific; ACPI_RESOURCE_MEM24 Memory24; ACPI_RESOURCE_MEM32 Memory32; ACPI_RESOURCE_FIXED_MEM32 FixedMemory32; ACPI_RESOURCE_ADDRESS16 Address16; ACPI_RESOURCE_ADDRESS32 Address32; ACPI_RESOURCE_ADDRESS64 Address64; ACPI_RESOURCE_EXT_IRQ ExtendedIrq; } ACPI_RESOURCE_DATA; typedef struct AcpiResource { ACPI_RESOURCE_TYPE Id; UINT32 Length; ACPI_RESOURCE_DATA Data; } ACPI_RESOURCE; #define ACPI_RESOURCE_LENGTH 12 #define ACPI_RESOURCE_LENGTH_NO_DATA 8 /* Id + Length fields */ #define SIZEOF_RESOURCE(Type) (ACPI_RESOURCE_LENGTH_NO_DATA + sizeof (Type)) #define NEXT_RESOURCE(Res) (ACPI_RESOURCE *)((UINT8 *) Res + Res->length) /* * END: Definitions for Resource Attributes */ typedef struct pci_routing_table { UINT32 Length; UINT32 Pin; ACPI_INTEGER Address; /* here for 64-bit alignment */ UINT32 SourceIndex; NATIVE_CHAR Source[4]; /* pad to 64 bits so sizeof() works in all cases */ } PCI_ROUTING_TABLE; /* * END: Definitions for PCI Routing tables */ #endif /* __ACTYPES_H__ */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/acutils.h =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/acutils.h (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/acutils.h (revision 82367) @@ -1,741 +1,763 @@ /****************************************************************************** * * Name: acutils.h -- prototypes for the common (subsystem-wide) procedures - * $Revision: 104 $ + * $Revision: 108 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #ifndef _ACUTILS_H #define _ACUTILS_H typedef ACPI_STATUS (*ACPI_PKG_CALLBACK) ( UINT8 ObjectType, ACPI_OPERAND_OBJECT *SourceObject, ACPI_GENERIC_STATE *State, void *Context); ACPI_STATUS AcpiUtWalkPackageTree ( ACPI_OPERAND_OBJECT *SourceObject, void *TargetObject, ACPI_PKG_CALLBACK WalkCallback, void *Context); typedef struct acpi_pkg_info { UINT8 *FreeSpace; UINT32 Length; UINT32 ObjectSpace; UINT32 NumPackages; } ACPI_PKG_INFO; #define REF_INCREMENT (UINT16) 0 #define REF_DECREMENT (UINT16) 1 #define REF_FORCE_DELETE (UINT16) 2 /* AcpiUtDumpBuffer */ #define DB_BYTE_DISPLAY 1 #define DB_WORD_DISPLAY 2 #define DB_DWORD_DISPLAY 4 #define DB_QWORD_DISPLAY 8 /* Global initialization interfaces */ void AcpiUtInitGlobals ( void); void AcpiUtTerminate ( void); /* * UtInit - miscellaneous initialization and shutdown */ ACPI_STATUS AcpiUtHardwareInitialize ( void); ACPI_STATUS AcpiUtSubsystemShutdown ( void); ACPI_STATUS AcpiUtValidateFadt ( void); /* * UtGlobal - Global data structures and procedures */ #ifdef ACPI_DEBUG NATIVE_CHAR * AcpiUtGetMutexName ( UINT32 MutexId); NATIVE_CHAR * AcpiUtGetTypeName ( UINT32 Type); NATIVE_CHAR * AcpiUtGetRegionName ( UINT8 SpaceId); #endif +UINT8 +AcpiUtHexToAsciiChar ( + ACPI_INTEGER Integer, + UINT32 Position); + BOOLEAN AcpiUtValidObjectType ( UINT32 Type); ACPI_OWNER_ID AcpiUtAllocateOwnerId ( UINT32 IdType); /* * UtClib - Local implementations of C library functions */ #ifndef ACPI_USE_SYSTEM_CLIBRARY UINT32 AcpiUtStrlen ( const NATIVE_CHAR *String); NATIVE_CHAR * AcpiUtStrcpy ( NATIVE_CHAR *DstString, const NATIVE_CHAR *SrcString); NATIVE_CHAR * AcpiUtStrncpy ( NATIVE_CHAR *DstString, const NATIVE_CHAR *SrcString, NATIVE_UINT Count); UINT32 AcpiUtStrncmp ( const NATIVE_CHAR *String1, const NATIVE_CHAR *String2, NATIVE_UINT Count); UINT32 AcpiUtStrcmp ( const NATIVE_CHAR *String1, const NATIVE_CHAR *String2); NATIVE_CHAR * AcpiUtStrcat ( NATIVE_CHAR *DstString, const NATIVE_CHAR *SrcString); NATIVE_CHAR * AcpiUtStrncat ( NATIVE_CHAR *DstString, const NATIVE_CHAR *SrcString, NATIVE_UINT Count); UINT32 AcpiUtStrtoul ( const NATIVE_CHAR *String, NATIVE_CHAR **Terminator, UINT32 Base); NATIVE_CHAR * AcpiUtStrstr ( NATIVE_CHAR *String1, NATIVE_CHAR *String2); void * AcpiUtMemcpy ( void *Dest, const void *Src, NATIVE_UINT Count); void * AcpiUtMemset ( void *Dest, NATIVE_UINT Value, NATIVE_UINT Count); UINT32 AcpiUtToUpper ( UINT32 c); UINT32 AcpiUtToLower ( UINT32 c); #endif /* ACPI_USE_SYSTEM_CLIBRARY */ /* * UtCopy - Object construction and conversion interfaces */ ACPI_STATUS AcpiUtBuildSimpleObject( ACPI_OPERAND_OBJECT *Obj, ACPI_OBJECT *UserObj, UINT8 *DataSpace, UINT32 *BufferSpaceUsed); ACPI_STATUS AcpiUtBuildPackageObject ( ACPI_OPERAND_OBJECT *Obj, UINT8 *Buffer, UINT32 *SpaceUsed); ACPI_STATUS AcpiUtCopyIobjectToEobject ( ACPI_OPERAND_OBJECT *Obj, ACPI_BUFFER *RetBuffer); ACPI_STATUS AcpiUtCopyEsimpleToIsimple( ACPI_OBJECT *UserObj, ACPI_OPERAND_OBJECT *Obj); ACPI_STATUS AcpiUtCopyEobjectToIobject ( ACPI_OBJECT *Obj, ACPI_OPERAND_OBJECT *InternalObj); ACPI_STATUS AcpiUtCopyISimpleToIsimple ( ACPI_OPERAND_OBJECT *SourceObj, ACPI_OPERAND_OBJECT *DestObj); ACPI_STATUS AcpiUtCopyIpackageToIpackage ( ACPI_OPERAND_OBJECT *SourceObj, ACPI_OPERAND_OBJECT *DestObj, ACPI_WALK_STATE *WalkState); /* * UtCreate - Object creation */ ACPI_STATUS AcpiUtUpdateObjectReference ( ACPI_OPERAND_OBJECT *Object, UINT16 Action); ACPI_OPERAND_OBJECT * _UtCreateInternalObject ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, ACPI_OBJECT_TYPE8 Type); /* * UtDebug - Debug interfaces */ UINT32 GetDebugLevel ( void); void SetDebugLevel ( UINT32 level); void FunctionTrace ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName); void FunctionTracePtr ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, void *Pointer); void FunctionTraceU32 ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, UINT32 Integer); void FunctionTraceStr ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, NATIVE_CHAR *String); void FunctionExit ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName); void FunctionStatusExit ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, ACPI_STATUS Status); void FunctionValueExit ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, ACPI_INTEGER Value); void FunctionPtrExit ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, UINT8 *Ptr); void -DebugPrintPrefix ( - NATIVE_CHAR *ModuleName, - UINT32 LineNumber); - -void -DebugPrint ( - NATIVE_CHAR *ModuleName, - UINT32 LineNumber, - UINT32 ComponentId, - UINT32 PrintLevel, - NATIVE_CHAR *Format, ...); - -void -DebugPrintRaw ( - NATIVE_CHAR *Format, ...); - -void _ReportInfo ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId); void _ReportError ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId); void _ReportWarning ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId); void AcpiUtDumpBuffer ( UINT8 *Buffer, UINT32 Count, UINT32 Display, UINT32 componentId); +void +AcpiUtDebugPrint ( + UINT32 RequestedDebugLevel, + UINT32 ComponentId, + NATIVE_CHAR *ModuleName, + NATIVE_CHAR *ProcName, + UINT32 LineNumber, + char *Format, + ...); +void +AcpiUtDebugPrintRaw ( + UINT32 RequestedDebugLevel, + UINT32 ComponentId, + NATIVE_CHAR *ModuleName, + NATIVE_CHAR *ProcName, + UINT32 LineNumber, + char *Format, + ...); + /* * UtDelete - Object deletion */ void AcpiUtDeleteInternalObj ( ACPI_OPERAND_OBJECT *Object); void AcpiUtDeleteInternalPackageObject ( ACPI_OPERAND_OBJECT *Object); void AcpiUtDeleteInternalSimpleObject ( ACPI_OPERAND_OBJECT *Object); ACPI_STATUS AcpiUtDeleteInternalObjectList ( ACPI_OPERAND_OBJECT **ObjList); /* * UtEval - object evaluation */ /* Method name strings */ #define METHOD_NAME__HID "_HID" #define METHOD_NAME__UID "_UID" #define METHOD_NAME__ADR "_ADR" #define METHOD_NAME__STA "_STA" #define METHOD_NAME__REG "_REG" #define METHOD_NAME__SEG "_SEG" #define METHOD_NAME__BBN "_BBN" ACPI_STATUS AcpiUtEvaluateNumericObject ( NATIVE_CHAR *ObjectName, ACPI_NAMESPACE_NODE *DeviceNode, ACPI_INTEGER *Address); ACPI_STATUS AcpiUtExecute_HID ( ACPI_NAMESPACE_NODE *DeviceNode, ACPI_DEVICE_ID *Hid); ACPI_STATUS AcpiUtExecute_STA ( ACPI_NAMESPACE_NODE *DeviceNode, UINT32 *StatusFlags); ACPI_STATUS AcpiUtExecute_UID ( ACPI_NAMESPACE_NODE *DeviceNode, ACPI_DEVICE_ID *Uid); /* * UtMutex - mutual exclusion interfaces */ ACPI_STATUS AcpiUtMutexInitialize ( void); void AcpiUtMutexTerminate ( void); ACPI_STATUS AcpiUtCreateMutex ( ACPI_MUTEX_HANDLE MutexId); ACPI_STATUS AcpiUtDeleteMutex ( ACPI_MUTEX_HANDLE MutexId); ACPI_STATUS AcpiUtAcquireMutex ( ACPI_MUTEX_HANDLE MutexId); ACPI_STATUS AcpiUtReleaseMutex ( ACPI_MUTEX_HANDLE MutexId); /* * UtObject - internal object create/delete/cache routines */ void * _UtAllocateObjectDesc ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId); #define AcpiUtCreateInternalObject(t) _UtCreateInternalObject(_THIS_MODULE,__LINE__,_COMPONENT,t) #define AcpiUtAllocateObjectDesc() _UtAllocateObjectDesc(_THIS_MODULE,__LINE__,_COMPONENT) void AcpiUtDeleteObjectDesc ( ACPI_OPERAND_OBJECT *Object); BOOLEAN AcpiUtValidInternalObject ( void *Object); /* * UtRefCnt - Object reference count management */ void AcpiUtAddReference ( ACPI_OPERAND_OBJECT *Object); void AcpiUtRemoveReference ( ACPI_OPERAND_OBJECT *Object); /* * UtSize - Object size routines */ ACPI_STATUS AcpiUtGetSimpleObjectSize ( ACPI_OPERAND_OBJECT *Obj, UINT32 *ObjLength); ACPI_STATUS AcpiUtGetPackageObjectSize ( ACPI_OPERAND_OBJECT *Obj, UINT32 *ObjLength); ACPI_STATUS AcpiUtGetObjectSize( ACPI_OPERAND_OBJECT *Obj, UINT32 *ObjLength); /* * UtState - Generic state creation/cache routines */ void AcpiUtPushGenericState ( ACPI_GENERIC_STATE **ListHead, ACPI_GENERIC_STATE *State); ACPI_GENERIC_STATE * AcpiUtPopGenericState ( ACPI_GENERIC_STATE **ListHead); ACPI_GENERIC_STATE * AcpiUtCreateGenericState ( void); ACPI_GENERIC_STATE * AcpiUtCreateUpdateState ( ACPI_OPERAND_OBJECT *Object, UINT16 Action); ACPI_GENERIC_STATE * AcpiUtCreatePkgState ( void *InternalObject, void *ExternalObject, UINT16 Index); ACPI_STATUS AcpiUtCreateUpdateStateAndPush ( ACPI_OPERAND_OBJECT *Object, UINT16 Action, ACPI_GENERIC_STATE **StateList); ACPI_STATUS AcpiUtCreatePkgStateAndPush ( void *InternalObject, void *ExternalObject, UINT16 Index, ACPI_GENERIC_STATE **StateList); ACPI_GENERIC_STATE * AcpiUtCreateControlState ( void); void AcpiUtDeleteGenericState ( ACPI_GENERIC_STATE *State); void AcpiUtDeleteGenericStateCache ( void); void AcpiUtDeleteObjectCache ( void); /* * Ututils */ BOOLEAN AcpiUtValidAcpiName ( UINT32 Name); BOOLEAN AcpiUtValidAcpiCharacter ( NATIVE_CHAR Character); NATIVE_CHAR * AcpiUtStrupr ( NATIVE_CHAR *SrcString); ACPI_STATUS AcpiUtResolvePackageReferences ( ACPI_OPERAND_OBJECT *ObjDesc); #ifdef ACPI_DEBUG void AcpiUtDisplayInitPathname ( ACPI_HANDLE ObjHandle, char *Path); #endif /* - * Memory allocation functions and related macros. - * Macros that expand to include filename and line number + * Utalloc - memory allocation and object caching */ + +void * +AcpiUtAcquireFromCache ( + UINT32 ListId); + +void +AcpiUtReleaseToCache ( + UINT32 ListId, + void *Object); + +void +AcpiUtDeleteGenericCache ( + UINT32 ListId); + + +/* Debug Memory allocation functions */ void * AcpiUtAllocate ( UINT32 Size, UINT32 Component, NATIVE_CHAR *Module, UINT32 Line); void * AcpiUtCallocate ( UINT32 Size, UINT32 Component, NATIVE_CHAR *Module, UINT32 Line); void AcpiUtFree ( void *Address, UINT32 Component, NATIVE_CHAR *Module, UINT32 Line); void AcpiUtInitStaticObject ( ACPI_OPERAND_OBJECT *ObjDesc); #ifdef ACPI_DBG_TRACK_ALLOCATIONS void AcpiUtDumpAllocationInfo ( void); void AcpiUtDumpCurrentAllocations ( UINT32 Component, NATIVE_CHAR *Module); #endif #endif /* _ACUTILS_H */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbdisasm.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbdisasm.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbdisasm.c (revision 82367) @@ -1,831 +1,848 @@ /******************************************************************************* * * Module Name: dbdisasm - parser op tree display routines - * $Revision: 40 $ + * $Revision: 43 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #include "acnamesp.h" #include "acdebug.h" #ifdef ENABLE_DEBUGGER #define _COMPONENT ACPI_DEBUGGER MODULE_NAME ("dbdisasm") #define MAX_SHOW_ENTRY 128 #define BLOCK_PAREN 1 #define BLOCK_BRACE 2 #define DB_NO_OP_INFO " [%2.2d] " #define DB_FULL_OP_INFO "%5.5X #%4.4X [%2.2d] " NATIVE_CHAR *INDENT_STRING = "...."; /******************************************************************************* * * FUNCTION: AcpiDbBlockType * * PARAMETERS: Op - Object to be examined * * RETURN: Status * * DESCRIPTION: Type of block for this op (parens or braces) * ******************************************************************************/ UINT32 AcpiDbBlockType ( ACPI_PARSE_OBJECT *Op) { switch (Op->Opcode) { case AML_METHOD_OP: return (BLOCK_BRACE); break; default: break; } return (BLOCK_PAREN); } /******************************************************************************* * * FUNCTION: AcpiPsDisplayObjectPathname * * PARAMETERS: Op - Object whose pathname is to be obtained * * RETURN: Status * * DESCRIPTION: Diplay the pathname associated with a named object. Two * versions. One searches the parse tree (for parser-only * applications suchas AcpiDump), and the other searches the * ACPI namespace (the parse tree is probably deleted) * ******************************************************************************/ #ifdef PARSER_ONLY ACPI_STATUS AcpiPsDisplayObjectPathname ( ACPI_PARSE_OBJECT *Op) { ACPI_PARSE_OBJECT *TargetOp; /* Search parent tree up to the root if necessary */ TargetOp = AcpiPsFind (Op, Op->Value.Name, 0, 0); if (!TargetOp) { /* * Didn't find the name in the parse tree. This may be * a problem, or it may simply be one of the predefined names * (such as _OS_). Rather than worry about looking up all * the predefined names, just display the name as given */ AcpiOsPrintf (" **** Path not found in parse tree"); } else { /* The target was found, print the name and complete path */ AcpiOsPrintf (" (Path "); AcpiDbDisplayPath (TargetOp); AcpiOsPrintf (")"); } return (AE_OK); } #else ACPI_STATUS AcpiPsDisplayObjectPathname ( ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status; ACPI_NAMESPACE_NODE *Node; NATIVE_CHAR Buffer[MAX_SHOW_ENTRY]; UINT32 BufferSize = MAX_SHOW_ENTRY; AcpiOsPrintf (" (Path "); /* Just get the Node out of the Op object */ Node = Op->Node; if (!Node) { /* * No Named obj, so we can't get the pathname since the object * is not in the namespace. This can happen during single * stepping where a dynamic named object is *about* to be created. */ return (AE_OK); } /* Convert NamedDesc/handle to a full pathname */ Status = AcpiNsHandleToPathname (Node, &BufferSize, Buffer); if (ACPI_FAILURE (Status)) { AcpiOsPrintf ("****Could not get pathname****)"); return (Status); } AcpiOsPrintf ("%s)", Buffer); return (AE_OK); } #endif /******************************************************************************* * * FUNCTION: AcpiDbDisplayOp * * PARAMETERS: Origin - Starting object * NumOpcodes - Max number of opcodes to be displayed * * RETURN: None * * DESCRIPTION: Display parser object and its children * ******************************************************************************/ void AcpiDbDisplayOp ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Origin, UINT32 NumOpcodes) { ACPI_PARSE_OBJECT *Op = Origin; ACPI_PARSE_OBJECT *arg; ACPI_PARSE_OBJECT *depth; UINT32 DepthCount = 0; UINT32 LastDepth = 0; UINT32 i; UINT32 j; if (Op) { while (Op) { /* indentation */ DepthCount = 0; if (!opt_verbose) { DepthCount++; } /* Determine the nesting depth of this argument */ for (depth = Op->Parent; depth; depth = depth->Parent) { arg = AcpiPsGetArg (depth, 0); while (arg && arg != Origin) { arg = arg->Next; } if (arg) { break; } DepthCount++; } /* Open a new block if we are nested further than last time */ if (DepthCount > LastDepth) { VERBOSE_PRINT ((DB_NO_OP_INFO, LastDepth)); for (i = 0; i < LastDepth; i++) { - AcpiOsPrintf (INDENT_STRING); + AcpiOsPrintf ("%s", INDENT_STRING); } if (AcpiDbBlockType (Op) == BLOCK_PAREN) { AcpiOsPrintf ("(\n"); } else { AcpiOsPrintf ("{\n"); } } /* Close a block if we are nested less than last time */ else if (DepthCount < LastDepth) { for (j = 0; j < (LastDepth - DepthCount); j++) { VERBOSE_PRINT ((DB_NO_OP_INFO, LastDepth - j)); for (i = 0; i < (LastDepth - j - 1); i++) { - AcpiOsPrintf (INDENT_STRING); + AcpiOsPrintf ("%s", INDENT_STRING); } if (AcpiDbBlockType (Op) == BLOCK_PAREN) { AcpiOsPrintf (")\n"); } else { AcpiOsPrintf ("}\n"); } } } /* In verbose mode, print the AML offset, opcode and depth count */ VERBOSE_PRINT ((DB_FULL_OP_INFO, (unsigned) Op->AmlOffset, Op->Opcode, DepthCount)); /* Indent the output according to the depth count */ for (i = 0; i < DepthCount; i++) { - AcpiOsPrintf (INDENT_STRING); + AcpiOsPrintf ("%s", INDENT_STRING); } /* Now print the opcode */ AcpiDbDisplayOpcode (WalkState, Op); /* Resolve a name reference */ if ((Op->Opcode == AML_INT_NAMEPATH_OP && Op->Value.Name) && (Op->Parent) && (opt_verbose)) { AcpiPsDisplayObjectPathname (Op); } AcpiOsPrintf ("\n"); /* Get the next node in the tree */ Op = AcpiPsGetDepthNext (Origin, Op); LastDepth = DepthCount; NumOpcodes--; if (!NumOpcodes) { Op = NULL; } } /* Close the last block(s) */ DepthCount = LastDepth -1; for (i = 0; i < LastDepth; i++) { VERBOSE_PRINT ((DB_NO_OP_INFO, LastDepth - i)); for (j = 0; j < DepthCount; j++) { - AcpiOsPrintf (INDENT_STRING); + AcpiOsPrintf ("%s", INDENT_STRING); } AcpiOsPrintf ("}\n"); DepthCount--; } } else { AcpiDbDisplayOpcode (WalkState, Op); } } /******************************************************************************* * * FUNCTION: AcpiDbDisplayNamestring * * PARAMETERS: Name - ACPI Name string to store * * RETURN: None * * DESCRIPTION: Display namestring. Handles prefix characters * ******************************************************************************/ void AcpiDbDisplayNamestring ( NATIVE_CHAR *Name) { UINT32 SegCount; BOOLEAN DoDot = FALSE; if (!Name) { AcpiOsPrintf (""); return; } if (AcpiPsIsPrefixChar (GET8 (Name))) { /* append prefix character */ AcpiOsPrintf ("%1c", GET8 (Name)); Name++; } switch (GET8 (Name)) { case AML_DUAL_NAME_PREFIX: SegCount = 2; Name++; break; case AML_MULTI_NAME_PREFIX_OP: SegCount = (UINT32) GET8 (Name + 1); Name += 2; break; default: SegCount = 1; break; } while (SegCount--) { /* append Name segment */ if (DoDot) { /* append dot */ AcpiOsPrintf ("."); } AcpiOsPrintf ("%4.4s", Name); DoDot = TRUE; Name += 4; } } /******************************************************************************* * * FUNCTION: AcpiDbDisplayPath * * PARAMETERS: Op - Named Op whose path is to be constructed * * RETURN: None * * DESCRIPTION: Walk backwards from current scope and display the name * of each previous level of scope up to the root scope * (like "pwd" does with file systems) * ******************************************************************************/ void AcpiDbDisplayPath ( ACPI_PARSE_OBJECT *Op) { ACPI_PARSE_OBJECT *Prev; ACPI_PARSE_OBJECT *Search; UINT32 Name; BOOLEAN DoDot = FALSE; ACPI_PARSE_OBJECT *NamePath; /* We are only interested in named objects */ if (!AcpiPsIsNodeOp (Op->Opcode)) { return; } if (AcpiPsIsCreateFieldOp (Op->Opcode)) { /* Field creation - check for a fully qualified namepath */ if (Op->Opcode == AML_CREATE_FIELD_OP) { NamePath = AcpiPsGetArg (Op, 3); } else { NamePath = AcpiPsGetArg (Op, 2); } if ((NamePath) && (NamePath->Value.String) && (NamePath->Value.String[0] == '\\')) { AcpiDbDisplayNamestring (NamePath->Value.String); return; } } Prev = NULL; /* Start with Root Node */ while (Prev != Op) { /* Search upwards in the tree to find scope with "prev" as its parent */ Search = Op; for (; ;) { if (Search->Parent == Prev) { break; } /* Go up one level */ Search = Search->Parent; } if (Prev && !AcpiPsIsFieldOp (Search->Opcode)) { /* below root scope, append scope name */ if (DoDot) { /* append dot */ AcpiOsPrintf ("."); } if (AcpiPsIsCreateFieldOp (Search->Opcode)) { if (Op->Opcode == AML_CREATE_FIELD_OP) { NamePath = AcpiPsGetArg (Op, 3); } else { NamePath = AcpiPsGetArg (Op, 2); } if ((NamePath) && (NamePath->Value.String)) { AcpiOsPrintf ("%4.4s", NamePath->Value.String); } } else { Name = AcpiPsGetName (Search); AcpiOsPrintf ("%4.4s", &Name); } DoDot = TRUE; } Prev = Search; } } /******************************************************************************* * * FUNCTION: AcpiDbDisplayOpcode * * PARAMETERS: Op - Op that is to be printed * * RETURN: Status * * DESCRIPTION: Store printed op in a Buffer and return its length * (or -1 if out of space) * * NOTE: Terse mode prints out ASL-like code. Verbose mode adds more info. * ******************************************************************************/ void AcpiDbDisplayOpcode ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { UINT8 *ByteData; UINT32 ByteCount; UINT32 i; ACPI_OPCODE_INFO *Opc = NULL; UINT32 Name; if (!Op) { AcpiOsPrintf (""); } /* op and arguments */ switch (Op->Opcode) { case AML_BYTE_OP: if (opt_verbose) { - AcpiOsPrintf ("(UINT8) 0x%2.2X", Op->Value.Integer & ACPI_UINT8_MAX); + AcpiOsPrintf ("(UINT8) 0x%2.2X", Op->Value.Integer8); } else { - AcpiOsPrintf ("0x%2.2X", Op->Value.Integer & ACPI_UINT8_MAX); + AcpiOsPrintf ("0x%2.2X", Op->Value.Integer8); } break; case AML_WORD_OP: if (opt_verbose) { - AcpiOsPrintf ("(UINT16) 0x%4.4X", Op->Value.Integer & ACPI_UINT16_MAX); + AcpiOsPrintf ("(UINT16) 0x%4.4X", Op->Value.Integer16); } else { - AcpiOsPrintf ("0x%4.4X", Op->Value.Integer & ACPI_UINT16_MAX); + AcpiOsPrintf ("0x%4.4X", Op->Value.Integer16); } break; case AML_DWORD_OP: if (opt_verbose) { - AcpiOsPrintf ("(UINT32) 0x%8.8X", Op->Value.Integer); + AcpiOsPrintf ("(UINT32) 0x%8.8X", Op->Value.Integer32); } else { - AcpiOsPrintf ("0x%8.8X", Op->Value.Integer); + AcpiOsPrintf ("0x%8.8X", Op->Value.Integer32); } break; + case AML_QWORD_OP: + + if (opt_verbose) + { + AcpiOsPrintf ("(UINT64) 0x%8.8X%8.8X", Op->Value.Integer64.Hi, + Op->Value.Integer64.Lo); + } + + else + { + AcpiOsPrintf ("0x%8.8X%8.8X", Op->Value.Integer64.Hi, + Op->Value.Integer64.Lo); + } + + break; + + case AML_STRING_OP: if (Op->Value.String) { AcpiOsPrintf ("\"%s\"", Op->Value.String); } else { AcpiOsPrintf ("<\"NULL STRING PTR\">"); } break; case AML_INT_STATICSTRING_OP: if (Op->Value.String) { AcpiOsPrintf ("\"%s\"", Op->Value.String); } else { AcpiOsPrintf ("\"\""); } break; case AML_INT_NAMEPATH_OP: AcpiDbDisplayNamestring (Op->Value.Name); break; case AML_INT_NAMEDFIELD_OP: - AcpiOsPrintf ("NamedField (Length 0x%8.8X) ", Op->Value.Integer); + AcpiOsPrintf ("NamedField (Length 0x%8.8X) ", Op->Value.Integer32); break; case AML_INT_RESERVEDFIELD_OP: - AcpiOsPrintf ("ReservedField (Length 0x%8.8X) ", Op->Value.Integer); + AcpiOsPrintf ("ReservedField (Length 0x%8.8X) ", Op->Value.Integer32); break; case AML_INT_ACCESSFIELD_OP: - AcpiOsPrintf ("AccessField (Length 0x%8.8X) ", Op->Value.Integer); + AcpiOsPrintf ("AccessField (Length 0x%8.8X) ", Op->Value.Integer32); break; case AML_INT_BYTELIST_OP: if (opt_verbose) { - AcpiOsPrintf ("ByteList (Length 0x%8.8X) ", Op->Value.Integer); + AcpiOsPrintf ("ByteList (Length 0x%8.8X) ", Op->Value.Integer32); } else { - AcpiOsPrintf ("0x%2.2X", Op->Value.Integer); + AcpiOsPrintf ("0x%2.2X", Op->Value.Integer32); - ByteCount = Op->Value.Integer; + ByteCount = Op->Value.Integer32; ByteData = ((ACPI_PARSE2_OBJECT *) Op)->Data; for (i = 0; i < ByteCount; i++) { AcpiOsPrintf (", 0x%2.2X", ByteData[i]); } } break; default: /* Just get the opcode name and print it */ Opc = AcpiPsGetOpcodeInfo (Op->Opcode); AcpiOsPrintf ("%s", Opc->Name); #ifndef PARSER_ONLY if ((Op->Opcode == AML_INT_RETURN_VALUE_OP) && (WalkState->Results) && (WalkState->Results->Results.NumResults)) { AcpiDbDecodeInternalObject (WalkState->Results->Results.ObjDesc [WalkState->Results->Results.NumResults-1]); } #endif break; } if (!Opc) { /* If there is another element in the list, add a comma */ if (Op->Next) { AcpiOsPrintf (","); } } /* * If this is a named opcode, print the associated name value */ if (Op && AcpiPsIsNamedOp (Op->Opcode)) { Name = AcpiPsGetName (Op); AcpiOsPrintf (" %4.4s", &Name); if (opt_verbose) { AcpiOsPrintf (" (Path \\"); AcpiDbDisplayPath (Op); AcpiOsPrintf (")"); } } } #endif /* ENABLE_DEBUGGER */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbdisply.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbdisply.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbdisply.c (revision 82367) @@ -1,937 +1,943 @@ /******************************************************************************* * * Module Name: dbdisply - debug display commands - * $Revision: 46 $ + * $Revision: 47 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #include "acdispat.h" #include "acnamesp.h" #include "acparser.h" #include "acevents.h" #include "acinterp.h" #include "acdebug.h" #ifdef ENABLE_DEBUGGER #define _COMPONENT ACPI_DEBUGGER MODULE_NAME ("dbdisply") /****************************************************************************** * * FUNCTION: AcpiDbGetPointer * * PARAMETERS: Target - Pointer to string to be converted * * RETURN: Converted pointer * * DESCRIPTION: Convert an ascii pointer value to a real value * *****************************************************************************/ void * AcpiDbGetPointer ( void *Target) { void *ObjPtr; #ifdef _IA16 #include /* Have to handle 16-bit pointers of the form segment:offset */ if (!sscanf (Target, "%p", &ObjPtr)) { AcpiOsPrintf ("Invalid pointer: %s\n", Target); return (NULL); } #else /* Simple flat pointer */ ObjPtr = (void *) STRTOUL (Target, NULL, 16); #endif return (ObjPtr); } /******************************************************************************* * * FUNCTION: AcpiDbDumpParserDescriptor * * PARAMETERS: Op - A parser Op descriptor * * RETURN: None * * DESCRIPTION: Display a formatted parser object * ******************************************************************************/ void AcpiDbDumpParserDescriptor ( ACPI_PARSE_OBJECT *Op) { ACPI_OPCODE_INFO *Info; Info = AcpiPsGetOpcodeInfo (Op->Opcode); AcpiOsPrintf ("Parser Op Descriptor:\n"); AcpiOsPrintf ("%20.20s : %4.4X\n", "Opcode", Op->Opcode); DEBUG_ONLY_MEMBERS (AcpiOsPrintf ("%20.20s : %s\n", "Opcode Name", Info->Name)); AcpiOsPrintf ("%20.20s : %p\n", "Value/ArgList", Op->Value); AcpiOsPrintf ("%20.20s : %p\n", "Parent", Op->Parent); AcpiOsPrintf ("%20.20s : %p\n", "NextOp", Op->Next); } /******************************************************************************* * * FUNCTION: AcpiDbDecodeAndDisplayObject * * PARAMETERS: Target - String with object to be displayed. Names * and hex pointers are supported. * OutputType - Byte, Word, Dword, or Qword (B|W|D|Q) * * RETURN: None * * DESCRIPTION: Display a formatted ACPI object * ******************************************************************************/ void AcpiDbDecodeAndDisplayObject ( NATIVE_CHAR *Target, NATIVE_CHAR *OutputType) { void *ObjPtr; ACPI_NAMESPACE_NODE *Node; UINT32 Display = DB_BYTE_DISPLAY; NATIVE_CHAR Buffer[80]; ACPI_BUFFER RetBuf; ACPI_STATUS Status; UINT32 Size; if (!Target) { return; } /* Decode the output type */ if (OutputType) { STRUPR (OutputType); if (OutputType[0] == 'W') { Display = DB_WORD_DISPLAY; } else if (OutputType[0] == 'D') { Display = DB_DWORD_DISPLAY; } else if (OutputType[0] == 'Q') { Display = DB_QWORD_DISPLAY; } } RetBuf.Length = sizeof (Buffer); RetBuf.Pointer = Buffer; /* Differentiate between a number and a name */ if ((Target[0] >= 0x30) && (Target[0] <= 0x39)) { ObjPtr = AcpiDbGetPointer (Target); if (!AcpiOsReadable (ObjPtr, 16)) { AcpiOsPrintf ("Address %p is invalid in this address space\n", ObjPtr); return; } /* Decode the object type */ if (VALID_DESCRIPTOR_TYPE ((ObjPtr), ACPI_DESC_TYPE_NAMED)) { /* This is a Node */ if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_NAMESPACE_NODE))) { AcpiOsPrintf ("Cannot read entire Named object at address %p\n", ObjPtr); return; } Node = ObjPtr; goto DumpNte; } else if (VALID_DESCRIPTOR_TYPE ((ObjPtr), ACPI_DESC_TYPE_INTERNAL)) { /* This is an ACPI OBJECT */ if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_OPERAND_OBJECT))) { AcpiOsPrintf ("Cannot read entire ACPI object at address %p\n", ObjPtr); return; } AcpiUtDumpBuffer (ObjPtr, sizeof (ACPI_OPERAND_OBJECT), Display, ACPI_UINT32_MAX); AcpiExDumpObjectDescriptor (ObjPtr, 1); } else if (VALID_DESCRIPTOR_TYPE ((ObjPtr), ACPI_DESC_TYPE_PARSER)) { /* This is an Parser Op object */ if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_PARSE_OBJECT))) { AcpiOsPrintf ("Cannot read entire Parser object at address %p\n", ObjPtr); return; } AcpiUtDumpBuffer (ObjPtr, sizeof (ACPI_PARSE_OBJECT), Display, ACPI_UINT32_MAX); AcpiDbDumpParserDescriptor ((ACPI_PARSE_OBJECT *) ObjPtr); } else { Size = 16; if (AcpiOsReadable (ObjPtr, 64)) { Size = 64; } /* Just dump some memory */ AcpiUtDumpBuffer (ObjPtr, Size, Display, ACPI_UINT32_MAX); } return; } /* The parameter is a name string that must be resolved to a Named obj */ Node = AcpiDbLocalNsLookup (Target); if (!Node) { return; } DumpNte: /* Now dump the Named obj */ Status = AcpiGetName (Node, ACPI_FULL_PATHNAME, &RetBuf); if (ACPI_FAILURE (Status)) { AcpiOsPrintf ("Could not convert name to pathname\n"); } else { AcpiOsPrintf ("Object Pathname: %s\n", RetBuf.Pointer); } if (!AcpiOsReadable (Node, sizeof (ACPI_NAMESPACE_NODE))) { AcpiOsPrintf ("Invalid Named object at address %p\n", Node); return; } AcpiUtDumpBuffer ((void *) Node, sizeof (ACPI_NAMESPACE_NODE), Display, ACPI_UINT32_MAX); AcpiExDumpNode (Node, 1); if (Node->Object) { AcpiOsPrintf ("\nAttached Object (%p):\n", Node->Object); if (!AcpiOsReadable (Node->Object, sizeof (ACPI_OPERAND_OBJECT))) { AcpiOsPrintf ("Invalid internal ACPI Object at address %p\n", Node->Object); return; } AcpiUtDumpBuffer (Node->Object, sizeof (ACPI_OPERAND_OBJECT), Display, ACPI_UINT32_MAX); AcpiExDumpObjectDescriptor (Node->Object, 1); } } /******************************************************************************* * * FUNCTION: AcpiDbDecodeInternalObject * * PARAMETERS: ObjDesc - Object to be displayed * * RETURN: None * * DESCRIPTION: Short display of an internal object. Numbers and Strings. * ******************************************************************************/ void AcpiDbDecodeInternalObject ( ACPI_OPERAND_OBJECT *ObjDesc) { UINT32 i; if (!ObjDesc) { return; } AcpiOsPrintf (" %s", AcpiUtGetTypeName (ObjDesc->Common.Type)); switch (ObjDesc->Common.Type) { case ACPI_TYPE_INTEGER: - AcpiOsPrintf (" %.8X", ObjDesc->Integer.Value); + + AcpiOsPrintf (" %.8X%.8X", HIDWORD (ObjDesc->Integer.Value), + LODWORD (ObjDesc->Integer.Value)); break; + case ACPI_TYPE_STRING: + AcpiOsPrintf ("(%d) \"%.24s", ObjDesc->String.Length, ObjDesc->String.Pointer); if (ObjDesc->String.Length > 24) { AcpiOsPrintf ("..."); } else { AcpiOsPrintf ("\""); } break; + case ACPI_TYPE_BUFFER: + AcpiOsPrintf ("(%d)", ObjDesc->Buffer.Length); for (i = 0; (i < 8) && (i < ObjDesc->Buffer.Length); i++) { AcpiOsPrintf (" %2.2X", ObjDesc->Buffer.Pointer[i]); } break; } } /******************************************************************************* * * FUNCTION: AcpiDbDisplayInternalObject * * PARAMETERS: ObjDesc - Object to be displayed * WalkState - Current walk state * * RETURN: None * * DESCRIPTION: Short display of an internal object * ******************************************************************************/ void AcpiDbDisplayInternalObject ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState) { UINT8 Type; AcpiOsPrintf ("%p ", ObjDesc); if (!ObjDesc) { AcpiOsPrintf ("\n"); return; } /* Decode the object type */ else if (VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_PARSER)) { AcpiOsPrintf (" "); } else if (VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_NAMED)) { AcpiOsPrintf (" Name %4.4s Type-%s", &((ACPI_NAMESPACE_NODE *)ObjDesc)->Name, AcpiUtGetTypeName (((ACPI_NAMESPACE_NODE *) ObjDesc)->Type)); if (((ACPI_NAMESPACE_NODE *) ObjDesc)->Flags & ANOBJ_METHOD_ARG) { AcpiOsPrintf (" [Method Arg]"); } if (((ACPI_NAMESPACE_NODE *) ObjDesc)->Flags & ANOBJ_METHOD_LOCAL) { AcpiOsPrintf (" [Method Local]"); } } else if (VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_INTERNAL)) { AcpiOsPrintf (" "); Type = ObjDesc->Common.Type; if (Type > INTERNAL_TYPE_MAX) { AcpiOsPrintf (" Type %x [Invalid Type]", Type); return; } /* Decode the ACPI object type */ switch (ObjDesc->Common.Type) { case INTERNAL_TYPE_REFERENCE: switch (ObjDesc->Reference.Opcode) { case AML_ZERO_OP: - AcpiOsPrintf ("[Const] Number %.8X", 0); + AcpiOsPrintf ("[Const] Zero (0) [Null Target]", 0); break; case AML_ONES_OP: - AcpiOsPrintf ("[Const] Number %.8X", ACPI_UINT32_MAX); + AcpiOsPrintf ("[Const] Ones (0xFFFFFFFFFFFFFFFF) [No Limit]"); break; case AML_ONE_OP: - AcpiOsPrintf ("[Const] Number %.8X", 1); + AcpiOsPrintf ("[Const] One (1)"); break; case AML_LOCAL_OP: AcpiOsPrintf ("[Local%d] ", ObjDesc->Reference.Offset); if (WalkState) { ObjDesc = WalkState->LocalVariables[ObjDesc->Reference.Offset].Object; AcpiDbDecodeInternalObject (ObjDesc); } break; case AML_ARG_OP: AcpiOsPrintf ("[Arg%d] ", ObjDesc->Reference.Offset); if (WalkState) { ObjDesc = WalkState->Arguments[ObjDesc->Reference.Offset].Object; AcpiDbDecodeInternalObject (ObjDesc); } break; case AML_DEBUG_OP: AcpiOsPrintf ("[Debug] "); break; case AML_INDEX_OP: AcpiOsPrintf ("[Index] "); AcpiDbDecodeInternalObject (ObjDesc->Reference.Object); break; default: break; } break; default: AcpiOsPrintf (" "); AcpiDbDecodeInternalObject (ObjDesc); break; } } else { AcpiOsPrintf (" "); } AcpiOsPrintf ("\n"); } /******************************************************************************* * * FUNCTION: AcpiDbDisplayMethodInfo * * PARAMETERS: StartOp - Root of the control method parse tree * * RETURN: None * * DESCRIPTION: Display information about the current method * ******************************************************************************/ void AcpiDbDisplayMethodInfo ( ACPI_PARSE_OBJECT *StartOp) { ACPI_WALK_STATE *WalkState; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_NAMESPACE_NODE *Node; ACPI_PARSE_OBJECT *RootOp; ACPI_PARSE_OBJECT *Op; ACPI_OPCODE_INFO *OpInfo; UINT32 NumOps = 0; UINT32 NumOperands = 0; UINT32 NumOperators = 0; UINT32 NumRemainingOps = 0; UINT32 NumRemainingOperands = 0; UINT32 NumRemainingOperators = 0; UINT32 NumArgs; UINT32 Concurrency; BOOLEAN CountRemaining = FALSE; WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList); if (!WalkState) { AcpiOsPrintf ("There is no method currently executing\n"); return; } ObjDesc = WalkState->MethodDesc; Node = WalkState->MethodNode; NumArgs = ObjDesc->Method.ParamCount; Concurrency = ObjDesc->Method.Concurrency; AcpiOsPrintf ("Currently executing control method is [%4.4s]\n", &Node->Name); AcpiOsPrintf ("%X arguments, max concurrency = %X\n", NumArgs, Concurrency); RootOp = StartOp; while (RootOp->Parent) { RootOp = RootOp->Parent; } Op = RootOp; while (Op) { if (Op == StartOp) { CountRemaining = TRUE; } NumOps++; if (CountRemaining) { NumRemainingOps++; } OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode); if (ACPI_GET_OP_TYPE (OpInfo) != ACPI_OP_TYPE_OPCODE) { /* Bad opcode or ASCII character */ continue; } /* Decode the opcode */ switch (ACPI_GET_OP_CLASS (OpInfo)) { case OPTYPE_CONSTANT: /* argument type only */ case OPTYPE_LITERAL: /* argument type only */ case OPTYPE_DATA_TERM: /* argument type only */ case OPTYPE_LOCAL_VARIABLE: /* argument type only */ case OPTYPE_METHOD_ARGUMENT: /* argument type only */ if (CountRemaining) { NumRemainingOperands++; } NumOperands++; break; default: if (CountRemaining) { NumRemainingOperators++; } NumOperators++; break; } Op = AcpiPsGetDepthNext (StartOp, Op); } AcpiOsPrintf ("Method contains: %X AML Opcodes - %X Operators, %X Operands\n", NumOps, NumOperators, NumOperands); AcpiOsPrintf ("Remaining to execute: %X AML Opcodes - %X Operators, %X Operands\n", NumRemainingOps, NumRemainingOperators, NumRemainingOperands); } /******************************************************************************* * * FUNCTION: AcpiDbDisplayLocals * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Display all locals for the currently running control method * ******************************************************************************/ void AcpiDbDisplayLocals (void) { UINT32 i; ACPI_WALK_STATE *WalkState; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_NAMESPACE_NODE *Node; WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList); if (!WalkState) { AcpiOsPrintf ("There is no method currently executing\n"); return; } ObjDesc = WalkState->MethodDesc; Node = WalkState->MethodNode; AcpiOsPrintf ("Local Variables for method [%4.4s]:\n", &Node->Name); for (i = 0; i < MTH_NUM_LOCALS; i++) { ObjDesc = WalkState->LocalVariables[i].Object; AcpiOsPrintf ("Local%d: ", i); AcpiDbDisplayInternalObject (ObjDesc, WalkState); } } /******************************************************************************* * * FUNCTION: AcpiDbDisplayArguments * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Display all arguments for the currently running control method * ******************************************************************************/ void AcpiDbDisplayArguments (void) { UINT32 i; ACPI_WALK_STATE *WalkState; ACPI_OPERAND_OBJECT *ObjDesc; UINT32 NumArgs; UINT32 Concurrency; ACPI_NAMESPACE_NODE *Node; WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList); if (!WalkState) { AcpiOsPrintf ("There is no method currently executing\n"); return; } ObjDesc = WalkState->MethodDesc; Node = WalkState->MethodNode; NumArgs = ObjDesc->Method.ParamCount; Concurrency = ObjDesc->Method.Concurrency; AcpiOsPrintf ("Method [%4.4s] has %X arguments, max concurrency = %X\n", &Node->Name, NumArgs, Concurrency); for (i = 0; i < NumArgs; i++) { ObjDesc = WalkState->Arguments[i].Object; AcpiOsPrintf ("Arg%d: ", i); AcpiDbDisplayInternalObject (ObjDesc, WalkState); } } /******************************************************************************* * * FUNCTION: AcpiDbDisplayResults * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Display current contents of a method result stack * ******************************************************************************/ void AcpiDbDisplayResults (void) { UINT32 i; ACPI_WALK_STATE *WalkState; ACPI_OPERAND_OBJECT *ObjDesc; UINT32 NumResults = 0; ACPI_NAMESPACE_NODE *Node; WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList); if (!WalkState) { AcpiOsPrintf ("There is no method currently executing\n"); return; } ObjDesc = WalkState->MethodDesc; Node = WalkState->MethodNode; if (WalkState->Results) { NumResults = WalkState->Results->Results.NumResults; } AcpiOsPrintf ("Method [%4.4s] has %X stacked result objects\n", &Node->Name, NumResults); for (i = 0; i < NumResults; i++) { ObjDesc = WalkState->Results->Results.ObjDesc[i]; AcpiOsPrintf ("Result%d: ", i); AcpiDbDisplayInternalObject (ObjDesc, WalkState); } } /******************************************************************************* * * FUNCTION: AcpiDbDisplayCallingTree * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Display current calling tree of nested control methods * ******************************************************************************/ void AcpiDbDisplayCallingTree (void) { UINT32 i; ACPI_WALK_STATE *WalkState; ACPI_NAMESPACE_NODE *Node; WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList); if (!WalkState) { AcpiOsPrintf ("There is no method currently executing\n"); return; } Node = WalkState->MethodNode; AcpiOsPrintf ("Current Control Method Call Tree\n"); for (i = 0; WalkState; i++) { Node = WalkState->MethodNode; AcpiOsPrintf (" [%4.4s]\n", &Node->Name); WalkState = WalkState->Next; } } /******************************************************************************* * * FUNCTION: AcpiDbDisplayResultObject * * PARAMETERS: ObjDesc - Object to be displayed * WalkState - Current walk state * * RETURN: None * * DESCRIPTION: Display the result of an AML opcode * ******************************************************************************/ void AcpiDbDisplayResultObject ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState) { /* TBD: [Future] We don't always want to display the result. * For now, only display if single stepping * however, this output is very useful in other contexts also */ if (!AcpiGbl_CmSingleStep) { return; } AcpiOsPrintf ("ResultObj: "); AcpiDbDisplayInternalObject (ObjDesc, WalkState); AcpiOsPrintf ("\n"); } /******************************************************************************* * * FUNCTION: AcpiDbDisplayArgumentObject * * PARAMETERS: ObjDesc - Object to be displayed * WalkState - Current walk state * * RETURN: None * * DESCRIPTION: Display the result of an AML opcode * ******************************************************************************/ void AcpiDbDisplayArgumentObject ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState) { if (!AcpiGbl_CmSingleStep) { return; } AcpiOsPrintf ("ArgObj: "); AcpiDbDisplayInternalObject (ObjDesc, WalkState); } #endif /* ENABLE_DEBUGGER */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbexec.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbexec.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbexec.c (revision 82367) @@ -1,478 +1,514 @@ /******************************************************************************* * * Module Name: dbexec - debugger control method execution - * $Revision: 27 $ + * $Revision: 29 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acparser.h" #include "acdispat.h" #include "amlcode.h" #include "acnamesp.h" #include "acparser.h" #include "acevents.h" #include "acinterp.h" #include "acdebug.h" #include "actables.h" #ifdef ENABLE_DEBUGGER #define _COMPONENT ACPI_DEBUGGER MODULE_NAME ("dbexec") DB_METHOD_INFO Info; /******************************************************************************* * * FUNCTION: AcpiDbExecuteMethod * * PARAMETERS: Info - Valid info segment * ReturnObj - Where to put return object * * RETURN: Status * * DESCRIPTION: Execute a control method. * ******************************************************************************/ ACPI_STATUS AcpiDbExecuteMethod ( DB_METHOD_INFO *Info, ACPI_BUFFER *ReturnObj) { ACPI_STATUS Status; ACPI_OBJECT_LIST ParamObjects; ACPI_OBJECT Params[MTH_NUM_ARGS]; UINT32 i; if (OutputToFile && !AcpiDbgLevel) { AcpiOsPrintf ("Warning: debug output is not enabled!\n"); } /* Are there arguments to the method? */ if (Info->Args && Info->Args[0]) { for (i = 0; Info->Args[i] && i < MTH_NUM_ARGS; i++) { Params[i].Type = ACPI_TYPE_INTEGER; Params[i].Integer.Value = STRTOUL (Info->Args[i], NULL, 16); } ParamObjects.Pointer = Params; ParamObjects.Count = i; } else { /* Setup default parameters */ Params[0].Type = ACPI_TYPE_INTEGER; Params[0].Integer.Value = 0x01020304; Params[1].Type = ACPI_TYPE_STRING; Params[1].String.Length = 12; Params[1].String.Pointer = "AML Debugger"; ParamObjects.Pointer = Params; ParamObjects.Count = 2; } /* Prepare for a return object of arbitrary size */ ReturnObj->Pointer = Buffer; ReturnObj->Length = BUFFER_SIZE; /* Do the actual method execution */ Status = AcpiEvaluateObject (NULL, Info->Pathname, &ParamObjects, ReturnObj); AcpiGbl_CmSingleStep = FALSE; AcpiGbl_MethodExecuting = FALSE; return (Status); } /******************************************************************************* * * FUNCTION: AcpiDbExecuteSetup * * PARAMETERS: Info - Valid method info * * RETURN: Status * * DESCRIPTION: Setup info segment prior to method execution * ******************************************************************************/ void AcpiDbExecuteSetup ( DB_METHOD_INFO *Info) { /* Catenate the current scope to the supplied name */ Info->Pathname[0] = 0; if ((Info->Name[0] != '\\') && (Info->Name[0] != '/')) { STRCAT (Info->Pathname, ScopeBuf); } STRCAT (Info->Pathname, Info->Name); AcpiDbPrepNamestring (Info->Pathname); AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT); AcpiOsPrintf ("Executing %s\n", Info->Pathname); if (Info->Flags & EX_SINGLE_STEP) { AcpiGbl_CmSingleStep = TRUE; AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT); } else { /* No single step, allow redirection to a file */ AcpiDbSetOutputDestination (DB_REDIRECTABLE_OUTPUT); } } /******************************************************************************* * + * FUNCTION: AcpiDbGetOutstandingAllocations + * + * PARAMETERS: None + * + * RETURN: Current global allocation count minus cache entries + * + * DESCRIPTION: Determine the current number of "outstanding" allocations -- + * those allocations that have not been freed and also are not + * in one of the various object caches. + * + ******************************************************************************/ + +UINT32 +AcpiDbGetOutstandingAllocations (void) +{ + UINT32 i; + UINT32 Outstanding = 0; + +#ifdef ACPI_DBG_TRACK_ALLOCATIONS + + for (i = ACPI_MEM_LIST_FIRST_CACHE_LIST; i < ACPI_NUM_MEM_LISTS; i++) + { + Outstanding += (AcpiGbl_MemoryLists[i].TotalAllocated - + AcpiGbl_MemoryLists[i].TotalFreed - + AcpiGbl_MemoryLists[i].CacheDepth); + } +#endif + + return (Outstanding); +} + + +/******************************************************************************* + * * FUNCTION: AcpiDbExecute * * PARAMETERS: Name - Name of method to execute * Args - Parameters to the method * Flags - single step/no single step * * RETURN: Status * * DESCRIPTION: Execute a control method. Name is relative to the current * scope. * ******************************************************************************/ void AcpiDbExecute ( NATIVE_CHAR *Name, NATIVE_CHAR **Args, UINT32 Flags) { ACPI_STATUS Status; ACPI_BUFFER ReturnObj; #ifdef ACPI_DEBUG UINT32 PreviousAllocations; - UINT32 PreviousSize; UINT32 Allocations; - UINT32 Size; /* Memory allocation tracking */ - PreviousAllocations = AcpiGbl_CurrentAllocCount; - PreviousSize = AcpiGbl_CurrentAllocSize; + PreviousAllocations = AcpiDbGetOutstandingAllocations (); #endif Info.Name = Name; Info.Args = Args; Info.Flags = Flags; AcpiDbExecuteSetup (&Info); Status = AcpiDbExecuteMethod (&Info, &ReturnObj); + /* + * Allow any handlers in separate threads to complete. + * (Such as Notify handlers invoked from AML executed above). + */ + AcpiOsSleep (0, 10); + #ifdef ACPI_DEBUG /* Memory allocation tracking */ - Allocations = AcpiGbl_CurrentAllocCount - PreviousAllocations; - Size = AcpiGbl_CurrentAllocSize - PreviousSize; + Allocations = AcpiDbGetOutstandingAllocations () - PreviousAllocations; AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT); if (Allocations > 0) { - AcpiOsPrintf ("Outstanding: %ld allocations of total size %ld after execution\n", - Allocations, Size); + AcpiOsPrintf ("Outstanding: %ld allocations after execution\n", + Allocations); } #endif if (ACPI_FAILURE (Status)) { AcpiOsPrintf ("Execution of %s failed with status %s\n", Info.Pathname, AcpiFormatException (Status)); } else { /* Display a return object, if any */ if (ReturnObj.Length) { AcpiOsPrintf ("Execution of %s returned object %p Buflen %X\n", Info.Pathname, ReturnObj.Pointer, ReturnObj.Length); AcpiDbDumpObject (ReturnObj.Pointer, 1); } } AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT); } /******************************************************************************* * * FUNCTION: AcpiDbMethodThread * * PARAMETERS: Context - Execution info segment * * RETURN: None * * DESCRIPTION: Debugger execute thread. Waits for a command line, then * simply dispatches it. * ******************************************************************************/ void AcpiDbMethodThread ( void *Context) { ACPI_STATUS Status; DB_METHOD_INFO *Info = Context; UINT32 i; ACPI_BUFFER ReturnObj; for (i = 0; i < Info->NumLoops; i++) { Status = AcpiDbExecuteMethod (Info, &ReturnObj); if (ACPI_SUCCESS (Status)) { if (ReturnObj.Length) { AcpiOsPrintf ("Execution of %s returned object %p Buflen %X\n", Info->Pathname, ReturnObj.Pointer, ReturnObj.Length); AcpiDbDumpObject (ReturnObj.Pointer, 1); } } } /* Signal our completion */ AcpiOsSignalSemaphore (Info->ThreadGate, 1); } /******************************************************************************* * * FUNCTION: AcpiDbCreateExecutionThreads * * PARAMETERS: NumThreadsArg - Number of threads to create * NumLoopsArg - Loop count for the thread(s) * MethodNameArg - Control method to execute * * RETURN: None * * DESCRIPTION: Create threads to execute method(s) * ******************************************************************************/ void AcpiDbCreateExecutionThreads ( NATIVE_CHAR *NumThreadsArg, NATIVE_CHAR *NumLoopsArg, NATIVE_CHAR *MethodNameArg) { ACPI_STATUS Status; UINT32 NumThreads; UINT32 NumLoops; UINT32 i; ACPI_HANDLE ThreadGate; /* Get the arguments */ NumThreads = STRTOUL (NumThreadsArg, NULL, 0); NumLoops = STRTOUL (NumLoopsArg, NULL, 0); if (!NumThreads || !NumLoops) { AcpiOsPrintf ("Bad argument: Threads %X, Loops %X\n", NumThreads, NumLoops); return; } /* Create the synchronization semaphore */ Status = AcpiOsCreateSemaphore (1, 0, &ThreadGate); if (ACPI_FAILURE (Status)) { AcpiOsPrintf ("Could not create semaphore, %s\n", AcpiFormatException (Status)); return; } /* Setup the context to be passed to each thread */ Info.Name = MethodNameArg; Info.Args = NULL; Info.Flags = 0; Info.NumLoops = NumLoops; Info.ThreadGate = ThreadGate; AcpiDbExecuteSetup (&Info); /* Create the threads */ AcpiOsPrintf ("Creating %X threads to execute %X times each\n", NumThreads, NumLoops); for (i = 0; i < (NumThreads); i++) { AcpiOsQueueForExecution (OSD_PRIORITY_MED, AcpiDbMethodThread, &Info); } /* Wait for all threads to complete */ i = NumThreads; while (i) /* Brain damage for OSD implementations that only support wait of 1 unit */ { Status = AcpiOsWaitSemaphore (ThreadGate, 1, WAIT_FOREVER); i--; } /* Cleanup and exit */ AcpiOsDeleteSemaphore (ThreadGate); AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT); AcpiOsPrintf ("All threads (%X) have completed\n", NumThreads); AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT); } #endif /* ENABLE_DEBUGGER */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbfileio.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbfileio.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbfileio.c (revision 82367) @@ -1,494 +1,495 @@ /******************************************************************************* * * Module Name: dbfileio - Debugger file I/O commands. These can't usually * be used when running the debugger in Ring 0 (Kernel mode) - * $Revision: 43 $ + * $Revision: 44 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acdebug.h" #include "acnamesp.h" #include "acparser.h" #include "acevents.h" #include "actables.h" #ifdef ENABLE_DEBUGGER #define _COMPONENT ACPI_DEBUGGER MODULE_NAME ("dbfileio") ACPI_PARSE_OBJECT *root; #ifdef ACPI_APPLICATION #include FILE *DebugFile = NULL; #endif /* * NOTE: this is here for lack of a better place. It is used in all * flavors of the debugger, need LCD file */ /******************************************************************************* * * FUNCTION: AcpiDbMatchArgument * * PARAMETERS: UserArgument - User command line * Arguments - Array of commands to match against * * RETURN: Index into command array or ACPI_TYPE_NOT_FOUND if not found * * DESCRIPTION: Search command array for a command match * ******************************************************************************/ ACPI_OBJECT_TYPE8 AcpiDbMatchArgument ( NATIVE_CHAR *UserArgument, ARGUMENT_INFO *Arguments) { UINT32 i; if (!UserArgument || UserArgument[0] == 0) { return (ACPI_TYPE_NOT_FOUND); } for (i = 0; Arguments[i].Name; i++) { if (STRSTR (Arguments[i].Name, UserArgument) == Arguments[i].Name) { return ((ACPI_OBJECT_TYPE8) i); } } /* Argument not recognized */ return (ACPI_TYPE_NOT_FOUND); } /******************************************************************************* * * FUNCTION: AcpiDbCloseDebugFile * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: If open, close the current debug output file * ******************************************************************************/ void AcpiDbCloseDebugFile ( void) { #ifdef ACPI_APPLICATION if (DebugFile) { fclose (DebugFile); DebugFile = NULL; OutputToFile = FALSE; AcpiOsPrintf ("Debug output file %s closed\n", DebugFilename); } #endif } /******************************************************************************* * * FUNCTION: AcpiDbOpenDebugFile * * PARAMETERS: Name - Filename to open * * RETURN: Status * * DESCRIPTION: Open a file where debug output will be directed. * ******************************************************************************/ void AcpiDbOpenDebugFile ( NATIVE_CHAR *Name) { #ifdef ACPI_APPLICATION AcpiDbCloseDebugFile (); DebugFile = fopen (Name, "w+"); if (DebugFile) { AcpiOsPrintf ("Debug output file %s opened\n", Name); STRCPY (DebugFilename, Name); OutputToFile = TRUE; } else { AcpiOsPrintf ("Could not open debug file %s\n", Name); } #endif } #ifdef ACPI_APPLICATION /******************************************************************************* * * FUNCTION: AcpiDbLoadTable * * PARAMETERS: fp - File that contains table * TablePtr - Return value, buffer with table * TableLenght - Return value, length of table * * RETURN: Status * * DESCRIPTION: Load the DSDT from the file pointer * ******************************************************************************/ ACPI_STATUS AcpiDbLoadTable( FILE *fp, ACPI_TABLE_HEADER **TablePtr, UINT32 *TableLength) { ACPI_TABLE_HEADER TableHeader; UINT8 *AmlPtr; UINT32 AmlLength; UINT32 Actual; ACPI_STATUS Status; /* Read the table header */ if (fread (&TableHeader, 1, sizeof (TableHeader), fp) != sizeof (ACPI_TABLE_HEADER)) { AcpiOsPrintf ("Couldn't read the table header\n"); return (AE_BAD_SIGNATURE); } /* Validate the table header/length */ Status = AcpiTbValidateTableHeader (&TableHeader); if ((ACPI_FAILURE (Status)) || (TableHeader.Length > 524288)) /* 1/2 Mbyte should be enough */ { AcpiOsPrintf ("Table header is invalid!\n"); return (AE_ERROR); } /* We only support a limited number of table types */ if (STRNCMP ((char *) TableHeader.Signature, DSDT_SIG, 4) && STRNCMP ((char *) TableHeader.Signature, PSDT_SIG, 4) && STRNCMP ((char *) TableHeader.Signature, SSDT_SIG, 4)) { AcpiOsPrintf ("Table signature is invalid\n"); DUMP_BUFFER (&TableHeader, sizeof (ACPI_TABLE_HEADER)); return (AE_ERROR); } /* Allocate a buffer for the table */ *TableLength = TableHeader.Length; *TablePtr = ACPI_MEM_ALLOCATE ((size_t) *TableLength); if (!*TablePtr) { - AcpiOsPrintf ("Could not allocate memory for the table (size=%X)\n", TableHeader.Length); + AcpiOsPrintf ("Could not allocate memory for ACPI table %4.4s (size=%X)\n", + TableHeader.Signature, TableHeader.Length); return (AE_NO_MEMORY); } AmlPtr = (UINT8 *) *TablePtr + sizeof (TableHeader); AmlLength = *TableLength - sizeof (TableHeader); /* Copy the header to the buffer */ MEMCPY (*TablePtr, &TableHeader, sizeof (TableHeader)); /* Get the rest of the table */ Actual = fread (AmlPtr, 1, (size_t) AmlLength, fp); if (Actual == AmlLength) { return (AE_OK); } if (Actual > 0) { AcpiOsPrintf ("Warning - reading table, asked for %X got %X\n", AmlLength, Actual); return (AE_OK); } AcpiOsPrintf ("Error - could not read the table file\n"); ACPI_MEM_FREE (*TablePtr); *TablePtr = NULL; *TableLength = 0; return (AE_ERROR); } #endif /******************************************************************************* * * FUNCTION: AeLocalLoadTable * * PARAMETERS: TablePtr - pointer to a buffer containing the entire * table to be loaded * * RETURN: Status * * DESCRIPTION: This function is called to load a table from the caller's * buffer. The buffer must contain an entire ACPI Table including * a valid header. The header fields will be verified, and if it * is determined that the table is invalid, the call will fail. * * If the call fails an appropriate status will be returned. * ******************************************************************************/ ACPI_STATUS AeLocalLoadTable ( ACPI_TABLE_HEADER *TablePtr) { ACPI_STATUS Status; ACPI_TABLE_DESC TableInfo; FUNCTION_TRACE ("AeLocalLoadTable"); if (!TablePtr) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Install the new table into the local data structures */ TableInfo.Pointer = TablePtr; Status = AcpiTbInstallTable (NULL, &TableInfo); if (ACPI_FAILURE (Status)) { /* Free table allocated by AcpiTbGetTable */ AcpiTbDeleteSingleTable (&TableInfo); return_ACPI_STATUS (Status); } #ifndef PARSER_ONLY Status = AcpiNsLoadTable (TableInfo.InstalledDesc, AcpiGbl_RootNode); if (ACPI_FAILURE (Status)) { /* Uninstall table and free the buffer */ AcpiTbUninstallTable (TableInfo.InstalledDesc); return_ACPI_STATUS (Status); } #endif return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiDbLoadAcpiTable * * PARAMETERS: Filname - File where table is located * * RETURN: Status * * DESCRIPTION: Load an ACPI table from a file * ******************************************************************************/ ACPI_STATUS AcpiDbLoadAcpiTable ( NATIVE_CHAR *Filename) { #ifdef ACPI_APPLICATION FILE *fp; ACPI_STATUS Status; ACPI_TABLE_HEADER *TablePtr; UINT32 TableLength; /* Open the file */ fp = fopen (Filename, "rb"); if (!fp) { AcpiOsPrintf ("Could not open file %s\n", Filename); return (AE_ERROR); } /* Get the entire file */ AcpiOsPrintf ("Loading Acpi table from file %s\n", Filename); Status = AcpiDbLoadTable (fp, &TablePtr, &TableLength); fclose(fp); if (ACPI_FAILURE (Status)) { AcpiOsPrintf ("Couldn't get table from the file\n"); return (Status); } /* Attempt to recognize and install the table */ Status = AeLocalLoadTable (TablePtr); if (ACPI_FAILURE (Status)) { if (Status == AE_EXIST) { AcpiOsPrintf ("Table %4.4s is already installed\n", &TablePtr->Signature); } else { AcpiOsPrintf ("Could not install table, %s\n", AcpiFormatException (Status)); } ACPI_MEM_FREE (TablePtr); return (Status); } AcpiOsPrintf ("%4.4s at %p successfully installed and loaded\n", &TablePtr->Signature, TablePtr); AcpiGbl_AcpiHardwarePresent = FALSE; #endif /* ACPI_APPLICATION */ return (AE_OK); } #endif /* ENABLE_DEBUGGER */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbinput.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbinput.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbinput.c (revision 82367) @@ -1,1003 +1,1003 @@ /******************************************************************************* * * Module Name: dbinput - user front-end to the AML debugger - * $Revision: 62 $ + * $Revision: 64 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acparser.h" #include "actables.h" #include "acnamesp.h" #include "acinterp.h" #include "acdebug.h" #ifdef ENABLE_DEBUGGER #define _COMPONENT ACPI_DEBUGGER MODULE_NAME ("dbinput") /* * Globals that are specific to the debugger */ NATIVE_CHAR LineBuf[80]; NATIVE_CHAR ParsedBuf[80]; NATIVE_CHAR ScopeBuf[40]; NATIVE_CHAR DebugFilename[40]; NATIVE_CHAR *Args[DB_MAX_ARGS]; NATIVE_CHAR *Buffer; NATIVE_CHAR *Filename = NULL; BOOLEAN OutputToFile = FALSE; UINT32 AcpiGbl_DbDebugLevel = 0x0FFFFFFF; -UINT32 AcpiGbl_DbConsoleDebugLevel = NORMAL_DEFAULT | TRACE_TABLES; +UINT32 AcpiGbl_DbConsoleDebugLevel = NORMAL_DEFAULT | ACPI_LV_TABLES; UINT8 AcpiGbl_DbOutputFlags = DB_CONSOLE_OUTPUT; BOOLEAN opt_tables = FALSE; BOOLEAN opt_disasm = FALSE; BOOLEAN opt_stats = FALSE; BOOLEAN opt_parse_jit = FALSE; BOOLEAN opt_verbose = TRUE; BOOLEAN opt_ini_methods = TRUE; /* * Top-level debugger commands. * * This list of commands must match the string table below it */ enum AcpiExDebuggerCommands { CMD_NOT_FOUND = 0, CMD_NULL, CMD_ALLOCATIONS, CMD_ARGS, CMD_ARGUMENTS, CMD_BREAKPOINT, CMD_CALL, CMD_CLOSE, CMD_DEBUG, CMD_DUMP, CMD_ENABLEACPI, CMD_EVENT, CMD_EXECUTE, CMD_EXIT, CMD_FIND, CMD_GO, CMD_HELP, CMD_HELP2, CMD_HISTORY, CMD_HISTORY_EXE, CMD_HISTORY_LAST, CMD_INFORMATION, CMD_INTO, CMD_LEVEL, CMD_LIST, CMD_LOAD, CMD_LOCALS, CMD_LOCKS, CMD_METHODS, CMD_NAMESPACE, CMD_NOTIFY, CMD_OBJECT, CMD_OPEN, CMD_OWNER, CMD_PREFIX, CMD_QUIT, CMD_REFERENCES, CMD_RESOURCES, CMD_RESULTS, CMD_SET, CMD_STATS, CMD_STOP, CMD_TABLES, CMD_TERMINATE, CMD_THREADS, CMD_TREE, CMD_UNLOAD }; #define CMD_FIRST_VALID 2 COMMAND_INFO Commands[] = { {"", 0}, {"", 0}, {"ALLOCATIONS", 0}, {"ARGS", 0}, {"ARGUMENTS", 0}, {"BREAKPOINT", 1}, {"CALL", 0}, {"CLOSE", 0}, {"DEBUG", 1}, {"DUMP", 1}, {"ENABLEACPI", 0}, {"EVENT", 1}, {"EXECUTE", 1}, {"EXIT", 0}, {"FIND", 1}, {"GO", 0}, {"HELP", 0}, {"?", 0}, {"HISTORY", 0}, {"!", 1}, {"!!", 0}, {"INFORMATION", 0}, {"INTO", 0}, {"LEVEL", 0}, {"LIST", 0}, {"LOAD", 1}, {"LOCALS", 0}, {"LOCKS", 0}, {"METHODS", 0}, {"NAMESPACE", 0}, {"NOTIFY", 2}, {"OBJECT", 1}, {"OPEN", 1}, {"OWNER", 1}, {"PREFIX", 0}, {"QUIT", 0}, {"REFERENCES", 1}, {"RESOURCES", 1}, {"RESULTS", 0}, {"SET", 3}, {"STATS", 0}, {"STOP", 0}, {"TABLES", 0}, {"TERMINATE", 0}, {"THREADS", 3}, {"TREE", 0}, - {"UNLOAD", 0}, + {"UNLOAD", 1}, {NULL, 0} }; /******************************************************************************* * * FUNCTION: AcpiDbDisplayHelp * * PARAMETERS: HelpType - Subcommand (optional) * * RETURN: None * * DESCRIPTION: Print a usage message. * ******************************************************************************/ void AcpiDbDisplayHelp ( NATIVE_CHAR *HelpType) { /* No parameter, just give the overview */ if (!HelpType) { AcpiOsPrintf ("ACPI CA Debugger Commands\n\n"); AcpiOsPrintf ("The following classes of commands are available. Help is available for\n"); AcpiOsPrintf ("each class by entering \"Help \"\n\n"); AcpiOsPrintf (" [GENERAL] General-Purpose Commands\n"); AcpiOsPrintf (" [NAMESPACE] Namespace Access Commands\n"); AcpiOsPrintf (" [METHOD] Control Method Execution Commands\n"); AcpiOsPrintf (" [FILE] File I/O Commands\n"); return; } /* * Parameter is the command class * * The idea here is to keep each class of commands smaller than a screenful */ switch (HelpType[0]) { case 'G': AcpiOsPrintf ("\nGeneral-Purpose Commands\n\n"); AcpiOsPrintf ("Allocations Display list of current memory allocations\n"); AcpiOsPrintf ("Dump
|\n"); AcpiOsPrintf (" [Byte|Word|Dword|Qword] Display ACPI objects or memory\n"); AcpiOsPrintf ("EnableAcpi Enable ACPI (hardware) mode\n"); AcpiOsPrintf ("Help This help screen\n"); AcpiOsPrintf ("History Display command history buffer\n"); AcpiOsPrintf ("Level [] [console] Get/Set debug level for file or console\n"); AcpiOsPrintf ("Locks Current status of internal mutexes\n"); AcpiOsPrintf ("Quit or Exit Exit this command\n"); AcpiOsPrintf ("Stats [Allocations|Memory|Misc\n"); AcpiOsPrintf (" |Objects|Tables] Display namespace and memory statistics\n"); AcpiOsPrintf ("Tables Display info about loaded ACPI tables\n"); - AcpiOsPrintf ("Unload Unload an ACPI table\n"); + AcpiOsPrintf ("Unload [Instance] Unload an ACPI table\n"); AcpiOsPrintf ("! Execute command from history buffer\n"); AcpiOsPrintf ("!! Execute last command again\n"); return; case 'N': AcpiOsPrintf ("\nNamespace Access Commands\n\n"); AcpiOsPrintf ("Debug [Arguments] Single Step a control method\n"); AcpiOsPrintf ("Event Generate AcpiEvent (Fixed/GPE)\n"); AcpiOsPrintf ("Execute [Arguments] Execute control method\n"); AcpiOsPrintf ("Find (? is wildcard) Find ACPI name(s) with wildcards\n"); AcpiOsPrintf ("Method Display list of loaded control methods\n"); AcpiOsPrintf ("Namespace [|] [Depth] Display loaded namespace tree/subtree\n"); AcpiOsPrintf ("Notify Send a notification\n"); AcpiOsPrintf ("Objects Display all objects of the given type\n"); AcpiOsPrintf ("Owner [Depth] Display loaded namespace by object owner\n"); AcpiOsPrintf ("Prefix [] Set or Get current execution prefix\n"); AcpiOsPrintf ("References Find all references to object at addr\n"); AcpiOsPrintf ("Resources xxx Get and display resources\n"); AcpiOsPrintf ("Terminate Delete namespace and all internal objects\n"); AcpiOsPrintf ("Thread Spawn threads to execute method(s)\n"); return; case 'M': AcpiOsPrintf ("\nControl Method Execution Commands\n\n"); AcpiOsPrintf ("Arguments (or Args) Display method arguments\n"); AcpiOsPrintf ("Breakpoint Set an AML execution breakpoint\n"); AcpiOsPrintf ("Call Run to next control method invocation\n"); AcpiOsPrintf ("Go Allow method to run to completion\n"); AcpiOsPrintf ("Information Display info about the current method\n"); AcpiOsPrintf ("Into Step into (not over) a method call\n"); AcpiOsPrintf ("List [# of Aml Opcodes] Display method ASL statements\n"); AcpiOsPrintf ("Locals Display method local variables\n"); AcpiOsPrintf ("Results Display method result stack\n"); AcpiOsPrintf ("Set <#> Set method data (Arguments/Locals)\n"); AcpiOsPrintf ("Stop Terminate control method\n"); AcpiOsPrintf ("Tree Display control method calling tree\n"); AcpiOsPrintf (" Single step next AML opcode (over calls)\n"); return; case 'F': AcpiOsPrintf ("\nFile I/O Commands\n\n"); AcpiOsPrintf ("Close Close debug output file\n"); AcpiOsPrintf ("Open Open a file for debug output\n"); AcpiOsPrintf ("Load Load ACPI table from a file\n"); return; default: AcpiOsPrintf ("Unrecognized Command Class: %x\n", HelpType); return; } } /******************************************************************************* * * FUNCTION: AcpiDbGetNextToken * * PARAMETERS: String - Command buffer * Next - Return value, end of next token * * RETURN: Pointer to the start of the next token. * * DESCRIPTION: Command line parsing. Get the next token on the command line * ******************************************************************************/ NATIVE_CHAR * AcpiDbGetNextToken ( NATIVE_CHAR *String, NATIVE_CHAR **Next) { NATIVE_CHAR *Start; /* At end of buffer? */ if (!String || !(*String)) { return (NULL); } /* Get rid of any spaces at the beginning */ if (*String == ' ') { while (*String && (*String == ' ')) { String++; } if (!(*String)) { return (NULL); } } Start = String; /* Find end of token */ while (*String && (*String != ' ')) { String++; } if (!(*String)) { *Next = NULL; } else { *String = 0; *Next = String + 1; } return (Start); } /******************************************************************************* * * FUNCTION: AcpiDbGetLine * * PARAMETERS: InputBuffer - Command line buffer * * RETURN: None * * DESCRIPTION: Get the next command line from the user. Gets entire line * up to the next newline * ******************************************************************************/ UINT32 AcpiDbGetLine ( NATIVE_CHAR *InputBuffer) { UINT32 i; UINT32 Count; NATIVE_CHAR *Next; NATIVE_CHAR *This; STRCPY (ParsedBuf, InputBuffer); STRUPR (ParsedBuf); This = ParsedBuf; for (i = 0; i < DB_MAX_ARGS; i++) { Args[i] = AcpiDbGetNextToken (This, &Next); if (!Args[i]) { break; } This = Next; } /* Uppercase the actual command */ if (Args[0]) { STRUPR (Args[0]); } Count = i; if (Count) { Count--; /* Number of args only */ } return (Count); } /******************************************************************************* * * FUNCTION: AcpiDbMatchCommand * * PARAMETERS: UserCommand - User command line * * RETURN: Index into command array, -1 if not found * * DESCRIPTION: Search command array for a command match * ******************************************************************************/ UINT32 AcpiDbMatchCommand ( NATIVE_CHAR *UserCommand) { UINT32 i; if (!UserCommand || UserCommand[0] == 0) { return (CMD_NULL); } for (i = CMD_FIRST_VALID; Commands[i].Name; i++) { if (STRSTR (Commands[i].Name, UserCommand) == Commands[i].Name) { return (i); } } /* Command not recognized */ return (CMD_NOT_FOUND); } /******************************************************************************* * * FUNCTION: AcpiDbCommandDispatch * * PARAMETERS: InputBuffer - Command line buffer * WalkState - Current walk * Op - Current (executing) parse op * * RETURN: Status * * DESCRIPTION: Command dispatcher. Called from two places: * ******************************************************************************/ ACPI_STATUS AcpiDbCommandDispatch ( NATIVE_CHAR *InputBuffer, ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { UINT32 Temp; UINT32 CommandIndex; UINT32 ParamCount; NATIVE_CHAR *CommandLine; ACPI_STATUS Status = AE_CTRL_TRUE; /* If AcpiTerminate has been called, terminate this thread */ if (AcpiGbl_DbTerminateThreads) { return (AE_CTRL_TERMINATE); } ParamCount = AcpiDbGetLine (InputBuffer); CommandIndex = AcpiDbMatchCommand (Args[0]); Temp = 0; /* Verify that we have the minimum number of params */ if (ParamCount < Commands[CommandIndex].MinArgs) { AcpiOsPrintf ("%d parameters entered, [%s] requires %d parameters\n", ParamCount, Commands[CommandIndex].Name, Commands[CommandIndex].MinArgs); return (AE_CTRL_TRUE); } /* Decode and dispatch the command */ switch (CommandIndex) { case CMD_NULL: if (Op) { return (AE_OK); } break; case CMD_ALLOCATIONS: #ifdef ACPI_DBG_TRACK_ALLOCATIONS AcpiUtDumpCurrentAllocations ((UINT32) -1, NULL); #endif break; case CMD_ARGS: case CMD_ARGUMENTS: AcpiDbDisplayArguments (); break; case CMD_BREAKPOINT: AcpiDbSetMethodBreakpoint (Args[1], WalkState, Op); break; case CMD_CALL: AcpiDbSetMethodCallBreakpoint (Op); Status = AE_OK; break; case CMD_CLOSE: AcpiDbCloseDebugFile (); break; case CMD_DEBUG: AcpiDbExecute (Args[1], &Args[2], EX_SINGLE_STEP); break; case CMD_DUMP: AcpiDbDecodeAndDisplayObject (Args[1], Args[2]); break; case CMD_ENABLEACPI: Status = AcpiEnable(); if (ACPI_FAILURE(Status)) { AcpiOsPrintf("AcpiEnable failed (Status=%X)\n", Status); return (Status); } break; case CMD_EVENT: AcpiOsPrintf ("Event command not implemented\n"); break; case CMD_EXECUTE: AcpiDbExecute (Args[1], &Args[2], EX_NO_SINGLE_STEP); break; case CMD_FIND: AcpiDbFindNameInNamespace (Args[1]); break; case CMD_GO: AcpiGbl_CmSingleStep = FALSE; return (AE_OK); case CMD_HELP: case CMD_HELP2: AcpiDbDisplayHelp (Args[1]); break; case CMD_HISTORY: AcpiDbDisplayHistory (); break; case CMD_HISTORY_EXE: CommandLine = AcpiDbGetFromHistory (Args[1]); if (!CommandLine) { return (AE_CTRL_TRUE); } Status = AcpiDbCommandDispatch (CommandLine, WalkState, Op); if (ACPI_SUCCESS (Status)) { Status = AE_CTRL_TRUE; } return (Status); break; case CMD_HISTORY_LAST: CommandLine = AcpiDbGetFromHistory (NULL); if (!CommandLine) { return (AE_CTRL_TRUE); } Status = AcpiDbCommandDispatch (CommandLine, WalkState, Op); if (ACPI_SUCCESS (Status)) { Status = AE_CTRL_TRUE; } return (Status); case CMD_INFORMATION: AcpiDbDisplayMethodInfo (Op); break; case CMD_INTO: if (Op) { AcpiGbl_CmSingleStep = TRUE; /* TBD: Must get current walk state */ /* AcpiGbl_MethodBreakpoint = 0; */ return (AE_OK); } break; case CMD_LEVEL: if (ParamCount == 0) { AcpiOsPrintf ("Current debug level for file output is: %8.8lX\n", AcpiGbl_DbDebugLevel); AcpiOsPrintf ("Current debug level for console output is: %8.8lX\n", AcpiGbl_DbConsoleDebugLevel); } else if (ParamCount == 2) { Temp = AcpiGbl_DbConsoleDebugLevel; AcpiGbl_DbConsoleDebugLevel = STRTOUL (Args[1], NULL, 16); AcpiOsPrintf ("Debug Level for console output was %8.8lX, now %8.8lX\n", Temp, AcpiGbl_DbConsoleDebugLevel); } else { Temp = AcpiGbl_DbDebugLevel; AcpiGbl_DbDebugLevel = STRTOUL (Args[1], NULL, 16); AcpiOsPrintf ("Debug Level for file output was %8.8lX, now %8.8lX\n", Temp, AcpiGbl_DbDebugLevel); } break; case CMD_LIST: AcpiDbDisassembleAml (Args[1], Op); break; case CMD_LOAD: Status = AcpiDbLoadAcpiTable (Args[1]); if (ACPI_FAILURE (Status)) { return (Status); } break; case CMD_LOCKS: AcpiDbDisplayLocks (); break; case CMD_LOCALS: AcpiDbDisplayLocals (); break; case CMD_METHODS: AcpiDbDisplayObjects ("METHOD", Args[1]); break; case CMD_NAMESPACE: AcpiDbDumpNamespace (Args[1], Args[2]); break; case CMD_NOTIFY: Temp = STRTOUL (Args[2], NULL, 0); AcpiDbSendNotify (Args[1], Temp); break; case CMD_OBJECT: AcpiDbDisplayObjects (STRUPR (Args[1]), Args[2]); break; case CMD_OPEN: AcpiDbOpenDebugFile (Args[1]); break; case CMD_OWNER: AcpiDbDumpNamespaceByOwner (Args[1], Args[2]); break; case CMD_PREFIX: AcpiDbSetScope (Args[1]); break; case CMD_REFERENCES: AcpiDbFindReferences (Args[1]); break; case CMD_RESOURCES: AcpiDbDisplayResources (Args[1]); break; case CMD_RESULTS: AcpiDbDisplayResults (); break; case CMD_SET: AcpiDbSetMethodData (Args[1], Args[2], Args[3]); break; case CMD_STATS: AcpiDbDisplayStatistics (Args[1]); break; case CMD_STOP: return (AE_AML_ERROR); break; case CMD_TABLES: AcpiDbDisplayTableInfo (Args[1]); break; case CMD_TERMINATE: AcpiDbSetOutputDestination (DB_REDIRECTABLE_OUTPUT); AcpiUtSubsystemShutdown (); /* TBD: [Restructure] Need some way to re-initialize without re-creating the semaphores! */ /* AcpiInitialize (NULL); */ break; case CMD_THREADS: AcpiDbCreateExecutionThreads (Args[1], Args[2], Args[3]); break; case CMD_TREE: AcpiDbDisplayCallingTree (); break; case CMD_UNLOAD: AcpiDbUnloadAcpiTable (Args[1], Args[2]); break; case CMD_EXIT: case CMD_QUIT: if (Op) { AcpiOsPrintf ("Method execution terminated\n"); return (AE_CTRL_TERMINATE); } if (!OutputToFile) { AcpiDbgLevel = DEBUG_DEFAULT; } /* Shutdown */ /* AcpiUtSubsystemShutdown (); */ AcpiDbCloseDebugFile (); AcpiGbl_DbTerminateThreads = TRUE; return (AE_CTRL_TERMINATE); case CMD_NOT_FOUND: AcpiOsPrintf ("Unknown Command\n"); return (AE_CTRL_TRUE); } /* Add all commands that come here to the history buffer */ AcpiDbAddToHistory (InputBuffer); return (Status); } /******************************************************************************* * * FUNCTION: AcpiDbExecuteThread * * PARAMETERS: Context - Not used * * RETURN: None * * DESCRIPTION: Debugger execute thread. Waits for a command line, then * simply dispatches it. * ******************************************************************************/ void AcpiDbExecuteThread ( void *Context) { ACPI_STATUS Status = AE_OK; while (Status != AE_CTRL_TERMINATE) { AcpiGbl_MethodExecuting = FALSE; AcpiGbl_StepToNextCall = FALSE; AcpiUtAcquireMutex (ACPI_MTX_DEBUG_CMD_READY); Status = AcpiDbCommandDispatch (LineBuf, NULL, NULL); AcpiUtReleaseMutex (ACPI_MTX_DEBUG_CMD_COMPLETE); } } /******************************************************************************* * * FUNCTION: AcpiDbSingleThread * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Debugger execute thread. Waits for a command line, then * simply dispatches it. * ******************************************************************************/ void AcpiDbSingleThread ( void) { ACPI_STATUS Status = AE_OK; AcpiGbl_MethodExecuting = FALSE; AcpiGbl_StepToNextCall = FALSE; Status = AcpiDbCommandDispatch (LineBuf, NULL, NULL); } /******************************************************************************* * * FUNCTION: AcpiDbUserCommands * * PARAMETERS: Prompt - User prompt (depends on mode) * Op - Current executing parse op * * RETURN: None * * DESCRIPTION: Command line execution for the AML debugger. Commands are * matched and dispatched here. * ******************************************************************************/ ACPI_STATUS AcpiDbUserCommands ( NATIVE_CHAR Prompt, ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status = AE_OK; /* TBD: [Restructure] Need a separate command line buffer for step mode */ while (!AcpiGbl_DbTerminateThreads) { /* Force output to console until a command is entered */ AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT); /* Different prompt if method is executing */ if (!AcpiGbl_MethodExecuting) { AcpiOsPrintf ("%1c ", DB_COMMAND_PROMPT); } else { AcpiOsPrintf ("%1c ", DB_EXECUTE_PROMPT); } /* Get the user input line */ AcpiOsGetLine (LineBuf); /* Check for single or multithreaded debug */ if (AcpiGbl_DebuggerConfiguration & DEBUGGER_MULTI_THREADED) { /* * Signal the debug thread that we have a command to execute, * and wait for the command to complete. */ AcpiUtReleaseMutex (ACPI_MTX_DEBUG_CMD_READY); AcpiUtAcquireMutex (ACPI_MTX_DEBUG_CMD_COMPLETE); } else { /* Just call to the command line interpreter */ AcpiDbSingleThread (); } } /* * Only this thread (the original thread) should actually terminate the subsystem, * because all the semaphores are deleted during termination */ AcpiTerminate (); return (Status); } #endif /* ENABLE_DEBUGGER */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbstats.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbstats.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbstats.c (revision 82367) @@ -1,550 +1,561 @@ /******************************************************************************* * * Module Name: dbstats - Generation and display of ACPI table statistics - * $Revision: 41 $ + * $Revision: 43 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include #include #include #include #include #ifdef ENABLE_DEBUGGER #define _COMPONENT ACPI_DEBUGGER MODULE_NAME ("dbstats") /* * Statistics subcommands */ ARGUMENT_INFO AcpiDbStatTypes [] = { {"ALLOCATIONS"}, {"OBJECTS"}, {"MEMORY"}, {"MISC"}, {"TABLES"}, {"SIZES"}, {NULL} /* Must be null terminated */ }; #define CMD_ALLOCATIONS 0 #define CMD_OBJECTS 1 #define CMD_MEMORY 2 #define CMD_MISC 3 #define CMD_TABLES 4 #define CMD_SIZES 5 /* * Statistic globals */ UINT16 AcpiGbl_ObjTypeCount[INTERNAL_TYPE_NODE_MAX+1]; UINT16 AcpiGbl_NodeTypeCount[INTERNAL_TYPE_NODE_MAX+1]; UINT16 AcpiGbl_ObjTypeCountMisc; UINT16 AcpiGbl_NodeTypeCountMisc; UINT32 NumNodes; UINT32 NumObjects; UINT32 SizeOfParseTree; UINT32 SizeOfMethodTrees; UINT32 SizeOfNodeEntries; UINT32 SizeOfAcpiObjects; /******************************************************************************* * * FUNCTION: AcpiDbEnumerateObject * * PARAMETERS: ObjDesc - Object to be counted * * RETURN: None * * DESCRIPTION: Add this object to the global counts, by object type. * Recursively handles subobjects and packages. * * [TBD] Restructure - remove recursion. * ******************************************************************************/ void AcpiDbEnumerateObject ( ACPI_OPERAND_OBJECT *ObjDesc) { UINT32 Type; UINT32 i; if (!ObjDesc) { return; } /* Enumerate this object first */ NumObjects++; Type = ObjDesc->Common.Type; if (Type > INTERNAL_TYPE_NODE_MAX) { AcpiGbl_ObjTypeCountMisc++; } else { AcpiGbl_ObjTypeCount [Type]++; } /* Count the sub-objects */ switch (Type) { case ACPI_TYPE_PACKAGE: for (i = 0; i< ObjDesc->Package.Count; i++) { AcpiDbEnumerateObject (ObjDesc->Package.Elements[i]); } break; case ACPI_TYPE_DEVICE: AcpiDbEnumerateObject (ObjDesc->Device.SysHandler); AcpiDbEnumerateObject (ObjDesc->Device.DrvHandler); AcpiDbEnumerateObject (ObjDesc->Device.AddrHandler); break; case ACPI_TYPE_REGION: AcpiDbEnumerateObject (ObjDesc->Region.AddrHandler); break; case ACPI_TYPE_POWER: AcpiDbEnumerateObject (ObjDesc->PowerResource.SysHandler); AcpiDbEnumerateObject (ObjDesc->PowerResource.DrvHandler); break; case ACPI_TYPE_PROCESSOR: AcpiDbEnumerateObject (ObjDesc->Processor.SysHandler); AcpiDbEnumerateObject (ObjDesc->Processor.DrvHandler); AcpiDbEnumerateObject (ObjDesc->Processor.AddrHandler); break; case ACPI_TYPE_THERMAL: AcpiDbEnumerateObject (ObjDesc->ThermalZone.SysHandler); AcpiDbEnumerateObject (ObjDesc->ThermalZone.DrvHandler); AcpiDbEnumerateObject (ObjDesc->ThermalZone.AddrHandler); break; } } #ifndef PARSER_ONLY /******************************************************************************* * * FUNCTION: AcpiDbClassifyOneObject * * PARAMETERS: Callback for WalkNamespace * * RETURN: Status * * DESCRIPTION: Enumerate both the object descriptor (including subobjects) and * the parent namespace node. * ******************************************************************************/ ACPI_STATUS AcpiDbClassifyOneObject ( ACPI_HANDLE ObjHandle, UINT32 NestingLevel, void *Context, void **ReturnValue) { ACPI_NAMESPACE_NODE *Node; ACPI_OPERAND_OBJECT *ObjDesc; UINT32 Type; NumNodes++; Node = (ACPI_NAMESPACE_NODE *) ObjHandle; ObjDesc = ((ACPI_NAMESPACE_NODE *) ObjHandle)->Object; AcpiDbEnumerateObject (ObjDesc); Type = Node->Type; if (Type > INTERNAL_TYPE_INVALID) { AcpiGbl_NodeTypeCountMisc++; } else { AcpiGbl_NodeTypeCount [Type]++; } return AE_OK; /* TBD: These need to be counted during the initial parsing phase */ /* if (AcpiPsIsNamedOp (Op->Opcode)) { NumNodes++; } if (IsMethod) { NumMethodElements++; } NumGrammarElements++; Op = AcpiPsGetDepthNext (Root, Op); SizeOfParseTree = (NumGrammarElements - NumMethodElements) * (UINT32) sizeof (ACPI_PARSE_OBJECT); SizeOfMethodTrees = NumMethodElements * (UINT32) sizeof (ACPI_PARSE_OBJECT); SizeOfNodeEntries = NumNodes * (UINT32) sizeof (ACPI_NAMESPACE_NODE); SizeOfAcpiObjects = NumNodes * (UINT32) sizeof (ACPI_OPERAND_OBJECT); */ } /******************************************************************************* * * FUNCTION: AcpiDbCountNamespaceObjects * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Count and classify the entire namespace, including all * namespace nodes and attached objects. * ******************************************************************************/ ACPI_STATUS AcpiDbCountNamespaceObjects ( void) { UINT32 i; NumNodes = 0; NumObjects = 0; AcpiGbl_ObjTypeCountMisc = 0; for (i = 0; i < INTERNAL_TYPE_INVALID; i++) { AcpiGbl_ObjTypeCount [i] = 0; AcpiGbl_NodeTypeCount [i] = 0; } AcpiNsWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, FALSE, AcpiDbClassifyOneObject, NULL, NULL); return (AE_OK); } #endif /******************************************************************************* * * FUNCTION: AcpiDbDisplayStatistics * * PARAMETERS: TypeArg - Subcommand * * RETURN: Status * * DESCRIPTION: Display various statistics * ******************************************************************************/ ACPI_STATUS AcpiDbDisplayStatistics ( NATIVE_CHAR *TypeArg) { UINT32 i; UINT32 Type; + UINT32 Outstanding; + UINT32 Size; if (!AcpiGbl_DSDT) { AcpiOsPrintf ("*** Warning: There is no DSDT loaded\n"); } if (!TypeArg) { AcpiOsPrintf ("The following subcommands are available:\n ALLOCATIONS, OBJECTS, MEMORY, MISC, SIZES, TABLES\n"); return (AE_OK); } STRUPR (TypeArg); Type = AcpiDbMatchArgument (TypeArg, AcpiDbStatTypes); if (Type == (UINT32) -1) { AcpiOsPrintf ("Invalid or unsupported argument\n"); return (AE_OK); } #ifndef PARSER_ONLY AcpiDbCountNamespaceObjects (); #endif switch (Type) { #ifndef PARSER_ONLY case CMD_ALLOCATIONS: #ifdef ACPI_DBG_TRACK_ALLOCATIONS AcpiUtDumpAllocationInfo (); #endif break; #endif case CMD_TABLES: AcpiOsPrintf ("ACPI Table Information:\n\n"); if (AcpiGbl_DSDT) { AcpiOsPrintf ("DSDT Length:................% 7ld (%X)\n", AcpiGbl_DSDT->Length, AcpiGbl_DSDT->Length); } break; case CMD_OBJECTS: AcpiOsPrintf ("\nObjects defined in the current namespace:\n\n"); AcpiOsPrintf ("%16.16s % 10.10s % 10.10s\n", "ACPI_TYPE", "NODES", "OBJECTS"); for (i = 0; i < INTERNAL_TYPE_NODE_MAX; i++) { AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", AcpiUtGetTypeName (i), AcpiGbl_NodeTypeCount [i], AcpiGbl_ObjTypeCount [i]); } AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", "Misc/Unknown", AcpiGbl_NodeTypeCountMisc, AcpiGbl_ObjTypeCountMisc); AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", "TOTALS:", NumNodes, NumObjects); /* AcpiOsPrintf ("\n"); AcpiOsPrintf ("ASL/AML Grammar Usage:\n\n"); AcpiOsPrintf ("Elements Inside Methods:....% 7ld\n", NumMethodElements); AcpiOsPrintf ("Elements Outside Methods:...% 7ld\n", NumGrammarElements - NumMethodElements); AcpiOsPrintf ("Total Grammar Elements:.....% 7ld\n", NumGrammarElements); */ break; case CMD_MEMORY: - AcpiOsPrintf ("\nDynamic Memory Estimates:\n\n"); - AcpiOsPrintf ("Parse Tree without Methods:.% 7ld\n", SizeOfParseTree); - AcpiOsPrintf ("Control Method Parse Trees:.% 7ld (If parsed simultaneously)\n", SizeOfMethodTrees); - AcpiOsPrintf ("Namespace Nodes:............% 7ld (%d nodes)\n", sizeof (ACPI_NAMESPACE_NODE) * NumNodes, NumNodes); - AcpiOsPrintf ("Named Internal Objects......% 7ld\n", SizeOfAcpiObjects); - AcpiOsPrintf ("State Cache size............% 7ld\n", AcpiGbl_GenericStateCacheDepth * sizeof (ACPI_GENERIC_STATE)); - AcpiOsPrintf ("Parse Cache size............% 7ld\n", AcpiGbl_ParseCacheDepth * sizeof (ACPI_PARSE_OBJECT)); - AcpiOsPrintf ("Object Cache size...........% 7ld\n", AcpiGbl_ObjectCacheDepth * sizeof (ACPI_OPERAND_OBJECT)); - AcpiOsPrintf ("WalkState Cache size........% 7ld\n", AcpiGbl_WalkStateCacheDepth * sizeof (ACPI_WALK_STATE)); +#ifdef ACPI_DBG_TRACK_ALLOCATIONS + AcpiOsPrintf ("\n----Object and Cache Statistics---------------------------------------------\n"); - AcpiOsPrintf ("\n"); + for (i = 0; i < ACPI_NUM_MEM_LISTS; i++) + { + AcpiOsPrintf ("\n%s\n", AcpiGbl_MemoryLists[i].ListName); - AcpiOsPrintf ("Cache Statistics:\n\n"); - AcpiOsPrintf ("State Cache requests........% 7ld\n", AcpiGbl_StateCacheRequests); - AcpiOsPrintf ("State Cache hits............% 7ld\n", AcpiGbl_StateCacheHits); - AcpiOsPrintf ("State Cache depth...........% 7ld (%d remaining entries)\n", AcpiGbl_GenericStateCacheDepth, - MAX_STATE_CACHE_DEPTH - AcpiGbl_GenericStateCacheDepth); - AcpiOsPrintf ("Parse Cache requests........% 7ld\n", AcpiGbl_ParseCacheRequests); - AcpiOsPrintf ("Parse Cache hits............% 7ld\n", AcpiGbl_ParseCacheHits); - AcpiOsPrintf ("Parse Cache depth...........% 7ld (%d remaining entries)\n", AcpiGbl_ParseCacheDepth, - MAX_PARSE_CACHE_DEPTH - AcpiGbl_ParseCacheDepth); - AcpiOsPrintf ("Ext Parse Cache requests....% 7ld\n", AcpiGbl_ExtParseCacheRequests); - AcpiOsPrintf ("Ext Parse Cache hits........% 7ld\n", AcpiGbl_ExtParseCacheHits); - AcpiOsPrintf ("Ext Parse Cache depth.......% 7ld (%d remaining entries)\n", AcpiGbl_ExtParseCacheDepth, - MAX_EXTPARSE_CACHE_DEPTH - AcpiGbl_ExtParseCacheDepth); - AcpiOsPrintf ("Object Cache requests.......% 7ld\n", AcpiGbl_ObjectCacheRequests); - AcpiOsPrintf ("Object Cache hits...........% 7ld\n", AcpiGbl_ObjectCacheHits); - AcpiOsPrintf ("Object Cache depth..........% 7ld (%d remaining entries)\n", AcpiGbl_ObjectCacheDepth, - MAX_OBJECT_CACHE_DEPTH - AcpiGbl_ObjectCacheDepth); - AcpiOsPrintf ("WalkState Cache requests....% 7ld\n", AcpiGbl_WalkStateCacheRequests); - AcpiOsPrintf ("WalkState Cache hits........% 7ld\n", AcpiGbl_WalkStateCacheHits); - AcpiOsPrintf ("WalkState Cache depth.......% 7ld (%d remaining entries)\n", AcpiGbl_WalkStateCacheDepth, - MAX_WALK_CACHE_DEPTH - AcpiGbl_WalkStateCacheDepth); + if (AcpiGbl_MemoryLists[i].MaxCacheDepth > 0) + { + AcpiOsPrintf (" Cache: [Depth Max Avail Size] % 7d % 7d % 7d % 7d B\n", + AcpiGbl_MemoryLists[i].CacheDepth, + AcpiGbl_MemoryLists[i].MaxCacheDepth, + AcpiGbl_MemoryLists[i].MaxCacheDepth - AcpiGbl_MemoryLists[i].CacheDepth, + (AcpiGbl_MemoryLists[i].CacheDepth * AcpiGbl_MemoryLists[i].ObjectSize)); + + AcpiOsPrintf (" Cache: [Requests Hits Misses ObjSize] % 7d % 7d % 7d % 7d B\n", + AcpiGbl_MemoryLists[i].CacheRequests, + AcpiGbl_MemoryLists[i].CacheHits, + AcpiGbl_MemoryLists[i].CacheRequests - AcpiGbl_MemoryLists[i].CacheHits, + AcpiGbl_MemoryLists[i].ObjectSize); + } + + Outstanding = AcpiGbl_MemoryLists[i].TotalAllocated - + AcpiGbl_MemoryLists[i].TotalFreed - + AcpiGbl_MemoryLists[i].CacheDepth; + + if (AcpiGbl_MemoryLists[i].ObjectSize) + { + Size = ROUND_UP_TO_1K (Outstanding * AcpiGbl_MemoryLists[i].ObjectSize); + } + else + { + Size = ROUND_UP_TO_1K (AcpiGbl_MemoryLists[i].CurrentTotalSize); + } + + AcpiOsPrintf (" Mem: [Alloc Free Outstanding Size] % 7d % 7d % 7d % 7d Kb\n", + AcpiGbl_MemoryLists[i].TotalAllocated, + AcpiGbl_MemoryLists[i].TotalFreed, + Outstanding, Size); + } +#endif + break; case CMD_MISC: AcpiOsPrintf ("\nMiscellaneous Statistics:\n\n"); AcpiOsPrintf ("Calls to AcpiPsFind:.. ........% 7ld\n", AcpiGbl_PsFindCount); AcpiOsPrintf ("Calls to AcpiNsLookup:..........% 7ld\n", AcpiGbl_NsLookupCount); AcpiOsPrintf ("\n"); AcpiOsPrintf ("Mutex usage:\n\n"); for (i = 0; i < NUM_MTX; i++) { AcpiOsPrintf ("%-28s: % 7ld\n", AcpiUtGetMutexName (i), AcpiGbl_AcpiMutexInfo[i].UseCount); } break; case CMD_SIZES: AcpiOsPrintf ("\nInternal object sizes:\n\n"); AcpiOsPrintf ("Common %3d\n", sizeof (ACPI_OBJECT_COMMON)); AcpiOsPrintf ("Number %3d\n", sizeof (ACPI_OBJECT_INTEGER)); AcpiOsPrintf ("String %3d\n", sizeof (ACPI_OBJECT_STRING)); AcpiOsPrintf ("Buffer %3d\n", sizeof (ACPI_OBJECT_BUFFER)); AcpiOsPrintf ("Package %3d\n", sizeof (ACPI_OBJECT_PACKAGE)); AcpiOsPrintf ("BufferField %3d\n", sizeof (ACPI_OBJECT_BUFFER_FIELD)); AcpiOsPrintf ("Device %3d\n", sizeof (ACPI_OBJECT_DEVICE)); AcpiOsPrintf ("Event %3d\n", sizeof (ACPI_OBJECT_EVENT)); AcpiOsPrintf ("Method %3d\n", sizeof (ACPI_OBJECT_METHOD)); AcpiOsPrintf ("Mutex %3d\n", sizeof (ACPI_OBJECT_MUTEX)); AcpiOsPrintf ("Region %3d\n", sizeof (ACPI_OBJECT_REGION)); AcpiOsPrintf ("PowerResource %3d\n", sizeof (ACPI_OBJECT_POWER_RESOURCE)); AcpiOsPrintf ("Processor %3d\n", sizeof (ACPI_OBJECT_PROCESSOR)); AcpiOsPrintf ("ThermalZone %3d\n", sizeof (ACPI_OBJECT_THERMAL_ZONE)); AcpiOsPrintf ("RegionField %3d\n", sizeof (ACPI_OBJECT_REGION_FIELD)); AcpiOsPrintf ("BankField %3d\n", sizeof (ACPI_OBJECT_BANK_FIELD)); AcpiOsPrintf ("IndexField %3d\n", sizeof (ACPI_OBJECT_INDEX_FIELD)); AcpiOsPrintf ("Reference %3d\n", sizeof (ACPI_OBJECT_REFERENCE)); AcpiOsPrintf ("NotifyHandler %3d\n", sizeof (ACPI_OBJECT_NOTIFY_HANDLER)); AcpiOsPrintf ("AddrHandler %3d\n", sizeof (ACPI_OBJECT_ADDR_HANDLER)); AcpiOsPrintf ("Extra %3d\n", sizeof (ACPI_OBJECT_EXTRA)); AcpiOsPrintf ("\n"); AcpiOsPrintf ("ParseObject %3d\n", sizeof (ACPI_PARSE_OBJECT)); AcpiOsPrintf ("Parse2Object %3d\n", sizeof (ACPI_PARSE2_OBJECT)); AcpiOsPrintf ("OperandObject %3d\n", sizeof (ACPI_OPERAND_OBJECT)); AcpiOsPrintf ("NamespaceNode %3d\n", sizeof (ACPI_NAMESPACE_NODE)); break; } AcpiOsPrintf ("\n"); return (AE_OK); } #endif /* ENABLE_DEBUGGER */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbutils.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbutils.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbutils.c (revision 82367) @@ -1,465 +1,473 @@ /******************************************************************************* * * Module Name: dbutils - AML debugger utilities - * $Revision: 39 $ + * $Revision: 41 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #include "acnamesp.h" #include "acparser.h" #include "acevents.h" #include "acinterp.h" #include "acdebug.h" #include "acdispat.h" #ifdef ENABLE_DEBUGGER #define _COMPONENT ACPI_DEBUGGER MODULE_NAME ("dbutils") /******************************************************************************* * * FUNCTION: AcpiDbSetOutputDestination * * PARAMETERS: OutputFlags - Current flags word * * RETURN: None * * DESCRIPTION: Set the current destination for debugger output. Alos sets * the debug output level accordingly. * ******************************************************************************/ void AcpiDbSetOutputDestination ( UINT32 OutputFlags) { AcpiGbl_DbOutputFlags = (UINT8) OutputFlags; if (OutputFlags & DB_REDIRECTABLE_OUTPUT) { if (OutputToFile) { AcpiDbgLevel = AcpiGbl_DbDebugLevel; } } else { AcpiDbgLevel = AcpiGbl_DbConsoleDebugLevel; } } /******************************************************************************* * * FUNCTION: AcpiDbDumpBuffer * * PARAMETERS: Address - Pointer to the buffer * * RETURN: None * * DESCRIPTION: Print a portion of a buffer * ******************************************************************************/ void AcpiDbDumpBuffer ( UINT32 Address) { AcpiOsPrintf ("\nLocation %X:\n", Address); - AcpiDbgLevel |= TRACE_TABLES; + AcpiDbgLevel |= ACPI_LV_TABLES; AcpiUtDumpBuffer ((UINT8 *) Address, 64, DB_BYTE_DISPLAY, ACPI_UINT32_MAX); } /******************************************************************************* * * FUNCTION: AcpiDbDumpObject * * PARAMETERS: ObjDesc - External ACPI object to dump * Level - Nesting level. * * RETURN: None * * DESCRIPTION: Dump the contents of an ACPI external object * ******************************************************************************/ void AcpiDbDumpObject ( ACPI_OBJECT *ObjDesc, UINT32 Level) { UINT32 i; if (!ObjDesc) { AcpiOsPrintf ("[Null Object]\n"); return; } for (i = 0; i < Level; i++) { AcpiOsPrintf (" "); } switch (ObjDesc->Type) { case ACPI_TYPE_ANY: - AcpiOsPrintf ("[Object Reference] Value: %p\n", ObjDesc->Reference.Handle); + AcpiOsPrintf ("[Object Reference] = %p\n", ObjDesc->Reference.Handle); break; case ACPI_TYPE_INTEGER: - AcpiOsPrintf ("[Number] Value: %ld (%lX)\n", ObjDesc->Integer.Value, ObjDesc->Integer.Value); + + AcpiOsPrintf ("[Integer] = %X%8.8X\n", HIDWORD (ObjDesc->Integer.Value), + LODWORD (ObjDesc->Integer.Value)); break; case ACPI_TYPE_STRING: AcpiOsPrintf ("[String] Value: "); for (i = 0; i < ObjDesc->String.Length; i++) { AcpiOsPrintf ("%c", ObjDesc->String.Pointer[i]); } AcpiOsPrintf ("\n"); break; case ACPI_TYPE_BUFFER: - AcpiOsPrintf ("[Buffer] Value: "); + AcpiOsPrintf ("[Buffer] = "); AcpiUtDumpBuffer ((UINT8 *) ObjDesc->Buffer.Pointer, ObjDesc->Buffer.Length, DB_DWORD_DISPLAY, _COMPONENT); break; case ACPI_TYPE_PACKAGE: AcpiOsPrintf ("[Package] Contains %d Elements: \n", ObjDesc->Package.Count); for (i = 0; i < ObjDesc->Package.Count; i++) { AcpiDbDumpObject (&ObjDesc->Package.Elements[i], Level+1); } break; case INTERNAL_TYPE_REFERENCE: - AcpiOsPrintf ("[Object Reference] Value: %p\n", ObjDesc->Reference.Handle); + + AcpiOsPrintf ("[Object Reference] = %p\n", ObjDesc->Reference.Handle); break; + case ACPI_TYPE_PROCESSOR: + AcpiOsPrintf ("[Processor]\n"); break; + case ACPI_TYPE_POWER: + AcpiOsPrintf ("[Power Resource]\n"); break; + default: AcpiOsPrintf ("[Unknown Type] %X \n", ObjDesc->Type); break; } } /******************************************************************************* * * FUNCTION: AcpiDbPrepNamestring * * PARAMETERS: Name - String to prepare * * RETURN: None * * DESCRIPTION: Translate all forward slashes and dots to backslashes. * ******************************************************************************/ void AcpiDbPrepNamestring ( NATIVE_CHAR *Name) { if (!Name) { return; } STRUPR (Name); /* Convert a leading forward slash to a backslash */ if (*Name == '/') { *Name = '\\'; } /* Ignore a leading backslash, this is the root prefix */ if (*Name == '\\') { Name++; } /* Convert all slash path separators to dots */ while (*Name) { if ((*Name == '/') || (*Name == '\\')) { *Name = '.'; } Name++; } } /******************************************************************************* * * FUNCTION: AcpiDbSecondPassParse * * PARAMETERS: Root - Root of the parse tree * * RETURN: Status * * DESCRIPTION: Second pass parse of the ACPI tables. We need to wait until * second pass to parse the control methods * ******************************************************************************/ ACPI_STATUS AcpiDbSecondPassParse ( ACPI_PARSE_OBJECT *Root) { ACPI_PARSE_OBJECT *Op = Root; ACPI_PARSE2_OBJECT *Method; ACPI_PARSE_OBJECT *SearchOp; ACPI_PARSE_OBJECT *StartOp; ACPI_STATUS Status = AE_OK; UINT32 BaseAmlOffset; AcpiOsPrintf ("Pass two parse ....\n"); while (Op) { if (Op->Opcode == AML_METHOD_OP) { Method = (ACPI_PARSE2_OBJECT *) Op; Status = AcpiPsParseAml (Op, Method->Data, Method->Length, 0, NULL, NULL, NULL, AcpiDsLoad1BeginOp, AcpiDsLoad1EndOp); BaseAmlOffset = (Method->Value.Arg)->AmlOffset + 1; StartOp = (Method->Value.Arg)->Next; SearchOp = StartOp; while (SearchOp) { SearchOp->AmlOffset += BaseAmlOffset; SearchOp = AcpiPsGetDepthNext (StartOp, SearchOp); } } if (Op->Opcode == AML_REGION_OP) { /* TBD: [Investigate] this isn't quite the right thing to do! */ /* * * Method = (ACPI_DEFERRED_OP *) Op; * Status = AcpiPsParseAml (Op, Method->Body, Method->BodyLength); */ } if (ACPI_FAILURE (Status)) { return (Status); } Op = AcpiPsGetDepthNext (Root, Op); } return (Status); } /******************************************************************************* * * FUNCTION: AcpiDbLocalNsLookup * * PARAMETERS: Name - Name to lookup * * RETURN: Pointer to a namespace node * * DESCRIPTION: Lookup a name in the ACPI namespace * ******************************************************************************/ ACPI_NAMESPACE_NODE * AcpiDbLocalNsLookup ( NATIVE_CHAR *Name) { NATIVE_CHAR *InternalPath; ACPI_STATUS Status; ACPI_NAMESPACE_NODE *Node = NULL; AcpiDbPrepNamestring (Name); /* Build an internal namestring */ Status = AcpiNsInternalizeName (Name, &InternalPath); if (ACPI_FAILURE (Status)) { AcpiOsPrintf ("Invalid namestring: %s\n", Name); return (NULL); } /* Lookup the name */ /* TBD: [Investigate] what scope do we use? */ /* Use the root scope for the start of the search */ Status = AcpiNsLookup (NULL, InternalPath, ACPI_TYPE_ANY, IMODE_EXECUTE, NS_NO_UPSEARCH | NS_DONT_OPEN_SCOPE, NULL, &Node); if (ACPI_FAILURE (Status)) { AcpiOsPrintf ("Could not locate name: %s %s\n", Name, AcpiFormatException (Status)); } ACPI_MEM_FREE (InternalPath); return (Node); } #endif /* ENABLE_DEBUGGER */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbxface.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbxface.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dbxface.c (revision 82367) @@ -1,432 +1,432 @@ /******************************************************************************* * * Module Name: dbxface - AML Debugger external interfaces - * $Revision: 37 $ + * $Revision: 38 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #include "acnamesp.h" #include "acparser.h" #include "acevents.h" #include "acinterp.h" #include "acdebug.h" #ifdef ENABLE_DEBUGGER #define _COMPONENT ACPI_DEBUGGER MODULE_NAME ("dbxface") /******************************************************************************* * * FUNCTION: AcpiDbSingleStep * * PARAMETERS: WalkState - Current walk * Op - Current executing op * OpType - Type of the current AML Opcode * * RETURN: Status * * DESCRIPTION: Called just before execution of an AML opcode. * ******************************************************************************/ ACPI_STATUS AcpiDbSingleStep ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, UINT8 OpType) { ACPI_PARSE_OBJECT *Next; ACPI_STATUS Status = AE_OK; UINT32 OriginalDebugLevel; ACPI_PARSE_OBJECT *DisplayOp; /* Is there a breakpoint set? */ if (WalkState->MethodBreakpoint) { /* Check if the breakpoint has been reached or passed */ if (WalkState->MethodBreakpoint <= Op->AmlOffset) { /* Hit the breakpoint, resume single step, reset breakpoint */ AcpiOsPrintf ("***Break*** at AML offset %X\n", Op->AmlOffset); AcpiGbl_CmSingleStep = TRUE; AcpiGbl_StepToNextCall = FALSE; WalkState->MethodBreakpoint = 0; } } /* * Check if this is an opcode that we are interested in -- * namely, opcodes that have arguments */ if (Op->Opcode == AML_INT_NAMEDFIELD_OP) { return (AE_OK); } switch (OpType) { case OPTYPE_UNDEFINED: case OPTYPE_CONSTANT: /* argument type only */ case OPTYPE_LITERAL: /* argument type only */ case OPTYPE_DATA_TERM: /* argument type only */ case OPTYPE_LOCAL_VARIABLE: /* argument type only */ case OPTYPE_METHOD_ARGUMENT: /* argument type only */ return (AE_OK); break; case OPTYPE_NAMED_OBJECT: switch (Op->Opcode) { case AML_INT_NAMEPATH_OP: return (AE_OK); break; } } /* * Under certain debug conditions, display this opcode and its operands */ if ((OutputToFile) || (AcpiGbl_CmSingleStep) || - (AcpiDbgLevel & TRACE_PARSE)) + (AcpiDbgLevel & ACPI_LV_PARSE)) { if ((OutputToFile) || - (AcpiDbgLevel & TRACE_PARSE)) + (AcpiDbgLevel & ACPI_LV_PARSE)) { AcpiOsPrintf ("\n[AmlDebug] Next AML Opcode to execute:\n"); } /* * Display this op (and only this op - zero out the NEXT field temporarily, * and disable parser trace output for the duration of the display because * we don't want the extraneous debug output) */ OriginalDebugLevel = AcpiDbgLevel; - AcpiDbgLevel &= ~(TRACE_PARSE | TRACE_FUNCTIONS); + AcpiDbgLevel &= ~(ACPI_LV_PARSE | ACPI_LV_FUNCTIONS); Next = Op->Next; Op->Next = NULL; DisplayOp = Op; if (Op->Parent) { if ((Op->Parent->Opcode == AML_IF_OP) || (Op->Parent->Opcode == AML_WHILE_OP)) { DisplayOp = Op->Parent; } } /* Now we can display it */ AcpiDbDisplayOp (WalkState, DisplayOp, ACPI_UINT32_MAX); if ((Op->Opcode == AML_IF_OP) || (Op->Opcode == AML_WHILE_OP)) { if (WalkState->ControlState->Common.Value) { AcpiOsPrintf ("Predicate was TRUE, executed block\n"); } else { AcpiOsPrintf ("Predicate is FALSE, skipping block\n"); } } else if (Op->Opcode == AML_ELSE_OP) { /* TBD */ } /* Restore everything */ Op->Next = Next; AcpiOsPrintf ("\n"); AcpiDbgLevel = OriginalDebugLevel; } /* If we are not single stepping, just continue executing the method */ if (!AcpiGbl_CmSingleStep) { return (AE_OK); } /* * If we are executing a step-to-call command, * Check if this is a method call. */ if (AcpiGbl_StepToNextCall) { if (Op->Opcode != AML_INT_METHODCALL_OP) { /* Not a method call, just keep executing */ return (AE_OK); } /* Found a method call, stop executing */ AcpiGbl_StepToNextCall = FALSE; } /* * If the next opcode is a method call, we will "step over" it * by default. */ if (Op->Opcode == AML_INT_METHODCALL_OP) { AcpiGbl_CmSingleStep = FALSE; /* No more single step while executing called method */ /* Set the breakpoint on the call, it will stop execution as soon as we return */ /* TBD: [Future] don't kill the user breakpoint! */ WalkState->MethodBreakpoint = /* Op->AmlOffset + */ 1; /* Must be non-zero! */ } /* TBD: [Investigate] what are the namespace locking issues here */ /* AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); */ /* Go into the command loop and await next user command */ AcpiGbl_MethodExecuting = TRUE; Status = AE_CTRL_TRUE; while (Status == AE_CTRL_TRUE) { if (AcpiGbl_DebuggerConfiguration == DEBUGGER_MULTI_THREADED) { /* Handshake with the front-end that gets user command lines */ AcpiUtReleaseMutex (ACPI_MTX_DEBUG_CMD_COMPLETE); AcpiUtAcquireMutex (ACPI_MTX_DEBUG_CMD_READY); } else { /* Single threaded, we must get a command line ourselves */ /* Force output to console until a command is entered */ AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT); /* Different prompt if method is executing */ if (!AcpiGbl_MethodExecuting) { AcpiOsPrintf ("%1c ", DB_COMMAND_PROMPT); } else { AcpiOsPrintf ("%1c ", DB_EXECUTE_PROMPT); } /* Get the user input line */ AcpiOsGetLine (LineBuf); } Status = AcpiDbCommandDispatch (LineBuf, WalkState, Op); } /* AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); */ /* User commands complete, continue execution of the interrupted method */ return (Status); } /******************************************************************************* * * FUNCTION: AcpiDbInitialize * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Init and start debugger * ******************************************************************************/ int AcpiDbInitialize (void) { /* Init globals */ Buffer = AcpiOsAllocate (BUFFER_SIZE); /* Initial scope is the root */ ScopeBuf [0] = '\\'; ScopeBuf [1] = 0; /* * If configured for multi-thread support, the debug executor runs in * a separate thread so that the front end can be in another address * space, environment, or even another machine. */ if (AcpiGbl_DebuggerConfiguration & DEBUGGER_MULTI_THREADED) { /* These were created with one unit, grab it */ AcpiUtAcquireMutex (ACPI_MTX_DEBUG_CMD_COMPLETE); AcpiUtAcquireMutex (ACPI_MTX_DEBUG_CMD_READY); /* Create the debug execution thread to execute commands */ AcpiOsQueueForExecution (0, AcpiDbExecuteThread, NULL); } if (!opt_verbose) { INDENT_STRING = " "; opt_disasm = TRUE; opt_stats = FALSE; } return (0); } #endif /* ENABLE_DEBUGGER */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsfield.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsfield.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsfield.c (revision 82367) @@ -1,518 +1,518 @@ /****************************************************************************** * * Module Name: dsfield - Dispatcher field routines - * $Revision: 41 $ + * $Revision: 43 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __DSFIELD_C__ #include "acpi.h" #include "amlcode.h" #include "acdispat.h" #include "acinterp.h" #include "acnamesp.h" #define _COMPONENT ACPI_DISPATCHER MODULE_NAME ("dsfield") /* * Field flags: Bits 00 - 03 : AccessType (AnyAcc, ByteAcc, etc.) * 04 : LockRule (1 == Lock) * 05 - 06 : UpdateRule */ #define FIELD_ACCESS_TYPE_MASK 0x0F #define FIELD_LOCK_RULE_MASK 0x10 #define FIELD_UPDATE_RULE_MASK 0x60 /******************************************************************************* * * FUNCTION: AcpiDsCreateField * * PARAMETERS: Op - Op containing the Field definition and args * RegionNode - Object for the containing Operation Region * ` WalkState - Current method state * * RETURN: Status * * DESCRIPTION: Create a new field in the specified operation region * ******************************************************************************/ ACPI_STATUS AcpiDsCreateField ( ACPI_PARSE_OBJECT *Op, ACPI_NAMESPACE_NODE *RegionNode, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_AML_ERROR; ACPI_PARSE_OBJECT *Arg; ACPI_NAMESPACE_NODE *Node; UINT8 FieldFlags; UINT32 FieldBitPosition = 0; FUNCTION_TRACE_PTR ("DsCreateField", Op); /* First arg is the name of the parent OpRegion */ Arg = Op->Value.Arg; if (!RegionNode) { Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Value.Name, ACPI_TYPE_REGION, IMODE_EXECUTE, NS_SEARCH_PARENT, WalkState, &RegionNode); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* Second arg is the field flags */ Arg = Arg->Next; FieldFlags = (UINT8) Arg->Value.Integer; /* Each remaining arg is a Named Field */ Arg = Arg->Next; while (Arg) { switch (Arg->Opcode) { case AML_INT_RESERVEDFIELD_OP: FieldBitPosition += Arg->Value.Size; break; case AML_INT_ACCESSFIELD_OP: /* * Get a new AccessType and AccessAttribute for all * entries (until end or another AccessAs keyword) */ FieldFlags = (UINT8) ((FieldFlags & FIELD_ACCESS_TYPE_MASK) || ((UINT8) (Arg->Value.Integer >> 8))); break; case AML_INT_NAMEDFIELD_OP: Status = AcpiNsLookup (WalkState->ScopeInfo, (NATIVE_CHAR *) &((ACPI_PARSE2_OBJECT *)Arg)->Name, INTERNAL_TYPE_REGION_FIELD, IMODE_LOAD_PASS1, NS_NO_UPSEARCH | NS_DONT_OPEN_SCOPE, NULL, &Node); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Initialize an object for the new Node that is on * the object stack */ Status = AcpiExPrepRegionFieldValue (Node, RegionNode, FieldFlags, FieldBitPosition, Arg->Value.Size); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Keep track of bit position for *next* field */ FieldBitPosition += Arg->Value.Size; break; } Arg = Arg->Next; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiDsCreateBankField * * PARAMETERS: Op - Op containing the Field definition and args * RegionNode - Object for the containing Operation Region * ` WalkState - Current method state * * RETURN: Status * * DESCRIPTION: Create a new bank field in the specified operation region * ******************************************************************************/ ACPI_STATUS AcpiDsCreateBankField ( ACPI_PARSE_OBJECT *Op, ACPI_NAMESPACE_NODE *RegionNode, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_AML_ERROR; ACPI_PARSE_OBJECT *Arg; ACPI_NAMESPACE_NODE *RegisterNode; ACPI_NAMESPACE_NODE *Node; UINT32 BankValue; UINT8 FieldFlags; UINT32 FieldBitPosition = 0; FUNCTION_TRACE_PTR ("DsCreateBankField", Op); /* First arg is the name of the parent OpRegion */ Arg = Op->Value.Arg; if (!RegionNode) { Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Value.Name, ACPI_TYPE_REGION, IMODE_EXECUTE, NS_SEARCH_PARENT, WalkState, &RegionNode); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* Second arg is the Bank Register */ Arg = Arg->Next; Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Value.String, INTERNAL_TYPE_BANK_FIELD_DEFN, IMODE_LOAD_PASS1, NS_NO_UPSEARCH | NS_DONT_OPEN_SCOPE, NULL, &RegisterNode); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Third arg is the BankValue */ Arg = Arg->Next; - BankValue = Arg->Value.Integer; + BankValue = Arg->Value.Integer32; /* Next arg is the field flags */ Arg = Arg->Next; - FieldFlags = (UINT8) Arg->Value.Integer; + FieldFlags = Arg->Value.Integer8; /* Each remaining arg is a Named Field */ Arg = Arg->Next; while (Arg) { switch (Arg->Opcode) { case AML_INT_RESERVEDFIELD_OP: FieldBitPosition += Arg->Value.Size; break; case AML_INT_ACCESSFIELD_OP: /* * Get a new AccessType and AccessAttribute for * all entries (until end or another AccessAs keyword) */ FieldFlags = (UINT8) ((FieldFlags & FIELD_ACCESS_TYPE_MASK) || ((UINT8) (Arg->Value.Integer >> 8))); break; case AML_INT_NAMEDFIELD_OP: Status = AcpiNsLookup (WalkState->ScopeInfo, (NATIVE_CHAR *) &((ACPI_PARSE2_OBJECT *)Arg)->Name, INTERNAL_TYPE_REGION_FIELD, IMODE_LOAD_PASS1, NS_NO_UPSEARCH | NS_DONT_OPEN_SCOPE, NULL, &Node); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Initialize an object for the new Node that is on * the object stack */ Status = AcpiExPrepBankFieldValue (Node, RegionNode, RegisterNode, BankValue, FieldFlags, FieldBitPosition, Arg->Value.Size); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Keep track of bit position for the *next* field */ FieldBitPosition += Arg->Value.Size; break; } Arg = Arg->Next; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiDsCreateIndexField * * PARAMETERS: Op - Op containing the Field definition and args * RegionNode - Object for the containing Operation Region * ` WalkState - Current method state * * RETURN: Status * * DESCRIPTION: Create a new index field in the specified operation region * ******************************************************************************/ ACPI_STATUS AcpiDsCreateIndexField ( ACPI_PARSE_OBJECT *Op, ACPI_NAMESPACE_NODE *RegionNode, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; ACPI_PARSE_OBJECT *Arg; ACPI_NAMESPACE_NODE *Node; ACPI_NAMESPACE_NODE *IndexRegisterNode; ACPI_NAMESPACE_NODE *DataRegisterNode; UINT8 FieldFlags; UINT32 FieldBitPosition = 0; FUNCTION_TRACE_PTR ("DsCreateIndexField", Op); Arg = Op->Value.Arg; /* First arg is the name of the Index register */ Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Value.String, ACPI_TYPE_ANY, IMODE_LOAD_PASS1, NS_NO_UPSEARCH | NS_DONT_OPEN_SCOPE, NULL, &IndexRegisterNode); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Second arg is the data register */ Arg = Arg->Next; Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Value.String, INTERNAL_TYPE_INDEX_FIELD_DEFN, IMODE_LOAD_PASS1, NS_NO_UPSEARCH | NS_DONT_OPEN_SCOPE, NULL, &DataRegisterNode); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Next arg is the field flags */ Arg = Arg->Next; FieldFlags = (UINT8) Arg->Value.Integer; /* Each remaining arg is a Named Field */ Arg = Arg->Next; while (Arg) { switch (Arg->Opcode) { case AML_INT_RESERVEDFIELD_OP: FieldBitPosition += Arg->Value.Size; break; case AML_INT_ACCESSFIELD_OP: /* * Get a new AccessType and AccessAttribute for all * entries (until end or another AccessAs keyword) */ FieldFlags = (UINT8) ((FieldFlags & FIELD_ACCESS_TYPE_MASK) || ((UINT8) (Arg->Value.Integer >> 8))); break; case AML_INT_NAMEDFIELD_OP: Status = AcpiNsLookup (WalkState->ScopeInfo, (NATIVE_CHAR *) &((ACPI_PARSE2_OBJECT *)Arg)->Name, INTERNAL_TYPE_INDEX_FIELD, IMODE_LOAD_PASS1, NS_NO_UPSEARCH | NS_DONT_OPEN_SCOPE, NULL, &Node); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Initialize an object for the new Node that is on * the object stack */ Status = AcpiExPrepIndexFieldValue (Node, IndexRegisterNode, DataRegisterNode, FieldFlags, FieldBitPosition, Arg->Value.Size); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Keep track of bit position for the *next* field */ FieldBitPosition += Arg->Value.Size; break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Invalid opcode in field list: %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Invalid opcode in field list: %X\n", Arg->Opcode)); Status = AE_AML_ERROR; break; } Arg = Arg->Next; } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsmethod.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsmethod.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsmethod.c (revision 82367) @@ -1,644 +1,644 @@ /****************************************************************************** * * Module Name: dsmethod - Parser/Interpreter interface - control method parsing - * $Revision: 63 $ + * $Revision: 64 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __DSMETHOD_C__ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #include "acdispat.h" #include "acinterp.h" #include "acnamesp.h" #include "actables.h" #include "acdebug.h" #define _COMPONENT ACPI_DISPATCHER MODULE_NAME ("dsmethod") /******************************************************************************* * * FUNCTION: AcpiDsParseMethod * * PARAMETERS: ObjHandle - Node of the method * Level - Current nesting level * Context - Points to a method counter * ReturnValue - Not used * * RETURN: Status * * DESCRIPTION: Call the parser and parse the AML that is * associated with the method. * * MUTEX: Assumes parser is locked * ******************************************************************************/ ACPI_STATUS AcpiDsParseMethod ( ACPI_HANDLE ObjHandle) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_PARSE_OBJECT *Op; ACPI_NAMESPACE_NODE *Node; ACPI_OWNER_ID OwnerId; FUNCTION_TRACE_PTR ("DsParseMethod", ObjHandle); /* Parameter Validation */ if (!ObjHandle) { return_ACPI_STATUS (AE_NULL_ENTRY); } - DEBUG_PRINTP (ACPI_INFO, ("**** Parsing [%4.4s] **** NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "**** Parsing [%4.4s] **** NamedObj=%p\n", &((ACPI_NAMESPACE_NODE *)ObjHandle)->Name, ObjHandle)); /* Extract the method object from the method Node */ Node = (ACPI_NAMESPACE_NODE *) ObjHandle; ObjDesc = Node->Object; if (!ObjDesc) { return_ACPI_STATUS (AE_NULL_OBJECT); } /* Create a mutex for the method if there is a concurrency limit */ if ((ObjDesc->Method.Concurrency != INFINITE_CONCURRENCY) && (!ObjDesc->Method.Semaphore)) { Status = AcpiOsCreateSemaphore (ObjDesc->Method.Concurrency, ObjDesc->Method.Concurrency, &ObjDesc->Method.Semaphore); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* * Allocate a new parser op to be the root of the parsed * method tree */ Op = AcpiPsAllocOp (AML_METHOD_OP); if (!Op) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Init new op with the method name and pointer back to the Node */ AcpiPsSetName (Op, Node->Name); Op->Node = Node; /* * Parse the method, first pass * * The first pass load is where newly declared named objects are * added into the namespace. Actual evaluation of * the named objects (what would be called a "second * pass") happens during the actual execution of the * method so that operands to the named objects can * take on dynamic run-time values. */ Status = AcpiPsParseAml (Op, ObjDesc->Method.Pcode, ObjDesc->Method.PcodeLength, ACPI_PARSE_LOAD_PASS1 | ACPI_PARSE_DELETE_TREE, Node, NULL, NULL, AcpiDsLoad1BeginOp, AcpiDsLoad1EndOp); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Get a new OwnerId for objects created by this method */ OwnerId = AcpiUtAllocateOwnerId (OWNER_TYPE_METHOD); ObjDesc->Method.OwningId = OwnerId; - DEBUG_PRINTP (ACPI_INFO, ("**** [%4.4s] Parsed **** NamedObj=%p Op=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "**** [%4.4s] Parsed **** NamedObj=%p Op=%p\n", &((ACPI_NAMESPACE_NODE *)ObjHandle)->Name, ObjHandle, Op)); /* Install the parsed tree in the method object */ /* TBD: [Restructure] Obsolete field? */ AcpiPsDeleteParseTree (Op); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiDsBeginMethodExecution * * PARAMETERS: MethodNode - Node of the method * ObjDesc - The method object * CallingMethodNode - Caller of this method (if non-null) * * RETURN: Status * * DESCRIPTION: Prepare a method for execution. Parses the method if necessary, * increments the thread count, and waits at the method semaphore * for clearance to execute. * * MUTEX: Locks/unlocks parser. * ******************************************************************************/ ACPI_STATUS AcpiDsBeginMethodExecution ( ACPI_NAMESPACE_NODE *MethodNode, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_NAMESPACE_NODE *CallingMethodNode) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE_PTR ("DsBeginMethodExecution", MethodNode); if (!MethodNode) { return_ACPI_STATUS (AE_NULL_ENTRY); } /* * If there is a concurrency limit on this method, we need to * obtain a unit from the method semaphore. */ if (ObjDesc->Method.Semaphore) { /* * Allow recursive method calls, up to the reentrancy/concurrency * limit imposed by the SERIALIZED rule and the SyncLevel method * parameter. * * The point of this code is to avoid permanently blocking a * thread that is making recursive method calls. */ if (MethodNode == CallingMethodNode) { if (ObjDesc->Method.ThreadCount >= ObjDesc->Method.Concurrency) { return_ACPI_STATUS (AE_AML_METHOD_LIMIT); } } /* * Get a unit from the method semaphore. This releases the * interpreter if we block */ Status = AcpiExSystemWaitSemaphore (ObjDesc->Method.Semaphore, WAIT_FOREVER); } /* * Increment the method parse tree thread count since it has been * reentered one more time (even if it is the same thread) */ ObjDesc->Method.ThreadCount++; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiDsCallControlMethod * * PARAMETERS: WalkState - Current state of the walk * Op - Current Op to be walked * * RETURN: Status * * DESCRIPTION: Transfer execution to a called control method * ******************************************************************************/ ACPI_STATUS AcpiDsCallControlMethod ( ACPI_WALK_LIST *WalkList, ACPI_WALK_STATE *ThisWalkState, ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status; ACPI_NAMESPACE_NODE *MethodNode; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_WALK_STATE *NextWalkState; ACPI_PARSE_STATE *ParserState; UINT32 i; FUNCTION_TRACE_PTR ("DsCallControlMethod", ThisWalkState); - DEBUG_PRINTP (TRACE_DISPATCH, ("Execute method %p, currentstate=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Execute method %p, currentstate=%p\n", ThisWalkState->PrevOp, ThisWalkState)); /* * Get the namespace entry for the control method we are about to call */ MethodNode = ThisWalkState->MethodCallNode; if (!MethodNode) { return_ACPI_STATUS (AE_NULL_ENTRY); } ObjDesc = AcpiNsGetAttachedObject (MethodNode); if (!ObjDesc) { return_ACPI_STATUS (AE_NULL_OBJECT); } /* Init for new method, wait on concurrency semaphore */ Status = AcpiDsBeginMethodExecution (MethodNode, ObjDesc, ThisWalkState->MethodNode); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Create and initialize a new parser state */ ParserState = AcpiPsCreateState (ObjDesc->Method.Pcode, ObjDesc->Method.PcodeLength); if (!ParserState) { return_ACPI_STATUS (AE_NO_MEMORY); } AcpiPsInitScope (ParserState, NULL); ParserState->StartNode = MethodNode; /* Create a new state for the preempting walk */ NextWalkState = AcpiDsCreateWalkState (ObjDesc->Method.OwningId, NULL, ObjDesc, WalkList); if (!NextWalkState) { /* TBD: delete parser state */ return_ACPI_STATUS (AE_NO_MEMORY); } NextWalkState->WalkType = WALK_METHOD; NextWalkState->MethodNode = MethodNode; NextWalkState->ParserState = ParserState; NextWalkState->ParseFlags = ThisWalkState->ParseFlags; NextWalkState->DescendingCallback = ThisWalkState->DescendingCallback; NextWalkState->AscendingCallback = ThisWalkState->AscendingCallback; /* The NextOp of the NextWalk will be the beginning of the method */ /* TBD: [Restructure] -- obsolete? */ NextWalkState->NextOp = NULL; /* Open a new scope */ Status = AcpiDsScopeStackPush (MethodNode, ACPI_TYPE_METHOD, NextWalkState); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* * Initialize the arguments for the method. The resolved * arguments were put on the previous walk state's operand * stack. Operands on the previous walk state stack always * start at index 0. */ Status = AcpiDsMethodDataInitArgs (&ThisWalkState->Operands[0], ThisWalkState->NumOperands, NextWalkState); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* Create and init a Root Node */ Op = AcpiPsAllocOp (AML_SCOPE_OP); if (!Op) { return_ACPI_STATUS (AE_NO_MEMORY); } Status = AcpiPsParseAml (Op, ObjDesc->Method.Pcode, ObjDesc->Method.PcodeLength, ACPI_PARSE_LOAD_PASS1 | ACPI_PARSE_DELETE_TREE, MethodNode, NULL, NULL, AcpiDsLoad1BeginOp, AcpiDsLoad1EndOp); AcpiPsDeleteParseTree (Op); /* * Delete the operands on the previous walkstate operand stack * (they were copied to new objects) */ for (i = 0; i < ObjDesc->Method.ParamCount; i++) { AcpiUtRemoveReference (ThisWalkState->Operands [i]); ThisWalkState->Operands [i] = NULL; } /* Clear the operand stack */ ThisWalkState->NumOperands = 0; - DEBUG_PRINTP (TRACE_DISPATCH, ("Starting nested execution, newstate=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Starting nested execution, newstate=%p\n", NextWalkState)); return_ACPI_STATUS (AE_OK); /* On error, we must delete the new walk state */ Cleanup: AcpiDsTerminateControlMethod (NextWalkState); AcpiDsDeleteWalkState (NextWalkState); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiDsRestartControlMethod * * PARAMETERS: WalkState - State of the method when it was preempted * Op - Pointer to new current op * * RETURN: Status * * DESCRIPTION: Restart a method that was preempted * ******************************************************************************/ ACPI_STATUS AcpiDsRestartControlMethod ( ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT *ReturnDesc) { ACPI_STATUS Status; FUNCTION_TRACE_PTR ("DsRestartControlMethod", WalkState); if (ReturnDesc) { if (WalkState->ReturnUsed) { /* * Get the return value (if any) from the previous method. * NULL if no return value */ Status = AcpiDsResultPush (ReturnDesc, WalkState); if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ReturnDesc); return_ACPI_STATUS (Status); } } else { /* * Delete the return value if it will not be used by the * calling method */ AcpiUtRemoveReference (ReturnDesc); } } - DEBUG_PRINTP (TRACE_DISPATCH, - ("Method=%p Return=%p ReturnUsed?=%X ResStack=%p State=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "Method=%p Return=%p ReturnUsed?=%X ResStack=%p State=%p\n", WalkState->MethodCallOp, ReturnDesc, WalkState->ReturnUsed, WalkState->Results, WalkState)); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsTerminateControlMethod * * PARAMETERS: WalkState - State of the method * * RETURN: Status * * DESCRIPTION: Terminate a control method. Delete everything that the method * created, delete all locals and arguments, and delete the parse * tree if requested. * ******************************************************************************/ ACPI_STATUS AcpiDsTerminateControlMethod ( ACPI_WALK_STATE *WalkState) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_NAMESPACE_NODE *MethodNode; FUNCTION_TRACE_PTR ("DsTerminateControlMethod", WalkState); /* The method object should be stored in the walk state */ ObjDesc = WalkState->MethodDesc; if (!ObjDesc) { return_ACPI_STATUS (AE_OK); } /* Delete all arguments and locals */ AcpiDsMethodDataDeleteAll (WalkState); /* * Lock the parser while we terminate this method. * If this is the last thread executing the method, * we have additional cleanup to perform */ AcpiUtAcquireMutex (ACPI_MTX_PARSER); /* Signal completion of the execution of this method if necessary */ if (WalkState->MethodDesc->Method.Semaphore) { AcpiOsSignalSemaphore ( WalkState->MethodDesc->Method.Semaphore, 1); } /* Decrement the thread count on the method parse tree */ WalkState->MethodDesc->Method.ThreadCount--; if (!WalkState->MethodDesc->Method.ThreadCount) { /* * There are no more threads executing this method. Perform * additional cleanup. * * The method Node is stored in the walk state */ MethodNode = WalkState->MethodNode; /* * Delete any namespace entries created immediately underneath * the method */ AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); if (MethodNode->Child) { AcpiNsDeleteNamespaceSubtree (MethodNode); } /* * Delete any namespace entries created anywhere else within * the namespace */ AcpiNsDeleteNamespaceByOwner (WalkState->MethodDesc->Method.OwningId); AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); } AcpiUtReleaseMutex (ACPI_MTX_PARSER); return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsmthdat.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsmthdat.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsmthdat.c (revision 82367) @@ -1,879 +1,879 @@ /******************************************************************************* * * Module Name: dsmthdat - control method arguments and local variables - * $Revision: 47 $ + * $Revision: 48 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __DSMTHDAT_C__ #include "acpi.h" #include "acparser.h" #include "acdispat.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #define _COMPONENT ACPI_DISPATCHER MODULE_NAME ("dsmthdat") /******************************************************************************* * * FUNCTION: AcpiDsMethodDataInit * * PARAMETERS: WalkState - Current walk state object * * RETURN: Status * * DESCRIPTION: Initialize the data structures that hold the method's arguments * and locals. The data struct is an array of NTEs for each. * This allows RefOf and DeRefOf to work properly for these * special data types. * ******************************************************************************/ ACPI_STATUS AcpiDsMethodDataInit ( ACPI_WALK_STATE *WalkState) { UINT32 i; FUNCTION_TRACE ("DsMethodDataInit"); /* * WalkState fields are initialized to zero by the * ACPI_MEM_CALLOCATE(). * * An Node is assigned to each argument and local so * that RefOf() can return a pointer to the Node. */ /* Init the method arguments */ for (i = 0; i < MTH_NUM_ARGS; i++) { MOVE_UNALIGNED32_TO_32 (&WalkState->Arguments[i].Name, NAMEOF_ARG_NTE); WalkState->Arguments[i].Name |= (i << 24); WalkState->Arguments[i].DataType = ACPI_DESC_TYPE_NAMED; WalkState->Arguments[i].Type = ACPI_TYPE_ANY; WalkState->Arguments[i].Flags = ANOBJ_END_OF_PEER_LIST | ANOBJ_METHOD_ARG; } /* Init the method locals */ for (i = 0; i < MTH_NUM_LOCALS; i++) { MOVE_UNALIGNED32_TO_32 (&WalkState->LocalVariables[i].Name, NAMEOF_LOCAL_NTE); WalkState->LocalVariables[i].Name |= (i << 24); WalkState->LocalVariables[i].DataType = ACPI_DESC_TYPE_NAMED; WalkState->LocalVariables[i].Type = ACPI_TYPE_ANY; WalkState->LocalVariables[i].Flags = ANOBJ_END_OF_PEER_LIST | ANOBJ_METHOD_LOCAL; } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsMethodDataDeleteAll * * PARAMETERS: WalkState - Current walk state object * * RETURN: Status * * DESCRIPTION: Delete method locals and arguments. Arguments are only * deleted if this method was called from another method. * ******************************************************************************/ ACPI_STATUS AcpiDsMethodDataDeleteAll ( ACPI_WALK_STATE *WalkState) { UINT32 Index; ACPI_OPERAND_OBJECT *Object; FUNCTION_TRACE ("DsMethodDataDeleteAll"); /* Delete the locals */ - DEBUG_PRINTP (ACPI_INFO, ("Deleting local variables in %p\n", WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Deleting local variables in %p\n", WalkState)); for (Index = 0; Index < MTH_NUM_LOCALS; Index++) { Object = WalkState->LocalVariables[Index].Object; if (Object) { - DEBUG_PRINTP (TRACE_EXEC, ("Deleting Local%d=%p\n", Index, Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Deleting Local%d=%p\n", Index, Object)); /* Remove first */ WalkState->LocalVariables[Index].Object = NULL; /* Was given a ref when stored */ AcpiUtRemoveReference (Object); } } /* Delete the arguments */ - DEBUG_PRINTP (ACPI_INFO, ("Deleting arguments in %p\n", WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Deleting arguments in %p\n", WalkState)); for (Index = 0; Index < MTH_NUM_ARGS; Index++) { Object = WalkState->Arguments[Index].Object; if (Object) { - DEBUG_PRINTP (TRACE_EXEC, ("Deleting Arg%d=%p\n", Index, Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Deleting Arg%d=%p\n", Index, Object)); /* Remove first */ WalkState->Arguments[Index].Object = NULL; /* Was given a ref when stored */ AcpiUtRemoveReference (Object); } } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsMethodDataInitArgs * * PARAMETERS: *Params - Pointer to a parameter list for the method * MaxParamCount - The arg count for this method * WalkState - Current walk state object * * RETURN: Status * * DESCRIPTION: Initialize arguments for a method * ******************************************************************************/ ACPI_STATUS AcpiDsMethodDataInitArgs ( ACPI_OPERAND_OBJECT **Params, UINT32 MaxParamCount, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; UINT32 Mindex; UINT32 Pindex; FUNCTION_TRACE_PTR ("DsMethodDataInitArgs", Params); if (!Params) { - DEBUG_PRINTP (TRACE_EXEC, ("No param list passed to method\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "No param list passed to method\n")); return_ACPI_STATUS (AE_OK); } /* Copy passed parameters into the new method stack frame */ for (Pindex = Mindex = 0; (Mindex < MTH_NUM_ARGS) && (Pindex < MaxParamCount); Mindex++) { if (Params[Pindex]) { /* * A valid parameter. * Set the current method argument to the * Params[Pindex++] argument object descriptor */ Status = AcpiDsStoreObjectToLocal (AML_ARG_OP, Mindex, Params[Pindex], WalkState); if (ACPI_FAILURE (Status)) { break; } Pindex++; } else { break; } } - DEBUG_PRINTP (TRACE_EXEC, ("%d args passed to method\n", Pindex)); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%d args passed to method\n", Pindex)); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsMethodDataGetEntry * * PARAMETERS: Opcode - Either AML_LOCAL_OP or AML_ARG_OP * Index - Which localVar or argument to get * Entry - Pointer to where a pointer to the stack * entry is returned. * WalkState - Current walk state object * * RETURN: Status * * DESCRIPTION: Get the address of the object entry given by Opcode:Index * ******************************************************************************/ ACPI_STATUS AcpiDsMethodDataGetEntry ( UINT16 Opcode, UINT32 Index, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT ***Entry) { FUNCTION_TRACE_U32 ("DsMethodDataGetEntry", Index); /* * Get the requested object. * The stack "Opcode" is either a LocalVariable or an Argument */ switch (Opcode) { case AML_LOCAL_OP: if (Index > MTH_MAX_LOCAL) { - DEBUG_PRINTP (ACPI_ERROR, ("LocalVar index %d is invalid (max %d)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "LocalVar index %d is invalid (max %d)\n", Index, MTH_MAX_LOCAL)); return_ACPI_STATUS (AE_BAD_PARAMETER); } *Entry = (ACPI_OPERAND_OBJECT **) &WalkState->LocalVariables[Index].Object; break; case AML_ARG_OP: if (Index > MTH_MAX_ARG) { - DEBUG_PRINTP (ACPI_ERROR, ("Arg index %d is invalid (max %d)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Arg index %d is invalid (max %d)\n", Index, MTH_MAX_ARG)); return_ACPI_STATUS (AE_BAD_PARAMETER); } *Entry = (ACPI_OPERAND_OBJECT **) &WalkState->Arguments[Index].Object; break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Opcode %d is invalid\n", Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Opcode %d is invalid\n", Opcode)); return_ACPI_STATUS (AE_BAD_PARAMETER); } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsMethodDataSetEntry * * PARAMETERS: Opcode - Either AML_LOCAL_OP or AML_ARG_OP * Index - Which localVar or argument to get * Object - Object to be inserted into the stack entry * WalkState - Current walk state object * * RETURN: Status * * DESCRIPTION: Insert an object onto the method stack at entry Opcode:Index. * ******************************************************************************/ ACPI_STATUS AcpiDsMethodDataSetEntry ( UINT16 Opcode, UINT32 Index, ACPI_OPERAND_OBJECT *Object, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT **Entry; FUNCTION_TRACE ("DsMethodDataSetEntry"); /* Get a pointer to the stack entry to set */ Status = AcpiDsMethodDataGetEntry (Opcode, Index, WalkState, &Entry); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Increment ref count so object can't be deleted while installed */ AcpiUtAddReference (Object); /* Install the object into the stack entry */ *Entry = Object; return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsMethodDataGetType * * PARAMETERS: Opcode - Either AML_LOCAL_OP or AML_ARG_OP * Index - Which localVar or argument whose type * to get * WalkState - Current walk state object * * RETURN: Data type of selected Arg or Local * Used only in ExecMonadic2()/TypeOp. * ******************************************************************************/ ACPI_OBJECT_TYPE8 AcpiDsMethodDataGetType ( UINT16 Opcode, UINT32 Index, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT **Entry; ACPI_OPERAND_OBJECT *Object; FUNCTION_TRACE ("DsMethodDataGetType"); /* Get a pointer to the requested stack entry */ Status = AcpiDsMethodDataGetEntry (Opcode, Index, WalkState, &Entry); if (ACPI_FAILURE (Status)) { return_VALUE ((ACPI_TYPE_NOT_FOUND)); } /* Get the object from the method stack */ Object = *Entry; /* Get the object type */ if (!Object) { /* Any == 0 => "uninitialized" -- see spec 15.2.3.5.2.28 */ return_VALUE (ACPI_TYPE_ANY); } return_VALUE (Object->Common.Type); } /******************************************************************************* * * FUNCTION: AcpiDsMethodDataGetNode * * PARAMETERS: Opcode - Either AML_LOCAL_OP or AML_ARG_OP * Index - Which localVar or argument whose type * to get * WalkState - Current walk state object * * RETURN: Get the Node associated with a local or arg. * ******************************************************************************/ ACPI_NAMESPACE_NODE * AcpiDsMethodDataGetNode ( UINT16 Opcode, UINT32 Index, ACPI_WALK_STATE *WalkState) { ACPI_NAMESPACE_NODE *Node = NULL; FUNCTION_TRACE ("DsMethodDataGetNode"); switch (Opcode) { case AML_LOCAL_OP: if (Index > MTH_MAX_LOCAL) { - DEBUG_PRINTP (ACPI_ERROR, ("Local index %d is invalid (max %d)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Local index %d is invalid (max %d)\n", Index, MTH_MAX_LOCAL)); return_PTR (Node); } Node = &WalkState->LocalVariables[Index]; break; case AML_ARG_OP: if (Index > MTH_MAX_ARG) { - DEBUG_PRINTP (ACPI_ERROR, ("Arg index %d is invalid (max %d)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Arg index %d is invalid (max %d)\n", Index, MTH_MAX_ARG)); return_PTR (Node); } Node = &WalkState->Arguments[Index]; break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Opcode %d is invalid\n", Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Opcode %d is invalid\n", Opcode)); break; } return_PTR (Node); } /******************************************************************************* * * FUNCTION: AcpiDsMethodDataGetValue * * PARAMETERS: Opcode - Either AML_LOCAL_OP or AML_ARG_OP * Index - Which localVar or argument to get * WalkState - Current walk state object * *DestDesc - Ptr to Descriptor into which selected Arg * or Local value should be copied * * RETURN: Status * * DESCRIPTION: Retrieve value of selected Arg or Local from the method frame * at the current top of the method stack. * Used only in AcpiExResolveToValue(). * ******************************************************************************/ ACPI_STATUS AcpiDsMethodDataGetValue ( UINT16 Opcode, UINT32 Index, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **DestDesc) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT **Entry; ACPI_OPERAND_OBJECT *Object; FUNCTION_TRACE ("DsMethodDataGetValue"); /* Validate the object descriptor */ if (!DestDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("Null object descriptor pointer\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null object descriptor pointer\n")); return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Get a pointer to the requested method stack entry */ Status = AcpiDsMethodDataGetEntry (Opcode, Index, WalkState, &Entry); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Get the object from the method stack */ Object = *Entry; /* Examine the returned object, it must be valid. */ if (!Object) { /* * Index points to uninitialized object stack value. * This means that either 1) The expected argument was * not passed to the method, or 2) A local variable * was referenced by the method (via the ASL) * before it was initialized. Either case is an error. */ switch (Opcode) { case AML_ARG_OP: - DEBUG_PRINTP (ACPI_ERROR, ("Uninitialized Arg[%d] at entry %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Uninitialized Arg[%d] at entry %p\n", Index, Entry)); return_ACPI_STATUS (AE_AML_UNINITIALIZED_ARG); break; case AML_LOCAL_OP: - DEBUG_PRINTP (ACPI_ERROR, ("Uninitialized Local[%d] at entry %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Uninitialized Local[%d] at entry %p\n", Index, Entry)); return_ACPI_STATUS (AE_AML_UNINITIALIZED_LOCAL); break; } } /* * Index points to initialized and valid object stack value. * Return an additional reference to the object */ *DestDesc = Object; AcpiUtAddReference (Object); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsMethodDataDeleteValue * * PARAMETERS: Opcode - Either AML_LOCAL_OP or AML_ARG_OP * Index - Which localVar or argument to delete * WalkState - Current walk state object * * RETURN: Status * * DESCRIPTION: Delete the entry at Opcode:Index on the method stack. Inserts * a null into the stack slot after the object is deleted. * ******************************************************************************/ ACPI_STATUS AcpiDsMethodDataDeleteValue ( UINT16 Opcode, UINT32 Index, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT **Entry; ACPI_OPERAND_OBJECT *Object; FUNCTION_TRACE ("DsMethodDataDeleteValue"); /* Get a pointer to the requested entry */ Status = AcpiDsMethodDataGetEntry (Opcode, Index, WalkState, &Entry); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Get the current entry in this slot k */ Object = *Entry; /* * Undefine the Arg or Local by setting its descriptor * pointer to NULL. Locals/Args can contain both * ACPI_OPERAND_OBJECTS and ACPI_NAMESPACE_NODEs */ *Entry = NULL; if ((Object) && (VALID_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_INTERNAL))) { /* * There is a valid object in this slot * Decrement the reference count by one to balance the * increment when the object was stored in the slot. */ AcpiUtRemoveReference (Object); } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsStoreObjectToLocal * * PARAMETERS: Opcode - Either AML_LOCAL_OP or AML_ARG_OP * Index - Which localVar or argument to set * SrcDesc - Value to be stored * WalkState - Current walk state * * RETURN: Status * * DESCRIPTION: Store a value in an Arg or Local. The SrcDesc is installed * as the new value for the Arg or Local and the reference count * for SrcDesc is incremented. * ******************************************************************************/ ACPI_STATUS AcpiDsStoreObjectToLocal ( UINT16 Opcode, UINT32 Index, ACPI_OPERAND_OBJECT *SrcDesc, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT **Entry; FUNCTION_TRACE ("DsMethodDataSetValue"); - DEBUG_PRINTP (TRACE_EXEC, ("Opcode=%d Idx=%d Obj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Opcode=%d Idx=%d Obj=%p\n", Opcode, Index, SrcDesc)); /* Parameter validation */ if (!SrcDesc) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Get a pointer to the requested method stack entry */ Status = AcpiDsMethodDataGetEntry (Opcode, Index, WalkState, &Entry); if (ACPI_FAILURE (Status)) { goto Cleanup; } if (*Entry == SrcDesc) { - DEBUG_PRINTP (TRACE_EXEC, ("Obj=%p already installed!\n", SrcDesc)); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p already installed!\n", SrcDesc)); goto Cleanup; } /* * If there is an object already in this slot, we either * have to delete it, or if this is an argument and there * is an object reference stored there, we have to do * an indirect store! */ if (*Entry) { /* * Check for an indirect store if an argument * contains an object reference (stored as an Node). * We don't allow this automatic dereferencing for * locals, since a store to a local should overwrite * anything there, including an object reference. * * If both Arg0 and Local0 contain RefOf (Local4): * * Store (1, Arg0) - Causes indirect store to local4 * Store (1, Local0) - Stores 1 in local0, overwriting * the reference to local4 * Store (1, DeRefof (Local0)) - Causes indirect store to local4 * * Weird, but true. */ if ((Opcode == AML_ARG_OP) && (VALID_DESCRIPTOR_TYPE (*Entry, ACPI_DESC_TYPE_NAMED))) { - DEBUG_PRINTP (TRACE_EXEC, - ("Arg (%p) is an ObjRef(Node), storing in %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, + "Arg (%p) is an ObjRef(Node), storing in %p\n", SrcDesc, *Entry)); /* Detach an existing object from the Node */ AcpiNsDetachObject ((ACPI_NAMESPACE_NODE *) *Entry); /* * Store this object into the Node * (do the indirect store) */ Status = AcpiNsAttachObject ((ACPI_NAMESPACE_NODE *) *Entry, SrcDesc, SrcDesc->Common.Type); return_ACPI_STATUS (Status); } #ifdef ACPI_ENABLE_IMPLICIT_CONVERSION /* * Perform "Implicit conversion" of the new object to the type of the * existing object */ Status = AcpiExConvertToTargetType ((*Entry)->Common.Type, &SrcDesc, WalkState); if (ACPI_FAILURE (Status)) { goto Cleanup; } #endif /* * Delete the existing object * before storing the new one */ AcpiDsMethodDataDeleteValue (Opcode, Index, WalkState); } /* * Install the ObjStack descriptor (*SrcDesc) into * the descriptor for the Arg or Local. * Install the new object in the stack entry * (increments the object reference count by one) */ Status = AcpiDsMethodDataSetEntry (Opcode, Index, SrcDesc, WalkState); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* Normal exit */ return_ACPI_STATUS (AE_OK); /* Error exit */ Cleanup: return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsobject.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsobject.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsobject.c (revision 82367) @@ -1,808 +1,874 @@ /****************************************************************************** * * Module Name: dsobject - Dispatcher object management routines - * $Revision: 67 $ + * $Revision: 71 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __DSOBJECT_C__ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #include "acdispat.h" #include "acinterp.h" #include "acnamesp.h" #define _COMPONENT ACPI_DISPATCHER MODULE_NAME ("dsobject") /******************************************************************************* * * FUNCTION: AcpiDsInitOneObject * * PARAMETERS: ObjHandle - Node * Level - Current nesting level * Context - Points to a init info struct * ReturnValue - Not used * * RETURN: Status * * DESCRIPTION: Callback from AcpiWalkNamespace. Invoked for every object * within the namespace. * * Currently, the only objects that require initialization are: * 1) Methods * 2) Op Regions * ******************************************************************************/ ACPI_STATUS AcpiDsInitOneObject ( ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue) { ACPI_OBJECT_TYPE8 Type; ACPI_STATUS Status; ACPI_INIT_WALK_INFO *Info = (ACPI_INIT_WALK_INFO *) Context; UINT8 TableRevision; PROC_NAME ("DsInitOneObject"); Info->ObjectCount++; TableRevision = Info->TableDesc->Pointer->Revision; /* * We are only interested in objects owned by the table that * was just loaded */ if (((ACPI_NAMESPACE_NODE *) ObjHandle)->OwnerId != Info->TableDesc->TableId) { return (AE_OK); } /* And even then, we are only interested in a few object types */ Type = AcpiNsGetType (ObjHandle); switch (Type) { case ACPI_TYPE_REGION: AcpiDsInitializeRegion (ObjHandle); Info->OpRegionCount++; break; case ACPI_TYPE_METHOD: Info->MethodCount++; - if (!(AcpiDbgLevel & TRACE_INIT)) + if (!(AcpiDbgLevel & ACPI_LV_INIT)) { - DEBUG_PRINT_RAW (ACPI_OK, (".")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, ".")); } /* * Set the execution data width (32 or 64) based upon the * revision number of the parent ACPI table. */ if (TableRevision == 1) { ((ACPI_NAMESPACE_NODE *)ObjHandle)->Flags |= ANOBJ_DATA_WIDTH_32; } /* * Always parse methods to detect errors, we may delete * the parse tree below */ Status = AcpiDsParseMethod (ObjHandle); /* TBD: [Errors] what do we do with an error? */ if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("Method %p [%4.4s] parse failed! %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Method %p [%4.4s] parse failed! %s\n", ObjHandle, &((ACPI_NAMESPACE_NODE *)ObjHandle)->Name, AcpiFormatException (Status))); break; } /* * Delete the parse tree. We simple re-parse the method * for every execution since there isn't much overhead */ AcpiNsDeleteNamespaceSubtree (ObjHandle); break; default: break; } /* * We ignore errors from above, and always return OK, since * we don't want to abort the walk on a single error. */ return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsInitializeObjects * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Walk the entire namespace and perform any necessary * initialization on the objects found therein * ******************************************************************************/ ACPI_STATUS AcpiDsInitializeObjects ( ACPI_TABLE_DESC *TableDesc, ACPI_NAMESPACE_NODE *StartNode) { ACPI_STATUS Status; ACPI_INIT_WALK_INFO Info; FUNCTION_TRACE ("DsInitializeObjects"); - DEBUG_PRINTP (TRACE_DISPATCH, - ("**** Starting initialization of namespace objects ****\n")); - DEBUG_PRINT_RAW (ACPI_OK, ("Parsing Methods:")); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "**** Starting initialization of namespace objects ****\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, "Parsing Methods:")); Info.MethodCount = 0; Info.OpRegionCount = 0; Info.ObjectCount = 0; Info.TableDesc = TableDesc; /* Walk entire namespace from the supplied root */ Status = AcpiWalkNamespace (ACPI_TYPE_ANY, StartNode, ACPI_UINT32_MAX, AcpiDsInitOneObject, &Info, NULL); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("WalkNamespace failed! %x\n", Status)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "WalkNamespace failed! %x\n", Status)); } - DEBUG_PRINT_RAW (ACPI_OK, - ("\n%d Control Methods found and parsed (%d nodes total)\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, + "\n%d Control Methods found and parsed (%d nodes total)\n", Info.MethodCount, Info.ObjectCount)); - DEBUG_PRINTP (TRACE_DISPATCH, - ("%d Control Methods found\n", Info.MethodCount)); - DEBUG_PRINTP (TRACE_DISPATCH, - ("%d Op Regions found\n", Info.OpRegionCount)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "%d Control Methods found\n", Info.MethodCount)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "%d Op Regions found\n", Info.OpRegionCount)); return_ACPI_STATUS (AE_OK); } /***************************************************************************** * * FUNCTION: AcpiDsInitObjectFromOp * * PARAMETERS: Op - Parser op used to init the internal object * Opcode - AML opcode associated with the object * ObjDesc - Namespace object to be initialized * * RETURN: Status * * DESCRIPTION: Initialize a namespace object from a parser Op and its * associated arguments. The namespace object is a more compact * representation of the Op and its arguments. * ****************************************************************************/ ACPI_STATUS AcpiDsInitObjectFromOp ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, UINT16 Opcode, - ACPI_OPERAND_OBJECT **ObjDesc) + ACPI_OPERAND_OBJECT **RetObjDesc) { ACPI_STATUS Status; ACPI_PARSE_OBJECT *Arg; ACPI_PARSE2_OBJECT *ByteList; ACPI_OPERAND_OBJECT *ArgDesc; ACPI_OPCODE_INFO *OpInfo; + ACPI_OPERAND_OBJECT *ObjDesc; PROC_NAME ("DsInitObjectFromOp"); + ObjDesc = *RetObjDesc; OpInfo = AcpiPsGetOpcodeInfo (Opcode); if (ACPI_GET_OP_TYPE (OpInfo) != ACPI_OP_TYPE_OPCODE) { /* Unknown opcode */ return (AE_TYPE); } /* Get and prepare the first argument */ - switch ((*ObjDesc)->Common.Type) + switch (ObjDesc->Common.Type) { case ACPI_TYPE_BUFFER: /* First arg is a number */ AcpiDsCreateOperand (WalkState, Op->Value.Arg, 0); ArgDesc = WalkState->Operands [WalkState->NumOperands - 1]; AcpiDsObjStackPop (1, WalkState); /* Resolve the object (could be an arg or local) */ Status = AcpiExResolveToValue (&ArgDesc, WalkState); if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ArgDesc); return (Status); } /* We are expecting a number */ if (ArgDesc->Common.Type != ACPI_TYPE_INTEGER) { - DEBUG_PRINTP (ACPI_ERROR, - ("Expecting number, got obj: %p type %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Expecting number, got obj: %p type %X\n", ArgDesc, ArgDesc->Common.Type)); AcpiUtRemoveReference (ArgDesc); return (AE_TYPE); } /* Get the value, delete the internal object */ - (*ObjDesc)->Buffer.Length = (UINT32) ArgDesc->Integer.Value; + ObjDesc->Buffer.Length = (UINT32) ArgDesc->Integer.Value; AcpiUtRemoveReference (ArgDesc); /* Allocate the buffer */ - if ((*ObjDesc)->Buffer.Length == 0) + if (ObjDesc->Buffer.Length == 0) { - (*ObjDesc)->Buffer.Pointer = NULL; + ObjDesc->Buffer.Pointer = NULL; REPORT_WARNING (("Buffer created with zero length in AML\n")); break; } else { - (*ObjDesc)->Buffer.Pointer = ACPI_MEM_CALLOCATE ( - (*ObjDesc)->Buffer.Length); + ObjDesc->Buffer.Pointer = ACPI_MEM_CALLOCATE ( + ObjDesc->Buffer.Length); - if (!(*ObjDesc)->Buffer.Pointer) + if (!ObjDesc->Buffer.Pointer) { return (AE_NO_MEMORY); } } /* - * Second arg is the buffer data (optional) - * ByteList can be either individual bytes or a - * string initializer! + * Second arg is the buffer data (optional) ByteList can be either + * individual bytes or a string initializer. */ - /* skip first arg */ - Arg = Op->Value.Arg; + Arg = Op->Value.Arg; /* skip first arg */ + ByteList = (ACPI_PARSE2_OBJECT *) Arg->Next; if (ByteList) { if (ByteList->Opcode != AML_INT_BYTELIST_OP) { - DEBUG_PRINTP (ACPI_ERROR, ("Expecting bytelist, got: %x\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Expecting bytelist, got: %x\n", ByteList)); return (AE_TYPE); } - MEMCPY ((*ObjDesc)->Buffer.Pointer, ByteList->Data, - (*ObjDesc)->Buffer.Length); + MEMCPY (ObjDesc->Buffer.Pointer, ByteList->Data, + ObjDesc->Buffer.Length); } break; case ACPI_TYPE_PACKAGE: /* - * When called, an internal package object has already - * been built and is pointed to by *ObjDesc. - * AcpiDsBuildInternalObject build another internal - * package object, so remove reference to the original - * so that it is deleted. Error checking is done - * within the remove reference function. + * When called, an internal package object has already been built and + * is pointed to by ObjDesc. AcpiDsBuildInternalObject builds another + * internal package object, so remove reference to the original so + * that it is deleted. Error checking is done within the remove + * reference function. */ - AcpiUtRemoveReference(*ObjDesc); - - Status = AcpiDsBuildInternalObject (WalkState, Op, ObjDesc); + AcpiUtRemoveReference (ObjDesc); + Status = AcpiDsBuildInternalObject (WalkState, Op, RetObjDesc); break; case ACPI_TYPE_INTEGER: - (*ObjDesc)->Integer.Value = Op->Value.Integer; + ObjDesc->Integer.Value = Op->Value.Integer; break; case ACPI_TYPE_STRING: - (*ObjDesc)->String.Pointer = Op->Value.String; - (*ObjDesc)->String.Length = STRLEN (Op->Value.String); + ObjDesc->String.Pointer = Op->Value.String; + ObjDesc->String.Length = STRLEN (Op->Value.String); break; case ACPI_TYPE_METHOD: break; case INTERNAL_TYPE_REFERENCE: switch (ACPI_GET_OP_CLASS (OpInfo)) { case OPTYPE_LOCAL_VARIABLE: /* Split the opcode into a base opcode + offset */ - (*ObjDesc)->Reference.Opcode = AML_LOCAL_OP; - (*ObjDesc)->Reference.Offset = Opcode - AML_LOCAL_OP; + ObjDesc->Reference.Opcode = AML_LOCAL_OP; + ObjDesc->Reference.Offset = Opcode - AML_LOCAL_OP; break; + case OPTYPE_METHOD_ARGUMENT: /* Split the opcode into a base opcode + offset */ - (*ObjDesc)->Reference.Opcode = AML_ARG_OP; - (*ObjDesc)->Reference.Offset = Opcode - AML_ARG_OP; + ObjDesc->Reference.Opcode = AML_ARG_OP; + ObjDesc->Reference.Offset = Opcode - AML_ARG_OP; break; + +#ifdef INTEGER_CONST__ + case OPTYPE_CONSTANT: + + /* TBD: Why is the DEBUG object a CONSTANT? */ + + if (Op->Opcode == AML_DEBUG_OP) + { + break; + } + + /* Reference object no longer needed */ + + AcpiUtRemoveReference (ObjDesc); + + /* Create/Init a new Integer object */ + + ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); + if (!ObjDesc) + { + return_ACPI_STATUS (AE_NO_MEMORY); + } + + /* + * Decode constants here. Turn them into real integer objects + * that are initialized to the value of the constant. + */ + switch (Op->Opcode) + { + case AML_ONE_OP: + ObjDesc->Integer.Value = 1; + break; + + case AML_ONES_OP: + ObjDesc->Integer.Value = ACPI_INTEGER_MAX; + break; + + case AML_REVISION_OP: + ObjDesc->Integer.Value = ACPI_CA_VERSION; + break; + + case AML_ZERO_OP: + ObjDesc->Integer.Flags |= AOPOBJ_ZERO_CONST; + ObjDesc->Integer.Value = 0; + break; + + default: + ObjDesc->Integer.Value = 0; + break; + } + + *RetObjDesc = ObjDesc; + break; +#endif + default: /* Constants, Literals, etc.. */ if (Op->Opcode == AML_INT_NAMEPATH_OP) { /* Node was saved in Op */ - (*ObjDesc)->Reference.Node = Op->Node; + ObjDesc->Reference.Node = Op->Node; } - (*ObjDesc)->Reference.Opcode = Opcode; + ObjDesc->Reference.Opcode = Opcode; break; } break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Unimplemented data type: %x\n", - (*ObjDesc)->Common.Type)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unimplemented data type: %x\n", + ObjDesc->Common.Type)); break; } return (AE_OK); } /***************************************************************************** * * FUNCTION: AcpiDsBuildInternalSimpleObj * * PARAMETERS: Op - Parser object to be translated * ObjDescPtr - Where the ACPI internal object is returned * * RETURN: Status * * DESCRIPTION: Translate a parser Op object to the equivalent namespace object * Simple objects are any objects other than a package object! * ****************************************************************************/ static ACPI_STATUS AcpiDsBuildInternalSimpleObj ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_OPERAND_OBJECT **ObjDescPtr) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OBJECT_TYPE8 Type; ACPI_STATUS Status; UINT32 Length; char *Name; FUNCTION_TRACE ("DsBuildInternalSimpleObj"); if (Op->Opcode == AML_INT_NAMEPATH_OP) { /* * This is an object reference. If The name was * previously looked up in the NS, it is stored in this op. * Otherwise, go ahead and look it up now */ - if (!Op->Node) { Status = AcpiNsLookup (WalkState->ScopeInfo, Op->Value.String, ACPI_TYPE_ANY, IMODE_EXECUTE, NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE, NULL, (ACPI_NAMESPACE_NODE **)&(Op->Node)); if (ACPI_FAILURE (Status)) { if (Status == AE_NOT_FOUND) { Name = NULL; AcpiNsExternalizeName (ACPI_UINT32_MAX, Op->Value.String, &Length, &Name); if (Name) { REPORT_WARNING (("Reference %s at AML %X not found\n", Name, Op->AmlOffset)); ACPI_MEM_FREE (Name); } else { REPORT_WARNING (("Reference %s at AML %X not found\n", Op->Value.String, Op->AmlOffset)); } *ObjDescPtr = NULL; } else { return_ACPI_STATUS (Status); } } } /* * The reference will be a Reference * TBD: [Restructure] unless we really need a separate * type of INTERNAL_TYPE_REFERENCE change * AcpiDsMapOpcodeToDataType to handle this case */ Type = INTERNAL_TYPE_REFERENCE; } else { Type = AcpiDsMapOpcodeToDataType (Op->Opcode, NULL); } /* Create and init the internal ACPI object */ ObjDesc = AcpiUtCreateInternalObject (Type); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } Status = AcpiDsInitObjectFromOp (WalkState, Op, Op->Opcode, &ObjDesc); if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ObjDesc); return_ACPI_STATUS (Status); } *ObjDescPtr = ObjDesc; return_ACPI_STATUS (AE_OK); } /***************************************************************************** * * FUNCTION: AcpiDsBuildInternalPackageObj * * PARAMETERS: Op - Parser object to be translated * ObjDescPtr - Where the ACPI internal object is returned * * RETURN: Status * * DESCRIPTION: Translate a parser Op package object to the equivalent * namespace object * ****************************************************************************/ ACPI_STATUS AcpiDsBuildInternalPackageObj ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_OPERAND_OBJECT **ObjDescPtr) { ACPI_PARSE_OBJECT *Arg; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("DsBuildInternalPackageObj"); ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_PACKAGE); + *ObjDescPtr = ObjDesc; if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } + + if (Op->Opcode == AML_VAR_PACKAGE_OP) + { + /* + * Variable length package parameters are evaluated JIT + */ + return_ACPI_STATUS (AE_OK); + } /* The first argument must be the package length */ Arg = Op->Value.Arg; - ObjDesc->Package.Count = Arg->Value.Integer; + ObjDesc->Package.Count = Arg->Value.Integer32; /* * Allocate the array of pointers (ptrs to the * individual objects) Add an extra pointer slot so * that the list is always null terminated. */ - ObjDesc->Package.Elements = ACPI_MEM_CALLOCATE ( (ObjDesc->Package.Count + 1) * sizeof (void *)); if (!ObjDesc->Package.Elements) { AcpiUtDeleteObjectDesc (ObjDesc); return_ACPI_STATUS (AE_NO_MEMORY); } ObjDesc->Package.NextElement = ObjDesc->Package.Elements; /* * Now init the elements of the package */ - Arg = Arg->Next; while (Arg) { if (Arg->Opcode == AML_PACKAGE_OP) { Status = AcpiDsBuildInternalPackageObj (WalkState, Arg, ObjDesc->Package.NextElement); } else { Status = AcpiDsBuildInternalSimpleObj (WalkState, Arg, ObjDesc->Package.NextElement); } ObjDesc->Package.NextElement++; Arg = Arg->Next; } - *ObjDescPtr = ObjDesc; + ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID; return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiDsBuildInternalObject * * PARAMETERS: Op - Parser object to be translated * ObjDescPtr - Where the ACPI internal object is returned * * RETURN: Status * * DESCRIPTION: Translate a parser Op object to the equivalent namespace * object * ****************************************************************************/ ACPI_STATUS AcpiDsBuildInternalObject ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_OPERAND_OBJECT **ObjDescPtr) { ACPI_STATUS Status; - if (Op->Opcode == AML_PACKAGE_OP) + switch (Op->Opcode) { + case AML_PACKAGE_OP: + case AML_VAR_PACKAGE_OP: + Status = AcpiDsBuildInternalPackageObj (WalkState, Op, ObjDescPtr); - } + break; - else - { + + default: + Status = AcpiDsBuildInternalSimpleObj (WalkState, Op, ObjDescPtr); + break; } return (Status); } /***************************************************************************** * * FUNCTION: AcpiDsCreateNode * * PARAMETERS: Op - Parser object to be translated * ObjDescPtr - Where the ACPI internal object is returned * * RETURN: Status * * DESCRIPTION: * ****************************************************************************/ ACPI_STATUS AcpiDsCreateNode ( ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE *Node, ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *ObjDesc; FUNCTION_TRACE_PTR ("DsCreateNode", Op); if (!Op->Value.Arg) { /* No arguments, there is nothing to do */ return_ACPI_STATUS (AE_OK); } /* Build an internal object for the argument(s) */ Status = AcpiDsBuildInternalObject (WalkState, Op->Value.Arg, &ObjDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Re-type the object according to it's argument */ Node->Type = ObjDesc->Common.Type; /* Init obj */ Status = AcpiNsAttachObject (Node, ObjDesc, (UINT8) Node->Type); if (ACPI_FAILURE (Status)) { goto Cleanup; } return_ACPI_STATUS (Status); Cleanup: AcpiUtRemoveReference (ObjDesc); return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsopcode.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsopcode.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsopcode.c (revision 82367) @@ -1,1128 +1,1127 @@ /****************************************************************************** * * Module Name: dsopcode - Dispatcher Op Region support and handling of * "control" opcodes - * $Revision: 47 $ + * $Revision: 49 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __DSOPCODE_C__ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #include "acdispat.h" #include "acinterp.h" #include "acnamesp.h" #include "acevents.h" #include "actables.h" #define _COMPONENT ACPI_DISPATCHER MODULE_NAME ("dsopcode") /***************************************************************************** * * FUNCTION: AcpiDsGetBufferFieldArguments * * PARAMETERS: ObjDesc - A valid BufferField object * * RETURN: Status. * * DESCRIPTION: Get BufferField Buffer and Index. This implements the late * evaluation of these field attributes. * ****************************************************************************/ ACPI_STATUS AcpiDsGetBufferFieldArguments ( ACPI_OPERAND_OBJECT *ObjDesc) { ACPI_OPERAND_OBJECT *ExtraDesc; ACPI_NAMESPACE_NODE *Node; ACPI_PARSE_OBJECT *Op; ACPI_PARSE_OBJECT *FieldOp; ACPI_STATUS Status; ACPI_TABLE_DESC *TableDesc; FUNCTION_TRACE_PTR ("DsGetBufferFieldArguments", ObjDesc); if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID) { return_ACPI_STATUS (AE_OK); } /* Get the AML pointer (method object) and BufferField node */ ExtraDesc = ObjDesc->BufferField.Extra; Node = ObjDesc->BufferField.Node; DEBUG_EXEC(AcpiUtDisplayInitPathname (Node, " [Field]")); - DEBUG_PRINTP (TRACE_EXEC, ("[%4.4s] BufferField JIT Init\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s] BufferField JIT Init\n", &Node->Name)); /* * Allocate a new parser op to be the root of the parsed * OpRegion tree */ Op = AcpiPsAllocOp (AML_SCOPE_OP); if (!Op) { return (AE_NO_MEMORY); } /* Save the Node for use in AcpiPsParseAml */ Op->Node = AcpiNsGetParentObject (Node); /* Get a handle to the parent ACPI table */ Status = AcpiTbHandleToObject (Node->OwnerId, &TableDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Pass1: Parse the entire BufferField declaration */ Status = AcpiPsParseAml (Op, ExtraDesc->Extra.Pcode, ExtraDesc->Extra.PcodeLength, 0, NULL, NULL, NULL, AcpiDsLoad1BeginOp, AcpiDsLoad1EndOp); if (ACPI_FAILURE (Status)) { AcpiPsDeleteParseTree (Op); return_ACPI_STATUS (Status); } /* Get and init the actual FielUnitOp created above */ FieldOp = Op->Value.Arg; Op->Node = Node; FieldOp = Op->Value.Arg; FieldOp->Node = Node; AcpiPsDeleteParseTree (Op); /* AcpiEvaluate the address and length arguments for the OpRegion */ Op = AcpiPsAllocOp (AML_SCOPE_OP); if (!Op) { return (AE_NO_MEMORY); } Op->Node = AcpiNsGetParentObject (Node); Status = AcpiPsParseAml (Op, ExtraDesc->Extra.Pcode, ExtraDesc->Extra.PcodeLength, ACPI_PARSE_EXECUTE | ACPI_PARSE_DELETE_TREE, NULL /*MethodDesc*/, NULL, NULL, AcpiDsExecBeginOp, AcpiDsExecEndOp); /* All done with the parse tree, delete it */ AcpiPsDeleteParseTree (Op); /* * The pseudo-method object is no longer needed since the region is * now initialized */ AcpiUtRemoveReference (ObjDesc->BufferField.Extra); ObjDesc->BufferField.Extra = NULL; return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiDsGetRegionArguments * * PARAMETERS: ObjDesc - A valid region object * * RETURN: Status. * * DESCRIPTION: Get region address and length. This implements the late * evaluation of these region attributes. * ****************************************************************************/ ACPI_STATUS AcpiDsGetRegionArguments ( ACPI_OPERAND_OBJECT *ObjDesc) { ACPI_OPERAND_OBJECT *ExtraDesc = NULL; ACPI_NAMESPACE_NODE *Node; ACPI_PARSE_OBJECT *Op; ACPI_PARSE_OBJECT *RegionOp; ACPI_STATUS Status; ACPI_TABLE_DESC *TableDesc; FUNCTION_TRACE_PTR ("DsGetRegionArguments", ObjDesc); if (ObjDesc->Region.Flags & AOPOBJ_DATA_VALID) { return_ACPI_STATUS (AE_OK); } /* Get the AML pointer (method object) and region node */ ExtraDesc = ObjDesc->Region.Extra; Node = ObjDesc->Region.Node; DEBUG_EXEC(AcpiUtDisplayInitPathname (Node, " [Operation Region]")); - DEBUG_PRINTP (TRACE_EXEC, ("[%4.4s] OpRegion Init at AML %p[%x]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s] OpRegion Init at AML %p[%x]\n", &Node->Name, ExtraDesc->Extra.Pcode, *(UINT32*) ExtraDesc->Extra.Pcode)); /* * Allocate a new parser op to be the root of the parsed * OpRegion tree */ - Op = AcpiPsAllocOp (AML_SCOPE_OP); if (!Op) { return (AE_NO_MEMORY); } /* Save the Node for use in AcpiPsParseAml */ Op->Node = AcpiNsGetParentObject (Node); /* Get a handle to the parent ACPI table */ Status = AcpiTbHandleToObject (Node->OwnerId, &TableDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parse the entire OpRegion declaration, creating a parse tree */ Status = AcpiPsParseAml (Op, ExtraDesc->Extra.Pcode, ExtraDesc->Extra.PcodeLength, 0, NULL, NULL, NULL, AcpiDsLoad1BeginOp, AcpiDsLoad1EndOp); if (ACPI_FAILURE (Status)) { AcpiPsDeleteParseTree (Op); return_ACPI_STATUS (Status); } /* Get and init the actual RegionOp created above */ RegionOp = Op->Value.Arg; Op->Node = Node; RegionOp = Op->Value.Arg; RegionOp->Node = Node; AcpiPsDeleteParseTree (Op); - /* AcpiEvaluate the address and length arguments for the OpRegion */ + /* Evaluate the address and length arguments for the OpRegion */ Op = AcpiPsAllocOp (AML_SCOPE_OP); if (!Op) { return (AE_NO_MEMORY); } Op->Node = AcpiNsGetParentObject (Node); Status = AcpiPsParseAml (Op, ExtraDesc->Extra.Pcode, ExtraDesc->Extra.PcodeLength, ACPI_PARSE_EXECUTE | ACPI_PARSE_DELETE_TREE, NULL /*MethodDesc*/, NULL, NULL, AcpiDsExecBeginOp, AcpiDsExecEndOp); /* All done with the parse tree, delete it */ AcpiPsDeleteParseTree (Op); return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiDsInitializeRegion * * PARAMETERS: Op - A valid region Op object * * RETURN: Status * * DESCRIPTION: * ****************************************************************************/ ACPI_STATUS AcpiDsInitializeRegion ( ACPI_HANDLE ObjHandle) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_STATUS Status; ObjDesc = AcpiNsGetAttachedObject (ObjHandle); /* Namespace is NOT locked */ Status = AcpiEvInitializeRegion (ObjDesc, FALSE); return (Status); } /***************************************************************************** * * FUNCTION: AcpiDsEvalBufferFieldOperands * * PARAMETERS: Op - A valid BufferField Op object * * RETURN: Status * * DESCRIPTION: Get BufferField Buffer and Index * Called from AcpiDsExecEndOp during BufferField parse tree walk * * ACPI SPECIFICATION REFERENCES: * Each of the Buffer Field opcodes is defined as specified in in-line * comments below. For each one, use the following definitions. * * DefBitField := BitFieldOp SrcBuf BitIdx Destination * DefByteField := ByteFieldOp SrcBuf ByteIdx Destination * DefCreateField := CreateFieldOp SrcBuf BitIdx NumBits NameString * DefDWordField := DWordFieldOp SrcBuf ByteIdx Destination * DefWordField := WordFieldOp SrcBuf ByteIdx Destination * BitIndex := TermArg=>Integer * ByteIndex := TermArg=>Integer * Destination := NameString * NumBits := TermArg=>Integer * SourceBuf := TermArg=>Buffer * ****************************************************************************/ ACPI_STATUS AcpiDsEvalBufferFieldOperands ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_NAMESPACE_NODE *Node; ACPI_PARSE_OBJECT *NextOp; UINT32 Offset; UINT32 BitOffset; UINT32 BitCount; UINT8 FieldFlags; ACPI_OPERAND_OBJECT *ResDesc = NULL; ACPI_OPERAND_OBJECT *CntDesc = NULL; ACPI_OPERAND_OBJECT *OffDesc = NULL; ACPI_OPERAND_OBJECT *SrcDesc = NULL; UINT32 NumOperands = 3; FUNCTION_TRACE_PTR ("DsEvalBufferFieldOperands", Op); /* * This is where we evaluate the address and length fields of the * CreateXxxField declaration */ Node = Op->Node; /* NextOp points to the op that holds the Buffer */ NextOp = Op->Value.Arg; /* AcpiEvaluate/create the address and length operands */ Status = AcpiDsCreateOperands (WalkState, NextOp); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } ObjDesc = AcpiNsGetAttachedObject (Node); if (!ObjDesc) { return_ACPI_STATUS (AE_NOT_EXIST); } /* Resolve the operands */ Status = AcpiExResolveOperands (Op->Opcode, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (Op->Opcode), NumOperands, "after AcpiExResolveOperands"); /* Get the operands */ Status |= AcpiDsObjStackPopObject (&ResDesc, WalkState); if (AML_CREATE_FIELD_OP == Op->Opcode) { NumOperands = 4; Status |= AcpiDsObjStackPopObject (&CntDesc, WalkState); } Status |= AcpiDsObjStackPopObject (&OffDesc, WalkState); Status |= AcpiDsObjStackPopObject (&SrcDesc, WalkState); if (ACPI_FAILURE (Status)) { /* Invalid parameters on object stack */ - DEBUG_PRINTP (ACPI_ERROR, ("(%s) bad operand(s) (%X)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(%s) bad operand(s) (%X)\n", AcpiPsGetOpcodeName (Op->Opcode), Status)); goto Cleanup; } Offset = (UINT32) OffDesc->Integer.Value; /* * If ResDesc is a Name, it will be a direct name pointer after * AcpiExResolveOperands() */ if (!VALID_DESCRIPTOR_TYPE (ResDesc, ACPI_DESC_TYPE_NAMED)) { - DEBUG_PRINTP (ACPI_ERROR, ("(%s) destination must be a Node\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(%s) destination must be a Node\n", AcpiPsGetOpcodeName (Op->Opcode))); Status = AE_AML_OPERAND_TYPE; goto Cleanup; } /* * Setup the Bit offsets and counts, according to the opcode */ switch (Op->Opcode) { /* DefCreateField */ case AML_CREATE_FIELD_OP: /* Offset is in bits, count is in bits */ BitOffset = Offset; BitCount = (UINT32) CntDesc->Integer.Value; FieldFlags = ACCESS_BYTE_ACC; break; /* DefCreateBitField */ case AML_CREATE_BIT_FIELD_OP: /* Offset is in bits, Field is one bit */ BitOffset = Offset; BitCount = 1; FieldFlags = ACCESS_BYTE_ACC; break; /* DefCreateByteField */ case AML_CREATE_BYTE_FIELD_OP: /* Offset is in bytes, field is one byte */ BitOffset = 8 * Offset; BitCount = 8; FieldFlags = ACCESS_BYTE_ACC; break; /* DefCreateWordField */ case AML_CREATE_WORD_FIELD_OP: /* Offset is in bytes, field is one word */ BitOffset = 8 * Offset; BitCount = 16; FieldFlags = ACCESS_WORD_ACC; break; /* DefCreateDWordField */ case AML_CREATE_DWORD_FIELD_OP: /* Offset is in bytes, field is one dword */ BitOffset = 8 * Offset; BitCount = 32; FieldFlags = ACCESS_DWORD_ACC; break; /* DefCreateQWordField */ case AML_CREATE_QWORD_FIELD_OP: /* Offset is in bytes, field is one qword */ BitOffset = 8 * Offset; BitCount = 64; FieldFlags = ACCESS_QWORD_ACC; break; default: - DEBUG_PRINTP (ACPI_ERROR, - ("Internal error - unknown field creation opcode %02x\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Internal error - unknown field creation opcode %02x\n", Op->Opcode)); Status = AE_AML_BAD_OPCODE; goto Cleanup; } /* * Setup field according to the object type */ switch (SrcDesc->Common.Type) { /* SourceBuff := TermArg=>Buffer */ case ACPI_TYPE_BUFFER: if ((BitOffset + BitCount) > (8 * (UINT32) SrcDesc->Buffer.Length)) { - DEBUG_PRINTP (ACPI_ERROR, - ("Field size %d exceeds Buffer size %d (bits)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Field size %d exceeds Buffer size %d (bits)\n", BitOffset + BitCount, 8 * (UINT32) SrcDesc->Buffer.Length)); Status = AE_AML_BUFFER_LIMIT; goto Cleanup; } /* * Initialize areas of the field object that are common to all fields * For FieldFlags, use LOCK_RULE = 0 (NO_LOCK), UPDATE_RULE = 0 (UPDATE_PRESERVE) */ Status = AcpiExPrepCommonFieldObject (ObjDesc, FieldFlags, BitOffset, BitCount); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } ObjDesc->BufferField.BufferObj = SrcDesc; /* Reference count for SrcDesc inherits ObjDesc count */ SrcDesc->Common.ReferenceCount = (UINT16) (SrcDesc->Common.ReferenceCount + ObjDesc->Common.ReferenceCount); break; /* Improper object type */ default: if ((SrcDesc->Common.Type > (UINT8) INTERNAL_TYPE_REFERENCE) || !AcpiUtValidObjectType (SrcDesc->Common.Type)) /* TBD: This line MUST be a single line until AcpiSrc can handle it (block deletion) */ { - DEBUG_PRINTP (ACPI_ERROR, - ("Tried to create field in invalid object type %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Tried to create field in invalid object type %X\n", SrcDesc->Common.Type)); } else { - DEBUG_PRINTP (ACPI_ERROR, - ("Tried to create field in improper object type - %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Tried to create field in improper object type - %s\n", AcpiUtGetTypeName (SrcDesc->Common.Type))); } Status = AE_AML_OPERAND_TYPE; goto Cleanup; } if (AML_CREATE_FIELD_OP == Op->Opcode) { /* Delete object descriptor unique to CreateField */ AcpiUtRemoveReference (CntDesc); CntDesc = NULL; } Cleanup: /* Always delete the operands */ AcpiUtRemoveReference (OffDesc); AcpiUtRemoveReference (SrcDesc); if (AML_CREATE_FIELD_OP == Op->Opcode) { AcpiUtRemoveReference (CntDesc); } /* On failure, delete the result descriptor */ if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ResDesc); /* Result descriptor */ } else { /* Now the address and length are valid for this BufferField */ ObjDesc->BufferField.Flags |= AOPOBJ_DATA_VALID; } return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiDsEvalRegionOperands * * PARAMETERS: Op - A valid region Op object * * RETURN: Status * * DESCRIPTION: Get region address and length * Called from AcpiDsExecEndOp during OpRegion parse tree walk * ****************************************************************************/ ACPI_STATUS AcpiDsEvalRegionOperands ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *OperandDesc; ACPI_NAMESPACE_NODE *Node; ACPI_PARSE_OBJECT *NextOp; FUNCTION_TRACE_PTR ("DsEvalRegionOperands", Op); /* * This is where we evaluate the address and length fields of the OpRegion declaration */ Node = Op->Node; /* NextOp points to the op that holds the SpaceID */ NextOp = Op->Value.Arg; /* NextOp points to address op */ NextOp = NextOp->Next; /* AcpiEvaluate/create the address and length operands */ Status = AcpiDsCreateOperands (WalkState, NextOp); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Resolve the length and address operands to numbers */ Status = AcpiExResolveOperands (Op->Opcode, WALK_OPERANDS, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (Op->Opcode), 1, "after AcpiExResolveOperands"); ObjDesc = AcpiNsGetAttachedObject (Node); if (!ObjDesc) { return_ACPI_STATUS (AE_NOT_EXIST); } /* * Get the length operand and save it * (at Top of stack) */ OperandDesc = WalkState->Operands[WalkState->NumOperands - 1]; ObjDesc->Region.Length = (UINT32) OperandDesc->Integer.Value; AcpiUtRemoveReference (OperandDesc); /* * Get the address and save it * (at top of stack - 1) */ OperandDesc = WalkState->Operands[WalkState->NumOperands - 2]; ObjDesc->Region.Address = (ACPI_PHYSICAL_ADDRESS) OperandDesc->Integer.Value; AcpiUtRemoveReference (OperandDesc); - DEBUG_PRINTP (TRACE_EXEC, ("RgnObj %p Addr %8.8lX%8.8lX Len %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "RgnObj %p Addr %8.8lX%8.8lX Len %X\n", ObjDesc, HIDWORD(ObjDesc->Region.Address), LODWORD(ObjDesc->Region.Address), ObjDesc->Region.Length)); /* Now the address and length are valid for this opregion */ ObjDesc->Region.Flags |= AOPOBJ_DATA_VALID; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiDsExecBeginControlOp * * PARAMETERS: WalkList - The list that owns the walk stack * Op - The control Op * * RETURN: Status * * DESCRIPTION: Handles all control ops encountered during control method * execution. * ******************************************************************************/ ACPI_STATUS AcpiDsExecBeginControlOp ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status = AE_OK; ACPI_GENERIC_STATE *ControlState; PROC_NAME ("DsExecBeginControlOp"); - DEBUG_PRINTP (TRACE_DISPATCH, ("Op=%p Opcode=%2.2X State=%p\n", Op, + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p Opcode=%2.2X State=%p\n", Op, Op->Opcode, WalkState)); switch (Op->Opcode) { case AML_IF_OP: case AML_WHILE_OP: /* * IF/WHILE: Create a new control state to manage these * constructs. We need to manage these as a stack, in order * to handle nesting. */ ControlState = AcpiUtCreateControlState (); if (!ControlState) { Status = AE_NO_MEMORY; break; } AcpiUtPushGenericState (&WalkState->ControlState, ControlState); /* * Save a pointer to the predicate for multiple executions * of a loop */ WalkState->ControlState->Control.AmlPredicateStart = WalkState->ParserState->Aml - 1; /* TBD: can this be removed? */ /*AcpiPsPkgLengthEncodingSize (GET8 (WalkState->ParserState->Aml));*/ break; case AML_ELSE_OP: /* Predicate is in the state object */ /* If predicate is true, the IF was executed, ignore ELSE part */ if (WalkState->LastPredicate) { Status = AE_CTRL_TRUE; } break; case AML_RETURN_OP: break; default: break; } return (Status); } /******************************************************************************* * * FUNCTION: AcpiDsExecEndControlOp * * PARAMETERS: WalkList - The list that owns the walk stack * Op - The control Op * * RETURN: Status * * DESCRIPTION: Handles all control ops encountered during control method * execution. * * ******************************************************************************/ ACPI_STATUS AcpiDsExecEndControlOp ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status = AE_OK; ACPI_GENERIC_STATE *ControlState; PROC_NAME ("DsExecEndControlOp"); switch (Op->Opcode) { case AML_IF_OP: - DEBUG_PRINTP (TRACE_DISPATCH, ("[IF_OP] Op=%p\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[IF_OP] Op=%p\n", Op)); /* * Save the result of the predicate in case there is an * ELSE to come */ WalkState->LastPredicate = (BOOLEAN) WalkState->ControlState->Common.Value; /* * Pop the control state that was created at the start * of the IF and free it */ ControlState = AcpiUtPopGenericState (&WalkState->ControlState); AcpiUtDeleteGenericState (ControlState); break; case AML_ELSE_OP: break; case AML_WHILE_OP: - DEBUG_PRINTP (TRACE_DISPATCH, ("[WHILE_OP] Op=%p\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[WHILE_OP] Op=%p\n", Op)); if (WalkState->ControlState->Common.Value) { /* Predicate was true, go back and evaluate it again! */ Status = AE_CTRL_PENDING; } - DEBUG_PRINTP (TRACE_DISPATCH, ("[WHILE_OP] termination! Op=%p\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[WHILE_OP] termination! Op=%p\n", Op)); /* Pop this control state and free it */ ControlState = AcpiUtPopGenericState (&WalkState->ControlState); WalkState->AmlLastWhile = ControlState->Control.AmlPredicateStart; AcpiUtDeleteGenericState (ControlState); break; case AML_RETURN_OP: - DEBUG_PRINTP (TRACE_DISPATCH, - ("[RETURN_OP] Op=%p Arg=%p\n",Op, Op->Value.Arg)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "[RETURN_OP] Op=%p Arg=%p\n",Op, Op->Value.Arg)); /* * One optional operand -- the return value * It can be either an immediate operand or a result that * has been bubbled up the tree */ if (Op->Value.Arg) { /* Return statement has an immediate operand */ Status = AcpiDsCreateOperands (WalkState, Op->Value.Arg); if (ACPI_FAILURE (Status)) { return (Status); } /* * If value being returned is a Reference (such as * an arg or local), resolve it now because it may * cease to exist at the end of the method. */ Status = AcpiExResolveToValue (&WalkState->Operands [0], WalkState); if (ACPI_FAILURE (Status)) { return (Status); } /* * Get the return value and save as the last result * value. This is the only place where WalkState->ReturnDesc * is set to anything other than zero! */ WalkState->ReturnDesc = WalkState->Operands[0]; } else if ((WalkState->Results) && (WalkState->Results->Results.NumResults > 0)) { /* * The return value has come from a previous calculation. * * If value being returned is a Reference (such as * an arg or local), resolve it now because it may * cease to exist at the end of the method. * * Allow references created by the Index operator to return unchanged. */ if (VALID_DESCRIPTOR_TYPE (WalkState->Results->Results.ObjDesc [0], ACPI_DESC_TYPE_INTERNAL) && ((WalkState->Results->Results.ObjDesc [0])->Common.Type == INTERNAL_TYPE_REFERENCE) && ((WalkState->Results->Results.ObjDesc [0])->Reference.Opcode != AML_INDEX_OP)) { Status = AcpiExResolveToValue (&WalkState->Results->Results.ObjDesc [0], WalkState); if (ACPI_FAILURE (Status)) { return (Status); } } WalkState->ReturnDesc = WalkState->Results->Results.ObjDesc [0]; } else { /* No return operand */ if (WalkState->NumOperands) { AcpiUtRemoveReference (WalkState->Operands [0]); } WalkState->Operands [0] = NULL; WalkState->NumOperands = 0; WalkState->ReturnDesc = NULL; } - DEBUG_PRINTP (TRACE_DISPATCH, - ("Completed RETURN_OP State=%p, RetVal=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "Completed RETURN_OP State=%p, RetVal=%p\n", WalkState, WalkState->ReturnDesc)); /* End the control method execution right now */ Status = AE_CTRL_TERMINATE; break; case AML_NOOP_OP: /* Just do nothing! */ break; case AML_BREAK_POINT_OP: /* Call up to the OS service layer to handle this */ AcpiOsSignal (ACPI_SIGNAL_BREAKPOINT, "Executed AML Breakpoint opcode"); /* If and when it returns, all done. */ break; case AML_BREAK_OP: - DEBUG_PRINTP (ACPI_INFO, - ("Break to end of current package, Op=%p\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Break to end of current package, Op=%p\n", Op)); /* TBD: update behavior for ACPI 2.0 */ /* * As per the ACPI specification: * "The break operation causes the current package * execution to complete" * "Break -- Stop executing the current code package * at this point" * * Returning AE_FALSE here will cause termination of * the current package, and execution will continue one * level up, starting with the completion of the parent Op. */ Status = AE_CTRL_FALSE; break; case AML_CONTINUE_OP: /* ACPI 2.0 */ Status = AE_NOT_IMPLEMENTED; break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Unknown control opcode=%X Op=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown control opcode=%X Op=%p\n", Op->Opcode, Op)); Status = AE_AML_BAD_OPCODE; break; } return (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsutils.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsutils.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dsutils.c (revision 82367) @@ -1,934 +1,932 @@ /******************************************************************************* * * Module Name: dsutils - Dispatcher utilities - * $Revision: 62 $ + * $Revision: 68 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __DSUTILS_C__ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #include "acdispat.h" #include "acinterp.h" #include "acnamesp.h" #include "acdebug.h" #define _COMPONENT ACPI_DISPATCHER MODULE_NAME ("dsutils") /******************************************************************************* * * FUNCTION: AcpiDsIsResultUsed * * PARAMETERS: Op * ResultObj * WalkState * * RETURN: Status * * DESCRIPTION: Check if a result object will be used by the parent * ******************************************************************************/ BOOLEAN AcpiDsIsResultUsed ( ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState) { ACPI_OPCODE_INFO *ParentInfo; FUNCTION_TRACE_PTR ("DsIsResultUsed", Op); /* Must have both an Op and a Result Object */ if (!Op) { - DEBUG_PRINTP (ACPI_ERROR, ("Null Op\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null Op\n")); return_VALUE (TRUE); } /* * If there is no parent, the result can't possibly be used! * (An executing method typically has no parent, since each * method is parsed separately) However, a method that is * invoked from another method has a parent. */ if (!Op->Parent) { return_VALUE (FALSE); } /* * Get info on the parent. The root Op is AML_SCOPE */ ParentInfo = AcpiPsGetOpcodeInfo (Op->Parent->Opcode); if (ACPI_GET_OP_TYPE (ParentInfo) != ACPI_OP_TYPE_OPCODE) { - DEBUG_PRINTP (ACPI_ERROR, ("Unknown parent opcode. Op=%X\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown parent opcode. Op=%X\n", Op)); return_VALUE (FALSE); } /* * Decide what to do with the result based on the parent. If * the parent opcode will not use the result, delete the object. * Otherwise leave it as is, it will be deleted when it is used * as an operand later. */ switch (ACPI_GET_OP_CLASS (ParentInfo)) { /* * In these cases, the parent will never use the return object */ case OPTYPE_CONTROL: /* IF, ELSE, WHILE only */ switch (Op->Parent->Opcode) { case AML_RETURN_OP: /* Never delete the return value associated with a return opcode */ - DEBUG_PRINTP (TRACE_DISPATCH, - ("Result used, [RETURN] opcode=%X Op=%X\n", Op->Opcode, Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "Result used, [RETURN] opcode=%X Op=%X\n", Op->Opcode, Op)); return_VALUE (TRUE); break; case AML_IF_OP: case AML_WHILE_OP: /* * If we are executing the predicate AND this is the predicate op, * we will use the return value! */ if ((WalkState->ControlState->Common.State == CONTROL_PREDICATE_EXECUTING) && (WalkState->ControlState->Control.PredicateOp == Op)) { - DEBUG_PRINTP (TRACE_DISPATCH, - ("Result used as a predicate, [IF/WHILE] opcode=%X Op=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "Result used as a predicate, [IF/WHILE] opcode=%X Op=%X\n", Op->Opcode, Op)); return_VALUE (TRUE); } break; } /* Fall through to not used case below */ case OPTYPE_NAMED_OBJECT: /* Scope, method, etc. */ /* * These opcodes allow TermArg(s) as operands and therefore * method calls. The result is used. */ if ((Op->Parent->Opcode == AML_REGION_OP) || (Op->Parent->Opcode == AML_CREATE_FIELD_OP) || (Op->Parent->Opcode == AML_CREATE_BIT_FIELD_OP) || (Op->Parent->Opcode == AML_CREATE_BYTE_FIELD_OP) || (Op->Parent->Opcode == AML_CREATE_WORD_FIELD_OP) || (Op->Parent->Opcode == AML_CREATE_DWORD_FIELD_OP) || (Op->Parent->Opcode == AML_CREATE_QWORD_FIELD_OP)) { - DEBUG_PRINTP (TRACE_DISPATCH, - ("Result used, [Region or CreateField] opcode=%X Op=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "Result used, [Region or CreateField] opcode=%X Op=%X\n", Op->Opcode, Op)); return_VALUE (TRUE); } - DEBUG_PRINTP (TRACE_DISPATCH, - ("Result not used, Parent opcode=%X Op=%X\n", Op->Opcode, Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "Result not used, Parent opcode=%X Op=%X\n", Op->Opcode, Op)); return_VALUE (FALSE); break; /* * In all other cases. the parent will actually use the return * object, so keep it. */ default: break; } return_VALUE (TRUE); } /******************************************************************************* * * FUNCTION: AcpiDsDeleteResultIfNotUsed * * PARAMETERS: Op * ResultObj * WalkState * * RETURN: Status * * DESCRIPTION: Used after interpretation of an opcode. If there is an internal * result descriptor, check if the parent opcode will actually use * this result. If not, delete the result now so that it will * not become orphaned. * ******************************************************************************/ void AcpiDsDeleteResultIfNotUsed ( ACPI_PARSE_OBJECT *Op, ACPI_OPERAND_OBJECT *ResultObj, ACPI_WALK_STATE *WalkState) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_STATUS Status; FUNCTION_TRACE_PTR ("DsDeleteResultIfNotUsed", ResultObj); if (!Op) { - DEBUG_PRINTP (ACPI_ERROR, ("Null Op\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null Op\n")); return_VOID; } if (!ResultObj) { return_VOID; } if (!AcpiDsIsResultUsed (Op, WalkState)) { /* - * Must pop the result stack (ObjDesc should be equal - * to ResultObj) + * Must pop the result stack (ObjDesc should be equal to ResultObj) */ - Status = AcpiDsResultPop (&ObjDesc, WalkState); if (ACPI_SUCCESS (Status)) { AcpiUtRemoveReference (ResultObj); } } return_VOID; } /******************************************************************************* * * FUNCTION: AcpiDsCreateOperand * * PARAMETERS: WalkState * Arg * * RETURN: Status * * DESCRIPTION: Translate a parse tree object that is an argument to an AML * opcode to the equivalent interpreter object. This may include * looking up a name or entering a new name into the internal * namespace. * ******************************************************************************/ ACPI_STATUS AcpiDsCreateOperand ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Arg, UINT32 ArgIndex) { ACPI_STATUS Status = AE_OK; NATIVE_CHAR *NameString; UINT32 NameLength; ACPI_OBJECT_TYPE8 DataType; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_PARSE_OBJECT *ParentOp; UINT16 Opcode; UINT32 Flags; OPERATING_MODE InterpreterMode; FUNCTION_TRACE_PTR ("DsCreateOperand", Arg); /* A valid name must be looked up in the namespace */ if ((Arg->Opcode == AML_INT_NAMEPATH_OP) && (Arg->Value.String)) { - DEBUG_PRINTP (TRACE_DISPATCH, ("Getting a name: Arg=%p\n", Arg)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Getting a name: Arg=%p\n", Arg)); /* Get the entire name string from the AML stream */ Status = AcpiExGetNameString (ACPI_TYPE_ANY, Arg->Value.Buffer, &NameString, &NameLength); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * All prefixes have been handled, and the name is * in NameString */ /* * Differentiate between a namespace "create" operation * versus a "lookup" operation (IMODE_LOAD_PASS2 vs. * IMODE_EXECUTE) in order to support the creation of * namespace objects during the execution of control methods. */ - ParentOp = Arg->Parent; if ((AcpiPsIsNodeOp (ParentOp->Opcode)) && (ParentOp->Opcode != AML_INT_METHODCALL_OP) && (ParentOp->Opcode != AML_REGION_OP) && (ParentOp->Opcode != AML_INT_NAMEPATH_OP)) { /* Enter name into namespace if not found */ InterpreterMode = IMODE_LOAD_PASS2; } else { /* Return a failure if name not found */ InterpreterMode = IMODE_EXECUTE; } Status = AcpiNsLookup (WalkState->ScopeInfo, NameString, ACPI_TYPE_ANY, InterpreterMode, NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE, WalkState, (ACPI_NAMESPACE_NODE **) &ObjDesc); /* Free the namestring created above */ ACPI_MEM_FREE (NameString); /* * The only case where we pass through (ignore) a NOT_FOUND * error is for the CondRefOf opcode. */ if (Status == AE_NOT_FOUND) { if (ParentOp->Opcode == AML_COND_REF_OF_OP) { /* * For the Conditional Reference op, it's OK if * the name is not found; We just need a way to * indicate this to the interpreter, set the * object to the root */ ObjDesc = (ACPI_OPERAND_OBJECT *) AcpiGbl_RootNode; Status = AE_OK; } else { /* * We just plain didn't find it -- which is a * very serious error at this point */ Status = AE_AML_NAME_NOT_FOUND; } } /* Check status from the lookup */ if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Put the resulting object onto the current object stack */ Status = AcpiDsObjStackPush (ObjDesc, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (ObjDesc, WalkState)); } else { /* Check for null name case */ if (Arg->Opcode == AML_INT_NAMEPATH_OP) { /* * If the name is null, this means that this is an * optional result parameter that was not specified * in the original ASL. Create an Reference for a * placeholder */ Opcode = AML_ZERO_OP; /* Has no arguments! */ - DEBUG_PRINTP (TRACE_DISPATCH, ("Null namepath: Arg=%p\n", Arg)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Null namepath: Arg=%p\n", Arg)); /* * TBD: [Investigate] anything else needed for the * zero op lvalue? */ } else { Opcode = Arg->Opcode; } /* Get the data type of the argument */ DataType = AcpiDsMapOpcodeToDataType (Opcode, &Flags); if (DataType == INTERNAL_TYPE_INVALID) { return_ACPI_STATUS (AE_NOT_IMPLEMENTED); } if (Flags & OP_HAS_RETURN_VALUE) { - DEBUG_PRINTP (TRACE_DISPATCH, - ("Argument previously created, already stacked \n")); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "Argument previously created, already stacked \n")); DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (WalkState->Operands [WalkState->NumOperands - 1], WalkState)); /* * Use value that was already previously returned * by the evaluation of this argument */ Status = AcpiDsResultPopFromBottom (&ObjDesc, WalkState); if (ACPI_FAILURE (Status)) { /* * Only error is underflow, and this indicates * a missing or null operand! */ - DEBUG_PRINTP (ACPI_ERROR, ("Missing or null operand, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Missing or null operand, %s\n", AcpiFormatException (Status))); return_ACPI_STATUS (Status); } } else { /* Create an ACPI_INTERNAL_OBJECT for the argument */ ObjDesc = AcpiUtCreateInternalObject (DataType); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Initialize the new object */ Status = AcpiDsInitObjectFromOp (WalkState, Arg, Opcode, &ObjDesc); if (ACPI_FAILURE (Status)) { AcpiUtDeleteObjectDesc (ObjDesc); return_ACPI_STATUS (Status); } } /* Put the operand object on the object stack */ Status = AcpiDsObjStackPush (ObjDesc, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (ObjDesc, WalkState)); } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsCreateOperands * * PARAMETERS: FirstArg - First argument of a parser argument tree * * RETURN: Status * * DESCRIPTION: Convert an operator's arguments from a parse tree format to * namespace objects and place those argument object on the object * stack in preparation for evaluation by the interpreter. * ******************************************************************************/ ACPI_STATUS AcpiDsCreateOperands ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *FirstArg) { ACPI_STATUS Status = AE_OK; ACPI_PARSE_OBJECT *Arg; UINT32 ArgCount = 0; FUNCTION_TRACE_PTR ("DsCreateOperands", FirstArg); /* For all arguments in the list... */ Arg = FirstArg; while (Arg) { Status = AcpiDsCreateOperand (WalkState, Arg, ArgCount); if (ACPI_FAILURE (Status)) { goto Cleanup; } - DEBUG_PRINTP (TRACE_DISPATCH, ("Arg #%d (%p) done, Arg1=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Arg #%d (%p) done, Arg1=%p\n", ArgCount, Arg, FirstArg)); /* Move on to next argument, if any */ Arg = Arg->Next; ArgCount++; } return_ACPI_STATUS (Status); Cleanup: /* * We must undo everything done above; meaning that we must * pop everything off of the operand stack and delete those * objects */ AcpiDsObjStackPopAndDelete (ArgCount, WalkState); - DEBUG_PRINTP (ACPI_ERROR, ("While creating Arg %d - %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "While creating Arg %d - %s\n", (ArgCount + 1), AcpiFormatException (Status))); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiDsResolveOperands * * PARAMETERS: WalkState - Current walk state with operands on stack * * RETURN: Status * * DESCRIPTION: Resolve all operands to their values. Used to prepare * arguments to a control method invocation (a call from one * method to another.) * ******************************************************************************/ ACPI_STATUS AcpiDsResolveOperands ( ACPI_WALK_STATE *WalkState) { UINT32 i; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE_PTR ("DsResolveOperands", WalkState); /* * Attempt to resolve each of the valid operands * Method arguments are passed by value, not by reference */ /* * TBD: [Investigate] Note from previous parser: * RefOf problem with AcpiExResolveToValue() conversion. */ for (i = 0; i < WalkState->NumOperands; i++) { Status = AcpiExResolveToValue (&WalkState->Operands[i], WalkState); if (ACPI_FAILURE (Status)) { break; } } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiDsMapOpcodeToDataType * * PARAMETERS: Opcode - AML opcode to map * OutFlags - Additional info about the opcode * * RETURN: The ACPI type associated with the opcode * * DESCRIPTION: Convert a raw AML opcode to the associated ACPI data type, * if any. If the opcode returns a value as part of the * intepreter execution, a flag is returned in OutFlags. * ******************************************************************************/ ACPI_OBJECT_TYPE8 AcpiDsMapOpcodeToDataType ( UINT16 Opcode, UINT32 *OutFlags) { ACPI_OBJECT_TYPE8 DataType = INTERNAL_TYPE_INVALID; ACPI_OPCODE_INFO *OpInfo; UINT32 Flags = 0; PROC_NAME ("DsMapOpcodeToDataType"); OpInfo = AcpiPsGetOpcodeInfo (Opcode); if (ACPI_GET_OP_TYPE (OpInfo) != ACPI_OP_TYPE_OPCODE) { /* Unknown opcode */ - DEBUG_PRINTP (ACPI_ERROR, ("Unknown AML opcode: %x\n", Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown AML opcode: %x\n", Opcode)); return (DataType); } switch (ACPI_GET_OP_CLASS (OpInfo)) { case OPTYPE_LITERAL: switch (Opcode) { case AML_BYTE_OP: case AML_WORD_OP: case AML_DWORD_OP: + case AML_QWORD_OP: DataType = ACPI_TYPE_INTEGER; break; case AML_STRING_OP: DataType = ACPI_TYPE_STRING; break; case AML_INT_NAMEPATH_OP: DataType = INTERNAL_TYPE_REFERENCE; break; default: - DEBUG_PRINTP (ACPI_ERROR, - ("Unknown (type LITERAL) AML opcode: %x\n", Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Unknown (type LITERAL) AML opcode: %x\n", Opcode)); break; } break; case OPTYPE_DATA_TERM: switch (Opcode) { case AML_BUFFER_OP: DataType = ACPI_TYPE_BUFFER; break; case AML_PACKAGE_OP: case AML_VAR_PACKAGE_OP: DataType = ACPI_TYPE_PACKAGE; break; default: - DEBUG_PRINTP (ACPI_ERROR, - ("Unknown (type DATA_TERM) AML opcode: %x\n", Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Unknown (type DATA_TERM) AML opcode: %x\n", Opcode)); break; } break; case OPTYPE_CONSTANT: case OPTYPE_METHOD_ARGUMENT: case OPTYPE_LOCAL_VARIABLE: DataType = INTERNAL_TYPE_REFERENCE; break; case OPTYPE_MONADIC2: case OPTYPE_MONADIC2R: case OPTYPE_DYADIC2: case OPTYPE_DYADIC2R: case OPTYPE_DYADIC2S: case OPTYPE_TRIADIC: case OPTYPE_QUADRADIC: case OPTYPE_HEXADIC: case OPTYPE_RETURN: Flags = OP_HAS_RETURN_VALUE; DataType = ACPI_TYPE_ANY; break; case OPTYPE_METHOD_CALL: Flags = OP_HAS_RETURN_VALUE; DataType = ACPI_TYPE_METHOD; break; case OPTYPE_NAMED_OBJECT: DataType = AcpiDsMapNamedOpcodeToDataType (Opcode); break; case OPTYPE_DYADIC1: case OPTYPE_CONTROL: /* No mapping needed at this time */ break; default: - DEBUG_PRINTP (ACPI_ERROR, - ("Unimplemented data type opcode: %x\n", Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Unimplemented data type opcode: %x\n", Opcode)); break; } /* Return flags to caller if requested */ if (OutFlags) { *OutFlags = Flags; } return (DataType); } /******************************************************************************* * * FUNCTION: AcpiDsMapNamedOpcodeToDataType * * PARAMETERS: Opcode - The Named AML opcode to map * * RETURN: The ACPI type associated with the named opcode * * DESCRIPTION: Convert a raw Named AML opcode to the associated data type. * Named opcodes are a subsystem of the AML opcodes. * ******************************************************************************/ ACPI_OBJECT_TYPE8 AcpiDsMapNamedOpcodeToDataType ( UINT16 Opcode) { ACPI_OBJECT_TYPE8 DataType; /* Decode Opcode */ switch (Opcode) { case AML_SCOPE_OP: DataType = INTERNAL_TYPE_SCOPE; break; case AML_DEVICE_OP: DataType = ACPI_TYPE_DEVICE; break; case AML_THERMAL_ZONE_OP: DataType = ACPI_TYPE_THERMAL; break; case AML_METHOD_OP: DataType = ACPI_TYPE_METHOD; break; case AML_POWER_RES_OP: DataType = ACPI_TYPE_POWER; break; case AML_PROCESSOR_OP: DataType = ACPI_TYPE_PROCESSOR; break; case AML_FIELD_OP: /* FieldOp */ DataType = INTERNAL_TYPE_FIELD_DEFN; break; case AML_INDEX_FIELD_OP: /* IndexFieldOp */ DataType = INTERNAL_TYPE_INDEX_FIELD_DEFN; break; case AML_BANK_FIELD_OP: /* BankFieldOp */ DataType = INTERNAL_TYPE_BANK_FIELD_DEFN; break; case AML_INT_NAMEDFIELD_OP: /* NO CASE IN ORIGINAL */ DataType = ACPI_TYPE_ANY; break; case AML_NAME_OP: /* NameOp - special code in original */ case AML_INT_NAMEPATH_OP: DataType = ACPI_TYPE_ANY; break; case AML_ALIAS_OP: DataType = INTERNAL_TYPE_ALIAS; break; case AML_MUTEX_OP: DataType = ACPI_TYPE_MUTEX; break; case AML_EVENT_OP: DataType = ACPI_TYPE_EVENT; break; case AML_REGION_OP: DataType = ACPI_TYPE_REGION; break; default: DataType = ACPI_TYPE_ANY; break; } return (DataType); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswexec.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswexec.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswexec.c (revision 82367) @@ -1,808 +1,808 @@ /****************************************************************************** * * Module Name: dswexec - Dispatcher method execution callbacks; * dispatch to interpreter. - * $Revision: 63 $ + * $Revision: 64 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __DSWEXEC_C__ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #include "acdispat.h" #include "acinterp.h" #include "acnamesp.h" #include "acdebug.h" #define _COMPONENT ACPI_DISPATCHER MODULE_NAME ("dswexec") /***************************************************************************** * * FUNCTION: AcpiDsGetPredicateValue * * PARAMETERS: WalkState - Current state of the parse tree walk * * RETURN: Status * * DESCRIPTION: Get the result of a predicate evaluation * ****************************************************************************/ ACPI_STATUS AcpiDsGetPredicateValue ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, UINT32 HasResultObj) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *ObjDesc; FUNCTION_TRACE_PTR ("DsGetPredicateValue", WalkState); WalkState->ControlState->Common.State = 0; if (HasResultObj) { Status = AcpiDsResultPop (&ObjDesc, WalkState); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, - ("Could not get result from predicate evaluation, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Could not get result from predicate evaluation, %s\n", AcpiFormatException (Status))); return_ACPI_STATUS (Status); } } else { Status = AcpiDsCreateOperand (WalkState, Op, 0); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } Status = AcpiExResolveToValue (&WalkState->Operands [0], WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } ObjDesc = WalkState->Operands [0]; } if (!ObjDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("No predicate ObjDesc=%X State=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No predicate ObjDesc=%X State=%X\n", ObjDesc, WalkState)); return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* * Result of predicate evaluation currently must * be a number */ if (ObjDesc->Common.Type != ACPI_TYPE_INTEGER) { - DEBUG_PRINTP (ACPI_ERROR, - ("Bad predicate (not a number) ObjDesc=%X State=%X Type=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Bad predicate (not a number) ObjDesc=%X State=%X Type=%X\n", ObjDesc, WalkState, ObjDesc->Common.Type)); Status = AE_AML_OPERAND_TYPE; goto Cleanup; } /* Truncate the predicate to 32-bits if necessary */ AcpiExTruncateFor32bitTable (ObjDesc, WalkState); /* * Save the result of the predicate evaluation on * the control stack */ if (ObjDesc->Integer.Value) { WalkState->ControlState->Common.Value = TRUE; } else { /* * Predicate is FALSE, we will just toss the * rest of the package */ WalkState->ControlState->Common.Value = FALSE; Status = AE_CTRL_FALSE; } Cleanup: - DEBUG_PRINTP (TRACE_EXEC, ("Completed a predicate eval=%X Op=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Completed a predicate eval=%X Op=%X\n", WalkState->ControlState->Common.Value, Op)); /* Break to debugger to display result */ DEBUGGER_EXEC (AcpiDbDisplayResultObject (ObjDesc, WalkState)); /* * Delete the predicate result object (we know that * we don't need it anymore) */ AcpiUtRemoveReference (ObjDesc); WalkState->ControlState->Common.State = CONTROL_NORMAL; return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiDsExecBeginOp * * PARAMETERS: WalkState - Current state of the parse tree walk * Op - Op that has been just been reached in the * walk; Arguments have not been evaluated yet. * * RETURN: Status * * DESCRIPTION: Descending callback used during the execution of control * methods. This is where most operators and operands are * dispatched to the interpreter. * ****************************************************************************/ ACPI_STATUS AcpiDsExecBeginOp ( UINT16 Opcode, ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **OutOp) { ACPI_OPCODE_INFO *OpInfo; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE_PTR ("DsExecBeginOp", Op); if (!Op) { Status = AcpiDsLoad2BeginOp (Opcode, NULL, WalkState, OutOp); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } Op = *OutOp; } if (Op == WalkState->Origin) { if (OutOp) { *OutOp = Op; } return_ACPI_STATUS (AE_OK); } /* * If the previous opcode was a conditional, this opcode * must be the beginning of the associated predicate. * Save this knowledge in the current scope descriptor */ if ((WalkState->ControlState) && (WalkState->ControlState->Common.State == CONTROL_CONDITIONAL_EXECUTING)) { - DEBUG_PRINTP (TRACE_EXEC, ("Exec predicate Op=%X State=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Exec predicate Op=%X State=%X\n", Op, WalkState)); WalkState->ControlState->Common.State = CONTROL_PREDICATE_EXECUTING; /* Save start of predicate */ WalkState->ControlState->Control.PredicateOp = Op; } OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode); /* We want to send namepaths to the load code */ if (Op->Opcode == AML_INT_NAMEPATH_OP) { OpInfo->Flags = OPTYPE_NAMED_OBJECT; } /* * Handle the opcode based upon the opcode type */ switch (ACPI_GET_OP_CLASS (OpInfo)) { case OPTYPE_CONTROL: Status = AcpiDsResultStackPush (WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } Status = AcpiDsExecBeginControlOp (WalkState, Op); break; case OPTYPE_NAMED_OBJECT: if (WalkState->WalkType == WALK_METHOD) { /* * Found a named object declaration during method * execution; we must enter this object into the * namespace. The created object is temporary and * will be deleted upon completion of the execution * of this method. */ Status = AcpiDsLoad2BeginOp (Op->Opcode, Op, WalkState, NULL); } if (Op->Opcode == AML_REGION_OP) { Status = AcpiDsResultStackPush (WalkState); } break; /* most operators with arguments */ case OPTYPE_MONADIC1: case OPTYPE_DYADIC1: case OPTYPE_MONADIC2: case OPTYPE_MONADIC2R: case OPTYPE_DYADIC2: case OPTYPE_DYADIC2R: case OPTYPE_DYADIC2S: case OPTYPE_RECONFIGURATION: case OPTYPE_TRIADIC: case OPTYPE_QUADRADIC: case OPTYPE_HEXADIC: case OPTYPE_CREATE_FIELD: /* Start a new result/operand state */ Status = AcpiDsResultStackPush (WalkState); break; default: break; } /* Nothing to do here during method execution */ return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiDsExecEndOp * * PARAMETERS: WalkState - Current state of the parse tree walk * Op - Op that has been just been completed in the * walk; Arguments have now been evaluated. * * RETURN: Status * * DESCRIPTION: Ascending callback used during the execution of control * methods. The only thing we really need to do here is to * notice the beginning of IF, ELSE, and WHILE blocks. * ****************************************************************************/ ACPI_STATUS AcpiDsExecEndOp ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status = AE_OK; UINT16 Opcode; UINT8 Optype; ACPI_PARSE_OBJECT *NextOp; ACPI_PARSE_OBJECT *FirstArg; ACPI_OPERAND_OBJECT *ResultObj = NULL; ACPI_OPCODE_INFO *OpInfo; FUNCTION_TRACE_PTR ("DsExecEndOp", Op); Opcode = (UINT16) Op->Opcode; OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode); if (ACPI_GET_OP_TYPE (OpInfo) != ACPI_OP_TYPE_OPCODE) { - DEBUG_PRINTP (ACPI_ERROR, ("Unknown opcode %X\n", Op->Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown opcode %X\n", Op->Opcode)); return_ACPI_STATUS (AE_NOT_IMPLEMENTED); } Optype = (UINT8) ACPI_GET_OP_CLASS (OpInfo); FirstArg = Op->Value.Arg; /* Init the walk state */ WalkState->NumOperands = 0; WalkState->ReturnDesc = NULL; WalkState->OpInfo = OpInfo; WalkState->Opcode = Opcode; /* Call debugger for single step support (DEBUG build only) */ DEBUGGER_EXEC (Status = AcpiDbSingleStep (WalkState, Op, Optype)); DEBUGGER_EXEC (if (ACPI_FAILURE (Status)) {return_ACPI_STATUS (Status);}); /* Decode the opcode */ switch (Optype) { case OPTYPE_UNDEFINED: - DEBUG_PRINTP (ACPI_ERROR, ("Undefined opcode type Op=%X\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Undefined opcode type Op=%X\n", Op)); return_ACPI_STATUS (AE_NOT_IMPLEMENTED); break; case OPTYPE_BOGUS: - DEBUG_PRINTP (TRACE_DISPATCH, ("Internal opcode=%X type Op=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Internal opcode=%X type Op=%X\n", Opcode, Op)); break; case OPTYPE_CONSTANT: /* argument type only */ case OPTYPE_LITERAL: /* argument type only */ case OPTYPE_DATA_TERM: /* argument type only */ case OPTYPE_LOCAL_VARIABLE: /* argument type only */ case OPTYPE_METHOD_ARGUMENT: /* argument type only */ break; /* most operators with arguments */ case OPTYPE_MONADIC1: case OPTYPE_DYADIC1: case OPTYPE_MONADIC2: case OPTYPE_MONADIC2R: case OPTYPE_DYADIC2: case OPTYPE_DYADIC2R: case OPTYPE_DYADIC2S: case OPTYPE_RECONFIGURATION: case OPTYPE_TRIADIC: case OPTYPE_QUADRADIC: case OPTYPE_HEXADIC: /* Build resolved operand stack */ Status = AcpiDsCreateOperands (WalkState, FirstArg); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* Done with this result state (Now that operand stack is built) */ Status = AcpiDsResultStackPop (WalkState); if (ACPI_FAILURE (Status)) { goto Cleanup; } switch (Optype) { case OPTYPE_MONADIC1: /* 1 Operand, 0 ExternalResult, 0 InternalResult */ Status = AcpiExMonadic1 (Opcode, WalkState); break; case OPTYPE_MONADIC2: /* 1 Operand, 0 ExternalResult, 1 InternalResult */ Status = AcpiExMonadic2 (Opcode, WalkState, &ResultObj); break; case OPTYPE_MONADIC2R: /* 1 Operand, 1 ExternalResult, 1 InternalResult */ Status = AcpiExMonadic2R (Opcode, WalkState, &ResultObj); break; case OPTYPE_DYADIC1: /* 2 Operands, 0 ExternalResult, 0 InternalResult */ Status = AcpiExDyadic1 (Opcode, WalkState); break; case OPTYPE_DYADIC2: /* 2 Operands, 0 ExternalResult, 1 InternalResult */ Status = AcpiExDyadic2 (Opcode, WalkState, &ResultObj); break; case OPTYPE_DYADIC2R: /* 2 Operands, 1 or 2 ExternalResults, 1 InternalResult */ Status = AcpiExDyadic2R (Opcode, WalkState, &ResultObj); break; case OPTYPE_DYADIC2S: /* Synchronization Operator */ /* 2 Operands, 0 ExternalResult, 1 InternalResult */ Status = AcpiExDyadic2S (Opcode, WalkState, &ResultObj); break; case OPTYPE_TRIADIC: /* Opcode with 3 operands */ /* 3 Operands, 1 ExternalResult, 1 InternalResult */ Status = AcpiExTriadic (Opcode, WalkState, &ResultObj); break; case OPTYPE_QUADRADIC: /* Opcode with 4 operands */ break; case OPTYPE_HEXADIC: /* Opcode with 6 operands */ /* 6 Operands, 0 ExternalResult, 1 InternalResult */ Status = AcpiExHexadic (Opcode, WalkState, &ResultObj); break; case OPTYPE_RECONFIGURATION: /* 1 or 2 operands, 0 Internal Result */ Status = AcpiExReconfiguration (Opcode, WalkState); break; } /* * If a result object was returned from above, push it on the * current result stack */ if (ACPI_SUCCESS (Status) && ResultObj) { Status = AcpiDsResultPush (ResultObj, WalkState); } break; case OPTYPE_CONTROL: /* Type 1 opcode, IF/ELSE/WHILE/NOOP */ /* 1 Operand, 0 ExternalResult, 0 InternalResult */ Status = AcpiDsExecEndControlOp (WalkState, Op); AcpiDsResultStackPop (WalkState); break; case OPTYPE_METHOD_CALL: - DEBUG_PRINTP (TRACE_DISPATCH, ("Method invocation, Op=%X\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Method invocation, Op=%X\n", Op)); /* * (AML_METHODCALL) Op->Value->Arg->Node contains * the method Node pointer */ /* NextOp points to the op that holds the method name */ NextOp = FirstArg; /* NextOp points to first argument op */ NextOp = NextOp->Next; /* * Get the method's arguments and put them on the operand stack */ Status = AcpiDsCreateOperands (WalkState, NextOp); if (ACPI_FAILURE (Status)) { break; } /* * Since the operands will be passed to another * control method, we must resolve all local * references here (Local variables, arguments * to *this* method, etc.) */ Status = AcpiDsResolveOperands (WalkState); if (ACPI_FAILURE (Status)) { break; } /* * Tell the walk loop to preempt this running method and * execute the new method */ Status = AE_CTRL_TRANSFER; /* * Return now; we don't want to disturb anything, * especially the operand count! */ return_ACPI_STATUS (Status); break; case OPTYPE_CREATE_FIELD: - DEBUG_PRINTP (TRACE_EXEC, - ("Executing CreateField Buffer/Index Op=%X\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, + "Executing CreateField Buffer/Index Op=%X\n", Op)); Status = AcpiDsLoad2EndOp (WalkState, Op); if (ACPI_FAILURE (Status)) { break; } Status = AcpiDsEvalBufferFieldOperands (WalkState, Op); break; case OPTYPE_NAMED_OBJECT: Status = AcpiDsLoad2EndOp (WalkState, Op); if (ACPI_FAILURE (Status)) { break; } switch (Op->Opcode) { case AML_REGION_OP: - DEBUG_PRINTP (TRACE_EXEC, - ("Executing OpRegion Address/Length Op=%X\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, + "Executing OpRegion Address/Length Op=%X\n", Op)); Status = AcpiDsEvalRegionOperands (WalkState, Op); if (ACPI_FAILURE (Status)) { break; } Status = AcpiDsResultStackPop (WalkState); break; case AML_METHOD_OP: break; case AML_ALIAS_OP: /* Alias creation was already handled by call to psxload above */ break; default: /* Nothing needs to be done */ Status = AE_OK; break; } break; default: - DEBUG_PRINTP (ACPI_ERROR, - ("Unimplemented opcode, type=%X Opcode=%X Op=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Unimplemented opcode, type=%X Opcode=%X Op=%X\n", Optype, Op->Opcode, Op)); Status = AE_NOT_IMPLEMENTED; break; } /* * ACPI 2.0 support for 64-bit integers: * Truncate numeric result value if we are executing from a 32-bit ACPI table */ AcpiExTruncateFor32bitTable (ResultObj, WalkState); /* * Check if we just completed the evaluation of a * conditional predicate */ if ((WalkState->ControlState) && (WalkState->ControlState->Common.State == CONTROL_PREDICATE_EXECUTING) && (WalkState->ControlState->Control.PredicateOp == Op)) { Status = AcpiDsGetPredicateValue (WalkState, Op, (UINT32) ResultObj); ResultObj = NULL; } Cleanup: if (ResultObj) { /* Break to debugger to display result */ DEBUGGER_EXEC (AcpiDbDisplayResultObject (ResultObj, WalkState)); /* * Delete the result op if and only if: * Parent will not use the result -- such as any * non-nested type2 op in a method (parent will be method) */ AcpiDsDeleteResultIfNotUsed (Op, ResultObj, WalkState); } /* Always clear the object stack */ /* TBD: [Investigate] Clear stack of return value, but don't delete it */ WalkState->NumOperands = 0; return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswload.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswload.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswload.c (revision 82367) @@ -1,918 +1,913 @@ /****************************************************************************** * * Module Name: dswload - Dispatcher namespace load callbacks - * $Revision: 37 $ + * $Revision: 40 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __DSWLOAD_C__ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #include "acdispat.h" #include "acinterp.h" #include "acnamesp.h" #include "acevents.h" #define _COMPONENT ACPI_DISPATCHER MODULE_NAME ("dswload") /******************************************************************************* * * FUNCTION: AcpiDsLoad1BeginOp * * PARAMETERS: WalkState - Current state of the parse tree walk * Op - Op that has been just been reached in the * walk; Arguments have not been evaluated yet. * * RETURN: Status * * DESCRIPTION: Descending callback used during the loading of ACPI tables. * ******************************************************************************/ ACPI_STATUS AcpiDsLoad1BeginOp ( UINT16 Opcode, ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **OutOp) { ACPI_NAMESPACE_NODE *Node; ACPI_STATUS Status; ACPI_OBJECT_TYPE8 DataType; NATIVE_CHAR *Path; PROC_NAME ("DsLoad1BeginOp"); - DEBUG_PRINTP (TRACE_DISPATCH, ("Op=%p State=%p\n", Op, WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState)); /* We are only interested in opcodes that have an associated name */ if (!AcpiPsIsNamedOp (Opcode)) { *OutOp = Op; return (AE_OK); } /* Check if this object has already been installed in the namespace */ if (Op && Op->Node) { *OutOp = Op; return (AE_OK); } Path = AcpiPsGetNextNamestring (WalkState->ParserState); /* Map the raw opcode into an internal object type */ DataType = AcpiDsMapNamedOpcodeToDataType (Opcode); - DEBUG_PRINTP (TRACE_DISPATCH, - ("State=%p Op=%p Type=%x\n", WalkState, Op, DataType)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "State=%p Op=%p Type=%x\n", WalkState, Op, DataType)); if (Opcode == AML_SCOPE_OP) { - DEBUG_PRINTP (TRACE_DISPATCH, - ("State=%p Op=%p Type=%x\n", WalkState, Op, DataType)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "State=%p Op=%p Type=%x\n", WalkState, Op, DataType)); } /* * Enter the named type into the internal namespace. We enter the name * as we go downward in the parse tree. Any necessary subobjects that involve * arguments to the opcode must be created as we go back up the parse tree later. */ Status = AcpiNsLookup (WalkState->ScopeInfo, Path, DataType, IMODE_LOAD_PASS1, NS_NO_UPSEARCH, WalkState, &(Node)); if (ACPI_FAILURE (Status)) { return (Status); } if (!Op) { /* Create a new op */ Op = AcpiPsAllocOp (Opcode); if (!Op) { return (AE_NO_MEMORY); } } /* Initialize */ ((ACPI_PARSE2_OBJECT *)Op)->Name = Node->Name; /* * Put the Node in the "op" object that the parser uses, so we * can get it again quickly when this scope is closed */ Op->Node = Node; AcpiPsAppendArg (AcpiPsGetParentScope (WalkState->ParserState), Op); *OutOp = Op; return (Status); } /******************************************************************************* * * FUNCTION: AcpiDsLoad1EndOp * * PARAMETERS: WalkState - Current state of the parse tree walk * Op - Op that has been just been completed in the * walk; Arguments have now been evaluated. * * RETURN: Status * * DESCRIPTION: Ascending callback used during the loading of the namespace, * both control methods and everything else. * ******************************************************************************/ ACPI_STATUS AcpiDsLoad1EndOp ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { ACPI_OBJECT_TYPE8 DataType; PROC_NAME ("DsLoad1EndOp"); - DEBUG_PRINT (TRACE_DISPATCH, ("Op=%p State=%p\n", Op, WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState)); /* We are only interested in opcodes that have an associated name */ if (!AcpiPsIsNamedOp (Op->Opcode)) { return (AE_OK); } /* Get the type to determine if we should pop the scope */ DataType = AcpiDsMapNamedOpcodeToDataType (Op->Opcode); if (Op->Opcode == AML_NAME_OP) { /* For Name opcode, check the argument */ if (Op->Value.Arg) { DataType = AcpiDsMapOpcodeToDataType ( (Op->Value.Arg)->Opcode, NULL); ((ACPI_NAMESPACE_NODE *)Op->Node)->Type = (UINT8) DataType; } } /* Pop the scope stack */ if (AcpiNsOpensScope (DataType)) { - DEBUG_PRINTP (TRACE_DISPATCH, ("(%s): Popping scope for Op %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s): Popping scope for Op %p\n", AcpiUtGetTypeName (DataType), Op)); AcpiDsScopeStackPop (WalkState); } return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsLoad2BeginOp * * PARAMETERS: WalkState - Current state of the parse tree walk * Op - Op that has been just been reached in the * walk; Arguments have not been evaluated yet. * * RETURN: Status * * DESCRIPTION: Descending callback used during the loading of ACPI tables. * ******************************************************************************/ ACPI_STATUS AcpiDsLoad2BeginOp ( UINT16 Opcode, ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **OutOp) { ACPI_NAMESPACE_NODE *Node; ACPI_STATUS Status; ACPI_OBJECT_TYPE8 DataType; NATIVE_CHAR *BufferPtr; void *Original = NULL; PROC_NAME ("DsLoad2BeginOp"); - DEBUG_PRINTP (TRACE_DISPATCH, ("Op=%p State=%p\n", Op, WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState)); /* We only care about Namespace opcodes here */ if (!AcpiPsIsNamespaceOp (Opcode) && Opcode != AML_INT_NAMEPATH_OP) { return (AE_OK); } /* Temp! same code as in psparse */ if (!AcpiPsIsNamedOp (Opcode)) { return (AE_OK); } if (Op) { /* * Get the name we are going to enter or lookup in the namespace */ if (Opcode == AML_INT_NAMEPATH_OP) { /* For Namepath op, get the path string */ BufferPtr = Op->Value.String; if (!BufferPtr) { /* No name, just exit */ return (AE_OK); } } else { /* Get name from the op */ BufferPtr = (NATIVE_CHAR *) &((ACPI_PARSE2_OBJECT *)Op)->Name; } } else { BufferPtr = AcpiPsGetNextNamestring (WalkState->ParserState); } /* Map the raw opcode into an internal object type */ DataType = AcpiDsMapNamedOpcodeToDataType (Opcode); - DEBUG_PRINTP (TRACE_DISPATCH, - ("State=%p Op=%p Type=%x\n", WalkState, Op, DataType)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "State=%p Op=%p Type=%x\n", WalkState, Op, DataType)); if (Opcode == AML_FIELD_OP || Opcode == AML_BANK_FIELD_OP || Opcode == AML_INDEX_FIELD_OP) { Node = NULL; Status = AE_OK; } else if (Opcode == AML_INT_NAMEPATH_OP) { /* * The NamePath is an object reference to an existing object. Don't enter the * name into the namespace, but look it up for use later */ - Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, - DataType, IMODE_EXECUTE, - NS_SEARCH_PARENT, WalkState, - &(Node)); + Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, DataType, + IMODE_EXECUTE, NS_SEARCH_PARENT, WalkState, &(Node)); } else { if (Op && Op->Node) { Original = Op->Node; Node = Op->Node; if (AcpiNsOpensScope (DataType)) { - Status = AcpiDsScopeStackPush (Node, - DataType, - WalkState); + Status = AcpiDsScopeStackPush (Node, DataType, WalkState); if (ACPI_FAILURE (Status)) { return (Status); } } return (AE_OK); } /* * Enter the named type into the internal namespace. We enter the name * as we go downward in the parse tree. Any necessary subobjects that involve * arguments to the opcode must be created as we go back up the parse tree later. */ Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, DataType, IMODE_EXECUTE, NS_NO_UPSEARCH, WalkState, &(Node)); } if (ACPI_SUCCESS (Status)) { if (!Op) { /* Create a new op */ Op = AcpiPsAllocOp (Opcode); if (!Op) { return (AE_NO_MEMORY); } /* Initialize */ ((ACPI_PARSE2_OBJECT *)Op)->Name = Node->Name; *OutOp = Op; } /* * Put the Node in the "op" object that the parser uses, so we * can get it again quickly when this scope is closed */ Op->Node = Node; if (Original) { - DEBUG_PRINTP (ACPI_INFO, ("old %p new %p\n", Original, Node)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "old %p new %p\n", Original, Node)); if (Original != Node) { - DEBUG_PRINTP (ACPI_INFO, - ("Lookup match error: old %p new %p\n", Original, Node)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Lookup match error: old %p new %p\n", Original, Node)); } } } return (Status); } /******************************************************************************* * * FUNCTION: AcpiDsLoad2EndOp * * PARAMETERS: WalkState - Current state of the parse tree walk * Op - Op that has been just been completed in the * walk; Arguments have now been evaluated. * * RETURN: Status * * DESCRIPTION: Ascending callback used during the loading of the namespace, * both control methods and everything else. * ******************************************************************************/ ACPI_STATUS AcpiDsLoad2EndOp ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status = AE_OK; ACPI_OBJECT_TYPE8 DataType; ACPI_NAMESPACE_NODE *Node; ACPI_PARSE_OBJECT *Arg; ACPI_NAMESPACE_NODE *NewNode; PROC_NAME ("DsLoad2EndOp"); - DEBUG_PRINTP (TRACE_DISPATCH, ("Op=%p State=%p\n", Op, WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState)); if (!AcpiPsIsNamespaceObjectOp (Op->Opcode)) { return (AE_OK); } if (Op->Opcode == AML_SCOPE_OP) { - DEBUG_PRINTP (TRACE_DISPATCH, - ("Ending scope Op=%p State=%p\n", Op, WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "Ending scope Op=%p State=%p\n", Op, WalkState)); if (((ACPI_PARSE2_OBJECT *)Op)->Name == -1) { - DEBUG_PRINTP (ACPI_ERROR, ("Unnamed scope! Op=%p State=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unnamed scope! Op=%p State=%p\n", Op, WalkState)); return (AE_OK); } } DataType = AcpiDsMapNamedOpcodeToDataType (Op->Opcode); /* * Get the Node/name from the earlier lookup * (It was saved in the *op structure) */ Node = Op->Node; /* * Put the Node on the object stack (Contains the ACPI Name of * this object) */ WalkState->Operands[0] = (void *) Node; WalkState->NumOperands = 1; /* Pop the scope stack */ if (AcpiNsOpensScope (DataType)) { - DEBUG_PRINTP (TRACE_DISPATCH, ("(%s) Popping scope for Op %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s) Popping scope for Op %p\n", AcpiUtGetTypeName (DataType), Op)); AcpiDsScopeStackPop (WalkState); } /* * Named operations are as follows: * * AML_SCOPE * AML_DEVICE * AML_THERMALZONE * AML_METHOD * AML_POWERRES * AML_PROCESSOR * AML_FIELD * AML_INDEXFIELD * AML_BANKFIELD * AML_NAMEDFIELD * AML_NAME * AML_ALIAS * AML_MUTEX * AML_EVENT * AML_OPREGION * AML_CREATEFIELD * AML_CREATEBITFIELD * AML_CREATEBYTEFIELD * AML_CREATEWORDFIELD * AML_CREATEDWORDFIELD * AML_CREATEQWORDFIELD * AML_METHODCALL */ /* Decode the opcode */ Arg = Op->Value.Arg; switch (Op->Opcode) { case AML_CREATE_FIELD_OP: case AML_CREATE_BIT_FIELD_OP: case AML_CREATE_BYTE_FIELD_OP: case AML_CREATE_WORD_FIELD_OP: case AML_CREATE_DWORD_FIELD_OP: case AML_CREATE_QWORD_FIELD_OP: /* * Create the field object, but the field buffer and index must * be evaluated later during the execution phase */ - DEBUG_PRINTP (TRACE_DISPATCH, - ("CreateXxxField: State=%p Op=%p NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "CreateXxxField: State=%p Op=%p NamedObj=%p\n", WalkState, Op, Node)); /* Get the NameString argument */ if (Op->Opcode == AML_CREATE_FIELD_OP) { Arg = AcpiPsGetArg (Op, 3); } else { /* Create Bit/Byte/Word/Dword field */ Arg = AcpiPsGetArg (Op, 2); } if (!Arg) { Status = AE_AML_NO_OPERAND; goto Cleanup; } /* * Enter the NameString into the namespace */ Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Value.String, INTERNAL_TYPE_DEF_ANY, IMODE_LOAD_PASS1, NS_NO_UPSEARCH | NS_DONT_OPEN_SCOPE, WalkState, &(NewNode)); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* We could put the returned object (Node) on the object stack for later, but * for now, we will put it in the "op" object that the parser uses, so we * can get it again at the end of this scope */ Op->Node = NewNode; /* * If there is no object attached to the node, this node was just created and * we need to create the field object. Otherwise, this was a lookup of an * existing node and we don't want to create the field object again. */ if (!NewNode->Object) { /* * The Field definition is not fully parsed at this time. * (We must save the address of the AML for the buffer and index operands) */ Status = AcpiExCreateBufferField (((ACPI_PARSE2_OBJECT *) Op)->Data, ((ACPI_PARSE2_OBJECT *) Op)->Length, NewNode, WalkState); } break; case AML_INT_METHODCALL_OP: - DEBUG_PRINTP (TRACE_DISPATCH, - ("RESOLVING-MethodCall: State=%p Op=%p NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "RESOLVING-MethodCall: State=%p Op=%p NamedObj=%p\n", WalkState, Op, Node)); /* * Lookup the method name and save the Node */ Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Value.String, ACPI_TYPE_ANY, IMODE_LOAD_PASS2, NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE, WalkState, &(NewNode)); if (ACPI_SUCCESS (Status)) { /* TBD: has name already been resolved by here ??*/ /* TBD: [Restructure] Make sure that what we found is indeed a method! */ /* We didn't search for a method on purpose, to see if the name would resolve! */ /* We could put the returned object (Node) on the object stack for later, but * for now, we will put it in the "op" object that the parser uses, so we * can get it again at the end of this scope */ Op->Node = NewNode; } break; case AML_PROCESSOR_OP: /* Nothing to do other than enter object into namespace */ - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-Processor: State=%p Op=%p NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-Processor: State=%p Op=%p NamedObj=%p\n", WalkState, Op, Node)); Status = AcpiExCreateProcessor (Op, Node); if (ACPI_FAILURE (Status)) { goto Cleanup; } - DEBUG_PRINT (TRACE_DISPATCH, - ("Completed Processor Init, Op=%p State=%p entry=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "Completed Processor Init, Op=%p State=%p entry=%p\n", Op, WalkState, Node)); break; case AML_POWER_RES_OP: /* Nothing to do other than enter object into namespace */ - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-PowerResource: State=%p Op=%p NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-PowerResource: State=%p Op=%p NamedObj=%p\n", WalkState, Op, Node)); Status = AcpiExCreatePowerResource (Op, Node); if (ACPI_FAILURE (Status)) { goto Cleanup; } - DEBUG_PRINT (TRACE_DISPATCH, - ("Completed PowerResource Init, Op=%p State=%p entry=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "Completed PowerResource Init, Op=%p State=%p entry=%p\n", Op, WalkState, Node)); break; case AML_THERMAL_ZONE_OP: /* Nothing to do other than enter object into namespace */ - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-ThermalZone: State=%p Op=%p NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-ThermalZone: State=%p Op=%p NamedObj=%p\n", WalkState, Op, Node)); break; case AML_FIELD_OP: - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-Field: State=%p Op=%p NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-Field: State=%p Op=%p NamedObj=%p\n", WalkState, Op, Node)); Arg = Op->Value.Arg; Status = AcpiDsCreateField (Op, Arg->Node, WalkState); break; case AML_INDEX_FIELD_OP: - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-IndexField: State=%p Op=%p NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-IndexField: State=%p Op=%p NamedObj=%p\n", WalkState, Op, Node)); Arg = Op->Value.Arg; Status = AcpiDsCreateIndexField (Op, (ACPI_HANDLE) Arg->Node, WalkState); break; case AML_BANK_FIELD_OP: - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-BankField: State=%p Op=%p NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-BankField: State=%p Op=%p NamedObj=%p\n", WalkState, Op, Node)); Arg = Op->Value.Arg; Status = AcpiDsCreateBankField (Op, Arg->Node, WalkState); break; /* * MethodOp PkgLength NamesString MethodFlags TermList */ case AML_METHOD_OP: - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-Method: State=%p Op=%p NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-Method: State=%p Op=%p NamedObj=%p\n", WalkState, Op, Node)); if (!Node->Object) { Status = AcpiExCreateMethod (((ACPI_PARSE2_OBJECT *) Op)->Data, ((ACPI_PARSE2_OBJECT *) Op)->Length, - Arg->Value.Integer, Node); + Arg->Value.Integer32, Node); } break; case AML_MUTEX_OP: - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-Mutex: Op=%p State=%p\n", Op, WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-Mutex: Op=%p State=%p\n", Op, WalkState)); Status = AcpiDsCreateOperands (WalkState, Arg); if (ACPI_FAILURE (Status)) { goto Cleanup; } Status = AcpiExCreateMutex (WalkState); break; case AML_EVENT_OP: - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-Event: Op=%p State=%p\n", Op, WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-Event: Op=%p State=%p\n", Op, WalkState)); Status = AcpiDsCreateOperands (WalkState, Arg); if (ACPI_FAILURE (Status)) { goto Cleanup; } Status = AcpiExCreateEvent (WalkState); break; case AML_REGION_OP: if (Node->Object) { break; } - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-Opregion: Op=%p State=%p NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-Opregion: Op=%p State=%p NamedObj=%p\n", Op, WalkState, Node)); /* * The OpRegion is not fully parsed at this time. Only valid argument is the SpaceId. * (We must save the address of the AML of the address and length operands) */ Status = AcpiExCreateRegion (((ACPI_PARSE2_OBJECT *) Op)->Data, ((ACPI_PARSE2_OBJECT *) Op)->Length, (ACPI_ADR_SPACE_TYPE) Arg->Value.Integer, WalkState); - DEBUG_PRINT (TRACE_DISPATCH, - ("Completed OpRegion Init, Op=%p State=%p entry=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "Completed OpRegion Init, Op=%p State=%p entry=%p\n", Op, WalkState, Node)); break; /* Namespace Modifier Opcodes */ case AML_ALIAS_OP: - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-Alias: Op=%p State=%p\n", Op, WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-Alias: Op=%p State=%p\n", Op, WalkState)); Status = AcpiDsCreateOperands (WalkState, Arg); if (ACPI_FAILURE (Status)) { goto Cleanup; } Status = AcpiExCreateAlias (WalkState); break; case AML_NAME_OP: - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-Name: Op=%p State=%p\n", Op, WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-Name: Op=%p State=%p\n", Op, WalkState)); /* * Because of the execution pass through the non-control-method * parts of the table, we can arrive here twice. Only init * the named object node the first time through */ - if (!Node->Object) { Status = AcpiDsCreateNode (WalkState, Node, Op); } break; case AML_INT_NAMEPATH_OP: - DEBUG_PRINTP (TRACE_DISPATCH, - ("LOADING-NamePath object: State=%p Op=%p NamedObj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "LOADING-NamePath object: State=%p Op=%p NamedObj=%p\n", WalkState, Op, Node)); break; default: break; } Cleanup: /* Remove the Node pushed at the very beginning */ AcpiDsObjStackPop (1, WalkState); return (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswscope.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswscope.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswscope.c (revision 82367) @@ -1,268 +1,270 @@ /****************************************************************************** * * Module Name: dswscope - Scope stack manipulation - * $Revision: 45 $ + * $Revision: 46 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __DSWSCOPE_C__ #include "acpi.h" #include "acinterp.h" #include "acdispat.h" #define _COMPONENT ACPI_DISPATCHER MODULE_NAME ("dswscope") #define STACK_POP(head) head /**************************************************************************** * * FUNCTION: AcpiDsScopeStackClear * * PARAMETERS: None * * DESCRIPTION: Pop (and free) everything on the scope stack except the * root scope object (which remains at the stack top.) * ***************************************************************************/ void AcpiDsScopeStackClear ( ACPI_WALK_STATE *WalkState) { ACPI_GENERIC_STATE *ScopeInfo; + PROC_NAME ("AcpiDsScopeStackClear"); + while (WalkState->ScopeInfo) { /* Pop a scope off the stack */ ScopeInfo = WalkState->ScopeInfo; WalkState->ScopeInfo = ScopeInfo->Scope.Next; - DEBUG_PRINT (TRACE_EXEC, - ("Popped object type %X\n", ScopeInfo->Common.Value)); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, + "Popped object type %X\n", ScopeInfo->Common.Value)); AcpiUtDeleteGenericState (ScopeInfo); } } /**************************************************************************** * * FUNCTION: AcpiDsScopeStackPush * * PARAMETERS: *Node, - Name to be made current * Type, - Type of frame being pushed * * DESCRIPTION: Push the current scope on the scope stack, and make the * passed Node current. * ***************************************************************************/ ACPI_STATUS AcpiDsScopeStackPush ( ACPI_NAMESPACE_NODE *Node, ACPI_OBJECT_TYPE8 Type, ACPI_WALK_STATE *WalkState) { ACPI_GENERIC_STATE *ScopeInfo; FUNCTION_TRACE ("DsScopeStackPush"); if (!Node) { /* invalid scope */ REPORT_ERROR (("DsScopeStackPush: null scope passed\n")); return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Make sure object type is valid */ if (!AcpiExValidateObjectType (Type)) { REPORT_WARNING (("DsScopeStackPush: type code out of range\n")); } /* Allocate a new scope object */ ScopeInfo = AcpiUtCreateGenericState (); if (!ScopeInfo) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Init new scope object */ ScopeInfo->Scope.Node = Node; ScopeInfo->Common.Value = (UINT16) Type; /* Push new scope object onto stack */ AcpiUtPushGenericState (&WalkState->ScopeInfo, ScopeInfo); return_ACPI_STATUS (AE_OK); } /**************************************************************************** * * FUNCTION: AcpiDsScopeStackPop * * PARAMETERS: Type - The type of frame to be found * * DESCRIPTION: Pop the scope stack until a frame of the requested type * is found. * * RETURN: Count of frames popped. If no frame of the requested type * was found, the count is returned as a negative number and * the scope stack is emptied (which sets the current scope * to the root). If the scope stack was empty at entry, the * function is a no-op and returns 0. * ***************************************************************************/ ACPI_STATUS AcpiDsScopeStackPop ( ACPI_WALK_STATE *WalkState) { ACPI_GENERIC_STATE *ScopeInfo; FUNCTION_TRACE ("DsScopeStackPop"); /* * Pop scope info object off the stack. */ ScopeInfo = AcpiUtPopGenericState (&WalkState->ScopeInfo); if (!ScopeInfo) { return_ACPI_STATUS (AE_STACK_UNDERFLOW); } - DEBUG_PRINT (TRACE_EXEC, - ("Popped object type %X\n", ScopeInfo->Common.Value)); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, + "Popped object type %X\n", ScopeInfo->Common.Value)); AcpiUtDeleteGenericState (ScopeInfo); return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswstate.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswstate.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/dswstate.c (revision 82367) @@ -1,1150 +1,1091 @@ /****************************************************************************** * * Module Name: dswstate - Dispatcher parse tree walk management routines - * $Revision: 46 $ + * $Revision: 48 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __DSWSTATE_C__ #include "acpi.h" #include "amlcode.h" #include "acparser.h" #include "acdispat.h" #include "acnamesp.h" #include "acinterp.h" #define _COMPONENT ACPI_DISPATCHER MODULE_NAME ("dswstate") /******************************************************************************* * * FUNCTION: AcpiDsResultInsert * * PARAMETERS: Object - Object to push * WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: Push an object onto this walk's result stack * ******************************************************************************/ ACPI_STATUS AcpiDsResultInsert ( void *Object, UINT32 Index, ACPI_WALK_STATE *WalkState) { ACPI_GENERIC_STATE *State; PROC_NAME ("DsResultInsert"); State = WalkState->Results; if (!State) { - DEBUG_PRINTP (ACPI_ERROR, ("No result object pushed! State=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No result object pushed! State=%p\n", WalkState)); return (AE_NOT_EXIST); } if (Index >= OBJ_NUM_OPERANDS) { - DEBUG_PRINTP (ACPI_ERROR, - ("Index out of range: %X Obj=%p State=%p Num=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Index out of range: %X Obj=%p State=%p Num=%X\n", Index, Object, WalkState, State->Results.NumResults)); return (AE_BAD_PARAMETER); } if (!Object) { - DEBUG_PRINTP (ACPI_ERROR, - ("Null Object! Index=%X Obj=%p State=%p Num=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Null Object! Index=%X Obj=%p State=%p Num=%X\n", Index, Object, WalkState, State->Results.NumResults)); return (AE_BAD_PARAMETER); } State->Results.ObjDesc [Index] = Object; State->Results.NumResults++; - DEBUG_PRINTP (TRACE_EXEC, - ("Obj=%p [%s] State=%p Num=%X Cur=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, + "Obj=%p [%s] State=%p Num=%X Cur=%X\n", Object, Object ? AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *) Object)->Common.Type) : "NULL", WalkState, State->Results.NumResults, WalkState->CurrentResult)); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsResultRemove * * PARAMETERS: Object - Where to return the popped object * WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: Pop an object off the bottom of this walk's result stack. In * other words, this is a FIFO. * ******************************************************************************/ ACPI_STATUS AcpiDsResultRemove ( ACPI_OPERAND_OBJECT **Object, UINT32 Index, ACPI_WALK_STATE *WalkState) { ACPI_GENERIC_STATE *State; PROC_NAME ("DsResultRemove"); State = WalkState->Results; if (!State) { - DEBUG_PRINTP (ACPI_ERROR, ("No result object pushed! State=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No result object pushed! State=%p\n", WalkState)); return (AE_NOT_EXIST); } if (Index >= OBJ_NUM_OPERANDS) { - DEBUG_PRINTP (ACPI_ERROR, - ("Index out of range: %X State=%p Num=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Index out of range: %X State=%p Num=%X\n", Index, WalkState, State->Results.NumResults)); } /* Check for a valid result object */ if (!State->Results.ObjDesc [Index]) { - DEBUG_PRINTP (ACPI_ERROR, - ("Null operand! State=%p #Ops=%X, Index=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Null operand! State=%p #Ops=%X, Index=%X\n", WalkState, State->Results.NumResults, Index)); return (AE_AML_NO_RETURN_VALUE); } /* Remove the object */ State->Results.NumResults--; *Object = State->Results.ObjDesc [Index]; State->Results.ObjDesc [Index] = NULL; - DEBUG_PRINTP (TRACE_EXEC, - ("Obj=%p [%s] Index=%X State=%p Num=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, + "Obj=%p [%s] Index=%X State=%p Num=%X\n", *Object, (*Object) ? AcpiUtGetTypeName ((*Object)->Common.Type) : "NULL", Index, WalkState, State->Results.NumResults)); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsResultPop * * PARAMETERS: Object - Where to return the popped object * WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: Pop an object off the bottom of this walk's result stack. In * other words, this is a FIFO. * ******************************************************************************/ ACPI_STATUS AcpiDsResultPop ( ACPI_OPERAND_OBJECT **Object, ACPI_WALK_STATE *WalkState) { UINT32 Index; ACPI_GENERIC_STATE *State; PROC_NAME ("DsResultPop"); State = WalkState->Results; if (!State) { return (AE_OK); } if (!State->Results.NumResults) { - DEBUG_PRINTP (ACPI_ERROR, ("Result stack is empty! State=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Result stack is empty! State=%p\n", WalkState)); return (AE_AML_NO_RETURN_VALUE); } /* Remove top element */ State->Results.NumResults--; for (Index = OBJ_NUM_OPERANDS; Index; Index--) { /* Check for a valid result object */ if (State->Results.ObjDesc [Index -1]) { *Object = State->Results.ObjDesc [Index -1]; State->Results.ObjDesc [Index -1] = NULL; - DEBUG_PRINTP (TRACE_EXEC, ("Obj=%p [%s] Index=%X State=%p Num=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p [%s] Index=%X State=%p Num=%X\n", *Object, (*Object) ? AcpiUtGetTypeName ((*Object)->Common.Type) : "NULL", Index -1, WalkState, State->Results.NumResults)); return (AE_OK); } } - DEBUG_PRINTP (ACPI_ERROR, ("No result objects! State=%p\n", WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No result objects! State=%p\n", WalkState)); return (AE_AML_NO_RETURN_VALUE); } /******************************************************************************* * * FUNCTION: AcpiDsResultPopFromBottom * * PARAMETERS: Object - Where to return the popped object * WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: Pop an object off the bottom of this walk's result stack. In * other words, this is a FIFO. * ******************************************************************************/ ACPI_STATUS AcpiDsResultPopFromBottom ( ACPI_OPERAND_OBJECT **Object, ACPI_WALK_STATE *WalkState) { UINT32 Index; ACPI_GENERIC_STATE *State; PROC_NAME ("DsResultPopFromBottom"); State = WalkState->Results; if (!State) { - DEBUG_PRINTP (ACPI_ERROR, - ("Warning: No result object pushed! State=%p\n", WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Warning: No result object pushed! State=%p\n", WalkState)); return (AE_NOT_EXIST); } if (!State->Results.NumResults) { - DEBUG_PRINTP (ACPI_ERROR, ("No result objects! State=%p\n", WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No result objects! State=%p\n", WalkState)); return (AE_AML_NO_RETURN_VALUE); } /* Remove Bottom element */ *Object = State->Results.ObjDesc [0]; /* Push entire stack down one element */ for (Index = 0; Index < State->Results.NumResults; Index++) { State->Results.ObjDesc [Index] = State->Results.ObjDesc [Index + 1]; } State->Results.NumResults--; /* Check for a valid result object */ if (!*Object) { - DEBUG_PRINTP (ACPI_ERROR, ("Null operand! State=%p #Ops=%X, Index=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null operand! State=%p #Ops=%X, Index=%X\n", WalkState, State->Results.NumResults, Index)); return (AE_AML_NO_RETURN_VALUE); } - DEBUG_PRINTP (TRACE_EXEC, ("Obj=%p [%s], Results=%p State=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p [%s], Results=%p State=%p\n", *Object, (*Object) ? AcpiUtGetTypeName ((*Object)->Common.Type) : "NULL", State, WalkState)); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsResultPush * * PARAMETERS: Object - Where to return the popped object * WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: Push an object onto the current result stack * ******************************************************************************/ ACPI_STATUS AcpiDsResultPush ( ACPI_OPERAND_OBJECT *Object, ACPI_WALK_STATE *WalkState) { ACPI_GENERIC_STATE *State; PROC_NAME ("DsResultPush"); State = WalkState->Results; if (!State) { - DEBUG_PRINTP (ACPI_ERROR, ("No result stack frame\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No result stack frame\n")); return (AE_AML_INTERNAL); } if (State->Results.NumResults == OBJ_NUM_OPERANDS) { - DEBUG_PRINTP (ACPI_ERROR, - ("Result stack overflow: Obj=%p State=%p Num=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Result stack overflow: Obj=%p State=%p Num=%X\n", Object, WalkState, State->Results.NumResults)); return (AE_STACK_OVERFLOW); } if (!Object) { - DEBUG_PRINTP (ACPI_ERROR, ("Null Object! Obj=%p State=%p Num=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null Object! Obj=%p State=%p Num=%X\n", Object, WalkState, State->Results.NumResults)); return (AE_BAD_PARAMETER); } State->Results.ObjDesc [State->Results.NumResults] = Object; State->Results.NumResults++; - DEBUG_PRINTP (TRACE_EXEC, ("Obj=%p [%s] State=%p Num=%X Cur=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p [%s] State=%p Num=%X Cur=%X\n", Object, Object ? AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *) Object)->Common.Type) : "NULL", WalkState, State->Results.NumResults, WalkState->CurrentResult)); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsResultStackPush * * PARAMETERS: Object - Object to push * WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: * ******************************************************************************/ ACPI_STATUS AcpiDsResultStackPush ( ACPI_WALK_STATE *WalkState) { ACPI_GENERIC_STATE *State; + PROC_NAME ("DsResultStackPush"); + State = AcpiUtCreateGenericState (); if (!State) { return (AE_NO_MEMORY); } AcpiUtPushGenericState (&WalkState->Results, State); - DEBUG_PRINT (TRACE_EXEC, ("DsResultStackPush: Results=%p State=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Results=%p State=%p\n", State, WalkState)); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsResultStackPop * * PARAMETERS: WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: * ******************************************************************************/ ACPI_STATUS AcpiDsResultStackPop ( ACPI_WALK_STATE *WalkState) { ACPI_GENERIC_STATE *State; + PROC_NAME ("DsResultStackPop"); + /* Check for stack underflow */ if (WalkState->Results == NULL) { - DEBUG_PRINT (TRACE_EXEC, ("DsResultStackPop: Underflow - State=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Underflow - State=%p\n", WalkState)); return (AE_AML_NO_OPERAND); } State = AcpiUtPopGenericState (&WalkState->Results); - DEBUG_PRINT (TRACE_EXEC, - ("DsResultStackPop: Result=%p RemainingResults=%X State=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, + "Result=%p RemainingResults=%X State=%p\n", State, State->Results.NumResults, WalkState)); AcpiUtDeleteGenericState (State); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsObjStackDeleteAll * * PARAMETERS: WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: Clear the object stack by deleting all objects that are on it. * Should be used with great care, if at all! * ******************************************************************************/ ACPI_STATUS AcpiDsObjStackDeleteAll ( ACPI_WALK_STATE *WalkState) { UINT32 i; FUNCTION_TRACE_PTR ("DsObjStackDeleteAll", WalkState); /* The stack size is configurable, but fixed */ for (i = 0; i < OBJ_NUM_OPERANDS; i++) { if (WalkState->Operands[i]) { AcpiUtRemoveReference (WalkState->Operands[i]); WalkState->Operands[i] = NULL; } } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsObjStackPush * * PARAMETERS: Object - Object to push * WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: Push an object onto this walk's object/operand stack * ******************************************************************************/ ACPI_STATUS AcpiDsObjStackPush ( void *Object, ACPI_WALK_STATE *WalkState) { + PROC_NAME ("DsObjStackPush"); /* Check for stack overflow */ if (WalkState->NumOperands >= OBJ_NUM_OPERANDS) { - DEBUG_PRINT (ACPI_ERROR, - ("DsObjStackPush: overflow! Obj=%p State=%p #Ops=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "overflow! Obj=%p State=%p #Ops=%X\n", Object, WalkState, WalkState->NumOperands)); return (AE_STACK_OVERFLOW); } /* Put the object onto the stack */ WalkState->Operands [WalkState->NumOperands] = Object; WalkState->NumOperands++; - DEBUG_PRINT (TRACE_EXEC, ("DsObjStackPush: Obj=%p [%s] State=%p #Ops=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p [%s] State=%p #Ops=%X\n", Object, AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *) Object)->Common.Type), WalkState, WalkState->NumOperands)); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsObjStackPopObject * * PARAMETERS: PopCount - Number of objects/entries to pop * WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: Pop this walk's object stack. Objects on the stack are NOT * deleted by this routine. * ******************************************************************************/ ACPI_STATUS AcpiDsObjStackPopObject ( ACPI_OPERAND_OBJECT **Object, ACPI_WALK_STATE *WalkState) { + PROC_NAME ("DsObjStackPopObject"); /* Check for stack underflow */ if (WalkState->NumOperands == 0) { - DEBUG_PRINT (ACPI_ERROR, - ("DsObjStackPop: Missing operand/stack empty! State=%p #Ops=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Missing operand/stack empty! State=%p #Ops=%X\n", WalkState, WalkState->NumOperands)); *Object = NULL; return (AE_AML_NO_OPERAND); } /* Pop the stack */ WalkState->NumOperands--; /* Check for a valid operand */ if (!WalkState->Operands [WalkState->NumOperands]) { - DEBUG_PRINT (ACPI_ERROR, - ("DsObjStackPop: Null operand! State=%p #Ops=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Null operand! State=%p #Ops=%X\n", WalkState, WalkState->NumOperands)); *Object = NULL; return (AE_AML_NO_OPERAND); } /* Get operand and set stack entry to null */ *Object = WalkState->Operands [WalkState->NumOperands]; WalkState->Operands [WalkState->NumOperands] = NULL; - DEBUG_PRINT (TRACE_EXEC, ("DsObjStackPopObject: Obj=%p [%s] State=%p #Ops=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p [%s] State=%p #Ops=%X\n", *Object, AcpiUtGetTypeName ((*Object)->Common.Type), WalkState, WalkState->NumOperands)); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsObjStackPop * * PARAMETERS: PopCount - Number of objects/entries to pop * WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: Pop this walk's object stack. Objects on the stack are NOT * deleted by this routine. * ******************************************************************************/ ACPI_STATUS AcpiDsObjStackPop ( UINT32 PopCount, ACPI_WALK_STATE *WalkState) { UINT32 i; + PROC_NAME ("DsObjStackPop"); + for (i = 0; i < PopCount; i++) { /* Check for stack underflow */ if (WalkState->NumOperands == 0) { - DEBUG_PRINT (ACPI_ERROR, - ("DsObjStackPop: Underflow! Count=%X State=%p #Ops=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Underflow! Count=%X State=%p #Ops=%X\n", PopCount, WalkState, WalkState->NumOperands)); return (AE_STACK_UNDERFLOW); } /* Just set the stack entry to null */ WalkState->NumOperands--; WalkState->Operands [WalkState->NumOperands] = NULL; } - DEBUG_PRINT (TRACE_EXEC, ("DsObjStackPop: Count=%X State=%p #Ops=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Count=%X State=%p #Ops=%X\n", PopCount, WalkState, WalkState->NumOperands)); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsObjStackPopAndDelete * * PARAMETERS: PopCount - Number of objects/entries to pop * WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: Pop this walk's object stack and delete each object that is * popped off. * ******************************************************************************/ ACPI_STATUS AcpiDsObjStackPopAndDelete ( UINT32 PopCount, ACPI_WALK_STATE *WalkState) { UINT32 i; ACPI_OPERAND_OBJECT *ObjDesc; + PROC_NAME ("DsObjStackPopAndDelete"); + for (i = 0; i < PopCount; i++) { /* Check for stack underflow */ if (WalkState->NumOperands == 0) { - DEBUG_PRINT (ACPI_ERROR, - ("DsObjStackPop: Underflow! Count=%X State=%p #Ops=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Underflow! Count=%X State=%p #Ops=%X\n", PopCount, WalkState, WalkState->NumOperands)); return (AE_STACK_UNDERFLOW); } /* Pop the stack and delete an object if present in this stack entry */ WalkState->NumOperands--; ObjDesc = WalkState->Operands [WalkState->NumOperands]; if (ObjDesc) { AcpiUtRemoveReference (WalkState->Operands [WalkState->NumOperands]); WalkState->Operands [WalkState->NumOperands] = NULL; } } - DEBUG_PRINT (TRACE_EXEC, ("DsObjStackPop: Count=%X State=%p #Ops=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Count=%X State=%p #Ops=%X\n", PopCount, WalkState, WalkState->NumOperands)); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiDsObjStackGetValue * * PARAMETERS: Index - Stack index whose value is desired. Based * on the top of the stack (index=0 == top) * WalkState - Current Walk state * * RETURN: Status * * DESCRIPTION: Retrieve an object from this walk's object stack. Index must * be within the range of the current stack pointer. * ******************************************************************************/ void * AcpiDsObjStackGetValue ( UINT32 Index, ACPI_WALK_STATE *WalkState) { FUNCTION_TRACE_PTR ("DsObjStackGetValue", WalkState); /* Can't do it if the stack is empty */ if (WalkState->NumOperands == 0) { return_PTR (NULL); } /* or if the index is past the top of the stack */ if (Index > (WalkState->NumOperands - (UINT32) 1)) { return_PTR (NULL); } return_PTR (WalkState->Operands[(NATIVE_UINT)(WalkState->NumOperands - 1) - Index]); } /******************************************************************************* * * FUNCTION: AcpiDsGetCurrentWalkState * * PARAMETERS: WalkList - Get current active state for this walk list * * RETURN: Pointer to the current walk state * * DESCRIPTION: Get the walk state that is at the head of the list (the "current" * walk state. * ******************************************************************************/ ACPI_WALK_STATE * AcpiDsGetCurrentWalkState ( ACPI_WALK_LIST *WalkList) { + PROC_NAME ("DsGetCurrentWalkState"); - DEBUG_PRINT (TRACE_PARSE, ("DsGetCurrentWalkState, =%p\n", + + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "DsGetCurrentWalkState, =%p\n", WalkList->WalkState)); if (!WalkList) { return (NULL); } return (WalkList->WalkState); } /******************************************************************************* * * FUNCTION: AcpiDsPushWalkState * * PARAMETERS: WalkState - State to push * WalkList - The list that owns the walk stack * * RETURN: None * * DESCRIPTION: Place the WalkState at the head of the state list. * ******************************************************************************/ static void AcpiDsPushWalkState ( ACPI_WALK_STATE *WalkState, ACPI_WALK_LIST *WalkList) { FUNCTION_TRACE ("DsPushWalkState"); WalkState->Next = WalkList->WalkState; WalkList->WalkState = WalkState; return_VOID; } /******************************************************************************* * * FUNCTION: AcpiDsPopWalkState * * PARAMETERS: WalkList - The list that owns the walk stack * * RETURN: A WalkState object popped from the stack * * DESCRIPTION: Remove and return the walkstate object that is at the head of * the walk stack for the given walk list. NULL indicates that * the list is empty. * ******************************************************************************/ ACPI_WALK_STATE * AcpiDsPopWalkState ( ACPI_WALK_LIST *WalkList) { ACPI_WALK_STATE *WalkState; FUNCTION_TRACE ("DsPopWalkState"); WalkState = WalkList->WalkState; if (WalkState) { /* Next walk state becomes the current walk state */ WalkList->WalkState = WalkState->Next; /* * Don't clear the NEXT field, this serves as an indicator * that there is a parent WALK STATE * WalkState->Next = NULL; */ } return_PTR (WalkState); } /******************************************************************************* * * FUNCTION: AcpiDsCreateWalkState * * PARAMETERS: Origin - Starting point for this walk * WalkList - Owning walk list * * RETURN: Pointer to the new walk state. * * DESCRIPTION: Allocate and initialize a new walk state. The current walk state * is set to this new state. * ******************************************************************************/ ACPI_WALK_STATE * AcpiDsCreateWalkState ( ACPI_OWNER_ID OwnerId, ACPI_PARSE_OBJECT *Origin, ACPI_OPERAND_OBJECT *MthDesc, ACPI_WALK_LIST *WalkList) { ACPI_WALK_STATE *WalkState; ACPI_STATUS Status; FUNCTION_TRACE ("DsCreateWalkState"); - AcpiUtAcquireMutex (ACPI_MTX_CACHES); - AcpiGbl_WalkStateCacheRequests++; - - /* Check the cache first */ - - if (AcpiGbl_WalkStateCache) + WalkState = AcpiUtAcquireFromCache (ACPI_MEM_LIST_WALK); + if (!WalkState) { - /* There is an object available, use it */ - - WalkState = AcpiGbl_WalkStateCache; - AcpiGbl_WalkStateCache = WalkState->Next; - - AcpiGbl_WalkStateCacheHits++; - AcpiGbl_WalkStateCacheDepth--; - - DEBUG_PRINTP (TRACE_EXEC, ("State %p from cache\n", WalkState)); - - AcpiUtReleaseMutex (ACPI_MTX_CACHES); + return_PTR (NULL); } - else - { - /* The cache is empty, create a new object */ - - /* Avoid deadlock with ACPI_MEM_CALLOCATE */ - - AcpiUtReleaseMutex (ACPI_MTX_CACHES); - - WalkState = ACPI_MEM_CALLOCATE (sizeof (ACPI_WALK_STATE)); - if (!WalkState) - { - return_PTR (NULL); - } - } - WalkState->DataType = ACPI_DESC_TYPE_WALK; WalkState->OwnerId = OwnerId; WalkState->Origin = Origin; WalkState->MethodDesc = MthDesc; WalkState->WalkList = WalkList; /* Init the method args/local */ #ifndef _ACPI_ASL_COMPILER AcpiDsMethodDataInit (WalkState); #endif /* Create an initial result stack entry */ Status = AcpiDsResultStackPush (WalkState); if (ACPI_FAILURE (Status)) { return_PTR (NULL); } /* Put the new state at the head of the walk list */ AcpiDsPushWalkState (WalkState, WalkList); return_PTR (WalkState); } /******************************************************************************* * * FUNCTION: AcpiDsDeleteWalkState * * PARAMETERS: WalkState - State to delete * * RETURN: Status * * DESCRIPTION: Delete a walk state including all internal data structures * ******************************************************************************/ void AcpiDsDeleteWalkState ( ACPI_WALK_STATE *WalkState) { ACPI_GENERIC_STATE *State; FUNCTION_TRACE_PTR ("DsDeleteWalkState", WalkState); if (!WalkState) { return; } if (WalkState->DataType != ACPI_DESC_TYPE_WALK) { - DEBUG_PRINTP (ACPI_ERROR, ("%p is not a valid walk state\n", WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%p is not a valid walk state\n", WalkState)); return; } /* Always must free any linked control states */ while (WalkState->ControlState) { State = WalkState->ControlState; WalkState->ControlState = State->Common.Next; AcpiUtDeleteGenericState (State); } /* Always must free any linked parse states */ while (WalkState->ScopeInfo) { State = WalkState->ScopeInfo; WalkState->ScopeInfo = State->Common.Next; AcpiUtDeleteGenericState (State); } /* Always must free any stacked result states */ while (WalkState->Results) { State = WalkState->Results; WalkState->Results = State->Common.Next; AcpiUtDeleteGenericState (State); } - /* If walk cache is full, just free this wallkstate object */ - - if (AcpiGbl_WalkStateCacheDepth >= MAX_WALK_CACHE_DEPTH) - { - ACPI_MEM_FREE (WalkState); - } - - /* Otherwise put this object back into the cache */ - - else - { - AcpiUtAcquireMutex (ACPI_MTX_CACHES); - - /* Clear the state */ - - MEMSET (WalkState, 0, sizeof (ACPI_WALK_STATE)); - WalkState->DataType = ACPI_DESC_TYPE_WALK; - - /* Put the object at the head of the global cache list */ - - WalkState->Next = AcpiGbl_WalkStateCache; - AcpiGbl_WalkStateCache = WalkState; - AcpiGbl_WalkStateCacheDepth++; - - - AcpiUtReleaseMutex (ACPI_MTX_CACHES); - } - + AcpiUtReleaseToCache (ACPI_MEM_LIST_WALK, WalkState); return_VOID; } /****************************************************************************** * * FUNCTION: AcpiDsDeleteWalkStateCache * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Purge the global state object cache. Used during subsystem * termination. * ******************************************************************************/ void AcpiDsDeleteWalkStateCache ( void) { - ACPI_WALK_STATE *Next; - - FUNCTION_TRACE ("DsDeleteWalkStateCache"); - /* Traverse the global cache list */ - - while (AcpiGbl_WalkStateCache) - { - /* Delete one cached state object */ - - Next = AcpiGbl_WalkStateCache->Next; - ACPI_MEM_FREE (AcpiGbl_WalkStateCache); - - AcpiGbl_WalkStateCache = Next; - AcpiGbl_WalkStateCacheDepth--; - } - + AcpiUtDeleteGenericCache (ACPI_MEM_LIST_WALK); return_VOID; } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/evevent.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/evevent.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/evevent.c (revision 82367) @@ -1,954 +1,960 @@ /****************************************************************************** * * Module Name: evevent - Fixed and General Purpose AcpiEvent * handling and dispatch - * $Revision: 46 $ + * $Revision: 47 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "achware.h" #include "acevents.h" #include "acnamesp.h" #define _COMPONENT ACPI_EVENTS MODULE_NAME ("evevent") /******************************************************************************* * * FUNCTION: AcpiEvInitialize * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Ensures that the system control interrupt (SCI) is properly * configured, disables SCI event sources, installs the SCI * handler * ******************************************************************************/ ACPI_STATUS AcpiEvInitialize ( void) { ACPI_STATUS Status; FUNCTION_TRACE ("EvInitialize"); /* Make sure we have ACPI tables */ if (!AcpiGbl_DSDT) { - DEBUG_PRINTP (ACPI_WARN, ("No ACPI tables present!\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "No ACPI tables present!\n")); return_ACPI_STATUS (AE_NO_ACPI_TABLES); } /* Make sure the BIOS supports ACPI mode */ if (SYS_MODE_LEGACY == AcpiHwGetModeCapabilities()) { - DEBUG_PRINTP (ACPI_WARN, ("ACPI Mode is not supported!\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "ACPI Mode is not supported!\n")); return_ACPI_STATUS (AE_ERROR); } AcpiGbl_OriginalMode = AcpiHwGetMode(); /* * Initialize the Fixed and General Purpose AcpiEvents prior. This is * done prior to enabling SCIs to prevent interrupts from occuring * before handers are installed. */ Status = AcpiEvFixedEventInitialize (); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_FATAL, ("Unable to initialize fixed events.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_FATAL, "Unable to initialize fixed events.\n")); return_ACPI_STATUS (Status); } Status = AcpiEvGpeInitialize (); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_FATAL, ("Unable to initialize general purpose events.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_FATAL, "Unable to initialize general purpose events.\n")); return_ACPI_STATUS (Status); } /* Install the SCI handler */ Status = AcpiEvInstallSciHandler (); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_FATAL, ("Unable to install System Control Interrupt Handler\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_FATAL, "Unable to install System Control Interrupt Handler\n")); return_ACPI_STATUS (Status); } /* Install handlers for control method GPE handlers (_Lxx, _Exx) */ Status = AcpiEvInitGpeControlMethods (); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_FATAL, ("Unable to initialize Gpe control methods\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_FATAL, "Unable to initialize Gpe control methods\n")); return_ACPI_STATUS (Status); } /* Install the handler for the Global Lock */ Status = AcpiEvInitGlobalLockHandler (); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_FATAL, ("Unable to initialize Global Lock handler\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_FATAL, "Unable to initialize Global Lock handler\n")); return_ACPI_STATUS (Status); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiEvFixedEventInitialize * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Initialize the Fixed AcpiEvent data structures * ******************************************************************************/ ACPI_STATUS AcpiEvFixedEventInitialize(void) { int i = 0; /* Initialize the structure that keeps track of fixed event handlers */ for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) { AcpiGbl_FixedEventHandlers[i].Handler = NULL; AcpiGbl_FixedEventHandlers[i].Context = NULL; } AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, TMR_EN, 0); AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, GBL_EN, 0); AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, PWRBTN_EN, 0); AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, SLPBTN_EN, 0); AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, RTC_EN, 0); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiEvFixedEventDetect * * PARAMETERS: None * * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED * * DESCRIPTION: Checks the PM status register for fixed events * ******************************************************************************/ UINT32 -AcpiEvFixedEventDetect(void) +AcpiEvFixedEventDetect (void) { UINT32 IntStatus = INTERRUPT_NOT_HANDLED; UINT32 StatusRegister; UINT32 EnableRegister; + PROC_NAME ("AcpiEvFixedEventDetect"); + + /* * Read the fixed feature status and enable registers, as all the cases * depend on their values. */ StatusRegister = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, PM1_STS); EnableRegister = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, PM1_EN); - DEBUG_PRINT (TRACE_INTERRUPTS, - ("Fixed AcpiEvent Block: Enable %08X Status %08X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INTERRUPTS, + "Fixed AcpiEvent Block: Enable %08X Status %08X\n", EnableRegister, StatusRegister)); /* power management timer roll over */ if ((StatusRegister & ACPI_STATUS_PMTIMER) && (EnableRegister & ACPI_ENABLE_PMTIMER)) { IntStatus |= AcpiEvFixedEventDispatch (ACPI_EVENT_PMTIMER); } /* global event (BIOS wants the global lock) */ if ((StatusRegister & ACPI_STATUS_GLOBAL) && (EnableRegister & ACPI_ENABLE_GLOBAL)) { IntStatus |= AcpiEvFixedEventDispatch (ACPI_EVENT_GLOBAL); } /* power button event */ if ((StatusRegister & ACPI_STATUS_POWER_BUTTON) && (EnableRegister & ACPI_ENABLE_POWER_BUTTON)) { IntStatus |= AcpiEvFixedEventDispatch (ACPI_EVENT_POWER_BUTTON); } /* sleep button event */ if ((StatusRegister & ACPI_STATUS_SLEEP_BUTTON) && (EnableRegister & ACPI_ENABLE_SLEEP_BUTTON)) { IntStatus |= AcpiEvFixedEventDispatch (ACPI_EVENT_SLEEP_BUTTON); } return (IntStatus); } /******************************************************************************* * * FUNCTION: AcpiEvFixedEventDispatch * * PARAMETERS: Event - Event type * * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED * * DESCRIPTION: Clears the status bit for the requested event, calls the * handler that previously registered for the event. * ******************************************************************************/ UINT32 AcpiEvFixedEventDispatch ( UINT32 Event) { UINT32 RegisterId; /* Clear the status bit */ switch (Event) { case ACPI_EVENT_PMTIMER: RegisterId = TMR_STS; break; case ACPI_EVENT_GLOBAL: RegisterId = GBL_STS; break; case ACPI_EVENT_POWER_BUTTON: RegisterId = PWRBTN_STS; break; case ACPI_EVENT_SLEEP_BUTTON: RegisterId = SLPBTN_STS; break; case ACPI_EVENT_RTC: RegisterId = RTC_STS; break; default: return 0; break; } AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_DO_NOT_LOCK, RegisterId, 1); /* * Make sure we've got a handler. If not, report an error. * The event is disabled to prevent further interrupts. */ if (NULL == AcpiGbl_FixedEventHandlers[Event].Handler) { RegisterId = (PM1_EN | REGISTER_BIT_ID(RegisterId)); AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_DO_NOT_LOCK, RegisterId, 0); REPORT_ERROR ( ("EvGpeDispatch: No installed handler for fixed event [%08X]\n", Event)); return (INTERRUPT_NOT_HANDLED); } /* Invoke the handler */ return ((AcpiGbl_FixedEventHandlers[Event].Handler)( AcpiGbl_FixedEventHandlers[Event].Context)); } /******************************************************************************* * * FUNCTION: AcpiEvGpeInitialize * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Initialize the GPE data structures * ******************************************************************************/ ACPI_STATUS AcpiEvGpeInitialize (void) { UINT32 i; UINT32 j; UINT32 RegisterIndex; UINT32 GpeNumber; UINT16 Gpe0RegisterCount; UINT16 Gpe1RegisterCount; FUNCTION_TRACE ("EvGpeInitialize"); /* * Set up various GPE counts * * You may ask,why are the GPE register block lengths divided by 2? * From the ACPI 2.0 Spec, section, 4.7.1.6 General-Purpose Event * Registers, we have, * * "Each register block contains two registers of equal length * GPEx_STS and GPEx_EN (where x is 0 or 1). The length of the * GPE0_STS and GPE0_EN registers is equal to half the GPE0_LEN * The length of the GPE1_STS and GPE1_EN registers is equal to * half the GPE1_LEN. If a generic register block is not supported * then its respective block pointer and block length values in the * FADT table contain zeros. The GPE0_LEN and GPE1_LEN do not need * to be the same size." */ Gpe0RegisterCount = (UINT16) DIV_2 (AcpiGbl_FADT->Gpe0BlkLen); Gpe1RegisterCount = (UINT16) DIV_2 (AcpiGbl_FADT->Gpe1BlkLen); AcpiGbl_GpeRegisterCount = Gpe0RegisterCount + Gpe1RegisterCount; if (!AcpiGbl_GpeRegisterCount) { REPORT_WARNING (("Zero GPEs are defined in the FADT\n")); return_ACPI_STATUS (AE_OK); } /* * Allocate the Gpe information block */ AcpiGbl_GpeRegisters = ACPI_MEM_CALLOCATE (AcpiGbl_GpeRegisterCount * sizeof (ACPI_GPE_REGISTERS)); if (!AcpiGbl_GpeRegisters) { - DEBUG_PRINTP (ACPI_ERROR, - ("Could not allocate the GpeRegisters block\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Could not allocate the GpeRegisters block\n")); return_ACPI_STATUS (AE_NO_MEMORY); } /* * Allocate the Gpe dispatch handler block * There are eight distinct GP events per register. * Initialization to zeros is sufficient */ AcpiGbl_GpeInfo = ACPI_MEM_CALLOCATE (MUL_8 (AcpiGbl_GpeRegisterCount) * sizeof (ACPI_GPE_LEVEL_INFO)); if (!AcpiGbl_GpeInfo) { ACPI_MEM_FREE (AcpiGbl_GpeRegisters); - DEBUG_PRINTP (ACPI_ERROR, ("Could not allocate the GpeInfo block\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not allocate the GpeInfo block\n")); return_ACPI_STATUS (AE_NO_MEMORY); } /* Set the Gpe validation table to GPE_INVALID */ MEMSET (AcpiGbl_GpeValid, (int) ACPI_GPE_INVALID, ACPI_NUM_GPE); /* * Initialize the Gpe information and validation blocks. A goal of these * blocks is to hide the fact that there are two separate GPE register sets * In a given block, the status registers occupy the first half, and * the enable registers occupy the second half. */ /* GPE Block 0 */ RegisterIndex = 0; for (i = 0; i < Gpe0RegisterCount; i++) { AcpiGbl_GpeRegisters[RegisterIndex].StatusAddr = (UINT16) (ACPI_GET_ADDRESS (AcpiGbl_FADT->XGpe0Blk.Address) + i); AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr = (UINT16) (ACPI_GET_ADDRESS (AcpiGbl_FADT->XGpe0Blk.Address) + i + Gpe0RegisterCount); AcpiGbl_GpeRegisters[RegisterIndex].GpeBase = (UINT8) MUL_8 (i); for (j = 0; j < 8; j++) { GpeNumber = AcpiGbl_GpeRegisters[RegisterIndex].GpeBase + j; AcpiGbl_GpeValid[GpeNumber] = (UINT8) RegisterIndex; } /* * Clear the status/enable registers. Note that status registers * are cleared by writing a '1', while enable registers are cleared * by writing a '0'. */ AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, 0x00, 8); AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].StatusAddr, 0xFF, 8); RegisterIndex++; } /* GPE Block 1 */ for (i = 0; i < Gpe1RegisterCount; i++) { AcpiGbl_GpeRegisters[RegisterIndex].StatusAddr = (UINT16) (ACPI_GET_ADDRESS (AcpiGbl_FADT->XGpe1Blk.Address) + i); AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr = (UINT16) (ACPI_GET_ADDRESS (AcpiGbl_FADT->XGpe1Blk.Address) + i + Gpe1RegisterCount); AcpiGbl_GpeRegisters[RegisterIndex].GpeBase = (UINT8) (AcpiGbl_FADT->Gpe1Base + MUL_8 (i)); for (j = 0; j < 8; j++) { GpeNumber = AcpiGbl_GpeRegisters[RegisterIndex].GpeBase + j; AcpiGbl_GpeValid[GpeNumber] = (UINT8) RegisterIndex; } /* * Clear the status/enable registers. Note that status registers * are cleared by writing a '1', while enable registers are cleared * by writing a '0'. */ AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, 0x00, 8); AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].StatusAddr, 0xFF, 8); RegisterIndex++; } - DEBUG_PRINTP (ACPI_INFO, ("GPE registers: %X@%p (Blk0) %X@%p (Blk1)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "GPE registers: %X@%p (Blk0) %X@%p (Blk1)\n", Gpe0RegisterCount, AcpiGbl_FADT->XGpe0Blk.Address, Gpe1RegisterCount, AcpiGbl_FADT->XGpe1Blk.Address)); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiEvSaveMethodInfo * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Called from AcpiWalkNamespace. Expects each object to be a * control method under the _GPE portion of the namespace. * Extract the name and GPE type from the object, saving this * information for quick lookup during GPE dispatch * * The name of each GPE control method is of the form: * "_Lnn" or "_Enn" * Where: * L - means that the GPE is level triggered * E - means that the GPE is edge triggered * nn - is the GPE number * ******************************************************************************/ static ACPI_STATUS AcpiEvSaveMethodInfo ( ACPI_HANDLE ObjHandle, UINT32 Level, void *ObjDesc, void **ReturnValue) { UINT32 GpeNumber; NATIVE_CHAR Name[ACPI_NAME_SIZE + 1]; UINT8 Type; PROC_NAME ("EvSaveMethodInfo"); /* Extract the name from the object and convert to a string */ MOVE_UNALIGNED32_TO_32 (Name, &((ACPI_NAMESPACE_NODE *) ObjHandle)->Name); Name[ACPI_NAME_SIZE] = 0; /* * Edge/Level determination is based on the 2nd INT8 of the method name */ if (Name[1] == 'L') { Type = ACPI_EVENT_LEVEL_TRIGGERED; } else if (Name[1] == 'E') { Type = ACPI_EVENT_EDGE_TRIGGERED; } else { /* Unknown method type, just ignore it! */ - DEBUG_PRINTP (ACPI_ERROR, - ("Unknown GPE method type: %s (name not of form _Lnn or _Enn)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Unknown GPE method type: %s (name not of form _Lnn or _Enn)\n", Name)); return (AE_OK); } /* Convert the last two characters of the name to the Gpe Number */ GpeNumber = STRTOUL (&Name[2], NULL, 16); if (GpeNumber == ACPI_UINT32_MAX) { /* Conversion failed; invalid method, just ignore it */ - DEBUG_PRINTP (ACPI_ERROR, - ("Could not extract GPE number from name: %s (name not of form _Lnn or _Enn)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Could not extract GPE number from name: %s (name not of form _Lnn or _Enn)\n", Name)); return (AE_OK); } /* Ensure that we have a valid GPE number */ if (AcpiGbl_GpeValid[GpeNumber] == ACPI_GPE_INVALID) { /* Not valid, all we can do here is ignore it */ return (AE_OK); } /* * Now we can add this information to the GpeInfo block * for use during dispatch of this GPE. */ AcpiGbl_GpeInfo [GpeNumber].Type = Type; AcpiGbl_GpeInfo [GpeNumber].MethodHandle = ObjHandle; /* * Enable the GPE (SCIs should be disabled at this point) */ AcpiHwEnableGpe (GpeNumber); - DEBUG_PRINTP (ACPI_INFO, ("Registered GPE method %s as GPE number %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Registered GPE method %s as GPE number %X\n", Name, GpeNumber)); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiEvInitGpeControlMethods * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Obtain the control methods associated with the GPEs. * * NOTE: Must be called AFTER namespace initialization! * ******************************************************************************/ ACPI_STATUS AcpiEvInitGpeControlMethods (void) { ACPI_STATUS Status; FUNCTION_TRACE ("EvInitGpeControlMethods"); /* Get a permanent handle to the _GPE object */ Status = AcpiGetHandle (NULL, "\\_GPE", &AcpiGbl_GpeObjHandle); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Traverse the namespace under \_GPE to find all methods there */ Status = AcpiWalkNamespace (ACPI_TYPE_METHOD, AcpiGbl_GpeObjHandle, ACPI_UINT32_MAX, AcpiEvSaveMethodInfo, NULL, NULL); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiEvGpeDetect * * PARAMETERS: None * * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED * * DESCRIPTION: Detect if any GP events have occurred * ******************************************************************************/ UINT32 AcpiEvGpeDetect (void) { UINT32 IntStatus = INTERRUPT_NOT_HANDLED; UINT32 i; UINT32 j; UINT8 EnabledStatusByte; UINT8 BitMask; + PROC_NAME ("EvGpeDetect"); + + /* * Read all of the 8-bit GPE status and enable registers * in both of the register blocks, saving all of it. * Find all currently active GP events. */ for (i = 0; i < AcpiGbl_GpeRegisterCount; i++) { AcpiOsReadPort (AcpiGbl_GpeRegisters[i].StatusAddr, &AcpiGbl_GpeRegisters[i].Status, 8); AcpiOsReadPort (AcpiGbl_GpeRegisters[i].EnableAddr, &AcpiGbl_GpeRegisters[i].Enable, 8); - DEBUG_PRINT (TRACE_INTERRUPTS, - ("GPE block at %X - Enable %08X Status %08X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INTERRUPTS, + "GPE block at %X - Enable %08X Status %08X\n", AcpiGbl_GpeRegisters[i].EnableAddr, AcpiGbl_GpeRegisters[i].Status, AcpiGbl_GpeRegisters[i].Enable)); /* First check if there is anything active at all in this register */ EnabledStatusByte = (UINT8) (AcpiGbl_GpeRegisters[i].Status & AcpiGbl_GpeRegisters[i].Enable); if (!EnabledStatusByte) { /* No active GPEs in this register, move on */ continue; } /* Now look at the individual GPEs in this byte register */ for (j = 0, BitMask = 1; j < 8; j++, BitMask <<= 1) { /* Examine one GPE bit */ if (EnabledStatusByte & BitMask) { /* * Found an active GPE. Dispatch the event to a handler * or method. */ IntStatus |= AcpiEvGpeDispatch ( AcpiGbl_GpeRegisters[i].GpeBase + j); } } } return (IntStatus); } /******************************************************************************* * * FUNCTION: AcpiEvAsynchExecuteGpeMethod * * PARAMETERS: GpeNumber - The 0-based Gpe number * * RETURN: None * * DESCRIPTION: Perform the actual execution of a GPE control method. This * function is called from an invocation of AcpiOsQueueForExecution * (and therefore does NOT execute at interrupt level) so that * the control method itself is not executed in the context of * the SCI interrupt handler. * ******************************************************************************/ static void AcpiEvAsynchExecuteGpeMethod ( void *Context) { UINT32 GpeNumber = (UINT32) Context; ACPI_GPE_LEVEL_INFO GpeInfo; FUNCTION_TRACE ("EvAsynchExecuteGpeMethod"); /* * Take a snapshot of the GPE info for this level */ AcpiUtAcquireMutex (ACPI_MTX_EVENTS); GpeInfo = AcpiGbl_GpeInfo [GpeNumber]; AcpiUtReleaseMutex (ACPI_MTX_EVENTS); /* * Method Handler (_Lxx, _Exx): * ---------------------------- * Evaluate the _Lxx/_Exx control method that corresponds to this GPE. */ if (GpeInfo.MethodHandle) { AcpiNsEvaluateByHandle (GpeInfo.MethodHandle, NULL, NULL); } /* * Level-Triggered? * ---------------- * If level-triggered we clear the GPE status bit after handling the event. */ if (GpeInfo.Type & ACPI_EVENT_LEVEL_TRIGGERED) { AcpiHwClearGpe (GpeNumber); } /* * Enable the GPE. */ AcpiHwEnableGpe (GpeNumber); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiEvGpeDispatch * * PARAMETERS: GpeNumber - The 0-based Gpe number * * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED * * DESCRIPTION: Handle and dispatch a General Purpose AcpiEvent. * Clears the status bit for the requested event. * * TBD: [Investigate] is this still valid or necessary: * The Gpe handler differs from the fixed events in that it clears the enable * bit rather than the status bit to clear the interrupt. This allows * software outside of interrupt context to determine what caused the SCI and * dispatch the correct AML. * ******************************************************************************/ UINT32 AcpiEvGpeDispatch ( UINT32 GpeNumber) { ACPI_GPE_LEVEL_INFO GpeInfo; FUNCTION_TRACE ("EvGpeDispatch"); /* * Valid GPE number? */ if (AcpiGbl_GpeValid[GpeNumber] == ACPI_GPE_INVALID) { - DEBUG_PRINTP (ACPI_ERROR, ("Invalid GPE bit [%X].\n", GpeNumber)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Invalid GPE bit [%X].\n", GpeNumber)); return_VALUE (INTERRUPT_NOT_HANDLED); } /* * Disable the GPE. */ AcpiHwDisableGpe (GpeNumber); GpeInfo = AcpiGbl_GpeInfo [GpeNumber]; /* * Edge-Triggered? * --------------- * If edge-triggered, clear the GPE status bit now. Note that * level-triggered events are cleared after the GPE is serviced. */ if (GpeInfo.Type & ACPI_EVENT_EDGE_TRIGGERED) { AcpiHwClearGpe (GpeNumber); } /* * Function Handler (e.g. EC)? */ if (GpeInfo.Handler) { /* Invoke function handler (at interrupt level). */ GpeInfo.Handler (GpeInfo.Context); /* Level-Triggered? */ if (GpeInfo.Type & ACPI_EVENT_LEVEL_TRIGGERED) { AcpiHwClearGpe (GpeNumber); } /* Enable GPE */ AcpiHwEnableGpe (GpeNumber); } /* * Method Handler (e.g. _Exx/_Lxx)? */ else if (GpeInfo.MethodHandle) { if (ACPI_FAILURE(AcpiOsQueueForExecution (OSD_PRIORITY_GPE, AcpiEvAsynchExecuteGpeMethod, (void*) GpeNumber))) { /* * Shoudn't occur, but if it does report an error. Note that * the GPE will remain disabled until the ACPI Core Subsystem * is restarted, or the handler is removed/reinstalled. */ REPORT_ERROR (("AcpiEvGpeDispatch: Unable to queue handler for GPE bit [%X]\n", GpeNumber)); } } /* * No Handler? Report an error and leave the GPE disabled. */ else { REPORT_ERROR (("AcpiEvGpeDispatch: No installed handler for GPE [%X]\n", GpeNumber)); /* Level-Triggered? */ if (GpeInfo.Type & ACPI_EVENT_LEVEL_TRIGGERED) { AcpiHwClearGpe (GpeNumber); } } return_VALUE (INTERRUPT_HANDLED); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/evmisc.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/evmisc.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/evmisc.c (revision 82367) @@ -1,581 +1,581 @@ /****************************************************************************** * * Module Name: evmisc - ACPI device notification handler dispatch * and ACPI Global Lock support - * $Revision: 31 $ + * $Revision: 32 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acevents.h" #include "acnamesp.h" #include "acinterp.h" #include "achware.h" #define _COMPONENT ACPI_EVENTS MODULE_NAME ("evmisc") /******************************************************************************* * * FUNCTION: AcpiEvQueueNotifyRequest * * PARAMETERS: * * RETURN: None. * * DESCRIPTION: Dispatch a device notification event to a previously * installed handler. * ******************************************************************************/ ACPI_STATUS AcpiEvQueueNotifyRequest ( ACPI_NAMESPACE_NODE *Node, UINT32 NotifyValue) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *HandlerObj = NULL; ACPI_GENERIC_STATE *NotifyInfo; ACPI_STATUS Status = AE_OK; PROC_NAME ("EvQueueNotifyRequest"); /* * For value 1 (Ejection Request), some device method may need to be run. * For value 2 (Device Wake) if _PRW exists, the _PS0 method may need to be run. * For value 0x80 (Status Change) on the power button or sleep button, * initiate soft-off or sleep operation? */ - DEBUG_PRINTP (ACPI_INFO, - ("Dispatching Notify(%X) on node %p\n", NotifyValue, Node)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Dispatching Notify(%X) on node %p\n", NotifyValue, Node)); switch (NotifyValue) { case 0: - DEBUG_PRINTP (ACPI_INFO, ("Notify value: Re-enumerate Devices\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Notify value: Re-enumerate Devices\n")); break; case 1: - DEBUG_PRINTP (ACPI_INFO, ("Notify value: Ejection Request\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Notify value: Ejection Request\n")); break; case 2: - DEBUG_PRINTP (ACPI_INFO, ("Notify value: Device Wake\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Notify value: Device Wake\n")); break; case 0x80: - DEBUG_PRINTP (ACPI_INFO, ("Notify value: Status Change\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Notify value: Status Change\n")); break; default: - DEBUG_PRINTP (ACPI_INFO, ("Unknown Notify Value: %lx \n", NotifyValue)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Unknown Notify Value: %lx \n", NotifyValue)); break; } /* * Get the notify object attached to the device Node */ ObjDesc = AcpiNsGetAttachedObject (Node); if (ObjDesc) { /* We have the notify object, Get the right handler */ switch (Node->Type) { case ACPI_TYPE_DEVICE: if (NotifyValue <= MAX_SYS_NOTIFY) { HandlerObj = ObjDesc->Device.SysHandler; } else { HandlerObj = ObjDesc->Device.DrvHandler; } break; case ACPI_TYPE_THERMAL: if (NotifyValue <= MAX_SYS_NOTIFY) { HandlerObj = ObjDesc->ThermalZone.SysHandler; } else { HandlerObj = ObjDesc->ThermalZone.DrvHandler; } break; } } /* If there is any handler to run, schedule the dispatcher */ if ((AcpiGbl_SysNotify.Handler && (NotifyValue <= MAX_SYS_NOTIFY)) || (AcpiGbl_DrvNotify.Handler && (NotifyValue > MAX_SYS_NOTIFY)) || HandlerObj) { NotifyInfo = AcpiUtCreateGenericState (); if (!NotifyInfo) { return (AE_NO_MEMORY); } NotifyInfo->Notify.Node = Node; NotifyInfo->Notify.Value = (UINT16) NotifyValue; NotifyInfo->Notify.HandlerObj = HandlerObj; Status = AcpiOsQueueForExecution (OSD_PRIORITY_HIGH, AcpiEvNotifyDispatch, NotifyInfo); if (ACPI_FAILURE (Status)) { AcpiUtDeleteGenericState (NotifyInfo); } } if (!HandlerObj) { /* There is no per-device notify handler for this device */ - DEBUG_PRINTP (ACPI_INFO, ("No notify handler for node %p \n", Node)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "No notify handler for node %p \n", Node)); } return (Status); } /******************************************************************************* * * FUNCTION: AcpiEvNotifyDispatch * * PARAMETERS: * * RETURN: None. * * DESCRIPTION: Dispatch a device notification event to a previously * installed handler. * ******************************************************************************/ void AcpiEvNotifyDispatch ( void *Context) { ACPI_GENERIC_STATE *NotifyInfo = (ACPI_GENERIC_STATE *) Context; ACPI_NOTIFY_HANDLER GlobalHandler = NULL; void *GlobalContext = NULL; ACPI_OPERAND_OBJECT *HandlerObj; /* * We will invoke a global notify handler if installed. * This is done _before_ we invoke the per-device handler attached to the device. */ if (NotifyInfo->Notify.Value <= MAX_SYS_NOTIFY) { /* Global system notification handler */ if (AcpiGbl_SysNotify.Handler) { GlobalHandler = AcpiGbl_SysNotify.Handler; GlobalContext = AcpiGbl_SysNotify.Context; } } else { /* Global driver notification handler */ if (AcpiGbl_DrvNotify.Handler) { GlobalHandler = AcpiGbl_DrvNotify.Handler; GlobalContext = AcpiGbl_DrvNotify.Context; } } /* Invoke the system handler first, if present */ if (GlobalHandler) { GlobalHandler (NotifyInfo->Notify.Node, NotifyInfo->Notify.Value, GlobalContext); } /* Now invoke the per-device handler, if present */ HandlerObj = NotifyInfo->Notify.HandlerObj; if (HandlerObj) { HandlerObj->NotifyHandler.Handler (NotifyInfo->Notify.Node, NotifyInfo->Notify.Value, HandlerObj->NotifyHandler.Context); } /* All done with the info object */ AcpiUtDeleteGenericState (NotifyInfo); } /******************************************************************************* * * FUNCTION: AcpiEvGlobalLockThread * * RETURN: None * * DESCRIPTION: Invoked by SCI interrupt handler upon acquisition of the * Global Lock. Simply signal all threads that are waiting * for the lock. * ******************************************************************************/ static void AcpiEvGlobalLockThread ( void *Context) { /* Signal threads that are waiting for the lock */ if (AcpiGbl_GlobalLockThreadCount) { /* Send sufficient units to the semaphore */ AcpiOsSignalSemaphore (AcpiGbl_GlobalLockSemaphore, AcpiGbl_GlobalLockThreadCount); } } /******************************************************************************* * * FUNCTION: AcpiEvGlobalLockHandler * * RETURN: Status * * DESCRIPTION: Invoked directly from the SCI handler when a global lock * release interrupt occurs. Grab the global lock and queue * the global lock thread for execution * ******************************************************************************/ static UINT32 AcpiEvGlobalLockHandler ( void *Context) { BOOLEAN Acquired = FALSE; void *GlobalLock; /* * Attempt to get the lock * If we don't get it now, it will be marked pending and we will * take another interrupt when it becomes free. */ GlobalLock = AcpiGbl_FACS->GlobalLock; ACPI_ACQUIRE_GLOBAL_LOCK (GlobalLock, Acquired); if (Acquired) { /* Got the lock, now wake all threads waiting for it */ AcpiGbl_GlobalLockAcquired = TRUE; /* Run the Global Lock thread which will signal all waiting threads */ AcpiOsQueueForExecution (OSD_PRIORITY_HIGH, AcpiEvGlobalLockThread, Context); } return (INTERRUPT_HANDLED); } /******************************************************************************* * * FUNCTION: AcpiEvInitGlobalLockHandler * * RETURN: Status * * DESCRIPTION: Install a handler for the global lock release event * ******************************************************************************/ ACPI_STATUS AcpiEvInitGlobalLockHandler (void) { ACPI_STATUS Status; FUNCTION_TRACE ("EvInitGlobalLockHandler"); AcpiGbl_GlobalLockPresent = TRUE; Status = AcpiInstallFixedEventHandler (ACPI_EVENT_GLOBAL, AcpiEvGlobalLockHandler, NULL); /* * If the global lock does not exist on this platform, the attempt * to enable GBL_STS will fail (the GBL_EN bit will not stick) * Map to AE_OK, but mark global lock as not present. * Any attempt to actually use the global lock will be flagged * with an error. */ if (Status == AE_NO_HARDWARE_RESPONSE) { AcpiGbl_GlobalLockPresent = FALSE; Status = AE_OK; } return_ACPI_STATUS (Status); } /****************************************************************************** * * FUNCTION: AcpiEvAcquireGlobalLock * * RETURN: Status * * DESCRIPTION: Attempt to gain ownership of the Global Lock. * *****************************************************************************/ ACPI_STATUS AcpiEvAcquireGlobalLock(void) { ACPI_STATUS Status = AE_OK; BOOLEAN Acquired = FALSE; void *GlobalLock; FUNCTION_TRACE ("EvAcquireGlobalLock"); /* Make sure that we actually have a global lock */ if (!AcpiGbl_GlobalLockPresent) { return_ACPI_STATUS (AE_NO_GLOBAL_LOCK); } /* One more thread wants the global lock */ AcpiGbl_GlobalLockThreadCount++; /* If we (OS side) have the hardware lock already, we are done */ if (AcpiGbl_GlobalLockAcquired) { return_ACPI_STATUS (AE_OK); } /* Only if the FACS is valid */ if (!AcpiGbl_FACS) { return_ACPI_STATUS (AE_OK); } /* We must acquire the actual hardware lock */ GlobalLock = AcpiGbl_FACS->GlobalLock; ACPI_ACQUIRE_GLOBAL_LOCK (GlobalLock, Acquired); if (Acquired) { /* We got the lock */ - DEBUG_PRINTP (ACPI_INFO, ("Acquired the Global Lock\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Acquired the Global Lock\n")); AcpiGbl_GlobalLockAcquired = TRUE; return_ACPI_STATUS (AE_OK); } /* * Did not get the lock. The pending bit was set above, and we must now * wait until we get the global lock released interrupt. */ - DEBUG_PRINTP (ACPI_INFO, ("Waiting for the HW Global Lock\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Waiting for the HW Global Lock\n")); /* * Acquire the global lock semaphore first. * Since this wait will block, we must release the interpreter */ Status = AcpiExSystemWaitSemaphore (AcpiGbl_GlobalLockSemaphore, ACPI_UINT32_MAX); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiEvReleaseGlobalLock * * DESCRIPTION: Releases ownership of the Global Lock. * ******************************************************************************/ void AcpiEvReleaseGlobalLock (void) { BOOLEAN Pending = FALSE; void *GlobalLock; FUNCTION_TRACE ("EvReleaseGlobalLock"); if (!AcpiGbl_GlobalLockThreadCount) { REPORT_WARNING(("Global Lock has not be acquired, cannot release\n")); return_VOID; } /* One fewer thread has the global lock */ AcpiGbl_GlobalLockThreadCount--; /* Have all threads released the lock? */ if (!AcpiGbl_GlobalLockThreadCount) { /* * No more threads holding lock, we can do the actual hardware * release */ GlobalLock = AcpiGbl_FACS->GlobalLock; ACPI_RELEASE_GLOBAL_LOCK (GlobalLock, Pending); AcpiGbl_GlobalLockAcquired = FALSE; /* * If the pending bit was set, we must write GBL_RLS to the control * register */ if (Pending) { AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, GBL_RLS, 1); } } return_VOID; } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/evregion.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/evregion.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/evregion.c (revision 82367) @@ -1,767 +1,767 @@ /****************************************************************************** * * Module Name: evregion - ACPI AddressSpace (OpRegion) handler dispatch - * $Revision: 106 $ + * $Revision: 107 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EVREGION_C__ #include "acpi.h" #include "acevents.h" #include "acnamesp.h" #include "acinterp.h" #include "amlcode.h" #define _COMPONENT ACPI_EVENTS MODULE_NAME ("evregion") /******************************************************************************* * * FUNCTION: AcpiEvInstallDefaultAddressSpaceHandlers * * PARAMETERS: * * RETURN: Status * * DESCRIPTION: Installs the core subsystem address space handlers. * ******************************************************************************/ ACPI_STATUS AcpiEvInstallDefaultAddressSpaceHandlers ( void) { ACPI_STATUS Status; FUNCTION_TRACE ("EvInstallDefaultAddressSpaceHandlers"); /* * All address spaces (PCI Config, EC, SMBus) are scope dependent * and registration must occur for a specific device. In the case * system memory and IO address spaces there is currently no device * associated with the address space. For these we use the root. * We install the default PCI config space handler at the root so * that this space is immediately available even though the we have * not enumerated all the PCI Root Buses yet. This is to conform * to the ACPI specification which states that the PCI config * space must be always available -- even though we are nowhere * near ready to find the PCI root buses at this point. * * NOTE: We ignore AE_EXIST because this means that a handler has * already been installed (via AcpiInstallAddressSpaceHandler) */ Status = AcpiInstallAddressSpaceHandler (AcpiGbl_RootNode, ACPI_ADR_SPACE_SYSTEM_MEMORY, ACPI_DEFAULT_HANDLER, NULL, NULL); if ((ACPI_FAILURE (Status)) && (Status != AE_EXIST)) { return_ACPI_STATUS (Status); } Status = AcpiInstallAddressSpaceHandler (AcpiGbl_RootNode, ACPI_ADR_SPACE_SYSTEM_IO, ACPI_DEFAULT_HANDLER, NULL, NULL); if ((ACPI_FAILURE (Status)) && (Status != AE_EXIST)) { return_ACPI_STATUS (Status); } Status = AcpiInstallAddressSpaceHandler (AcpiGbl_RootNode, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL); if ((ACPI_FAILURE (Status)) && (Status != AE_EXIST)) { return_ACPI_STATUS (Status); } return_ACPI_STATUS (AE_OK); } /* TBD: [Restructure] Move elsewhere */ /******************************************************************************* * * FUNCTION: AcpiEvExecuteRegMethod * * PARAMETERS: RegionObj - Object structure * Function - On (1) or Off (0) * * RETURN: Status * * DESCRIPTION: Execute _REG method for a region * ******************************************************************************/ static ACPI_STATUS AcpiEvExecuteRegMethod ( ACPI_OPERAND_OBJECT *RegionObj, UINT32 Function) { ACPI_OPERAND_OBJECT *Params[3]; ACPI_OPERAND_OBJECT SpaceIdDesc; ACPI_OPERAND_OBJECT FunctionDesc; ACPI_STATUS Status; FUNCTION_TRACE ("EvExecuteRegMethod"); if (RegionObj->Region.Extra->Extra.Method_REG == NULL) { return_ACPI_STATUS (AE_OK); } /* * _REG method has two arguments * Arg0: Integer: Operation region space ID * Same value as RegionObj->Region.SpaceId * Arg1: Integer: connection status * 1 for connecting the handler, * 0 for disconnecting the handler * Passed as a parameter */ AcpiUtInitStaticObject (&SpaceIdDesc); AcpiUtInitStaticObject (&FunctionDesc); /* * Method requires two parameters. */ Params [0] = &SpaceIdDesc; Params [1] = &FunctionDesc; Params [2] = NULL; /* * Set up the parameter objects */ SpaceIdDesc.Common.Type = ACPI_TYPE_INTEGER; SpaceIdDesc.Integer.Value = RegionObj->Region.SpaceId; FunctionDesc.Common.Type = ACPI_TYPE_INTEGER; FunctionDesc.Integer.Value = Function; /* * Execute the method, no return value */ DEBUG_EXEC(AcpiUtDisplayInitPathname (RegionObj->Region.Extra->Extra.Method_REG, " [Method]")); Status = AcpiNsEvaluateByHandle (RegionObj->Region.Extra->Extra.Method_REG, Params, NULL); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiEvAddressSpaceDispatch * * PARAMETERS: RegionObj - internal region object * SpaceId - ID of the address space (0-255) * Function - Read or Write operation * Address - Where in the space to read or write * BitWidth - Field width in bits (8, 16, or 32) * Value - Pointer to in or out value * * RETURN: Status * * DESCRIPTION: Dispatch an address space or operation region access to * a previously installed handler. * ******************************************************************************/ ACPI_STATUS AcpiEvAddressSpaceDispatch ( ACPI_OPERAND_OBJECT *RegionObj, UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT32 *Value) { ACPI_STATUS Status; ACPI_ADR_SPACE_HANDLER Handler; ACPI_ADR_SPACE_SETUP RegionSetup; ACPI_OPERAND_OBJECT *HandlerDesc; void *RegionContext = NULL; FUNCTION_TRACE ("EvAddressSpaceDispatch"); /* * Ensure that there is a handler associated with this region */ HandlerDesc = RegionObj->Region.AddrHandler; if (!HandlerDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("no handler for region(%p) [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "no handler for region(%p) [%s]\n", RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId))); return_ACPI_STATUS(AE_NOT_EXIST); } /* * It may be the case that the region has never been initialized * Some types of regions require special init code */ if (!(RegionObj->Region.Flags & AOPOBJ_INITIALIZED)) { /* * This region has not been initialized yet, do it */ RegionSetup = HandlerDesc->AddrHandler.Setup; if (!RegionSetup) { /* * Bad news, no init routine and not init'd */ - DEBUG_PRINTP (ACPI_ERROR, ("No init routine for region(%p) [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No init routine for region(%p) [%s]\n", RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId))); return_ACPI_STATUS (AE_UNKNOWN_STATUS); } /* * We must exit the interpreter because the region setup will potentially * execute control methods */ AcpiExExitInterpreter (); Status = RegionSetup (RegionObj, ACPI_REGION_ACTIVATE, HandlerDesc->AddrHandler.Context, &RegionContext); /* Re-enter the interpreter */ AcpiExEnterInterpreter (); /* * Init routine may fail */ if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("Region Init: %s [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Region Init: %s [%s]\n", AcpiFormatException (Status), AcpiUtGetRegionName (RegionObj->Region.SpaceId))); return_ACPI_STATUS(Status); } RegionObj->Region.Flags |= AOPOBJ_INITIALIZED; /* * Save the returned context for use in all accesses to * this particular region. */ RegionObj->Region.Extra->Extra.RegionContext = RegionContext; } /* * We have everything we need, begin the process */ Handler = HandlerDesc->AddrHandler.Handler; - DEBUG_PRINTP ((TRACE_OPREGION | VERBOSE_INFO), - ("Addrhandler %p (%p), Address %8.8lX%8.8lX\n", + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "Addrhandler %p (%p), Address %8.8lX%8.8lX\n", &RegionObj->Region.AddrHandler->AddrHandler, Handler, HIDWORD(Address), LODWORD(Address))); if (!(HandlerDesc->AddrHandler.Flags & ADDR_HANDLER_DEFAULT_INSTALLED)) { /* * For handlers other than the default (supplied) handlers, we must * exit the interpreter because the handler *might* block -- we don't * know what it will do, so we can't hold the lock on the intepreter. */ AcpiExExitInterpreter(); } /* * Invoke the handler. */ Status = Handler (Function, Address, BitWidth, Value, HandlerDesc->AddrHandler.Context, RegionObj->Region.Extra->Extra.RegionContext); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("Region handler: %s [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Region handler: %s [%s]\n", AcpiFormatException (Status), AcpiUtGetRegionName (RegionObj->Region.SpaceId))); } if (!(HandlerDesc->AddrHandler.Flags & ADDR_HANDLER_DEFAULT_INSTALLED)) { /* We just returned from a non-default handler, we must re-enter the interpreter */ AcpiExEnterInterpreter (); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiEvDisassociateRegionFromHandler * * PARAMETERS: RegionObj - Region Object * AcpiNsIsLocked - Namespace Region Already Locked? * * RETURN: None * * DESCRIPTION: Break the association between the handler and the region * this is a two way association. * ******************************************************************************/ void AcpiEvDisassociateRegionFromHandler( ACPI_OPERAND_OBJECT *RegionObj, BOOLEAN AcpiNsIsLocked) { ACPI_OPERAND_OBJECT *HandlerObj; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT **LastObjPtr; ACPI_ADR_SPACE_SETUP RegionSetup; void *RegionContext; ACPI_STATUS Status; FUNCTION_TRACE ("EvDisassociateRegionFromHandler"); RegionContext = RegionObj->Region.Extra->Extra.RegionContext; /* * Get the address handler from the region object */ HandlerObj = RegionObj->Region.AddrHandler; if (!HandlerObj) { /* * This region has no handler, all done */ return_VOID; } /* * Find this region in the handler's list */ ObjDesc = HandlerObj->AddrHandler.RegionList; LastObjPtr = &HandlerObj->AddrHandler.RegionList; while (ObjDesc) { /* * See if this is the one */ if (ObjDesc == RegionObj) { - DEBUG_PRINTP (TRACE_OPREGION, - ("Removing Region %p from address handler %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "Removing Region %p from address handler %p\n", RegionObj, HandlerObj)); /* * This is it, remove it from the handler's list */ *LastObjPtr = ObjDesc->Region.Next; ObjDesc->Region.Next = NULL; /* Must clear field */ if (AcpiNsIsLocked) { AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); } /* * Now stop region accesses by executing the _REG method */ AcpiEvExecuteRegMethod (RegionObj, 0); if (AcpiNsIsLocked) { AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); } /* * Call the setup handler with the deactivate notification */ RegionSetup = HandlerObj->AddrHandler.Setup; Status = RegionSetup (RegionObj, ACPI_REGION_DEACTIVATE, HandlerObj->AddrHandler.Context, &RegionContext); /* * Init routine may fail, Just ignore errors */ if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("%s from region init, [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%s from region init, [%s]\n", AcpiFormatException (Status), AcpiUtGetRegionName (RegionObj->Region.SpaceId))); } RegionObj->Region.Flags &= ~(AOPOBJ_INITIALIZED); /* * Remove handler reference in the region * * NOTE: this doesn't mean that the region goes away * The region is just inaccessible as indicated to * the _REG method * * If the region is on the handler's list * this better be the region's handler */ RegionObj->Region.AddrHandler = NULL; return_VOID; } /* found the right handler */ /* * Move through the linked list of handlers */ LastObjPtr = &ObjDesc->Region.Next; ObjDesc = ObjDesc->Region.Next; } /* * If we get here, the region was not in the handler's region list */ - DEBUG_PRINTP (TRACE_OPREGION, - ("Cannot remove region %p from address handler %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "Cannot remove region %p from address handler %p\n", RegionObj, HandlerObj)); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiEvAssociateRegionAndHandler * * PARAMETERS: HandlerObj - Handler Object * RegionObj - Region Object * AcpiNsIsLocked - Namespace Region Already Locked? * * RETURN: None * * DESCRIPTION: Create the association between the handler and the region * this is a two way association. * ******************************************************************************/ ACPI_STATUS AcpiEvAssociateRegionAndHandler ( ACPI_OPERAND_OBJECT *HandlerObj, ACPI_OPERAND_OBJECT *RegionObj, BOOLEAN AcpiNsIsLocked) { ACPI_STATUS Status; FUNCTION_TRACE ("EvAssociateRegionAndHandler"); - DEBUG_PRINTP (TRACE_OPREGION, - ("Adding Region %p to address handler %p [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "Adding Region %p to address handler %p [%s]\n", RegionObj, HandlerObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId))); /* * Link this region to the front of the handler's list */ RegionObj->Region.Next = HandlerObj->AddrHandler.RegionList; HandlerObj->AddrHandler.RegionList = RegionObj; /* * set the region's handler */ RegionObj->Region.AddrHandler = HandlerObj; /* * Last thing, tell all users that this region is usable */ if (AcpiNsIsLocked) { AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); } Status = AcpiEvExecuteRegMethod (RegionObj, 1); if (AcpiNsIsLocked) { AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiEvAddrHandlerHelper * * PARAMETERS: Handle - Node to be dumped * Level - Nesting level of the handle * Context - Passed into AcpiNsWalkNamespace * * DESCRIPTION: This routine checks to see if the object is a Region if it * is then the address handler is installed in it. * * If the Object is a Device, and the device has a handler of * the same type then the search is terminated in that branch. * * This is because the existing handler is closer in proximity * to any more regions than the one we are trying to install. * ******************************************************************************/ ACPI_STATUS AcpiEvAddrHandlerHelper ( ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue) { ACPI_OPERAND_OBJECT *HandlerObj; ACPI_OPERAND_OBJECT *TmpObj; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_NAMESPACE_NODE *Node; ACPI_STATUS Status; PROC_NAME ("EvAddrHandlerHelper"); HandlerObj = (ACPI_OPERAND_OBJECT *) Context; /* Parameter validation */ if (!HandlerObj) { return (AE_OK); } /* Convert and validate the device handle */ Node = AcpiNsConvertHandleToEntry (ObjHandle); if (!Node) { return (AE_BAD_PARAMETER); } /* * We only care about regions.and objects * that can have address handlers */ if ((Node->Type != ACPI_TYPE_DEVICE) && (Node->Type != ACPI_TYPE_REGION) && (Node != AcpiGbl_RootNode)) { return (AE_OK); } /* Check for an existing internal object */ ObjDesc = AcpiNsGetAttachedObject (Node); if (!ObjDesc) { /* * The object DNE, we don't care about it */ return (AE_OK); } /* * Devices are handled different than regions */ if (IS_THIS_OBJECT_TYPE (ObjDesc, ACPI_TYPE_DEVICE)) { /* * See if this guy has any handlers */ TmpObj = ObjDesc->Device.AddrHandler; while (TmpObj) { /* * Now let's see if it's for the same address space. */ if (TmpObj->AddrHandler.SpaceId == HandlerObj->AddrHandler.SpaceId) { /* * It's for the same address space */ - DEBUG_PRINTP (TRACE_OPREGION, - ("Found handler for region [%s] in device %p(%p) handler %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "Found handler for region [%s] in device %p(%p) handler %p\n", AcpiUtGetRegionName (HandlerObj->AddrHandler.SpaceId), ObjDesc, TmpObj, HandlerObj)); /* * Since the object we found it on was a device, then it * means that someone has already installed a handler for * the branch of the namespace from this device on. Just * bail out telling the walk routine to not traverse this * branch. This preserves the scoping rule for handlers. */ return (AE_CTRL_DEPTH); } /* * Move through the linked list of handlers */ TmpObj = TmpObj->AddrHandler.Next; } /* * As long as the device didn't have a handler for this * space we don't care about it. We just ignore it and * proceed. */ return (AE_OK); } /* * Only here if it was a region */ if (ObjDesc->Region.SpaceId != HandlerObj->AddrHandler.SpaceId) { /* * This region is for a different address space * ignore it */ return (AE_OK); } /* * Now we have a region and it is for the handler's address * space type. * * First disconnect region for any previous handler (if any) */ AcpiEvDisassociateRegionFromHandler (ObjDesc, FALSE); /* * Then connect the region to the new handler */ Status = AcpiEvAssociateRegionAndHandler (HandlerObj, ObjDesc, FALSE); return (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/evrgnini.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/evrgnini.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/evrgnini.c (revision 82367) @@ -1,553 +1,553 @@ /****************************************************************************** * * Module Name: evrgnini- ACPI AddressSpace (OpRegion) init - * $Revision: 44 $ + * $Revision: 45 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EVRGNINI_C__ #include "acpi.h" #include "acevents.h" #include "acnamesp.h" #include "acinterp.h" #include "amlcode.h" #define _COMPONENT ACPI_EVENTS MODULE_NAME ("evrgnini") /******************************************************************************* * * FUNCTION: AcpiEvSystemMemoryRegionSetup * * PARAMETERS: RegionObj - region we are interested in * Function - start or stop * HandlerContext - Address space handler context * RegionContext - Region specific context * * RETURN: Status * * DESCRIPTION: Do any prep work for region handling, a nop for now * ******************************************************************************/ ACPI_STATUS AcpiEvSystemMemoryRegionSetup ( ACPI_HANDLE Handle, UINT32 Function, void *HandlerContext, void **RegionContext) { FUNCTION_TRACE ("EvSystemMemoryRegionSetup"); if (Function == ACPI_REGION_DEACTIVATE) { if (*RegionContext) { ACPI_MEM_FREE (*RegionContext); *RegionContext = NULL; } return_ACPI_STATUS (AE_OK); } /* Activate. Create a new context */ *RegionContext = ACPI_MEM_CALLOCATE (sizeof (ACPI_MEM_SPACE_CONTEXT)); if (!(*RegionContext)) { return_ACPI_STATUS (AE_NO_MEMORY); } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiEvIoSpaceRegionSetup * * PARAMETERS: RegionObj - region we are interested in * Function - start or stop * HandlerContext - Address space handler context * RegionContext - Region specific context * * RETURN: Status * * DESCRIPTION: Do any prep work for region handling * ******************************************************************************/ ACPI_STATUS AcpiEvIoSpaceRegionSetup ( ACPI_HANDLE Handle, UINT32 Function, void *HandlerContext, void **RegionContext) { FUNCTION_TRACE ("EvIoSpaceRegionSetup"); if (Function == ACPI_REGION_DEACTIVATE) { *RegionContext = NULL; } else { *RegionContext = HandlerContext; } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiEvPciConfigRegionSetup * * PARAMETERS: RegionObj - region we are interested in * Function - start or stop * HandlerContext - Address space handler context * RegionContext - Region specific context * * RETURN: Status * * DESCRIPTION: Do any prep work for region handling * * MUTEX: Assumes namespace is not locked * ******************************************************************************/ ACPI_STATUS AcpiEvPciConfigRegionSetup ( ACPI_HANDLE Handle, UINT32 Function, void *HandlerContext, void **RegionContext) { ACPI_STATUS Status = AE_OK; ACPI_INTEGER Temp; ACPI_PCI_ID *PciId = *RegionContext; ACPI_OPERAND_OBJECT *HandlerObj; ACPI_NAMESPACE_NODE *Node; ACPI_OPERAND_OBJECT *RegionObj = (ACPI_OPERAND_OBJECT *) Handle; ACPI_DEVICE_ID ObjectHID; FUNCTION_TRACE ("EvPciConfigRegionSetup"); HandlerObj = RegionObj->Region.AddrHandler; if (!HandlerObj) { /* * No installed handler. This shouldn't happen because the dispatch * routine checks before we get here, but we check again just in case. */ - DEBUG_PRINTP (TRACE_OPREGION, - ("Attempting to init a region %X, with no handler\n", RegionObj)); + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "Attempting to init a region %X, with no handler\n", RegionObj)); return_ACPI_STATUS (AE_NOT_EXIST); } if (Function == ACPI_REGION_DEACTIVATE) { if (PciId) { ACPI_MEM_FREE (PciId); *RegionContext = NULL; } return_ACPI_STATUS (Status); } /* Create a new context */ PciId = ACPI_MEM_CALLOCATE (sizeof (ACPI_PCI_ID)); if (!PciId) { return_ACPI_STATUS (AE_NO_MEMORY); } /* * For PCI Config space access, we have to pass the segment, bus, * device and function numbers. This routine must acquire those. */ /* * First get device and function numbers from the _ADR object * in the parent's scope. */ Node = AcpiNsGetParentObject (RegionObj->Region.Node); /* AcpiEvaluate the _ADR object */ Status = AcpiUtEvaluateNumericObject (METHOD_NAME__ADR, Node, &Temp); /* * The default is zero, since the allocation above zeroed the data, just * do nothing on failures. */ if (ACPI_SUCCESS (Status)) { PciId->Device = HIWORD (Temp); PciId->Function = LOWORD (Temp); } /* * Get the _SEG and _BBN values from the device upon which the handler * is installed. * * We need to get the _SEG and _BBN objects relative to the PCI BUS device. * This is the device the handler has been registered to handle. */ /* * If the AddrHandler.Node is still pointing to the root, we need * to scan upward for a PCI Root bridge and re-associate the OpRegion * handlers with that device. */ if (HandlerObj->AddrHandler.Node == AcpiGbl_RootNode) { /* * Node is currently the parent object */ while (Node != AcpiGbl_RootNode) { Status = AcpiUtExecute_HID (Node, &ObjectHID); if (ACPI_SUCCESS (Status)) { if (!(STRNCMP (ObjectHID.Buffer, PCI_ROOT_HID_STRING, sizeof (PCI_ROOT_HID_STRING)))) { AcpiInstallAddressSpaceHandler (Node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL); break; } } Node = AcpiNsGetParentObject (Node); } } else { Node = HandlerObj->AddrHandler.Node; } /* * The PCI segment number comes from the _SEG method */ Status = AcpiUtEvaluateNumericObject (METHOD_NAME__SEG, Node, &Temp); if (ACPI_SUCCESS (Status)) { PciId->Segment = LOWORD (Temp); } /* * The PCI bus number comes from the _BBN method */ Status = AcpiUtEvaluateNumericObject (METHOD_NAME__BBN, Node, &Temp); if (ACPI_SUCCESS (Status)) { PciId->Bus = LOWORD (Temp); } *RegionContext = PciId; return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiEvDefaultRegionSetup * * PARAMETERS: RegionObj - region we are interested in * Function - start or stop * HandlerContext - Address space handler context * RegionContext - Region specific context * * RETURN: Status * * DESCRIPTION: Do any prep work for region handling * ******************************************************************************/ ACPI_STATUS AcpiEvDefaultRegionSetup ( ACPI_HANDLE Handle, UINT32 Function, void *HandlerContext, void **RegionContext) { FUNCTION_TRACE ("EvDefaultRegionSetup"); if (Function == ACPI_REGION_DEACTIVATE) { *RegionContext = NULL; } else { *RegionContext = HandlerContext; } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiEvInitializeRegion * * PARAMETERS: RegionObj - Region we are initializing * * RETURN: Status * * DESCRIPTION: Initializes the region, finds any _REG methods and saves them * for execution at a later time * * Get the appropriate address space handler for a newly * created region. * * This also performs address space specific intialization. For * example, PCI regions must have an _ADR object that contains * a PCI address in the scope of the definition. This address is * required to perform an access to PCI config space. * ******************************************************************************/ ACPI_STATUS AcpiEvInitializeRegion ( ACPI_OPERAND_OBJECT *RegionObj, BOOLEAN AcpiNsLocked) { ACPI_OPERAND_OBJECT *HandlerObj; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_ADR_SPACE_TYPE SpaceId; ACPI_NAMESPACE_NODE *Node; ACPI_STATUS Status; ACPI_NAMESPACE_NODE *MethodNode; ACPI_NAME *RegNamePtr = (ACPI_NAME *) METHOD_NAME__REG; FUNCTION_TRACE_U32 ("EvInitializeRegion", AcpiNsLocked); if (!RegionObj) { return_ACPI_STATUS (AE_BAD_PARAMETER); } Node = AcpiNsGetParentObject (RegionObj->Region.Node); SpaceId = RegionObj->Region.SpaceId; RegionObj->Region.AddrHandler = NULL; RegionObj->Region.Extra->Extra.Method_REG = NULL; RegionObj->Region.Flags &= ~(AOPOBJ_INITIALIZED); /* * Find any "_REG" associated with this region definition */ Status = AcpiNsSearchNode (*RegNamePtr, Node, ACPI_TYPE_METHOD, &MethodNode); if (ACPI_SUCCESS (Status)) { /* * The _REG method is optional and there can be only one per region * definition. This will be executed when the handler is attached * or removed */ RegionObj->Region.Extra->Extra.Method_REG = MethodNode; } /* * The following loop depends upon the root Node having no parent * ie: AcpiGbl_RootNode->ParentEntry being set to NULL */ while (Node) { /* * Check to see if a handler exists */ HandlerObj = NULL; ObjDesc = AcpiNsGetAttachedObject (Node); if (ObjDesc) { /* * can only be a handler if the object exists */ switch (Node->Type) { case ACPI_TYPE_DEVICE: HandlerObj = ObjDesc->Device.AddrHandler; break; case ACPI_TYPE_PROCESSOR: HandlerObj = ObjDesc->Processor.AddrHandler; break; case ACPI_TYPE_THERMAL: HandlerObj = ObjDesc->ThermalZone.AddrHandler; break; } while (HandlerObj) { /* * This guy has at least one address handler * see if it has the type we want */ if (HandlerObj->AddrHandler.SpaceId == SpaceId) { - DEBUG_PRINTP (TRACE_OPREGION, - ("Found handler %p for region %p in obj %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "Found handler %p for region %p in obj %p\n", HandlerObj, RegionObj, ObjDesc)); /* * Found it! Now update the region and the handler */ AcpiEvAssociateRegionAndHandler (HandlerObj, RegionObj, AcpiNsLocked); return_ACPI_STATUS (AE_OK); } HandlerObj = HandlerObj->AddrHandler.Next; } /* while handlerobj */ } /* * This one does not have the handler we need * Pop up one level */ Node = AcpiNsGetParentObject (Node); } /* while Node != ROOT */ /* * If we get here, there is no handler for this region */ - DEBUG_PRINTP (TRACE_OPREGION, - ("No handler for RegionType %s(%X) (RegionObj %p)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "No handler for RegionType %s(%X) (RegionObj %p)\n", AcpiUtGetRegionName (SpaceId), SpaceId, RegionObj)); return_ACPI_STATUS (AE_NOT_EXIST); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/evxface.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/evxface.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/evxface.c (revision 82367) @@ -1,843 +1,843 @@ /****************************************************************************** * * Module Name: evxface - External interfaces for ACPI events - * $Revision: 110 $ + * $Revision: 111 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial prton of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EVXFACE_C__ #include "acpi.h" #include "achware.h" #include "acnamesp.h" #include "acevents.h" #include "amlcode.h" #include "acinterp.h" #define _COMPONENT ACPI_EVENTS MODULE_NAME ("evxface") /******************************************************************************* * * FUNCTION: AcpiInstallFixedEventHandler * * PARAMETERS: Event - Event type to enable. * Handler - Pointer to the handler function for the * event * Context - Value passed to the handler on each GPE * * RETURN: Status * * DESCRIPTION: Saves the pointer to the handler function and then enables the * event. * ******************************************************************************/ ACPI_STATUS AcpiInstallFixedEventHandler ( UINT32 Event, ACPI_EVENT_HANDLER Handler, void *Context) { ACPI_STATUS Status; FUNCTION_TRACE ("AcpiInstallFixedEventHandler"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parameter validation */ if (Event > ACPI_EVENT_MAX) { return_ACPI_STATUS (AE_BAD_PARAMETER); } AcpiUtAcquireMutex (ACPI_MTX_EVENTS); /* Don't allow two handlers. */ if (NULL != AcpiGbl_FixedEventHandlers[Event].Handler) { Status = AE_EXIST; goto Cleanup; } /* Install the handler before enabling the event - just in case... */ AcpiGbl_FixedEventHandlers[Event].Handler = Handler; AcpiGbl_FixedEventHandlers[Event].Context = Context; Status = AcpiEnableEvent (Event, ACPI_EVENT_FIXED); if (!ACPI_SUCCESS (Status)) { - DEBUG_PRINTP (ACPI_WARN, ("Could not enable fixed event.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Could not enable fixed event.\n")); /* Remove the handler */ AcpiGbl_FixedEventHandlers[Event].Handler = NULL; AcpiGbl_FixedEventHandlers[Event].Context = NULL; } else { - DEBUG_PRINTP (ACPI_INFO, - ("Enabled fixed event %X, Handler=%p\n", Event, Handler)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Enabled fixed event %X, Handler=%p\n", Event, Handler)); } Cleanup: AcpiUtReleaseMutex (ACPI_MTX_EVENTS); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiRemoveFixedEventHandler * * PARAMETERS: Event - Event type to disable. * Handler - Address of the handler * * RETURN: Status * * DESCRIPTION: Disables the event and unregisters the event handler. * ******************************************************************************/ ACPI_STATUS AcpiRemoveFixedEventHandler ( UINT32 Event, ACPI_EVENT_HANDLER Handler) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("AcpiRemoveFixedEventHandler"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parameter validation */ if (Event > ACPI_EVENT_MAX) { return_ACPI_STATUS (AE_BAD_PARAMETER); } AcpiUtAcquireMutex (ACPI_MTX_EVENTS); /* Disable the event before removing the handler - just in case... */ Status = AcpiDisableEvent(Event, ACPI_EVENT_FIXED); /* Always Remove the handler */ AcpiGbl_FixedEventHandlers[Event].Handler = NULL; AcpiGbl_FixedEventHandlers[Event].Context = NULL; if (!ACPI_SUCCESS(Status)) { - DEBUG_PRINTP (ACPI_WARN, - ("Could not write to fixed event enable register.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, + "Could not write to fixed event enable register.\n")); } else { - DEBUG_PRINTP (ACPI_INFO, ("Disabled fixed event %X.\n", Event)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Disabled fixed event %X.\n", Event)); } AcpiUtReleaseMutex (ACPI_MTX_EVENTS); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiInstallNotifyHandler * * PARAMETERS: Device - The device for which notifies will be handled * HandlerType - The type of handler: * ACPI_SYSTEM_NOTIFY: SystemHandler (00-7f) * ACPI_DEVICE_NOTIFY: DriverHandler (80-ff) * Handler - Address of the handler * Context - Value passed to the handler on each GPE * * RETURN: Status * * DESCRIPTION: Install a handler for notifies on an ACPI device * ******************************************************************************/ ACPI_STATUS AcpiInstallNotifyHandler ( ACPI_HANDLE Device, UINT32 HandlerType, ACPI_NOTIFY_HANDLER Handler, void *Context) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *NotifyObj; ACPI_NAMESPACE_NODE *DeviceNode; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("AcpiInstallNotifyHandler"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parameter validation */ if ((!Handler) || (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); /* Convert and validate the device handle */ DeviceNode = AcpiNsConvertHandleToEntry (Device); if (!DeviceNode) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } /* * Root Object: * ------------ * Registering a notify handler on the root object indicates that the * caller wishes to receive notifications for all objects. Note that * only one global handler can be regsitered (per notify type). */ if (Device == ACPI_ROOT_OBJECT) { /* Make sure the handler is not already installed */ if (((HandlerType == ACPI_SYSTEM_NOTIFY) && AcpiGbl_SysNotify.Handler) || ((HandlerType == ACPI_DEVICE_NOTIFY) && AcpiGbl_DrvNotify.Handler)) { Status = AE_EXIST; goto UnlockAndExit; } if (HandlerType == ACPI_SYSTEM_NOTIFY) { AcpiGbl_SysNotify.Node = DeviceNode; AcpiGbl_SysNotify.Handler = Handler; AcpiGbl_SysNotify.Context = Context; } else /* ACPI_DEVICE_NOTIFY */ { AcpiGbl_DrvNotify.Node = DeviceNode; AcpiGbl_DrvNotify.Handler = Handler; AcpiGbl_DrvNotify.Context = Context; } /* Global notify handler installed */ } /* * Other Objects: * -------------- * Caller will only receive notifications specific to the target object. * Note that only certain object types can receive notifications. */ else { /* * These are the ONLY objects that can receive ACPI notifications */ if ((DeviceNode->Type != ACPI_TYPE_DEVICE) && (DeviceNode->Type != ACPI_TYPE_PROCESSOR) && (DeviceNode->Type != ACPI_TYPE_POWER) && (DeviceNode->Type != ACPI_TYPE_THERMAL)) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } /* Check for an existing internal object */ ObjDesc = AcpiNsGetAttachedObject (DeviceNode); if (ObjDesc) { /* Object exists - make sure there's no handler */ if (((HandlerType == ACPI_SYSTEM_NOTIFY) && ObjDesc->Device.SysHandler) || ((HandlerType == ACPI_DEVICE_NOTIFY) && ObjDesc->Device.DrvHandler)) { Status = AE_EXIST; goto UnlockAndExit; } } else { /* Create a new object */ ObjDesc = AcpiUtCreateInternalObject (DeviceNode->Type); if (!ObjDesc) { Status = AE_NO_MEMORY; goto UnlockAndExit; } /* Attach new object to the Node */ Status = AcpiNsAttachObject (Device, ObjDesc, (UINT8) DeviceNode->Type); if (ACPI_FAILURE (Status)) { goto UnlockAndExit; } } /* Install the handler */ NotifyObj = AcpiUtCreateInternalObject (INTERNAL_TYPE_NOTIFY); if (!NotifyObj) { Status = AE_NO_MEMORY; goto UnlockAndExit; } NotifyObj->NotifyHandler.Node = DeviceNode; NotifyObj->NotifyHandler.Handler = Handler; NotifyObj->NotifyHandler.Context = Context; if (HandlerType == ACPI_SYSTEM_NOTIFY) { ObjDesc->Device.SysHandler = NotifyObj; } else /* ACPI_DEVICE_NOTIFY */ { ObjDesc->Device.DrvHandler = NotifyObj; } } UnlockAndExit: AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiRemoveNotifyHandler * * PARAMETERS: Device - The device for which notifies will be handled * HandlerType - The type of handler: * ACPI_SYSTEM_NOTIFY: SystemHandler (00-7f) * ACPI_DEVICE_NOTIFY: DriverHandler (80-ff) * Handler - Address of the handler * RETURN: Status * * DESCRIPTION: Remove a handler for notifies on an ACPI device * ******************************************************************************/ ACPI_STATUS AcpiRemoveNotifyHandler ( ACPI_HANDLE Device, UINT32 HandlerType, ACPI_NOTIFY_HANDLER Handler) { ACPI_OPERAND_OBJECT *NotifyObj; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_NAMESPACE_NODE *DeviceNode; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("AcpiRemoveNotifyHandler"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parameter validation */ if ((!Handler) || (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); /* Convert and validate the device handle */ DeviceNode = AcpiNsConvertHandleToEntry (Device); if (!DeviceNode) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } /* * Root Object: * ------------ */ if (Device == ACPI_ROOT_OBJECT) { - DEBUG_PRINTP (ACPI_INFO, ("Removing notify handler for ROOT object.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Removing notify handler for ROOT object.\n")); if (((HandlerType == ACPI_SYSTEM_NOTIFY) && !AcpiGbl_SysNotify.Handler) || ((HandlerType == ACPI_DEVICE_NOTIFY) && !AcpiGbl_DrvNotify.Handler)) { Status = AE_NOT_EXIST; goto UnlockAndExit; } if (HandlerType == ACPI_SYSTEM_NOTIFY) { AcpiGbl_SysNotify.Node = NULL; AcpiGbl_SysNotify.Handler = NULL; AcpiGbl_SysNotify.Context = NULL; } else { AcpiGbl_DrvNotify.Node = NULL; AcpiGbl_DrvNotify.Handler = NULL; AcpiGbl_DrvNotify.Context = NULL; } } /* * Other Objects: * -------------- */ else { /* * These are the ONLY objects that can receive ACPI notifications */ if ((DeviceNode->Type != ACPI_TYPE_DEVICE) && (DeviceNode->Type != ACPI_TYPE_PROCESSOR) && (DeviceNode->Type != ACPI_TYPE_POWER) && (DeviceNode->Type != ACPI_TYPE_THERMAL)) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } /* Check for an existing internal object */ ObjDesc = AcpiNsGetAttachedObject (DeviceNode); if (!ObjDesc) { Status = AE_NOT_EXIST; goto UnlockAndExit; } /* Object exists - make sure there's an existing handler */ if (HandlerType == ACPI_SYSTEM_NOTIFY) { NotifyObj = ObjDesc->Device.SysHandler; } else { NotifyObj = ObjDesc->Device.DrvHandler; } if ((!NotifyObj) || (NotifyObj->NotifyHandler.Handler != Handler)) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } /* Remove the handler */ if (HandlerType == ACPI_SYSTEM_NOTIFY) { ObjDesc->Device.SysHandler = NULL; } else { ObjDesc->Device.DrvHandler = NULL; } AcpiUtRemoveReference (NotifyObj); } UnlockAndExit: AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiInstallGpeHandler * * PARAMETERS: GpeNumber - The GPE number. The numbering scheme is * bank 0 first, then bank 1. * Type - Whether this GPE should be treated as an * edge- or level-triggered interrupt. * Handler - Address of the handler * Context - Value passed to the handler on each GPE * * RETURN: Status * * DESCRIPTION: Install a handler for a General Purpose Event. * ******************************************************************************/ ACPI_STATUS AcpiInstallGpeHandler ( UINT32 GpeNumber, UINT32 Type, ACPI_GPE_HANDLER Handler, void *Context) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("AcpiInstallGpeHandler"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parameter validation */ if (!Handler || (GpeNumber > ACPI_GPE_MAX)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Ensure that we have a valid GPE number */ if (AcpiGbl_GpeValid[GpeNumber] == ACPI_GPE_INVALID) { return_ACPI_STATUS (AE_BAD_PARAMETER); } AcpiUtAcquireMutex (ACPI_MTX_EVENTS); /* Make sure that there isn't a handler there already */ if (AcpiGbl_GpeInfo[GpeNumber].Handler) { Status = AE_EXIST; goto Cleanup; } /* Install the handler */ AcpiGbl_GpeInfo[GpeNumber].Handler = Handler; AcpiGbl_GpeInfo[GpeNumber].Context = Context; AcpiGbl_GpeInfo[GpeNumber].Type = (UINT8) Type; /* Clear the GPE (of stale events), the enable it */ AcpiHwClearGpe (GpeNumber); AcpiHwEnableGpe (GpeNumber); Cleanup: AcpiUtReleaseMutex (ACPI_MTX_EVENTS); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiRemoveGpeHandler * * PARAMETERS: GpeNumber - The event to remove a handler * Handler - Address of the handler * * RETURN: Status * * DESCRIPTION: Remove a handler for a General Purpose AcpiEvent. * ******************************************************************************/ ACPI_STATUS AcpiRemoveGpeHandler ( UINT32 GpeNumber, ACPI_GPE_HANDLER Handler) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("AcpiRemoveGpeHandler"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parameter validation */ if (!Handler || (GpeNumber > ACPI_GPE_MAX)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Ensure that we have a valid GPE number */ if (AcpiGbl_GpeValid[GpeNumber] == ACPI_GPE_INVALID) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Disable the GPE before removing the handler */ AcpiHwDisableGpe (GpeNumber); AcpiUtAcquireMutex (ACPI_MTX_EVENTS); /* Make sure that the installed handler is the same */ if (AcpiGbl_GpeInfo[GpeNumber].Handler != Handler) { AcpiHwEnableGpe (GpeNumber); Status = AE_BAD_PARAMETER; goto Cleanup; } /* Remove the handler */ AcpiGbl_GpeInfo[GpeNumber].Handler = NULL; AcpiGbl_GpeInfo[GpeNumber].Context = NULL; Cleanup: AcpiUtReleaseMutex (ACPI_MTX_EVENTS); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiAcquireGlobalLock * * PARAMETERS: Timeout - How long the caller is willing to wait * OutHandle - A handle to the lock if acquired * * RETURN: Status * * DESCRIPTION: Acquire the ACPI Global Lock * ******************************************************************************/ ACPI_STATUS AcpiAcquireGlobalLock ( void) { ACPI_STATUS Status; /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return (Status); } Status = AcpiExEnterInterpreter (); if (ACPI_FAILURE (Status)) { return (Status); } /* * TBD: [Restructure] add timeout param to internal interface, and * perhaps INTERPRETER_LOCKED */ Status = AcpiEvAcquireGlobalLock (); AcpiExExitInterpreter (); return (Status); } /******************************************************************************* * * FUNCTION: AcpiReleaseGlobalLock * * PARAMETERS: Handle - Returned from AcpiAcquireGlobalLock * * RETURN: Status * * DESCRIPTION: Release the ACPI Global Lock * ******************************************************************************/ ACPI_STATUS AcpiReleaseGlobalLock ( void) { ACPI_STATUS Status; /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return (Status); } AcpiEvReleaseGlobalLock (); return (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/evxfevnt.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/evxfevnt.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/evxfevnt.c (revision 82367) @@ -1,665 +1,665 @@ /****************************************************************************** * * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable - * $Revision: 33 $ + * $Revision: 34 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial prton of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EVXFEVNT_C__ #include "acpi.h" #include "achware.h" #include "acnamesp.h" #include "acevents.h" #include "amlcode.h" #include "acinterp.h" #define _COMPONENT ACPI_EVENTS MODULE_NAME ("evxfevnt") /******************************************************************************* * * FUNCTION: AcpiEnable * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Transfers the system into ACPI mode. * ******************************************************************************/ ACPI_STATUS AcpiEnable (void) { ACPI_STATUS Status; FUNCTION_TRACE ("AcpiEnable"); /* Make sure we've got ACPI tables */ if (!AcpiGbl_DSDT) { - DEBUG_PRINTP (ACPI_WARN, ("No ACPI tables present!\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "No ACPI tables present!\n")); return_ACPI_STATUS (AE_NO_ACPI_TABLES); } /* Make sure the BIOS supports ACPI mode */ if (SYS_MODE_LEGACY == AcpiHwGetModeCapabilities()) { - DEBUG_PRINTP (ACPI_WARN, ("Only legacy mode supported!\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Only legacy mode supported!\n")); return_ACPI_STATUS (AE_ERROR); } /* Transition to ACPI mode */ Status = AcpiHwSetMode (SYS_MODE_ACPI); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_FATAL, ("Could not transition to ACPI mode.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_FATAL, "Could not transition to ACPI mode.\n")); return_ACPI_STATUS (Status); } - DEBUG_PRINTP (ACPI_OK, ("Transition to ACPI mode successful\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_OK, "Transition to ACPI mode successful\n")); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiDisable * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Returns the system to original ACPI/legacy mode, and * uninstalls the SCI interrupt handler. * ******************************************************************************/ ACPI_STATUS AcpiDisable (void) { ACPI_STATUS Status; FUNCTION_TRACE ("AcpiDisable"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Restore original mode */ Status = AcpiHwSetMode (AcpiGbl_OriginalMode); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("Unable to transition to original mode")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unable to transition to original mode")); return_ACPI_STATUS (Status); } /* Unload the SCI interrupt handler */ AcpiEvRemoveSciHandler (); AcpiEvRestoreAcpiState (); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiEnableEvent * * PARAMETERS: Event - The fixed event or GPE to be enabled * Type - The type of event * * RETURN: Status * * DESCRIPTION: Enable an ACPI event (fixed and general purpose) * ******************************************************************************/ ACPI_STATUS AcpiEnableEvent ( UINT32 Event, UINT32 Type) { ACPI_STATUS Status = AE_OK; UINT32 RegisterId; FUNCTION_TRACE ("AcpiEnableEvent"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* The Type must be either Fixed AcpiEvent or GPE */ switch (Type) { case ACPI_EVENT_FIXED: /* Decode the Fixed AcpiEvent */ switch (Event) { case ACPI_EVENT_PMTIMER: RegisterId = TMR_EN; break; case ACPI_EVENT_GLOBAL: RegisterId = GBL_EN; break; case ACPI_EVENT_POWER_BUTTON: RegisterId = PWRBTN_EN; break; case ACPI_EVENT_SLEEP_BUTTON: RegisterId = SLPBTN_EN; break; case ACPI_EVENT_RTC: RegisterId = RTC_EN; break; default: return_ACPI_STATUS (AE_BAD_PARAMETER); break; } /* * Enable the requested fixed event (by writing a one to the * enable register bit) */ AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, RegisterId, 1); if (1 != AcpiHwRegisterBitAccess(ACPI_READ, ACPI_MTX_LOCK, RegisterId)) { - DEBUG_PRINTP (ACPI_ERROR, - ("Fixed event bit clear when it should be set\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Fixed event bit clear when it should be set\n")); return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE); } break; case ACPI_EVENT_GPE: /* Ensure that we have a valid GPE number */ if ((Event > ACPI_GPE_MAX) || (AcpiGbl_GpeValid[Event] == ACPI_GPE_INVALID)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Enable the requested GPE number */ AcpiHwEnableGpe (Event); break; default: Status = AE_BAD_PARAMETER; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiDisableEvent * * PARAMETERS: Event - The fixed event or GPE to be enabled * Type - The type of event * * RETURN: Status * * DESCRIPTION: Disable an ACPI event (fixed and general purpose) * ******************************************************************************/ ACPI_STATUS AcpiDisableEvent ( UINT32 Event, UINT32 Type) { ACPI_STATUS Status = AE_OK; UINT32 RegisterId; FUNCTION_TRACE ("AcpiDisableEvent"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* The Type must be either Fixed AcpiEvent or GPE */ switch (Type) { case ACPI_EVENT_FIXED: /* Decode the Fixed AcpiEvent */ switch (Event) { case ACPI_EVENT_PMTIMER: RegisterId = TMR_EN; break; case ACPI_EVENT_GLOBAL: RegisterId = GBL_EN; break; case ACPI_EVENT_POWER_BUTTON: RegisterId = PWRBTN_EN; break; case ACPI_EVENT_SLEEP_BUTTON: RegisterId = SLPBTN_EN; break; case ACPI_EVENT_RTC: RegisterId = RTC_EN; break; default: return_ACPI_STATUS (AE_BAD_PARAMETER); break; } /* * Disable the requested fixed event (by writing a zero to the * enable register bit) */ AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, RegisterId, 0); if (0 != AcpiHwRegisterBitAccess(ACPI_READ, ACPI_MTX_LOCK, RegisterId)) { - DEBUG_PRINTP (ACPI_ERROR, - ("Fixed event bit set when it should be clear,\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Fixed event bit set when it should be clear,\n")); return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE); } break; case ACPI_EVENT_GPE: /* Ensure that we have a valid GPE number */ if ((Event > ACPI_GPE_MAX) || (AcpiGbl_GpeValid[Event] == ACPI_GPE_INVALID)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Disable the requested GPE number */ AcpiHwDisableGpe (Event); break; default: Status = AE_BAD_PARAMETER; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiClearEvent * * PARAMETERS: Event - The fixed event or GPE to be cleared * Type - The type of event * * RETURN: Status * * DESCRIPTION: Clear an ACPI event (fixed and general purpose) * ******************************************************************************/ ACPI_STATUS AcpiClearEvent ( UINT32 Event, UINT32 Type) { ACPI_STATUS Status = AE_OK; UINT32 RegisterId; FUNCTION_TRACE ("AcpiClearEvent"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* The Type must be either Fixed AcpiEvent or GPE */ switch (Type) { case ACPI_EVENT_FIXED: /* Decode the Fixed AcpiEvent */ switch (Event) { case ACPI_EVENT_PMTIMER: RegisterId = TMR_STS; break; case ACPI_EVENT_GLOBAL: RegisterId = GBL_STS; break; case ACPI_EVENT_POWER_BUTTON: RegisterId = PWRBTN_STS; break; case ACPI_EVENT_SLEEP_BUTTON: RegisterId = SLPBTN_STS; break; case ACPI_EVENT_RTC: RegisterId = RTC_STS; break; default: return_ACPI_STATUS (AE_BAD_PARAMETER); break; } /* * Clear the requested fixed event (By writing a one to the * status register bit) */ AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, RegisterId, 1); break; case ACPI_EVENT_GPE: /* Ensure that we have a valid GPE number */ if ((Event > ACPI_GPE_MAX) || (AcpiGbl_GpeValid[Event] == ACPI_GPE_INVALID)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } AcpiHwClearGpe (Event); break; default: Status = AE_BAD_PARAMETER; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiGetEventStatus * * PARAMETERS: Event - The fixed event or GPE * Type - The type of event * Status - Where the current status of the event will * be returned * * RETURN: Status * * DESCRIPTION: Obtains and returns the current status of the event * ******************************************************************************/ ACPI_STATUS AcpiGetEventStatus ( UINT32 Event, UINT32 Type, ACPI_EVENT_STATUS *EventStatus) { ACPI_STATUS Status = AE_OK; UINT32 RegisterId; FUNCTION_TRACE ("AcpiGetEventStatus"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } if (!EventStatus) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* The Type must be either Fixed AcpiEvent or GPE */ switch (Type) { case ACPI_EVENT_FIXED: /* Decode the Fixed AcpiEvent */ switch (Event) { case ACPI_EVENT_PMTIMER: RegisterId = TMR_STS; break; case ACPI_EVENT_GLOBAL: RegisterId = GBL_STS; break; case ACPI_EVENT_POWER_BUTTON: RegisterId = PWRBTN_STS; break; case ACPI_EVENT_SLEEP_BUTTON: RegisterId = SLPBTN_STS; break; case ACPI_EVENT_RTC: RegisterId = RTC_STS; break; default: return_ACPI_STATUS (AE_BAD_PARAMETER); break; } /* Get the status of the requested fixed event */ *EventStatus = AcpiHwRegisterBitAccess (ACPI_READ, ACPI_MTX_LOCK, RegisterId); break; case ACPI_EVENT_GPE: /* Ensure that we have a valid GPE number */ if ((Event > ACPI_GPE_MAX) || (AcpiGbl_GpeValid[Event] == ACPI_GPE_INVALID)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Obtain status on the requested GPE number */ AcpiHwGetGpeStatus (Event, EventStatus); break; default: Status = AE_BAD_PARAMETER; } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/evxfregn.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/evxfregn.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/evxfregn.c (revision 82367) @@ -1,531 +1,531 @@ /****************************************************************************** * * Module Name: evxfregn - External Interfaces, ACPI Operation Regions and * Address Spaces. - * $Revision: 34 $ + * $Revision: 35 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial prton of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EVXFREGN_C__ #include "acpi.h" #include "achware.h" #include "acnamesp.h" #include "acevents.h" #include "amlcode.h" #include "acinterp.h" #define _COMPONENT ACPI_EVENTS MODULE_NAME ("evxfregn") /******************************************************************************* * * FUNCTION: AcpiInstallAddressSpaceHandler * * PARAMETERS: Device - Handle for the device * SpaceId - The address space ID * Handler - Address of the handler * Setup - Address of the setup function * Context - Value passed to the handler on each access * * RETURN: Status * * DESCRIPTION: Install a handler for all OpRegions of a given SpaceId. * ******************************************************************************/ ACPI_STATUS AcpiInstallAddressSpaceHandler ( ACPI_HANDLE Device, ACPI_ADR_SPACE_TYPE SpaceId, ACPI_ADR_SPACE_HANDLER Handler, ACPI_ADR_SPACE_SETUP Setup, void *Context) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *HandlerObj; ACPI_NAMESPACE_NODE *Node; ACPI_STATUS Status = AE_OK; ACPI_OBJECT_TYPE8 Type; UINT16 Flags = 0; FUNCTION_TRACE ("AcpiInstallAddressSpaceHandler"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parameter validation */ if ((!Device) || ((!Handler) && (Handler != ACPI_DEFAULT_HANDLER)) || (SpaceId > ACPI_MAX_ADDRESS_SPACE)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); /* Convert and validate the device handle */ Node = AcpiNsConvertHandleToEntry (Device); if (!Node) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } /* * This registration is valid for only the types below * and the root. This is where the default handlers * get placed. */ if ((Node->Type != ACPI_TYPE_DEVICE) && (Node->Type != ACPI_TYPE_PROCESSOR) && (Node->Type != ACPI_TYPE_THERMAL) && (Node != AcpiGbl_RootNode)) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } if (Handler == ACPI_DEFAULT_HANDLER) { Flags = ADDR_HANDLER_DEFAULT_INSTALLED; switch (SpaceId) { case ACPI_ADR_SPACE_SYSTEM_MEMORY: Handler = AcpiExSystemMemorySpaceHandler; Setup = AcpiEvSystemMemoryRegionSetup; break; case ACPI_ADR_SPACE_SYSTEM_IO: Handler = AcpiExSystemIoSpaceHandler; Setup = AcpiEvIoSpaceRegionSetup; break; case ACPI_ADR_SPACE_PCI_CONFIG: Handler = AcpiExPciConfigSpaceHandler; Setup = AcpiEvPciConfigRegionSetup; break; default: Status = AE_NOT_EXIST; goto UnlockAndExit; break; } } /* * If the caller hasn't specified a setup routine, use the default */ if (!Setup) { Setup = AcpiEvDefaultRegionSetup; } /* * Check for an existing internal object */ ObjDesc = AcpiNsGetAttachedObject (Node); if (ObjDesc) { /* * The object exists. * Make sure the handler is not already installed. */ /* check the address handler the user requested */ HandlerObj = ObjDesc->Device.AddrHandler; while (HandlerObj) { /* * We have an Address handler, see if user requested this * address space. */ if(HandlerObj->AddrHandler.SpaceId == SpaceId) { Status = AE_EXIST; goto UnlockAndExit; } /* * Move through the linked list of handlers */ HandlerObj = HandlerObj->AddrHandler.Next; } } else { - DEBUG_PRINTP (TRACE_OPREGION, - ("Creating object on Device %p while installing handler\n", Node)); + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "Creating object on Device %p while installing handler\n", Node)); /* ObjDesc does not exist, create one */ if (Node->Type == ACPI_TYPE_ANY) { Type = ACPI_TYPE_DEVICE; } else { Type = Node->Type; } ObjDesc = AcpiUtCreateInternalObject (Type); if (!ObjDesc) { Status = AE_NO_MEMORY; goto UnlockAndExit; } /* Init new descriptor */ ObjDesc->Common.Type = (UINT8) Type; /* Attach the new object to the Node */ Status = AcpiNsAttachObject (Node, ObjDesc, (UINT8) Type); if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ObjDesc); goto UnlockAndExit; } } - DEBUG_PRINTP (TRACE_OPREGION, - ("Installing address handler for region %s(%X) on Device %p(%p)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "Installing address handler for region %s(%X) on Device %p(%p)\n", AcpiUtGetRegionName (SpaceId), SpaceId, Node, ObjDesc)); /* * Now we can install the handler * * At this point we know that there is no existing handler. * So, we just allocate the object for the handler and link it * into the list. */ HandlerObj = AcpiUtCreateInternalObject (INTERNAL_TYPE_ADDRESS_HANDLER); if (!HandlerObj) { Status = AE_NO_MEMORY; goto UnlockAndExit; } HandlerObj->AddrHandler.SpaceId = (UINT8) SpaceId; HandlerObj->AddrHandler.Hflags = Flags; HandlerObj->AddrHandler.Next = ObjDesc->Device.AddrHandler; HandlerObj->AddrHandler.RegionList = NULL; HandlerObj->AddrHandler.Node = Node; HandlerObj->AddrHandler.Handler = Handler; HandlerObj->AddrHandler.Context = Context; HandlerObj->AddrHandler.Setup = Setup; /* * Now walk the namespace finding all of the regions this * handler will manage. * * We start at the device and search the branch toward * the leaf nodes until either the leaf is encountered or * a device is detected that has an address handler of the * same type. * * In either case we back up and search down the remainder * of the branch */ Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, Device, ACPI_UINT32_MAX, NS_WALK_UNLOCK, AcpiEvAddrHandlerHelper, HandlerObj, NULL); /* * Place this handler 1st on the list */ HandlerObj->Common.ReferenceCount = (UINT16) (HandlerObj->Common.ReferenceCount + ObjDesc->Common.ReferenceCount - 1); ObjDesc->Device.AddrHandler = HandlerObj; UnlockAndExit: AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiRemoveAddressSpaceHandler * * PARAMETERS: SpaceId - The address space ID * Handler - Address of the handler * * RETURN: Status * * DESCRIPTION: Install a handler for accesses on an Operation Region * ******************************************************************************/ ACPI_STATUS AcpiRemoveAddressSpaceHandler ( ACPI_HANDLE Device, ACPI_ADR_SPACE_TYPE SpaceId, ACPI_ADR_SPACE_HANDLER Handler) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *HandlerObj; ACPI_OPERAND_OBJECT *RegionObj; ACPI_OPERAND_OBJECT **LastObjPtr; ACPI_NAMESPACE_NODE *Node; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("AcpiRemoveAddressSpaceHandler"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parameter validation */ if ((!Device) || ((!Handler) && (Handler != ACPI_DEFAULT_HANDLER)) || (SpaceId > ACPI_MAX_ADDRESS_SPACE)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); /* Convert and validate the device handle */ Node = AcpiNsConvertHandleToEntry (Device); if (!Node) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } /* Make sure the internal object exists */ ObjDesc = AcpiNsGetAttachedObject (Node); if (!ObjDesc) { /* * The object DNE. */ Status = AE_NOT_EXIST; goto UnlockAndExit; } /* * find the address handler the user requested */ HandlerObj = ObjDesc->Device.AddrHandler; LastObjPtr = &ObjDesc->Device.AddrHandler; while (HandlerObj) { /* * We have a handler, see if user requested this one */ if(HandlerObj->AddrHandler.SpaceId == SpaceId) { /* * Got it, first dereference this in the Regions */ - DEBUG_PRINTP (TRACE_OPREGION, - ("Removing address handler %p(%p) for region %s on Device %p(%p)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "Removing address handler %p(%p) for region %s on Device %p(%p)\n", HandlerObj, Handler, AcpiUtGetRegionName (SpaceId), Node, ObjDesc)); RegionObj = HandlerObj->AddrHandler.RegionList; /* Walk the handler's region list */ while (RegionObj) { /* * First disassociate the handler from the region. * * NOTE: this doesn't mean that the region goes away * The region is just inaccessible as indicated to * the _REG method */ AcpiEvDisassociateRegionFromHandler(RegionObj, TRUE); /* * Walk the list, since we took the first region and it * was removed from the list by the dissassociate call * we just get the first item on the list again */ RegionObj = HandlerObj->AddrHandler.RegionList; } /* * Remove this Handler object from the list */ *LastObjPtr = HandlerObj->AddrHandler.Next; /* * Now we can delete the handler object */ AcpiUtRemoveReference (HandlerObj); AcpiUtRemoveReference (HandlerObj); goto UnlockAndExit; } /* * Move through the linked list of handlers */ LastObjPtr = &HandlerObj->AddrHandler.Next; HandlerObj = HandlerObj->AddrHandler.Next; } /* * The handler does not exist */ - DEBUG_PRINTP (TRACE_OPREGION, - ("Unable to remove address handler %p for %s(%X), DevNode %p, obj %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, + "Unable to remove address handler %p for %s(%X), DevNode %p, obj %p\n", Handler, AcpiUtGetRegionName (SpaceId), SpaceId, Node, ObjDesc)); Status = AE_NOT_EXIST; UnlockAndExit: AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exconfig.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exconfig.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exconfig.c (revision 82367) @@ -1,431 +1,431 @@ /****************************************************************************** * * Module Name: exconfig - Namespace reconfiguration (Load/Unload opcodes) - * $Revision: 36 $ + * $Revision: 37 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXCONFIG_C__ #include "acpi.h" #include "acparser.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #include "acevents.h" #include "actables.h" #include "acdispat.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exconfig") /***************************************************************************** * * FUNCTION: AcpiExLoadTableOp * * PARAMETERS: RgnDesc - Op region where the table will be obtained * DdbHandle - Where a handle to the table will be returned * * RETURN: Status * * DESCRIPTION: Load an ACPI table * ****************************************************************************/ static ACPI_STATUS AcpiExLoadTableOp ( ACPI_OPERAND_OBJECT *RgnDesc, ACPI_HANDLE *DdbHandle) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *TableDesc = NULL; UINT8 *TablePtr; UINT8 *TableDataPtr; ACPI_TABLE_HEADER TableHeader; ACPI_TABLE_DESC TableInfo; UINT32 i; FUNCTION_TRACE ("ExLoadTable"); /* TBD: [Unhandled] Object can be either a field or an opregion */ /* Get the table header */ TableHeader.Length = 0; for (i = 0; i < sizeof (ACPI_TABLE_HEADER); i++) { Status = AcpiEvAddressSpaceDispatch (RgnDesc, ACPI_READ_ADR_SPACE, (ACPI_PHYSICAL_ADDRESS) i, 8, (UINT32 *) ((UINT8 *) &TableHeader + i)); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* Allocate a buffer for the entire table */ TablePtr = ACPI_MEM_ALLOCATE (TableHeader.Length); if (!TablePtr) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Copy the header to the buffer */ MEMCPY (TablePtr, &TableHeader, sizeof (ACPI_TABLE_HEADER)); TableDataPtr = TablePtr + sizeof (ACPI_TABLE_HEADER); /* Get the table from the op region */ for (i = 0; i < TableHeader.Length; i++) { Status = AcpiEvAddressSpaceDispatch (RgnDesc, ACPI_READ_ADR_SPACE, (ACPI_PHYSICAL_ADDRESS) i, 8, (UINT32 *) (TableDataPtr + i)); if (ACPI_FAILURE (Status)) { goto Cleanup; } } /* Table must be either an SSDT or a PSDT */ if ((!STRNCMP (TableHeader.Signature, AcpiGbl_AcpiTableData[ACPI_TABLE_PSDT].Signature, AcpiGbl_AcpiTableData[ACPI_TABLE_PSDT].SigLength)) && (!STRNCMP (TableHeader.Signature, AcpiGbl_AcpiTableData[ACPI_TABLE_SSDT].Signature, AcpiGbl_AcpiTableData[ACPI_TABLE_SSDT].SigLength))) { - DEBUG_PRINTP (ACPI_ERROR, - ("Table has invalid signature [%4.4s], must be SSDT or PSDT\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Table has invalid signature [%4.4s], must be SSDT or PSDT\n", TableHeader.Signature)); Status = AE_BAD_SIGNATURE; goto Cleanup; } /* Create an object to be the table handle */ TableDesc = AcpiUtCreateInternalObject (INTERNAL_TYPE_REFERENCE); if (!TableDesc) { Status = AE_NO_MEMORY; goto Cleanup; } /* Install the new table into the local data structures */ TableInfo.Pointer = (ACPI_TABLE_HEADER *) TablePtr; TableInfo.Length = TableHeader.Length; TableInfo.Allocation = ACPI_MEM_ALLOCATED; TableInfo.BasePointer = TablePtr; Status = AcpiTbInstallTable (NULL, &TableInfo); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* Add the table to the namespace */ /* TBD: [Restructure] - change to whatever new interface is appropriate */ /* Status = AcpiLoadNamespace (); if (ACPI_FAILURE (Status)) { */ /* TBD: [Errors] Unload the table on failure ? */ /* goto Cleanup; } */ /* TBD: [Investigate] we need a pointer to the table desc */ /* Init the table handle */ TableDesc->Reference.Opcode = AML_LOAD_OP; TableDesc->Reference.Object = TableInfo.InstalledDesc; *DdbHandle = TableDesc; return_ACPI_STATUS (Status); Cleanup: ACPI_MEM_FREE (TableDesc); ACPI_MEM_FREE (TablePtr); return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiExUnloadTable * * PARAMETERS: DdbHandle - Handle to a previously loaded table * * RETURN: Status * * DESCRIPTION: Unload an ACPI table * ****************************************************************************/ static ACPI_STATUS AcpiExUnloadTable ( ACPI_HANDLE DdbHandle) { ACPI_STATUS Status = AE_NOT_IMPLEMENTED; ACPI_OPERAND_OBJECT *TableDesc = (ACPI_OPERAND_OBJECT *) DdbHandle; ACPI_TABLE_DESC *TableInfo; FUNCTION_TRACE ("ExUnloadTable"); /* Validate the handle */ /* Although the handle is partially validated in AcpiExReconfiguration(), * when it calls AcpiExResolveOperands(), the handle is more completely * validated here. */ if ((!DdbHandle) || (!VALID_DESCRIPTOR_TYPE (DdbHandle, ACPI_DESC_TYPE_INTERNAL)) || (((ACPI_OPERAND_OBJECT *)DdbHandle)->Common.Type != INTERNAL_TYPE_REFERENCE)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Get the actual table descriptor from the DdbHandle */ TableInfo = (ACPI_TABLE_DESC *) TableDesc->Reference.Object; /* * Delete the entire namespace under this table Node * (Offset contains the TableId) */ Status = AcpiNsDeleteNamespaceByOwner (TableInfo->TableId); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Delete the table itself */ AcpiTbUninstallTable (TableInfo->InstalledDesc); /* Delete the table descriptor (DdbHandle) */ AcpiUtRemoveReference (TableDesc); return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiExReconfiguration * * PARAMETERS: Opcode - The opcode to be executed * WalkState - Current state of the parse tree walk * * RETURN: Status * * DESCRIPTION: Reconfiguration opcodes such as LOAD and UNLOAD * ****************************************************************************/ ACPI_STATUS AcpiExReconfiguration ( UINT16 Opcode, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *RegionDesc = NULL; ACPI_HANDLE *DdbHandle; FUNCTION_TRACE ("ExReconfiguration"); /* Resolve the operands */ Status = AcpiExResolveOperands (Opcode, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (Opcode), 2, "after AcpiExResolveOperands"); /* Get the table handle, common for both opcodes */ Status |= AcpiDsObjStackPopObject ((ACPI_OPERAND_OBJECT **) &DdbHandle, WalkState); switch (Opcode) { case AML_LOAD_OP: /* Get the region or field descriptor */ Status |= AcpiDsObjStackPopObject (&RegionDesc, WalkState); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("bad operand(s) (Load) (%s)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "bad operand(s) (Load) (%s)\n", AcpiFormatException (Status))); AcpiUtRemoveReference (RegionDesc); return_ACPI_STATUS (Status); } Status = AcpiExLoadTableOp (RegionDesc, DdbHandle); break; case AML_UNLOAD_OP: if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("bad operand(s) (unload) (%s)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "bad operand(s) (unload) (%s)\n", AcpiFormatException (Status))); return_ACPI_STATUS (Status); } Status = AcpiExUnloadTable (DdbHandle); break; default: - DEBUG_PRINTP (ACPI_ERROR, ("bad opcode=%X\n", Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "bad opcode=%X\n", Opcode)); Status = AE_AML_BAD_OPCODE; break; } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exconvrt.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exconvrt.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exconvrt.c (revision 82367) @@ -1,706 +1,833 @@ /****************************************************************************** * * Module Name: exconvrt - Object conversion routines - * $Revision: 16 $ + * $Revision: 20 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXCONVRT_C__ #include "acpi.h" #include "acparser.h" #include "acnamesp.h" #include "acinterp.h" #include "acevents.h" #include "amlcode.h" #include "acdispat.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exconvrt") /******************************************************************************* * * FUNCTION: AcpiExConvertToInteger * * PARAMETERS: *ObjDesc - Object to be converted. Must be an * Integer, Buffer, or String * WalkState - Current method state * * RETURN: Status * * DESCRIPTION: Convert an ACPI Object to an integer. * ******************************************************************************/ ACPI_STATUS AcpiExConvertToInteger ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc, ACPI_WALK_STATE *WalkState) { UINT32 i; ACPI_OPERAND_OBJECT *RetDesc; UINT32 Count; char *Pointer; ACPI_INTEGER Result; UINT32 IntegerSize = sizeof (ACPI_INTEGER); switch (ObjDesc->Common.Type) { case ACPI_TYPE_INTEGER: *ResultDesc = ObjDesc; return (AE_OK); case ACPI_TYPE_STRING: Pointer = ObjDesc->String.Pointer; Count = ObjDesc->String.Length; break; case ACPI_TYPE_BUFFER: Pointer = (char *) ObjDesc->Buffer.Pointer; Count = ObjDesc->Buffer.Length; break; default: return (AE_TYPE); } /* * Create a new integer */ RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!RetDesc) { return (AE_NO_MEMORY); } /* Handle both ACPI 1.0 and ACPI 2.0 Integer widths */ if (WalkState->MethodNode->Flags & ANOBJ_DATA_WIDTH_32) { /* * We are running a method that exists in a 32-bit ACPI table. * Truncate the value to 32 bits by zeroing out the upper 32-bit field */ IntegerSize = sizeof (UINT32); } /* * Convert the buffer/string to an integer. Note that both buffers and * strings are treated as raw data - we don't convert ascii to hex for * strings. * * There are two terminating conditions for the loop: * 1) The size of an integer has been reached, or * 2) The end of the buffer or string has been reached */ Result = 0; /* Transfer no more than an integer's worth of data */ if (Count > IntegerSize) { Count = IntegerSize; } /* * String conversion is different than Buffer conversion */ switch (ObjDesc->Common.Type) { case ACPI_TYPE_STRING: /* TBD: Need to use 64-bit STRTOUL */ /* * Convert string to an integer * String must be hexadecimal as per the ACPI specification */ Result = STRTOUL (Pointer, NULL, 16); break; case ACPI_TYPE_BUFFER: /* * Buffer conversion - we simply grab enough raw data from the * buffer to fill an integer */ for (i = 0; i < Count; i++) { /* * Get next byte and shift it into the Result. * Little endian is used, meaning that the first byte of the buffer * is the LSB of the integer */ Result |= (((ACPI_INTEGER) Pointer[i]) << (i * 8)); } break; } /* Save the Result, delete original descriptor, store new descriptor */ RetDesc->Integer.Value = Result; if (*ResultDesc == ObjDesc) { if (WalkState->Opcode != AML_STORE_OP) { AcpiUtRemoveReference (ObjDesc); } } *ResultDesc = RetDesc; return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExConvertToBuffer * * PARAMETERS: *ObjDesc - Object to be converted. Must be an * Integer, Buffer, or String * WalkState - Current method state * * RETURN: Status * * DESCRIPTION: Convert an ACPI Object to an Buffer * ******************************************************************************/ ACPI_STATUS AcpiExConvertToBuffer ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc, ACPI_WALK_STATE *WalkState) { ACPI_OPERAND_OBJECT *RetDesc; UINT32 i; UINT32 IntegerSize = sizeof (ACPI_INTEGER); UINT8 *NewBuf; switch (ObjDesc->Common.Type) { case ACPI_TYPE_INTEGER: /* * Create a new Buffer */ RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER); if (!RetDesc) { return (AE_NO_MEMORY); } /* Handle both ACPI 1.0 and ACPI 2.0 Integer widths */ if (WalkState->MethodNode->Flags & ANOBJ_DATA_WIDTH_32) { /* * We are running a method that exists in a 32-bit ACPI table. * Truncate the value to 32 bits by zeroing out the upper * 32-bit field */ IntegerSize = sizeof (UINT32); } /* Need enough space for one integers */ RetDesc->Buffer.Length = IntegerSize; NewBuf = ACPI_MEM_CALLOCATE (IntegerSize); if (!NewBuf) { REPORT_ERROR (("ExDyadic2R/ConcatOp: Buffer allocation failure\n")); AcpiUtRemoveReference (RetDesc); return (AE_NO_MEMORY); } /* Copy the integer to the buffer */ for (i = 0; i < IntegerSize; i++) { NewBuf[i] = (UINT8) (ObjDesc->Integer.Value >> (i * 8)); } RetDesc->Buffer.Pointer = NewBuf; /* Return the new buffer descriptor */ if (*ResultDesc == ObjDesc) { if (WalkState->Opcode != AML_STORE_OP) { AcpiUtRemoveReference (ObjDesc); } } *ResultDesc = RetDesc; break; case ACPI_TYPE_STRING: *ResultDesc = ObjDesc; break; case ACPI_TYPE_BUFFER: *ResultDesc = ObjDesc; break; default: return (AE_TYPE); break; } return (AE_OK); } + /******************************************************************************* * + * FUNCTION: AcpiExConvertAscii + * + * PARAMETERS: Integer + * + * RETURN: Actual string length + * + * DESCRIPTION: Convert an ACPI Integer to a hex string + * + ******************************************************************************/ + +UINT32 +AcpiExConvertToAscii ( + ACPI_INTEGER Integer, + UINT32 Base, + UINT8 *String) +{ + UINT32 i; + UINT32 j; + UINT32 k = 0; + UINT8 HexDigit; + ACPI_INTEGER Digit; + BOOLEAN LeadingZero = TRUE; + UINT32 Length = sizeof (ACPI_INTEGER); + + + /******** TBD: DEBUG only + char *buf; + char sbuf[32]; +#include +#include + buf = _ui64toa (Integer, sbuf, 10); + printf ("1): %s\n", sbuf); + + AcpiExConvertToDecimalAscii (Integer, 0, sbuf); + printf ("2): %s\n", sbuf); + + + buf = _ui64toa (Integer, sbuf, 16); + printf ("3): %s\n", sbuf); + + printf ("4): %s\n", String); +***************************************************/ + + + switch (Base) + { + case 10: + + for (i = ACPI_MAX_DECIMAL_DIGITS; i > 0 ; i--) + { + /* Divide by nth factor of 10 */ + + Digit = Integer; + for (j = 1; j < i; j++) + { + Digit = ACPI_DIVIDE (Digit, 10); + } + + /* Create the decimal digit */ + + if (Digit != 0) + { + LeadingZero = FALSE; + } + + if (!LeadingZero) + { + String[k] = (UINT8) (ASCII_ZERO + ACPI_MODULO (Digit, 10)); + k++; + } + } + break; + + case 16: + + /* Copy the integer to the buffer */ + + for (i = 0, j = ((Length * 2) -1); i < (Length * 2); i++, j--) + { + + HexDigit = AcpiUtHexToAsciiChar (Integer, (j * 4)); + if (HexDigit != ASCII_ZERO) + { + LeadingZero = FALSE; + } + + if (!LeadingZero) + { + String[k] = HexDigit; + k++; + } + } + break; + + default: + break; + } + + /* + * Since leading zeros are supressed, we must check for the case where + * the integer equals 0. + * + * Finally, null terminate the string and return the length + */ + if (!k) + { + String [0] = ASCII_ZERO; + k = 1; + } + String [k] = 0; + + return (k); +} + + +/******************************************************************************* + * * FUNCTION: AcpiExConvertToString * * PARAMETERS: *ObjDesc - Object to be converted. Must be an * Integer, Buffer, or String * WalkState - Current method state * * RETURN: Status * * DESCRIPTION: Convert an ACPI Object to a string * ******************************************************************************/ ACPI_STATUS AcpiExConvertToString ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc, + UINT32 Base, UINT32 MaxLength, ACPI_WALK_STATE *WalkState) { ACPI_OPERAND_OBJECT *RetDesc; UINT32 i; - UINT32 j; UINT32 Index; UINT32 StringLength; UINT32 IntegerSize = sizeof (ACPI_INTEGER); UINT8 *NewBuf; UINT8 *Pointer; switch (ObjDesc->Common.Type) { case ACPI_TYPE_INTEGER: - /* - * Create a new String - */ - RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_STRING); - if (!RetDesc) - { - return (AE_NO_MEMORY); - } - /* Handle both ACPI 1.0 and ACPI 2.0 Integer widths */ if (WalkState->MethodNode->Flags & ANOBJ_DATA_WIDTH_32) { /* * We are running a method that exists in a 32-bit ACPI table. * Truncate the value to 32 bits by zeroing out the upper * 32-bit field */ IntegerSize = sizeof (UINT32); } + StringLength = IntegerSize * 2; + if (Base == 10) + { + StringLength = ACPI_MAX_DECIMAL_DIGITS; + } + + /* + * Create a new String + */ + RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_STRING); + if (!RetDesc) + { + return (AE_NO_MEMORY); + } + /* Need enough space for one ASCII integer plus null terminator */ - RetDesc->String.Length = (IntegerSize * 2) + 1; - NewBuf = ACPI_MEM_CALLOCATE (RetDesc->String.Length); + NewBuf = ACPI_MEM_CALLOCATE (StringLength + 1); if (!NewBuf) { REPORT_ERROR (("ExConvertToString: Buffer allocation failure\n")); AcpiUtRemoveReference (RetDesc); return (AE_NO_MEMORY); } - /* Copy the integer to the buffer */ - for (i = 0, j = ((IntegerSize * 2) -1); i < (IntegerSize * 2); i++, j--) - { - NewBuf[i] = AcpiGbl_HexToAscii [(ObjDesc->Integer.Value >> (j * 4)) & 0xF]; - } + /* Convert */ + i = AcpiExConvertToAscii (ObjDesc->Integer.Value, Base, NewBuf); + /* Null terminate at the correct place */ if (MaxLength < i) { NewBuf[MaxLength] = 0; + RetDesc->String.Length = MaxLength; } else { NewBuf [i] = 0; + RetDesc->String.Length = i; } RetDesc->Buffer.Pointer = NewBuf; /* Return the new buffer descriptor */ if (*ResultDesc == ObjDesc) { if (WalkState->Opcode != AML_STORE_OP) { AcpiUtRemoveReference (ObjDesc); } } *ResultDesc = RetDesc; break; case ACPI_TYPE_BUFFER: StringLength = ObjDesc->Buffer.Length * 3; + if (Base == 10) + { + StringLength = ObjDesc->Buffer.Length * 4; + } if (MaxLength > ACPI_MAX_STRING_CONVERSION) { if (StringLength > ACPI_MAX_STRING_CONVERSION) { return (AE_AML_STRING_LIMIT); } } /* * Create a new string object */ RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_STRING); if (!RetDesc) { return (AE_NO_MEMORY); } /* String length is the lesser of the Max or the actual length */ if (MaxLength < StringLength) { StringLength = MaxLength; } NewBuf = ACPI_MEM_CALLOCATE (StringLength + 1); if (!NewBuf) { REPORT_ERROR (("ExConvertToString: Buffer allocation failure\n")); AcpiUtRemoveReference (RetDesc); return (AE_NO_MEMORY); } /* * Convert each byte of the buffer to two ASCII characters plus a space. */ Pointer = ObjDesc->Buffer.Pointer; Index = 0; - for (i = 0; i < (StringLength/3); i++) + for (i = 0, Index = 0; i < ObjDesc->Buffer.Length; i++) { - NewBuf[Index + 0] = AcpiGbl_HexToAscii [Pointer[i] & 0x0F]; - NewBuf[Index + 1] = AcpiGbl_HexToAscii [(Pointer[i] >> 4) & 0x0F]; - NewBuf[Index + 2] = ' '; - Index += 3; + Index = AcpiExConvertToAscii (Pointer[i], Base, &NewBuf[Index]); + + NewBuf[Index] = ' '; + Index++; } /* Null terminate */ NewBuf [Index-1] = 0; RetDesc->Buffer.Pointer = NewBuf; RetDesc->String.Length = STRLEN ((char *) NewBuf); /* Return the new buffer descriptor */ if (*ResultDesc == ObjDesc) { if (WalkState->Opcode != AML_STORE_OP) { AcpiUtRemoveReference (ObjDesc); } } *ResultDesc = RetDesc; break; case ACPI_TYPE_STRING: if (MaxLength >= ObjDesc->String.Length) { *ResultDesc = ObjDesc; } else { /* Must copy the string first and then truncate it */ return (AE_NOT_IMPLEMENTED); } break; default: return (AE_TYPE); break; } return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExConvertToTargetType * * PARAMETERS: *ObjDesc - Object to be converted. * WalkState - Current method state * * RETURN: Status * * DESCRIPTION: * ******************************************************************************/ ACPI_STATUS AcpiExConvertToTargetType ( ACPI_OBJECT_TYPE8 DestinationType, ACPI_OPERAND_OBJECT **ObjDesc, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("ExConvertToTargetType"); /* * If required by the target, * perform implicit conversion on the source before we store it. */ switch (GET_CURRENT_ARG_TYPE (WalkState->OpInfo->RuntimeArgs)) { case ARGI_SIMPLE_TARGET: case ARGI_FIXED_TARGET: case ARGI_INTEGER_REF: /* Handles Increment, Decrement cases */ switch (DestinationType) { case INTERNAL_TYPE_REGION_FIELD: /* * Named field can always handle conversions */ break; default: /* No conversion allowed for these types */ if (DestinationType != (*ObjDesc)->Common.Type) { - DEBUG_PRINTP (ACPI_ERROR, - ("Target does not allow conversion of type %s to %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Target does not allow conversion of type %s to %s\n", AcpiUtGetTypeName ((*ObjDesc)->Common.Type), AcpiUtGetTypeName (DestinationType))); Status = AE_TYPE; } } break; case ARGI_TARGETREF: switch (DestinationType) { case ACPI_TYPE_INTEGER: case ACPI_TYPE_BUFFER_FIELD: case INTERNAL_TYPE_BANK_FIELD: case INTERNAL_TYPE_INDEX_FIELD: /* * These types require an Integer operand. We can convert * a Buffer or a String to an Integer if necessary. */ Status = AcpiExConvertToInteger (*ObjDesc, ObjDesc, WalkState); break; case ACPI_TYPE_STRING: /* * The operand must be a String. We can convert an * Integer or Buffer if necessary */ - Status = AcpiExConvertToString (*ObjDesc, ObjDesc, ACPI_UINT32_MAX, WalkState); + Status = AcpiExConvertToString (*ObjDesc, ObjDesc, 16, ACPI_UINT32_MAX, WalkState); break; case ACPI_TYPE_BUFFER: /* * The operand must be a String. We can convert an * Integer or Buffer if necessary */ Status = AcpiExConvertToBuffer (*ObjDesc, ObjDesc, WalkState); break; } break; case ARGI_REFERENCE: /* * CreateXxxxField cases - we are storing the field object into the name */ break; default: - DEBUG_PRINTP (ACPI_ERROR, - ("Unknown Target type ID 0x%X Op %s DestType %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Unknown Target type ID 0x%X Op %s DestType %s\n", GET_CURRENT_ARG_TYPE (WalkState->OpInfo->RuntimeArgs), WalkState->OpInfo->Name, AcpiUtGetTypeName (DestinationType))); Status = AE_AML_INTERNAL; } /* * Source-to-Target conversion semantics: * * If conversion to the target type cannot be performed, then simply * overwrite the target with the new object and type. */ if (Status == AE_TYPE) { Status = AE_OK; } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/excreate.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/excreate.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/excreate.c (revision 82367) @@ -1,868 +1,868 @@ /****************************************************************************** * * Module Name: excreate - Named object creation - * $Revision: 63 $ + * $Revision: 64 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXCREATE_C__ #include "acpi.h" #include "acparser.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #include "acevents.h" #include "acdispat.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("excreate") /******************************************************************************* * * FUNCTION: AcpiExCreateBufferField * * PARAMETERS: Opcode - The opcode to be executed * Operands - List of operands for the opcode * * RETURN: Status * * DESCRIPTION: Execute CreateField operators: CreateBitFieldOp, * CreateByteFieldOp, CreateWordFieldOp, CreateDWordFieldOp, * CreateFieldOp (which define fields in buffers) * * ALLOCATION: Deletes CreateFieldOp's count operand descriptor * * * ACPI SPECIFICATION REFERENCES: * DefCreateBitField := CreateBitFieldOp SrcBuf BitIdx NameString * DefCreateByteField := CreateByteFieldOp SrcBuf ByteIdx NameString * DefCreateDWordField := CreateDWordFieldOp SrcBuf ByteIdx NameString * DefCreateField := CreateFieldOp SrcBuf BitIdx NumBits NameString * DefCreateWordField := CreateWordFieldOp SrcBuf ByteIdx NameString * BitIndex := TermArg=>Integer * ByteIndex := TermArg=>Integer * NumBits := TermArg=>Integer * SourceBuff := TermArg=>Buffer * ******************************************************************************/ ACPI_STATUS AcpiExCreateBufferField ( UINT8 *AmlPtr, UINT32 AmlLength, ACPI_NAMESPACE_NODE *Node, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *TmpDesc; FUNCTION_TRACE ("ExCreateBufferField"); /* Create the descriptor */ ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER_FIELD); if (!ObjDesc) { Status = AE_NO_MEMORY; goto Cleanup; } /* * Allocate a method object for this field unit */ ObjDesc->BufferField.Extra = AcpiUtCreateInternalObject ( INTERNAL_TYPE_EXTRA); if (!ObjDesc->BufferField.Extra) { Status = AE_NO_MEMORY; goto Cleanup; } /* * Remember location in AML stream of the field unit * opcode and operands -- since the buffer and index * operands must be evaluated. */ ObjDesc->BufferField.Extra->Extra.Pcode = AmlPtr; ObjDesc->BufferField.Extra->Extra.PcodeLength = AmlLength; ObjDesc->BufferField.Node = Node; /* * This operation is supposed to cause the destination Name to refer * to the defined BufferField -- it must not store the constructed * BufferField object (or its current value) in some location that the * Name may already be pointing to. So, if the Name currently contains * a reference which would cause AcpiExStore() to perform an indirect * store rather than setting the value of the Name itself, clobber that * reference before calling AcpiExStore(). */ /* Type of Name's existing value */ switch (AcpiNsGetType (Node)) { case ACPI_TYPE_BUFFER_FIELD: case INTERNAL_TYPE_ALIAS: case INTERNAL_TYPE_REGION_FIELD: case INTERNAL_TYPE_BANK_FIELD: case INTERNAL_TYPE_INDEX_FIELD: TmpDesc = AcpiNsGetAttachedObject (Node); if (TmpDesc) { /* * There is an existing object here; delete it and zero out the * object field within the Node */ DUMP_PATHNAME (Node, "ExCreateBufferField: Removing Current Reference", - TRACE_BFIELD, _COMPONENT); + ACPI_LV_BFIELD, _COMPONENT); - DUMP_ENTRY (Node, TRACE_BFIELD); + DUMP_ENTRY (Node, ACPI_LV_BFIELD); DUMP_STACK_ENTRY (TmpDesc); AcpiUtRemoveReference (TmpDesc); AcpiNsAttachObject ((ACPI_NAMESPACE_NODE *) Node, NULL, ACPI_TYPE_ANY); } /* Set the type to ANY (or the store below will fail) */ ((ACPI_NAMESPACE_NODE *) Node)->Type = ACPI_TYPE_ANY; break; default: break; } /* Store constructed field descriptor in result location */ Status = AcpiExStore (ObjDesc, (ACPI_OPERAND_OBJECT *) Node, WalkState); /* * If the field descriptor was not physically stored (or if a failure * above), we must delete it */ if (ObjDesc->Common.ReferenceCount <= 1) { AcpiUtRemoveReference (ObjDesc); } return_ACPI_STATUS (AE_OK); Cleanup: /* Delete region object and method subobject */ if (ObjDesc) { /* Remove deletes both objects! */ AcpiUtRemoveReference (ObjDesc); ObjDesc = NULL; } return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiExCreateAlias * * PARAMETERS: WalkState - Current state, contains List of * operands for the opcode * * RETURN: Status * * DESCRIPTION: Create a new named alias * ****************************************************************************/ ACPI_STATUS AcpiExCreateAlias ( ACPI_WALK_STATE *WalkState) { ACPI_NAMESPACE_NODE *SourceNode; ACPI_NAMESPACE_NODE *AliasNode; ACPI_STATUS Status; FUNCTION_TRACE ("ExCreateAlias"); /* Get the source/alias operands (both namespace nodes) */ Status = AcpiDsObjStackPopObject ((ACPI_OPERAND_OBJECT **) &SourceNode, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Don't pop it, it gets removed in the calling routine */ AliasNode = AcpiDsObjStackGetValue (0, WalkState); /* Add an additional reference to the object */ AcpiUtAddReference (SourceNode->Object); /* * Attach the original source Node to the new Alias Node. */ Status = AcpiNsAttachObject (AliasNode, SourceNode->Object, SourceNode->Type); /* * The new alias assumes the type of the source, but it points * to the same object. The reference count of the object has two * additional references to prevent deletion out from under either the * source or the alias Node */ /* Since both operands are Nodes, we don't need to delete them */ return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiExCreateEvent * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Create a new event object * ****************************************************************************/ ACPI_STATUS AcpiExCreateEvent ( ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *ObjDesc; FUNCTION_TRACE ("ExCreateEvent"); BREAKPOINT3; ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_EVENT); if (!ObjDesc) { Status = AE_NO_MEMORY; goto Cleanup; } /* Create the actual OS semaphore */ /* TBD: [Investigate] should be created with 0 or 1 units? */ Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 1, &ObjDesc->Event.Semaphore); if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ObjDesc); goto Cleanup; } /* Attach object to the Node */ Status = AcpiNsAttachObject (AcpiDsObjStackGetValue (0, WalkState), ObjDesc, (UINT8) ACPI_TYPE_EVENT); if (ACPI_FAILURE (Status)) { AcpiOsDeleteSemaphore (ObjDesc->Event.Semaphore); AcpiUtRemoveReference (ObjDesc); goto Cleanup; } Cleanup: return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiExCreateMutex * * PARAMETERS: InterpreterMode - Current running mode (load1/Load2/Exec) * Operands - List of operands for the opcode * * RETURN: Status * * DESCRIPTION: Create a new mutex object * ****************************************************************************/ ACPI_STATUS AcpiExCreateMutex ( ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *SyncDesc; ACPI_OPERAND_OBJECT *ObjDesc; FUNCTION_TRACE_PTR ("ExCreateMutex", WALK_OPERANDS); /* Get the operand */ Status = AcpiDsObjStackPopObject (&SyncDesc, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Attempt to allocate a new object */ ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_MUTEX); if (!ObjDesc) { Status = AE_NO_MEMORY; goto Cleanup; } /* Create the actual OS semaphore */ Status = AcpiOsCreateSemaphore (1, 1, &ObjDesc->Mutex.Semaphore); if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ObjDesc); goto Cleanup; } ObjDesc->Mutex.SyncLevel = (UINT8) SyncDesc->Integer.Value; /* ObjDesc was on the stack top, and the name is below it */ Status = AcpiNsAttachObject (AcpiDsObjStackGetValue (0, WalkState), ObjDesc, (UINT8) ACPI_TYPE_MUTEX); if (ACPI_FAILURE (Status)) { AcpiOsDeleteSemaphore (ObjDesc->Mutex.Semaphore); AcpiUtRemoveReference (ObjDesc); goto Cleanup; } Cleanup: /* Always delete the operand */ AcpiUtRemoveReference (SyncDesc); return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiExCreateRegion * * PARAMETERS: AmlPtr - Pointer to the region declaration AML * AmlLength - Max length of the declaration AML * Operands - List of operands for the opcode * InterpreterMode - Load1/Load2/Execute * * RETURN: Status * * DESCRIPTION: Create a new operation region object * ****************************************************************************/ ACPI_STATUS AcpiExCreateRegion ( UINT8 *AmlPtr, UINT32 AmlLength, UINT8 RegionSpace, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_NAMESPACE_NODE *Node; FUNCTION_TRACE ("ExCreateRegion"); /* * Space ID must be one of the predefined IDs, or in the user-defined * range */ if ((RegionSpace >= NUM_REGION_TYPES) && (RegionSpace < USER_REGION_BEGIN)) { REPORT_ERROR (("Invalid AddressSpace type %X\n", RegionSpace)); return_ACPI_STATUS (AE_AML_INVALID_SPACE_ID); } - DEBUG_PRINTP (TRACE_LOAD, ("Region Type - %s (%X)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "Region Type - %s (%X)\n", AcpiUtGetRegionName (RegionSpace), RegionSpace)); /* Get the Node from the object stack */ Node = (ACPI_NAMESPACE_NODE *) AcpiDsObjStackGetValue (0, WalkState); /* Create the region descriptor */ ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_REGION); if (!ObjDesc) { Status = AE_NO_MEMORY; goto Cleanup; } /* * Allocate a method object for this region. */ ObjDesc->Region.Extra = AcpiUtCreateInternalObject ( INTERNAL_TYPE_EXTRA); if (!ObjDesc->Region.Extra) { Status = AE_NO_MEMORY; goto Cleanup; } /* * Remember location in AML stream of address & length * operands since they need to be evaluated at run time. */ ObjDesc->Region.Extra->Extra.Pcode = AmlPtr; ObjDesc->Region.Extra->Extra.PcodeLength = AmlLength; /* Init the region from the operands */ ObjDesc->Region.SpaceId = RegionSpace; ObjDesc->Region.Address = 0; ObjDesc->Region.Length = 0; /* Install the new region object in the parent Node */ ObjDesc->Region.Node = Node; Status = AcpiNsAttachObject (Node, ObjDesc, (UINT8) ACPI_TYPE_REGION); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* * If we have a valid region, initialize it * Namespace is NOT locked at this point. */ Status = AcpiEvInitializeRegion (ObjDesc, FALSE); if (ACPI_FAILURE (Status)) { /* * If AE_NOT_EXIST is returned, it is not fatal * because many regions get created before a handler * is installed for said region. */ if (AE_NOT_EXIST == Status) { Status = AE_OK; } } Cleanup: if (ACPI_FAILURE (Status)) { /* Delete region object and method subobject */ if (ObjDesc) { /* Remove deletes both objects! */ AcpiUtRemoveReference (ObjDesc); ObjDesc = NULL; } } return_ACPI_STATUS (Status); } /***************************************************************************** * * FUNCTION: AcpiExCreateProcessor * * PARAMETERS: Op - Op containing the Processor definition and * args * ProcessorNode - Parent Node for the processor object * * RETURN: Status * * DESCRIPTION: Create a new processor object and populate the fields * ****************************************************************************/ ACPI_STATUS AcpiExCreateProcessor ( ACPI_PARSE_OBJECT *Op, ACPI_NAMESPACE_NODE *ProcessorNode) { ACPI_STATUS Status; ACPI_PARSE_OBJECT *Arg; ACPI_OPERAND_OBJECT *ObjDesc; FUNCTION_TRACE_PTR ("ExCreateProcessor", Op); ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_PROCESSOR); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Install the new processor object in the parent Node */ Status = AcpiNsAttachObject (ProcessorNode, ObjDesc, (UINT8) ACPI_TYPE_PROCESSOR); if (ACPI_FAILURE (Status)) { AcpiUtDeleteObjectDesc (ObjDesc); return_ACPI_STATUS (Status); } /* Get first arg and verify existence */ Arg = Op->Value.Arg; if (!Arg) { return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* First arg is the Processor ID */ ObjDesc->Processor.ProcId = (UINT8) Arg->Value.Integer; /* Get second arg and verify existence */ Arg = Arg->Next; if (!Arg) { return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* Second arg is the PBlock Address */ ObjDesc->Processor.Address = (ACPI_IO_ADDRESS) Arg->Value.Integer; /* Get third arg and verify existence */ Arg = Arg->Next; if (!Arg) { return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* Third arg is the PBlock Length */ ObjDesc->Processor.Length = (UINT8) Arg->Value.Integer; return_ACPI_STATUS (AE_OK); } /***************************************************************************** * * FUNCTION: AcpiExCreatePowerResource * * PARAMETERS: Op - Op containing the PowerResource definition * and args * PowerNode - Parent Node for the power object * * RETURN: Status * * DESCRIPTION: Create a new PowerResource object and populate the fields * ****************************************************************************/ ACPI_STATUS AcpiExCreatePowerResource ( ACPI_PARSE_OBJECT *Op, ACPI_NAMESPACE_NODE *PowerNode) { ACPI_STATUS Status; ACPI_PARSE_OBJECT *Arg; ACPI_OPERAND_OBJECT *ObjDesc; FUNCTION_TRACE_PTR ("ExCreatePowerResource", Op); ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_POWER); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Install the new power resource object in the parent Node */ Status = AcpiNsAttachObject (PowerNode, ObjDesc, (UINT8) ACPI_TYPE_POWER); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS(Status); } /* Get first arg and verify existence */ Arg = Op->Value.Arg; if (!Arg) { return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* First arg is the SystemLevel */ ObjDesc->PowerResource.SystemLevel = (UINT8) Arg->Value.Integer; /* Get second arg and check existence */ Arg = Arg->Next; if (!Arg) { return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* Second arg is the PBlock Address */ ObjDesc->PowerResource.ResourceOrder = (UINT16) Arg->Value.Integer; return_ACPI_STATUS (AE_OK); } /***************************************************************************** * * FUNCTION: AcpiExCreateMethod * * PARAMETERS: AmlPtr - First byte of the method's AML * AmlLength - AML byte count for this method * MethodFlags - AML method flag byte * Method - Method Node * * RETURN: Status * * DESCRIPTION: Create a new method object * ****************************************************************************/ ACPI_STATUS AcpiExCreateMethod ( UINT8 *AmlPtr, UINT32 AmlLength, UINT32 MethodFlags, ACPI_NAMESPACE_NODE *Method) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_STATUS Status; FUNCTION_TRACE_PTR ("ExCreateMethod", Method); /* Create a new method object */ ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Get the method's AML pointer/length from the Op */ ObjDesc->Method.Pcode = AmlPtr; ObjDesc->Method.PcodeLength = AmlLength; /* * First argument is the Method Flags (contains parameter count for the * method) */ ObjDesc->Method.MethodFlags = (UINT8) MethodFlags; ObjDesc->Method.ParamCount = (UINT8) (MethodFlags & METHOD_FLAGS_ARG_COUNT); /* * Get the concurrency count. If required, a semaphore will be * created for this method when it is parsed. */ if (MethodFlags & METHOD_FLAGS_SERIALIZED) { /* * ACPI 1.0: Concurrency = 1 * ACPI 2.0: Concurrency = (SyncLevel (in method declaration) + 1) */ ObjDesc->Method.Concurrency = (UINT8) (((MethodFlags & METHOD_FLAGS_SYNCH_LEVEL) >> 4) + 1); } else { ObjDesc->Method.Concurrency = INFINITE_CONCURRENCY; } /* Attach the new object to the method Node */ Status = AcpiNsAttachObject (Method, ObjDesc, (UINT8) ACPI_TYPE_METHOD); if (ACPI_FAILURE (Status)) { AcpiUtDeleteObjectDesc (ObjDesc); } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exdump.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exdump.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exdump.c (revision 82367) @@ -1,984 +1,994 @@ /****************************************************************************** * * Module Name: exdump - Interpreter debug output routines - * $Revision: 114 $ + * $Revision: 116 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXDUMP_C__ #include "acpi.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #include "actables.h" +#include "acparser.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exdump") /* * The following routines are used for debug output only */ #if defined(ACPI_DEBUG) || defined(ENABLE_DEBUGGER) /***************************************************************************** * * FUNCTION: AcpiExShowHexValue * * PARAMETERS: ByteCount - Number of bytes to print (1, 2, or 4) * *AmlPtr - Address in AML stream of bytes to print * InterpreterMode - Current running mode (load1/Load2/Exec) * LeadSpace - # of spaces to print ahead of value * 0 => none ahead but one behind * * DESCRIPTION: Print ByteCount byte(s) starting at AmlPtr as a single * value, in hex. If ByteCount > 1 or the value printed is > 9, also * print in decimal. * ****************************************************************************/ void AcpiExShowHexValue ( UINT32 ByteCount, UINT8 *AmlPtr, UINT32 LeadSpace) { UINT32 Value; /* Value retrieved from AML stream */ UINT32 ShowDecimalValue; UINT32 Length; /* Length of printed field */ UINT8 *CurrentAmlPtr = NULL; /* Pointer to current byte of AML value */ FUNCTION_TRACE ("ExShowHexValue"); if (!AmlPtr) { REPORT_ERROR (("ExShowHexValue: null pointer\n")); } /* * AML numbers are always stored little-endian, * even if the processor is big-endian. */ for (CurrentAmlPtr = AmlPtr + ByteCount, Value = 0; CurrentAmlPtr > AmlPtr; ) { Value = (Value << 8) + (UINT32)* --CurrentAmlPtr; } Length = LeadSpace * ByteCount + 2; if (ByteCount > 1) { Length += (ByteCount - 1); } ShowDecimalValue = (ByteCount > 1 || Value > 9); if (ShowDecimalValue) { Length += 3 + AcpiExDigitsNeeded (Value, 10); } - DEBUG_PRINT (TRACE_LOAD, ("")); + ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "")); for (Length = LeadSpace; Length; --Length ) { - DEBUG_PRINT_RAW (TRACE_LOAD, (" ")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_LOAD, " ")); } while (ByteCount--) { - DEBUG_PRINT_RAW (TRACE_LOAD, ("%02x", *AmlPtr++)); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_LOAD, "%02x", *AmlPtr++)); if (ByteCount) { - DEBUG_PRINT_RAW (TRACE_LOAD, (" ")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_LOAD, " ")); } } if (ShowDecimalValue) { - DEBUG_PRINT_RAW (TRACE_LOAD, (" [%ld]", Value)); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_LOAD, " [%ld]", Value)); } if (0 == LeadSpace) { - DEBUG_PRINT_RAW (TRACE_LOAD, (" ")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_LOAD, " ")); } - DEBUG_PRINT_RAW (TRACE_LOAD, ("\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_LOAD, "\n")); return_VOID; } /***************************************************************************** * * FUNCTION: AcpiExDumpOperand * * PARAMETERS: *EntryDesc - Pointer to entry to be dumped * * RETURN: Status * * DESCRIPTION: Dump a stack entry * ****************************************************************************/ ACPI_STATUS AcpiExDumpOperand ( ACPI_OPERAND_OBJECT *EntryDesc) { UINT8 *Buf = NULL; UINT32 Length; UINT32 i; PROC_NAME ("ExDumpOperand") if (!EntryDesc) { /* * This usually indicates that something serious is wrong -- * since most (if not all) * code that dumps the stack expects something to be there! */ - DEBUG_PRINTP (ACPI_INFO, ("Null stack entry ptr\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Null stack entry ptr\n")); return (AE_OK); } if (VALID_DESCRIPTOR_TYPE (EntryDesc, ACPI_DESC_TYPE_NAMED)) { - DEBUG_PRINTP (ACPI_INFO, ("Node: \n")); - DUMP_ENTRY (EntryDesc, ACPI_INFO); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Node: \n")); + DUMP_ENTRY (EntryDesc, ACPI_LV_INFO); return (AE_OK); } if (AcpiTbSystemTablePointer (EntryDesc)) { - DEBUG_PRINTP (ACPI_INFO, ("%p is an AML pointer\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%p is an AML pointer\n", EntryDesc)); return (AE_OK); } if (!VALID_DESCRIPTOR_TYPE (EntryDesc, ACPI_DESC_TYPE_INTERNAL)) { - DEBUG_PRINTP (ACPI_INFO, ("%p Not a local object \n", EntryDesc)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%p Not a local object \n", EntryDesc)); DUMP_BUFFER (EntryDesc, sizeof (ACPI_OPERAND_OBJECT)); return (AE_OK); } /* EntryDesc is a valid object */ - DEBUG_PRINTP (ACPI_INFO, ("%p ", EntryDesc)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%p ", EntryDesc)); switch (EntryDesc->Common.Type) { case INTERNAL_TYPE_REFERENCE: switch (EntryDesc->Reference.Opcode) { case AML_ZERO_OP: - DEBUG_PRINT_RAW (ACPI_INFO, ("Reference: Zero\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Reference: Zero\n")); break; case AML_ONE_OP: - DEBUG_PRINT_RAW (ACPI_INFO, ("Reference: One\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Reference: One\n")); break; case AML_ONES_OP: - DEBUG_PRINT_RAW (ACPI_INFO, ("Reference: Ones\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Reference: Ones\n")); break; case AML_DEBUG_OP: - DEBUG_PRINT_RAW (ACPI_INFO, ("Reference: Debug\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Reference: Debug\n")); break; case AML_NAME_OP: DUMP_PATHNAME (EntryDesc->Reference.Object, "Reference: Name: ", - ACPI_INFO, _COMPONENT); - DUMP_ENTRY (EntryDesc->Reference.Object, ACPI_INFO); + ACPI_LV_INFO, _COMPONENT); + DUMP_ENTRY (EntryDesc->Reference.Object, ACPI_LV_INFO); break; case AML_INDEX_OP: - DEBUG_PRINT_RAW (ACPI_INFO, ("Reference: Index %p\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Reference: Index %p\n", EntryDesc->Reference.Object)); break; case AML_ARG_OP: - DEBUG_PRINT_RAW (ACPI_INFO, ("Reference: Arg%d", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Reference: Arg%d", EntryDesc->Reference.Offset)); if (ACPI_TYPE_INTEGER == EntryDesc->Common.Type) { /* Value is a Number */ - DEBUG_PRINT_RAW (ACPI_INFO, (" value is [%ld]", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, " value is [%ld]", EntryDesc->Integer.Value)); } - DEBUG_PRINT_RAW (ACPI_INFO, ("\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "\n")); break; case AML_LOCAL_OP: - DEBUG_PRINT_RAW (ACPI_INFO, ("Reference: Local%d", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Reference: Local%d", EntryDesc->Reference.Offset)); if (ACPI_TYPE_INTEGER == EntryDesc->Common.Type) { /* Value is a Number */ - DEBUG_PRINT_RAW (ACPI_INFO, (" value is [%ld]", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, " value is [%ld]", EntryDesc->Integer.Value)); } - DEBUG_PRINT_RAW (ACPI_INFO, ("\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "\n")); break; case AML_INT_NAMEPATH_OP: - DEBUG_PRINT_RAW (ACPI_INFO, ("Reference.Node->Name %x\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Reference.Node->Name %x\n", EntryDesc->Reference.Node->Name)); break; default: /* unknown opcode */ - DEBUG_PRINT_RAW (ACPI_INFO, ("Unknown opcode=%X\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Unknown opcode=%X\n", EntryDesc->Reference.Opcode)); break; } break; case ACPI_TYPE_BUFFER: - DEBUG_PRINT_RAW (ACPI_INFO, ("Buffer len %X @ %p \n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Buffer len %X @ %p \n", EntryDesc->Buffer.Length, EntryDesc->Buffer.Pointer)); Length = EntryDesc->Buffer.Length; if (Length > 64) { Length = 64; } /* Debug only -- dump the buffer contents */ if (EntryDesc->Buffer.Pointer) { - DEBUG_PRINT_RAW (ACPI_INFO, ("Buffer Contents: ")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Buffer Contents: ")); for (Buf = EntryDesc->Buffer.Pointer; Length--; ++Buf) { - DEBUG_PRINT_RAW (ACPI_INFO, - (Length ? " %02x" : " %02x", *Buf)); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, + Length ? " %02x" : " %02x", *Buf)); } - DEBUG_PRINT_RAW (ACPI_INFO,("\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO,"\n")); } break; case ACPI_TYPE_INTEGER: - DEBUG_PRINT_RAW (ACPI_INFO, ("Number %lX\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Number %lX\n", EntryDesc->Integer.Value)); break; case INTERNAL_TYPE_IF: - DEBUG_PRINT_RAW (ACPI_INFO, ("If [Number] %lX\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "If [Number] %lX\n", EntryDesc->Integer.Value)); break; case INTERNAL_TYPE_WHILE: - DEBUG_PRINT_RAW (ACPI_INFO, ("While [Number] %lX\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "While [Number] %lX\n", EntryDesc->Integer.Value)); break; case ACPI_TYPE_PACKAGE: - DEBUG_PRINT_RAW (ACPI_INFO, ("Package count %X @ %p\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Package count %X @ %p\n", EntryDesc->Package.Count, EntryDesc->Package.Elements)); /* * If elements exist, package vector pointer is valid, * and debug_level exceeds 1, dump package's elements. */ if (EntryDesc->Package.Count && EntryDesc->Package.Elements && GetDebugLevel () > 1) { ACPI_OPERAND_OBJECT**Element; UINT16 ElementIndex; for (ElementIndex = 0, Element = EntryDesc->Package.Elements; ElementIndex < EntryDesc->Package.Count; ++ElementIndex, ++Element) { AcpiExDumpOperand (*Element); } } - DEBUG_PRINT_RAW (ACPI_INFO, ("\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "\n")); break; case ACPI_TYPE_REGION: - DEBUG_PRINT_RAW (ACPI_INFO, ("Region %s (%X)", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Region %s (%X)", AcpiUtGetRegionName (EntryDesc->Region.SpaceId), EntryDesc->Region.SpaceId)); /* * If the address and length have not been evaluated, * don't print them. */ if (!(EntryDesc->Region.Flags & AOPOBJ_DATA_VALID)) { - DEBUG_PRINT_RAW (ACPI_INFO, ("\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "\n")); } else { - DEBUG_PRINT_RAW (ACPI_INFO, (" base %p Length %X\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, " base %p Length %X\n", EntryDesc->Region.Address, EntryDesc->Region.Length)); } break; case ACPI_TYPE_STRING: - DEBUG_PRINT_RAW (ACPI_INFO, ("String length %X @ %p\n\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "String length %X @ %p\n\n", EntryDesc->String.Length, EntryDesc->String.Pointer)); for (i=0; i < EntryDesc->String.Length; i++) { - DEBUG_PRINT_RAW (ACPI_INFO, ("%c", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "%c", EntryDesc->String.Pointer[i])); } - DEBUG_PRINT_RAW (ACPI_INFO, ("\n\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "\n\n")); break; case INTERNAL_TYPE_BANK_FIELD: - DEBUG_PRINT_RAW (ACPI_INFO, ("BankField\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "BankField\n")); break; case INTERNAL_TYPE_REGION_FIELD: - DEBUG_PRINT_RAW (ACPI_INFO, - ("RegionField: bits=%X bitaccwidth=%X lock=%X update=%X at byte=%lX bit=%X of below:\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, + "RegionField: bits=%X bitaccwidth=%X lock=%X update=%X at byte=%lX bit=%X of below:\n", EntryDesc->Field.BitLength, EntryDesc->Field.AccessBitWidth, EntryDesc->Field.LockRule, EntryDesc->Field.UpdateRule, EntryDesc->Field.BaseByteOffset, EntryDesc->Field.StartFieldBitOffset)); DUMP_STACK_ENTRY (EntryDesc->Field.RegionObj); break; case INTERNAL_TYPE_INDEX_FIELD: - DEBUG_PRINT_RAW (ACPI_INFO, ("IndexField\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "IndexField\n")); break; case ACPI_TYPE_BUFFER_FIELD: - DEBUG_PRINT_RAW (ACPI_INFO, - ("BufferField: %X bits at byte %lX bit %X of \n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, + "BufferField: %X bits at byte %lX bit %X of \n", EntryDesc->BufferField.BitLength, EntryDesc->BufferField.BaseByteOffset, EntryDesc->BufferField.StartFieldBitOffset)); if (!EntryDesc->BufferField.BufferObj) { - DEBUG_PRINT (ACPI_INFO, ("*NULL* \n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "*NULL* \n")); } else if (ACPI_TYPE_BUFFER != EntryDesc->BufferField.BufferObj->Common.Type) { - DEBUG_PRINT_RAW (ACPI_INFO, ("*not a Buffer* \n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "*not a Buffer* \n")); } else { DUMP_STACK_ENTRY (EntryDesc->BufferField.BufferObj); } break; case ACPI_TYPE_EVENT: - DEBUG_PRINT_RAW (ACPI_INFO, ("Event\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Event\n")); break; case ACPI_TYPE_METHOD: - DEBUG_PRINT_RAW (ACPI_INFO, - ("Method(%X) @ %p:%lX\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, + "Method(%X) @ %p:%lX\n", EntryDesc->Method.ParamCount, EntryDesc->Method.Pcode, EntryDesc->Method.PcodeLength)); break; case ACPI_TYPE_MUTEX: - DEBUG_PRINT_RAW (ACPI_INFO, ("Mutex\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Mutex\n")); break; case ACPI_TYPE_DEVICE: - DEBUG_PRINT_RAW (ACPI_INFO, ("Device\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Device\n")); break; case ACPI_TYPE_POWER: - DEBUG_PRINT_RAW (ACPI_INFO, ("Power\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Power\n")); break; case ACPI_TYPE_PROCESSOR: - DEBUG_PRINT_RAW (ACPI_INFO, ("Processor\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Processor\n")); break; case ACPI_TYPE_THERMAL: - DEBUG_PRINT_RAW (ACPI_INFO, ("Thermal\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Thermal\n")); break; default: /* unknown EntryDesc->Common.Type value */ - DEBUG_PRINT_RAW (ACPI_INFO, ("Unknown Type %X\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "Unknown Type %X\n", EntryDesc->Common.Type)); /* Back up to previous entry */ EntryDesc--; /* TBD: [Restructure] Change to use dump object routine !! */ /* What is all of this?? */ DUMP_BUFFER (EntryDesc, sizeof (ACPI_OPERAND_OBJECT)); DUMP_BUFFER (++EntryDesc, sizeof (ACPI_OPERAND_OBJECT)); DUMP_BUFFER (++EntryDesc, sizeof (ACPI_OPERAND_OBJECT)); break; } return (AE_OK); } /***************************************************************************** * * FUNCTION: AcpiExDumpOperands * * PARAMETERS: InterpreterMode - Load or Exec * *Ident - Identification * NumLevels - # of stack entries to dump above line * *Note - Output notation * * DESCRIPTION: Dump the object stack * ****************************************************************************/ void AcpiExDumpOperands ( ACPI_OPERAND_OBJECT **Operands, OPERATING_MODE InterpreterMode, NATIVE_CHAR *Ident, UINT32 NumLevels, NATIVE_CHAR *Note, NATIVE_CHAR *ModuleName, UINT32 LineNumber) { NATIVE_UINT i; ACPI_OPERAND_OBJECT **EntryDesc; + PROC_NAME ("AcpiExDumpOperands"); + if (!Ident) { Ident = "?"; } if (!Note) { Note = "?"; } - DEBUG_PRINT (ACPI_INFO, - ("************* AcpiExDumpOperands Mode=%X ******************\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "************* AcpiExDumpOperands Mode=%X ******************\n", InterpreterMode)); - DEBUG_PRINT (ACPI_INFO, - ("From %12s(%d) %s: %s\n", ModuleName, LineNumber, Ident, Note)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "From %12s(%d) %s: %s\n", ModuleName, LineNumber, Ident, Note)); if (NumLevels == 0) { NumLevels = 1; } /* Dump the stack starting at the top, working down */ for (i = 0; NumLevels > 0; i--, NumLevels--) { EntryDesc = &Operands[i]; if (ACPI_FAILURE (AcpiExDumpOperand (*EntryDesc))) { break; } } return; } /***************************************************************************** * * FUNCTION: AcpiExDumpNode * * PARAMETERS: *Node - Descriptor to dump * Flags - Force display * * DESCRIPTION: Dumps the members of the given.Node * ****************************************************************************/ void AcpiExDumpNode ( ACPI_NAMESPACE_NODE *Node, UINT32 Flags) { if (!Flags) { - if (!((TRACE_OBJECTS & AcpiDbgLevel) && (_COMPONENT & AcpiDbgLayer))) + if (!((ACPI_LV_OBJECTS & AcpiDbgLevel) && (_COMPONENT & AcpiDbgLayer))) { return; } } AcpiOsPrintf ("%20s : %4.4s\n", "Name", &Node->Name); AcpiOsPrintf ("%20s : %s\n", "Type", AcpiUtGetTypeName (Node->Type)); AcpiOsPrintf ("%20s : %X\n", "Flags", Node->Flags); AcpiOsPrintf ("%20s : %X\n", "Owner Id", Node->OwnerId); AcpiOsPrintf ("%20s : %X\n", "Reference Count", Node->ReferenceCount); AcpiOsPrintf ("%20s : %p\n", "Attached Object", Node->Object); AcpiOsPrintf ("%20s : %p\n", "ChildList", Node->Child); AcpiOsPrintf ("%20s : %p\n", "NextPeer", Node->Peer); AcpiOsPrintf ("%20s : %p\n", "Parent", AcpiNsGetParentObject (Node)); } /***************************************************************************** * * FUNCTION: AcpiExDumpObjectDescriptor * * PARAMETERS: *Object - Descriptor to dump * Flags - Force display * * DESCRIPTION: Dumps the members of the object descriptor given. * ****************************************************************************/ void AcpiExDumpObjectDescriptor ( ACPI_OPERAND_OBJECT *ObjDesc, UINT32 Flags) { + ACPI_OPCODE_INFO *OpInfo; + + FUNCTION_TRACE ("ExDumpObjectDescriptor"); if (!Flags) { - if (!((TRACE_OBJECTS & AcpiDbgLevel) && (_COMPONENT & AcpiDbgLayer))) + if (!((ACPI_DB_OBJECTS & AcpiDbgLevel) && (_COMPONENT & AcpiDbgLayer))) { return; } } if (!(VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_INTERNAL))) { AcpiOsPrintf ("%p is not a valid ACPI object\n", ObjDesc); return; } /* Common Fields */ AcpiOsPrintf ("%20s : %X\n", "Reference Count", ObjDesc->Common.ReferenceCount); AcpiOsPrintf ("%20s : %X\n", "Flags", ObjDesc->Common.Flags); /* Object-specific Fields */ switch (ObjDesc->Common.Type) { case ACPI_TYPE_INTEGER: - AcpiOsPrintf ("%20s : %s\n", "Type", "Number"); - AcpiOsPrintf ("%20s : %X\n", "Value", ObjDesc->Integer.Value); + AcpiOsPrintf ("%20s : %s\n", "Type", "Integer"); + AcpiOsPrintf ("%20s : %X%8.8X\n", "Value", HIDWORD (ObjDesc->Integer.Value), + LODWORD (ObjDesc->Integer.Value)); break; case ACPI_TYPE_STRING: AcpiOsPrintf ("%20s : %s\n", "Type", "String"); AcpiOsPrintf ("%20s : %X\n", "Length", ObjDesc->String.Length); AcpiOsPrintf ("%20s : %p\n", "Pointer", ObjDesc->String.Pointer); break; case ACPI_TYPE_BUFFER: AcpiOsPrintf ("%20s : %s\n", "Type", "Buffer"); AcpiOsPrintf ("%20s : %X\n", "Length", ObjDesc->Buffer.Length); AcpiOsPrintf ("%20s : %p\n", "Pointer", ObjDesc->Buffer.Pointer); break; case ACPI_TYPE_PACKAGE: AcpiOsPrintf ("%20s : %s\n", "Type", "Package"); + AcpiOsPrintf ("%20s : %X\n", "Flags", ObjDesc->Package.Flags); AcpiOsPrintf ("%20s : %X\n", "Count", ObjDesc->Package.Count); AcpiOsPrintf ("%20s : %p\n", "Elements", ObjDesc->Package.Elements); AcpiOsPrintf ("%20s : %p\n", "NextElement", ObjDesc->Package.NextElement); break; case ACPI_TYPE_BUFFER_FIELD: AcpiOsPrintf ("%20s : %s\n", "Type", "BufferField"); AcpiOsPrintf ("%20s : %X\n", "BitLength", ObjDesc->BufferField.BitLength); AcpiOsPrintf ("%20s : %X\n", "BitOffset", ObjDesc->BufferField.StartFieldBitOffset); AcpiOsPrintf ("%20s : %X\n", "BaseByteOffset",ObjDesc->BufferField.BaseByteOffset); AcpiOsPrintf ("%20s : %p\n", "BufferObj", ObjDesc->BufferField.BufferObj); break; case ACPI_TYPE_DEVICE: AcpiOsPrintf ("%20s : %s\n", "Type", "Device"); AcpiOsPrintf ("%20s : %p\n", "AddrHandler", ObjDesc->Device.AddrHandler); AcpiOsPrintf ("%20s : %p\n", "SysHandler", ObjDesc->Device.SysHandler); AcpiOsPrintf ("%20s : %p\n", "DrvHandler", ObjDesc->Device.DrvHandler); break; case ACPI_TYPE_EVENT: AcpiOsPrintf ("%20s : %s\n", "Type", "Event"); AcpiOsPrintf ("%20s : %X\n", "Semaphore", ObjDesc->Event.Semaphore); break; case ACPI_TYPE_METHOD: AcpiOsPrintf ("%20s : %s\n", "Type", "Method"); AcpiOsPrintf ("%20s : %X\n", "ParamCount", ObjDesc->Method.ParamCount); AcpiOsPrintf ("%20s : %X\n", "Concurrency", ObjDesc->Method.Concurrency); AcpiOsPrintf ("%20s : %p\n", "Semaphore", ObjDesc->Method.Semaphore); AcpiOsPrintf ("%20s : %X\n", "PcodeLength", ObjDesc->Method.PcodeLength); AcpiOsPrintf ("%20s : %X\n", "Pcode", ObjDesc->Method.Pcode); break; case ACPI_TYPE_MUTEX: AcpiOsPrintf ("%20s : %s\n", "Type", "Mutex"); AcpiOsPrintf ("%20s : %X\n", "SyncLevel", ObjDesc->Mutex.SyncLevel); AcpiOsPrintf ("%20s : %p\n", "Owner", ObjDesc->Mutex.Owner); AcpiOsPrintf ("%20s : %X\n", "AcquisitionDepth", ObjDesc->Mutex.AcquisitionDepth); AcpiOsPrintf ("%20s : %p\n", "Semaphore", ObjDesc->Mutex.Semaphore); break; case ACPI_TYPE_REGION: AcpiOsPrintf ("%20s : %s\n", "Type", "Region"); AcpiOsPrintf ("%20s : %X\n", "SpaceId", ObjDesc->Region.SpaceId); AcpiOsPrintf ("%20s : %X\n", "Flags", ObjDesc->Region.Flags); AcpiOsPrintf ("%20s : %X\n", "Address", ObjDesc->Region.Address); AcpiOsPrintf ("%20s : %X\n", "Length", ObjDesc->Region.Length); AcpiOsPrintf ("%20s : %p\n", "AddrHandler", ObjDesc->Region.AddrHandler); AcpiOsPrintf ("%20s : %p\n", "Next", ObjDesc->Region.Next); break; case ACPI_TYPE_POWER: AcpiOsPrintf ("%20s : %s\n", "Type", "PowerResource"); AcpiOsPrintf ("%20s : %X\n", "SystemLevel", ObjDesc->PowerResource.SystemLevel); AcpiOsPrintf ("%20s : %X\n", "ResourceOrder", ObjDesc->PowerResource.ResourceOrder); AcpiOsPrintf ("%20s : %p\n", "SysHandler", ObjDesc->PowerResource.SysHandler); AcpiOsPrintf ("%20s : %p\n", "DrvHandler", ObjDesc->PowerResource.DrvHandler); break; case ACPI_TYPE_PROCESSOR: AcpiOsPrintf ("%20s : %s\n", "Type", "Processor"); AcpiOsPrintf ("%20s : %X\n", "Processor ID", ObjDesc->Processor.ProcId); AcpiOsPrintf ("%20s : %X\n", "Length", ObjDesc->Processor.Length); AcpiOsPrintf ("%20s : %X\n", "Address", ObjDesc->Processor.Address); AcpiOsPrintf ("%20s : %p\n", "SysHandler", ObjDesc->Processor.SysHandler); AcpiOsPrintf ("%20s : %p\n", "DrvHandler", ObjDesc->Processor.DrvHandler); AcpiOsPrintf ("%20s : %p\n", "AddrHandler", ObjDesc->Processor.AddrHandler); break; case ACPI_TYPE_THERMAL: AcpiOsPrintf ("%20s : %s\n", "Type", "ThermalZone"); AcpiOsPrintf ("%20s : %p\n", "SysHandler", ObjDesc->ThermalZone.SysHandler); AcpiOsPrintf ("%20s : %p\n", "DrvHandler", ObjDesc->ThermalZone.DrvHandler); AcpiOsPrintf ("%20s : %p\n", "AddrHandler", ObjDesc->ThermalZone.AddrHandler); break; case INTERNAL_TYPE_REGION_FIELD: AcpiOsPrintf ("%20s : %p\n", "AccessBitWidth", ObjDesc->Field.AccessBitWidth); AcpiOsPrintf ("%20s : %p\n", "BitLength", ObjDesc->Field.BitLength); AcpiOsPrintf ("%20s : %p\n", "BaseByteOffset",ObjDesc->Field.BaseByteOffset); AcpiOsPrintf ("%20s : %p\n", "BitOffset", ObjDesc->Field.StartFieldBitOffset); AcpiOsPrintf ("%20s : %p\n", "RegionObj", ObjDesc->Field.RegionObj); break; case INTERNAL_TYPE_BANK_FIELD: AcpiOsPrintf ("%20s : %s\n", "Type", "BankField"); AcpiOsPrintf ("%20s : %X\n", "AccessBitWidth", ObjDesc->BankField.AccessBitWidth); AcpiOsPrintf ("%20s : %X\n", "LockRule", ObjDesc->BankField.LockRule); AcpiOsPrintf ("%20s : %X\n", "UpdateRule", ObjDesc->BankField.UpdateRule); AcpiOsPrintf ("%20s : %X\n", "BitLength", ObjDesc->BankField.BitLength); AcpiOsPrintf ("%20s : %X\n", "BitOffset", ObjDesc->BankField.StartFieldBitOffset); AcpiOsPrintf ("%20s : %X\n", "BaseByteOffset", ObjDesc->BankField.BaseByteOffset); AcpiOsPrintf ("%20s : %X\n", "Value", ObjDesc->BankField.Value); AcpiOsPrintf ("%20s : %p\n", "RegionObj", ObjDesc->BankField.RegionObj); AcpiOsPrintf ("%20s : %X\n", "BankRegisterObj", ObjDesc->BankField.BankRegisterObj); break; case INTERNAL_TYPE_INDEX_FIELD: AcpiOsPrintf ("%20s : %s\n", "Type", "IndexField"); AcpiOsPrintf ("%20s : %X\n", "AccessBitWidth", ObjDesc->IndexField.AccessBitWidth); AcpiOsPrintf ("%20s : %X\n", "LockRule", ObjDesc->IndexField.LockRule); AcpiOsPrintf ("%20s : %X\n", "UpdateRule", ObjDesc->IndexField.UpdateRule); AcpiOsPrintf ("%20s : %X\n", "BitLength", ObjDesc->IndexField.BitLength); AcpiOsPrintf ("%20s : %X\n", "BitOffset", ObjDesc->IndexField.StartFieldBitOffset); AcpiOsPrintf ("%20s : %X\n", "Value", ObjDesc->IndexField.Value); AcpiOsPrintf ("%20s : %X\n", "Index", ObjDesc->IndexField.IndexObj); AcpiOsPrintf ("%20s : %X\n", "Data", ObjDesc->IndexField.DataObj); break; case INTERNAL_TYPE_REFERENCE: + OpInfo = AcpiPsGetOpcodeInfo (ObjDesc->Reference.Opcode); + AcpiOsPrintf ("%20s : %s\n", "Type", "Reference"); AcpiOsPrintf ("%20s : %X\n", "TargetType", ObjDesc->Reference.TargetType); - AcpiOsPrintf ("%20s : %X\n", "Opcode", ObjDesc->Reference.Opcode); + AcpiOsPrintf ("%20s : %s\n", "Opcode", OpInfo->Name); AcpiOsPrintf ("%20s : %X\n", "Offset", ObjDesc->Reference.Offset); AcpiOsPrintf ("%20s : %p\n", "ObjDesc", ObjDesc->Reference.Object); AcpiOsPrintf ("%20s : %p\n", "Node", ObjDesc->Reference.Node); AcpiOsPrintf ("%20s : %p\n", "Where", ObjDesc->Reference.Where); break; case INTERNAL_TYPE_ADDRESS_HANDLER: AcpiOsPrintf ("%20s : %s\n", "Type", "Address Handler"); AcpiOsPrintf ("%20s : %X\n", "SpaceId", ObjDesc->AddrHandler.SpaceId); AcpiOsPrintf ("%20s : %p\n", "Next", ObjDesc->AddrHandler.Next); AcpiOsPrintf ("%20s : %p\n", "RegionList", ObjDesc->AddrHandler.RegionList); AcpiOsPrintf ("%20s : %p\n", "Node", ObjDesc->AddrHandler.Node); AcpiOsPrintf ("%20s : %p\n", "Handler", ObjDesc->AddrHandler.Handler); AcpiOsPrintf ("%20s : %p\n", "Context", ObjDesc->AddrHandler.Context); break; case INTERNAL_TYPE_NOTIFY: AcpiOsPrintf ("%20s : %s\n", "Type", "Notify Handler"); AcpiOsPrintf ("%20s : %p\n", "Node", ObjDesc->NotifyHandler.Node); AcpiOsPrintf ("%20s : %p\n", "Handler", ObjDesc->NotifyHandler.Handler); AcpiOsPrintf ("%20s : %p\n", "Context", ObjDesc->NotifyHandler.Context); break; case INTERNAL_TYPE_ALIAS: case INTERNAL_TYPE_FIELD_DEFN: case INTERNAL_TYPE_BANK_FIELD_DEFN: case INTERNAL_TYPE_INDEX_FIELD_DEFN: case INTERNAL_TYPE_IF: case INTERNAL_TYPE_ELSE: case INTERNAL_TYPE_WHILE: case INTERNAL_TYPE_SCOPE: case INTERNAL_TYPE_DEF_ANY: AcpiOsPrintf ("*** Structure display not implemented for type %X! ***\n", ObjDesc->Common.Type); break; default: AcpiOsPrintf ("*** Cannot display unknown type %X! ***\n", ObjDesc->Common.Type); break; } return_VOID; } #endif Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exdyadic.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exdyadic.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exdyadic.c (revision 82367) @@ -1,1099 +1,1107 @@ /****************************************************************************** * * Module Name: exdyadic - ACPI AML execution for dyadic (2-operand) operators - * $Revision: 82 $ + * $Revision: 85 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXDYADIC_C__ #include "acpi.h" #include "acparser.h" #include "acnamesp.h" #include "acinterp.h" #include "acevents.h" #include "amlcode.h" #include "acdispat.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exdyadic") /******************************************************************************* * * FUNCTION: AcpiExDoConcatenate * * PARAMETERS: *ObjDesc - Object to be converted. Must be an * Integer, Buffer, or String * WalkState - Current walk state * * RETURN: Status * * DESCRIPTION: Concatenate two objects OF THE SAME TYPE. * ******************************************************************************/ ACPI_STATUS AcpiExDoConcatenate ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT *ObjDesc2, ACPI_OPERAND_OBJECT **ActualRetDesc, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; UINT32 i; ACPI_INTEGER ThisInteger; ACPI_OPERAND_OBJECT *RetDesc; NATIVE_CHAR *NewBuf; UINT32 IntegerSize = sizeof (ACPI_INTEGER); /* * There are three cases to handle: * 1) Two Integers concatenated to produce a buffer * 2) Two Strings concatenated to produce a string * 3) Two Buffers concatenated to produce a buffer */ switch (ObjDesc->Common.Type) { case ACPI_TYPE_INTEGER: /* Handle both ACPI 1.0 and ACPI 2.0 Integer widths */ if (WalkState->MethodNode->Flags & ANOBJ_DATA_WIDTH_32) { /* * We are running a method that exists in a 32-bit ACPI table. * Truncate the value to 32 bits by zeroing out the upper * 32-bit field */ IntegerSize = sizeof (UINT32); } /* Result of two integers is a buffer */ RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER); if (!RetDesc) { return (AE_NO_MEMORY); } /* Need enough space for two integers */ RetDesc->Buffer.Length = IntegerSize * 2; NewBuf = ACPI_MEM_CALLOCATE (RetDesc->Buffer.Length); if (!NewBuf) { REPORT_ERROR (("ExDoConcatenate: Buffer allocation failure\n")); Status = AE_NO_MEMORY; goto Cleanup; } RetDesc->Buffer.Pointer = (UINT8 *) NewBuf; /* Convert the first integer */ ThisInteger = ObjDesc->Integer.Value; for (i = 0; i < IntegerSize; i++) { NewBuf[i] = (UINT8) ThisInteger; ThisInteger >>= 8; } /* Convert the second integer */ ThisInteger = ObjDesc2->Integer.Value; for (; i < (IntegerSize * 2); i++) { NewBuf[i] = (UINT8) ThisInteger; ThisInteger >>= 8; } break; case ACPI_TYPE_STRING: RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_STRING); if (!RetDesc) { return (AE_NO_MEMORY); } /* Operand1 is string */ NewBuf = ACPI_MEM_ALLOCATE (ObjDesc->String.Length + ObjDesc2->String.Length + 1); if (!NewBuf) { REPORT_ERROR (("ExDoConcatenate: String allocation failure\n")); Status = AE_NO_MEMORY; goto Cleanup; } STRCPY (NewBuf, ObjDesc->String.Pointer); STRCPY (NewBuf + ObjDesc->String.Length, ObjDesc2->String.Pointer); /* Point the return object to the new string */ RetDesc->String.Pointer = NewBuf; RetDesc->String.Length = ObjDesc->String.Length += ObjDesc2->String.Length; break; case ACPI_TYPE_BUFFER: /* Operand1 is a buffer */ RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER); if (!RetDesc) { return (AE_NO_MEMORY); } NewBuf = ACPI_MEM_ALLOCATE (ObjDesc->Buffer.Length + ObjDesc2->Buffer.Length); if (!NewBuf) { REPORT_ERROR (("ExDoConcatenate: Buffer allocation failure\n")); Status = AE_NO_MEMORY; goto Cleanup; } MEMCPY (NewBuf, ObjDesc->Buffer.Pointer, ObjDesc->Buffer.Length); MEMCPY (NewBuf + ObjDesc->Buffer.Length, ObjDesc2->Buffer.Pointer, ObjDesc2->Buffer.Length); /* * Point the return object to the new buffer */ RetDesc->Buffer.Pointer = (UINT8 *) NewBuf; RetDesc->Buffer.Length = ObjDesc->Buffer.Length + ObjDesc2->Buffer.Length; break; default: Status = AE_AML_INTERNAL; RetDesc = NULL; } *ActualRetDesc = RetDesc; return (AE_OK); Cleanup: AcpiUtRemoveReference (RetDesc); return (Status); } /******************************************************************************* * * FUNCTION: AcpiExDyadic1 * * PARAMETERS: Opcode - The opcode to be executed * WalkState - Current walk state * * RETURN: Status * * DESCRIPTION: Execute Type 1 dyadic operator with numeric operands: * NotifyOp * * ALLOCATION: Deletes both operands * ******************************************************************************/ ACPI_STATUS AcpiExDyadic1 ( UINT16 Opcode, ACPI_WALK_STATE *WalkState) { ACPI_OPERAND_OBJECT *ObjDesc = NULL; ACPI_OPERAND_OBJECT *ValDesc = NULL; ACPI_NAMESPACE_NODE *Node; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE_PTR ("ExDyadic1", WALK_OPERANDS); /* Resolve all operands */ Status = AcpiExResolveOperands (Opcode, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (Opcode), 2, "after AcpiExResolveOperands"); /* Get the operands */ Status |= AcpiDsObjStackPopObject (&ValDesc, WalkState); Status |= AcpiDsObjStackPopObject (&ObjDesc, WalkState); if (ACPI_FAILURE (Status)) { /* Invalid parameters on object stack */ - DEBUG_PRINTP (ACPI_ERROR, ("(%s) bad operand(s) %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(%s) bad operand(s) %s\n", AcpiPsGetOpcodeName (Opcode), AcpiFormatException (Status))); goto Cleanup; } /* Examine the opcode */ switch (Opcode) { /* DefNotify := NotifyOp NotifyObject NotifyValue */ case AML_NOTIFY_OP: /* The ObjDesc is actually an Node */ Node = (ACPI_NAMESPACE_NODE *) ObjDesc; ObjDesc = NULL; /* Object must be a device or thermal zone */ if (Node && ValDesc) { switch (Node->Type) { case ACPI_TYPE_DEVICE: case ACPI_TYPE_THERMAL: /* * Dispatch the notify to the appropriate handler * NOTE: the request is queued for execution after this method * completes. The notify handlers are NOT invoked synchronously * from this thread -- because handlers may in turn run other * control methods. */ Status = AcpiEvQueueNotifyRequest (Node, (UINT32) ValDesc->Integer.Value); break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Unexpected notify object type %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unexpected notify object type %X\n", ObjDesc->Common.Type)); Status = AE_AML_OPERAND_TYPE; break; } } break; default: REPORT_ERROR (("AcpiExDyadic1: Unknown dyadic opcode %X\n", Opcode)); Status = AE_AML_BAD_OPCODE; } Cleanup: /* Always delete both operands */ AcpiUtRemoveReference (ValDesc); AcpiUtRemoveReference (ObjDesc); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExDyadic2R * * PARAMETERS: Opcode - The opcode to be executed * WalkState - Current walk state * ReturnDesc - Where to store the return object * * RETURN: Status * * DESCRIPTION: Execute Type 2 dyadic operator with numeric operands and * one or two result operands. * * ALLOCATION: Deletes one operand descriptor -- other remains on stack * ******************************************************************************/ ACPI_STATUS AcpiExDyadic2R ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc) { ACPI_OPERAND_OBJECT *ObjDesc = NULL; ACPI_OPERAND_OBJECT *ObjDesc2 = NULL; ACPI_OPERAND_OBJECT *ResDesc = NULL; ACPI_OPERAND_OBJECT *ResDesc2 = NULL; ACPI_OPERAND_OBJECT *RetDesc = NULL; ACPI_OPERAND_OBJECT *RetDesc2 = NULL; ACPI_STATUS Status = AE_OK; UINT32 NumOperands = 3; FUNCTION_TRACE_U32 ("ExDyadic2R", Opcode); /* Resolve all operands */ Status = AcpiExResolveOperands (Opcode, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (Opcode), NumOperands, "after AcpiExResolveOperands"); + if (ACPI_FAILURE (Status)) + { + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(%s) Could not resolve operand(s) (%s)\n", + AcpiPsGetOpcodeName (Opcode), AcpiFormatException (Status))); + + goto Cleanup; + } + /* Get all operands */ if (AML_DIVIDE_OP == Opcode) { NumOperands = 4; Status |= AcpiDsObjStackPopObject (&ResDesc2, WalkState); } Status |= AcpiDsObjStackPopObject (&ResDesc, WalkState); Status |= AcpiDsObjStackPopObject (&ObjDesc2, WalkState); Status |= AcpiDsObjStackPopObject (&ObjDesc, WalkState); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("(%s) bad operand(s) (%s)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(%s) bad operand(s) (%s)\n", AcpiPsGetOpcodeName (Opcode), AcpiFormatException (Status))); goto Cleanup; } /* Create an internal return object if necessary */ switch (Opcode) { case AML_ADD_OP: case AML_BIT_AND_OP: case AML_BIT_NAND_OP: case AML_BIT_OR_OP: case AML_BIT_NOR_OP: case AML_BIT_XOR_OP: case AML_DIVIDE_OP: case AML_MOD_OP: case AML_MULTIPLY_OP: case AML_SHIFT_LEFT_OP: case AML_SHIFT_RIGHT_OP: case AML_SUBTRACT_OP: RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!RetDesc) { Status = AE_NO_MEMORY; goto Cleanup; } break; } /* * Execute the opcode */ switch (Opcode) { /* DefAdd := AddOp Operand1 Operand2 Result */ case AML_ADD_OP: RetDesc->Integer.Value = ObjDesc->Integer.Value + ObjDesc2->Integer.Value; break; /* DefAnd := AndOp Operand1 Operand2 Result */ case AML_BIT_AND_OP: RetDesc->Integer.Value = ObjDesc->Integer.Value & ObjDesc2->Integer.Value; break; /* DefNAnd := NAndOp Operand1 Operand2 Result */ case AML_BIT_NAND_OP: RetDesc->Integer.Value = ~(ObjDesc->Integer.Value & ObjDesc2->Integer.Value); break; /* DefOr := OrOp Operand1 Operand2 Result */ case AML_BIT_OR_OP: RetDesc->Integer.Value = ObjDesc->Integer.Value | ObjDesc2->Integer.Value; break; /* DefNOr := NOrOp Operand1 Operand2 Result */ case AML_BIT_NOR_OP: RetDesc->Integer.Value = ~(ObjDesc->Integer.Value | ObjDesc2->Integer.Value); break; /* DefXOr := XOrOp Operand1 Operand2 Result */ case AML_BIT_XOR_OP: RetDesc->Integer.Value = ObjDesc->Integer.Value ^ ObjDesc2->Integer.Value; break; /* DefDivide := DivideOp Dividend Divisor Remainder Quotient */ case AML_DIVIDE_OP: if (!ObjDesc2->Integer.Value) { REPORT_ERROR (("DivideOp: Divide by zero\n")); Status = AE_AML_DIVIDE_BY_ZERO; goto Cleanup; } RetDesc2 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!RetDesc2) { Status = AE_NO_MEMORY; goto Cleanup; } /* Remainder (modulo) */ RetDesc->Integer.Value = ACPI_MODULO (ObjDesc->Integer.Value, ObjDesc2->Integer.Value); /* Result (what we used to call the quotient) */ RetDesc2->Integer.Value = ACPI_DIVIDE (ObjDesc->Integer.Value, ObjDesc2->Integer.Value); break; /* DefMod := ModOp Dividend Divisor Remainder */ case AML_MOD_OP: /* ACPI 2.0 */ if (!ObjDesc2->Integer.Value) { REPORT_ERROR (("ModOp: Divide by zero\n")); Status = AE_AML_DIVIDE_BY_ZERO; goto Cleanup; } /* Remainder (modulo) */ RetDesc->Integer.Value = ACPI_MODULO (ObjDesc->Integer.Value, ObjDesc2->Integer.Value); break; /* DefMultiply := MultiplyOp Operand1 Operand2 Result */ case AML_MULTIPLY_OP: RetDesc->Integer.Value = ObjDesc->Integer.Value * ObjDesc2->Integer.Value; break; /* DefShiftLeft := ShiftLeftOp Operand ShiftCount Result */ case AML_SHIFT_LEFT_OP: RetDesc->Integer.Value = ObjDesc->Integer.Value << ObjDesc2->Integer.Value; break; /* DefShiftRight := ShiftRightOp Operand ShiftCount Result */ case AML_SHIFT_RIGHT_OP: RetDesc->Integer.Value = ObjDesc->Integer.Value >> ObjDesc2->Integer.Value; break; /* DefSubtract := SubtractOp Operand1 Operand2 Result */ case AML_SUBTRACT_OP: RetDesc->Integer.Value = ObjDesc->Integer.Value - ObjDesc2->Integer.Value; break; /* DefConcat := ConcatOp Data1 Data2 Result */ case AML_CONCAT_OP: /* * Convert the second operand if necessary. The first operand * determines the type of the second operand, (See the Data Types * section of the ACPI specification.) Both object types are * guaranteed to be either Integer/String/Buffer by the operand * resolution mechanism above. */ switch (ObjDesc->Common.Type) { case ACPI_TYPE_INTEGER: Status = AcpiExConvertToInteger (ObjDesc2, &ObjDesc2, WalkState); break; case ACPI_TYPE_STRING: - Status = AcpiExConvertToString (ObjDesc2, &ObjDesc2, ACPI_UINT32_MAX, WalkState); + Status = AcpiExConvertToString (ObjDesc2, &ObjDesc2, 16, ACPI_UINT32_MAX, WalkState); break; case ACPI_TYPE_BUFFER: Status = AcpiExConvertToBuffer (ObjDesc2, &ObjDesc2, WalkState); break; default: Status = AE_AML_INTERNAL; } if (ACPI_FAILURE (Status)) { goto Cleanup; } /* * Both operands are now known to be the same object type * (Both are Integer, String, or Buffer), and we can now perform the * concatenation. */ Status = AcpiExDoConcatenate (ObjDesc, ObjDesc2, &RetDesc, WalkState); if (ACPI_FAILURE (Status)) { goto Cleanup; } break; /* DefToString := Buffer, Length, Result */ case AML_TO_STRING_OP: /* ACPI 2.0 */ - Status = AcpiExConvertToString (ObjDesc, &RetDesc, + Status = AcpiExConvertToString (ObjDesc, &RetDesc, 16, (UINT32) ObjDesc2->Integer.Value, WalkState); break; /* DefConcatRes := Buffer, Buffer, Result */ case AML_CONCAT_RES_OP: /* ACPI 2.0 */ Status = AE_NOT_IMPLEMENTED; goto Cleanup; break; default: REPORT_ERROR (("AcpiExDyadic2R: Unknown dyadic opcode %X\n", Opcode)); Status = AE_AML_BAD_OPCODE; goto Cleanup; } /* * Store the result of the operation (which is now in ObjDesc) into * the result descriptor, or the location pointed to by the result * descriptor (ResDesc). */ Status = AcpiExStore (RetDesc, ResDesc, WalkState); if (ACPI_FAILURE (Status)) { goto Cleanup; } if (AML_DIVIDE_OP == Opcode) { Status = AcpiExStore (RetDesc2, ResDesc2, WalkState); /* * Since the remainder is not returned, remove a reference to * the object we created earlier */ AcpiUtRemoveReference (RetDesc2); } Cleanup: /* Always delete the operands */ AcpiUtRemoveReference (ObjDesc); AcpiUtRemoveReference (ObjDesc2); /* Delete return object on error */ if (ACPI_FAILURE (Status)) { /* On failure, delete the result ops */ AcpiUtRemoveReference (ResDesc); AcpiUtRemoveReference (ResDesc2); if (RetDesc) { /* And delete the internal return object */ AcpiUtRemoveReference (RetDesc); RetDesc = NULL; } } /* Set the return object and exit */ *ReturnDesc = RetDesc; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExDyadic2S * * PARAMETERS: Opcode - The opcode to be executed * WalkState - Current walk state * ReturnDesc - Where to store the return object * * RETURN: Status * * DESCRIPTION: Execute Type 2 dyadic synchronization operator * * ALLOCATION: Deletes one operand descriptor -- other remains on stack * ******************************************************************************/ ACPI_STATUS AcpiExDyadic2S ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *TimeDesc; ACPI_OPERAND_OBJECT *RetDesc = NULL; ACPI_STATUS Status; FUNCTION_TRACE_PTR ("ExDyadic2S", WALK_OPERANDS); /* Resolve all operands */ Status = AcpiExResolveOperands (Opcode, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (Opcode), 2, "after AcpiExResolveOperands"); /* Get all operands */ Status |= AcpiDsObjStackPopObject (&TimeDesc, WalkState); Status |= AcpiDsObjStackPopObject (&ObjDesc, WalkState); if (ACPI_FAILURE (Status)) { /* Invalid parameters on object stack */ - DEBUG_PRINTP (ACPI_ERROR, ("(%s) bad operand(s) %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(%s) bad operand(s) %s\n", AcpiPsGetOpcodeName (Opcode), AcpiFormatException (Status))); goto Cleanup; } /* Create the internal return object */ RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!RetDesc) { Status = AE_NO_MEMORY; goto Cleanup; } /* Default return value is FALSE, operation did not time out */ RetDesc->Integer.Value = 0; /* Examine the opcode */ switch (Opcode) { /* DefAcquire := AcquireOp MutexObject Timeout */ case AML_ACQUIRE_OP: Status = AcpiExAcquireMutex (TimeDesc, ObjDesc, WalkState); break; /* DefWait := WaitOp AcpiEventObject Timeout */ case AML_WAIT_OP: Status = AcpiExSystemWaitEvent (TimeDesc, ObjDesc); break; default: REPORT_ERROR (("AcpiExDyadic2S: Unknown dyadic synchronization opcode %X\n", Opcode)); Status = AE_AML_BAD_OPCODE; goto Cleanup; } /* * Return a boolean indicating if operation timed out * (TRUE) or not (FALSE) */ if (Status == AE_TIME) { RetDesc->Integer.Value = ACPI_INTEGER_MAX; /* TRUE, op timed out */ Status = AE_OK; } Cleanup: /* Delete params */ AcpiUtRemoveReference (TimeDesc); AcpiUtRemoveReference (ObjDesc); /* Delete return object on error */ if (ACPI_FAILURE (Status) && (RetDesc)) { AcpiUtRemoveReference (RetDesc); RetDesc = NULL; } /* Set the return object and exit */ *ReturnDesc = RetDesc; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExDyadic2 * * PARAMETERS: Opcode - The opcode to be executed * WalkState - Current walk state * ReturnDesc - Where to store the return object * * RETURN: Status * * DESCRIPTION: Execute Type 2 dyadic operator with numeric operands and * no result operands * * ALLOCATION: Deletes one operand descriptor -- other remains on stack * containing result value * ******************************************************************************/ ACPI_STATUS AcpiExDyadic2 ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *ObjDesc2; ACPI_OPERAND_OBJECT *RetDesc = NULL; ACPI_STATUS Status; BOOLEAN Lboolean; FUNCTION_TRACE_PTR ("ExDyadic2", WALK_OPERANDS); /* Resolve all operands */ Status = AcpiExResolveOperands (Opcode, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (Opcode), 2, "after AcpiExResolveOperands"); /* Get all operands */ Status |= AcpiDsObjStackPopObject (&ObjDesc2, WalkState); Status |= AcpiDsObjStackPopObject (&ObjDesc, WalkState); if (ACPI_FAILURE (Status)) { /* Invalid parameters on object stack */ - DEBUG_PRINTP (ACPI_ERROR, ("(%s) bad operand(s) %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(%s) bad operand(s) %s\n", AcpiPsGetOpcodeName (Opcode), AcpiFormatException (Status))); goto Cleanup; } /* Create the internal return object */ RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!RetDesc) { Status = AE_NO_MEMORY; goto Cleanup; } /* * Execute the Opcode */ Lboolean = FALSE; switch (Opcode) { /* DefLAnd := LAndOp Operand1 Operand2 */ case AML_LAND_OP: Lboolean = (BOOLEAN) (ObjDesc->Integer.Value && ObjDesc2->Integer.Value); break; /* DefLEqual := LEqualOp Operand1 Operand2 */ case AML_LEQUAL_OP: Lboolean = (BOOLEAN) (ObjDesc->Integer.Value == ObjDesc2->Integer.Value); break; /* DefLGreater := LGreaterOp Operand1 Operand2 */ case AML_LGREATER_OP: Lboolean = (BOOLEAN) (ObjDesc->Integer.Value > ObjDesc2->Integer.Value); break; /* DefLLess := LLessOp Operand1 Operand2 */ case AML_LLESS_OP: Lboolean = (BOOLEAN) (ObjDesc->Integer.Value < ObjDesc2->Integer.Value); break; /* DefLOr := LOrOp Operand1 Operand2 */ case AML_LOR_OP: Lboolean = (BOOLEAN) (ObjDesc->Integer.Value || ObjDesc2->Integer.Value); break; /* DefCopy := Source, Destination */ case AML_COPY_OP: /* ACPI 2.0 */ Status = AE_NOT_IMPLEMENTED; goto Cleanup; break; default: REPORT_ERROR (("AcpiExDyadic2: Unknown dyadic opcode %X\n", Opcode)); Status = AE_AML_BAD_OPCODE; goto Cleanup; break; } /* Set return value to logical TRUE (all ones) or FALSE (zero) */ if (Lboolean) { RetDesc->Integer.Value = ACPI_INTEGER_MAX; } else { RetDesc->Integer.Value = 0; } Cleanup: /* Always delete operands */ AcpiUtRemoveReference (ObjDesc); AcpiUtRemoveReference (ObjDesc2); /* Delete return object on error */ if (ACPI_FAILURE (Status) && (RetDesc)) { AcpiUtRemoveReference (RetDesc); RetDesc = NULL; } /* Set the return object and exit */ *ReturnDesc = RetDesc; return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exfield.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exfield.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exfield.c (revision 82367) @@ -1,639 +1,639 @@ /****************************************************************************** * * Module Name: exfield - ACPI AML (p-code) execution - field manipulation - * $Revision: 91 $ + * $Revision: 92 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXFIELD_C__ #include "acpi.h" #include "acdispat.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #include "achware.h" #include "acevents.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exfield") /******************************************************************************* * * FUNCTION: AcpiExReadDataFromField * * PARAMETERS: Mode - ACPI_READ or ACPI_WRITE * *FieldNode - Parent node for field to be accessed * *Buffer - Value(s) to be read or written * BufferLength - Number of bytes to transfer * * RETURN: Status3 * * DESCRIPTION: Read or write a named field * ******************************************************************************/ ACPI_STATUS AcpiExReadDataFromField ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **RetBufferDesc) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *BufferDesc; UINT32 Length; void *Buffer; FUNCTION_TRACE_PTR ("ExReadDataFromField", ObjDesc); /* Parameter validation */ if (!ObjDesc) { return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* * Allocate a buffer for the contents of the field. * * If the field is larger than the size of an ACPI_INTEGER, create * a BUFFER to hold it. Otherwise, use an INTEGER. This allows * the use of arithmetic operators on the returned value if the * field size is equal or smaller than an Integer. * * Note: Field.length is in bits. */ Length = ROUND_BITS_UP_TO_BYTES (ObjDesc->Field.BitLength); if (Length > sizeof (ACPI_INTEGER)) { /* Field is too large for an Integer, create a Buffer instead */ BufferDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER); if (!BufferDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Create the actual read buffer */ BufferDesc->Buffer.Pointer = ACPI_MEM_CALLOCATE (Length); if (!BufferDesc->Buffer.Pointer) { AcpiUtRemoveReference (BufferDesc); return_ACPI_STATUS (AE_NO_MEMORY); } BufferDesc->Buffer.Length = Length; Buffer = BufferDesc->Buffer.Pointer; } else { /* Field will fit within an Integer (normal case) */ BufferDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!BufferDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } Length = sizeof (BufferDesc->Integer.Value); Buffer = &BufferDesc->Integer.Value; } /* Read from the appropriate field */ switch (ObjDesc->Common.Type) { case ACPI_TYPE_BUFFER_FIELD: Status = AcpiExAccessBufferField (ACPI_READ, ObjDesc, Buffer, Length); break; case INTERNAL_TYPE_REGION_FIELD: Status = AcpiExAccessRegionField (ACPI_READ, ObjDesc, Buffer, Length); break; case INTERNAL_TYPE_BANK_FIELD: Status = AcpiExAccessBankField (ACPI_READ, ObjDesc, Buffer, Length); break; case INTERNAL_TYPE_INDEX_FIELD: Status = AcpiExAccessIndexField (ACPI_READ, ObjDesc, Buffer, Length); break; default: Status = AE_AML_INTERNAL; } if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (BufferDesc); } else if (RetBufferDesc) { *RetBufferDesc = BufferDesc; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExWriteDataToField * * PARAMETERS: Mode - ACPI_READ or ACPI_WRITE * *FieldNode - Parent node for field to be accessed * *Buffer - Value(s) to be read or written * BufferLength - Number of bytes to transfer * * RETURN: Status * * DESCRIPTION: Read or write a named field * ******************************************************************************/ ACPI_STATUS AcpiExWriteDataToField ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *ObjDesc) { ACPI_STATUS Status; UINT32 Length; void *Buffer; FUNCTION_TRACE_PTR ("ExWriteDataToField", ObjDesc); /* Parameter validation */ if (!SourceDesc || !ObjDesc) { return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* * Get a pointer to the data to be written */ switch (SourceDesc->Common.Type) { case ACPI_TYPE_INTEGER: Buffer = &SourceDesc->Integer.Value; Length = sizeof (SourceDesc->Integer.Value); break; case ACPI_TYPE_BUFFER: Buffer = SourceDesc->Buffer.Pointer; Length = SourceDesc->Buffer.Length; break; case ACPI_TYPE_STRING: Buffer = SourceDesc->String.Pointer; Length = SourceDesc->String.Length; break; default: return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* * Decode the type of field to be written */ switch (ObjDesc->Common.Type) { case ACPI_TYPE_BUFFER_FIELD: Status = AcpiExAccessBufferField (ACPI_WRITE, ObjDesc, Buffer, Length); break; case INTERNAL_TYPE_REGION_FIELD: Status = AcpiExAccessRegionField (ACPI_WRITE, ObjDesc, Buffer, Length); break; case INTERNAL_TYPE_BANK_FIELD: Status = AcpiExAccessBankField (ACPI_WRITE, ObjDesc, Buffer, Length); break; case INTERNAL_TYPE_INDEX_FIELD: Status = AcpiExAccessIndexField (ACPI_WRITE, ObjDesc, Buffer, Length); break; default: return_ACPI_STATUS (AE_AML_INTERNAL); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExAccessBufferField * * PARAMETERS: Mode - ACPI_READ or ACPI_WRITE * *FieldNode - Parent node for field to be accessed * *Buffer - Value(s) to be read or written * BufferLength - Number of bytes to transfer * * RETURN: Status * * DESCRIPTION: Read or write a named field * ******************************************************************************/ ACPI_STATUS AcpiExAccessBufferField ( UINT32 Mode, ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength) { ACPI_STATUS Status; FUNCTION_TRACE_PTR ("AcpiExAccessBufferField", ObjDesc); /* * If the BufferField arguments have not been previously evaluated, * evaluate them now and save the results. */ if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)) { Status = AcpiDsGetBufferFieldArguments (ObjDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } Status = AcpiExCommonAccessField (Mode, ObjDesc, Buffer, BufferLength); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExAccessRegionField * * PARAMETERS: Mode - ACPI_READ or ACPI_WRITE * *FieldNode - Parent node for field to be accessed * *Buffer - Value(s) to be read or written * BufferLength - Number of bytes to transfer * * RETURN: Status * * DESCRIPTION: Read or write a named field * ******************************************************************************/ ACPI_STATUS AcpiExAccessRegionField ( UINT32 Mode, ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength) { ACPI_STATUS Status; BOOLEAN Locked; FUNCTION_TRACE_PTR ("ExAccessRegionField", ObjDesc); /* * Get the global lock if needed */ Locked = AcpiExAcquireGlobalLock (ObjDesc->Field.LockRule); Status = AcpiExCommonAccessField (Mode, ObjDesc, Buffer, BufferLength); /* * Release global lock if we acquired it earlier */ AcpiExReleaseGlobalLock (Locked); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExAccessBankField * * PARAMETERS: Mode - ACPI_READ or ACPI_WRITE * *FieldNode - Parent node for field to be accessed * *Buffer - Value(s) to be read or written * BufferLength - Number of bytes to transfer * * RETURN: Status * * DESCRIPTION: Read or write a Bank Field * ******************************************************************************/ ACPI_STATUS AcpiExAccessBankField ( UINT32 Mode, ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength) { ACPI_STATUS Status; BOOLEAN Locked; FUNCTION_TRACE_PTR ("ExAccessBankField", ObjDesc); /* * Get the global lock if needed */ Locked = AcpiExAcquireGlobalLock (ObjDesc->BankField.LockRule); /* * Write the BankValue to the BankRegister to select the bank. * The BankValue for this BankField is specified in the * BankField ASL declaration. The BankRegister is always a Field in * an operation region. */ Status = AcpiExCommonAccessField (ACPI_WRITE, ObjDesc->BankField.BankRegisterObj, &ObjDesc->BankField.Value, sizeof (ObjDesc->BankField.Value)); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* * The bank was successfully selected, now read or write the actual * data. */ Status = AcpiExCommonAccessField (Mode, ObjDesc, Buffer, BufferLength); Cleanup: /* * Release global lock if we acquired it earlier */ AcpiExReleaseGlobalLock (Locked); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExAccessIndexField * * PARAMETERS: Mode - ACPI_READ or ACPI_WRITE * *FieldNode - Parent node for field to be accessed * *Buffer - Value(s) to be read or written * BufferLength - Number of bytes to transfer * * RETURN: Status * * DESCRIPTION: Read or write a Index Field * ******************************************************************************/ ACPI_STATUS AcpiExAccessIndexField ( UINT32 Mode, ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength) { ACPI_STATUS Status; BOOLEAN Locked; FUNCTION_TRACE_PTR ("ExAccessIndexField", ObjDesc); /* * Get the global lock if needed */ Locked = AcpiExAcquireGlobalLock (ObjDesc->IndexField.LockRule); /* * Set Index value to select proper Data register */ Status = AcpiExCommonAccessField (ACPI_WRITE, ObjDesc->IndexField.IndexObj, &ObjDesc->IndexField.Value, sizeof (ObjDesc->IndexField.Value)); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* Now read/write the data register */ Status = AcpiExCommonAccessField (Mode, ObjDesc->IndexField.DataObj, Buffer, BufferLength); Cleanup: /* * Release global lock if we acquired it earlier */ AcpiExReleaseGlobalLock (Locked); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExCommonAccessField * * PARAMETERS: Mode - ACPI_READ or ACPI_WRITE * *FieldNode - Parent node for field to be accessed * *Buffer - Value(s) to be read or written * BufferLength - Size of buffer, in bytes. Must be large * enough for all bits of the field. * * RETURN: Status * * DESCRIPTION: Read or write a named field * ******************************************************************************/ ACPI_STATUS AcpiExCommonAccessField ( UINT32 Mode, ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength) { ACPI_STATUS Status; FUNCTION_TRACE_PTR ("ExCommonAccessField", ObjDesc); - DEBUG_PRINTP (ACPI_INFO, ("Obj=%p Type=%X Buf=%p Len=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Obj=%p Type=%X Buf=%p Len=%X\n", ObjDesc, ObjDesc->Common.Type, Buffer, BufferLength)); - DEBUG_PRINTP (ACPI_INFO, ("Mode=%d BitLen=%X BitOff=%X ByteOff=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Mode=%d BitLen=%X BitOff=%X ByteOff=%X\n", Mode, ObjDesc->CommonField.BitLength, ObjDesc->CommonField.StartFieldBitOffset, ObjDesc->CommonField.BaseByteOffset)); /* Perform the actual read or write of the field */ switch (Mode) { case ACPI_READ: Status = AcpiExExtractFromField (ObjDesc, Buffer, BufferLength); break; case ACPI_WRITE: Status = AcpiExInsertIntoField (ObjDesc, Buffer, BufferLength); break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Unknown I/O Mode: %X\n", Mode)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown I/O Mode: %X\n", Mode)); Status = AE_BAD_PARAMETER; break; } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exfldio.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exfldio.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exfldio.c (revision 82367) @@ -1,1056 +1,1048 @@ /****************************************************************************** * * Module Name: exfldio - Aml Field I/O - * $Revision: 59 $ + * $Revision: 62 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXFLDIO_C__ #include "acpi.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #include "achware.h" #include "acevents.h" #include "acdispat.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exfldio") /******************************************************************************* * * FUNCTION: AcpiExSetupField * * PARAMETERS: *ObjDesc - Field to be read or written * FieldDatumByteOffset - Current offset into the field * * RETURN: Status * * DESCRIPTION: Common processing for AcpiExExtractFromField and * AcpiExInsertIntoField * ******************************************************************************/ ACPI_STATUS AcpiExSetupField ( ACPI_OPERAND_OBJECT *ObjDesc, UINT32 FieldDatumByteOffset) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *RgnDesc; FUNCTION_TRACE_U32 ("ExSetupField", FieldDatumByteOffset); - - /* Parameter validation */ - RgnDesc = ObjDesc->CommonField.RegionObj; - if (!ObjDesc || !RgnDesc) - { - DEBUG_PRINTP (ACPI_ERROR, ("Internal error - null handle\n")); - return_ACPI_STATUS (AE_AML_NO_OPERAND); - } if (ACPI_TYPE_REGION != RgnDesc->Common.Type) { - DEBUG_PRINTP (ACPI_ERROR, ("Needed Region, found type %x %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Needed Region, found type %x %s\n", RgnDesc->Common.Type, AcpiUtGetTypeName (RgnDesc->Common.Type))); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* * If the Region Address and Length have not been previously evaluated, * evaluate them now and save the results. */ if (!(RgnDesc->Region.Flags & AOPOBJ_DATA_VALID)) { Status = AcpiDsGetRegionArguments (RgnDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* * Validate the request. The entire request from the byte offset for a * length of one field datum (access width) must fit within the region. * (Region length is specified in bytes) */ if (RgnDesc->Region.Length < (ObjDesc->CommonField.BaseByteOffset + FieldDatumByteOffset + ObjDesc->CommonField.AccessByteWidth)) { if (RgnDesc->Region.Length < ObjDesc->CommonField.AccessByteWidth) { /* * This is the case where the AccessType (AccWord, etc.) is wider * than the region itself. For example, a region of length one * byte, and a field with Dword access specified. */ - DEBUG_PRINTP (ACPI_ERROR, - ("Field access width (%d bytes) too large for region size (%X)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Field access width (%d bytes) too large for region size (%X)\n", ObjDesc->CommonField.AccessByteWidth, RgnDesc->Region.Length)); } /* * Offset rounded up to next multiple of field width * exceeds region length, indicate an error */ - DEBUG_PRINTP (ACPI_ERROR, - ("Field base+offset+width %X+%X+%X exceeds region size (%X bytes) field=%p region=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Field base+offset+width %X+%X+%X exceeds region size (%X bytes) field=%p region=%p\n", ObjDesc->CommonField.BaseByteOffset, FieldDatumByteOffset, ObjDesc->CommonField.AccessByteWidth, RgnDesc->Region.Length, ObjDesc, RgnDesc)); return_ACPI_STATUS (AE_AML_REGION_LIMIT); } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExReadFieldDatum * * PARAMETERS: *ObjDesc - Field to be read * *Value - Where to store value (must be 32 bits) * * RETURN: Status * * DESCRIPTION: Retrieve the value of the given field * ******************************************************************************/ ACPI_STATUS AcpiExReadFieldDatum ( ACPI_OPERAND_OBJECT *ObjDesc, UINT32 FieldDatumByteOffset, UINT32 *Value) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *RgnDesc; ACPI_PHYSICAL_ADDRESS Address; UINT32 LocalValue; FUNCTION_TRACE_U32 ("ExReadFieldDatum", FieldDatumByteOffset); if (!Value) { LocalValue = 0; Value = &LocalValue; /* support reads without saving value */ } /* Clear the entire return buffer first, [Very Important!] */ *Value = 0; /* * BufferFields - Read from a Buffer * Other Fields - Read from a Operation Region. */ switch (ObjDesc->Common.Type) { case ACPI_TYPE_BUFFER_FIELD: /* * For BufferFields, we only need to copy the data from the * source buffer. Length is the field width in bytes. */ MEMCPY (Value, (ObjDesc->BufferField.BufferObj)->Buffer.Pointer + ObjDesc->BufferField.BaseByteOffset + FieldDatumByteOffset, ObjDesc->CommonField.AccessByteWidth); Status = AE_OK; break; case INTERNAL_TYPE_REGION_FIELD: case INTERNAL_TYPE_BANK_FIELD: /* * For other fields, we need to go through an Operation Region * (Only types that will get here are RegionFields and BankFields) */ Status = AcpiExSetupField (ObjDesc, FieldDatumByteOffset); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * The physical address of this field datum is: * * 1) The base of the region, plus * 2) The base offset of the field, plus * 3) The current offset into the field */ RgnDesc = ObjDesc->CommonField.RegionObj; Address = RgnDesc->Region.Address + ObjDesc->CommonField.BaseByteOffset + FieldDatumByteOffset; - DEBUG_PRINTP (TRACE_BFIELD, ("Region %s(%X) width %X base:off %X:%X at %8.8lX%8.8lX\n", + ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Region %s(%X) width %X base:off %X:%X at %8.8lX%8.8lX\n", AcpiUtGetRegionName (RgnDesc->Region.SpaceId), RgnDesc->Region.SpaceId, ObjDesc->CommonField.AccessBitWidth, ObjDesc->CommonField.BaseByteOffset, FieldDatumByteOffset, HIDWORD(Address), LODWORD(Address))); /* Invoke the appropriate AddressSpace/OpRegion handler */ Status = AcpiEvAddressSpaceDispatch (RgnDesc, ACPI_READ_ADR_SPACE, Address, ObjDesc->CommonField.AccessBitWidth, Value); if (Status == AE_NOT_IMPLEMENTED) { - DEBUG_PRINTP (ACPI_ERROR, ("Region %s(%X) not implemented\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Region %s(%X) not implemented\n", AcpiUtGetRegionName (RgnDesc->Region.SpaceId), RgnDesc->Region.SpaceId)); } else if (Status == AE_NOT_EXIST) { - DEBUG_PRINTP (ACPI_ERROR, ("Region %s(%X) has no handler\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Region %s(%X) has no handler\n", AcpiUtGetRegionName (RgnDesc->Region.SpaceId), RgnDesc->Region.SpaceId)); } break; default: - DEBUG_PRINTP (ACPI_ERROR, ("%p, wrong source type - %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%p, wrong source type - %s\n", ObjDesc, AcpiUtGetTypeName (ObjDesc->Common.Type))); Status = AE_AML_INTERNAL; break; } - DEBUG_PRINTP (TRACE_BFIELD, ("Returned value=%08lX \n", *Value)); + ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Returned value=%08lX \n", *Value)); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExGetBufferDatum * * PARAMETERS: MergedDatum - Value to store * Buffer - Receiving buffer * ByteGranularity - 1/2/4 Granularity of the field * (aka Datum Size) * Offset - Datum offset into the buffer * * RETURN: none * * DESCRIPTION: Store the merged datum to the buffer according to the * byte granularity * ******************************************************************************/ static void AcpiExGetBufferDatum( UINT32 *Datum, void *Buffer, UINT32 ByteGranularity, UINT32 Offset) { switch (ByteGranularity) { case ACPI_FIELD_BYTE_GRANULARITY: *Datum = ((UINT8 *) Buffer) [Offset]; break; case ACPI_FIELD_WORD_GRANULARITY: MOVE_UNALIGNED16_TO_32 (Datum, &(((UINT16 *) Buffer) [Offset])); break; case ACPI_FIELD_DWORD_GRANULARITY: MOVE_UNALIGNED32_TO_32 (Datum, &(((UINT32 *) Buffer) [Offset])); break; } } /******************************************************************************* * * FUNCTION: AcpiExSetBufferDatum * * PARAMETERS: MergedDatum - Value to store * Buffer - Receiving buffer * ByteGranularity - 1/2/4 Granularity of the field * (aka Datum Size) * Offset - Datum offset into the buffer * * RETURN: none * * DESCRIPTION: Store the merged datum to the buffer according to the * byte granularity * ******************************************************************************/ static void AcpiExSetBufferDatum ( UINT32 MergedDatum, void *Buffer, UINT32 ByteGranularity, UINT32 Offset) { switch (ByteGranularity) { case ACPI_FIELD_BYTE_GRANULARITY: ((UINT8 *) Buffer) [Offset] = (UINT8) MergedDatum; break; case ACPI_FIELD_WORD_GRANULARITY: MOVE_UNALIGNED16_TO_16 (&(((UINT16 *) Buffer)[Offset]), &MergedDatum); break; case ACPI_FIELD_DWORD_GRANULARITY: MOVE_UNALIGNED32_TO_32 (&(((UINT32 *) Buffer)[Offset]), &MergedDatum); break; } } /******************************************************************************* * * FUNCTION: AcpiExExtractFromField * * PARAMETERS: *ObjDesc - Field to be read * *Value - Where to store value * * RETURN: Status * * DESCRIPTION: Retrieve the value of the given field * ******************************************************************************/ ACPI_STATUS AcpiExExtractFromField ( ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength) { ACPI_STATUS Status; UINT32 FieldDatumByteOffset; UINT32 DatumOffset; UINT32 PreviousRawDatum; UINT32 ThisRawDatum = 0; UINT32 MergedDatum = 0; UINT32 ByteFieldLength; UINT32 DatumCount; FUNCTION_TRACE ("ExExtractFromField"); /* * The field must fit within the caller's buffer */ ByteFieldLength = ROUND_BITS_UP_TO_BYTES (ObjDesc->CommonField.BitLength); if (ByteFieldLength > BufferLength) { - DEBUG_PRINTP (ACPI_INFO, ("Field size %X (bytes) too large for buffer (%X)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Field size %X (bytes) too large for buffer (%X)\n", ByteFieldLength, BufferLength)); return_ACPI_STATUS (AE_BUFFER_OVERFLOW); } /* Convert field byte count to datum count, round up if necessary */ DatumCount = ROUND_UP_TO (ByteFieldLength, ObjDesc->CommonField.AccessByteWidth); - DEBUG_PRINT (ACPI_INFO, - ("ByteLen=%x, DatumLen=%x, BitGran=%x, ByteGran=%x\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "ByteLen=%x, DatumLen=%x, BitGran=%x, ByteGran=%x\n", ByteFieldLength, DatumCount, ObjDesc->CommonField.AccessBitWidth, ObjDesc->CommonField.AccessByteWidth)); /* * Clear the caller's buffer (the whole buffer length as given) * This is very important, especially in the cases where a byte is read, * but the buffer is really a UINT32 (4 bytes). */ MEMSET (Buffer, 0, BufferLength); /* Read the first raw datum to prime the loop */ FieldDatumByteOffset = 0; DatumOffset= 0; Status = AcpiExReadFieldDatum (ObjDesc, FieldDatumByteOffset, &PreviousRawDatum); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* We might actually be done if the request fits in one datum */ if ((DatumCount == 1) && (ObjDesc->CommonField.AccessFlags & AFIELD_SINGLE_DATUM)) { /* 1) Shift the valid data bits down to start at bit 0 */ MergedDatum = (PreviousRawDatum >> ObjDesc->CommonField.StartFieldBitOffset); /* 2) Mask off any upper unused bits (bits not part of the field) */ if (ObjDesc->CommonField.EndBufferValidBits) { MergedDatum &= MASK_BITS_ABOVE (ObjDesc->CommonField.EndBufferValidBits); } /* Store the datum to the caller buffer */ AcpiExSetBufferDatum (MergedDatum, Buffer, ObjDesc->CommonField.AccessByteWidth, DatumOffset); return_ACPI_STATUS (AE_OK); } /* We need to get more raw data to complete one or more field data */ while (DatumOffset < DatumCount) { FieldDatumByteOffset += ObjDesc->CommonField.AccessByteWidth; /* * If the field is aligned on a byte boundary, we don't want * to perform a final read, since this would potentially read * past the end of the region. * * TBD: [Investigate] It may make more sense to just split the aligned * and non-aligned cases since the aligned case is so very simple, */ if ((ObjDesc->CommonField.StartFieldBitOffset != 0) || ((ObjDesc->CommonField.StartFieldBitOffset == 0) && (DatumOffset < (DatumCount -1)))) { /* * Get the next raw datum, it contains some or all bits * of the current field datum */ Status = AcpiExReadFieldDatum (ObjDesc, FieldDatumByteOffset, &ThisRawDatum); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* * Create the (possibly) merged datum to be stored to the caller buffer */ if (ObjDesc->CommonField.StartFieldBitOffset == 0) { /* Field is not skewed and we can just copy the datum */ MergedDatum = PreviousRawDatum; } else { /* * Put together the appropriate bits of the two raw data to make a * single complete field datum * * 1) Normalize the first datum down to bit 0 */ MergedDatum = (PreviousRawDatum >> ObjDesc->CommonField.StartFieldBitOffset); /* 2) Insert the second datum "above" the first datum */ MergedDatum |= (ThisRawDatum << ObjDesc->CommonField.DatumValidBits); if ((DatumOffset >= (DatumCount -1))) { /* * This is the last iteration of the loop. We need to clear * any unused bits (bits that are not part of this field) that * came from the last raw datum before we store the final * merged datum into the caller buffer. */ if (ObjDesc->CommonField.EndBufferValidBits) { MergedDatum &= MASK_BITS_ABOVE (ObjDesc->CommonField.EndBufferValidBits); } } } /* * Store the merged field datum in the caller's buffer, according to * the granularity of the field (size of each datum). */ AcpiExSetBufferDatum (MergedDatum, Buffer, ObjDesc->CommonField.AccessByteWidth, DatumOffset); /* * Save the raw datum that was just acquired since it may contain bits * of the *next* field datum. Update offsets */ PreviousRawDatum = ThisRawDatum; DatumOffset++; } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExWriteFieldDatum * * PARAMETERS: *ObjDesc - Field to be set * Value - Value to store * * RETURN: Status * * DESCRIPTION: Store the value into the given field * ******************************************************************************/ static ACPI_STATUS AcpiExWriteFieldDatum ( ACPI_OPERAND_OBJECT *ObjDesc, UINT32 FieldDatumByteOffset, UINT32 Value) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *RgnDesc = NULL; ACPI_PHYSICAL_ADDRESS Address; FUNCTION_TRACE_U32 ("ExWriteFieldDatum", FieldDatumByteOffset); /* * BufferFields - Read from a Buffer * Other Fields - Read from a Operation Region. */ switch (ObjDesc->Common.Type) { case ACPI_TYPE_BUFFER_FIELD: /* * For BufferFields, we only need to copy the data to the * target buffer. Length is the field width in bytes. */ MEMCPY ((ObjDesc->BufferField.BufferObj)->Buffer.Pointer + ObjDesc->BufferField.BaseByteOffset + FieldDatumByteOffset, &Value, ObjDesc->CommonField.AccessByteWidth); Status = AE_OK; break; case INTERNAL_TYPE_REGION_FIELD: case INTERNAL_TYPE_BANK_FIELD: /* * For other fields, we need to go through an Operation Region * (Only types that will get here are RegionFields and BankFields) */ Status = AcpiExSetupField (ObjDesc, FieldDatumByteOffset); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * The physical address of this field datum is: * * 1) The base of the region, plus * 2) The base offset of the field, plus * 3) The current offset into the field */ RgnDesc = ObjDesc->CommonField.RegionObj; Address = RgnDesc->Region.Address + ObjDesc->CommonField.BaseByteOffset + FieldDatumByteOffset; - DEBUG_PRINTP (TRACE_BFIELD, - ("Store %X in Region %s(%X) at %8.8lX%8.8lX width %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, + "Store %X in Region %s(%X) at %8.8lX%8.8lX width %X\n", Value, AcpiUtGetRegionName (RgnDesc->Region.SpaceId), RgnDesc->Region.SpaceId, HIDWORD(Address), LODWORD(Address), ObjDesc->CommonField.AccessBitWidth)); /* Invoke the appropriate AddressSpace/OpRegion handler */ Status = AcpiEvAddressSpaceDispatch (RgnDesc, ACPI_WRITE_ADR_SPACE, Address, ObjDesc->CommonField.AccessBitWidth, &Value); if (Status == AE_NOT_IMPLEMENTED) { - DEBUG_PRINTP (ACPI_ERROR, - ("**** Region type %s(%X) not implemented\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "**** Region type %s(%X) not implemented\n", AcpiUtGetRegionName (RgnDesc->Region.SpaceId), RgnDesc->Region.SpaceId)); } else if (Status == AE_NOT_EXIST) { - DEBUG_PRINTP (ACPI_ERROR, - ("**** Region type %s(%X) does not have a handler\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "**** Region type %s(%X) does not have a handler\n", AcpiUtGetRegionName (RgnDesc->Region.SpaceId), RgnDesc->Region.SpaceId)); } break; default: - DEBUG_PRINTP (ACPI_ERROR, ("%p, wrong source type - %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%p, wrong source type - %s\n", ObjDesc, AcpiUtGetTypeName (ObjDesc->Common.Type))); Status = AE_AML_INTERNAL; break; } - DEBUG_PRINTP (TRACE_BFIELD, ("Value written=%08lX \n", Value)); + ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Value written=%08lX \n", Value)); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExWriteFieldDatumWithUpdateRule * * PARAMETERS: *ObjDesc - Field to be set * Value - Value to store * * RETURN: Status * * DESCRIPTION: Apply the field update rule to a field write * ******************************************************************************/ static ACPI_STATUS AcpiExWriteFieldDatumWithUpdateRule ( ACPI_OPERAND_OBJECT *ObjDesc, UINT32 Mask, UINT32 FieldValue, UINT32 FieldDatumByteOffset) { ACPI_STATUS Status = AE_OK; UINT32 MergedValue; UINT32 CurrentValue; FUNCTION_TRACE ("ExWriteFieldDatumWithUpdateRule"); /* Start with the new bits */ MergedValue = FieldValue; /* If the mask is all ones, we don't need to worry about the update rule */ if (Mask != ACPI_UINT32_MAX) { /* Decode the update rule */ switch (ObjDesc->CommonField.UpdateRule) { case UPDATE_PRESERVE: /* * Check if update rule needs to be applied (not if mask is all * ones) The left shift drops the bits we want to ignore. */ if ((~Mask << (sizeof (Mask) * 8 - ObjDesc->CommonField.AccessBitWidth)) != 0) { /* * Read the current contents of the byte/word/dword containing * the field, and merge with the new field value. */ Status = AcpiExReadFieldDatum (ObjDesc, FieldDatumByteOffset, &CurrentValue); MergedValue |= (CurrentValue & ~Mask); } break; case UPDATE_WRITE_AS_ONES: /* Set positions outside the field to all ones */ MergedValue |= ~Mask; break; case UPDATE_WRITE_AS_ZEROS: /* Set positions outside the field to all zeros */ MergedValue &= Mask; break; default: - DEBUG_PRINT (ACPI_ERROR, - ("WriteWithUpdateRule: Unknown UpdateRule setting: %x\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "WriteWithUpdateRule: Unknown UpdateRule setting: %x\n", ObjDesc->CommonField.UpdateRule)); return_ACPI_STATUS (AE_AML_OPERAND_VALUE); break; } } /* Write the merged value */ Status = AcpiExWriteFieldDatum (ObjDesc, FieldDatumByteOffset, MergedValue); - DEBUG_PRINTP (TRACE_BFIELD, ("Mask %X DatumOffset %X Value %X, MergedValue %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Mask %X DatumOffset %X Value %X, MergedValue %X\n", Mask, FieldDatumByteOffset, FieldValue, MergedValue)); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExInsertIntoField * * PARAMETERS: *ObjDesc - Field to be set * Buffer - Value to store * * RETURN: Status * * DESCRIPTION: Store the value into the given field * ******************************************************************************/ ACPI_STATUS AcpiExInsertIntoField ( ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength) { ACPI_STATUS Status; UINT32 FieldDatumByteOffset; UINT32 DatumOffset; UINT32 Mask; UINT32 MergedDatum; UINT32 PreviousRawDatum; UINT32 ThisRawDatum; UINT32 ByteFieldLength; UINT32 DatumCount; FUNCTION_TRACE ("ExInsertIntoField"); /* * Incoming buffer must be at least as long as the field, we do not * allow "partial" field writes. We do not care if the buffer is * larger than the field, this typically happens when an integer is * written to a field that is actually smaller than an integer. */ ByteFieldLength = ROUND_BITS_UP_TO_BYTES (ObjDesc->CommonField.BitLength); if (BufferLength < ByteFieldLength) { - DEBUG_PRINTP (ACPI_INFO, ("Buffer length %X too small for field %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Buffer length %X too small for field %X\n", BufferLength, ByteFieldLength)); /* TBD: Need a better error code */ return_ACPI_STATUS (AE_BUFFER_OVERFLOW); } /* Convert byte count to datum count, round up if necessary */ DatumCount = ROUND_UP_TO (ByteFieldLength, ObjDesc->CommonField.AccessByteWidth); - DEBUG_PRINT (ACPI_INFO, - ("ByteLen=%x, DatumLen=%x, BitGran=%x, ByteGran=%x\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "ByteLen=%x, DatumLen=%x, BitGran=%x, ByteGran=%x\n", ByteFieldLength, DatumCount, ObjDesc->CommonField.AccessBitWidth, ObjDesc->CommonField.AccessByteWidth)); /* * Break the request into up to three parts (similar to an I/O request): * 1) non-aligned part at start * 2) aligned part in middle * 3) non-aligned part at the end */ FieldDatumByteOffset = 0; DatumOffset= 0; /* Get a single datum from the caller's buffer */ AcpiExGetBufferDatum (&PreviousRawDatum, Buffer, ObjDesc->CommonField.AccessByteWidth, DatumOffset); /* * Part1: * Write a partial field datum if field does not begin on a datum boundary * Note: The code in this section also handles the aligned case * * Construct Mask with 1 bits where the field is, 0 bits elsewhere * (Only the bottom 5 bits of BitLength are valid for a shift operation) * * Mask off bits that are "below" the field (if any) */ Mask = MASK_BITS_BELOW (ObjDesc->CommonField.StartFieldBitOffset); /* If the field fits in one datum, may need to mask upper bits */ if ((ObjDesc->CommonField.AccessFlags & AFIELD_SINGLE_DATUM) && ObjDesc->CommonField.EndFieldValidBits) { /* There are bits above the field, mask them off also */ Mask &= MASK_BITS_ABOVE (ObjDesc->CommonField.EndFieldValidBits); } /* Shift and mask the value into the field position */ MergedDatum = (PreviousRawDatum << ObjDesc->CommonField.StartFieldBitOffset); MergedDatum &= Mask; /* Apply the update rule (if necessary) and write the datum to the field */ Status = AcpiExWriteFieldDatumWithUpdateRule (ObjDesc, Mask, MergedDatum, FieldDatumByteOffset); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* If the entire field fits within one datum, we are done. */ if ((DatumCount == 1) && (ObjDesc->CommonField.AccessFlags & AFIELD_SINGLE_DATUM)) { return_ACPI_STATUS (AE_OK); } /* * Part2: * Write the aligned data. * * We don't need to worry about the update rule for these data, because * all of the bits in each datum are part of the field. * * The last datum must be special cased because it might contain bits * that are not part of the field -- therefore the "update rule" must be * applied in Part3 below. */ while (DatumOffset < DatumCount) { DatumOffset++; FieldDatumByteOffset += ObjDesc->CommonField.AccessByteWidth; /* * Get the next raw buffer datum. It may contain bits of the previous * field datum */ AcpiExGetBufferDatum (&ThisRawDatum, Buffer, ObjDesc->CommonField.AccessByteWidth, DatumOffset); /* Create the field datum based on the field alignment */ if (ObjDesc->CommonField.StartFieldBitOffset != 0) { /* * Put together appropriate bits of the two raw buffer data to make * a single complete field datum */ MergedDatum = (PreviousRawDatum >> ObjDesc->CommonField.DatumValidBits) | (ThisRawDatum << ObjDesc->CommonField.StartFieldBitOffset); } else { /* Field began aligned on datum boundary */ MergedDatum = ThisRawDatum; } /* * Special handling for the last datum if the field does NOT end on * a datum boundary. Update Rule must be applied to the bits outside * the field. */ if ((DatumOffset == DatumCount) && ObjDesc->CommonField.EndFieldValidBits) { /* * Part3: * This is the last datum and the field does not end on a datum boundary. * Build the partial datum and write with the update rule. */ /* Mask off the unused bits above (after) the end-of-field */ Mask = MASK_BITS_ABOVE (ObjDesc->CommonField.EndFieldValidBits); MergedDatum &= Mask; /* Write the last datum with the update rule */ Status = AcpiExWriteFieldDatumWithUpdateRule (ObjDesc, Mask, MergedDatum, FieldDatumByteOffset); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } else { /* Normal case -- write the completed datum */ Status = AcpiExWriteFieldDatum (ObjDesc, FieldDatumByteOffset, MergedDatum); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* * Save the most recent datum since it may contain bits of the *next* * field datum. Update current byte offset. */ PreviousRawDatum = ThisRawDatum; } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exmisc.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exmisc.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exmisc.c (revision 82367) @@ -1,716 +1,716 @@ /****************************************************************************** * * Module Name: exmisc - ACPI AML (p-code) execution - specific opcodes - * $Revision: 79 $ + * $Revision: 80 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXMISC_C__ #include "acpi.h" #include "acparser.h" #include "acinterp.h" #include "amlcode.h" #include "acdispat.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exmisc") /******************************************************************************* * * FUNCTION: AcpiExFatal * * PARAMETERS: none * * RETURN: Status. If the OS returns from the OSD call, we just keep * on going. * * DESCRIPTION: Execute Fatal operator * * ACPI SPECIFICATION REFERENCES: * DefFatal := FatalOp FatalType FatalCode FatalArg * FatalType := ByteData * FatalCode := DWordData * FatalArg := TermArg=>Integer * ******************************************************************************/ ACPI_STATUS AcpiExFatal ( ACPI_WALK_STATE *WalkState) { ACPI_OPERAND_OBJECT *TypeDesc; ACPI_OPERAND_OBJECT *CodeDesc; ACPI_OPERAND_OBJECT *ArgDesc; ACPI_STATUS Status; FUNCTION_TRACE ("ExFatal"); /* Resolve operands */ Status = AcpiExResolveOperands (AML_FATAL_OP, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (AML_FATAL_OP), 3, "after AcpiExResolveOperands"); /* Get operands */ Status |= AcpiDsObjStackPopObject (&ArgDesc, WalkState); Status |= AcpiDsObjStackPopObject (&CodeDesc, WalkState); Status |= AcpiDsObjStackPopObject (&TypeDesc, WalkState); if (ACPI_FAILURE (Status)) { /* Invalid parameters on object stack */ - DEBUG_PRINTP (ACPI_ERROR, ("bad operand(s) (Status=%X)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "bad operand(s) (Status=%X)\n", Status)); goto Cleanup; } /* DefFatal := FatalOp FatalType FatalCode FatalArg */ - DEBUG_PRINTP (ACPI_INFO, - ("Type %x Code %x Arg %x <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Type %x Code %x Arg %x <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n", TypeDesc->Integer.Value, CodeDesc->Integer.Value, ArgDesc->Integer.Value)); /* * TBD: [Unhandled] call OSD interface to notify OS of fatal error * requiring shutdown! */ Cleanup: /* Free the operands */ AcpiUtRemoveReference (ArgDesc); AcpiUtRemoveReference (CodeDesc); AcpiUtRemoveReference (TypeDesc); /* If we get back from the OS call, we might as well keep going. */ REPORT_WARNING (("An AML \"Fatal\" Opcode (FatalOp) was executed\n")); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExTriadic * * PARAMETERS: Opcode - The opcode to be executed * WalkState - Current walk state * ReturnDesc - Where to store the return object * * RETURN: Status * * DESCRIPTION: Execute Triadic operator (3 operands) * * ALLOCATION: Deletes one operand descriptor -- other remains on stack * ******************************************************************************/ ACPI_STATUS AcpiExTriadic ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc) { ACPI_OPERAND_OBJECT *ObjDesc1; ACPI_OPERAND_OBJECT *ObjDesc2; ACPI_OPERAND_OBJECT *ResDesc; ACPI_OPERAND_OBJECT *RetDesc = NULL; ACPI_OPERAND_OBJECT *TmpDesc; ACPI_SIGNAL_FATAL_INFO *Fatal; ACPI_STATUS Status; FUNCTION_TRACE ("ExTriadic"); /* Resolve operands */ /* First operand can be either a package or a buffer */ Status = AcpiExResolveOperands (AML_INDEX_OP, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (AML_INDEX_OP), 3, "after AcpiExResolveOperands"); /* Get all operands */ Status |= AcpiDsObjStackPopObject (&ResDesc, WalkState); Status |= AcpiDsObjStackPopObject (&ObjDesc2, WalkState); Status |= AcpiDsObjStackPopObject (&ObjDesc1, WalkState); if (ACPI_FAILURE (Status)) { /* Invalid parameters on object stack */ - DEBUG_PRINTP (ACPI_ERROR, ("bad operand(s) (Status=%X)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "bad operand(s) (Status=%X)\n", Status)); goto Cleanup; } switch (Opcode) { case AML_FATAL_OP: /* DefFatal := FatalOp FatalType FatalCode FatalArg */ - DEBUG_PRINTP (ACPI_INFO, - ("FatalOp: Type %x Code %x Arg %x <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "FatalOp: Type %x Code %x Arg %x <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n", (UINT32) ObjDesc1->Integer.Value, (UINT32) ObjDesc2->Integer.Value, (UINT32) ResDesc->Integer.Value)); Fatal = ACPI_MEM_ALLOCATE (sizeof (ACPI_SIGNAL_FATAL_INFO)); if (Fatal) { Fatal->Type = (UINT32) ObjDesc1->Integer.Value; Fatal->Code = (UINT32) ObjDesc2->Integer.Value; Fatal->Argument = (UINT32) ResDesc->Integer.Value; } /* * Signal the OS */ AcpiOsSignal (ACPI_SIGNAL_FATAL, Fatal); /* Might return while OS is shutting down */ ACPI_MEM_FREE (Fatal); break; case AML_MID_OP: /* DefMid := MidOp Source Index Length Result */ /* Create the internal return object (string or buffer) */ break; case AML_INDEX_OP: /* DefIndex := IndexOp Source Index Destination */ /* Create the internal return object */ RetDesc = AcpiUtCreateInternalObject (INTERNAL_TYPE_REFERENCE); if (!RetDesc) { Status = AE_NO_MEMORY; goto Cleanup; } /* * At this point, the ObjDesc1 operand is either a Package or a Buffer */ if (ObjDesc1->Common.Type == ACPI_TYPE_PACKAGE) { /* Object to be indexed is a Package */ if (ObjDesc2->Integer.Value >= ObjDesc1->Package.Count) { - DEBUG_PRINTP (ACPI_ERROR, ("Index value beyond package end\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Index value beyond package end\n")); Status = AE_AML_PACKAGE_LIMIT; goto Cleanup; } if ((ResDesc->Common.Type == INTERNAL_TYPE_REFERENCE) && (ResDesc->Reference.Opcode == AML_ZERO_OP)) { /* * There is no actual result descriptor (the ZeroOp Result * descriptor is a placeholder), so just delete the placeholder and * return a reference to the package element */ AcpiUtRemoveReference (ResDesc); } else { /* * Each element of the package is an internal object. Get the one * we are after. */ TmpDesc = ObjDesc1->Package.Elements[ObjDesc2->Integer.Value]; RetDesc->Reference.Opcode = AML_INDEX_OP; RetDesc->Reference.TargetType = TmpDesc->Common.Type; RetDesc->Reference.Object = TmpDesc; Status = AcpiExStore (RetDesc, ResDesc, WalkState); RetDesc->Reference.Object = NULL; } /* * The local return object must always be a reference to the package element, * not the element itself. */ RetDesc->Reference.Opcode = AML_INDEX_OP; RetDesc->Reference.TargetType = ACPI_TYPE_PACKAGE; RetDesc->Reference.Where = &ObjDesc1->Package.Elements[ObjDesc2->Integer.Value]; } else { /* Object to be indexed is a Buffer */ if (ObjDesc2->Integer.Value >= ObjDesc1->Buffer.Length) { - DEBUG_PRINTP (ACPI_ERROR, ("Index value beyond end of buffer\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Index value beyond end of buffer\n")); Status = AE_AML_BUFFER_LIMIT; goto Cleanup; } RetDesc->Reference.Opcode = AML_INDEX_OP; RetDesc->Reference.TargetType = ACPI_TYPE_BUFFER_FIELD; RetDesc->Reference.Object = ObjDesc1; RetDesc->Reference.Offset = (UINT32) ObjDesc2->Integer.Value; Status = AcpiExStore (RetDesc, ResDesc, WalkState); } break; } Cleanup: /* Always delete operands */ AcpiUtRemoveReference (ObjDesc1); AcpiUtRemoveReference (ObjDesc2); /* Delete return object on error */ if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ResDesc); if (RetDesc) { AcpiUtRemoveReference (RetDesc); RetDesc = NULL; } } /* Set the return object and exit */ *ReturnDesc = RetDesc; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExHexadic * * PARAMETERS: Opcode - The opcode to be executed * WalkState - Current walk state * ReturnDesc - Where to store the return object * * RETURN: Status * * DESCRIPTION: Execute Match operator * ******************************************************************************/ ACPI_STATUS AcpiExHexadic ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc) { ACPI_OPERAND_OBJECT *PkgDesc; ACPI_OPERAND_OBJECT *Op1Desc; ACPI_OPERAND_OBJECT *V1Desc; ACPI_OPERAND_OBJECT *Op2Desc; ACPI_OPERAND_OBJECT *V2Desc; ACPI_OPERAND_OBJECT *StartDesc; ACPI_OPERAND_OBJECT *RetDesc = NULL; ACPI_STATUS Status; UINT32 Index; UINT32 MatchValue = (UINT32) -1; FUNCTION_TRACE ("ExHexadic"); /* Resolve all operands */ Status = AcpiExResolveOperands (AML_MATCH_OP, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (AML_MATCH_OP), 6, "after AcpiExResolveOperands"); /* Get all operands */ Status |= AcpiDsObjStackPopObject (&StartDesc, WalkState); Status |= AcpiDsObjStackPopObject (&V2Desc, WalkState); Status |= AcpiDsObjStackPopObject (&Op2Desc, WalkState); Status |= AcpiDsObjStackPopObject (&V1Desc, WalkState); Status |= AcpiDsObjStackPopObject (&Op1Desc, WalkState); Status |= AcpiDsObjStackPopObject (&PkgDesc, WalkState); if (ACPI_FAILURE (Status)) { /* Invalid parameters on object stack */ - DEBUG_PRINTP (ACPI_ERROR, ("bad operand(s) (Status=%X)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "bad operand(s) (Status=%X)\n", Status)); goto Cleanup; } switch (Opcode) { case AML_MATCH_OP: /* Validate match comparison sub-opcodes */ if ((Op1Desc->Integer.Value > MAX_MATCH_OPERATOR) || (Op2Desc->Integer.Value > MAX_MATCH_OPERATOR)) { - DEBUG_PRINTP (ACPI_ERROR, ("operation encoding out of range\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "operation encoding out of range\n")); Status = AE_AML_OPERAND_VALUE; goto Cleanup; } Index = (UINT32) StartDesc->Integer.Value; if (Index >= (UINT32) PkgDesc->Package.Count) { - DEBUG_PRINTP (ACPI_ERROR, ("Start position value out of range\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Start position value out of range\n")); Status = AE_AML_PACKAGE_LIMIT; goto Cleanup; } RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!RetDesc) { Status = AE_NO_MEMORY; goto Cleanup; } /* * Examine each element until a match is found. Within the loop, * "continue" signifies that the current element does not match * and the next should be examined. * Upon finding a match, the loop will terminate via "break" at * the bottom. If it terminates "normally", MatchValue will be -1 * (its initial value) indicating that no match was found. When * returned as a Number, this will produce the Ones value as specified. */ for ( ; Index < PkgDesc->Package.Count; ++Index) { /* * Treat any NULL or non-numeric elements as non-matching. * TBD [Unhandled] - if an element is a Name, * should we examine its value? */ if (!PkgDesc->Package.Elements[Index] || ACPI_TYPE_INTEGER != PkgDesc->Package.Elements[Index]->Common.Type) { continue; } /* * Within these switch statements: * "break" (exit from the switch) signifies a match; * "continue" (proceed to next iteration of enclosing * "for" loop) signifies a non-match. */ switch (Op1Desc->Integer.Value) { case MATCH_MTR: /* always true */ break; case MATCH_MEQ: /* true if equal */ if (PkgDesc->Package.Elements[Index]->Integer.Value != V1Desc->Integer.Value) { continue; } break; case MATCH_MLE: /* true if less than or equal */ if (PkgDesc->Package.Elements[Index]->Integer.Value > V1Desc->Integer.Value) { continue; } break; case MATCH_MLT: /* true if less than */ if (PkgDesc->Package.Elements[Index]->Integer.Value >= V1Desc->Integer.Value) { continue; } break; case MATCH_MGE: /* true if greater than or equal */ if (PkgDesc->Package.Elements[Index]->Integer.Value < V1Desc->Integer.Value) { continue; } break; case MATCH_MGT: /* true if greater than */ if (PkgDesc->Package.Elements[Index]->Integer.Value <= V1Desc->Integer.Value) { continue; } break; default: /* undefined */ continue; } switch(Op2Desc->Integer.Value) { case MATCH_MTR: break; case MATCH_MEQ: if (PkgDesc->Package.Elements[Index]->Integer.Value != V2Desc->Integer.Value) { continue; } break; case MATCH_MLE: if (PkgDesc->Package.Elements[Index]->Integer.Value > V2Desc->Integer.Value) { continue; } break; case MATCH_MLT: if (PkgDesc->Package.Elements[Index]->Integer.Value >= V2Desc->Integer.Value) { continue; } break; case MATCH_MGE: if (PkgDesc->Package.Elements[Index]->Integer.Value < V2Desc->Integer.Value) { continue; } break; case MATCH_MGT: if (PkgDesc->Package.Elements[Index]->Integer.Value <= V2Desc->Integer.Value) { continue; } break; default: continue; } /* Match found: exit from loop */ MatchValue = Index; break; } /* MatchValue is the return value */ RetDesc->Integer.Value = MatchValue; break; } Cleanup: /* Free the operands */ AcpiUtRemoveReference (StartDesc); AcpiUtRemoveReference (V2Desc); AcpiUtRemoveReference (Op2Desc); AcpiUtRemoveReference (V1Desc); AcpiUtRemoveReference (Op1Desc); AcpiUtRemoveReference (PkgDesc); /* Delete return object on error */ if (ACPI_FAILURE (Status) && (RetDesc)) { AcpiUtRemoveReference (RetDesc); RetDesc = NULL; } /* Set the return object and exit */ *ReturnDesc = RetDesc; return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exmonad.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exmonad.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exmonad.c (revision 82367) @@ -1,1232 +1,1222 @@ /****************************************************************************** * * Module Name: exmonad - ACPI AML execution for monadic (1 operand) operators - * $Revision: 104 $ + * $Revision: 108 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXMONAD_C__ #include "acpi.h" #include "acparser.h" #include "acdispat.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exmonad") /******************************************************************************* * * FUNCTION: AcpiExGetObjectReference * * PARAMETERS: ObjDesc - Create a reference to this object * RetDesc - Where to store the reference * * RETURN: Status * * DESCRIPTION: Obtain and return a "reference" to the target object * Common code for the RefOfOp and the CondRefOfOp. * ******************************************************************************/ static ACPI_STATUS AcpiExGetObjectReference ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **RetDesc, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE_PTR ("ExGetObjectReference", ObjDesc); if (VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_INTERNAL)) { if (ObjDesc->Common.Type != INTERNAL_TYPE_REFERENCE) { *RetDesc = NULL; Status = AE_TYPE; goto Cleanup; } /* * Not a Name -- an indirect name pointer would have * been converted to a direct name pointer in AcpiExResolveOperands */ switch (ObjDesc->Reference.Opcode) { case AML_LOCAL_OP: case AML_ARG_OP: *RetDesc = (void *) AcpiDsMethodDataGetNode (ObjDesc->Reference.Opcode, ObjDesc->Reference.Offset, WalkState); break; default: - DEBUG_PRINTP (ACPI_ERROR, ("(Internal) Unknown Ref subtype %02x\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(Internal) Unknown Ref subtype %02x\n", ObjDesc->Reference.Opcode)); *RetDesc = NULL; Status = AE_AML_INTERNAL; goto Cleanup; } } else if (VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_NAMED)) { /* Must be a named object; Just return the Node */ *RetDesc = ObjDesc; } else { *RetDesc = NULL; Status = AE_TYPE; } Cleanup: - DEBUG_PRINTP (TRACE_EXEC, ("Obj=%p Ref=%p\n", ObjDesc, *RetDesc)); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p Ref=%p\n", ObjDesc, *RetDesc)); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExMonadic1 * * PARAMETERS: Opcode - The opcode to be executed * * RETURN: Status * * DESCRIPTION: Execute Type 1 monadic operator with numeric operand on * object stack * ******************************************************************************/ ACPI_STATUS AcpiExMonadic1 ( UINT16 Opcode, ACPI_WALK_STATE *WalkState) { ACPI_OPERAND_OBJECT *ObjDesc = NULL; ACPI_STATUS Status; ACPI_STATUS ResolveStatus; FUNCTION_TRACE_PTR ("ExMonadic1", WALK_OPERANDS); /* Resolve the operand */ ResolveStatus = AcpiExResolveOperands (Opcode, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (Opcode), 1, "after AcpiExResolveOperands"); /* Get the operand */ Status = AcpiDsObjStackPopObject (&ObjDesc, WalkState); /* Check operand status */ if (ACPI_FAILURE (ResolveStatus)) { - DEBUG_PRINTP (ACPI_ERROR, ("[%s]: Could not resolve operands, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "[%s]: Could not resolve operands, %s\n", AcpiPsGetOpcodeName (Opcode), AcpiFormatException (ResolveStatus))); goto Cleanup; } if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("[%s]: bad operand(s) %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "[%s]: bad operand(s) %s\n", AcpiPsGetOpcodeName (Opcode), AcpiFormatException (Status))); goto Cleanup; } /* Examine the opcode */ switch (Opcode) { /* DefRelease := ReleaseOp MutexObject */ case AML_RELEASE_OP: Status = AcpiExReleaseMutex (ObjDesc, WalkState); break; /* DefReset := ResetOp AcpiEventObject */ case AML_RESET_OP: Status = AcpiExSystemResetEvent (ObjDesc); break; /* DefSignal := SignalOp AcpiEventObject */ case AML_SIGNAL_OP: Status = AcpiExSystemSignalEvent (ObjDesc); break; /* DefSleep := SleepOp MsecTime */ case AML_SLEEP_OP: AcpiExSystemDoSuspend ((UINT32) ObjDesc->Integer.Value); break; /* DefStall := StallOp UsecTime */ case AML_STALL_OP: AcpiExSystemDoStall ((UINT32) ObjDesc->Integer.Value); break; /* Unknown opcode */ default: REPORT_ERROR (("AcpiExMonadic1: Unknown monadic opcode %X\n", Opcode)); Status = AE_AML_BAD_OPCODE; break; } /* switch */ Cleanup: /* Always delete the operand */ AcpiUtRemoveReference (ObjDesc); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExMonadic2R * * PARAMETERS: Opcode - The opcode to be executed * * RETURN: Status * * DESCRIPTION: Execute Type 2 monadic operator with numeric operand and * result operand on operand stack * ******************************************************************************/ ACPI_STATUS AcpiExMonadic2R ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *ResDesc; ACPI_OPERAND_OBJECT *RetDesc = NULL; ACPI_OPERAND_OBJECT *RetDesc2 = NULL; UINT32 ResVal; ACPI_STATUS Status; ACPI_STATUS ResolveStatus; UINT32 i; UINT32 j; ACPI_INTEGER Digit; FUNCTION_TRACE_PTR ("ExMonadic2R", WALK_OPERANDS); /* Resolve all operands */ ResolveStatus = AcpiExResolveOperands (Opcode, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (Opcode), 2, "after AcpiExResolveOperands"); /* Get all operands */ Status = AcpiDsObjStackPopObject (&ResDesc, WalkState); Status |= AcpiDsObjStackPopObject (&ObjDesc, WalkState); /* Now we can check the status codes */ if (ACPI_FAILURE (ResolveStatus)) { - DEBUG_PRINTP (ACPI_ERROR, ("[%s]: Could not resolve operands, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "[%s]: Could not resolve operands, %s\n", AcpiPsGetOpcodeName (Opcode), AcpiFormatException (ResolveStatus))); goto Cleanup; } if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("[%s]: bad operand(s) %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "[%s]: bad operand(s) %s\n", AcpiPsGetOpcodeName (Opcode), AcpiFormatException(Status))); goto Cleanup; } /* Create a return object of type NUMBER for most opcodes */ switch (Opcode) { case AML_BIT_NOT_OP: case AML_FIND_SET_LEFT_BIT_OP: case AML_FIND_SET_RIGHT_BIT_OP: case AML_FROM_BCD_OP: case AML_TO_BCD_OP: case AML_COND_REF_OF_OP: RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!RetDesc) { Status = AE_NO_MEMORY; goto Cleanup; } break; } switch (Opcode) { /* DefNot := NotOp Operand Result */ case AML_BIT_NOT_OP: RetDesc->Integer.Value = ~ObjDesc->Integer.Value; break; /* DefFindSetLeftBit := FindSetLeftBitOp Operand Result */ case AML_FIND_SET_LEFT_BIT_OP: RetDesc->Integer.Value = ObjDesc->Integer.Value; /* * Acpi specification describes Integer type as a little * endian unsigned value, so this boundary condition is valid. */ for (ResVal = 0; RetDesc->Integer.Value && ResVal < ACPI_INTEGER_BIT_SIZE; ++ResVal) { RetDesc->Integer.Value >>= 1; } RetDesc->Integer.Value = ResVal; break; /* DefFindSetRightBit := FindSetRightBitOp Operand Result */ case AML_FIND_SET_RIGHT_BIT_OP: RetDesc->Integer.Value = ObjDesc->Integer.Value; /* * Acpi specification describes Integer type as a little * endian unsigned value, so this boundary condition is valid. */ for (ResVal = 0; RetDesc->Integer.Value && ResVal < ACPI_INTEGER_BIT_SIZE; ++ResVal) { RetDesc->Integer.Value <<= 1; } /* Since returns must be 1-based, subtract from 33 (65) */ RetDesc->Integer.Value = ResVal == 0 ? 0 : (ACPI_INTEGER_BIT_SIZE + 1) - ResVal; break; /* DefFromBDC := FromBCDOp BCDValue Result */ case AML_FROM_BCD_OP: /* * The 64-bit ACPI integer can hold 16 4-bit BCD integers */ RetDesc->Integer.Value = 0; for (i = 0; i < ACPI_MAX_BCD_DIGITS; i++) { /* Get one BCD digit */ Digit = (ACPI_INTEGER) ((ObjDesc->Integer.Value >> (i * 4)) & 0xF); /* Check the range of the digit */ if (Digit > 9) { - DEBUG_PRINTP (ACPI_ERROR, ("BCD digit too large: \n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "BCD digit too large: \n", Digit)); Status = AE_AML_NUMERIC_OVERFLOW; goto Cleanup; } if (Digit > 0) { /* Sum into the result with the appropriate power of 10 */ for (j = 0; j < i; j++) { Digit *= 10; } RetDesc->Integer.Value += Digit; } } break; /* DefToBDC := ToBCDOp Operand Result */ case AML_TO_BCD_OP: if (ObjDesc->Integer.Value > ACPI_MAX_BCD_VALUE) { - DEBUG_PRINTP (ACPI_ERROR, ("BCD overflow: %d\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "BCD overflow: %d\n", ObjDesc->Integer.Value)); Status = AE_AML_NUMERIC_OVERFLOW; goto Cleanup; } RetDesc->Integer.Value = 0; for (i = 0; i < ACPI_MAX_BCD_DIGITS; i++) { /* Divide by nth factor of 10 */ Digit = ObjDesc->Integer.Value; for (j = 0; j < i; j++) { - Digit /= 10; + Digit = ACPI_DIVIDE (Digit, 10); } /* Create the BCD digit */ if (Digit > 0) { RetDesc->Integer.Value += (ACPI_MODULO (Digit, 10) << (i * 4)); } } break; /* DefCondRefOf := CondRefOfOp SourceObject Result */ case AML_COND_REF_OF_OP: /* * This op is a little strange because the internal return value is * different than the return value stored in the result descriptor * (There are really two return values) */ if ((ACPI_NAMESPACE_NODE *) ObjDesc == AcpiGbl_RootNode) { /* * This means that the object does not exist in the namespace, * return FALSE */ RetDesc->Integer.Value = 0; /* * Must delete the result descriptor since there is no reference * being returned */ AcpiUtRemoveReference (ResDesc); goto Cleanup; } /* Get the object reference and store it */ Status = AcpiExGetObjectReference (ObjDesc, &RetDesc2, WalkState); if (ACPI_FAILURE (Status)) { goto Cleanup; } Status = AcpiExStore (RetDesc2, ResDesc, WalkState); /* The object exists in the namespace, return TRUE */ RetDesc->Integer.Value = ACPI_INTEGER_MAX; goto Cleanup; break; case AML_STORE_OP: /* * A store operand is typically a number, string, buffer or lvalue * TBD: [Unhandled] What about a store to a package? */ /* * Do the store, and be careful about deleting the source object, * since the object itself may have been stored. */ - Status = AcpiExStore (ObjDesc, ResDesc, WalkState); if (ACPI_FAILURE (Status)) { /* On failure, just delete the ObjDesc */ AcpiUtRemoveReference (ObjDesc); + return_ACPI_STATUS (Status); } - else - { - /* - * Normally, we would remove a reference on the ObjDesc parameter; - * But since it is being used as the internal return object - * (meaning we would normally increment it), the two cancel out, - * and we simply don't do anything. - */ - *ReturnDesc = ObjDesc; - } - - ObjDesc = NULL; + /* + * Normally, we would remove a reference on the ObjDesc parameter; + * But since it is being used as the internal return object + * (meaning we would normally increment it), the two cancel out, + * and we simply don't do anything. + */ + *ReturnDesc = ObjDesc; return_ACPI_STATUS (Status); - break; case AML_DEBUG_OP: /* Reference, returning an Reference */ - DEBUG_PRINTP (ACPI_ERROR, ("DebugOp should never get here!\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "DebugOp should never get here!\n")); return_ACPI_STATUS (AE_OK); break; /* * ACPI 2.0 Opcodes */ case AML_TO_DECSTRING_OP: - - DEBUG_PRINTP (ACPI_ERROR, ("%s is not implemented\n", - AcpiPsGetOpcodeName (Opcode))); - Status = AE_NOT_IMPLEMENTED; - goto Cleanup; + Status = AcpiExConvertToString (ObjDesc, &RetDesc, 10, ACPI_UINT32_MAX, WalkState); break; case AML_TO_HEXSTRING_OP: - Status = AcpiExConvertToString (ObjDesc, &RetDesc, ACPI_UINT32_MAX, WalkState); + Status = AcpiExConvertToString (ObjDesc, &RetDesc, 16, ACPI_UINT32_MAX, WalkState); break; case AML_TO_BUFFER_OP: Status = AcpiExConvertToBuffer (ObjDesc, &RetDesc, WalkState); break; case AML_TO_INTEGER_OP: Status = AcpiExConvertToInteger (ObjDesc, &RetDesc, WalkState); break; /* * These are obsolete opcodes */ /* DefShiftLeftBit := ShiftLeftBitOp Source BitNum */ /* DefShiftRightBit := ShiftRightBitOp Source BitNum */ case AML_SHIFT_LEFT_BIT_OP: case AML_SHIFT_RIGHT_BIT_OP: - DEBUG_PRINTP (ACPI_ERROR, ("%s is unimplemented\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%s is unimplemented\n", AcpiPsGetOpcodeName (Opcode))); Status = AE_SUPPORT; goto Cleanup; break; default: REPORT_ERROR (("AcpiExMonadic2R: Unknown monadic opcode %X\n", Opcode)); Status = AE_AML_BAD_OPCODE; goto Cleanup; } Status = AcpiExStore (RetDesc, ResDesc, WalkState); Cleanup: /* Always delete the operand object */ AcpiUtRemoveReference (ObjDesc); /* Delete return object(s) on error */ if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ResDesc); /* Result descriptor */ if (RetDesc) { AcpiUtRemoveReference (RetDesc); RetDesc = NULL; } } /* Set the return object and exit */ *ReturnDesc = RetDesc; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExMonadic2 * * PARAMETERS: Opcode - The opcode to be executed * * RETURN: Status * * DESCRIPTION: Execute Type 2 monadic operator with numeric operand: * DerefOfOp, RefOfOp, SizeOfOp, TypeOp, IncrementOp, * DecrementOp, LNotOp, * ******************************************************************************/ ACPI_STATUS AcpiExMonadic2 ( UINT16 Opcode, ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *TmpDesc; ACPI_OPERAND_OBJECT *RetDesc = NULL; ACPI_STATUS ResolveStatus; ACPI_STATUS Status; UINT32 Type; ACPI_INTEGER Value; FUNCTION_TRACE_PTR ("ExMonadic2", WALK_OPERANDS); /* Attempt to resolve the operands */ ResolveStatus = AcpiExResolveOperands (Opcode, WALK_OPERANDS, WalkState); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, AcpiPsGetOpcodeName (Opcode), 1, "after AcpiExResolveOperands"); /* Always get all operands */ Status = AcpiDsObjStackPopObject (&ObjDesc, WalkState); /* Now we can check the status codes */ if (ACPI_FAILURE (ResolveStatus)) { - DEBUG_PRINTP (ACPI_ERROR, ("[%s]: Could not resolve operands, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "[%s]: Could not resolve operands, %s\n", AcpiPsGetOpcodeName (Opcode), AcpiFormatException (ResolveStatus))); goto Cleanup; } if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("[%s]: Bad operand(s), %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "[%s]: Bad operand(s), %s\n", AcpiPsGetOpcodeName (Opcode), AcpiFormatException (Status))); goto Cleanup; } /* Get the operand and decode the opcode */ switch (Opcode) { /* DefLNot := LNotOp Operand */ case AML_LNOT_OP: RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!RetDesc) { Status = AE_NO_MEMORY; goto Cleanup; } RetDesc->Integer.Value = !ObjDesc->Integer.Value; break; /* DefDecrement := DecrementOp Target */ /* DefIncrement := IncrementOp Target */ case AML_DECREMENT_OP: case AML_INCREMENT_OP: /* * Since we are expecting an Reference on the top of the stack, it * can be either an Node or an internal object. * * TBD: [Future] This may be the prototype code for all cases where * an Reference is expected!! 10/99 */ if (VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_NAMED)) { RetDesc = ObjDesc; } else { /* * Duplicate the Reference in a new object so that we can resolve it * without destroying the original Reference object */ RetDesc = AcpiUtCreateInternalObject (INTERNAL_TYPE_REFERENCE); if (!RetDesc) { Status = AE_NO_MEMORY; goto Cleanup; } RetDesc->Reference.Opcode = ObjDesc->Reference.Opcode; RetDesc->Reference.Offset = ObjDesc->Reference.Offset; RetDesc->Reference.Object = ObjDesc->Reference.Object; } /* * Convert the RetDesc Reference to a Number * (This deletes the original RetDesc) */ Status = AcpiExResolveOperands (AML_LNOT_OP, &RetDesc, WalkState); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("%s: bad operand(s) %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%s: bad operand(s) %s\n", AcpiPsGetOpcodeName (Opcode), AcpiFormatException(Status))); goto Cleanup; } /* Do the actual increment or decrement */ if (AML_INCREMENT_OP == Opcode) { RetDesc->Integer.Value++; } else { RetDesc->Integer.Value--; } /* Store the result back in the original descriptor */ Status = AcpiExStore (RetDesc, ObjDesc, WalkState); /* Objdesc was just deleted (because it is an Reference) */ ObjDesc = NULL; break; /* DefObjectType := ObjectTypeOp SourceObject */ case AML_TYPE_OP: if (INTERNAL_TYPE_REFERENCE == ObjDesc->Common.Type) { /* * Not a Name -- an indirect name pointer would have * been converted to a direct name pointer in ResolveOperands */ switch (ObjDesc->Reference.Opcode) { case AML_ZERO_OP: case AML_ONE_OP: case AML_ONES_OP: /* Constants are of type Number */ Type = ACPI_TYPE_INTEGER; break; case AML_DEBUG_OP: /* Per 1.0b spec, Debug object is of type DebugObject */ Type = ACPI_TYPE_DEBUG_OBJECT; break; case AML_INDEX_OP: /* Get the type of this reference (index into another object) */ Type = ObjDesc->Reference.TargetType; if (Type == ACPI_TYPE_PACKAGE) { /* * The main object is a package, we want to get the type * of the individual package element that is referenced by * the index. */ Type = (*(ObjDesc->Reference.Where))->Common.Type; } break; case AML_LOCAL_OP: case AML_ARG_OP: Type = AcpiDsMethodDataGetType (ObjDesc->Reference.Opcode, ObjDesc->Reference.Offset, WalkState); break; default: REPORT_ERROR (("AcpiExMonadic2/TypeOp: Internal error - Unknown Reference subtype %X\n", ObjDesc->Reference.Opcode)); Status = AE_AML_INTERNAL; goto Cleanup; } } else { /* * It's not a Reference, so it must be a direct name pointer. */ Type = AcpiNsGetType ((ACPI_NAMESPACE_NODE *) ObjDesc); /* Convert internal types to external types */ switch (Type) { case INTERNAL_TYPE_REGION_FIELD: case INTERNAL_TYPE_BANK_FIELD: case INTERNAL_TYPE_INDEX_FIELD: Type = ACPI_TYPE_FIELD_UNIT; } } /* Allocate a descriptor to hold the type. */ RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!RetDesc) { Status = AE_NO_MEMORY; goto Cleanup; } RetDesc->Integer.Value = Type; break; /* DefSizeOf := SizeOfOp SourceObject */ case AML_SIZE_OF_OP: if (VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_NAMED)) { ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) ObjDesc); } if (!ObjDesc) { Value = 0; } else { switch (ObjDesc->Common.Type) { case ACPI_TYPE_BUFFER: Value = ObjDesc->Buffer.Length; break; case ACPI_TYPE_STRING: Value = ObjDesc->String.Length; break; case ACPI_TYPE_PACKAGE: Value = ObjDesc->Package.Count; break; case INTERNAL_TYPE_REFERENCE: Value = 4; break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Not Buf/Str/Pkg - found type %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Not Buf/Str/Pkg - found type %X\n", ObjDesc->Common.Type)); Status = AE_AML_OPERAND_TYPE; goto Cleanup; } } /* * Now that we have the size of the object, create a result * object to hold the value */ RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!RetDesc) { Status = AE_NO_MEMORY; goto Cleanup; } RetDesc->Integer.Value = Value; break; /* DefRefOf := RefOfOp SourceObject */ case AML_REF_OF_OP: Status = AcpiExGetObjectReference (ObjDesc, &RetDesc, WalkState); if (ACPI_FAILURE (Status)) { goto Cleanup; } break; /* DefDerefOf := DerefOfOp ObjReference */ case AML_DEREF_OF_OP: /* Check for a method local or argument */ if (!VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_NAMED)) { /* * Must resolve/dereference the local/arg reference first */ switch (ObjDesc->Reference.Opcode) { /* Set ObjDesc to the value of the local/arg */ case AML_LOCAL_OP: case AML_ARG_OP: AcpiDsMethodDataGetValue (ObjDesc->Reference.Opcode, ObjDesc->Reference.Offset, WalkState, &TmpDesc); /* * Delete our reference to the input object and * point to the object just retrieved */ AcpiUtRemoveReference (ObjDesc); ObjDesc = TmpDesc; break; default: /* Index op - handled below */ break; } } /* ObjDesc may have changed from the code above */ if (VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_NAMED)) { /* Get the actual object from the Node (This is the dereference) */ RetDesc = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Object; /* Returning a pointer to the object, add another reference! */ AcpiUtAddReference (RetDesc); } else { /* * This must be a reference object produced by the Index * ASL operation -- check internal opcode */ if ((ObjDesc->Reference.Opcode != AML_INDEX_OP) && (ObjDesc->Reference.Opcode != AML_REF_OF_OP)) { - DEBUG_PRINTP (ACPI_ERROR, ("Unknown opcode in ref(%p) - %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown opcode in ref(%p) - %X\n", ObjDesc, ObjDesc->Reference.Opcode)); Status = AE_TYPE; goto Cleanup; } switch (ObjDesc->Reference.Opcode) { case AML_INDEX_OP: /* * Supported target types for the Index operator are * 1) A Buffer * 2) A Package */ if (ObjDesc->Reference.TargetType == ACPI_TYPE_BUFFER_FIELD) { /* * The target is a buffer, we must create a new object that * contains one element of the buffer, the element pointed * to by the index. * * NOTE: index into a buffer is NOT a pointer to a * sub-buffer of the main buffer, it is only a pointer to a * single element (byte) of the buffer! */ RetDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!RetDesc) { Status = AE_NO_MEMORY; goto Cleanup; } TmpDesc = ObjDesc->Reference.Object; RetDesc->Integer.Value = TmpDesc->Buffer.Pointer[ObjDesc->Reference.Offset]; /* TBD: [Investigate] (see below) Don't add an additional * ref! */ } else if (ObjDesc->Reference.TargetType == ACPI_TYPE_PACKAGE) { /* * The target is a package, we want to return the referenced * element of the package. We must add another reference to * this object, however. */ RetDesc = *(ObjDesc->Reference.Where); if (!RetDesc) { /* * We can't return a NULL dereferenced value. This is * an uninitialized package element and is thus a * severe error. */ - DEBUG_PRINTP (ACPI_ERROR, ("NULL package element obj %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "NULL package element obj %p\n", ObjDesc)); Status = AE_AML_UNINITIALIZED_ELEMENT; goto Cleanup; } AcpiUtAddReference (RetDesc); } else { - DEBUG_PRINTP (ACPI_ERROR, ("Unknown TargetType %X in obj %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown TargetType %X in obj %p\n", ObjDesc->Reference.TargetType, ObjDesc)); Status = AE_AML_OPERAND_TYPE; goto Cleanup; } break; case AML_REF_OF_OP: RetDesc = ObjDesc->Reference.Object; /* Add another reference to the object! */ AcpiUtAddReference (RetDesc); break; } } break; default: REPORT_ERROR (("AcpiExMonadic2: Unknown monadic opcode %X\n", Opcode)); Status = AE_AML_BAD_OPCODE; goto Cleanup; } Cleanup: if (ObjDesc) { AcpiUtRemoveReference (ObjDesc); } /* Delete return object on error */ if (ACPI_FAILURE (Status) && (RetDesc)) { AcpiUtRemoveReference (RetDesc); RetDesc = NULL; } *ReturnDesc = RetDesc; return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exnames.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exnames.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exnames.c (revision 82367) @@ -1,543 +1,543 @@ /****************************************************************************** * * Module Name: exnames - interpreter/scanner name load/execute - * $Revision: 80 $ + * $Revision: 81 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXNAMES_C__ #include "acpi.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exnames") /* AML Package Length encodings */ #define ACPI_AML_PACKAGE_TYPE1 0x40 #define ACPI_AML_PACKAGE_TYPE2 0x4000 #define ACPI_AML_PACKAGE_TYPE3 0x400000 #define ACPI_AML_PACKAGE_TYPE4 0x40000000 /******************************************************************************* * * FUNCTION: AcpiExAllocateNameString * * PARAMETERS: PrefixCount - Count of parent levels. Special cases: * (-1) = root, 0 = none * NumNameSegs - count of 4-character name segments * * RETURN: A pointer to the allocated string segment. This segment must * be deleted by the caller. * * DESCRIPTION: Allocate a buffer for a name string. Ensure allocated name * string is long enough, and set up prefix if any. * ******************************************************************************/ NATIVE_CHAR * AcpiExAllocateNameString ( UINT32 PrefixCount, UINT32 NumNameSegs) { NATIVE_CHAR *TempPtr; NATIVE_CHAR *NameString; UINT32 SizeNeeded; FUNCTION_TRACE ("ExAllocateNameString"); /* * Allow room for all \ and ^ prefixes, all segments, and a MultiNamePrefix. * Also, one byte for the null terminator. * This may actually be somewhat longer than needed. */ if (PrefixCount == (UINT32) -1) { /* Special case for root */ SizeNeeded = 1 + (ACPI_NAME_SIZE * NumNameSegs) + 2 + 1; } else { SizeNeeded = PrefixCount + (ACPI_NAME_SIZE * NumNameSegs) + 2 + 1; } /* * Allocate a buffer for the name. * This buffer must be deleted by the caller! */ NameString = ACPI_MEM_ALLOCATE (SizeNeeded); if (!NameString) { REPORT_ERROR (("ExAllocateNameString: name allocation failure\n")); return_PTR (NULL); } TempPtr = NameString; /* Set up Root or Parent prefixes if needed */ if (PrefixCount == (UINT32) -1) { *TempPtr++ = AML_ROOT_PREFIX; } else { while (PrefixCount--) { *TempPtr++ = AML_PARENT_PREFIX; } } /* Set up Dual or Multi prefixes if needed */ if (NumNameSegs > 2) { /* Set up multi prefixes */ *TempPtr++ = AML_MULTI_NAME_PREFIX_OP; *TempPtr++ = (char) NumNameSegs; } else if (2 == NumNameSegs) { /* Set up dual prefixes */ *TempPtr++ = AML_DUAL_NAME_PREFIX; } /* * Terminate string following prefixes. AcpiExNameSegment() will * append the segment(s) */ *TempPtr = 0; return_PTR (NameString); } /******************************************************************************* * * FUNCTION: AcpiExNameSegment * * PARAMETERS: InterpreterMode - Current running mode (load1/Load2/Exec) * * RETURN: Status * * DESCRIPTION: Execute a name segment (4 bytes) * ******************************************************************************/ ACPI_STATUS AcpiExNameSegment ( UINT8 **InAmlAddress, NATIVE_CHAR *NameString) { UINT8 *AmlAddress = *InAmlAddress; ACPI_STATUS Status = AE_OK; UINT32 Index; NATIVE_CHAR CharBuf[5]; FUNCTION_TRACE ("ExNameSegment"); /* * If first character is a digit, then we know that we aren't looking at a * valid name segment */ CharBuf[0] = *AmlAddress; if ('0' <= CharBuf[0] && CharBuf[0] <= '9') { - DEBUG_PRINTP (ACPI_ERROR, ("leading digit: %c\n", CharBuf[0])); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "leading digit: %c\n", CharBuf[0])); return_ACPI_STATUS (AE_CTRL_PENDING); } - DEBUG_PRINTP (TRACE_LOAD, ("Bytes from stream:\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "Bytes from stream:\n")); for (Index = 4; (Index > 0) && (AcpiUtValidAcpiCharacter (*AmlAddress)); --Index) { CharBuf[4 - Index] = *AmlAddress++; - DEBUG_PRINT (TRACE_LOAD, ("%c\n", CharBuf[4 - Index])); + ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "%c\n", CharBuf[4 - Index])); } /* Valid name segment */ if (0 == Index) { /* Found 4 valid characters */ CharBuf[4] = '\0'; if (NameString) { STRCAT (NameString, CharBuf); - DEBUG_PRINTP (TRACE_NAMES, - ("Appended to - %s \n", NameString)); + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, + "Appended to - %s \n", NameString)); } else { - DEBUG_PRINTP (TRACE_NAMES, - ("No Name string - %s \n", CharBuf)); + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, + "No Name string - %s \n", CharBuf)); } } else if (4 == Index) { /* * First character was not a valid name character, * so we are looking at something other than a name. */ - DEBUG_PRINTP (ACPI_INFO, - ("Leading character is not alpha: %02Xh (not a name)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Leading character is not alpha: %02Xh (not a name)\n", CharBuf[0])); Status = AE_CTRL_PENDING; } else { /* Segment started with one or more valid characters, but fewer than 4 */ Status = AE_AML_BAD_NAME; - DEBUG_PRINTP (ACPI_ERROR, ("Bad character %02x in name, at %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Bad character %02x in name, at %p\n", *AmlAddress, AmlAddress)); } *InAmlAddress = AmlAddress; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExGetNameString * * PARAMETERS: DataType - Data type to be associated with this name * * RETURN: Status * * DESCRIPTION: Get a name, including any prefixes. * ******************************************************************************/ ACPI_STATUS AcpiExGetNameString ( ACPI_OBJECT_TYPE8 DataType, UINT8 *InAmlAddress, NATIVE_CHAR **OutNameString, UINT32 *OutNameLength) { ACPI_STATUS Status = AE_OK; UINT8 *AmlAddress = InAmlAddress; NATIVE_CHAR *NameString = NULL; UINT32 NumSegments; UINT32 PrefixCount = 0; UINT8 Prefix = 0; BOOLEAN HasPrefix = FALSE; FUNCTION_TRACE_PTR ("ExGetNameString", AmlAddress); if (INTERNAL_TYPE_REGION_FIELD == DataType || INTERNAL_TYPE_BANK_FIELD == DataType || INTERNAL_TYPE_INDEX_FIELD == DataType) { /* Disallow prefixes for types associated with FieldUnit names */ NameString = AcpiExAllocateNameString (0, 1); if (!NameString) { Status = AE_NO_MEMORY; } else { Status = AcpiExNameSegment (&AmlAddress, NameString); } } else { /* * DataType is not a field name. * Examine first character of name for root or parent prefix operators */ switch (*AmlAddress) { case AML_ROOT_PREFIX: Prefix = *AmlAddress++; - DEBUG_PRINT (TRACE_LOAD, ("RootPrefix: %x\n", Prefix)); + ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "RootPrefix: %x\n", Prefix)); /* * Remember that we have a RootPrefix -- * see comment in AcpiExAllocateNameString() */ PrefixCount = (UINT32) -1; HasPrefix = TRUE; break; case AML_PARENT_PREFIX: /* Increment past possibly multiple parent prefixes */ do { Prefix = *AmlAddress++; - DEBUG_PRINT (TRACE_LOAD, ("ParentPrefix: %x\n", Prefix)); + ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "ParentPrefix: %x\n", Prefix)); ++PrefixCount; } while (*AmlAddress == AML_PARENT_PREFIX); HasPrefix = TRUE; break; default: break; } /* Examine first character of name for name segment prefix operator */ switch (*AmlAddress) { case AML_DUAL_NAME_PREFIX: Prefix = *AmlAddress++; - DEBUG_PRINT (TRACE_LOAD, ("DualNamePrefix: %x\n", Prefix)); + ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "DualNamePrefix: %x\n", Prefix)); NameString = AcpiExAllocateNameString (PrefixCount, 2); if (!NameString) { Status = AE_NO_MEMORY; break; } /* Indicate that we processed a prefix */ HasPrefix = TRUE; Status = AcpiExNameSegment (&AmlAddress, NameString); if (ACPI_SUCCESS (Status)) { Status = AcpiExNameSegment (&AmlAddress, NameString); } break; case AML_MULTI_NAME_PREFIX_OP: Prefix = *AmlAddress++; - DEBUG_PRINT (TRACE_LOAD, ("MultiNamePrefix: %x\n", Prefix)); + ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "MultiNamePrefix: %x\n", Prefix)); /* Fetch count of segments remaining in name path */ NumSegments = *AmlAddress++; NameString = AcpiExAllocateNameString (PrefixCount, NumSegments); if (!NameString) { Status = AE_NO_MEMORY; break; } /* Indicate that we processed a prefix */ HasPrefix = TRUE; while (NumSegments && (Status = AcpiExNameSegment (&AmlAddress, NameString)) == AE_OK) { --NumSegments; } break; case 0: /* NullName valid as of 8-12-98 ASL/AML Grammar Update */ if (-1 == PrefixCount) { - DEBUG_PRINTP (TRACE_EXEC, ("NameSeg is \"\\\" followed by NULL\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "NameSeg is \"\\\" followed by NULL\n")); } /* Consume the NULL byte */ AmlAddress++; NameString = AcpiExAllocateNameString (PrefixCount, 0); if (!NameString) { Status = AE_NO_MEMORY; break; } break; default: /* Name segment string */ NameString = AcpiExAllocateNameString (PrefixCount, 1); if (!NameString) { Status = AE_NO_MEMORY; break; } Status = AcpiExNameSegment (&AmlAddress, NameString); break; } /* Switch (PeekOp ()) */ } if (AE_CTRL_PENDING == Status && HasPrefix) { /* Ran out of segments after processing a prefix */ REPORT_ERROR ( ("ExDoName: Malformed Name at %p\n", NameString)); Status = AE_AML_BAD_NAME; } *OutNameString = NameString; *OutNameLength = (UINT32) (AmlAddress - InAmlAddress); return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exprep.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exprep.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exprep.c (revision 82367) @@ -1,641 +1,643 @@ /****************************************************************************** * * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities - * $Revision: 91 $ + * $Revision: 93 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXPREP_C__ #include "acpi.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #include "acparser.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exprep") /******************************************************************************* * * FUNCTION: AcpiExDecodeFieldAccessType * * PARAMETERS: Access - Encoded field access bits * Length - Field length. * - * RETURN: Field granularity (8, 16, or 32) + * RETURN: Field granularity (8, 16, 32 or 64) * * DESCRIPTION: Decode the AccessType bits of a field definition. * ******************************************************************************/ static UINT32 AcpiExDecodeFieldAccessType ( UINT32 Access, UINT16 Length, UINT32 *Alignment) { + PROC_NAME ("AcpiExDecodeFieldAccessType"); + switch (Access) { case ACCESS_ANY_ACC: *Alignment = 8; /* Use the length to set the access type */ if (Length <= 8) { return (8); } else if (Length <= 16) { return (16); } else if (Length <= 32) { return (32); } else if (Length <= 64) { return (64); } /* Default is 8 (byte) */ return (8); break; case ACCESS_BYTE_ACC: *Alignment = 8; return (8); break; case ACCESS_WORD_ACC: *Alignment = 16; return (16); break; case ACCESS_DWORD_ACC: *Alignment = 32; return (32); break; case ACCESS_QWORD_ACC: /* ACPI 2.0 */ *Alignment = 64; return (64); break; default: /* Invalid field access type */ - DEBUG_PRINT (ACPI_ERROR, - ("ExDecodeFieldAccessType: Unknown field access type %x\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Unknown field access type %x\n", Access)); return (0); } } /******************************************************************************* * * FUNCTION: AcpiExPrepCommonFieldObject * * PARAMETERS: ObjDesc - The field object * FieldFlags - Access, LockRule, and UpdateRule. * The format of a FieldFlag is described * in the ACPI specification * FieldBitPosition - Field start position * FieldBitLength - Field length in number of bits * * RETURN: Status * * DESCRIPTION: Initialize the areas of the field object that are common * to the various types of fields. * ******************************************************************************/ ACPI_STATUS AcpiExPrepCommonFieldObject ( ACPI_OPERAND_OBJECT *ObjDesc, UINT8 FieldFlags, UINT32 FieldBitPosition, UINT32 FieldBitLength) { UINT32 AccessBitWidth; UINT32 Alignment; UINT32 NearestByteAddress; FUNCTION_TRACE ("ExPrepCommonFieldObject"); /* * Note: the structure being initialized is the * ACPI_COMMON_FIELD_INFO; No structure fields outside of the common area * are initialized by this procedure. */ /* Demultiplex the FieldFlags byte */ ObjDesc->CommonField.LockRule = (UINT8) ((FieldFlags & LOCK_RULE_MASK) >> LOCK_RULE_SHIFT); ObjDesc->CommonField.UpdateRule = (UINT8) ((FieldFlags & UPDATE_RULE_MASK) >> UPDATE_RULE_SHIFT); /* Other misc fields */ ObjDesc->CommonField.BitLength = (UINT16) FieldBitLength; /* * Decode the access type so we can compute offsets. The access type gives * two pieces of information - the width of each field access and the * necessary alignment of the access. For AnyAcc, the width used is the * largest necessary/possible in an attempt to access the whole field in one * I/O operation. However, for AnyAcc, the alignment is 8. For all other * access types (Byte, Word, Dword, Qword), the width is the same as the * alignment. */ AccessBitWidth = AcpiExDecodeFieldAccessType ( ((FieldFlags & ACCESS_TYPE_MASK) >> ACCESS_TYPE_SHIFT), ObjDesc->Field.BitLength, &Alignment); if (!AccessBitWidth) { return_ACPI_STATUS (AE_AML_OPERAND_VALUE); } /* Setup width (access granularity) fields */ ObjDesc->CommonField.AccessBitWidth = (UINT8) AccessBitWidth; /* 8, 16, 32, 64 */ ObjDesc->CommonField.AccessByteWidth = (UINT8) DIV_8 (AccessBitWidth); /* 1, 2, 4, 8 */ if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD) { /* * BufferField access can be on any byte boundary, so the * alignment is always 8 (regardless of any alignment implied by the * field access type.) */ Alignment = 8; } /* * BaseByteOffset is the address of the start of the field within the region. It is * the byte address of the first *datum* (field-width data unit) of the field. * (i.e., the first datum that contains at least the first *bit* of the field.) */ NearestByteAddress = ROUND_BITS_DOWN_TO_BYTES (FieldBitPosition); ObjDesc->CommonField.BaseByteOffset = ROUND_DOWN (NearestByteAddress, DIV_8 (Alignment)); /* * StartFieldBitOffset is the offset of the first bit of the field within a field datum. * This is calculated as the number of bits from the BaseByteOffset. In other words, * the start of the field is relative to a byte address, regardless of the access type * of the field. */ ObjDesc->CommonField.StartFieldBitOffset = (UINT8) (MOD_8 (FieldBitPosition)); /* * DatumValidBits is the number of valid field bits in the first field datum. */ ObjDesc->CommonField.DatumValidBits = (UINT8) (AccessBitWidth - ObjDesc->CommonField.StartFieldBitOffset); /* * Valid bits -- the number of bits that compose a partial datum, * 1) At the end of the field within the region (arbitrary starting bit offset) * 2) At the end of a buffer used to contain the field (starting offset always zero) */ ObjDesc->CommonField.EndFieldValidBits = (UINT8) ((ObjDesc->CommonField.StartFieldBitOffset + FieldBitLength) % AccessBitWidth); ObjDesc->CommonField.EndBufferValidBits = (UINT8) (FieldBitLength % AccessBitWidth); /* StartBufferBitOffset always = 0 */ /* * Does the entire field fit within a single field access element * (datum)? (without crossing a datum boundary) */ if ((ObjDesc->CommonField.StartFieldBitOffset + ObjDesc->CommonField.BitLength) <= (UINT16) ObjDesc->CommonField.AccessBitWidth) { ObjDesc->CommonField.AccessFlags |= AFIELD_SINGLE_DATUM; } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExPrepRegionFieldValue * * PARAMETERS: Node - Owning Node * RegionNode - Region in which field is being defined * FieldFlags - Access, LockRule, and UpdateRule. * FieldBitPosition - Field start position * FieldBitLength - Field length in number of bits * * RETURN: Status * * DESCRIPTION: Construct an ACPI_OPERAND_OBJECT of type DefField and * connect it to the parent Node. * ******************************************************************************/ ACPI_STATUS AcpiExPrepRegionFieldValue ( ACPI_NAMESPACE_NODE *Node, ACPI_HANDLE RegionNode, UINT8 FieldFlags, UINT32 FieldBitPosition, UINT32 FieldBitLength) { ACPI_OPERAND_OBJECT *ObjDesc; UINT32 Type; ACPI_STATUS Status; FUNCTION_TRACE ("ExPrepRegionFieldValue"); /* Parameter validation */ if (!RegionNode) { - DEBUG_PRINTP (ACPI_ERROR, ("Null RegionNode\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null RegionNode\n")); return_ACPI_STATUS (AE_AML_NO_OPERAND); } Type = AcpiNsGetType (RegionNode); if (Type != ACPI_TYPE_REGION) { - DEBUG_PRINTP (ACPI_ERROR, ("Needed Region, found type %X %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Needed Region, found type %X %s\n", Type, AcpiUtGetTypeName (Type))); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* Allocate a new object */ ObjDesc = AcpiUtCreateInternalObject (INTERNAL_TYPE_REGION_FIELD); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } /* ObjDesc and Region valid */ DUMP_OPERANDS ((ACPI_OPERAND_OBJECT **) &Node, IMODE_EXECUTE, "ExPrepRegionFieldValue", 1, "case RegionField"); DUMP_OPERANDS ((ACPI_OPERAND_OBJECT **) &RegionNode, IMODE_EXECUTE, "ExPrepRegionFieldValue", 1, "case RegionField"); /* Initialize areas of the object that are common to all fields */ Status = AcpiExPrepCommonFieldObject (ObjDesc, FieldFlags, FieldBitPosition, FieldBitLength); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Initialize areas of the object that are specific to this field type */ ObjDesc->Field.RegionObj = AcpiNsGetAttachedObject (RegionNode); /* An additional reference for the container */ AcpiUtAddReference (ObjDesc->Field.RegionObj); /* Debug info */ - DEBUG_PRINTP (ACPI_INFO, ("Bitoff=%X Off=%X Gran=%X Region %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Bitoff=%X Off=%X Gran=%X Region %p\n", ObjDesc->Field.StartFieldBitOffset, ObjDesc->Field.BaseByteOffset, ObjDesc->Field.AccessBitWidth, ObjDesc->Field.RegionObj)); - DEBUG_PRINTP (ACPI_INFO, ("set NamedObj %p (%4.4s) val = %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "set NamedObj %p (%4.4s) val = %p\n", Node, &(Node->Name), ObjDesc)); /* * Store the constructed descriptor (ObjDesc) into the parent Node, * preserving the current type of that NamedObj. */ Status = AcpiNsAttachObject (Node, ObjDesc, (UINT8) AcpiNsGetType (Node)); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExPrepBankFieldValue * * PARAMETERS: Node - Owning Node * RegionNode - Region in which field is being defined * BankRegisterNode - Bank selection register node * BankVal - Value to store in selection register * FieldFlags - Access, LockRule, and UpdateRule * FieldBitPosition - Field start position * FieldBitLength - Field length in number of bits * * RETURN: Status * * DESCRIPTION: Construct an object of type BankField and attach it to the * parent Node. * ******************************************************************************/ ACPI_STATUS AcpiExPrepBankFieldValue ( ACPI_NAMESPACE_NODE *Node, ACPI_NAMESPACE_NODE *RegionNode, ACPI_NAMESPACE_NODE *BankRegisterNode, UINT32 BankVal, UINT8 FieldFlags, UINT32 FieldBitPosition, UINT32 FieldBitLength) { ACPI_OPERAND_OBJECT *ObjDesc; UINT32 Type; ACPI_STATUS Status; FUNCTION_TRACE ("ExPrepBankFieldValue"); /* Parameter validation */ if (!RegionNode) { - DEBUG_PRINTP (ACPI_ERROR, ("Null RegionNode\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null RegionNode\n")); return_ACPI_STATUS (AE_AML_NO_OPERAND); } Type = AcpiNsGetType (RegionNode); if (Type != ACPI_TYPE_REGION) { - DEBUG_PRINTP (ACPI_ERROR, ("Needed Region, found type %X %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Needed Region, found type %X %s\n", Type, AcpiUtGetTypeName (Type))); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* Allocate a new object */ ObjDesc = AcpiUtCreateInternalObject (INTERNAL_TYPE_BANK_FIELD); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } /* ObjDesc and Region valid */ DUMP_OPERANDS ((ACPI_OPERAND_OBJECT **) &Node, IMODE_EXECUTE, "ExPrepBankFieldValue", 1, "case BankField"); DUMP_OPERANDS ((ACPI_OPERAND_OBJECT **) &RegionNode, IMODE_EXECUTE, "ExPrepBankFieldValue", 1, "case BankField"); /* Initialize areas of the object that are common to all fields */ Status = AcpiExPrepCommonFieldObject (ObjDesc, FieldFlags, FieldBitPosition, FieldBitLength); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Initialize areas of the object that are specific to this field type */ ObjDesc->BankField.Value = BankVal; ObjDesc->BankField.RegionObj = AcpiNsGetAttachedObject (RegionNode); ObjDesc->BankField.BankRegisterObj = AcpiNsGetAttachedObject (BankRegisterNode); /* An additional reference for the attached objects */ AcpiUtAddReference (ObjDesc->BankField.RegionObj); AcpiUtAddReference (ObjDesc->BankField.BankRegisterObj); /* Debug info */ - DEBUG_PRINTP (ACPI_INFO, ("BitOff=%X Off=%X Gran=%X Region %p BankReg %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "BitOff=%X Off=%X Gran=%X Region %p BankReg %p\n", ObjDesc->BankField.StartFieldBitOffset, ObjDesc->BankField.BaseByteOffset, ObjDesc->Field.AccessBitWidth, ObjDesc->BankField.RegionObj, ObjDesc->BankField.BankRegisterObj)); - DEBUG_PRINTP (ACPI_INFO, ("Set NamedObj %p (%4.4s) val=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Set NamedObj %p (%4.4s) val=%p\n", Node, &(Node->Name), ObjDesc)); /* * Store the constructed descriptor (ObjDesc) into the parent Node, * preserving the current type of that NamedObj. */ Status = AcpiNsAttachObject (Node, ObjDesc, (UINT8) AcpiNsGetType (Node)); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExPrepIndexFieldValue * * PARAMETERS: Node - Owning Node * IndexReg - Index register * DataReg - Data register * FieldFlags - Access, LockRule, and UpdateRule * FieldBitPosition - Field start position * FieldBitLength - Field length in number of bits * * RETURN: Status * * DESCRIPTION: Construct an ACPI_OPERAND_OBJECT of type IndexField and * connect it to the parent Node. * ******************************************************************************/ ACPI_STATUS AcpiExPrepIndexFieldValue ( ACPI_NAMESPACE_NODE *Node, ACPI_NAMESPACE_NODE *IndexReg, ACPI_NAMESPACE_NODE *DataReg, UINT8 FieldFlags, UINT32 FieldBitPosition, UINT32 FieldBitLength) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_STATUS Status; FUNCTION_TRACE ("ExPrepIndexFieldValue"); /* Parameter validation */ if (!IndexReg || !DataReg) { - DEBUG_PRINTP (ACPI_ERROR, ("Null handle\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null handle\n")); return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* Allocate a new object descriptor */ ObjDesc = AcpiUtCreateInternalObject (INTERNAL_TYPE_INDEX_FIELD); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Initialize areas of the object that are common to all fields */ Status = AcpiExPrepCommonFieldObject (ObjDesc, FieldFlags, FieldBitPosition, FieldBitLength); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Initialize areas of the object that are specific to this field type */ ObjDesc->IndexField.DataObj = AcpiNsGetAttachedObject (DataReg); ObjDesc->IndexField.IndexObj = AcpiNsGetAttachedObject (IndexReg); ObjDesc->IndexField.Value = (UINT32) (FieldBitPosition / ObjDesc->Field.AccessBitWidth); /* An additional reference for the attached objects */ AcpiUtAddReference (ObjDesc->IndexField.DataObj); AcpiUtAddReference (ObjDesc->IndexField.IndexObj); /* Debug info */ - DEBUG_PRINTP (ACPI_INFO, ("bitoff=%X off=%X gran=%X Index %p Data %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "bitoff=%X off=%X gran=%X Index %p Data %p\n", ObjDesc->IndexField.StartFieldBitOffset, ObjDesc->IndexField.BaseByteOffset, ObjDesc->Field.AccessBitWidth, ObjDesc->IndexField.IndexObj, ObjDesc->IndexField.DataObj)); - DEBUG_PRINTP (ACPI_INFO, ("set NamedObj %p (%4.4s) val = %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "set NamedObj %p (%4.4s) val = %p\n", Node, &(Node->Name), ObjDesc)); /* * Store the constructed descriptor (ObjDesc) into the parent Node, * preserving the current type of that NamedObj. */ Status = AcpiNsAttachObject (Node, ObjDesc, (UINT8) AcpiNsGetType (Node)); return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exregion.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exregion.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exregion.c (revision 82367) @@ -1,445 +1,445 @@ /****************************************************************************** * * Module Name: exregion - ACPI default OpRegion (address space) handlers - * $Revision: 54 $ + * $Revision: 55 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXREGION_C__ #include "acpi.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #include "achware.h" #include "acevents.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exregion") /******************************************************************************* * * FUNCTION: AcpiExSystemMemorySpaceHandler * * PARAMETERS: Function - Read or Write operation * Address - Where in the space to read or write * BitWidth - Field width in bits (8, 16, or 32) * Value - Pointer to in or out value * HandlerContext - Pointer to Handler's context * RegionContext - Pointer to context specific to the * accessed region * * RETURN: Status * * DESCRIPTION: Handler for the System Memory address space (Op Region) * ******************************************************************************/ ACPI_STATUS AcpiExSystemMemorySpaceHandler ( UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT32 *Value, void *HandlerContext, void *RegionContext) { ACPI_STATUS Status = AE_OK; void *LogicalAddrPtr = NULL; ACPI_MEM_SPACE_CONTEXT *MemInfo = RegionContext; UINT32 Length; FUNCTION_TRACE ("ExSystemMemorySpaceHandler"); /* Validate and translate the bit width */ switch (BitWidth) { case 8: Length = 1; break; case 16: Length = 2; break; case 32: Length = 4; break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Invalid SystemMemory width %d\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Invalid SystemMemory width %d\n", BitWidth)); return_ACPI_STATUS (AE_AML_OPERAND_VALUE); break; } /* * Does the request fit into the cached memory mapping? * Is 1) Address below the current mapping? OR * 2) Address beyond the current mapping? */ if ((Address < MemInfo->MappedPhysicalAddress) || (((ACPI_INTEGER) Address + Length) > ((ACPI_INTEGER) MemInfo->MappedPhysicalAddress + MemInfo->MappedLength))) { /* * The request cannot be resolved by the current memory mapping; * Delete the existing mapping and create a new one. */ if (MemInfo->MappedLength) { /* Valid mapping, delete it */ AcpiOsUnmapMemory (MemInfo->MappedLogicalAddress, MemInfo->MappedLength); } MemInfo->MappedLength = 0; /* In case of failure below */ /* Create a new mapping starting at the address given */ Status = AcpiOsMapMemory (Address, SYSMEM_REGION_WINDOW_SIZE, (void **) &MemInfo->MappedLogicalAddress); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* TBD: should these pointers go to 64-bit in all cases ? */ MemInfo->MappedPhysicalAddress = Address; MemInfo->MappedLength = SYSMEM_REGION_WINDOW_SIZE; } /* * Generate a logical pointer corresponding to the address we want to * access */ /* TBD: should these pointers go to 64-bit in all cases ? */ LogicalAddrPtr = MemInfo->MappedLogicalAddress + ((ACPI_INTEGER) Address - (ACPI_INTEGER) MemInfo->MappedPhysicalAddress); - DEBUG_PRINT ((TRACE_OPREGION | VERBOSE_INFO), - ("IO %d (%d width) Address=%8.8lX%8.8lX\n", Function, BitWidth, - HIDWORD(Address), LODWORD(Address))); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "IO %d (%d width) Address=%8.8lX%8.8lX\n", Function, BitWidth, + HIDWORD (Address), LODWORD (Address))); /* Perform the memory read or write */ switch (Function) { case ACPI_READ_ADR_SPACE: switch (BitWidth) { case 8: *Value = (UINT32)* (UINT8 *) LogicalAddrPtr; break; case 16: MOVE_UNALIGNED16_TO_32 (Value, LogicalAddrPtr); break; case 32: MOVE_UNALIGNED32_TO_32 (Value, LogicalAddrPtr); break; } break; case ACPI_WRITE_ADR_SPACE: switch (BitWidth) { case 8: *(UINT8 *) LogicalAddrPtr = (UINT8) *Value; break; case 16: MOVE_UNALIGNED16_TO_16 (LogicalAddrPtr, Value); break; case 32: MOVE_UNALIGNED32_TO_32 (LogicalAddrPtr, Value); break; } break; default: Status = AE_BAD_PARAMETER; break; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExSystemIoSpaceHandler * * PARAMETERS: Function - Read or Write operation * Address - Where in the space to read or write * BitWidth - Field width in bits (8, 16, or 32) * Value - Pointer to in or out value * HandlerContext - Pointer to Handler's context * RegionContext - Pointer to context specific to the * accessed region * * RETURN: Status * * DESCRIPTION: Handler for the System IO address space (Op Region) * ******************************************************************************/ ACPI_STATUS AcpiExSystemIoSpaceHandler ( UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT32 *Value, void *HandlerContext, void *RegionContext) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("ExSystemIoSpaceHandler"); - DEBUG_PRINT ((TRACE_OPREGION | VERBOSE_INFO), - ("IO %d (%d width) Address=%8.8lX%8.8lX\n", Function, BitWidth, - HIDWORD(Address), LODWORD(Address))); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "IO %d (%d width) Address=%8.8lX%8.8lX\n", Function, BitWidth, + HIDWORD (Address), LODWORD (Address))); /* Decode the function parameter */ switch (Function) { case ACPI_READ_ADR_SPACE: *Value = 0; Status = AcpiOsReadPort ((ACPI_IO_ADDRESS) Address, Value, BitWidth); break; case ACPI_WRITE_ADR_SPACE: Status = AcpiOsWritePort ((ACPI_IO_ADDRESS) Address, *Value, BitWidth); break; default: Status = AE_BAD_PARAMETER; break; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExPciConfigSpaceHandler * * PARAMETERS: Function - Read or Write operation * Address - Where in the space to read or write * BitWidth - Field width in bits (8, 16, or 32) * Value - Pointer to in or out value * HandlerContext - Pointer to Handler's context * RegionContext - Pointer to context specific to the * accessed region * * RETURN: Status * * DESCRIPTION: Handler for the PCI Config address space (Op Region) * ******************************************************************************/ ACPI_STATUS AcpiExPciConfigSpaceHandler ( UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT32 *Value, void *HandlerContext, void *RegionContext) { ACPI_STATUS Status = AE_OK; ACPI_PCI_ID *PciId; UINT16 PciRegister; FUNCTION_TRACE ("ExPciConfigSpaceHandler"); /* * The arguments to AcpiOs(Read|Write)PciCfg(Byte|Word|Dword) are: * * PciSegment is the PCI bus segment range 0-31 * PciBus is the PCI bus number range 0-255 * PciDevice is the PCI device number range 0-31 * PciFunction is the PCI device function number * PciRegister is the Config space register range 0-255 bytes * * Value - input value for write, output address for read * */ PciId = (ACPI_PCI_ID *) RegionContext; PciRegister = (UINT16) Address; - DEBUG_PRINT ((TRACE_OPREGION | VERBOSE_INFO), - ("IO %d (%d) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "IO %d (%d) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n", Function, BitWidth, PciId->Segment, PciId->Bus, PciId->Device, PciId->Function, PciRegister)); switch (Function) { case ACPI_READ_ADR_SPACE: *Value = 0; Status = AcpiOsReadPciConfiguration (PciId, PciRegister, Value, BitWidth); break; case ACPI_WRITE_ADR_SPACE: Status = AcpiOsWritePciConfiguration (PciId, PciRegister, *Value, BitWidth); break; default: Status = AE_BAD_PARAMETER; break; } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exresnte.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exresnte.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exresnte.c (revision 82367) @@ -1,461 +1,384 @@ /****************************************************************************** * * Module Name: exresnte - AML Interpreter object resolution - * $Revision: 37 $ + * $Revision: 39 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXRESNTE_C__ #include "acpi.h" #include "amlcode.h" #include "acparser.h" #include "acdispat.h" #include "acinterp.h" #include "acnamesp.h" #include "actables.h" #include "acevents.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exresnte") /******************************************************************************* * * FUNCTION: AcpiExResolveNodeToValue * * PARAMETERS: StackPtr - Pointer to a location on a stack that contains * a pointer to a Node * WalkState - Current state * * RETURN: Status * * DESCRIPTION: Resolve a Namespace node (AKA a "direct name pointer") to * a valued object * * Note: for some of the data types, the pointer attached to the Node * can be either a pointer to an actual internal object or a pointer into the * AML stream itself. These types are currently: * * ACPI_TYPE_INTEGER * ACPI_TYPE_STRING * ACPI_TYPE_BUFFER * ACPI_TYPE_MUTEX * ACPI_TYPE_PACKAGE * ******************************************************************************/ ACPI_STATUS AcpiExResolveNodeToValue ( ACPI_NAMESPACE_NODE **StackPtr, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *ValDesc; ACPI_OPERAND_OBJECT *ObjDesc = NULL; ACPI_NAMESPACE_NODE *Node; - UINT8 *AmlPointer = NULL; ACPI_OBJECT_TYPE8 EntryType; ACPI_INTEGER TempVal; - BOOLEAN AttachedAmlPointer = FALSE; - UINT8 AmlOpcode = 0; FUNCTION_TRACE ("ExResolveNodeToValue"); /* * The stack pointer points to a ACPI_NAMESPACE_NODE (Node). Get the * object that is attached to the Node. */ - Node = *StackPtr; ValDesc = AcpiNsGetAttachedObject (Node); EntryType = AcpiNsGetType ((ACPI_HANDLE) Node); - DEBUG_PRINTP (TRACE_EXEC, ("Entry=%p ValDesc=%p Type=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Entry=%p ValDesc=%p Type=%X\n", Node, ValDesc, EntryType)); - /* - * The ValDesc attached to the Node can be either: - * 1) An internal ACPI object - * 2) A pointer into the AML stream (into one of the ACPI system tables) - */ - if (AcpiTbSystemTablePointer (ValDesc)) - { - /* CAN THIS EVERY HAPPEN NOW? TBD!!! */ - - AttachedAmlPointer = TRUE; - AmlOpcode = *((UINT8 *) ValDesc); - AmlPointer = ((UINT8 *) ValDesc) + 1; - - DEBUG_PRINTP (TRACE_EXEC, ("Unparsed AML: %p Len=%X\n", - AmlOpcode, AmlPointer)); - } - - /* - * Several EntryTypes do not require further processing, so - * we will return immediately + * Several object types require no further processing: + * 1) Devices rarely have an attached object, return the Node + * 2) Method locals and arguments have a pseudo-Node */ - /* Devices rarely have an attached object, return the Node - * and Method locals and arguments have a pseudo-Node - */ if (EntryType == ACPI_TYPE_DEVICE || (Node->Flags & (ANOBJ_METHOD_ARG | ANOBJ_METHOD_LOCAL))) { return_ACPI_STATUS (AE_OK); } if (!ValDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("No object attached to node %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No object attached to node %p\n", Node)); return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* * Action is based on the type of the Node, which indicates the type * of the attached object or pointer */ switch (EntryType) { case ACPI_TYPE_PACKAGE: - if (AttachedAmlPointer) - { - /* - * This means that the package initialization is not parsed - * -- should not happen - */ - DEBUG_PRINTP (ACPI_ERROR, ("Unparsed Packages not supported!\n")); - return_ACPI_STATUS (AE_NOT_IMPLEMENTED); - } - - /* ValDesc is an internal object in all cases by the time we get here */ - if (ACPI_TYPE_PACKAGE != ValDesc->Common.Type) { - DEBUG_PRINTP (ACPI_ERROR, ("Object not a package, type %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Object not a package, type %X\n", ValDesc->Common.Type)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* Return an additional reference to the object */ ObjDesc = ValDesc; AcpiUtAddReference (ObjDesc); break; case ACPI_TYPE_BUFFER: - if (AttachedAmlPointer) - { - /* - * This means that the buffer initialization is not parsed - * -- should not happen - */ - DEBUG_PRINTP (ACPI_ERROR, ("Unparsed Buffers not supported!\n")); - return_ACPI_STATUS (AE_NOT_IMPLEMENTED); - } - - /* ValDesc is an internal object in all cases by the time we get here */ - if (ACPI_TYPE_BUFFER != ValDesc->Common.Type) { - DEBUG_PRINTP (ACPI_ERROR, ("Object not a buffer, type %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Object not a buffer, type %X\n", ValDesc->Common.Type)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* Return an additional reference to the object */ ObjDesc = ValDesc; AcpiUtAddReference (ObjDesc); break; case ACPI_TYPE_STRING: - if (AttachedAmlPointer) + if (ACPI_TYPE_STRING != ValDesc->Common.Type) { - /* Allocate a new string object */ - - ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_STRING); - if (!ObjDesc) - { - return_ACPI_STATUS (AE_NO_MEMORY); - } - - /* Init the internal object */ - - ObjDesc->String.Pointer = (NATIVE_CHAR *) AmlPointer; - ObjDesc->String.Length = STRLEN (ObjDesc->String.Pointer); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Object not a string, type %X\n", + ValDesc->Common.Type)); + return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } - else - { - if (ACPI_TYPE_STRING != ValDesc->Common.Type) - { - DEBUG_PRINTP (ACPI_ERROR, ("Object not a string, type %X\n", - ValDesc->Common.Type)); - return_ACPI_STATUS (AE_AML_OPERAND_TYPE); - } + /* Return an additional reference to the object */ - /* Return an additional reference to the object */ - - ObjDesc = ValDesc; - AcpiUtAddReference (ObjDesc); - } - + ObjDesc = ValDesc; + AcpiUtAddReference (ObjDesc); break; case ACPI_TYPE_INTEGER: - DEBUG_PRINTP (TRACE_EXEC, ("case Integer \n")); - - /* - * The Node has an attached internal object, make sure that it's a - * number - */ - if (ACPI_TYPE_INTEGER != ValDesc->Common.Type) { - DEBUG_PRINTP (ACPI_ERROR, ("Object not a Number, type %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Object not a Number, type %X\n", ValDesc->Common.Type)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* Return an additional reference to the object */ ObjDesc = ValDesc; AcpiUtAddReference (ObjDesc); break; case ACPI_TYPE_BUFFER_FIELD: case INTERNAL_TYPE_REGION_FIELD: case INTERNAL_TYPE_BANK_FIELD: case INTERNAL_TYPE_INDEX_FIELD: - DEBUG_PRINTP (TRACE_EXEC, ("FieldRead Node=%p ValDesc=%p Type=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "FieldRead Node=%p ValDesc=%p Type=%X\n", Node, ValDesc, EntryType)); Status = AcpiExReadDataFromField (ValDesc, &ObjDesc); break; /* * For these objects, just return the object attached to the Node */ - case ACPI_TYPE_MUTEX: case ACPI_TYPE_METHOD: case ACPI_TYPE_POWER: case ACPI_TYPE_PROCESSOR: case ACPI_TYPE_THERMAL: case ACPI_TYPE_EVENT: case ACPI_TYPE_REGION: - /* Return an additional reference to the object */ ObjDesc = ValDesc; AcpiUtAddReference (ObjDesc); break; /* TYPE_Any is untyped, and thus there is no object associated with it */ case ACPI_TYPE_ANY: - DEBUG_PRINTP (ACPI_ERROR, ("Untyped entry %p, no attached object!\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Untyped entry %p, no attached object!\n", Node)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); /* Cannot be AE_TYPE */ break; /* * The only named references allowed are named constants * e.g. -- Name (\OSFL, Ones) */ case INTERNAL_TYPE_REFERENCE: switch (ValDesc->Reference.Opcode) { case AML_ZERO_OP: TempVal = 0; break; case AML_ONE_OP: TempVal = 1; break; case AML_ONES_OP: TempVal = ACPI_INTEGER_MAX; break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Unsupported reference opcode %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unsupported reference opcode %X\n", ValDesc->Reference.Opcode)); return_ACPI_STATUS (AE_AML_BAD_OPCODE); } /* Create object for result */ ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } ObjDesc->Integer.Value = TempVal; /* Truncate value if we are executing from a 32-bit ACPI table */ AcpiExTruncateFor32bitTable (ObjDesc, WalkState); break; /* Default case is for unknown types */ default: - DEBUG_PRINTP (ACPI_ERROR, ("Node %p - Unknown object type %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Node %p - Unknown object type %X\n", Node, EntryType)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* switch (EntryType) */ /* Put the object descriptor on the stack */ *StackPtr = (void *) ObjDesc; return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exresolv.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exresolv.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exresolv.c (revision 82367) @@ -1,549 +1,549 @@ /****************************************************************************** * * Module Name: exresolv - AML Interpreter object resolution - * $Revision: 95 $ + * $Revision: 96 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXRESOLV_C__ #include "acpi.h" #include "amlcode.h" #include "acparser.h" #include "acdispat.h" #include "acinterp.h" #include "acnamesp.h" #include "actables.h" #include "acevents.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exresolv") /******************************************************************************* * * FUNCTION: AcpiExGetBufferFieldValue * * PARAMETERS: *ObjDesc - Pointer to a BufferField * *ResultDesc - Pointer to an empty descriptor which will * become an Integer with the field's value * * RETURN: Status * * DESCRIPTION: Retrieve the value from a BufferField * ******************************************************************************/ ACPI_STATUS AcpiExGetBufferFieldValue ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT *ResultDesc) { ACPI_STATUS Status; UINT32 Mask; UINT8 *Location; FUNCTION_TRACE ("ExGetBufferFieldValue"); /* * Parameter validation */ if (!ObjDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("Internal - null field pointer\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - null field pointer\n")); return_ACPI_STATUS (AE_AML_NO_OPERAND); } if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)) { Status = AcpiDsGetBufferFieldArguments (ObjDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } if (!ObjDesc->BufferField.BufferObj) { - DEBUG_PRINTP (ACPI_ERROR, ("Internal - null container pointer\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - null container pointer\n")); return_ACPI_STATUS (AE_AML_INTERNAL); } if (ACPI_TYPE_BUFFER != ObjDesc->BufferField.BufferObj->Common.Type) { - DEBUG_PRINTP (ACPI_ERROR, ("Internal - container is not a Buffer\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - container is not a Buffer\n")); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } if (!ResultDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("Internal - null result pointer\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - null result pointer\n")); return_ACPI_STATUS (AE_AML_INTERNAL); } /* Field location is (base of buffer) + (byte offset) */ Location = ObjDesc->BufferField.BufferObj->Buffer.Pointer + ObjDesc->BufferField.BaseByteOffset; /* * Construct Mask with as many 1 bits as the field width * * NOTE: Only the bottom 5 bits are valid for a shift operation, so * special care must be taken for any shift greater than 31 bits. * * TBD: [Unhandled] Fields greater than 32 bits will not work. */ if (ObjDesc->BufferField.BitLength < 32) { Mask = ((UINT32) 1 << ObjDesc->BufferField.BitLength) - (UINT32) 1; } else { Mask = ACPI_UINT32_MAX; } ResultDesc->Integer.Type = (UINT8) ACPI_TYPE_INTEGER; /* Get the 32 bit value at the location */ MOVE_UNALIGNED32_TO_32 (&ResultDesc->Integer.Value, Location); /* * Shift the 32-bit word containing the field, and mask off the * resulting value */ ResultDesc->Integer.Value = (ResultDesc->Integer.Value >> ObjDesc->BufferField.StartFieldBitOffset) & Mask; - DEBUG_PRINT (ACPI_INFO, - ("** Read from buffer %p byte %ld bit %d width %d addr %p mask %08lx val %08lx\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "** Read from buffer %p byte %ld bit %d width %d addr %p mask %08lx val %08lx\n", ObjDesc->BufferField.BufferObj->Buffer.Pointer, ObjDesc->BufferField.BaseByteOffset, ObjDesc->BufferField.StartFieldBitOffset, ObjDesc->BufferField.BitLength, Location, Mask, ResultDesc->Integer.Value)); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExResolveToValue * * PARAMETERS: **StackPtr - Points to entry on ObjStack, which can * be either an (ACPI_OPERAND_OBJECT *) * or an ACPI_HANDLE. * WalkState - Current method state * * RETURN: Status * * DESCRIPTION: Convert Reference objects to values * ******************************************************************************/ ACPI_STATUS AcpiExResolveToValue ( ACPI_OPERAND_OBJECT **StackPtr, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; FUNCTION_TRACE_PTR ("ExResolveToValue", StackPtr); if (!StackPtr || !*StackPtr) { - DEBUG_PRINTP (ACPI_ERROR, ("Internal - null pointer\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - null pointer\n")); return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* * The entity pointed to by the StackPtr can be either * 1) A valid ACPI_OPERAND_OBJECT, or * 2) A ACPI_NAMESPACE_NODE (NamedObj) */ if (VALID_DESCRIPTOR_TYPE (*StackPtr, ACPI_DESC_TYPE_INTERNAL)) { Status = AcpiExResolveObjectToValue (StackPtr, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* * Object on the stack may have changed if AcpiExResolveObjectToValue() * was called (i.e., we can't use an _else_ here.) */ if (VALID_DESCRIPTOR_TYPE (*StackPtr, ACPI_DESC_TYPE_NAMED)) { Status = AcpiExResolveNodeToValue ((ACPI_NAMESPACE_NODE **) StackPtr, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } - DEBUG_PRINTP (ACPI_INFO, ("Resolved object %p\n", *StackPtr)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Resolved object %p\n", *StackPtr)); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExResolveObjectToValue * * PARAMETERS: StackPtr - Pointer to a stack location that contains a * ptr to an internal object. * WalkState - Current method state * * RETURN: Status * * DESCRIPTION: Retrieve the value from an internal object. The Reference type * uses the associated AML opcode to determine the value. * ******************************************************************************/ ACPI_STATUS AcpiExResolveObjectToValue ( ACPI_OPERAND_OBJECT **StackPtr, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *StackDesc; void *TempNode; ACPI_OPERAND_OBJECT *ObjDesc; UINT16 Opcode; FUNCTION_TRACE ("ExResolveObjectToValue"); StackDesc = *StackPtr; /* This is an ACPI_OPERAND_OBJECT */ switch (StackDesc->Common.Type) { case INTERNAL_TYPE_REFERENCE: Opcode = StackDesc->Reference.Opcode; switch (Opcode) { case AML_NAME_OP: /* * Convert indirect name ptr to a direct name ptr. * Then, AcpiExResolveNodeToValue can be used to get the value */ TempNode = StackDesc->Reference.Object; /* Delete the Reference Object */ AcpiUtRemoveReference (StackDesc); /* Put direct name pointer onto stack and exit */ (*StackPtr) = TempNode; break; case AML_LOCAL_OP: case AML_ARG_OP: /* * Get the local from the method's state info * Note: this increments the local's object reference count */ Status = AcpiDsMethodDataGetValue (Opcode, StackDesc->Reference.Offset, WalkState, &ObjDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Now we can delete the original Reference Object and * replace it with the resolve value */ AcpiUtRemoveReference (StackDesc); *StackPtr = ObjDesc; - DEBUG_PRINTP (ACPI_INFO, ("[Arg/Local %d] ValueObj is %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "[Arg/Local %d] ValueObj is %p\n", StackDesc->Reference.Offset, ObjDesc)); break; /* * TBD: [Restructure] These next three opcodes change the type of * the object, which is actually a no-no. */ case AML_ZERO_OP: StackDesc->Common.Type = (UINT8) ACPI_TYPE_INTEGER; StackDesc->Integer.Value = 0; break; case AML_ONE_OP: StackDesc->Common.Type = (UINT8) ACPI_TYPE_INTEGER; StackDesc->Integer.Value = 1; break; case AML_ONES_OP: StackDesc->Common.Type = (UINT8) ACPI_TYPE_INTEGER; StackDesc->Integer.Value = ACPI_INTEGER_MAX; /* Truncate value if we are executing from a 32-bit ACPI table */ AcpiExTruncateFor32bitTable (StackDesc, WalkState); break; case AML_INDEX_OP: switch (StackDesc->Reference.TargetType) { case ACPI_TYPE_BUFFER_FIELD: /* Just return - leave the Reference on the stack */ break; case ACPI_TYPE_PACKAGE: ObjDesc = *StackDesc->Reference.Where; if (ObjDesc) { /* * Valid obj descriptor, copy pointer to return value * (i.e., dereference the package index) * Delete the ref object, increment the returned object */ AcpiUtRemoveReference (StackDesc); AcpiUtAddReference (ObjDesc); *StackPtr = ObjDesc; } else { /* * A NULL object descriptor means an unitialized element of * the package, can't dereference it */ - DEBUG_PRINTP (ACPI_ERROR, - ("Attempt to deref an Index to NULL pkg element Idx=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Attempt to deref an Index to NULL pkg element Idx=%p\n", StackDesc)); Status = AE_AML_UNINITIALIZED_ELEMENT; } break; default: /* Invalid reference object */ - DEBUG_PRINTP (ACPI_ERROR, - ("Unknown TargetType %X in Index/Reference obj %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Unknown TargetType %X in Index/Reference obj %p\n", StackDesc->Reference.TargetType, StackDesc)); Status = AE_AML_INTERNAL; break; } break; case AML_DEBUG_OP: /* Just leave the object as-is */ break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Unknown Reference object subtype %02X in %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown Reference object subtype %02X in %p\n", Opcode, StackDesc)); Status = AE_AML_INTERNAL; break; } /* switch (Opcode) */ break; /* case INTERNAL_TYPE_REFERENCE */ case ACPI_TYPE_BUFFER_FIELD: ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_ANY); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } Status = AcpiExGetBufferFieldValue (StackDesc, ObjDesc); if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ObjDesc); ObjDesc = NULL; } *StackPtr = (void *) ObjDesc; break; case INTERNAL_TYPE_BANK_FIELD: ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_ANY); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } /* TBD: WRONG! */ Status = AcpiExGetBufferFieldValue (StackDesc, ObjDesc); if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ObjDesc); ObjDesc = NULL; } *StackPtr = (void *) ObjDesc; break; /* TBD: [Future] - may need to handle IndexField, and DefField someday */ default: break; } /* switch (StackDesc->Common.Type) */ return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exresop.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exresop.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exresop.c (revision 82367) @@ -1,667 +1,667 @@ /****************************************************************************** * * Module Name: exresop - AML Interpreter operand/object resolution - * $Revision: 31 $ + * $Revision: 33 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXRESOP_C__ #include "acpi.h" #include "amlcode.h" #include "acparser.h" #include "acdispat.h" #include "acinterp.h" #include "acnamesp.h" #include "actables.h" #include "acevents.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exresop") /******************************************************************************* * * FUNCTION: AcpiExCheckObjectType * * PARAMETERS: TypeNeeded Object type needed * ThisType Actual object type * Object Object pointer * * RETURN: Status * * DESCRIPTION: Check required type against actual type * ******************************************************************************/ ACPI_STATUS AcpiExCheckObjectType ( ACPI_OBJECT_TYPE TypeNeeded, ACPI_OBJECT_TYPE ThisType, void *Object) { + PROC_NAME ("AcpiExCheckObjectType"); - if (TypeNeeded == ACPI_TYPE_ANY) { /* All types OK, so we don't perform any typechecks */ return (AE_OK); } if (TypeNeeded != ThisType) { - DEBUG_PRINT (ACPI_INFO, - ("ExCheckObjectType: Needed [%s], found [%s] %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Needed [%s], found [%s] %p\n", AcpiUtGetTypeName (TypeNeeded), AcpiUtGetTypeName (ThisType), Object)); return (AE_AML_OPERAND_TYPE); } return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExResolveOperands * * PARAMETERS: Opcode Opcode being interpreted * StackPtr Top of operand stack * * RETURN: Status * * DESCRIPTION: Convert stack entries to required types * * Each nibble in ArgTypes represents one required operand * and indicates the required Type: * * The corresponding stack entry will be converted to the * required type if possible, else return an exception * ******************************************************************************/ ACPI_STATUS AcpiExResolveOperands ( UINT16 Opcode, ACPI_OPERAND_OBJECT **StackPtr, ACPI_WALK_STATE *WalkState) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_STATUS Status = AE_OK; UINT8 ObjectType; void *TempNode; UINT32 ArgTypes; ACPI_OPCODE_INFO *OpInfo; UINT32 ThisArgType; ACPI_OBJECT_TYPE TypeNeeded; FUNCTION_TRACE_U32 ("ExResolveOperands", Opcode); OpInfo = AcpiPsGetOpcodeInfo (Opcode); if (ACPI_GET_OP_TYPE (OpInfo) != ACPI_OP_TYPE_OPCODE) { return_ACPI_STATUS (AE_AML_BAD_OPCODE); } ArgTypes = OpInfo->RuntimeArgs; if (ArgTypes == ARGI_INVALID_OPCODE) { - DEBUG_PRINTP (ACPI_ERROR, ("Internal - %X is not a valid AML opcode\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - %X is not a valid AML opcode\n", Opcode)); return_ACPI_STATUS (AE_AML_INTERNAL); } - DEBUG_PRINTP (TRACE_EXEC, ("Opcode %X OperandTypes=%X \n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Opcode %X OperandTypes=%X \n", Opcode, ArgTypes)); /* * Normal exit is with (ArgTypes == 0) at end of argument list. * Function will return an exception from within the loop upon * finding an entry which is not (or cannot be converted * to) the required type; if stack underflows; or upon * finding a NULL stack entry (which should not happen). */ while (GET_CURRENT_ARG_TYPE (ArgTypes)) { if (!StackPtr || !*StackPtr) { - DEBUG_PRINTP (ACPI_ERROR, ("Internal - null stack entry at %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - null stack entry at %X\n", StackPtr)); return_ACPI_STATUS (AE_AML_INTERNAL); } /* Extract useful items */ ObjDesc = *StackPtr; /* Decode the descriptor type */ if (VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_NAMED)) { /* Node */ ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type; } else if (VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_INTERNAL)) { /* ACPI internal object */ ObjectType = ObjDesc->Common.Type; /* Check for bad ACPI_OBJECT_TYPE */ if (!AcpiExValidateObjectType (ObjectType)) { - DEBUG_PRINTP (ACPI_ERROR, ("Bad operand object type [%X]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Bad operand object type [%X]\n", ObjectType)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } if (ObjectType == (UINT8) INTERNAL_TYPE_REFERENCE) { /* * Decode the Reference */ OpInfo = AcpiPsGetOpcodeInfo (Opcode); if (ACPI_GET_OP_TYPE (OpInfo) != ACPI_OP_TYPE_OPCODE) { return_ACPI_STATUS (AE_AML_BAD_OPCODE); } switch (ObjDesc->Reference.Opcode) { case AML_ZERO_OP: case AML_ONE_OP: case AML_ONES_OP: case AML_DEBUG_OP: case AML_NAME_OP: case AML_INDEX_OP: case AML_ARG_OP: case AML_LOCAL_OP: - DEBUG_ONLY_MEMBERS (DEBUG_PRINT (ACPI_INFO, - ("Reference Opcode: %s\n", OpInfo->Name))); + DEBUG_ONLY_MEMBERS (ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Reference Opcode: %s\n", OpInfo->Name))); break; default: - DEBUG_PRINT (ACPI_INFO, - ("Reference Opcode: Unknown [%02x]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Reference Opcode: Unknown [%02x]\n", ObjDesc->Reference.Opcode)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); break; } } } else { /* Invalid descriptor */ - DEBUG_PRINT (ACPI_ERROR, - ("Bad descriptor type %X in Obj %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Bad descriptor type %X in Obj %p\n", ObjDesc->Common.DataType, ObjDesc)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* * Get one argument type, point to the next */ ThisArgType = GET_CURRENT_ARG_TYPE (ArgTypes); INCREMENT_ARG_LIST (ArgTypes); /* * Handle cases where the object does not need to be * resolved to a value */ switch (ThisArgType) { case ARGI_REFERENCE: /* References */ case ARGI_INTEGER_REF: case ARGI_OBJECT_REF: case ARGI_DEVICE_REF: case ARGI_TARGETREF: /* TBD: must implement implicit conversion rules before store */ case ARGI_FIXED_TARGET: /* No implicit conversion before store to target */ case ARGI_SIMPLE_TARGET: /* Name, Local, or Arg - no implicit conversion */ /* Need an operand of type INTERNAL_TYPE_REFERENCE */ if (VALID_DESCRIPTOR_TYPE (ObjDesc, ACPI_DESC_TYPE_NAMED)) /* direct name ptr OK as-is */ { goto NextOperand; } Status = AcpiExCheckObjectType (INTERNAL_TYPE_REFERENCE, ObjectType, ObjDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } if (AML_NAME_OP == ObjDesc->Reference.Opcode) { /* * Convert an indirect name ptr to direct name ptr and put * it on the stack */ TempNode = ObjDesc->Reference.Object; AcpiUtRemoveReference (ObjDesc); (*StackPtr) = TempNode; } goto NextOperand; break; case ARGI_ANYTYPE: /* * We don't want to resolve IndexOp reference objects during * a store because this would be an implicit DeRefOf operation. * Instead, we just want to store the reference object. * -- All others must be resolved below. */ if ((Opcode == AML_STORE_OP) && ((*StackPtr)->Common.Type == INTERNAL_TYPE_REFERENCE) && ((*StackPtr)->Reference.Opcode == AML_INDEX_OP)) { goto NextOperand; } break; } /* * Resolve this object to a value */ Status = AcpiExResolveToValue (StackPtr, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Check the resulting object (value) type */ switch (ThisArgType) { /* * For the simple cases, only one type of resolved object * is allowed */ case ARGI_MUTEX: /* Need an operand of type ACPI_TYPE_MUTEX */ TypeNeeded = ACPI_TYPE_MUTEX; break; case ARGI_EVENT: /* Need an operand of type ACPI_TYPE_EVENT */ TypeNeeded = ACPI_TYPE_EVENT; break; case ARGI_REGION: /* Need an operand of type ACPI_TYPE_REGION */ TypeNeeded = ACPI_TYPE_REGION; break; case ARGI_IF: /* If */ /* Need an operand of type INTERNAL_TYPE_IF */ TypeNeeded = INTERNAL_TYPE_IF; break; case ARGI_PACKAGE: /* Package */ /* Need an operand of type ACPI_TYPE_PACKAGE */ TypeNeeded = ACPI_TYPE_PACKAGE; break; case ARGI_ANYTYPE: /* Any operand type will do */ TypeNeeded = ACPI_TYPE_ANY; break; /* * The more complex cases allow multiple resolved object types */ case ARGI_INTEGER: /* Number */ /* * Need an operand of type ACPI_TYPE_INTEGER, * But we can implicitly convert from a STRING or BUFFER */ Status = AcpiExConvertToInteger (*StackPtr, StackPtr, WalkState); if (ACPI_FAILURE (Status)) { if (Status == AE_TYPE) { - DEBUG_PRINTP (ACPI_INFO, - ("Needed [Integer/String/Buffer], found [%s] %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Needed [Integer/String/Buffer], found [%s] %p\n", AcpiUtGetTypeName ((*StackPtr)->Common.Type), *StackPtr)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } return_ACPI_STATUS (Status); } goto NextOperand; break; case ARGI_BUFFER: /* * Need an operand of type ACPI_TYPE_BUFFER, * But we can implicitly convert from a STRING or INTEGER */ Status = AcpiExConvertToBuffer (*StackPtr, StackPtr, WalkState); if (ACPI_FAILURE (Status)) { if (Status == AE_TYPE) { - DEBUG_PRINTP (ACPI_INFO, - ("Needed [Integer/String/Buffer], found [%s] %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Needed [Integer/String/Buffer], found [%s] %p\n", AcpiUtGetTypeName ((*StackPtr)->Common.Type), *StackPtr)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } return_ACPI_STATUS (Status); } goto NextOperand; break; case ARGI_STRING: /* * Need an operand of type ACPI_TYPE_STRING, * But we can implicitly convert from a BUFFER or INTEGER */ - Status = AcpiExConvertToString (*StackPtr, StackPtr, ACPI_UINT32_MAX, WalkState); + Status = AcpiExConvertToString (*StackPtr, StackPtr, 16, ACPI_UINT32_MAX, WalkState); if (ACPI_FAILURE (Status)) { if (Status == AE_TYPE) { - DEBUG_PRINTP (ACPI_INFO, - ("Needed [Integer/String/Buffer], found [%s] %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Needed [Integer/String/Buffer], found [%s] %p\n", AcpiUtGetTypeName ((*StackPtr)->Common.Type), *StackPtr)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } return_ACPI_STATUS (Status); } goto NextOperand; break; case ARGI_COMPUTEDATA: /* Need an operand of type INTEGER, STRING or BUFFER */ if ((ACPI_TYPE_INTEGER != (*StackPtr)->Common.Type) && (ACPI_TYPE_STRING != (*StackPtr)->Common.Type) && (ACPI_TYPE_BUFFER != (*StackPtr)->Common.Type)) { - DEBUG_PRINTP (ACPI_INFO, - ("Needed [Integer/String/Buffer], found [%s] %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Needed [Integer/String/Buffer], found [%s] %p\n", AcpiUtGetTypeName ((*StackPtr)->Common.Type), *StackPtr)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } goto NextOperand; break; case ARGI_DATAOBJECT: /* * ARGI_DATAOBJECT is only used by the SizeOf operator. * * The ACPI specification allows SizeOf to return the size of * a Buffer, String or Package. However, the MS ACPI.SYS AML * Interpreter also allows an Node reference to return without * error with a size of 4. */ /* Need a buffer, string, package or Node reference */ if (((*StackPtr)->Common.Type != ACPI_TYPE_BUFFER) && ((*StackPtr)->Common.Type != ACPI_TYPE_STRING) && ((*StackPtr)->Common.Type != ACPI_TYPE_PACKAGE) && ((*StackPtr)->Common.Type != INTERNAL_TYPE_REFERENCE)) { - DEBUG_PRINTP (ACPI_INFO, - ("Needed [Buf/Str/Pkg/Ref], found [%s] %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Needed [Buf/Str/Pkg/Ref], found [%s] %p\n", AcpiUtGetTypeName ((*StackPtr)->Common.Type), *StackPtr)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* * If this is a reference, only allow a reference to an Node. */ if ((*StackPtr)->Common.Type == INTERNAL_TYPE_REFERENCE) { if (!(*StackPtr)->Reference.Node) { - DEBUG_PRINTP (ACPI_INFO, - ("Needed [Node Reference], found [%p]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Needed [Node Reference], found [%p]\n", *StackPtr)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } } goto NextOperand; break; case ARGI_COMPLEXOBJ: /* Need a buffer or package or (ACPI 2.0) String */ if (((*StackPtr)->Common.Type != ACPI_TYPE_BUFFER) && ((*StackPtr)->Common.Type != ACPI_TYPE_STRING) && ((*StackPtr)->Common.Type != ACPI_TYPE_PACKAGE)) { - DEBUG_PRINTP (ACPI_INFO, - ("Needed [Buf/Pkg], found [%s] %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Needed [Buf/Pkg], found [%s] %p\n", AcpiUtGetTypeName ((*StackPtr)->Common.Type), *StackPtr)); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } goto NextOperand; break; default: /* Unknown type */ - DEBUG_PRINTP (ACPI_ERROR, - ("Internal - Unknown ARGI type %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Internal - Unknown ARGI type %X\n", ThisArgType)); return_ACPI_STATUS (AE_BAD_PARAMETER); } /* * Make sure that the original object was resolved to the * required object type (Simple cases only). */ Status = AcpiExCheckObjectType (TypeNeeded, (*StackPtr)->Common.Type, *StackPtr); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } NextOperand: /* * If more operands needed, decrement StackPtr to point * to next operand on stack */ if (GET_CURRENT_ARG_TYPE (ArgTypes)) { StackPtr--; } } /* while (*Types) */ return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exstore.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exstore.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exstore.c (revision 82367) @@ -1,779 +1,780 @@ /****************************************************************************** * * Module Name: exstore - AML Interpreter object store support - * $Revision: 140 $ + * $Revision: 142 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXSTORE_C__ #include "acpi.h" #include "acparser.h" #include "acdispat.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #include "actables.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exstore") /******************************************************************************* * * FUNCTION: AcpiExStore * * PARAMETERS: *ValDesc - Value to be stored * *DestDesc - Where to store it. Must be an NS node * or an ACPI_OPERAND_OBJECT of type * Reference; if the latter the descriptor * will be either reused or deleted. * * RETURN: Status * * DESCRIPTION: Store the value described by ValDesc into the location * described by DestDesc. Called by various interpreter * functions to store the result of an operation into * the destination operand. * ******************************************************************************/ ACPI_STATUS AcpiExStore ( ACPI_OPERAND_OBJECT *ValDesc, ACPI_OPERAND_OBJECT *DestDesc, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *RefDesc = DestDesc; FUNCTION_TRACE_PTR ("ExStore", DestDesc); /* Validate parameters */ if (!ValDesc || !DestDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("Internal - null pointer\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - null pointer\n")); return_ACPI_STATUS (AE_AML_NO_OPERAND); } /* DestDesc can be either a namespace node or an ACPI object */ if (VALID_DESCRIPTOR_TYPE (DestDesc, ACPI_DESC_TYPE_NAMED)) { /* * Dest is a namespace node, * Storing an object into a Name "container" */ Status = AcpiExStoreObjectToNode (ValDesc, (ACPI_NAMESPACE_NODE *) DestDesc, WalkState); /* All done, that's it */ return_ACPI_STATUS (Status); } /* Destination object must be an object of type Reference */ if (DestDesc->Common.Type != INTERNAL_TYPE_REFERENCE) { /* Destination is not an Reference */ - DEBUG_PRINTP (ACPI_ERROR, - ("Destination is not a ReferenceObj [%p]\n", DestDesc)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Destination is not a ReferenceObj [%p]\n", DestDesc)); DUMP_STACK_ENTRY (ValDesc); DUMP_STACK_ENTRY (DestDesc); DUMP_OPERANDS (&DestDesc, IMODE_EXECUTE, "ExStore", 2, "Target is not a ReferenceObj"); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* * Examine the Reference opcode. These cases are handled: * * 1) Store to Name (Change the object associated with a name) * 2) Store to an indexed area of a Buffer or Package * 3) Store to a Method Local or Arg * 4) Store to the debug object * 5) Store to a constant -- a noop */ switch (RefDesc->Reference.Opcode) { case AML_NAME_OP: /* Storing an object into a Name "container" */ Status = AcpiExStoreObjectToNode (ValDesc, RefDesc->Reference.Object, WalkState); break; case AML_INDEX_OP: /* Storing to an Index (pointer into a packager or buffer) */ Status = AcpiExStoreObjectToIndex (ValDesc, RefDesc, WalkState); break; case AML_LOCAL_OP: case AML_ARG_OP: /* Store to a method local/arg */ Status = AcpiDsStoreObjectToLocal (RefDesc->Reference.Opcode, RefDesc->Reference.Offset, ValDesc, WalkState); break; case AML_DEBUG_OP: /* * Storing to the Debug object causes the value stored to be * displayed and otherwise has no effect -- see ACPI Specification */ - DEBUG_PRINT (ACPI_INFO, ("**** Write to Debug Object: ****: \n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "**** Write to Debug Object: ****: \n")); - DEBUG_PRINT_RAW (ACPI_DEBUG_OBJECT, ("[ACPI Debug] %s: ", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OBJECTS, "[ACPI Debug] %s: ", AcpiUtGetTypeName (ValDesc->Common.Type))); switch (ValDesc->Common.Type) { case ACPI_TYPE_INTEGER: - DEBUG_PRINT_RAW (ACPI_DEBUG_OBJECT, ("0x%X (%d)\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OBJECTS, "0x%X (%d)\n", (UINT32) ValDesc->Integer.Value, (UINT32) ValDesc->Integer.Value)); break; case ACPI_TYPE_BUFFER: - DEBUG_PRINT_RAW (ACPI_DEBUG_OBJECT, ("Length 0x%X\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OBJECTS, "Length 0x%X\n", (UINT32) ValDesc->Buffer.Length)); break; case ACPI_TYPE_STRING: - DEBUG_PRINT_RAW (ACPI_DEBUG_OBJECT, ("%s\n", ValDesc->String.Pointer)); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OBJECTS, "%s\n", ValDesc->String.Pointer)); break; case ACPI_TYPE_PACKAGE: - DEBUG_PRINT_RAW (ACPI_DEBUG_OBJECT, ("Elements - 0x%X\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OBJECTS, "Elements - 0x%X\n", (UINT32) ValDesc->Package.Elements)); break; default: - DEBUG_PRINT_RAW (ACPI_DEBUG_OBJECT, ("@0x%p\n", ValDesc)); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OBJECTS, "@0x%p\n", ValDesc)); break; } break; case AML_ZERO_OP: case AML_ONE_OP: case AML_ONES_OP: + case AML_REVISION_OP: /* * Storing to a constant is a no-op -- see ACPI Specification * Delete the reference descriptor, however */ break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Internal - Unknown Reference subtype %02x\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - Unknown Reference subtype %02x\n", RefDesc->Reference.Opcode)); /* TBD: [Restructure] use object dump routine !! */ DUMP_BUFFER (RefDesc, sizeof (ACPI_OPERAND_OBJECT)); Status = AE_AML_INTERNAL; break; } /* switch (RefDesc->Reference.Opcode) */ /* Always delete the reference descriptor object */ if (RefDesc) { AcpiUtRemoveReference (RefDesc); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExStoreObjectToIndex * * PARAMETERS: *ValDesc - Value to be stored * *Node - Named object to receive the value * * RETURN: Status * * DESCRIPTION: Store the object to the named object. * ******************************************************************************/ ACPI_STATUS AcpiExStoreObjectToIndex ( ACPI_OPERAND_OBJECT *ValDesc, ACPI_OPERAND_OBJECT *DestDesc, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *ObjDesc; UINT32 Length; UINT32 i; UINT8 Value = 0; FUNCTION_TRACE ("AcpiExStoreObjectToIndex"); /* * Destination must be a reference pointer, and * must point to either a buffer or a package */ switch (DestDesc->Reference.TargetType) { case ACPI_TYPE_PACKAGE: /* * Storing to a package element is not simple. The source must be * evaluated and converted to the type of the destination and then the * source is copied into the destination - we can't just point to the * source object. */ if (DestDesc->Reference.TargetType == ACPI_TYPE_PACKAGE) { /* * The object at *(DestDesc->Reference.Where) is the * element within the package that is to be modified. */ ObjDesc = *(DestDesc->Reference.Where); if (ObjDesc) { /* * If the Destination element is a package, we will delete * that object and construct a new one. * * TBD: [Investigate] Should both the src and dest be required * to be packages? * && (ValDesc->Common.Type == ACPI_TYPE_PACKAGE) */ if (ObjDesc->Common.Type == ACPI_TYPE_PACKAGE) { /* * Take away the reference for being part of a package and * delete */ AcpiUtRemoveReference (ObjDesc); AcpiUtRemoveReference (ObjDesc); ObjDesc = NULL; } } if (!ObjDesc) { /* * If the ObjDesc is NULL, it means that an uninitialized package * element has been used as a destination (this is OK), therefore, * we must create the destination element to match the type of the * source element NOTE: ValDesc can be of any type. */ ObjDesc = AcpiUtCreateInternalObject (ValDesc->Common.Type); if (!ObjDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } /* * If the source is a package, copy the source to the new dest */ if (ACPI_TYPE_PACKAGE == ObjDesc->Common.Type) { Status = AcpiUtCopyIpackageToIpackage (ValDesc, ObjDesc, WalkState); if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ObjDesc); return_ACPI_STATUS (Status); } } /* * Install the new descriptor into the package and add a * reference to the newly created descriptor for now being * part of the parent package */ *(DestDesc->Reference.Where) = ObjDesc; AcpiUtAddReference (ObjDesc); } if (ACPI_TYPE_PACKAGE != ObjDesc->Common.Type) { /* * The destination element is not a package, so we need to * convert the contents of the source (ValDesc) and copy into * the destination (ObjDesc) */ Status = AcpiExStoreObjectToObject (ValDesc, ObjDesc, WalkState); if (ACPI_FAILURE (Status)) { /* * An error occurrered when copying the internal object * so delete the reference. */ - DEBUG_PRINTP (ACPI_ERROR, - ("Unable to copy the internal object\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Unable to copy the internal object\n")); return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } } } break; case ACPI_TYPE_BUFFER_FIELD: /* TBD: can probably call the generic Buffer/Field routines */ /* * Storing into a buffer at a location defined by an Index. * * Each 8-bit element of the source object is written to the * 8-bit Buffer Field of the Index destination object. */ /* * Set the ObjDesc to the destination object and type check. */ ObjDesc = DestDesc->Reference.Object; if (ObjDesc->Common.Type != ACPI_TYPE_BUFFER) { return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* * The assignment of the individual elements will be slightly * different for each source type. */ switch (ValDesc->Common.Type) { case ACPI_TYPE_INTEGER: /* * Type is Integer, assign bytewise * This loop to assign each of the elements is somewhat * backward because of the Big Endian-ness of IA-64 */ Length = sizeof (ACPI_INTEGER); for (i = Length; i != 0; i--) { Value = (UINT8)(ValDesc->Integer.Value >> (MUL_8 (i - 1))); ObjDesc->Buffer.Pointer[DestDesc->Reference.Offset] = Value; } break; case ACPI_TYPE_BUFFER: /* * Type is Buffer, the Length is in the structure. * Just loop through the elements and assign each one in turn. */ Length = ValDesc->Buffer.Length; for (i = 0; i < Length; i++) { - Value = *(ValDesc->Buffer.Pointer + i); + Value = ValDesc->Buffer.Pointer[i]; ObjDesc->Buffer.Pointer[DestDesc->Reference.Offset] = Value; } break; case ACPI_TYPE_STRING: /* * Type is String, the Length is in the structure. * Just loop through the elements and assign each one in turn. */ Length = ValDesc->String.Length; for (i = 0; i < Length; i++) { - Value = *(ValDesc->String.Pointer + i); + Value = ValDesc->String.Pointer[i]; ObjDesc->Buffer.Pointer[DestDesc->Reference.Offset] = Value; } break; default: /* Other types are invalid */ - DEBUG_PRINTP (ACPI_ERROR, - ("Source must be Number/Buffer/String type, not %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Source must be Number/Buffer/String type, not %X\n", ValDesc->Common.Type)); Status = AE_AML_OPERAND_TYPE; break; } break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Target is not a Package or BufferField\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Target is not a Package or BufferField\n")); Status = AE_AML_OPERAND_TYPE; break; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExStoreObjectToNode * * PARAMETERS: *SourceDesc - Value to be stored * *Node - Named object to receive the value * * RETURN: Status * * DESCRIPTION: Store the object to the named object. * * The Assignment of an object to a named object is handled here * The val passed in will replace the current value (if any) * with the input value. * * When storing into an object the data is converted to the * target object type then stored in the object. This means * that the target object type (for an initialized target) will * not be changed by a store operation. * * NOTE: the global lock is acquired early. This will result * in the global lock being held a bit longer. Also, if the * function fails during set up we may get the lock when we * don't really need it. I don't think we care. * ******************************************************************************/ ACPI_STATUS AcpiExStoreObjectToNode ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_NAMESPACE_NODE *Node, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *TargetDesc; ACPI_OBJECT_TYPE8 TargetType = ACPI_TYPE_ANY; FUNCTION_TRACE ("ExStoreObjectToNode"); /* * Assuming the parameters were already validated */ /* * Get current type of the node, and object attached to Node */ TargetType = AcpiNsGetType (Node); TargetDesc = AcpiNsGetAttachedObject (Node); - DEBUG_PRINTP (ACPI_INFO, ("Storing %p(%s) into node %p(%s)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Storing %p(%s) into node %p(%s)\n", Node, AcpiUtGetTypeName (SourceDesc->Common.Type), SourceDesc, AcpiUtGetTypeName (TargetType))); /* * Resolve the source object to an actual value * (If it is a reference object) */ Status = AcpiExResolveObject (&SourceDesc, TargetType, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Do the actual store operation */ switch (TargetType) { case ACPI_TYPE_BUFFER_FIELD: case INTERNAL_TYPE_REGION_FIELD: case INTERNAL_TYPE_BANK_FIELD: case INTERNAL_TYPE_INDEX_FIELD: /* * For fields, copy the source data to the target field. */ Status = AcpiExWriteDataToField (SourceDesc, TargetDesc); break; case ACPI_TYPE_INTEGER: case ACPI_TYPE_STRING: case ACPI_TYPE_BUFFER: /* * These target types are all of type Integer/String/Buffer, and * therefore support implicit conversion before the store. * * Copy and/or convert the source object to a new target object */ Status = AcpiExStoreObject (SourceDesc, TargetType, &TargetDesc, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Store the new TargetDesc as the new value of the Name, and set * the Name's type to that of the value being stored in it. * SourceDesc reference count is incremented by AttachObject. */ Status = AcpiNsAttachObject (Node, TargetDesc, TargetType); - DEBUG_PRINTP (ACPI_INFO, - ("Store %s into %s via Convert/Attach\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Store %s into %s via Convert/Attach\n", AcpiUtGetTypeName (TargetDesc->Common.Type), AcpiUtGetTypeName (TargetType))); break; default: /* No conversions for all other types. Just attach the source object */ Status = AcpiNsAttachObject (Node, SourceDesc, SourceDesc->Common.Type); - DEBUG_PRINTP (ACPI_INFO, - ("Store %s into %s via Attach only\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Store %s into %s via Attach only\n", AcpiUtGetTypeName (SourceDesc->Common.Type), AcpiUtGetTypeName (SourceDesc->Common.Type))); break; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExStoreObjectToObject * * PARAMETERS: *SourceDesc - Value to be stored * *DestDesc - Object to receive the value * * RETURN: Status * * DESCRIPTION: Store an object to another object. * * The Assignment of an object to another (not named) object * is handled here. * The val passed in will replace the current value (if any) * with the input value. * * When storing into an object the data is converted to the * target object type then stored in the object. This means * that the target object type (for an initialized target) will * not be changed by a store operation. * * This module allows destination types of Number, String, * and Buffer. * ******************************************************************************/ ACPI_STATUS AcpiExStoreObjectToObject ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *DestDesc, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_OK; ACPI_OBJECT_TYPE8 DestinationType = DestDesc->Common.Type; FUNCTION_TRACE ("ExStoreObjectToObject"); /* * Assuming the parameters are valid! */ - DEBUG_PRINTP (ACPI_INFO, ("Storing %p(%s) to %p(%s)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Storing %p(%s) to %p(%s)\n", SourceDesc, AcpiUtGetTypeName (SourceDesc->Common.Type), DestDesc, AcpiUtGetTypeName (DestDesc->Common.Type))); /* * From this interface, we only support Integers/Strings/Buffers */ switch (DestinationType) { case ACPI_TYPE_INTEGER: case ACPI_TYPE_STRING: case ACPI_TYPE_BUFFER: break; default: - DEBUG_PRINTP (ACPI_WARN, ("Store into %s not implemented\n", + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Store into %s not implemented\n", AcpiUtGetTypeName (DestDesc->Common.Type))); return_ACPI_STATUS (AE_NOT_IMPLEMENTED); } /* * Resolve the source object to an actual value * (If it is a reference object) */ Status = AcpiExResolveObject (&SourceDesc, DestinationType, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Copy and/or convert the source object to the destination object */ Status = AcpiExStoreObject (SourceDesc, DestinationType, &DestDesc, WalkState); return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exstoren.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exstoren.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exstoren.c (revision 82367) @@ -1,352 +1,352 @@ /****************************************************************************** * * Module Name: exstoren - AML Interpreter object store support, * Store to Node (namespace object) - * $Revision: 38 $ + * $Revision: 39 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXSTOREN_C__ #include "acpi.h" #include "acparser.h" #include "acdispat.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #include "actables.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exstoren") /******************************************************************************* * * FUNCTION: AcpiExResolveObject * * PARAMETERS: SourceDescPtr - Pointer to the source object * TargetType - Current type of the target * WalkState - Current walk state * * RETURN: Status, resolved object in SourceDescPtr. * * DESCRIPTION: Resolve an object. If the object is a reference, dereference * it and return the actual object in the SourceDescPtr. * ******************************************************************************/ ACPI_STATUS AcpiExResolveObject ( ACPI_OPERAND_OBJECT **SourceDescPtr, ACPI_OBJECT_TYPE8 TargetType, ACPI_WALK_STATE *WalkState) { ACPI_OPERAND_OBJECT *SourceDesc = *SourceDescPtr; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("ExResolveObject"); /* * Ensure we have a Source that can be stored in the target */ switch (TargetType) { /* This case handles the "interchangeable" types Integer, String, and Buffer. */ /* * These cases all require only Integers or values that * can be converted to Integers (Strings or Buffers) */ case ACPI_TYPE_BUFFER_FIELD: case INTERNAL_TYPE_REGION_FIELD: case INTERNAL_TYPE_BANK_FIELD: case INTERNAL_TYPE_INDEX_FIELD: /* * Stores into a Field/Region or into a Buffer/String * are all essentially the same. */ case ACPI_TYPE_INTEGER: case ACPI_TYPE_STRING: case ACPI_TYPE_BUFFER: /* TBD: FIX - check for source==REF, resolve, then check type */ /* * If SourceDesc is not a valid type, try to resolve it to one. */ if ((SourceDesc->Common.Type != ACPI_TYPE_INTEGER) && (SourceDesc->Common.Type != ACPI_TYPE_BUFFER) && (SourceDesc->Common.Type != ACPI_TYPE_STRING)) { /* * Initially not a valid type, convert */ Status = AcpiExResolveToValue (SourceDescPtr, WalkState); if (ACPI_SUCCESS (Status) && (SourceDesc->Common.Type != ACPI_TYPE_INTEGER) && (SourceDesc->Common.Type != ACPI_TYPE_BUFFER) && (SourceDesc->Common.Type != ACPI_TYPE_STRING)) { /* * Conversion successful but still not a valid type */ - DEBUG_PRINTP (ACPI_ERROR, - ("Cannot assign type %s to %s (must be type Int/Str/Buf)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Cannot assign type %s to %s (must be type Int/Str/Buf)\n", AcpiUtGetTypeName ((*SourceDescPtr)->Common.Type), AcpiUtGetTypeName (TargetType))); Status = AE_AML_OPERAND_TYPE; } } break; case INTERNAL_TYPE_ALIAS: /* * Aliases are resolved by AcpiExPrepOperands */ - DEBUG_PRINTP (ACPI_WARN, ("Store into Alias - should never happen\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Store into Alias - should never happen\n")); Status = AE_AML_INTERNAL; break; case ACPI_TYPE_PACKAGE: default: /* * All other types than Alias and the various Fields come here, * including the untyped case - ACPI_TYPE_ANY. */ break; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExStoreObject * * PARAMETERS: SourceDesc - Object to store * TargetType - Current type of the target * TargetDescPtr - Pointer to the target * WalkState - Current walk state * * RETURN: Status * * DESCRIPTION: "Store" an object to another object. This may include * converting the source type to the target type (implicit * conversion), and a copy of the value of the source to * the target. * ******************************************************************************/ ACPI_STATUS AcpiExStoreObject ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OBJECT_TYPE8 TargetType, ACPI_OPERAND_OBJECT **TargetDescPtr, ACPI_WALK_STATE *WalkState) { ACPI_OPERAND_OBJECT *TargetDesc = *TargetDescPtr; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("ExStoreObject"); /* * Perform the "implicit conversion" of the source to the current type * of the target - As per the ACPI specification. * * If no conversion performed, SourceDesc is left alone, otherwise it * is updated with a new object. */ Status = AcpiExConvertToTargetType (TargetType, &SourceDesc, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * We now have two objects of identical types, and we can perform a * copy of the *value* of the source object. */ switch (TargetType) { case ACPI_TYPE_ANY: case INTERNAL_TYPE_DEF_ANY: /* * The target namespace node is uninitialized (has no target object), * and will take on the type of the source object */ *TargetDescPtr = SourceDesc; break; case ACPI_TYPE_INTEGER: TargetDesc->Integer.Value = SourceDesc->Integer.Value; /* Truncate value if we are executing from a 32-bit ACPI table */ AcpiExTruncateFor32bitTable (TargetDesc, WalkState); break; case ACPI_TYPE_STRING: Status = AcpiExCopyStringToString (SourceDesc, TargetDesc); break; case ACPI_TYPE_BUFFER: Status = AcpiExCopyBufferToBuffer (SourceDesc, TargetDesc); break; case ACPI_TYPE_PACKAGE: /* * TBD: [Unhandled] Not real sure what to do here */ Status = AE_NOT_IMPLEMENTED; break; default: /* * All other types come here. */ - DEBUG_PRINTP (ACPI_WARN, ("Store into type %s not implemented\n", + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Store into type %s not implemented\n", AcpiUtGetTypeName (TargetType))); Status = AE_NOT_IMPLEMENTED; break; } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exstorob.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exstorob.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exstorob.c (revision 82367) @@ -1,272 +1,274 @@ /****************************************************************************** * * Module Name: exstorob - AML Interpreter object store support, store to object - * $Revision: 33 $ + * $Revision: 35 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXSTOROB_C__ #include "acpi.h" #include "acparser.h" #include "acdispat.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #include "actables.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exstorob") /******************************************************************************* * * FUNCTION: AcpiExCopyBufferToBuffer * * PARAMETERS: SourceDesc - Source object to copy * TargetDesc - Destination object of the copy * * RETURN: Status * * DESCRIPTION: Copy a buffer object to another buffer object. * ******************************************************************************/ ACPI_STATUS AcpiExCopyBufferToBuffer ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc) { UINT32 Length; UINT8 *Buffer; + PROC_NAME ("AcpiExCopyBufferToBuffer"); + /* * We know that SourceDesc is a buffer by now */ Buffer = (UINT8 *) SourceDesc->Buffer.Pointer; Length = SourceDesc->Buffer.Length; /* * If target is a buffer of length zero, allocate a new * buffer of the proper length */ if (TargetDesc->Buffer.Length == 0) { TargetDesc->Buffer.Pointer = ACPI_MEM_ALLOCATE (Length); if (!TargetDesc->Buffer.Pointer) { return (AE_NO_MEMORY); } TargetDesc->Buffer.Length = Length; } /* * Buffer is a static allocation, * only place what will fit in the buffer. */ if (Length <= TargetDesc->Buffer.Length) { /* Clear existing buffer and copy in the new one */ MEMSET (TargetDesc->Buffer.Pointer, 0, TargetDesc->Buffer.Length); MEMCPY (TargetDesc->Buffer.Pointer, Buffer, Length); } else { /* * Truncate the source, copy only what will fit */ MEMCPY (TargetDesc->Buffer.Pointer, Buffer, TargetDesc->Buffer.Length); - DEBUG_PRINT (ACPI_INFO, - ("ExCopyBufferToBuffer: Truncating src buffer from %X to %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Truncating src buffer from %X to %X\n", Length, TargetDesc->Buffer.Length)); } return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExCopyStringToString * * PARAMETERS: SourceDesc - Source object to copy * TargetDesc - Destination object of the copy * * RETURN: Status * * DESCRIPTION: Copy a String object to another String object * ******************************************************************************/ ACPI_STATUS AcpiExCopyStringToString ( ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc) { UINT32 Length; UINT8 *Buffer; /* * We know that SourceDesc is a string by now. */ Buffer = (UINT8 *) SourceDesc->String.Pointer; Length = SourceDesc->String.Length; /* * Setting a string value replaces the old string */ if (Length < TargetDesc->String.Length) { /* Clear old string and copy in the new one */ MEMSET (TargetDesc->String.Pointer, 0, TargetDesc->String.Length); MEMCPY (TargetDesc->String.Pointer, Buffer, Length); } else { /* * Free the current buffer, then allocate a buffer * large enough to hold the value */ if (TargetDesc->String.Pointer && - !AcpiTbSystemTablePointer (TargetDesc->String.Pointer)) + (!(TargetDesc->Common.Flags & AOPOBJ_STATIC_POINTER))) { /* * Only free if not a pointer into the DSDT */ ACPI_MEM_FREE (TargetDesc->String.Pointer); } TargetDesc->String.Pointer = ACPI_MEM_ALLOCATE (Length + 1); if (!TargetDesc->String.Pointer) { return (AE_NO_MEMORY); } TargetDesc->String.Length = Length; MEMCPY (TargetDesc->String.Pointer, Buffer, Length); } return (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exsystem.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exsystem.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exsystem.c (revision 82367) @@ -1,446 +1,446 @@ /****************************************************************************** * * Module Name: exsystem - Interface to OS services - * $Revision: 64 $ + * $Revision: 65 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXSYSTEM_C__ #include "acpi.h" #include "acinterp.h" #include "acnamesp.h" #include "achware.h" #include "acevents.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exsystem") /******************************************************************************* * * FUNCTION: AcpiExSystemWaitSemaphore * * PARAMETERS: Semaphore - OSD semaphore to wait on * Timeout - Max time to wait * * RETURN: Status * * DESCRIPTION: Implements a semaphore wait with a check to see if the * semaphore is available immediately. If it is not, the * interpreter is released. * ******************************************************************************/ ACPI_STATUS AcpiExSystemWaitSemaphore ( ACPI_HANDLE Semaphore, UINT32 Timeout) { ACPI_STATUS Status; FUNCTION_TRACE ("AcpiExSystemWaitSemaphore"); Status = AcpiOsWaitSemaphore (Semaphore, 1, 0); if (ACPI_SUCCESS (Status)) { return_ACPI_STATUS (Status); } if (Status == AE_TIME) { /* We must wait, so unlock the interpreter */ AcpiExExitInterpreter (); Status = AcpiOsWaitSemaphore (Semaphore, 1, Timeout); - DEBUG_PRINT (TRACE_EXEC, ("*** Thread awake after blocking, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "*** Thread awake after blocking, %s\n", AcpiFormatException (Status))); /* Reacquire the interpreter */ Status = AcpiExEnterInterpreter (); if (ACPI_SUCCESS (Status)) { /* Restore the timeout exception */ Status = AE_TIME; } } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExSystemDoStall * * PARAMETERS: HowLong - The amount of time to stall * * RETURN: None * * DESCRIPTION: Suspend running thread for specified amount of time. * ******************************************************************************/ void AcpiExSystemDoStall ( UINT32 HowLong) { if (HowLong > 1000) /* 1 millisecond */ { /* Since this thread will sleep, we must release the interpreter */ AcpiExExitInterpreter (); AcpiOsStall (HowLong); /* And now we must get the interpreter again */ AcpiExEnterInterpreter (); } else { AcpiOsSleep (0, (HowLong / 1000) + 1); } } /******************************************************************************* * * FUNCTION: AcpiExSystemDoSuspend * * PARAMETERS: HowLong - The amount of time to suspend * * RETURN: None * * DESCRIPTION: Suspend running thread for specified amount of time. * ******************************************************************************/ void AcpiExSystemDoSuspend ( UINT32 HowLong) { /* Since this thread will sleep, we must release the interpreter */ AcpiExExitInterpreter (); AcpiOsSleep ((UINT16) (HowLong / (UINT32) 1000), (UINT16) (HowLong % (UINT32) 1000)); /* And now we must get the interpreter again */ AcpiExEnterInterpreter (); } /******************************************************************************* * * FUNCTION: AcpiExSystemAcquireMutex * * PARAMETERS: *TimeDesc - The 'time to delay' object descriptor * *ObjDesc - The object descriptor for this op * * RETURN: Status * * DESCRIPTION: Provides an access point to perform synchronization operations * within the AML. This function will cause a lock to be generated * for the Mutex pointed to by ObjDesc. * ******************************************************************************/ ACPI_STATUS AcpiExSystemAcquireMutex ( ACPI_OPERAND_OBJECT *TimeDesc, ACPI_OPERAND_OBJECT *ObjDesc) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE_PTR ("AcpiExSystemAcquireMutex", ObjDesc); if (!ObjDesc) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* * Support for the _GL_ Mutex object -- go get the global lock */ if (ObjDesc->Mutex.Semaphore == AcpiGbl_GlobalLockSemaphore) { Status = AcpiEvAcquireGlobalLock (); return_ACPI_STATUS (Status); } Status = AcpiExSystemWaitSemaphore (ObjDesc->Mutex.Semaphore, (UINT32) TimeDesc->Integer.Value); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExSystemReleaseMutex * * PARAMETERS: *ObjDesc - The object descriptor for this op * * RETURN: Status * * DESCRIPTION: Provides an access point to perform synchronization operations * within the AML. This operation is a request to release a * previously acquired Mutex. If the Mutex variable is set then * it will be decremented. * ******************************************************************************/ ACPI_STATUS AcpiExSystemReleaseMutex ( ACPI_OPERAND_OBJECT *ObjDesc) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("AcpiExSystemReleaseMutex"); if (!ObjDesc) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* * Support for the _GL_ Mutex object -- release the global lock */ if (ObjDesc->Mutex.Semaphore == AcpiGbl_GlobalLockSemaphore) { AcpiEvReleaseGlobalLock (); return_ACPI_STATUS (AE_OK); } Status = AcpiOsSignalSemaphore (ObjDesc->Mutex.Semaphore, 1); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExSystemSignalEvent * * PARAMETERS: *ObjDesc - The object descriptor for this op * * RETURN: AE_OK * * DESCRIPTION: Provides an access point to perform synchronization operations * within the AML. * ******************************************************************************/ ACPI_STATUS AcpiExSystemSignalEvent ( ACPI_OPERAND_OBJECT *ObjDesc) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("AcpiExSystemSignalEvent"); if (ObjDesc) { Status = AcpiOsSignalSemaphore (ObjDesc->Event.Semaphore, 1); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExSystemWaitEvent * * PARAMETERS: *TimeDesc - The 'time to delay' object descriptor * *ObjDesc - The object descriptor for this op * * RETURN: Status * * DESCRIPTION: Provides an access point to perform synchronization operations * within the AML. This operation is a request to wait for an * event. * ******************************************************************************/ ACPI_STATUS AcpiExSystemWaitEvent ( ACPI_OPERAND_OBJECT *TimeDesc, ACPI_OPERAND_OBJECT *ObjDesc) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("AcpiExSystemWaitEvent"); if (ObjDesc) { Status = AcpiExSystemWaitSemaphore (ObjDesc->Event.Semaphore, (UINT32) TimeDesc->Integer.Value); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExSystemResetEvent * * PARAMETERS: *ObjDesc - The object descriptor for this op * * RETURN: Status * * DESCRIPTION: Reset an event to a known state. * ******************************************************************************/ ACPI_STATUS AcpiExSystemResetEvent ( ACPI_OPERAND_OBJECT *ObjDesc) { ACPI_STATUS Status = AE_OK; void *TempSemaphore; /* * We are going to simply delete the existing semaphore and * create a new one! */ Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 0, &TempSemaphore); if (ACPI_SUCCESS (Status)) { AcpiOsDeleteSemaphore (ObjDesc->Event.Semaphore); ObjDesc->Event.Semaphore = TempSemaphore; } return (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/exutils.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/exutils.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/exutils.c (revision 82367) @@ -1,487 +1,487 @@ /****************************************************************************** * * Module Name: exutils - interpreter/scanner utilities - * $Revision: 80 $ + * $Revision: 82 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __EXUTILS_C__ #include "acpi.h" #include "acparser.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #include "acevents.h" #define _COMPONENT ACPI_EXECUTER MODULE_NAME ("exutils") /******************************************************************************* * * FUNCTION: AcpiExEnterInterpreter * * PARAMETERS: None * * DESCRIPTION: Enter the interpreter execution region * TBD: should be a macro * ******************************************************************************/ ACPI_STATUS AcpiExEnterInterpreter (void) { ACPI_STATUS Status; FUNCTION_TRACE ("ExEnterInterpreter"); Status = AcpiUtAcquireMutex (ACPI_MTX_EXECUTE); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiExExitInterpreter * * PARAMETERS: None * * DESCRIPTION: Exit the interpreter execution region * * Cases where the interpreter is unlocked: * 1) Completion of the execution of a control method * 2) Method blocked on a Sleep() AML opcode * 3) Method blocked on an Acquire() AML opcode * 4) Method blocked on a Wait() AML opcode * 5) Method blocked to acquire the global lock * 6) Method blocked to execute a serialized control method that is * already executing * 7) About to invoke a user-installed opregion handler * * TBD: should be a macro * ******************************************************************************/ void AcpiExExitInterpreter (void) { FUNCTION_TRACE ("ExExitInterpreter"); AcpiUtReleaseMutex (ACPI_MTX_EXECUTE); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiExValidateObjectType * * PARAMETERS: Type Object type to validate * * DESCRIPTION: Determine if a type is a valid ACPI object type * ******************************************************************************/ BOOLEAN AcpiExValidateObjectType ( ACPI_OBJECT_TYPE Type) { if ((Type > ACPI_TYPE_MAX && Type < INTERNAL_TYPE_BEGIN) || (Type > INTERNAL_TYPE_MAX)) { return (FALSE); } return (TRUE); } /******************************************************************************* * * FUNCTION: AcpiExTruncateFor32bitTable * * PARAMETERS: ObjDesc - Object to be truncated * WalkState - Current walk state * (A method must be executing) * * RETURN: none * * DESCRIPTION: Truncate a number to 32-bits if the currently executing method * belongs to a 32-bit ACPI table. * ******************************************************************************/ void AcpiExTruncateFor32bitTable ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState) { /* * Object must be a valid number and we must be executing * a control method */ if ((!ObjDesc) || (ObjDesc->Common.Type != ACPI_TYPE_INTEGER) || (!WalkState->MethodNode)) { return; } if (WalkState->MethodNode->Flags & ANOBJ_DATA_WIDTH_32) { /* * We are running a method that exists in a 32-bit ACPI table. * Truncate the value to 32 bits by zeroing out the upper 32-bit field */ ObjDesc->Integer.Value &= (ACPI_INTEGER) ACPI_UINT32_MAX; } } /******************************************************************************* * * FUNCTION: AcpiExAcquireGlobalLock * * PARAMETERS: Rule - Lock rule: AlwaysLock, NeverLock * * RETURN: TRUE/FALSE indicating whether the lock was actually acquired * * DESCRIPTION: Obtain the global lock and keep track of this fact via two * methods. A global variable keeps the state of the lock, and * the state is returned to the caller. * ******************************************************************************/ BOOLEAN AcpiExAcquireGlobalLock ( UINT32 Rule) { BOOLEAN Locked = FALSE; ACPI_STATUS Status; FUNCTION_TRACE ("ExAcquireGlobalLock"); /* Only attempt lock if the Rule says so */ if (Rule == (UINT32) GLOCK_ALWAYS_LOCK) { /* We should attempt to get the lock */ Status = AcpiEvAcquireGlobalLock (); if (ACPI_SUCCESS (Status)) { Locked = TRUE; } else { - DEBUG_PRINTP (ACPI_ERROR, ("Could not acquire Global Lock, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not acquire Global Lock, %s\n", AcpiFormatException (Status))); } } return_VALUE (Locked); } /******************************************************************************* * * FUNCTION: AcpiExReleaseGlobalLock * * PARAMETERS: LockedByMe - Return value from corresponding call to * AcquireGlobalLock. * * RETURN: Status * * DESCRIPTION: Release the global lock if it is locked. * ******************************************************************************/ ACPI_STATUS AcpiExReleaseGlobalLock ( BOOLEAN LockedByMe) { FUNCTION_TRACE ("ExReleaseGlobalLock"); /* Only attempt unlock if the caller locked it */ if (LockedByMe) { /* OK, now release the lock */ AcpiEvReleaseGlobalLock (); } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExDigitsNeeded * * PARAMETERS: val - Value to be represented * base - Base of representation * * RETURN: the number of digits needed to represent val in base * ******************************************************************************/ UINT32 AcpiExDigitsNeeded ( ACPI_INTEGER val, UINT32 base) { UINT32 NumDigits = 0; FUNCTION_TRACE ("ExDigitsNeeded"); if (base < 1) { REPORT_ERROR (("ExDigitsNeeded: Internal error - Invalid base\n")); } else { /* * ACPI_INTEGER is unsigned, which is why we don't worry about the '-' */ for (NumDigits = 1; (val = ACPI_DIVIDE (val,base)); ++NumDigits) { ; } } return_VALUE (NumDigits); } /******************************************************************************* * * FUNCTION: ntohl * * PARAMETERS: Value - Value to be converted * * DESCRIPTION: Convert a 32-bit value to big-endian (swap the bytes) * ******************************************************************************/ static UINT32 _ntohl ( UINT32 Value) { union { UINT32 Value; UINT8 Bytes[4]; } Out; union { UINT32 Value; UINT8 Bytes[4]; } In; In.Value = Value; Out.Bytes[0] = In.Bytes[3]; Out.Bytes[1] = In.Bytes[2]; Out.Bytes[2] = In.Bytes[1]; Out.Bytes[3] = In.Bytes[0]; return (Out.Value); } /******************************************************************************* * * FUNCTION: AcpiExEisaIdToString * * PARAMETERS: NumericId - EISA ID to be converted * OutString - Where to put the converted string (8 bytes) * * DESCRIPTION: Convert a numeric EISA ID to string representation * ******************************************************************************/ ACPI_STATUS AcpiExEisaIdToString ( UINT32 NumericId, NATIVE_CHAR *OutString) { UINT32 id; /* swap to big-endian to get contiguous bits */ id = _ntohl (NumericId); OutString[0] = (char) ('@' + ((id >> 26) & 0x1f)); OutString[1] = (char) ('@' + ((id >> 21) & 0x1f)); OutString[2] = (char) ('@' + ((id >> 16) & 0x1f)); - OutString[3] = AcpiGbl_HexToAscii[(id >> 12) & 0xf]; - OutString[4] = AcpiGbl_HexToAscii[(id >> 8) & 0xf]; - OutString[5] = AcpiGbl_HexToAscii[(id >> 4) & 0xf]; - OutString[6] = AcpiGbl_HexToAscii[id & 0xf]; + OutString[3] = AcpiUtHexToAsciiChar (id, 12); + OutString[4] = AcpiUtHexToAsciiChar (id, 8); + OutString[5] = AcpiUtHexToAsciiChar (id, 4); + OutString[6] = AcpiUtHexToAsciiChar (id, 0); OutString[7] = 0; return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiExUnsignedIntegerToString * * PARAMETERS: Value - Value to be converted * OutString - Where to put the converted string (8 bytes) * * RETURN: Convert a number to string representation * ******************************************************************************/ ACPI_STATUS AcpiExUnsignedIntegerToString ( ACPI_INTEGER Value, NATIVE_CHAR *OutString) { UINT32 Count; UINT32 DigitsNeeded; DigitsNeeded = AcpiExDigitsNeeded (Value, 10); OutString[DigitsNeeded] = '\0'; for (Count = DigitsNeeded; Count > 0; Count--) { OutString[Count-1] = (NATIVE_CHAR) ('0' + (ACPI_MODULO (Value, 10))); Value = ACPI_DIVIDE (Value, 10); } return (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/hwacpi.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/hwacpi.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/hwacpi.c (revision 82367) @@ -1,447 +1,447 @@ /****************************************************************************** * * Module Name: hwacpi - ACPI Hardware Initialization/Mode Interface - * $Revision: 42 $ + * $Revision: 43 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __HWACPI_C__ #include "acpi.h" #include "achware.h" #define _COMPONENT ACPI_HARDWARE MODULE_NAME ("hwacpi") /****************************************************************************** * * FUNCTION: AcpiHwInitialize * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Initialize and validate various ACPI registers * ******************************************************************************/ ACPI_STATUS AcpiHwInitialize ( void) { ACPI_STATUS Status = AE_OK; UINT32 Index; FUNCTION_TRACE ("HwInitialize"); /* We must have the ACPI tables by the time we get here */ if (!AcpiGbl_FADT) { AcpiGbl_RestoreAcpiChipset = FALSE; - DEBUG_PRINTP (ACPI_ERROR, ("No FADT!\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No FADT!\n")); return_ACPI_STATUS (AE_NO_ACPI_TABLES); } /* Must support *some* mode! */ /* if (!(SystemFlags & SYS_MODES_MASK)) { RestoreAcpiChipset = FALSE; - DEBUG_PRINTP (ACPI_ERROR, - ("Supported modes uninitialized!\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Supported modes uninitialized!\n")); return_ACPI_STATUS (AE_ERROR); } */ switch (AcpiGbl_SystemFlags & SYS_MODES_MASK) { /* Identify current ACPI/legacy mode */ case (SYS_MODE_ACPI): AcpiGbl_OriginalMode = SYS_MODE_ACPI; - DEBUG_PRINTP (ACPI_INFO, ("System supports ACPI mode only.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "System supports ACPI mode only.\n")); break; case (SYS_MODE_LEGACY): AcpiGbl_OriginalMode = SYS_MODE_LEGACY; - DEBUG_PRINTP (ACPI_INFO, - ("Tables loaded from buffer, hardware assumed to support LEGACY mode only.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Tables loaded from buffer, hardware assumed to support LEGACY mode only.\n")); break; case (SYS_MODE_ACPI | SYS_MODE_LEGACY): if (AcpiHwGetMode () == SYS_MODE_ACPI) { AcpiGbl_OriginalMode = SYS_MODE_ACPI; } else { AcpiGbl_OriginalMode = SYS_MODE_LEGACY; } - DEBUG_PRINTP (ACPI_INFO, - ("System supports both ACPI and LEGACY modes.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "System supports both ACPI and LEGACY modes.\n")); - DEBUG_PRINTP (ACPI_INFO, - ("System is currently in %s mode.\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "System is currently in %s mode.\n", (AcpiGbl_OriginalMode == SYS_MODE_ACPI) ? "ACPI" : "LEGACY")); break; } if (AcpiGbl_SystemFlags & SYS_MODE_ACPI) { /* Target system supports ACPI mode */ /* * The purpose of this code is to save the initial state * of the ACPI event enable registers. An exit function will be * registered which will restore this state when the application * exits. The exit function will also clear all of the ACPI event * status bits prior to restoring the original mode. * * The location of the PM1aEvtBlk enable registers is defined as the * base of PM1aEvtBlk + DIV_2(PM1aEvtBlkLength). Since the spec further * fully defines the PM1aEvtBlk to be a total of 4 bytes, the offset * for the enable registers is always 2 from the base. It is hard * coded here. If this changes in the spec, this code will need to * be modified. The PM1bEvtBlk behaves as expected. */ AcpiGbl_Pm1EnableRegisterSave = (UINT16) AcpiHwRegisterRead ( ACPI_MTX_LOCK, PM1_EN); /* * The GPEs behave similarly, except that the length of the register * block is not fixed, so the buffer must be allocated with malloc */ if (ACPI_VALID_ADDRESS (AcpiGbl_FADT->XGpe0Blk.Address) && AcpiGbl_FADT->Gpe0BlkLen) { /* GPE0 specified in FADT */ AcpiGbl_Gpe0EnableRegisterSave = ACPI_MEM_ALLOCATE ( DIV_2 (AcpiGbl_FADT->Gpe0BlkLen)); if (!AcpiGbl_Gpe0EnableRegisterSave) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Save state of GPE0 enable bits */ for (Index = 0; Index < DIV_2 (AcpiGbl_FADT->Gpe0BlkLen); Index++) { AcpiGbl_Gpe0EnableRegisterSave[Index] = (UINT8) AcpiHwRegisterRead (ACPI_MTX_LOCK, GPE0_EN_BLOCK | Index); } } else { AcpiGbl_Gpe0EnableRegisterSave = NULL; } if (ACPI_VALID_ADDRESS (AcpiGbl_FADT->XGpe1Blk.Address) && AcpiGbl_FADT->Gpe1BlkLen) { /* GPE1 defined */ AcpiGbl_Gpe1EnableRegisterSave = ACPI_MEM_ALLOCATE ( DIV_2 (AcpiGbl_FADT->Gpe1BlkLen)); if (!AcpiGbl_Gpe1EnableRegisterSave) { return_ACPI_STATUS (AE_NO_MEMORY); } /* save state of GPE1 enable bits */ for (Index = 0; Index < DIV_2 (AcpiGbl_FADT->Gpe1BlkLen); Index++) { AcpiGbl_Gpe1EnableRegisterSave[Index] = (UINT8) AcpiHwRegisterRead (ACPI_MTX_LOCK, GPE1_EN_BLOCK | Index); } } else { AcpiGbl_Gpe1EnableRegisterSave = NULL; } } return_ACPI_STATUS (Status); } /****************************************************************************** * * FUNCTION: AcpiHwSetMode * * PARAMETERS: Mode - SYS_MODE_ACPI or SYS_MODE_LEGACY * * RETURN: Status * * DESCRIPTION: Transitions the system into the requested mode or does nothing * if the system is already in that mode. * ******************************************************************************/ ACPI_STATUS AcpiHwSetMode ( UINT32 Mode) { ACPI_STATUS Status = AE_NO_HARDWARE_RESPONSE; FUNCTION_TRACE ("HwSetMode"); if (Mode == SYS_MODE_ACPI) { /* BIOS should have disabled ALL fixed and GP events */ AcpiOsWritePort (AcpiGbl_FADT->SmiCmd, AcpiGbl_FADT->AcpiEnable, 8); - DEBUG_PRINTP (ACPI_INFO, ("Attempting to enable ACPI mode\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Attempting to enable ACPI mode\n")); } else if (Mode == SYS_MODE_LEGACY) { /* * BIOS should clear all fixed status bits and restore fixed event * enable bits to default */ AcpiOsWritePort (AcpiGbl_FADT->SmiCmd, AcpiGbl_FADT->AcpiDisable, 8); - DEBUG_PRINTP (ACPI_INFO, - ("Attempting to enable Legacy (non-ACPI) mode\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Attempting to enable Legacy (non-ACPI) mode\n")); } if (AcpiHwGetMode () == Mode) { - DEBUG_PRINTP (ACPI_INFO, ("Mode %X successfully enabled\n", Mode)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Mode %X successfully enabled\n", Mode)); Status = AE_OK; } return_ACPI_STATUS (Status); } /****************************************************************************** * * FUNCTION: AcpiHwGetMode * * PARAMETERS: none * * RETURN: SYS_MODE_ACPI or SYS_MODE_LEGACY * * DESCRIPTION: Return current operating state of system. Determined by * querying the SCI_EN bit. * ******************************************************************************/ UINT32 AcpiHwGetMode (void) { FUNCTION_TRACE ("HwGetMode"); if (AcpiHwRegisterBitAccess (ACPI_READ, ACPI_MTX_LOCK, SCI_EN)) { return_VALUE (SYS_MODE_ACPI); } else { return_VALUE (SYS_MODE_LEGACY); } } /****************************************************************************** * * FUNCTION: AcpiHwGetModeCapabilities * * PARAMETERS: none * * RETURN: logical OR of SYS_MODE_ACPI and SYS_MODE_LEGACY determined at initial * system state. * * DESCRIPTION: Returns capablities of system * ******************************************************************************/ UINT32 AcpiHwGetModeCapabilities (void) { FUNCTION_TRACE ("HwGetModeCapabilities"); if (!(AcpiGbl_SystemFlags & SYS_MODES_MASK)) { if (AcpiHwGetMode () == SYS_MODE_LEGACY) { /* * Assume that if this call is being made, AcpiInit has been called * and ACPI support has been established by the presence of the * tables. Therefore since we're in SYS_MODE_LEGACY, the system * must support both modes */ AcpiGbl_SystemFlags |= (SYS_MODE_ACPI | SYS_MODE_LEGACY); } else { /* TBD: [Investigate] !!! this may be unsafe... */ /* * system is is ACPI mode, so try to switch back to LEGACY to see if * it is supported */ AcpiHwSetMode (SYS_MODE_LEGACY); if (AcpiHwGetMode () == SYS_MODE_LEGACY) { /* Now in SYS_MODE_LEGACY, so both are supported */ AcpiGbl_SystemFlags |= (SYS_MODE_ACPI | SYS_MODE_LEGACY); AcpiHwSetMode (SYS_MODE_ACPI); } else { /* Still in SYS_MODE_ACPI so this must be an ACPI only system */ AcpiGbl_SystemFlags |= SYS_MODE_ACPI; } } } return_VALUE (AcpiGbl_SystemFlags & SYS_MODES_MASK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/hwregs.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/hwregs.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/hwregs.c (revision 82367) @@ -1,1089 +1,1093 @@ /******************************************************************************* * * Module Name: hwregs - Read/write access functions for the various ACPI * control and status registers. - * $Revision: 102 $ + * $Revision: 104 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __HWREGS_C__ #include "acpi.h" #include "achware.h" #include "acnamesp.h" #define _COMPONENT ACPI_HARDWARE MODULE_NAME ("hwregs") /* This matches the #defines in actypes.h. */ NATIVE_CHAR *SleepStateTable[] = {"\\_S0_","\\_S1_","\\_S2_","\\_S3_", "\\_S4_","\\_S5_","\\_S4B"}; /******************************************************************************* * * FUNCTION: AcpiHwGetBitShift * * PARAMETERS: Mask - Input mask to determine bit shift from. * Must have at least 1 bit set. * * RETURN: Bit location of the lsb of the mask * * DESCRIPTION: Returns the bit number for the low order bit that's set. * ******************************************************************************/ UINT32 AcpiHwGetBitShift ( UINT32 Mask) { UINT32 Shift; FUNCTION_TRACE ("HwGetBitShift"); for (Shift = 0; ((Mask >> Shift) & 1) == 0; Shift++) { ; } return_VALUE (Shift); } /******************************************************************************* * * FUNCTION: AcpiHwClearAcpiStatus * * PARAMETERS: none * * RETURN: none * * DESCRIPTION: Clears all fixed and general purpose status bits * ******************************************************************************/ void AcpiHwClearAcpiStatus (void) { UINT16 GpeLength; UINT16 Index; FUNCTION_TRACE ("HwClearAcpiStatus"); - DEBUG_PRINTP (TRACE_IO, ("About to write %04X to %04X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %04X\n", ALL_FIXED_STS_BITS, (UINT16) ACPI_GET_ADDRESS (AcpiGbl_FADT->XPm1aEvtBlk.Address))); AcpiUtAcquireMutex (ACPI_MTX_HARDWARE); AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, PM1_STS, ALL_FIXED_STS_BITS); if (ACPI_VALID_ADDRESS (AcpiGbl_FADT->XPm1bEvtBlk.Address)) { AcpiOsWritePort ((ACPI_IO_ADDRESS) ACPI_GET_ADDRESS (AcpiGbl_FADT->XPm1bEvtBlk.Address), ALL_FIXED_STS_BITS, 16); } /* now clear the GPE Bits */ if (AcpiGbl_FADT->Gpe0BlkLen) { GpeLength = (UINT16) DIV_2 (AcpiGbl_FADT->Gpe0BlkLen); for (Index = 0; Index < GpeLength; Index++) { AcpiOsWritePort ((ACPI_IO_ADDRESS) ( ACPI_GET_ADDRESS (AcpiGbl_FADT->XGpe0Blk.Address) + Index), 0xFF, 8); } } if (AcpiGbl_FADT->Gpe1BlkLen) { GpeLength = (UINT16) DIV_2 (AcpiGbl_FADT->Gpe1BlkLen); for (Index = 0; Index < GpeLength; Index++) { AcpiOsWritePort ((ACPI_IO_ADDRESS) ( ACPI_GET_ADDRESS (AcpiGbl_FADT->XGpe1Blk.Address) + Index), 0xFF, 8); } } AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiHwObtainSleepTypeRegisterData * * PARAMETERS: SleepState - Numeric state requested * *Slp_TypA - Pointer to byte to receive SLP_TYPa value * *Slp_TypB - Pointer to byte to receive SLP_TYPb value * * RETURN: Status - ACPI status * * DESCRIPTION: AcpiHwObtainSleepTypeRegisterData() obtains the SLP_TYP and * SLP_TYPb values for the sleep state requested. * ******************************************************************************/ ACPI_STATUS AcpiHwObtainSleepTypeRegisterData ( UINT8 SleepState, UINT8 *Slp_TypA, UINT8 *Slp_TypB) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *ObjDesc; FUNCTION_TRACE ("HwObtainSleepTypeRegisterData"); /* * Validate parameters */ if ((SleepState > ACPI_S_STATES_MAX) || !Slp_TypA || !Slp_TypB) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* * AcpiEvaluate the namespace object containing the values for this state */ Status = AcpiNsEvaluateByName (SleepStateTable[SleepState], NULL, &ObjDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } if (!ObjDesc) { REPORT_ERROR (("Missing Sleep State object\n")); return_ACPI_STATUS (AE_NOT_EXIST); } /* * We got something, now ensure it is correct. The object must * be a package and must have at least 2 numeric values as the * two elements */ /* Even though AcpiEvaluateObject resolves package references, * NsEvaluate dpesn't. So, we do it here. */ Status = AcpiUtResolvePackageReferences(ObjDesc); if (ObjDesc->Package.Count < 2) { /* Must have at least two elements */ REPORT_ERROR (("Sleep State package does not have at least two elements\n")); Status = AE_ERROR; } else if (((ObjDesc->Package.Elements[0])->Common.Type != ACPI_TYPE_INTEGER) || ((ObjDesc->Package.Elements[1])->Common.Type != ACPI_TYPE_INTEGER)) { /* Must have two */ REPORT_ERROR (("Sleep State package elements are not both of type Number\n")); Status = AE_ERROR; } else { /* * Valid _Sx_ package size, type, and value */ *Slp_TypA = (UINT8) (ObjDesc->Package.Elements[0])->Integer.Value; *Slp_TypB = (UINT8) (ObjDesc->Package.Elements[1])->Integer.Value; } if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("Bad Sleep object %p type %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Bad Sleep object %p type %X\n", ObjDesc, ObjDesc->Common.Type)); } AcpiUtRemoveReference (ObjDesc); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiHwRegisterBitAccess * * PARAMETERS: ReadWrite - Either ACPI_READ or ACPI_WRITE. * UseLock - Lock the hardware * RegisterId - index of ACPI Register to access * Value - (only used on write) value to write to the * Register. Shifted all the way right. * * RETURN: Value written to or read from specified Register. This value * is shifted all the way right. * * DESCRIPTION: Generic ACPI Register read/write function. * ******************************************************************************/ UINT32 AcpiHwRegisterBitAccess ( NATIVE_UINT ReadWrite, BOOLEAN UseLock, UINT32 RegisterId, ...) /* Value (only used on write) */ { UINT32 RegisterValue = 0; UINT32 Mask = 0; UINT32 Value = 0; va_list marker; FUNCTION_TRACE ("HwRegisterBitAccess"); if (ReadWrite == ACPI_WRITE) { va_start (marker, RegisterId); Value = va_arg (marker, UINT32); va_end (marker); } if (ACPI_MTX_LOCK == UseLock) { AcpiUtAcquireMutex (ACPI_MTX_HARDWARE); } /* * Decode the Register ID * Register id = Register block id | bit id * * Check bit id to fine locate Register offset. * Check Mask to determine Register offset, and then read-write. */ switch (REGISTER_BLOCK_ID (RegisterId)) { case PM1_STS: switch (RegisterId) { case TMR_STS: Mask = TMR_STS_MASK; break; case BM_STS: Mask = BM_STS_MASK; break; case GBL_STS: Mask = GBL_STS_MASK; break; case PWRBTN_STS: Mask = PWRBTN_STS_MASK; break; case SLPBTN_STS: Mask = SLPBTN_STS_MASK; break; case RTC_STS: Mask = RTC_STS_MASK; break; case WAK_STS: Mask = WAK_STS_MASK; break; default: Mask = 0; break; } RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, PM1_STS); if (ReadWrite == ACPI_WRITE) { /* * Status Registers are different from the rest. Clear by * writing 1, writing 0 has no effect. So, the only relevent * information is the single bit we're interested in, all * others should be written as 0 so they will be left * unchanged */ Value <<= AcpiHwGetBitShift (Mask); Value &= Mask; if (Value) { AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, PM1_STS, (UINT16) Value); RegisterValue = 0; } } break; case PM1_EN: switch (RegisterId) { case TMR_EN: Mask = TMR_EN_MASK; break; case GBL_EN: Mask = GBL_EN_MASK; break; case PWRBTN_EN: Mask = PWRBTN_EN_MASK; break; case SLPBTN_EN: Mask = SLPBTN_EN_MASK; break; case RTC_EN: Mask = RTC_EN_MASK; break; default: Mask = 0; break; } RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, PM1_EN); if (ReadWrite == ACPI_WRITE) { RegisterValue &= ~Mask; Value <<= AcpiHwGetBitShift (Mask); Value &= Mask; RegisterValue |= Value; AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, PM1_EN, (UINT16) RegisterValue); } break; case PM1_CONTROL: switch (RegisterId) { case SCI_EN: Mask = SCI_EN_MASK; break; case BM_RLD: Mask = BM_RLD_MASK; break; case GBL_RLS: Mask = GBL_RLS_MASK; break; case SLP_TYPE_A: case SLP_TYPE_B: Mask = SLP_TYPE_X_MASK; break; case SLP_EN: Mask = SLP_EN_MASK; break; default: Mask = 0; break; } /* * Read the PM1 Control register. * Note that at this level, the fact that there are actually TWO * registers (A and B) and that B may not exist, are abstracted. */ RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, PM1_CONTROL); - DEBUG_PRINT (TRACE_IO, ("PM1 control: Read %X\n", RegisterValue)); + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "PM1 control: Read %X\n", RegisterValue)); if (ReadWrite == ACPI_WRITE) { RegisterValue &= ~Mask; Value <<= AcpiHwGetBitShift (Mask); Value &= Mask; RegisterValue |= Value; /* * SLP_TYPE_x Registers are written differently * than any other control Registers with * respect to A and B Registers. The value * for A may be different than the value for B * * Therefore, pass the RegisterId, not just generic PM1_CONTROL, * because we need to do different things. Yuck. */ AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, RegisterId, (UINT16) RegisterValue); } break; case PM2_CONTROL: switch (RegisterId) { case ARB_DIS: Mask = ARB_DIS_MASK; break; default: Mask = 0; break; } RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, PM2_CONTROL); - DEBUG_PRINT (TRACE_IO, ("PM2 control: Read %X from %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "PM2 control: Read %X from %p\n", RegisterValue, ACPI_GET_ADDRESS (AcpiGbl_FADT->XPm2CntBlk.Address))); if (ReadWrite == ACPI_WRITE) { RegisterValue &= ~Mask; Value <<= AcpiHwGetBitShift (Mask); Value &= Mask; RegisterValue |= Value; - DEBUG_PRINT (TRACE_IO, ("About to write %04X to %p\n", RegisterValue, + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %p\n", RegisterValue, AcpiGbl_FADT->XPm2CntBlk.Address)); AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, PM2_CONTROL, (UINT8) (RegisterValue)); } break; case PM_TIMER: Mask = TMR_VAL_MASK; RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, PM_TIMER); - DEBUG_PRINT (TRACE_IO, ("PM_TIMER: Read %X from %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "PM_TIMER: Read %X from %p\n", RegisterValue, ACPI_GET_ADDRESS (AcpiGbl_FADT->XPmTmrBlk.Address))); break; case GPE1_EN_BLOCK: case GPE1_STS_BLOCK: case GPE0_EN_BLOCK: case GPE0_STS_BLOCK: /* Determine the bit to be accessed * * (UINT32) RegisterId: * 31 24 16 8 0 * +--------+--------+--------+--------+ * | gpe_block_id | gpe_bit_number | * +--------+--------+--------+--------+ * * gpe_block_id is one of GPE[01]_EN_BLOCK and GPE[01]_STS_BLOCK * gpe_bit_number is relative from the gpe_block (0x00~0xFF) */ Mask = REGISTER_BIT_ID(RegisterId); /* gpe_bit_number */ RegisterId = REGISTER_BLOCK_ID(RegisterId) | (Mask >> 3); Mask = AcpiGbl_DecodeTo8bit [Mask % 8]; /* * The base address of the GPE 0 Register Block * Plus 1/2 the length of the GPE 0 Register Block * The enable Register is the Register following the Status Register * and each Register is defined as 1/2 of the total Register Block */ /* * This sets the bit within EnableBit that needs to be written to * the Register indicated in Mask to a 1, all others are 0 */ /* Now get the current Enable Bits in the selected Reg */ RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, RegisterId); - DEBUG_PRINT (TRACE_IO, ("GPE Enable bits: Read %X from %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "GPE Enable bits: Read %X from %X\n", RegisterValue, RegisterId)); if (ReadWrite == ACPI_WRITE) { RegisterValue &= ~Mask; Value <<= AcpiHwGetBitShift (Mask); Value &= Mask; RegisterValue |= Value; /* This write will put the Action state into the General Purpose */ /* Enable Register indexed by the value in Mask */ - DEBUG_PRINT (TRACE_IO, ("About to write %04X to %04X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %04X\n", RegisterValue, RegisterId)); AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, RegisterId, (UINT8) RegisterValue); RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, RegisterId); } break; case SMI_CMD_BLOCK: case PROCESSOR_BLOCK: /* Not used by any callers at this time - therefore, not implemented */ default: Mask = 0; break; } if (ACPI_MTX_LOCK == UseLock) { AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); } RegisterValue &= Mask; RegisterValue >>= AcpiHwGetBitShift (Mask); - DEBUG_PRINT (TRACE_IO, ("Register I/O: returning %X\n", RegisterValue)); + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "Register I/O: returning %X\n", RegisterValue)); return_VALUE (RegisterValue); } /****************************************************************************** * * FUNCTION: AcpiHwRegisterRead * * PARAMETERS: UseLock - Mutex hw access. * RegisterId - RegisterID + Offset. * * RETURN: Value read or written. * * DESCRIPTION: Acpi register read function. Registers are read at the * given offset. * ******************************************************************************/ UINT32 AcpiHwRegisterRead ( BOOLEAN UseLock, UINT32 RegisterId) { UINT32 Value = 0; UINT32 BankOffset; FUNCTION_TRACE ("AcpiHwRegisterRead"); if (ACPI_MTX_LOCK == UseLock) { AcpiUtAcquireMutex (ACPI_MTX_HARDWARE); } switch (REGISTER_BLOCK_ID(RegisterId)) { case PM1_STS: /* 16-bit access */ Value = AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1aEvtBlk, 0); Value |= AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1bEvtBlk, 0); break; case PM1_EN: /* 16-bit access*/ BankOffset = DIV_2 (AcpiGbl_FADT->Pm1EvtLen); Value = AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1aEvtBlk, BankOffset); Value |= AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1bEvtBlk, BankOffset); break; case PM1_CONTROL: /* 16-bit access */ Value = AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1aCntBlk, 0); Value |= AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1bCntBlk, 0); break; case PM2_CONTROL: /* 8-bit access */ Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XPm2CntBlk, 0); break; case PM_TIMER: /* 32-bit access */ Value = AcpiHwLowLevelRead (32, &AcpiGbl_FADT->XPmTmrBlk, 0); break; + /* + * For the GPE? Blocks, the lower word of RegisterId contains the + * byte offset for which to read, as each part of each block may be + * several bytes long. + */ case GPE0_STS_BLOCK: /* 8-bit access */ - Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe0Blk, 0); + BankOffset = REGISTER_BIT_ID(RegisterId); + Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe0Blk, BankOffset); break; - case GPE0_EN_BLOCK: /* 8-bit access */ - BankOffset = DIV_2 (AcpiGbl_FADT->Gpe0BlkLen); - Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe0Blk, BankOffset); + BankOffset = DIV_2 (AcpiGbl_FADT->Gpe0BlkLen) + REGISTER_BIT_ID(RegisterId); + Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe0Blk, BankOffset); break; - case GPE1_STS_BLOCK: /* 8-bit access */ - Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe1Blk, 0); + BankOffset = REGISTER_BIT_ID(RegisterId); + Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe1Blk, BankOffset); break; - case GPE1_EN_BLOCK: /* 8-bit access */ - BankOffset = DIV_2 (AcpiGbl_FADT->Gpe1BlkLen); - Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe1Blk, BankOffset); + BankOffset = DIV_2 (AcpiGbl_FADT->Gpe1BlkLen) + REGISTER_BIT_ID(RegisterId); + Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe1Blk, BankOffset); break; - case SMI_CMD_BLOCK: /* 8bit */ AcpiOsReadPort (AcpiGbl_FADT->SmiCmd, &Value, 8); break; - default: /* Value will be returned as 0 */ break; } if (ACPI_MTX_LOCK == UseLock) { AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); } return_VALUE (Value); } /****************************************************************************** * * FUNCTION: AcpiHwRegisterWrite * * PARAMETERS: UseLock - Mutex hw access. * RegisterId - RegisterID + Offset. * * RETURN: Value read or written. * * DESCRIPTION: Acpi register Write function. Registers are written at the * given offset. * ******************************************************************************/ void AcpiHwRegisterWrite ( BOOLEAN UseLock, UINT32 RegisterId, UINT32 Value) { UINT32 BankOffset; FUNCTION_TRACE ("AcpiHwRegisterWrite"); if (ACPI_MTX_LOCK == UseLock) { AcpiUtAcquireMutex (ACPI_MTX_HARDWARE); } switch (REGISTER_BLOCK_ID (RegisterId)) { case PM1_STS: /* 16-bit access */ AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1aEvtBlk, 0); AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1bEvtBlk, 0); break; case PM1_EN: /* 16-bit access*/ BankOffset = DIV_2 (AcpiGbl_FADT->Pm1EvtLen); AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1aEvtBlk, BankOffset); AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1bEvtBlk, BankOffset); break; case PM1_CONTROL: /* 16-bit access */ AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1aCntBlk, 0); AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1bCntBlk, 0); break; case PM1A_CONTROL: /* 16-bit access */ AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1aCntBlk, 0); break; case PM1B_CONTROL: /* 16-bit access */ AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1bCntBlk, 0); break; case PM2_CONTROL: /* 8-bit access */ AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XPm2CntBlk, 0); break; case PM_TIMER: /* 32-bit access */ AcpiHwLowLevelWrite (32, Value, &AcpiGbl_FADT->XPmTmrBlk, 0); break; case GPE0_STS_BLOCK: /* 8-bit access */ - AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XGpe0Blk, 0); + BankOffset = REGISTER_BIT_ID(RegisterId); + AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XGpe0Blk, BankOffset); break; case GPE0_EN_BLOCK: /* 8-bit access */ - BankOffset = DIV_2 (AcpiGbl_FADT->Gpe0BlkLen); + BankOffset = DIV_2 (AcpiGbl_FADT->Gpe0BlkLen) + REGISTER_BIT_ID(RegisterId); AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XGpe0Blk, BankOffset); break; case GPE1_STS_BLOCK: /* 8-bit access */ - AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XGpe1Blk, 0); + BankOffset = REGISTER_BIT_ID(RegisterId); + AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XGpe1Blk, BankOffset); break; case GPE1_EN_BLOCK: /* 8-bit access */ - BankOffset = DIV_2 (AcpiGbl_FADT->Gpe1BlkLen); + BankOffset = DIV_2 (AcpiGbl_FADT->Gpe1BlkLen) + REGISTER_BIT_ID(RegisterId); AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XGpe1Blk, BankOffset); break; case SMI_CMD_BLOCK: /* 8bit */ /* For 2.0, SMI_CMD is always in IO space */ /* TBD: what about 1.0? 0.71? */ AcpiOsWritePort (AcpiGbl_FADT->SmiCmd, Value, 8); break; default: Value = 0; break; } if (ACPI_MTX_LOCK == UseLock) { AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); } return_VOID; } /****************************************************************************** * * FUNCTION: AcpiHwLowLevelRead * * PARAMETERS: Register - GAS register structure * Offset - Offset from the base address in the GAS * Width - 8, 16, or 32 * * RETURN: Value read * * DESCRIPTION: Read from either memory, IO, or PCI config space. * ******************************************************************************/ UINT32 AcpiHwLowLevelRead ( UINT32 Width, ACPI_GENERIC_ADDRESS *Reg, UINT32 Offset) { UINT32 Value = 0; ACPI_PHYSICAL_ADDRESS MemAddress; ACPI_IO_ADDRESS IoAddress; ACPI_PCI_ID PciId; UINT16 PciRegister; /* * Must have a valid pointer to a GAS structure, and * a non-zero address within */ if ((!Reg) || (!ACPI_VALID_ADDRESS (Reg->Address))) { return 0; } /* * Three address spaces supported: * Memory, Io, or PCI config. */ switch (Reg->AddressSpaceId) { case ACPI_ADR_SPACE_SYSTEM_MEMORY: MemAddress = (ACPI_PHYSICAL_ADDRESS) (ACPI_GET_ADDRESS (Reg->Address) + Offset); AcpiOsReadMemory (MemAddress, &Value, Width); break; case ACPI_ADR_SPACE_SYSTEM_IO: IoAddress = (ACPI_IO_ADDRESS) (ACPI_GET_ADDRESS (Reg->Address) + Offset); AcpiOsReadPort (IoAddress, &Value, Width); break; case ACPI_ADR_SPACE_PCI_CONFIG: PciId.Segment = 0; PciId.Bus = 0; PciId.Device = ACPI_PCI_DEVICE (ACPI_GET_ADDRESS (Reg->Address)); PciId.Function = ACPI_PCI_FUNCTION (ACPI_GET_ADDRESS (Reg->Address)); PciRegister = (UINT16) (ACPI_PCI_REGISTER (ACPI_GET_ADDRESS (Reg->Address)) + Offset); AcpiOsReadPciConfiguration (&PciId, PciRegister, &Value, Width); break; } return Value; } /****************************************************************************** * * FUNCTION: AcpiHwLowLevelWrite * * PARAMETERS: Width - 8, 16, or 32 * Value - To be written * Register - GAS register structure * Offset - Offset from the base address in the GAS * * * RETURN: Value read * * DESCRIPTION: Read from either memory, IO, or PCI config space. * ******************************************************************************/ void AcpiHwLowLevelWrite ( UINT32 Width, UINT32 Value, ACPI_GENERIC_ADDRESS *Reg, UINT32 Offset) { ACPI_PHYSICAL_ADDRESS MemAddress; ACPI_IO_ADDRESS IoAddress; ACPI_PCI_ID PciId; UINT16 PciRegister; /* * Must have a valid pointer to a GAS structure, and * a non-zero address within */ if ((!Reg) || (!ACPI_VALID_ADDRESS (Reg->Address))) { return; } /* * Three address spaces supported: * Memory, Io, or PCI config. */ switch (Reg->AddressSpaceId) { case ACPI_ADR_SPACE_SYSTEM_MEMORY: MemAddress = (ACPI_PHYSICAL_ADDRESS) (ACPI_GET_ADDRESS (Reg->Address) + Offset); AcpiOsWriteMemory (MemAddress, Value, Width); break; case ACPI_ADR_SPACE_SYSTEM_IO: IoAddress = (ACPI_IO_ADDRESS) (ACPI_GET_ADDRESS (Reg->Address) + Offset); AcpiOsWritePort (IoAddress, Value, Width); break; case ACPI_ADR_SPACE_PCI_CONFIG: PciId.Segment = 0; PciId.Bus = 0; PciId.Device = ACPI_PCI_DEVICE (ACPI_GET_ADDRESS (Reg->Address)); PciId.Function = ACPI_PCI_FUNCTION (ACPI_GET_ADDRESS (Reg->Address)); PciRegister = (UINT16) (ACPI_PCI_REGISTER (ACPI_GET_ADDRESS (Reg->Address)) + Offset); AcpiOsWritePciConfiguration (&PciId, PciRegister, Value, Width); break; } } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/hwsleep.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/hwsleep.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/hwsleep.c (revision 82367) @@ -1,309 +1,367 @@ /****************************************************************************** * * Name: hwsleep.c - ACPI Hardware Sleep/Wake Interface - * $Revision: 14 $ + * $Revision: 18 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acnamesp.h" #include "achware.h" #define _COMPONENT ACPI_HARDWARE MODULE_NAME ("hwsleep") /****************************************************************************** * * FUNCTION: AcpiSetFirmwareWakingVector * * PARAMETERS: PhysicalAddress - Physical address of ACPI real mode * entry point. * * RETURN: AE_OK or AE_ERROR * * DESCRIPTION: Access function for dFirmwareWakingVector field in FACS * ******************************************************************************/ ACPI_STATUS AcpiSetFirmwareWakingVector ( ACPI_PHYSICAL_ADDRESS PhysicalAddress) { FUNCTION_TRACE ("AcpiSetFirmwareWakingVector"); /* Make sure that we have an FACS */ if (!AcpiGbl_FACS) { return_ACPI_STATUS (AE_NO_ACPI_TABLES); } /* Set the vector */ if (AcpiGbl_FACS->VectorWidth == 32) { * (UINT32 *) AcpiGbl_FACS->FirmwareWakingVector = (UINT32) PhysicalAddress; } else { *AcpiGbl_FACS->FirmwareWakingVector = PhysicalAddress; } return_ACPI_STATUS (AE_OK); } /****************************************************************************** * * FUNCTION: AcpiGetFirmwareWakingVector * * PARAMETERS: *PhysicalAddress - Output buffer where contents of * the FirmwareWakingVector field of * the FACS will be stored. * * RETURN: Status * * DESCRIPTION: Access function for dFirmwareWakingVector field in FACS * ******************************************************************************/ ACPI_STATUS AcpiGetFirmwareWakingVector ( ACPI_PHYSICAL_ADDRESS *PhysicalAddress) { FUNCTION_TRACE ("AcpiGetFirmwareWakingVector"); if (!PhysicalAddress) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Make sure that we have an FACS */ if (!AcpiGbl_FACS) { return_ACPI_STATUS (AE_NO_ACPI_TABLES); } /* Get the vector */ if (AcpiGbl_FACS->VectorWidth == 32) { *PhysicalAddress = * (UINT32 *) AcpiGbl_FACS->FirmwareWakingVector; } else { *PhysicalAddress = *AcpiGbl_FACS->FirmwareWakingVector; } return_ACPI_STATUS (AE_OK); } /****************************************************************************** * * FUNCTION: AcpiEnterSleepState * * PARAMETERS: SleepState - Which sleep state to enter * * RETURN: Status * * DESCRIPTION: Enter a system sleep state (see ACPI 2.0 spec p 231) * ******************************************************************************/ ACPI_STATUS AcpiEnterSleepState ( UINT8 SleepState) { ACPI_STATUS Status; ACPI_OBJECT_LIST ArgList; ACPI_OBJECT Arg; UINT8 TypeA; UINT8 TypeB; UINT16 PM1AControl; UINT16 PM1BControl; FUNCTION_TRACE ("AcpiEnterSleepState"); /* * _PSW methods could be run here to enable wake-on keyboard, LAN, etc. */ Status = AcpiHwObtainSleepTypeRegisterData (SleepState, &TypeA, &TypeB); if (!ACPI_SUCCESS (Status)) { return Status; } /* run the _PTS and _GTS methods */ MEMSET(&ArgList, 0, sizeof(ArgList)); ArgList.Count = 1; ArgList.Pointer = &Arg; MEMSET(&Arg, 0, sizeof(Arg)); Arg.Type = ACPI_TYPE_INTEGER; Arg.Integer.Value = SleepState; - AcpiEvaluateObject(NULL, "\\_PTS", &ArgList, NULL); - AcpiEvaluateObject(NULL, "\\_GTS", &ArgList, NULL); + AcpiEvaluateObject (NULL, "\\_PTS", &ArgList, NULL); + AcpiEvaluateObject (NULL, "\\_GTS", &ArgList, NULL); /* clear wake status */ - AcpiHwRegisterBitAccess(ACPI_WRITE, ACPI_MTX_LOCK, WAK_STS, 1); + AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, WAK_STS, 1); - disable(); + disable (); - PM1AControl = (UINT16) AcpiHwRegisterRead(ACPI_MTX_LOCK, PM1_CONTROL); + /* TODO: disable all non-wake GPEs here */ - DEBUG_PRINT(ACPI_OK, ("Entering S%d\n", SleepState)); + PM1AControl = (UINT16) AcpiHwRegisterRead (ACPI_MTX_LOCK, PM1_CONTROL); + ACPI_DEBUG_PRINT ((ACPI_DB_OK, "Entering S%d\n", SleepState)); + /* mask off SLP_EN and SLP_TYP fields */ - PM1AControl &= 0xC3FF; + + PM1AControl &= ~(SLP_TYPE_X_MASK | SLP_EN_MASK); PM1BControl = PM1AControl; /* mask in SLP_TYP */ + PM1AControl |= (TypeA << AcpiHwGetBitShift (SLP_TYPE_X_MASK)); PM1BControl |= (TypeB << AcpiHwGetBitShift (SLP_TYPE_X_MASK)); /* write #1: fill in SLP_TYP data */ - AcpiHwRegisterWrite(ACPI_MTX_LOCK, PM1A_CONTROL, PM1AControl); - AcpiHwRegisterWrite(ACPI_MTX_LOCK, PM1B_CONTROL, PM1BControl); + AcpiHwRegisterWrite (ACPI_MTX_LOCK, PM1A_CONTROL, PM1AControl); + AcpiHwRegisterWrite (ACPI_MTX_LOCK, PM1B_CONTROL, PM1BControl); + /* mask in SLP_EN */ + PM1AControl |= (1 << AcpiHwGetBitShift (SLP_EN_MASK)); PM1BControl |= (1 << AcpiHwGetBitShift (SLP_EN_MASK)); + /* flush caches */ + + wbinvd(); + /* write #2: SLP_TYP + SLP_EN */ - AcpiHwRegisterWrite(ACPI_MTX_LOCK, PM1A_CONTROL, PM1AControl); - AcpiHwRegisterWrite(ACPI_MTX_LOCK, PM1B_CONTROL, PM1BControl); - /* wait a second, then try again */ - AcpiOsStall(1000000); + AcpiHwRegisterWrite (ACPI_MTX_LOCK, PM1A_CONTROL, PM1AControl); + AcpiHwRegisterWrite (ACPI_MTX_LOCK, PM1B_CONTROL, PM1BControl); - if (SleepState > ACPI_STATE_S1) { - AcpiHwRegisterWrite(ACPI_MTX_LOCK, PM1_CONTROL, - (1 << AcpiHwGetBitShift (SLP_EN_MASK))); + /* + * Wait a second, then try again. This is to get S4/5 to work on all machines. + */ + if (SleepState > ACPI_STATE_S3) + { + AcpiOsStall(1000000); + + AcpiHwRegisterWrite (ACPI_MTX_LOCK, PM1_CONTROL, + (1 << AcpiHwGetBitShift (SLP_EN_MASK))); } - enable(); + /* wait until we enter sleep state */ + + while (!AcpiHwRegisterBitAccess (ACPI_READ,ACPI_MTX_LOCK,WAK_STS)) + { } + + enable (); + + return_ACPI_STATUS (AE_OK); +} + +/****************************************************************************** + * + * FUNCTION: AcpiLeaveSleepState + * + * PARAMETERS: SleepState - Which sleep state we just exited + * + * RETURN: Status + * + * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep + * + ******************************************************************************/ + +ACPI_STATUS +AcpiLeaveSleepState ( + UINT8 SleepState) +{ + ACPI_OBJECT_LIST ArgList; + ACPI_OBJECT Arg; + + FUNCTION_TRACE ("AcpiLeaveSleepState"); + + + MEMSET (&ArgList, 0, sizeof(ArgList)); + ArgList.Count = 1; + ArgList.Pointer = &Arg; + + MEMSET (&Arg, 0, sizeof(Arg)); + Arg.Type = ACPI_TYPE_INTEGER; + Arg.Integer.Value = SleepState; + + AcpiEvaluateObject (NULL, "\\_BFS", &ArgList, NULL); + AcpiEvaluateObject (NULL, "\\_WAK", &ArgList, NULL); + /* _WAK returns stuff - do we want to look at it? */ + + /* Re-enable GPEs */ return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsaccess.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsaccess.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsaccess.c (revision 82367) @@ -1,733 +1,722 @@ /******************************************************************************* * * Module Name: nsaccess - Top-level functions for accessing ACPI namespace - * $Revision: 128 $ + * $Revision: 130 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSACCESS_C__ #include "acpi.h" #include "amlcode.h" #include "acinterp.h" #include "acnamesp.h" #include "acdispat.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nsaccess") /******************************************************************************* * * FUNCTION: AcpiNsRootInitialize * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Allocate and initialize the default root named objects * * MUTEX: Locks namespace for entire execution * ******************************************************************************/ ACPI_STATUS AcpiNsRootInitialize (void) { ACPI_STATUS Status = AE_OK; PREDEFINED_NAMES *InitVal = NULL; ACPI_NAMESPACE_NODE *NewNode; ACPI_OPERAND_OBJECT *ObjDesc; FUNCTION_TRACE ("NsRootInitialize"); AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); /* * The global root ptr is initially NULL, so a non-NULL value indicates * that AcpiNsRootInitialize() has already been called; just return. */ if (AcpiGbl_RootNode) { Status = AE_OK; goto UnlockAndExit; } /* * Tell the rest of the subsystem that the root is initialized * (This is OK because the namespace is locked) */ AcpiGbl_RootNode = &AcpiGbl_RootNodeStruct; /* Enter the pre-defined names in the name table */ - DEBUG_PRINTP (ACPI_INFO, ("Entering predefined entries into namespace\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Entering predefined entries into namespace\n")); for (InitVal = AcpiGbl_PreDefinedNames; InitVal->Name; InitVal++) { Status = AcpiNsLookup (NULL, InitVal->Name, InitVal->Type, IMODE_LOAD_PASS2, NS_NO_UPSEARCH, NULL, &NewNode); if (ACPI_FAILURE (Status) || (!NewNode)) /* Must be on same line for code converter */ { - DEBUG_PRINTP (ACPI_ERROR, - ("Could not create predefined name %s, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Could not create predefined name %s, %s\n", InitVal->Name, AcpiFormatException (Status))); } /* * Name entered successfully. * If entry in PreDefinedNames[] specifies an * initial value, create the initial value. */ if (InitVal->Val) { /* * Entry requests an initial value, allocate a * descriptor for it. */ ObjDesc = AcpiUtCreateInternalObject (InitVal->Type); if (!ObjDesc) { Status = AE_NO_MEMORY; goto UnlockAndExit; } /* * Convert value string from table entry to * internal representation. Only types actually * used for initial values are implemented here. */ switch (InitVal->Type) { case ACPI_TYPE_INTEGER: ObjDesc->Integer.Value = (ACPI_INTEGER) STRTOUL (InitVal->Val, NULL, 10); break; case ACPI_TYPE_STRING: - ObjDesc->String.Length = STRLEN (InitVal->Val); - /* - * Allocate a buffer for the string. All - * String.Pointers must be allocated buffers! - * (makes deletion simpler) + * Build an object around the static string */ - ObjDesc->String.Pointer = ACPI_MEM_ALLOCATE ( - (ObjDesc->String.Length + 1)); - if (!ObjDesc->String.Pointer) - { - AcpiUtRemoveReference (ObjDesc); - Status = AE_NO_MEMORY; - goto UnlockAndExit; - } - - STRCPY (ObjDesc->String.Pointer, InitVal->Val); + ObjDesc->String.Length = STRLEN (InitVal->Val); + ObjDesc->String.Pointer = InitVal->Val; + ObjDesc->Common.Flags |= AOPOBJ_STATIC_POINTER; break; case ACPI_TYPE_MUTEX: ObjDesc->Mutex.SyncLevel = (UINT16) STRTOUL (InitVal->Val, NULL, 10); if (STRCMP (InitVal->Name, "_GL_") == 0) { /* * Create a counting semaphore for the * global lock */ Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 1, &ObjDesc->Mutex.Semaphore); if (ACPI_FAILURE (Status)) { goto UnlockAndExit; } /* * We just created the mutex for the * global lock, save it */ AcpiGbl_GlobalLockSemaphore = ObjDesc->Mutex.Semaphore; } else { /* Create a mutex */ Status = AcpiOsCreateSemaphore (1, 1, &ObjDesc->Mutex.Semaphore); if (ACPI_FAILURE (Status)) { goto UnlockAndExit; } } break; default: REPORT_ERROR (("Unsupported initial type value %X\n", InitVal->Type)); AcpiUtRemoveReference (ObjDesc); ObjDesc = NULL; continue; } /* Store pointer to value descriptor in the Node */ AcpiNsAttachObject (NewNode, ObjDesc, ObjDesc->Common.Type); } } UnlockAndExit: AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsLookup * * PARAMETERS: PrefixNode - Search scope if name is not fully qualified * Pathname - Search pathname, in internal format * (as represented in the AML stream) * Type - Type associated with name * InterpreterMode - IMODE_LOAD_PASS2 => add name if not found * Flags - Flags describing the search restrictions * WalkState - Current state of the walk * ReturnNode - Where the Node is placed (if found * or created successfully) * * RETURN: Status * * DESCRIPTION: Find or enter the passed name in the name space. * Log an error if name not found in Exec mode. * * MUTEX: Assumes namespace is locked. * ******************************************************************************/ ACPI_STATUS AcpiNsLookup ( ACPI_GENERIC_STATE *ScopeInfo, NATIVE_CHAR *Pathname, ACPI_OBJECT_TYPE8 Type, OPERATING_MODE InterpreterMode, UINT32 Flags, ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE **ReturnNode) { ACPI_STATUS Status; ACPI_NAMESPACE_NODE *PrefixNode; ACPI_NAMESPACE_NODE *CurrentNode = NULL; ACPI_NAMESPACE_NODE *ScopeToPush = NULL; ACPI_NAMESPACE_NODE *ThisNode = NULL; UINT32 NumSegments; ACPI_NAME SimpleName; BOOLEAN NullNamePath = FALSE; ACPI_OBJECT_TYPE8 TypeToCheckFor; ACPI_OBJECT_TYPE8 ThisSearchType; UINT32 LocalFlags = Flags & ~NS_ERROR_IF_FOUND; DEBUG_EXEC (UINT32 i;) FUNCTION_TRACE ("NsLookup"); if (!ReturnNode) { return_ACPI_STATUS (AE_BAD_PARAMETER); } AcpiGbl_NsLookupCount++; *ReturnNode = ENTRY_NOT_FOUND; if (!AcpiGbl_RootNode) { return (AE_NO_NAMESPACE); } /* * Get the prefix scope. * A null scope means use the root scope */ if ((!ScopeInfo) || (!ScopeInfo->Scope.Node)) { - DEBUG_PRINTP (TRACE_NAMES, ("Null scope prefix, using root node (%p)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Null scope prefix, using root node (%p)\n", AcpiGbl_RootNode)); PrefixNode = AcpiGbl_RootNode; } else { PrefixNode = ScopeInfo->Scope.Node; } /* * This check is explicitly split to relax the TypeToCheckFor * conditions for BankFieldDefn. Originally, both BankFieldDefn and * DefFieldDefn caused TypeToCheckFor to be set to ACPI_TYPE_REGION, * but the BankFieldDefn may also check for a Field definition as well * as an OperationRegion. */ if (INTERNAL_TYPE_FIELD_DEFN == Type) { /* DefFieldDefn defines fields in a Region */ TypeToCheckFor = ACPI_TYPE_REGION; } else if (INTERNAL_TYPE_BANK_FIELD_DEFN == Type) { /* BankFieldDefn defines data fields in a Field Object */ TypeToCheckFor = ACPI_TYPE_ANY; } else { TypeToCheckFor = Type; } /* TBD: [Restructure] - Move the pathname stuff into a new procedure */ /* Examine the name pointer */ if (!Pathname) { /* 8-12-98 ASL Grammar Update supports null NamePath */ NullNamePath = TRUE; NumSegments = 0; ThisNode = AcpiGbl_RootNode; - DEBUG_PRINTP (TRACE_NAMES, - ("Null Pathname (Zero segments), Flags=%x\n", Flags)); + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, + "Null Pathname (Zero segments), Flags=%x\n", Flags)); } else { /* * Valid name pointer (Internal name format) * * Check for prefixes. As represented in the AML stream, a * Pathname consists of an optional scope prefix followed by * a segment part. * * If present, the scope prefix is either a RootPrefix (in * which case the name is fully qualified), or zero or more * ParentPrefixes (in which case the name's scope is relative * to the current scope). * * The segment part consists of either: * - A single 4-byte name segment, or * - A DualNamePrefix followed by two 4-byte name segments, or * - A MultiNamePrefixOp, followed by a byte indicating the * number of segments and the segments themselves. */ if (*Pathname == AML_ROOT_PREFIX) { /* Pathname is fully qualified, look in root name table */ CurrentNode = AcpiGbl_RootNode; /* point to segment part */ Pathname++; - DEBUG_PRINTP (TRACE_NAMES, ("Searching from root [%p]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Searching from root [%p]\n", CurrentNode)); /* Direct reference to root, "\" */ if (!(*Pathname)) { ThisNode = AcpiGbl_RootNode; goto CheckForNewScopeAndExit; } } else { /* Pathname is relative to current scope, start there */ CurrentNode = PrefixNode; - DEBUG_PRINTP (TRACE_NAMES, ("Searching relative to pfx scope [%p]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Searching relative to pfx scope [%p]\n", PrefixNode)); /* * Handle up-prefix (carat). More than one prefix * is supported */ while (*Pathname == AML_PARENT_PREFIX) { /* Point to segment part or next ParentPrefix */ Pathname++; /* Backup to the parent's scope */ ThisNode = AcpiNsGetParentObject (CurrentNode); if (!ThisNode) { /* Current scope has no parent scope */ REPORT_ERROR ( ("Too many parent prefixes (^) - reached root\n")); return_ACPI_STATUS (AE_NOT_FOUND); } CurrentNode = ThisNode; } } /* * Examine the name prefix opcode, if any, * to determine the number of segments */ if (*Pathname == AML_DUAL_NAME_PREFIX) { NumSegments = 2; /* point to first segment */ Pathname++; - DEBUG_PRINTP (TRACE_NAMES, - ("Dual Pathname (2 segments, Flags=%X)\n", Flags)); + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, + "Dual Pathname (2 segments, Flags=%X)\n", Flags)); } else if (*Pathname == AML_MULTI_NAME_PREFIX_OP) { NumSegments = (UINT32)* (UINT8 *) ++Pathname; /* point to first segment */ Pathname++; - DEBUG_PRINTP (TRACE_NAMES, - ("Multi Pathname (%d Segments, Flags=%X) \n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, + "Multi Pathname (%d Segments, Flags=%X) \n", NumSegments, Flags)); } else { /* * No Dual or Multi prefix, hence there is only one * segment and Pathname is already pointing to it. */ NumSegments = 1; - DEBUG_PRINTP (TRACE_NAMES, - ("Simple Pathname (1 segment, Flags=%X)\n", Flags)); + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, + "Simple Pathname (1 segment, Flags=%X)\n", Flags)); } #ifdef ACPI_DEBUG /* TBD: [Restructure] Make this a procedure */ /* Debug only: print the entire name that we are about to lookup */ - DEBUG_PRINTP (TRACE_NAMES, ("[")); + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "[")); for (i = 0; i < NumSegments; i++) { - DEBUG_PRINT_RAW (TRACE_NAMES, ("%4.4s/", &Pathname[i * 4])); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_NAMES, "%4.4s/", &Pathname[i * 4])); } - DEBUG_PRINT_RAW (TRACE_NAMES, ("]\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_NAMES, "]\n")); #endif } /* * Search namespace for each segment of the name. * Loop through and verify/add each name segment. */ while (NumSegments-- && CurrentNode) { /* * Search for the current name segment under the current * named object. The Type is significant only at the last (topmost) * level. (We don't care about the types along the path, only * the type of the final target object.) */ ThisSearchType = ACPI_TYPE_ANY; if (!NumSegments) { ThisSearchType = Type; LocalFlags = Flags; } /* Pluck one ACPI name from the front of the pathname */ MOVE_UNALIGNED32_TO_32 (&SimpleName, Pathname); /* Try to find the ACPI name */ Status = AcpiNsSearchAndEnter (SimpleName, WalkState, CurrentNode, InterpreterMode, ThisSearchType, LocalFlags, &ThisNode); if (ACPI_FAILURE (Status)) { if (Status == AE_NOT_FOUND) { /* Name not found in ACPI namespace */ - DEBUG_PRINTP (TRACE_NAMES, - ("Name [%4.4s] not found in scope %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, + "Name [%4.4s] not found in scope %X\n", &SimpleName, CurrentNode)); } return_ACPI_STATUS (Status); } /* * If 1) This is the last segment (NumSegments == 0) * 2) and looking for a specific type * (Not checking for TYPE_ANY) * 3) Which is not an alias * 4) which is not a local type (TYPE_DEF_ANY) * 5) which is not a local type (TYPE_SCOPE) * 6) which is not a local type (TYPE_INDEX_FIELD_DEFN) * 7) and type of object is known (not TYPE_ANY) * 8) and object does not match request * * Then we have a type mismatch. Just warn and ignore it. */ if ((NumSegments == 0) && (TypeToCheckFor != ACPI_TYPE_ANY) && (TypeToCheckFor != INTERNAL_TYPE_ALIAS) && (TypeToCheckFor != INTERNAL_TYPE_DEF_ANY) && (TypeToCheckFor != INTERNAL_TYPE_SCOPE) && (TypeToCheckFor != INTERNAL_TYPE_INDEX_FIELD_DEFN) && (ThisNode->Type != ACPI_TYPE_ANY) && (ThisNode->Type != TypeToCheckFor)) { /* Complain about a type mismatch */ REPORT_WARNING ( ("NsLookup: %4.4s, type %X, checking for type %X\n", &SimpleName, ThisNode->Type, TypeToCheckFor)); } /* * If this is the last name segment and we are not looking for a * specific type, but the type of found object is known, use that type * to see if it opens a scope. */ if ((0 == NumSegments) && (ACPI_TYPE_ANY == Type)) { Type = ThisNode->Type; } if ((NumSegments || AcpiNsOpensScope (Type)) && (ThisNode->Child == NULL)) { /* * More segments or the type implies enclosed scope, * and the next scope has not been allocated. */ - DEBUG_PRINTP (ACPI_INFO, ("Load mode=%X ThisNode=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Load mode=%X ThisNode=%X\n", InterpreterMode, ThisNode)); } CurrentNode = ThisNode; /* point to next name segment */ Pathname += ACPI_NAME_SIZE; } /* * Always check if we need to open a new scope */ CheckForNewScopeAndExit: if (!(Flags & NS_DONT_OPEN_SCOPE) && (WalkState)) { /* * If entry is a type which opens a scope, * push the new scope on the scope stack. */ if (AcpiNsOpensScope (TypeToCheckFor)) { /* 8-12-98 ASL Grammar Update supports null NamePath */ if (NullNamePath) { /* TBD: [Investigate] - is this the correct thing to do? */ ScopeToPush = NULL; } else { ScopeToPush = ThisNode; } Status = AcpiDsScopeStackPush (ScopeToPush, Type, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } - DEBUG_PRINTP (ACPI_INFO, ("Set global scope to %p\n", ScopeToPush)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Set global scope to %p\n", ScopeToPush)); } } *ReturnNode = ThisNode; return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsalloc.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsalloc.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsalloc.c (revision 82367) @@ -1,716 +1,716 @@ /******************************************************************************* * * Module Name: nsalloc - Namespace allocation and deletion utilities - * $Revision: 51 $ + * $Revision: 53 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSALLOC_C__ #include "acpi.h" #include "acnamesp.h" #include "acinterp.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nsalloc") /******************************************************************************* * * FUNCTION: AcpiNsCreateNode * * PARAMETERS: * * RETURN: None * * DESCRIPTION: * ******************************************************************************/ ACPI_NAMESPACE_NODE * AcpiNsCreateNode ( UINT32 AcpiName) { ACPI_NAMESPACE_NODE *Node; FUNCTION_TRACE ("NsCreateNode"); Node = ACPI_MEM_CALLOCATE (sizeof (ACPI_NAMESPACE_NODE)); if (!Node) { return_PTR (NULL); } - INCREMENT_NAME_TABLE_METRICS (sizeof (ACPI_NAMESPACE_NODE)); + ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_NSNODE].TotalAllocated++); Node->DataType = ACPI_DESC_TYPE_NAMED; Node->Name = AcpiName; Node->ReferenceCount = 1; return_PTR (Node); } /******************************************************************************* * * FUNCTION: AcpiNsDeleteNode * * PARAMETERS: * * RETURN: None * * DESCRIPTION: * ******************************************************************************/ void AcpiNsDeleteNode ( ACPI_NAMESPACE_NODE *Node) { ACPI_NAMESPACE_NODE *ParentNode; ACPI_NAMESPACE_NODE *PrevNode; ACPI_NAMESPACE_NODE *NextNode; FUNCTION_TRACE_PTR ("NsDeleteNode", Node); ParentNode = AcpiNsGetParentObject (Node); PrevNode = NULL; NextNode = ParentNode->Child; while (NextNode != Node) { PrevNode = NextNode; NextNode = PrevNode->Peer; } if (PrevNode) { PrevNode->Peer = NextNode->Peer; if (NextNode->Flags & ANOBJ_END_OF_PEER_LIST) { PrevNode->Flags |= ANOBJ_END_OF_PEER_LIST; } } else { ParentNode->Child = NextNode->Peer; } - DECREMENT_NAME_TABLE_METRICS (sizeof (ACPI_NAMESPACE_NODE)); + ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_NSNODE].TotalFreed++); /* * Detach an object if there is one */ if (Node->Object) { AcpiNsDetachObject (Node); } ACPI_MEM_FREE (Node); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiNsInstallNode * * PARAMETERS: WalkState - Current state of the walk * ParentNode - The parent of the new Node * Node - The new Node to install * Type - ACPI object type of the new Node * * RETURN: None * * DESCRIPTION: Initialize a new entry within a namespace table. * ******************************************************************************/ void AcpiNsInstallNode ( ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE *ParentNode, /* Parent */ ACPI_NAMESPACE_NODE *Node, /* New Child*/ ACPI_OBJECT_TYPE8 Type) { UINT16 OwnerId = TABLE_ID_DSDT; ACPI_NAMESPACE_NODE *ChildNode; FUNCTION_TRACE ("NsInstallNode"); /* * Get the owner ID from the Walk state * The owner ID is used to track table deletion and * deletion of objects created by methods */ if (WalkState) { OwnerId = WalkState->OwnerId; } /* link the new entry into the parent and existing children */ /* TBD: Could be first, last, or alphabetic */ ChildNode = ParentNode->Child; if (!ChildNode) { ParentNode->Child = Node; } else { while (!(ChildNode->Flags & ANOBJ_END_OF_PEER_LIST)) { ChildNode = ChildNode->Peer; } ChildNode->Peer = Node; /* Clear end-of-list flag */ ChildNode->Flags &= ~ANOBJ_END_OF_PEER_LIST; } /* Init the new entry */ Node->OwnerId = OwnerId; Node->Flags |= ANOBJ_END_OF_PEER_LIST; Node->Peer = ParentNode; /* * If adding a name with unknown type, or having to * add the region in order to define fields in it, we * have a forward reference. */ if ((ACPI_TYPE_ANY == Type) || (INTERNAL_TYPE_FIELD_DEFN == Type) || (INTERNAL_TYPE_BANK_FIELD_DEFN == Type)) { /* * We don't want to abort here, however! * We will fill in the actual type when the * real definition is found later. */ - DEBUG_PRINTP (ACPI_INFO, ("[%4.4s] is a forward reference\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "[%4.4s] is a forward reference\n", &Node->Name)); } /* * The DefFieldDefn and BankFieldDefn cases are actually * looking up the Region in which the field will be defined */ if ((INTERNAL_TYPE_FIELD_DEFN == Type) || (INTERNAL_TYPE_BANK_FIELD_DEFN == Type)) { Type = ACPI_TYPE_REGION; } /* * Scope, DefAny, and IndexFieldDefn are bogus "types" which do * not actually have anything to do with the type of the name * being looked up. Save any other value of Type as the type of * the entry. */ if ((Type != INTERNAL_TYPE_SCOPE) && (Type != INTERNAL_TYPE_DEF_ANY) && (Type != INTERNAL_TYPE_INDEX_FIELD_DEFN)) { Node->Type = (UINT8) Type; } - DEBUG_PRINTP (TRACE_NAMES, ("%4.4s added to %p at %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "%4.4s added to %p at %p\n", &Node->Name, ParentNode, Node)); /* * Increment the reference count(s) of all parents up to * the root! */ while ((Node = AcpiNsGetParentObject (Node)) != NULL) { Node->ReferenceCount++; } return_VOID; } /******************************************************************************* * * FUNCTION: AcpiNsDeleteChildren * * PARAMETERS: ParentNode - Delete this objects children * * RETURN: None. * * DESCRIPTION: Delete all children of the parent object. Deletes a * "scope". * ******************************************************************************/ void AcpiNsDeleteChildren ( ACPI_NAMESPACE_NODE *ParentNode) { ACPI_NAMESPACE_NODE *ChildNode; ACPI_NAMESPACE_NODE *NextNode; UINT8 Flags; FUNCTION_TRACE_PTR ("AcpiNsDeleteChildren", ParentNode); if (!ParentNode) { return_VOID; } /* If no children, all done! */ ChildNode = ParentNode->Child; if (!ChildNode) { return_VOID; } /* * Deallocate all children at this level */ do { /* Get the things we need */ NextNode = ChildNode->Peer; Flags = ChildNode->Flags; /* Grandchildren should have all been deleted already */ if (ChildNode->Child) { - DEBUG_PRINTP (ACPI_ERROR, ("Found a grandchild! P=%X C=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Found a grandchild! P=%X C=%X\n", ParentNode, ChildNode)); } /* Now we can free this child object */ - DECREMENT_NAME_TABLE_METRICS (sizeof (ACPI_NAMESPACE_NODE)); + ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_NSNODE].TotalFreed++); - DEBUG_PRINTP (ACPI_INFO, ("Object %p, Remaining %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Object %p, Remaining %X\n", ChildNode, AcpiGbl_CurrentNodeCount)); /* * Detach an object if there is one */ if (ChildNode->Object) { AcpiNsDetachObject (ChildNode); } ACPI_MEM_FREE (ChildNode); /* And move on to the next child in the list */ ChildNode = NextNode; } while (!(Flags & ANOBJ_END_OF_PEER_LIST)); /* Clear the parent's child pointer */ ParentNode->Child = NULL; return_VOID; } /******************************************************************************* * * FUNCTION: AcpiNsDeleteNamespaceSubtree * * PARAMETERS: None. * * RETURN: None. * * DESCRIPTION: Delete a subtree of the namespace. This includes all objects * stored within the subtree. Scope tables are deleted also * ******************************************************************************/ ACPI_STATUS AcpiNsDeleteNamespaceSubtree ( ACPI_NAMESPACE_NODE *ParentNode) { ACPI_NAMESPACE_NODE *ChildNode; ACPI_OPERAND_OBJECT *ObjDesc; UINT32 Level; FUNCTION_TRACE ("NsDeleteNamespaceSubtree"); if (!ParentNode) { return_ACPI_STATUS (AE_OK); } ChildNode = 0; Level = 1; /* * Traverse the tree of objects until we bubble back up * to where we started. */ while (Level > 0) { /* * Get the next typed object in this scope. * Null returned if not found */ ChildNode = AcpiNsGetNextObject (ACPI_TYPE_ANY, ParentNode, ChildNode); if (ChildNode) { /* * Found an object - delete the object within * the Value field */ ObjDesc = AcpiNsGetAttachedObject (ChildNode); if (ObjDesc) { AcpiNsDetachObject (ChildNode); AcpiUtRemoveReference (ObjDesc); } /* Check if this object has any children */ if (AcpiNsGetNextObject (ACPI_TYPE_ANY, ChildNode, 0)) { /* * There is at least one child of this object, * visit the object */ Level++; ParentNode = ChildNode; ChildNode = 0; } } else { /* * No more children in this object. * We will move up to the grandparent. */ Level--; /* * Now delete all of the children of this parent * all at the same time. */ AcpiNsDeleteChildren (ParentNode); /* New "last child" is this parent object */ ChildNode = ParentNode; /* Now we can move up the tree to the grandparent */ ParentNode = AcpiNsGetParentObject (ParentNode); } } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiNsRemoveReference * * PARAMETERS: Node - Named object whose reference count is to be * decremented * * RETURN: None. * * DESCRIPTION: Remove a Node reference. Decrements the reference count * of all parent Nodes up to the root. Any object along * the way that reaches zero references is freed. * ******************************************************************************/ static void AcpiNsRemoveReference ( ACPI_NAMESPACE_NODE *Node) { ACPI_NAMESPACE_NODE *NextNode; /* * Decrement the reference count(s) of this object and all * objects up to the root, Delete anything with zero remaining references. */ NextNode = Node; while (NextNode) { /* Decrement the reference count on this object*/ NextNode->ReferenceCount--; /* Delete the object if no more references */ if (!NextNode->ReferenceCount) { /* Delete all children and delete the object */ AcpiNsDeleteChildren (NextNode); AcpiNsDeleteNode (NextNode); } /* Move up to parent */ NextNode = AcpiNsGetParentObject (NextNode); } } /******************************************************************************* * * FUNCTION: AcpiNsDeleteNamespaceByOwner * * PARAMETERS: None. * * RETURN: None. * * DESCRIPTION: Delete entries within the namespace that are owned by a * specific ID. Used to delete entire ACPI tables. All * reference counts are updated. * ******************************************************************************/ ACPI_STATUS AcpiNsDeleteNamespaceByOwner ( UINT16 OwnerId) { ACPI_NAMESPACE_NODE *ChildNode; UINT32 Level; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_NAMESPACE_NODE *ParentNode; FUNCTION_TRACE ("NsDeleteNamespaceSubtree"); ParentNode = AcpiGbl_RootNode; ChildNode = 0; Level = 1; /* * Traverse the tree of objects until we bubble back up * to where we started. */ while (Level > 0) { /* * Get the next typed object in this scope. * Null returned if not found */ ChildNode = AcpiNsGetNextObject (ACPI_TYPE_ANY, ParentNode, ChildNode); if (ChildNode) { if (ChildNode->OwnerId == OwnerId) { /* * Found an object - delete the object within * the Value field */ ObjDesc = AcpiNsGetAttachedObject (ChildNode); if (ObjDesc) { AcpiNsDetachObject (ChildNode); AcpiUtRemoveReference (ObjDesc); } } /* Check if this object has any children */ if (AcpiNsGetNextObject (ACPI_TYPE_ANY, ChildNode, 0)) { /* * There is at least one child of this object, * visit the object */ Level++; ParentNode = ChildNode; ChildNode = 0; } else if (ChildNode->OwnerId == OwnerId) { AcpiNsRemoveReference (ChildNode); } } else { /* * No more children in this object. Move up to grandparent. */ Level--; if (Level != 0) { if (ParentNode->OwnerId == OwnerId) { AcpiNsRemoveReference (ParentNode); } } /* New "last child" is this parent object */ ChildNode = ParentNode; /* Now we can move up the tree to the grandparent */ ParentNode = AcpiNsGetParentObject (ParentNode); } } return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsdump.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsdump.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsdump.c (revision 82367) @@ -1,678 +1,685 @@ /****************************************************************************** * * Module Name: nsdump - table dumping routines for debug - * $Revision: 94 $ + * $Revision: 95 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSDUMP_C__ #include "acpi.h" #include "acinterp.h" #include "acnamesp.h" #include "actables.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nsdump") #if defined(ACPI_DEBUG) || defined(ENABLE_DEBUGGER) /******************************************************************************* * * FUNCTION: AcpiNsDumpPathname * * PARAMETERS: Handle - Object * Msg - Prefix message * Level - Desired debug level * Component - Caller's component ID * * DESCRIPTION: Print an object's full namespace pathname * Manages allocation/freeing of a pathname buffer * ******************************************************************************/ ACPI_STATUS AcpiNsDumpPathname ( ACPI_HANDLE Handle, NATIVE_CHAR *Msg, UINT32 Level, UINT32 Component) { NATIVE_CHAR *Buffer; UINT32 Length; FUNCTION_TRACE ("NsDumpPathname"); /* Do this only if the requested debug level and component are enabled */ if (!(AcpiDbgLevel & Level) || !(AcpiDbgLayer & Component)) { return_ACPI_STATUS (AE_OK); } Buffer = ACPI_MEM_ALLOCATE (PATHNAME_MAX); if (!Buffer) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Convert handle to a full pathname and print it (with supplied message) */ Length = PATHNAME_MAX; if (ACPI_SUCCESS (AcpiNsHandleToPathname (Handle, &Length, Buffer))) { AcpiOsPrintf ("%s %s (%p)\n", Msg, Buffer, Handle); } ACPI_MEM_FREE (Buffer); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiNsDumpOneObject * * PARAMETERS: Handle - Node to be dumped * Level - Nesting level of the handle * Context - Passed into WalkNamespace * * DESCRIPTION: Dump a single Node * This procedure is a UserFunction called by AcpiNsWalkNamespace. * ******************************************************************************/ ACPI_STATUS AcpiNsDumpOneObject ( ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue) { ACPI_WALK_INFO *Info = (ACPI_WALK_INFO *) Context; ACPI_NAMESPACE_NODE *ThisNode; UINT8 *Value; ACPI_OPERAND_OBJECT *ObjDesc = NULL; ACPI_OBJECT_TYPE8 ObjType; ACPI_OBJECT_TYPE8 Type; UINT32 BytesToDump; UINT32 DownstreamSiblingMask = 0; UINT32 LevelTmp; UINT32 WhichBit; + PROC_NAME ("AcpiNsDumpOneObject"); + + ThisNode = AcpiNsConvertHandleToEntry (ObjHandle); LevelTmp = Level; Type = ThisNode->Type; WhichBit = 1; if (!(AcpiDbgLevel & Info->DebugLevel)) { return (AE_OK); } if (!ObjHandle) { - DEBUG_PRINT (ACPI_INFO, ("NsDumpOneObject: Null object handle\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Null object handle\n")); return (AE_OK); } /* Check if the owner matches */ if ((Info->OwnerId != ACPI_UINT32_MAX) && (Info->OwnerId != ThisNode->OwnerId)) { return (AE_OK); } /* Indent the object according to the level */ while (LevelTmp--) { /* Print appropriate characters to form tree structure */ if (LevelTmp) { if (DownstreamSiblingMask & WhichBit) { - DEBUG_PRINT_RAW (TRACE_TABLES, ("|")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "|")); } else { - DEBUG_PRINT_RAW (TRACE_TABLES, (" ")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " ")); } WhichBit <<= 1; } else { if (AcpiNsExistDownstreamSibling (ThisNode + 1)) { DownstreamSiblingMask |= (1 << (Level - 1)); - DEBUG_PRINT_RAW (TRACE_TABLES, ("+")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "+")); } else { DownstreamSiblingMask &= ACPI_UINT32_MAX ^ (1 << (Level - 1)); - DEBUG_PRINT_RAW (TRACE_TABLES, ("+")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "+")); } if (ThisNode->Child == NULL) { - DEBUG_PRINT_RAW (TRACE_TABLES, ("-")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "-")); } else if (AcpiNsExistDownstreamSibling (ThisNode->Child)) { - DEBUG_PRINT_RAW (TRACE_TABLES, ("+")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "+")); } else { - DEBUG_PRINT_RAW (TRACE_TABLES, ("-")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "-")); } } } /* Check the integrity of our data */ if (Type > INTERNAL_TYPE_MAX) { Type = INTERNAL_TYPE_DEF_ANY; /* prints as *ERROR* */ } if (!AcpiUtValidAcpiName (ThisNode->Name)) { REPORT_WARNING (("Invalid ACPI Name %08X\n", ThisNode->Name)); } /* * Now we can print out the pertinent information */ - DEBUG_PRINT_RAW (TRACE_TABLES, (" %4.4s %-9s ", &ThisNode->Name, AcpiUtGetTypeName (Type))); - DEBUG_PRINT_RAW (TRACE_TABLES, ("%p S:%p O:%p", ThisNode, ThisNode->Child, ThisNode->Object)); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " %4.4s %-9s ", &ThisNode->Name, AcpiUtGetTypeName (Type))); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "%p S:%p O:%p", ThisNode, ThisNode->Child, ThisNode->Object)); if (!ThisNode->Object) { /* No attached object, we are done */ - DEBUG_PRINT_RAW (TRACE_TABLES, ("\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "\n")); return (AE_OK); } switch (Type) { case ACPI_TYPE_METHOD: /* Name is a Method and its AML offset/length are set */ - DEBUG_PRINT_RAW (TRACE_TABLES, (" M:%p-%X\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " M:%p-%X\n", ((ACPI_OPERAND_OBJECT *) ThisNode->Object)->Method.Pcode, ((ACPI_OPERAND_OBJECT *) ThisNode->Object)->Method.PcodeLength)); break; case ACPI_TYPE_INTEGER: - DEBUG_PRINT_RAW (TRACE_TABLES, (" N:%X\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " N:%X\n", ((ACPI_OPERAND_OBJECT *) ThisNode->Object)->Integer.Value)); break; case ACPI_TYPE_STRING: - DEBUG_PRINT_RAW (TRACE_TABLES, (" S:%p-%X\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " S:%p-%X\n", ((ACPI_OPERAND_OBJECT *) ThisNode->Object)->String.Pointer, ((ACPI_OPERAND_OBJECT *) ThisNode->Object)->String.Length)); break; case ACPI_TYPE_BUFFER: - DEBUG_PRINT_RAW (TRACE_TABLES, (" B:%p-%X\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " B:%p-%X\n", ((ACPI_OPERAND_OBJECT *) ThisNode->Object)->Buffer.Pointer, ((ACPI_OPERAND_OBJECT *) ThisNode->Object)->Buffer.Length)); break; default: - DEBUG_PRINT_RAW (TRACE_TABLES, ("\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "\n")); break; } /* If debug turned off, done */ - if (!(AcpiDbgLevel & TRACE_VALUES)) + if (!(AcpiDbgLevel & ACPI_LV_VALUES)) { return (AE_OK); } /* If there is an attached object, display it */ Value = ThisNode->Object; /* Dump attached objects */ while (Value) { ObjType = INTERNAL_TYPE_INVALID; /* Decode the type of attached object and dump the contents */ - DEBUG_PRINT_RAW (TRACE_TABLES, (" Attached Object %p: ", Value)); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " Attached Object %p: ", Value)); if (AcpiTbSystemTablePointer (Value)) { - DEBUG_PRINT_RAW (TRACE_TABLES, ("(Ptr to AML Code)\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "(Ptr to AML Code)\n")); BytesToDump = 16; } else if (VALID_DESCRIPTOR_TYPE (Value, ACPI_DESC_TYPE_NAMED)) { - DEBUG_PRINT_RAW (TRACE_TABLES, ("(Ptr to Node)\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "(Ptr to Node)\n")); BytesToDump = sizeof (ACPI_NAMESPACE_NODE); } else if (VALID_DESCRIPTOR_TYPE (Value, ACPI_DESC_TYPE_INTERNAL)) { ObjDesc = (ACPI_OPERAND_OBJECT *) Value; ObjType = ObjDesc->Common.Type; if (ObjType > INTERNAL_TYPE_MAX) { - DEBUG_PRINT_RAW (TRACE_TABLES, ("(Ptr to ACPI Object type %X [UNKNOWN])\n", ObjType)); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "(Ptr to ACPI Object type %X [UNKNOWN])\n", ObjType)); BytesToDump = 32; } else { - DEBUG_PRINT_RAW (TRACE_TABLES, ("(Ptr to ACPI Object type %X [%s])\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "(Ptr to ACPI Object type %X [%s])\n", ObjType, AcpiUtGetTypeName (ObjType))); BytesToDump = sizeof (ACPI_OPERAND_OBJECT); } } else { - DEBUG_PRINT_RAW (TRACE_TABLES, ("(String or Buffer - not descriptor)\n", Value)); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "(String or Buffer - not descriptor)\n", Value)); BytesToDump = 16; } DUMP_BUFFER (Value, BytesToDump); /* If value is NOT an internal object, we are done */ if ((AcpiTbSystemTablePointer (Value)) || (VALID_DESCRIPTOR_TYPE (Value, ACPI_DESC_TYPE_NAMED))) { goto Cleanup; } /* * Valid object, get the pointer to next level, if any */ switch (ObjType) { case ACPI_TYPE_STRING: Value = (UINT8 *) ObjDesc->String.Pointer; break; case ACPI_TYPE_BUFFER: Value = (UINT8 *) ObjDesc->Buffer.Pointer; break; case ACPI_TYPE_BUFFER_FIELD: Value = (UINT8 *) ObjDesc->BufferField.BufferObj; break; case ACPI_TYPE_PACKAGE: Value = (UINT8 *) ObjDesc->Package.Elements; break; case ACPI_TYPE_METHOD: Value = (UINT8 *) ObjDesc->Method.Pcode; break; case INTERNAL_TYPE_REGION_FIELD: Value = (UINT8 *) ObjDesc->Field.RegionObj; break; case INTERNAL_TYPE_BANK_FIELD: Value = (UINT8 *) ObjDesc->BankField.RegionObj; break; case INTERNAL_TYPE_INDEX_FIELD: Value = (UINT8 *) ObjDesc->IndexField.IndexObj; break; default: goto Cleanup; } ObjType = INTERNAL_TYPE_INVALID; /* Terminate loop after next pass */ } Cleanup: - DEBUG_PRINT_RAW (TRACE_TABLES, ("\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "\n")); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiNsDumpObjects * * PARAMETERS: Type - Object type to be dumped * MaxDepth - Maximum depth of dump. Use ACPI_UINT32_MAX * for an effectively unlimited depth. * OwnerId - Dump only objects owned by this ID. Use * ACPI_UINT32_MAX to match all owners. * StartHandle - Where in namespace to start/end search * * DESCRIPTION: Dump typed objects within the loaded namespace. * Uses AcpiNsWalkNamespace in conjunction with AcpiNsDumpOneObject. * ******************************************************************************/ void AcpiNsDumpObjects ( ACPI_OBJECT_TYPE8 Type, UINT32 MaxDepth, UINT32 OwnerId, ACPI_HANDLE StartHandle) { ACPI_WALK_INFO Info; - Info.DebugLevel = TRACE_TABLES; + Info.DebugLevel = ACPI_LV_TABLES; Info.OwnerId = OwnerId; AcpiNsWalkNamespace (Type, StartHandle, MaxDepth, NS_WALK_NO_UNLOCK, AcpiNsDumpOneObject, (void *) &Info, NULL); } #ifndef _ACPI_ASL_COMPILER /******************************************************************************* * * FUNCTION: AcpiNsDumpOneDevice * * PARAMETERS: Handle - Node to be dumped * Level - Nesting level of the handle * Context - Passed into WalkNamespace * * DESCRIPTION: Dump a single Node that represents a device * This procedure is a UserFunction called by AcpiNsWalkNamespace. * ******************************************************************************/ ACPI_STATUS AcpiNsDumpOneDevice ( ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue) { ACPI_DEVICE_INFO Info; ACPI_STATUS Status; UINT32 i; + PROC_NAME ("AcpiNsDumpOneDevice"); + Status = AcpiNsDumpOneObject (ObjHandle, Level, Context, ReturnValue); Status = AcpiGetObjectInfo (ObjHandle, &Info); if (ACPI_SUCCESS (Status)) { for (i = 0; i < Level; i++) { - DEBUG_PRINT_RAW (TRACE_TABLES, (" ")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " ")); } - DEBUG_PRINT_RAW (TRACE_TABLES, (" HID: %.8X, ADR: %.8X, Status: %x\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " HID: %.8X, ADR: %.8X, Status: %x\n", Info.HardwareId, Info.Address, Info.CurrentStatus)); } return (Status); } /******************************************************************************* * * FUNCTION: AcpiNsDumpRootDevices * * PARAMETERS: None * * DESCRIPTION: Dump all objects of type "device" * ******************************************************************************/ void AcpiNsDumpRootDevices (void) { ACPI_HANDLE SysBusHandle; + PROC_NAME ("AcpiNsDumpRootDevices"); + /* Only dump the table if tracing is enabled */ - if (!(TRACE_TABLES & AcpiDbgLevel)) + if (!(ACPI_DB_TABLES & AcpiDbgLevel)) { return; } AcpiGetHandle (0, NS_SYSTEM_BUS, &SysBusHandle); - DEBUG_PRINT (TRACE_TABLES, ("Display of all devices in the namespace:\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "Display of all devices in the namespace:\n")); AcpiNsWalkNamespace (ACPI_TYPE_DEVICE, SysBusHandle, ACPI_UINT32_MAX, NS_WALK_NO_UNLOCK, AcpiNsDumpOneDevice, NULL, NULL); } #endif /******************************************************************************* * * FUNCTION: AcpiNsDumpTables * * PARAMETERS: SearchBase - Root of subtree to be dumped, or * NS_ALL to dump the entire namespace * MaxDepth - Maximum depth of dump. Use INT_MAX * for an effectively unlimited depth. * * DESCRIPTION: Dump the name space, or a portion of it. * ******************************************************************************/ void AcpiNsDumpTables ( ACPI_HANDLE SearchBase, UINT32 MaxDepth) { ACPI_HANDLE SearchHandle = SearchBase; FUNCTION_TRACE ("NsDumpTables"); if (!AcpiGbl_RootNode) { /* * If the name space has not been initialized, * there is nothing to dump. */ - DEBUG_PRINTP (TRACE_TABLES, ("name space not initialized!\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "name space not initialized!\n")); return_VOID; } if (NS_ALL == SearchBase) { /* entire namespace */ SearchHandle = AcpiGbl_RootNode; - DEBUG_PRINT (TRACE_TABLES, ("\\\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "\\\n")); } AcpiNsDumpObjects (ACPI_TYPE_ANY, MaxDepth, ACPI_UINT32_MAX, SearchHandle); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiNsDumpEntry * * PARAMETERS: Handle - Node to be dumped * DebugLevel - Output level * * DESCRIPTION: Dump a single Node * ******************************************************************************/ void AcpiNsDumpEntry ( ACPI_HANDLE Handle, UINT32 DebugLevel) { ACPI_WALK_INFO Info; FUNCTION_TRACE_PTR ("NsDumpEntry", Handle); Info.DebugLevel = DebugLevel; Info.OwnerId = ACPI_UINT32_MAX; AcpiNsDumpOneObject (Handle, 1, &Info, NULL); return_VOID; } #endif Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nseval.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nseval.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nseval.c (revision 82367) @@ -1,663 +1,663 @@ /******************************************************************************* * * Module Name: nseval - Object evaluation interfaces -- includes control * method lookup and execution. - * $Revision: 93 $ + * $Revision: 94 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSEVAL_C__ #include "acpi.h" #include "amlcode.h" #include "acparser.h" #include "acinterp.h" #include "acnamesp.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nseval") /******************************************************************************* * * FUNCTION: AcpiNsEvaluateRelative * * PARAMETERS: Handle - The relative containing object * *Pathname - Name of method to execute, If NULL, the * handle is the object to execute * **Params - List of parameters to pass to the method, * terminated by NULL. Params itself may be * NULL if no parameters are being passed. * *ReturnObject - Where to put method's return value (if * any). If NULL, no value is returned. * * RETURN: Status * * DESCRIPTION: Find and execute the requested method using the handle as a * scope * * MUTEX: Locks Namespace * ******************************************************************************/ ACPI_STATUS AcpiNsEvaluateRelative ( ACPI_NAMESPACE_NODE *Handle, NATIVE_CHAR *Pathname, ACPI_OPERAND_OBJECT **Params, ACPI_OPERAND_OBJECT **ReturnObject) { ACPI_NAMESPACE_NODE *PrefixNode; ACPI_STATUS Status; ACPI_NAMESPACE_NODE *Node = NULL; NATIVE_CHAR *InternalPath = NULL; ACPI_GENERIC_STATE ScopeInfo; FUNCTION_TRACE ("NsEvaluateRelative"); /* * Must have a valid object handle */ if (!Handle) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Build an internal name string for the method */ Status = AcpiNsInternalizeName (Pathname, &InternalPath); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Get the prefix handle and Node */ AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); PrefixNode = AcpiNsConvertHandleToEntry (Handle); if (!PrefixNode) { AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); Status = AE_BAD_PARAMETER; goto Cleanup; } /* Lookup the name in the namespace */ ScopeInfo.Scope.Node = PrefixNode; Status = AcpiNsLookup (&ScopeInfo, InternalPath, ACPI_TYPE_ANY, IMODE_EXECUTE, NS_NO_UPSEARCH, NULL, &Node); AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_INFO, ("Object [%s] not found [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Object [%s] not found [%s]\n", Pathname, AcpiFormatException (Status))); goto Cleanup; } /* * Now that we have a handle to the object, we can attempt * to evaluate it. */ - DEBUG_PRINTP (ACPI_INFO, ("%s [%p] Value %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s [%p] Value %p\n", Pathname, Node, Node->Object)); Status = AcpiNsEvaluateByHandle (Node, Params, ReturnObject); - DEBUG_PRINTP (ACPI_INFO, ("*** Completed eval of object %s ***\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "*** Completed eval of object %s ***\n", Pathname)); Cleanup: ACPI_MEM_FREE (InternalPath); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsEvaluateByName * * PARAMETERS: Pathname - Fully qualified pathname to the object * *ReturnObject - Where to put method's return value (if * any). If NULL, no value is returned. * **Params - List of parameters to pass to the method, * terminated by NULL. Params itself may be * NULL if no parameters are being passed. * * RETURN: Status * * DESCRIPTION: Find and execute the requested method passing the given * parameters * * MUTEX: Locks Namespace * ******************************************************************************/ ACPI_STATUS AcpiNsEvaluateByName ( NATIVE_CHAR *Pathname, ACPI_OPERAND_OBJECT **Params, ACPI_OPERAND_OBJECT **ReturnObject) { ACPI_STATUS Status; ACPI_NAMESPACE_NODE *Node = NULL; NATIVE_CHAR *InternalPath = NULL; FUNCTION_TRACE ("NsEvaluateByName"); /* Build an internal name string for the method */ Status = AcpiNsInternalizeName (Pathname, &InternalPath); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); /* Lookup the name in the namespace */ Status = AcpiNsLookup (NULL, InternalPath, ACPI_TYPE_ANY, IMODE_EXECUTE, NS_NO_UPSEARCH, NULL, &Node); AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_INFO, ("Object at [%s] was not found, status=%.4X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Object at [%s] was not found, status=%.4X\n", Pathname, Status)); goto Cleanup; } /* * Now that we have a handle to the object, we can attempt * to evaluate it. */ - DEBUG_PRINTP (ACPI_INFO, ("%s [%p] Value %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s [%p] Value %p\n", Pathname, Node, Node->Object)); Status = AcpiNsEvaluateByHandle (Node, Params, ReturnObject); - DEBUG_PRINTP (ACPI_INFO, ("*** Completed eval of object %s ***\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "*** Completed eval of object %s ***\n", Pathname)); Cleanup: /* Cleanup */ if (InternalPath) { ACPI_MEM_FREE (InternalPath); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsEvaluateByHandle * * PARAMETERS: Handle - Method Node to execute * **Params - List of parameters to pass to the method, * terminated by NULL. Params itself may be * NULL if no parameters are being passed. * *ReturnObject - Where to put method's return value (if * any). If NULL, no value is returned. * * RETURN: Status * * DESCRIPTION: Execute the requested method passing the given parameters * * MUTEX: Locks Namespace * ******************************************************************************/ ACPI_STATUS AcpiNsEvaluateByHandle ( ACPI_NAMESPACE_NODE *Handle, ACPI_OPERAND_OBJECT **Params, ACPI_OPERAND_OBJECT **ReturnObject) { ACPI_NAMESPACE_NODE *Node; ACPI_STATUS Status; ACPI_OPERAND_OBJECT *LocalReturnObject; FUNCTION_TRACE ("NsEvaluateByHandle"); /* Check if namespace has been initialized */ if (!AcpiGbl_RootNode) { return_ACPI_STATUS (AE_NO_NAMESPACE); } /* Parameter Validation */ if (!Handle) { return_ACPI_STATUS (AE_BAD_PARAMETER); } if (ReturnObject) { /* Initialize the return value to an invalid object */ *ReturnObject = NULL; } /* Get the prefix handle and Node */ AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); Node = AcpiNsConvertHandleToEntry (Handle); if (!Node) { AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return_ACPI_STATUS (AE_BAD_PARAMETER); } /* * Two major cases here: * 1) The object is an actual control method -- execute it. * 2) The object is not a method -- just return it's current * value * * In both cases, the namespace is unlocked by the * AcpiNs* procedure */ if (AcpiNsGetType (Node) == ACPI_TYPE_METHOD) { /* * Case 1) We have an actual control method to execute */ Status = AcpiNsExecuteControlMethod (Node, Params, &LocalReturnObject); } else { /* * Case 2) Object is NOT a method, just return its * current value */ Status = AcpiNsGetObjectValue (Node, &LocalReturnObject); } /* * Check if there is a return value on the stack that must * be dealt with */ if (Status == AE_CTRL_RETURN_VALUE) { /* * If the Method returned a value and the caller * provided a place to store a returned value, Copy * the returned value to the object descriptor provided * by the caller. */ if (ReturnObject) { /* * Valid return object, copy the pointer to * the returned object */ *ReturnObject = LocalReturnObject; } /* Map AE_RETURN_VALUE to AE_OK, we are done with it */ if (Status == AE_CTRL_RETURN_VALUE) { Status = AE_OK; } } /* * Namespace was unlocked by the handling AcpiNs* function, * so we just return */ return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsExecuteControlMethod * * PARAMETERS: MethodNode - The object/method * **Params - List of parameters to pass to the method, * terminated by NULL. Params itself may be * NULL if no parameters are being passed. * **ReturnObjDesc - List of result objects to be returned * from the method. * * RETURN: Status * * DESCRIPTION: Execute the requested method passing the given parameters * * MUTEX: Assumes namespace is locked * ******************************************************************************/ ACPI_STATUS AcpiNsExecuteControlMethod ( ACPI_NAMESPACE_NODE *MethodNode, ACPI_OPERAND_OBJECT **Params, ACPI_OPERAND_OBJECT **ReturnObjDesc) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *ObjDesc; FUNCTION_TRACE ("NsExecuteControlMethod"); /* Verify that there is a method associated with this object */ ObjDesc = AcpiNsGetAttachedObject (MethodNode); if (!ObjDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("No attached method object\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No attached method object\n")); AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return_ACPI_STATUS (AE_ERROR); } - DEBUG_PRINTP (ACPI_INFO, ("Control method at Offset %x Length %lx]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Control method at Offset %x Length %lx]\n", ObjDesc->Method.Pcode + 1, ObjDesc->Method.PcodeLength - 1)); DUMP_PATHNAME (MethodNode, "NsExecuteControlMethod: Executing", - TRACE_NAMES, _COMPONENT); + ACPI_LV_NAMES, _COMPONENT); - DEBUG_PRINTP (TRACE_NAMES, ("At offset %8XH\n", ObjDesc->Method.Pcode + 1)); + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "At offset %8XH\n", ObjDesc->Method.Pcode + 1)); /* * Unlock the namespace before execution. This allows namespace access * via the external Acpi* interfaces while a method is being executed. * However, any namespace deletion must acquire both the namespace and * interpreter locks to ensure that no thread is using the portion of the * namespace that is being deleted. */ AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); /* * Execute the method via the interpreter */ Status = AcpiExExecuteMethod (MethodNode, Params, ReturnObjDesc); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsGetObjectValue * * PARAMETERS: Node - The object * * RETURN: Status * * DESCRIPTION: Return the current value of the object * * MUTEX: Assumes namespace is locked * ******************************************************************************/ ACPI_STATUS AcpiNsGetObjectValue ( ACPI_NAMESPACE_NODE *Node, ACPI_OPERAND_OBJECT **ReturnObjDesc) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *ValDesc; FUNCTION_TRACE ("NsGetObjectValue"); /* * We take the value from certain objects directly */ if ((Node->Type == ACPI_TYPE_PROCESSOR) || (Node->Type == ACPI_TYPE_POWER)) { /* * Create a Reference object to contain the object */ ObjDesc = AcpiUtCreateInternalObject (Node->Type); if (!ObjDesc) { Status = AE_NO_MEMORY; goto UnlockAndExit; } /* * Get the attached object */ ValDesc = AcpiNsGetAttachedObject (Node); if (!ValDesc) { Status = AE_NULL_OBJECT; goto UnlockAndExit; } /* * Just copy from the original to the return object * * TBD: [Future] - need a low-level object copy that handles * the reference count automatically. (Don't want to copy it) */ MEMCPY (ObjDesc, ValDesc, sizeof (ACPI_OPERAND_OBJECT)); ObjDesc->Common.ReferenceCount = 1; AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); } /* * Other objects require a reference object wrapper which we * then attempt to resolve. */ else { /* Create an Reference object to contain the object */ ObjDesc = AcpiUtCreateInternalObject (INTERNAL_TYPE_REFERENCE); if (!ObjDesc) { Status = AE_NO_MEMORY; goto UnlockAndExit; } /* Construct a descriptor pointing to the name */ ObjDesc->Reference.Opcode = (UINT8) AML_NAME_OP; ObjDesc->Reference.Object = (void *) Node; /* * Use ResolveToValue() to get the associated value. This call * always deletes ObjDesc (allocated above). * * NOTE: we can get away with passing in NULL for a walk state * because ObjDesc is guaranteed to not be a reference to either * a method local or a method argument * * Even though we do not directly invoke the interpreter * for this, we must enter it because we could access an opregion. * The opregion access code assumes that the interpreter * is locked. * * We must release the namespace lock before entering the * intepreter. */ AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); Status = AcpiExEnterInterpreter (); if (ACPI_SUCCESS (Status)) { Status = AcpiExResolveToValue (&ObjDesc, NULL); AcpiExExitInterpreter (); } } /* * If AcpiExResolveToValue() succeeded, the return value was * placed in ObjDesc. */ if (ACPI_SUCCESS (Status)) { Status = AE_CTRL_RETURN_VALUE; *ReturnObjDesc = ObjDesc; - DEBUG_PRINTP (ACPI_INFO, ("Returning obj %p\n", *ReturnObjDesc)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Returning obj %p\n", *ReturnObjDesc)); } /* Namespace is unlocked */ return_ACPI_STATUS (Status); UnlockAndExit: /* Unlock the namespace */ AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsinit.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsinit.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsinit.c (revision 82367) @@ -1,474 +1,477 @@ /****************************************************************************** * * Module Name: nsinit - namespace initialization - * $Revision: 28 $ + * $Revision: 29 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSXFINIT_C__ #include "acpi.h" #include "acnamesp.h" #include "acdispat.h" #include "acinterp.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nsinit") /******************************************************************************* * * FUNCTION: AcpiNsInitializeObjects * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Walk the entire namespace and perform any necessary * initialization on the objects found therein * ******************************************************************************/ ACPI_STATUS AcpiNsInitializeObjects ( void) { ACPI_STATUS Status; ACPI_INIT_WALK_INFO Info; FUNCTION_TRACE ("NsInitializeObjects"); - DEBUG_PRINTP (TRACE_DISPATCH, - ("**** Starting initialization of namespace objects ****\n")); - DEBUG_PRINT_RAW (ACPI_OK, ("Completing Region and Field initialization:")); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "**** Starting initialization of namespace objects ****\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, "Completing Region and Field initialization:")); Info.FieldCount = 0; Info.FieldInit = 0; Info.OpRegionCount = 0; Info.OpRegionInit = 0; Info.ObjectCount = 0; /* Walk entire namespace from the supplied root */ Status = AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, AcpiNsInitOneObject, &Info, NULL); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("WalkNamespace failed! %x\n", Status)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "WalkNamespace failed! %x\n", Status)); } - DEBUG_PRINT_RAW (ACPI_OK, - ("\n%d/%d Regions, %d/%d Fields initialized (%d nodes total)\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, + "\n%d/%d Regions, %d/%d Fields initialized (%d nodes total)\n", Info.OpRegionInit, Info.OpRegionCount, Info.FieldInit, Info.FieldCount, Info.ObjectCount)); - DEBUG_PRINTP (TRACE_DISPATCH, - ("%d Control Methods found\n", Info.MethodCount)); - DEBUG_PRINTP (TRACE_DISPATCH, - ("%d Op Regions found\n", Info.OpRegionCount)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "%d Control Methods found\n", Info.MethodCount)); + ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, + "%d Op Regions found\n", Info.OpRegionCount)); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiNsInitializeDevices * * PARAMETERS: None * * RETURN: ACPI_STATUS * * DESCRIPTION: Walk the entire namespace and initialize all ACPI devices. * This means running _INI on all present devices. * * Note: We install PCI config space handler on region access, * not here. * ******************************************************************************/ ACPI_STATUS AcpiNsInitializeDevices ( void) { ACPI_STATUS Status; ACPI_DEVICE_WALK_INFO Info; FUNCTION_TRACE ("NsInitializeDevices"); Info.DeviceCount = 0; Info.Num_STA = 0; Info.Num_INI = 0; - DEBUG_PRINT_RAW (ACPI_OK, ("Executing device _INI methods:")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, "Executing device _INI methods:")); Status = AcpiNsWalkNamespace (ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, FALSE, AcpiNsInitOneDevice, &Info, NULL); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("WalkNamespace failed! %x\n", Status)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "WalkNamespace failed! %x\n", Status)); } - DEBUG_PRINT_RAW (ACPI_OK, - ("\n%d Devices found: %d _STA, %d _INI\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, + "\n%d Devices found: %d _STA, %d _INI\n", Info.DeviceCount, Info.Num_STA, Info.Num_INI)); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsInitOneObject * * PARAMETERS: ObjHandle - Node * Level - Current nesting level * Context - Points to a init info struct * ReturnValue - Not used * * RETURN: Status * * DESCRIPTION: Callback from AcpiWalkNamespace. Invoked for every object * within the namespace. * * Currently, the only objects that require initialization are: * 1) Methods * 2) Op Regions * ******************************************************************************/ ACPI_STATUS AcpiNsInitOneObject ( ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue) { ACPI_OBJECT_TYPE8 Type; ACPI_STATUS Status; ACPI_INIT_WALK_INFO *Info = (ACPI_INIT_WALK_INFO *) Context; ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) ObjHandle; ACPI_OPERAND_OBJECT *ObjDesc; + PROC_NAME ("AcpiNsInitOneObject"); + + Info->ObjectCount++; /* And even then, we are only interested in a few object types */ Type = AcpiNsGetType (ObjHandle); ObjDesc = Node->Object; if (!ObjDesc) { return (AE_OK); } if ((Type != ACPI_TYPE_REGION) && (Type != ACPI_TYPE_BUFFER_FIELD)) { return (AE_OK); } /* * Must lock the interpreter before executing AML code */ Status = AcpiExEnterInterpreter (); if (ACPI_FAILURE (Status)) { return (Status); } switch (Type) { case ACPI_TYPE_REGION: Info->OpRegionCount++; if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID) { break; } Info->OpRegionInit++; Status = AcpiDsGetRegionArguments (ObjDesc); if (ACPI_FAILURE (Status)) { - DEBUG_PRINT_RAW (ACPI_ERROR, ("\n")); - DEBUG_PRINT (ACPI_ERROR, - ("%s while getting region arguments [%4.4s]\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ERROR, "\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "%s while getting region arguments [%4.4s]\n", AcpiFormatException (Status), &Node->Name)); } - if (!(AcpiDbgLevel & TRACE_INIT)) + if (!(AcpiDbgLevel & ACPI_LV_INIT)) { - DEBUG_PRINT_RAW (ACPI_OK, (".")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, ".")); } break; case ACPI_TYPE_BUFFER_FIELD: Info->FieldCount++; if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID) { break; } Info->FieldInit++; Status = AcpiDsGetBufferFieldArguments (ObjDesc); if (ACPI_FAILURE (Status)) { - DEBUG_PRINT_RAW (ACPI_ERROR, ("\n")); - DEBUG_PRINT (ACPI_ERROR, - ("%s while getting buffer field arguments [%4.4s]\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ERROR, "\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "%s while getting buffer field arguments [%4.4s]\n", AcpiFormatException (Status), &Node->Name)); } - if (!(AcpiDbgLevel & TRACE_INIT)) + if (!(AcpiDbgLevel & ACPI_LV_INIT)) { - DEBUG_PRINT_RAW (ACPI_OK, (".")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, ".")); } break; default: break; } /* * We ignore errors from above, and always return OK, since * we don't want to abort the walk on a single error. */ AcpiExExitInterpreter (); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiNsInitOneDevice * * PARAMETERS: ACPI_WALK_CALLBACK * * RETURN: ACPI_STATUS * * DESCRIPTION: This is called once per device soon after ACPI is enabled * to initialize each device. It determines if the device is * present, and if so, calls _INI. * ******************************************************************************/ ACPI_STATUS AcpiNsInitOneDevice ( ACPI_HANDLE ObjHandle, UINT32 NestingLevel, void *Context, void **ReturnValue) { ACPI_STATUS Status; ACPI_NAMESPACE_NODE *Node; UINT32 Flags; ACPI_DEVICE_WALK_INFO *Info = (ACPI_DEVICE_WALK_INFO *) Context; FUNCTION_TRACE ("AcpiNsInitOneDevice"); - if (!(AcpiDbgLevel & TRACE_INIT)) + if (!(AcpiDbgLevel & ACPI_LV_INIT)) { - DEBUG_PRINT_RAW (ACPI_OK, (".")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, ".")); } Info->DeviceCount++; AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); Node = AcpiNsConvertHandleToEntry (ObjHandle); if (!Node) { AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return (AE_BAD_PARAMETER); } AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); /* * Run _STA to determine if we can run _INI on the device. */ DEBUG_EXEC (AcpiUtDisplayInitPathname (Node, "_STA [Method]")); Status = AcpiUtExecute_STA (Node, &Flags); if (ACPI_FAILURE (Status)) { /* Ignore error and move on to next device */ return_ACPI_STATUS (AE_OK); } Info->Num_STA++; if (!(Flags & 0x01)) { /* don't look at children of a not present device */ return_ACPI_STATUS(AE_CTRL_DEPTH); } /* * The device is present. Run _INI. */ DEBUG_EXEC (AcpiUtDisplayInitPathname (ObjHandle, "_INI [Method]")); Status = AcpiNsEvaluateRelative (ObjHandle, "_INI", NULL, NULL); if (AE_NOT_FOUND == Status) { /* No _INI means device requires no initialization */ Status = AE_OK; } else if (ACPI_FAILURE (Status)) { /* Ignore error and move on to next device */ #ifdef ACPI_DEBUG NATIVE_CHAR *ScopeName = AcpiNsGetTablePathname (ObjHandle); - DEBUG_PRINTP (ACPI_WARN, ("%s._INI failed: %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "%s._INI failed: %s\n", ScopeName, AcpiFormatException (Status))); ACPI_MEM_FREE (ScopeName); #endif } else { /* Count of successful INIs */ Info->Num_INI++; } return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsload.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsload.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsload.c (revision 82367) @@ -1,687 +1,687 @@ /****************************************************************************** * * Module Name: nsload - namespace loading/expanding/contracting procedures - * $Revision: 41 $ + * $Revision: 42 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSLOAD_C__ #include "acpi.h" #include "acinterp.h" #include "acnamesp.h" #include "amlcode.h" #include "acparser.h" #include "acdispat.h" #include "acdebug.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nsload") /******************************************************************************* * * FUNCTION: AcpiLoadNamespace * * PARAMETERS: DisplayAmlDuringLoad * * RETURN: Status * * DESCRIPTION: Load the name space from what ever is pointed to by DSDT. * (DSDT points to either the BIOS or a buffer.) * ******************************************************************************/ ACPI_STATUS AcpiNsLoadNamespace ( void) { ACPI_STATUS Status; FUNCTION_TRACE ("AcpiLoadNameSpace"); /* There must be at least a DSDT installed */ if (AcpiGbl_DSDT == NULL) { - DEBUG_PRINTP (ACPI_ERROR, ("DSDT is not in memory\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "DSDT is not in memory\n")); return_ACPI_STATUS (AE_NO_ACPI_TABLES); } /* * Load the namespace. The DSDT is required, * but the SSDT and PSDT tables are optional. */ Status = AcpiNsLoadTableByType (ACPI_TABLE_DSDT); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Ignore exceptions from these */ AcpiNsLoadTableByType (ACPI_TABLE_SSDT); AcpiNsLoadTableByType (ACPI_TABLE_PSDT); - DEBUG_PRINT_RAW (ACPI_OK, - ("ACPI Namespace successfully loaded at root %p\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, + "ACPI Namespace successfully loaded at root %p\n", AcpiGbl_RootNode)); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsOneParsePass * * PARAMETERS: * * RETURN: Status * * DESCRIPTION: * ******************************************************************************/ ACPI_STATUS AcpiNsOneCompleteParse ( UINT32 PassNumber, ACPI_TABLE_DESC *TableDesc) { ACPI_PARSE_DOWNWARDS DescendingCallback; ACPI_PARSE_UPWARDS AscendingCallback; ACPI_PARSE_OBJECT *ParseRoot; ACPI_STATUS Status; FUNCTION_TRACE ("NsOneCompleteParse"); switch (PassNumber) { case 1: DescendingCallback = AcpiDsLoad1BeginOp; AscendingCallback = AcpiDsLoad1EndOp; break; case 2: DescendingCallback = AcpiDsLoad2BeginOp; AscendingCallback = AcpiDsLoad2EndOp; break; case 3: DescendingCallback = AcpiDsExecBeginOp; AscendingCallback = AcpiDsExecEndOp; break; default: return (AE_BAD_PARAMETER); } /* Create and init a Root Node */ ParseRoot = AcpiPsAllocOp (AML_SCOPE_OP); if (!ParseRoot) { return_ACPI_STATUS (AE_NO_MEMORY); } ((ACPI_PARSE2_OBJECT *) ParseRoot)->Name = ACPI_ROOT_NAME; /* Pass 1: Parse everything except control method bodies */ - DEBUG_PRINTP (TRACE_PARSE, ("*PARSE* pass %d parse\n", PassNumber)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "*PARSE* pass %d parse\n", PassNumber)); Status = AcpiPsParseAml (ParseRoot, TableDesc->AmlPointer, TableDesc->AmlLength, ACPI_PARSE_LOAD_PASS1 | ACPI_PARSE_DELETE_TREE, NULL, NULL, NULL, DescendingCallback, AscendingCallback); AcpiPsDeleteParseTree (ParseRoot); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsParseTable * * PARAMETERS: TableDesc - An ACPI table descriptor for table to parse * StartNode - Where to enter the table into the namespace * * RETURN: Status * * DESCRIPTION: Parse AML within an ACPI table and return a tree of ops * ******************************************************************************/ ACPI_STATUS AcpiNsParseTable ( ACPI_TABLE_DESC *TableDesc, ACPI_NAMESPACE_NODE *StartNode) { ACPI_STATUS Status; FUNCTION_TRACE ("NsParseTable"); /* * AML Parse, pass 1 * * In this pass, we load most of the namespace. Control methods * are not parsed until later. A parse tree is not created. Instead, * each Parser Op subtree is deleted when it is finished. This saves * a great deal of memory, and allows a small cache of parse objects * to service the entire parse. The second pass of the parse then * performs another complete parse of the AML.. */ Status = AcpiNsOneCompleteParse (1, TableDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * AML Parse, pass 2 * * In this pass, we resolve forward references and other things * that could not be completed during the first pass. * Another complete parse of the AML is performed, but the * overhead of this is compensated for by the fact that the * parse objects are all cached. */ Status = AcpiNsOneCompleteParse (2, TableDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsLoadTable * * PARAMETERS: *PcodeAddr - Address of pcode block * PcodeLength - Length of pcode block * * RETURN: Status * * DESCRIPTION: Load one ACPI table into the namespace * ******************************************************************************/ ACPI_STATUS AcpiNsLoadTable ( ACPI_TABLE_DESC *TableDesc, ACPI_NAMESPACE_NODE *Node) { ACPI_STATUS Status; FUNCTION_TRACE ("NsLoadTable"); if (!TableDesc->AmlPointer) { - DEBUG_PRINTP (ACPI_ERROR, ("Null AML pointer\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null AML pointer\n")); return_ACPI_STATUS (AE_BAD_PARAMETER); } - DEBUG_PRINTP (ACPI_INFO, ("AML block at %p\n", TableDesc->AmlPointer)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "AML block at %p\n", TableDesc->AmlPointer)); if (!TableDesc->AmlLength) { - DEBUG_PRINTP (ACPI_ERROR, ("Zero-length AML block\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Zero-length AML block\n")); return_ACPI_STATUS (AE_BAD_PARAMETER); } /* * Parse the table and load the namespace with all named * objects found within. Control methods are NOT parsed * at this time. In fact, the control methods cannot be * parsed until the entire namespace is loaded, because * if a control method makes a forward reference (call) * to another control method, we can't continue parsing * because we don't know how many arguments to parse next! */ - DEBUG_PRINTP (ACPI_INFO, ("**** Loading table into namespace ****\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "**** Loading table into namespace ****\n")); AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); Status = AcpiNsParseTable (TableDesc, Node->Child); AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Now we can parse the control methods. We always parse * them here for a sanity check, and if configured for * just-in-time parsing, we delete the control method * parse trees. */ - DEBUG_PRINTP (ACPI_INFO, - ("**** Begin Table Method Parsing and Object Initialization ****\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "**** Begin Table Method Parsing and Object Initialization ****\n")); Status = AcpiDsInitializeObjects (TableDesc, Node); - DEBUG_PRINTP (ACPI_INFO, - ("**** Completed Table Method Parsing and Object Initialization ****\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "**** Completed Table Method Parsing and Object Initialization ****\n")); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsLoadTableByType * * PARAMETERS: TableType - Id of the table type to load * * RETURN: Status * * DESCRIPTION: Load an ACPI table or tables into the namespace. All tables * of the given type are loaded. The mechanism allows this * routine to be called repeatedly. * ******************************************************************************/ ACPI_STATUS AcpiNsLoadTableByType ( ACPI_TABLE_TYPE TableType) { UINT32 i; ACPI_STATUS Status = AE_OK; ACPI_TABLE_DESC *TableDesc; FUNCTION_TRACE ("NsLoadTableByType"); AcpiUtAcquireMutex (ACPI_MTX_TABLES); /* * Table types supported are: * DSDT (one), SSDT/PSDT (multiple) */ switch (TableType) { case ACPI_TABLE_DSDT: - DEBUG_PRINTP (ACPI_INFO, ("Loading DSDT\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Loading DSDT\n")); TableDesc = &AcpiGbl_AcpiTables[ACPI_TABLE_DSDT]; /* If table already loaded into namespace, just return */ if (TableDesc->LoadedIntoNamespace) { goto UnlockAndExit; } TableDesc->TableId = TABLE_ID_DSDT; /* Now load the single DSDT */ Status = AcpiNsLoadTable (TableDesc, AcpiGbl_RootNode); if (ACPI_SUCCESS (Status)) { TableDesc->LoadedIntoNamespace = TRUE; } break; case ACPI_TABLE_SSDT: - DEBUG_PRINTP (ACPI_INFO, ("Loading %d SSDTs\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Loading %d SSDTs\n", AcpiGbl_AcpiTables[ACPI_TABLE_SSDT].Count)); /* * Traverse list of SSDT tables */ TableDesc = &AcpiGbl_AcpiTables[ACPI_TABLE_SSDT]; for (i = 0; i < AcpiGbl_AcpiTables[ACPI_TABLE_SSDT].Count; i++) { /* * Only attempt to load table if it is not * already loaded! */ if (!TableDesc->LoadedIntoNamespace) { Status = AcpiNsLoadTable (TableDesc, AcpiGbl_RootNode); if (ACPI_FAILURE (Status)) { break; } TableDesc->LoadedIntoNamespace = TRUE; } TableDesc = TableDesc->Next; } break; case ACPI_TABLE_PSDT: - DEBUG_PRINTP (ACPI_INFO, ("Loading %d PSDTs\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Loading %d PSDTs\n", AcpiGbl_AcpiTables[ACPI_TABLE_PSDT].Count)); /* * Traverse list of PSDT tables */ TableDesc = &AcpiGbl_AcpiTables[ACPI_TABLE_PSDT]; for (i = 0; i < AcpiGbl_AcpiTables[ACPI_TABLE_PSDT].Count; i++) { /* Only attempt to load table if it is not already loaded! */ if (!TableDesc->LoadedIntoNamespace) { Status = AcpiNsLoadTable (TableDesc, AcpiGbl_RootNode); if (ACPI_FAILURE (Status)) { break; } TableDesc->LoadedIntoNamespace = TRUE; } TableDesc = TableDesc->Next; } break; default: Status = AE_SUPPORT; break; } UnlockAndExit: AcpiUtReleaseMutex (ACPI_MTX_TABLES); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsDeleteSubtree * * PARAMETERS: StartHandle - Handle in namespace where search begins * * RETURNS Status * * DESCRIPTION: Walks the namespace starting at the given handle and deletes * all objects, entries, and scopes in the entire subtree. * * TBD: [Investigate] What if any part of this subtree is in use? * (i.e. on one of the object stacks?) * ******************************************************************************/ ACPI_STATUS AcpiNsDeleteSubtree ( ACPI_HANDLE StartHandle) { ACPI_STATUS Status; ACPI_HANDLE ChildHandle; ACPI_HANDLE ParentHandle; ACPI_HANDLE NextChildHandle; ACPI_HANDLE Dummy; UINT32 Level; FUNCTION_TRACE ("NsDeleteSubtree"); ParentHandle = StartHandle; ChildHandle = 0; Level = 1; /* * Traverse the tree of objects until we bubble back up * to where we started. */ while (Level > 0) { /* Attempt to get the next object in this scope */ Status = AcpiGetNextObject (ACPI_TYPE_ANY, ParentHandle, ChildHandle, &NextChildHandle); ChildHandle = NextChildHandle; /* Did we get a new object? */ if (ACPI_SUCCESS (Status)) { /* Check if this object has any children */ if (ACPI_SUCCESS (AcpiGetNextObject (ACPI_TYPE_ANY, ChildHandle, 0, &Dummy))) { /* * There is at least one child of this object, * visit the object */ Level++; ParentHandle = ChildHandle; ChildHandle = 0; } } else { /* * No more children in this object, go back up to * the object's parent */ Level--; /* Delete all children now */ AcpiNsDeleteChildren (ChildHandle); ChildHandle = ParentHandle; AcpiGetParent (ParentHandle, &ParentHandle); } } /* Now delete the starting object, and we are done */ AcpiNsDeleteNode (ChildHandle); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiNsUnloadNameSpace * * PARAMETERS: Handle - Root of namespace subtree to be deleted * * RETURN: Status * * DESCRIPTION: Shrinks the namespace, typically in response to an undocking * event. Deletes an entire subtree starting from (and * including) the given handle. * ******************************************************************************/ ACPI_STATUS AcpiNsUnloadNamespace ( ACPI_HANDLE Handle) { ACPI_STATUS Status; FUNCTION_TRACE ("NsUnloadNameSpace"); /* Parameter validation */ if (!AcpiGbl_RootNode) { return_ACPI_STATUS (AE_NO_NAMESPACE); } if (!Handle) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* This function does the real work */ Status = AcpiNsDeleteSubtree (Handle); return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsnames.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsnames.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsnames.c (revision 82367) @@ -1,363 +1,363 @@ /******************************************************************************* * * Module Name: nsnames - Name manipulation and search - * $Revision: 60 $ + * $Revision: 61 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSNAMES_C__ #include "acpi.h" #include "amlcode.h" #include "acinterp.h" #include "acnamesp.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nsnames") /******************************************************************************* * * FUNCTION: AcpiNsGetTablePathname * * PARAMETERS: Node - Scope whose name is needed * * RETURN: Pointer to storage containing the fully qualified name of * the scope, in Label format (all segments strung together * with no separators) * * DESCRIPTION: Used for debug printing in AcpiNsSearchTable(). * ******************************************************************************/ NATIVE_CHAR * AcpiNsGetTablePathname ( ACPI_NAMESPACE_NODE *Node) { NATIVE_CHAR *NameBuffer; UINT32 Size; ACPI_NAME Name; ACPI_NAMESPACE_NODE *ChildNode; ACPI_NAMESPACE_NODE *ParentNode; FUNCTION_TRACE_PTR ("AcpiNsGetTablePathname", Node); if (!AcpiGbl_RootNode || !Node) { /* * If the name space has not been initialized, * this function should not have been called. */ return_PTR (NULL); } ChildNode = Node->Child; /* Calculate required buffer size based on depth below root */ Size = 1; ParentNode = ChildNode; while (ParentNode) { ParentNode = AcpiNsGetParentObject (ParentNode); if (ParentNode) { Size += ACPI_NAME_SIZE; } } /* Allocate a buffer to be returned to caller */ NameBuffer = ACPI_MEM_CALLOCATE (Size + 1); if (!NameBuffer) { REPORT_ERROR (("NsGetTablePathname: allocation failure\n")); return_PTR (NULL); } /* Store terminator byte, then build name backwards */ NameBuffer[Size] = '\0'; while ((Size > ACPI_NAME_SIZE) && AcpiNsGetParentObject (ChildNode)) { Size -= ACPI_NAME_SIZE; Name = AcpiNsFindParentName (ChildNode); /* Put the name into the buffer */ MOVE_UNALIGNED32_TO_32 ((NameBuffer + Size), &Name); ChildNode = AcpiNsGetParentObject (ChildNode); } NameBuffer[--Size] = AML_ROOT_PREFIX; if (Size != 0) { - DEBUG_PRINTP (ACPI_ERROR, ("Bad pointer returned; size=%X\n", Size)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Bad pointer returned; size=%X\n", Size)); } return_PTR (NameBuffer); } /******************************************************************************* * * FUNCTION: AcpiNsGetPathnameLength * * PARAMETERS: Node - Namespace node * * RETURN: Length of path, including prefix * * DESCRIPTION: Get the length of the pathname string for this node * ******************************************************************************/ UINT32 AcpiNsGetPathnameLength ( ACPI_NAMESPACE_NODE *Node) { UINT32 Size; ACPI_NAMESPACE_NODE *NextNode; /* * Compute length of pathname as 5 * number of name segments. * Go back up the parent tree to the root */ for (Size = 0, NextNode = Node; AcpiNsGetParentObject (NextNode); NextNode = AcpiNsGetParentObject (NextNode)) { Size += PATH_SEGMENT_LENGTH; } /* Special case for size still 0 - no parent for "special" nodes */ if (!Size) { Size = PATH_SEGMENT_LENGTH; } return (Size + 1); } /******************************************************************************* * * FUNCTION: AcpiNsHandleToPathname * * PARAMETERS: TargetHandle - Handle of named object whose name is * to be found * BufSize - Size of the buffer provided * UserBuffer - Where the pathname is returned * * RETURN: Status, Buffer is filled with pathname if status is AE_OK * * DESCRIPTION: Build and return a full namespace pathname * * MUTEX: Locks Namespace * ******************************************************************************/ ACPI_STATUS AcpiNsHandleToPathname ( ACPI_HANDLE TargetHandle, UINT32 *BufSize, NATIVE_CHAR *UserBuffer) { ACPI_STATUS Status = AE_OK; ACPI_NAMESPACE_NODE *Node; UINT32 PathLength; UINT32 UserBufSize; ACPI_NAME Name; UINT32 Size; FUNCTION_TRACE_PTR ("NsHandleToPathname", TargetHandle); if (!AcpiGbl_RootNode) { /* * If the name space has not been initialized, * this function should not have been called. */ return_ACPI_STATUS (AE_NO_NAMESPACE); } Node = AcpiNsConvertHandleToEntry (TargetHandle); if (!Node) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Set return length to the required path length */ PathLength = AcpiNsGetPathnameLength (Node); Size = PathLength - 1; UserBufSize = *BufSize; *BufSize = PathLength; /* Check if the user buffer is sufficiently large */ if (PathLength > UserBufSize) { Status = AE_BUFFER_OVERFLOW; goto Exit; } /* Store null terminator */ UserBuffer[Size] = 0; Size -= ACPI_NAME_SIZE; /* Put the original ACPI name at the end of the path */ MOVE_UNALIGNED32_TO_32 ((UserBuffer + Size), &Node->Name); UserBuffer[--Size] = PATH_SEPARATOR; /* Build name backwards, putting "." between segments */ while ((Size > ACPI_NAME_SIZE) && Node) { Size -= ACPI_NAME_SIZE; Name = AcpiNsFindParentName (Node); MOVE_UNALIGNED32_TO_32 ((UserBuffer + Size), &Name); UserBuffer[--Size] = PATH_SEPARATOR; Node = AcpiNsGetParentObject (Node); } /* * Overlay the "." preceding the first segment with * the root name "\" */ UserBuffer[Size] = '\\'; - DEBUG_PRINTP (TRACE_EXEC, ("Len=%X, %s \n", PathLength, UserBuffer)); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Len=%X, %s \n", PathLength, UserBuffer)); Exit: return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsobject.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsobject.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsobject.c (revision 82367) @@ -1,517 +1,509 @@ /******************************************************************************* * * Module Name: nsobject - Utilities for objects attached to namespace * table entries - * $Revision: 56 $ + * $Revision: 60 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSOBJECT_C__ #include "acpi.h" #include "amlcode.h" #include "acnamesp.h" #include "acinterp.h" #include "actables.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nsobject") /******************************************************************************* * * FUNCTION: AcpiNsAttachObject * - * PARAMETERS: Node - Parent Node + * PARAMETERS: Node - Parent Node * Object - Object to be attached * Type - Type of object, or ACPI_TYPE_ANY if not - * known + * known * * DESCRIPTION: Record the given object as the value associated with the * name whose ACPI_HANDLE is passed. If Object is NULL * and Type is ACPI_TYPE_ANY, set the name as having no value. * * MUTEX: Assumes namespace is locked * ******************************************************************************/ ACPI_STATUS AcpiNsAttachObject ( ACPI_NAMESPACE_NODE *Node, ACPI_OPERAND_OBJECT *Object, ACPI_OBJECT_TYPE8 Type) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *PreviousObjDesc; - ACPI_OBJECT_TYPE8 ObjType = ACPI_TYPE_ANY; + ACPI_OBJECT_TYPE8 ObjType = ACPI_TYPE_ANY; UINT8 Flags; UINT16 Opcode; FUNCTION_TRACE ("NsAttachObject"); /* * Parameter validation */ - if (!AcpiGbl_RootNode) { /* Name space not initialized */ REPORT_ERROR (("NsAttachObject: Namespace not initialized\n")); return_ACPI_STATUS (AE_NO_NAMESPACE); } if (!Node) { /* Invalid handle */ REPORT_ERROR (("NsAttachObject: Null NamedObj handle\n")); return_ACPI_STATUS (AE_BAD_PARAMETER); } if (!Object && (ACPI_TYPE_ANY != Type)) { /* Null object */ REPORT_ERROR (("NsAttachObject: Null object, but type not ACPI_TYPE_ANY\n")); return_ACPI_STATUS (AE_BAD_PARAMETER); } if (!VALID_DESCRIPTOR_TYPE (Node, ACPI_DESC_TYPE_NAMED)) { /* Not a name handle */ REPORT_ERROR (("NsAttachObject: Invalid handle\n")); return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Check if this object is already attached */ if (Node->Object == Object) { - DEBUG_PRINTP (TRACE_EXEC, ("Obj %p already installed in NameObj %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj %p already installed in NameObj %p\n", Object, Node)); return_ACPI_STATUS (AE_OK); } /* Get the current flags field of the Node */ Flags = Node->Flags; Flags &= ~ANOBJ_AML_ATTACHMENT; /* If null object, we will just install it */ if (!Object) { ObjDesc = NULL; ObjType = ACPI_TYPE_ANY; } /* * If the object is an Node with an attached object, * we will use that (attached) object */ - else if (VALID_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_NAMED) && ((ACPI_NAMESPACE_NODE *) Object)->Object) { /* * Value passed is a name handle and that name has a * non-null value. Use that name's value and type. */ - ObjDesc = ((ACPI_NAMESPACE_NODE *) Object)->Object; ObjType = ((ACPI_NAMESPACE_NODE *) Object)->Type; /* * Copy appropriate flags */ - if (((ACPI_NAMESPACE_NODE *) Object)->Flags & ANOBJ_AML_ATTACHMENT) { Flags |= ANOBJ_AML_ATTACHMENT; } } /* * Otherwise, we will use the parameter object, but we must type * it first */ - else { ObjDesc = (ACPI_OPERAND_OBJECT *) Object; /* If a valid type (non-ANY) was given, just use it */ if (ACPI_TYPE_ANY != Type) { ObjType = Type; } /* * Type is TYPE_Any, we must try to determinte the * actual type of the object */ /* * Check if value points into the AML code */ else if (AcpiTbSystemTablePointer (Object)) { /* * Object points into the AML stream. * Set a flag bit in the Node to indicate this */ - Flags |= ANOBJ_AML_ATTACHMENT; /* * The next byte (perhaps the next two bytes) * will be the AML opcode */ - MOVE_UNALIGNED16_TO_16 (&Opcode, Object); /* Check for a recognized Opcode */ switch ((UINT8) Opcode) { case AML_OP_PREFIX: if (Opcode != AML_REVISION_OP) { /* * OpPrefix is unrecognized unless part * of RevisionOp */ - break; } - /* Else fall through to set type as Number */ + /* Otherwise, fall through and set the type to Integer */ + case AML_ZERO_OP: + case AML_ONES_OP: + case AML_ONE_OP: + case AML_BYTE_OP: + case AML_WORD_OP: + case AML_DWORD_OP: + case AML_QWORD_OP: - case AML_ZERO_OP: case AML_ONES_OP: case AML_ONE_OP: - case AML_BYTE_OP: case AML_WORD_OP: case AML_DWORD_OP: - ObjType = ACPI_TYPE_INTEGER; break; case AML_STRING_OP: ObjType = ACPI_TYPE_STRING; break; case AML_BUFFER_OP: ObjType = ACPI_TYPE_BUFFER; break; case AML_MUTEX_OP: ObjType = ACPI_TYPE_MUTEX; break; case AML_PACKAGE_OP: ObjType = ACPI_TYPE_PACKAGE; break; default: - DEBUG_PRINTP (ACPI_ERROR, - ("AML Opcode/Type [%x] not supported in attach\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "AML Opcode/Type [%x] not supported in attach\n", (UINT8) Opcode)); return_ACPI_STATUS (AE_TYPE); break; } } else { /* * Cannot figure out the type -- set to DefAny which * will print as an error in the name table dump */ - if (GetDebugLevel () > 0) { DUMP_PATHNAME (Node, "NsAttachObject confused: setting bogus type for ", - ACPI_INFO, _COMPONENT); + ACPI_LV_INFO, _COMPONENT); if (AcpiTbSystemTablePointer (Object)) { - DEBUG_PRINTP (ACPI_INFO, - ("AML-stream code %02x\n", *(UINT8 *) Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "AML-stream code %02x\n", *(UINT8 *) Object)); } else if (VALID_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_NAMED)) { - DUMP_PATHNAME (Object, "name ", ACPI_INFO, _COMPONENT); + DUMP_PATHNAME (Object, "name ", ACPI_LV_INFO, _COMPONENT); } else { - DUMP_PATHNAME (Object, "object ", ACPI_INFO, _COMPONENT); + DUMP_PATHNAME (Object, "object ", ACPI_LV_INFO, _COMPONENT); DUMP_STACK_ENTRY (Object); } } ObjType = INTERNAL_TYPE_DEF_ANY; } } - DEBUG_PRINTP (TRACE_EXEC, ("Installing obj %p into NameObj %p [%4.4s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Installing %p into Node %p [%4.4s]\n", ObjDesc, Node, &Node->Name)); /* * Must increment the new value's reference count * (if it is an internal object) */ - AcpiUtAddReference (ObjDesc); /* Save the existing object (if any) for deletion later */ PreviousObjDesc = Node->Object; /* Install the object and set the type, flags */ Node->Object = ObjDesc; Node->Type = (UINT8) ObjType; Node->Flags |= Flags; /* * Delete an existing attached object. */ - if (PreviousObjDesc) { /* One for the attach to the Node */ AcpiUtRemoveReference (PreviousObjDesc); /* Now delete */ AcpiUtRemoveReference (PreviousObjDesc); } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiNsDetachObject * * PARAMETERS: Node - An object whose Value will be deleted * * RETURN: None. * * DESCRIPTION: Delete the Value associated with a namespace object. If the * Value is an allocated object, it is freed. Otherwise, the * field is simply cleared. * ******************************************************************************/ void AcpiNsDetachObject ( ACPI_NAMESPACE_NODE *Node) { ACPI_OPERAND_OBJECT *ObjDesc; FUNCTION_TRACE ("NsDetachObject"); ObjDesc = Node->Object; if (!ObjDesc) { return_VOID; } /* Clear the entry in all cases */ Node->Object = NULL; /* Found a valid value */ - DEBUG_PRINTP (ACPI_INFO, ("Object=%p Value=%p Name %4.4s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Object=%p Value=%p Name %4.4s\n", Node, ObjDesc, &Node->Name)); /* * Not every value is an object allocated via ACPI_MEM_CALLOCATE, * - must check */ - if (!AcpiTbSystemTablePointer (ObjDesc)) { /* Attempt to delete the object (and all subobjects) */ AcpiUtRemoveReference (ObjDesc); } return_VOID; } /******************************************************************************* * * FUNCTION: AcpiNsGetAttachedObject * * PARAMETERS: Node - Parent Node to be examined * * RETURN: Current value of the object field from the Node whose * handle is passed * ******************************************************************************/ void * AcpiNsGetAttachedObject ( ACPI_NAMESPACE_NODE *Node) { FUNCTION_TRACE_PTR ("NsGetAttachedObject", Node); if (!Node) { /* handle invalid */ - DEBUG_PRINTP (ACPI_WARN, ("Null Node ptr\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Null Node ptr\n")); return_PTR (NULL); } return_PTR (Node->Object); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nssearch.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nssearch.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nssearch.c (revision 82367) @@ -1,505 +1,505 @@ /******************************************************************************* * * Module Name: nssearch - Namespace search - * $Revision: 71 $ + * $Revision: 72 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSSEARCH_C__ #include "acpi.h" #include "amlcode.h" #include "acinterp.h" #include "acnamesp.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nssearch") /******************************************************************************* * * FUNCTION: AcpiNsSearchNode * * PARAMETERS: *TargetName - Ascii ACPI name to search for * *Node - Starting table where search will begin * Type - Object type to match * **ReturnNode - Where the matched Named obj is returned * * RETURN: Status * * DESCRIPTION: Search a single namespace table. Performs a simple search, * does not add entries or search parents. * * * Named object lists are built (and subsequently dumped) in the * order in which the names are encountered during the namespace load; * * All namespace searching is linear in this implementation, but * could be easily modified to support any improved search * algorithm. However, the linear search was chosen for simplicity * and because the trees are small and the other interpreter * execution overhead is relatively high. * ******************************************************************************/ ACPI_STATUS AcpiNsSearchNode ( UINT32 TargetName, ACPI_NAMESPACE_NODE *Node, ACPI_OBJECT_TYPE8 Type, ACPI_NAMESPACE_NODE **ReturnNode) { ACPI_NAMESPACE_NODE *NextNode; FUNCTION_TRACE ("NsSearchNode"); #ifdef ACPI_DEBUG - if (TRACE_NAMES & AcpiDbgLevel) + if (ACPI_LV_NAMES & AcpiDbgLevel) { NATIVE_CHAR *ScopeName; ScopeName = AcpiNsGetTablePathname (Node); if (ScopeName) { - DEBUG_PRINTP (TRACE_NAMES, ("Searching %s [%p] For %4.4s (type %X)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Searching %s [%p] For %4.4s (type %X)\n", ScopeName, Node, &TargetName, Type)); ACPI_MEM_FREE (ScopeName); } } #endif /* * Search for name in this table, which is to say that we must search * for the name among the children of this object */ NextNode = Node->Child; while (NextNode) { /* Check for match against the name */ if (NextNode->Name == TargetName) { /* * Found matching entry. Capture the type if appropriate, before * returning the entry. * * The DefFieldDefn and BankFieldDefn cases are actually looking up * the Region in which the field will be defined */ if ((INTERNAL_TYPE_FIELD_DEFN == Type) || (INTERNAL_TYPE_BANK_FIELD_DEFN == Type)) { Type = ACPI_TYPE_REGION; } /* * Scope, DefAny, and IndexFieldDefn are bogus "types" which do not * actually have anything to do with the type of the name being * looked up. For any other value of Type, if the type stored in * the entry is Any (i.e. unknown), save the actual type. */ if (Type != INTERNAL_TYPE_SCOPE && Type != INTERNAL_TYPE_DEF_ANY && Type != INTERNAL_TYPE_INDEX_FIELD_DEFN && NextNode->Type == ACPI_TYPE_ANY) { NextNode->Type = (UINT8) Type; } - DEBUG_PRINTP (TRACE_NAMES, - ("Name %4.4s (actual type %X) found at %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, + "Name %4.4s (actual type %X) found at %p\n", &TargetName, NextNode->Type, NextNode)); *ReturnNode = NextNode; return_ACPI_STATUS (AE_OK); } /* * The last entry in the list points back to the parent, * so a flag is used to indicate the end-of-list */ if (NextNode->Flags & ANOBJ_END_OF_PEER_LIST) { /* Searched entire list, we are done */ break; } /* Didn't match name, move on to the next peer object */ NextNode = NextNode->Peer; } /* Searched entire table, not found */ - DEBUG_PRINTP (TRACE_NAMES, ("Name %4.4s (type %X) not found at %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Name %4.4s (type %X) not found at %p\n", &TargetName, Type, NextNode)); return_ACPI_STATUS (AE_NOT_FOUND); } /******************************************************************************* * * FUNCTION: AcpiNsSearchParentTree * * PARAMETERS: *TargetName - Ascii ACPI name to search for * *Node - Starting table where search will begin * Type - Object type to match * **ReturnNode - Where the matched Named Obj is returned * * RETURN: Status * * DESCRIPTION: Called when a name has not been found in the current namespace * table. Before adding it or giving up, ACPI scope rules require * searching enclosing scopes in cases identified by AcpiNsLocal(). * * "A name is located by finding the matching name in the current * name space, and then in the parent name space. If the parent * name space does not contain the name, the search continues * recursively until either the name is found or the name space * does not have a parent (the root of the name space). This * indicates that the name is not found" (From ACPI Specification, * section 5.3) * ******************************************************************************/ static ACPI_STATUS AcpiNsSearchParentTree ( UINT32 TargetName, ACPI_NAMESPACE_NODE *Node, ACPI_OBJECT_TYPE8 Type, ACPI_NAMESPACE_NODE **ReturnNode) { ACPI_STATUS Status; ACPI_NAMESPACE_NODE *ParentNode; FUNCTION_TRACE ("NsSearchParentTree"); ParentNode = AcpiNsGetParentObject (Node); /* * If there is no parent (at the root) or type is "local", we won't be * searching the parent tree. */ if ((AcpiNsLocal (Type)) || (!ParentNode)) { if (!ParentNode) { - DEBUG_PRINTP (TRACE_NAMES, ("[%4.4s] has no parent\n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "[%4.4s] has no parent\n", &TargetName)); } if (AcpiNsLocal (Type)) { - DEBUG_PRINTP (TRACE_NAMES, ("[%4.4s] type %X is local(no search)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "[%4.4s] type %X is local(no search)\n", &TargetName, Type)); } return_ACPI_STATUS (AE_NOT_FOUND); } /* Search the parent tree */ - DEBUG_PRINTP (TRACE_NAMES, ("Searching parent for %4.4s\n", &TargetName)); + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Searching parent for %4.4s\n", &TargetName)); /* * Search parents until found the target or we have backed up to * the root */ while (ParentNode) { /* Search parent scope */ /* TBD: [Investigate] Why ACPI_TYPE_ANY? */ Status = AcpiNsSearchNode (TargetName, ParentNode, ACPI_TYPE_ANY, ReturnNode); if (ACPI_SUCCESS (Status)) { return_ACPI_STATUS (Status); } /* * Not found here, go up another level * (until we reach the root) */ ParentNode = AcpiNsGetParentObject (ParentNode); } /* Not found in parent tree */ return_ACPI_STATUS (AE_NOT_FOUND); } /******************************************************************************* * * FUNCTION: AcpiNsSearchAndEnter * * PARAMETERS: TargetName - Ascii ACPI name to search for (4 chars) * WalkState - Current state of the walk * *Node - Starting table where search will begin * InterpreterMode - Add names only in MODE_LoadPassX. * Otherwise,search only. * Type - Object type to match * Flags - Flags describing the search restrictions * **ReturnNode - Where the Node is returned * * RETURN: Status * * DESCRIPTION: Search for a name segment in a single name table, * optionally adding it if it is not found. If the passed * Type is not Any and the type previously stored in the * entry was Any (i.e. unknown), update the stored type. * * In IMODE_EXECUTE, search only. * In other modes, search and add if not found. * ******************************************************************************/ ACPI_STATUS AcpiNsSearchAndEnter ( UINT32 TargetName, ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE *Node, OPERATING_MODE InterpreterMode, ACPI_OBJECT_TYPE8 Type, UINT32 Flags, ACPI_NAMESPACE_NODE **ReturnNode) { ACPI_STATUS Status; ACPI_NAMESPACE_NODE *NewNode; FUNCTION_TRACE ("NsSearchAndEnter"); /* Parameter validation */ if (!Node || !TargetName || !ReturnNode) { - DEBUG_PRINTP (ACPI_ERROR, ("Null param- Table %p Name %p Return %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null param- Table %p Name %p Return %p\n", Node, TargetName, ReturnNode)); REPORT_ERROR (("NsSearchAndEnter: bad (null) parameter\n")); return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Name must consist of printable characters */ if (!AcpiUtValidAcpiName (TargetName)) { - DEBUG_PRINTP (ACPI_ERROR, ("*** Bad character in name: %08lx *** \n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "*** Bad character in name: %08lx *** \n", TargetName)); REPORT_ERROR (("NsSearchAndEnter: Bad character in ACPI Name\n")); return_ACPI_STATUS (AE_BAD_CHARACTER); } /* Try to find the name in the table specified by the caller */ *ReturnNode = ENTRY_NOT_FOUND; Status = AcpiNsSearchNode (TargetName, Node, Type, ReturnNode); if (Status != AE_NOT_FOUND) { /* * If we found it AND the request specifies that a find is an error, * return the error */ if ((Status == AE_OK) && (Flags & NS_ERROR_IF_FOUND)) { Status = AE_EXIST; } /* * Either found it or there was an error * -- finished either way */ return_ACPI_STATUS (Status); } /* * Not found in the table. If we are NOT performing the * first pass (name entry) of loading the namespace, search * the parent tree (all the way to the root if necessary.) * We don't want to perform the parent search when the * namespace is actually being loaded. We want to perform * the search when namespace references are being resolved * (load pass 2) and during the execution phase. */ if ((InterpreterMode != IMODE_LOAD_PASS1) && (Flags & NS_SEARCH_PARENT)) { /* * Not found in table - search parent tree according * to ACPI specification */ Status = AcpiNsSearchParentTree (TargetName, Node, Type, ReturnNode); if (ACPI_SUCCESS (Status)) { return_ACPI_STATUS (Status); } } /* * In execute mode, just search, never add names. Exit now. */ if (InterpreterMode == IMODE_EXECUTE) { - DEBUG_PRINTP (TRACE_NAMES, ("%4.4s Not found in %p [Not adding]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "%4.4s Not found in %p [Not adding]\n", &TargetName, Node)); return_ACPI_STATUS (AE_NOT_FOUND); } /* Create the new named object */ NewNode = AcpiNsCreateNode (TargetName); if (!NewNode) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Install the new object into the parent's list of children */ AcpiNsInstallNode (WalkState, Node, NewNode, Type); *ReturnNode = NewNode; return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsutils.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsutils.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsutils.c (revision 82367) @@ -1,1099 +1,1099 @@ /****************************************************************************** * * Module Name: nsutils - Utilities for accessing ACPI namespace, accessing * parents and siblings and Scope manipulation - * $Revision: 85 $ + * $Revision: 86 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSUTILS_C__ #include "acpi.h" #include "acnamesp.h" #include "acinterp.h" #include "amlcode.h" #include "actables.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nsutils") /******************************************************************************* * * FUNCTION: AcpiNsValidRootPrefix * * PARAMETERS: Prefix - Character to be checked * * RETURN: TRUE if a valid prefix * * DESCRIPTION: Check if a character is a valid ACPI Root prefix * ******************************************************************************/ BOOLEAN AcpiNsValidRootPrefix ( NATIVE_CHAR Prefix) { return ((BOOLEAN) (Prefix == '\\')); } /******************************************************************************* * * FUNCTION: AcpiNsValidPathSeparator * * PARAMETERS: Sep - Character to be checked * * RETURN: TRUE if a valid path separator * * DESCRIPTION: Check if a character is a valid ACPI path separator * ******************************************************************************/ BOOLEAN AcpiNsValidPathSeparator ( NATIVE_CHAR Sep) { return ((BOOLEAN) (Sep == '.')); } /******************************************************************************* * * FUNCTION: AcpiNsGetType * * PARAMETERS: Handle - Parent Node to be examined * * RETURN: Type field from Node whose handle is passed * ******************************************************************************/ ACPI_OBJECT_TYPE8 AcpiNsGetType ( ACPI_NAMESPACE_NODE *Node) { FUNCTION_TRACE ("NsGetType"); if (!Node) { REPORT_WARNING (("NsGetType: Null Node ptr")); return_VALUE (ACPI_TYPE_ANY); } return_VALUE (Node->Type); } /******************************************************************************* * * FUNCTION: AcpiNsLocal * * PARAMETERS: Type - A namespace object type * * RETURN: LOCAL if names must be found locally in objects of the * passed type, 0 if enclosing scopes should be searched * ******************************************************************************/ UINT32 AcpiNsLocal ( ACPI_OBJECT_TYPE8 Type) { FUNCTION_TRACE ("NsLocal"); if (!AcpiUtValidObjectType (Type)) { /* Type code out of range */ REPORT_WARNING (("NsLocal: Invalid Object Type\n")); return_VALUE (NSP_NORMAL); } return_VALUE ((UINT32) AcpiGbl_NsProperties[Type] & NSP_LOCAL); } /******************************************************************************* * * FUNCTION: AcpiNsGetInternalNameLength * * PARAMETERS: Info - Info struct initialized with the * external name pointer. * * RETURN: Status * * DESCRIPTION: Calculate the length of the internal (AML) namestring * corresponding to the external (ASL) namestring. * ******************************************************************************/ ACPI_STATUS AcpiNsGetInternalNameLength ( ACPI_NAMESTRING_INFO *Info) { NATIVE_CHAR *NextExternalChar; UINT32 i; NextExternalChar = Info->ExternalName; Info->NumCarats = 0; Info->NumSegments = 0; Info->FullyQualified = FALSE; /* * For the internal name, the required length is 4 bytes * per segment, plus 1 each for RootPrefix, MultiNamePrefixOp, * segment count, trailing null (which is not really needed, * but no there's harm in putting it there) * * strlen() + 1 covers the first NameSeg, which has no * path separator */ if (AcpiNsValidRootPrefix (NextExternalChar[0])) { Info->FullyQualified = TRUE; NextExternalChar++; } else { /* * Handle Carat prefixes */ while (*NextExternalChar == '^') { Info->NumCarats++; NextExternalChar++; } } /* * Determine the number of ACPI name "segments" by counting * the number of path separators within the string. Start * with one segment since the segment count is (# separators) * + 1, and zero separators is ok. */ if (*NextExternalChar) { Info->NumSegments = 1; for (i = 0; NextExternalChar[i]; i++) { if (AcpiNsValidPathSeparator (NextExternalChar[i])) { Info->NumSegments++; } } } Info->Length = (ACPI_NAME_SIZE * Info->NumSegments) + 4 + Info->NumCarats; Info->NextExternalChar = NextExternalChar; return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiNsBuildInternalName * * PARAMETERS: Info - Info struct fully initialized * * RETURN: Status * * DESCRIPTION: Construct the internal (AML) namestring * corresponding to the external (ASL) namestring. * ******************************************************************************/ ACPI_STATUS AcpiNsBuildInternalName ( ACPI_NAMESTRING_INFO *Info) { UINT32 NumSegments = Info->NumSegments; NATIVE_CHAR *InternalName = Info->InternalName; NATIVE_CHAR *ExternalName = Info->NextExternalChar; NATIVE_CHAR *Result = NULL; UINT32 i; FUNCTION_TRACE ("AcpiNsBuildInternalName"); /* Setup the correct prefixes, counts, and pointers */ if (Info->FullyQualified) { InternalName[0] = '\\'; if (NumSegments <= 1) { Result = &InternalName[1]; } else if (NumSegments == 2) { InternalName[1] = AML_DUAL_NAME_PREFIX; Result = &InternalName[2]; } else { InternalName[1] = AML_MULTI_NAME_PREFIX_OP; InternalName[2] = (char) NumSegments; Result = &InternalName[3]; } } else { /* * Not fully qualified. * Handle Carats first, then append the name segments */ i = 0; if (Info->NumCarats) { for (i = 0; i < Info->NumCarats; i++) { InternalName[i] = '^'; } } if (NumSegments == 1) { Result = &InternalName[i]; } else if (NumSegments == 2) { InternalName[i] = AML_DUAL_NAME_PREFIX; Result = &InternalName[i+1]; } else { InternalName[i] = AML_MULTI_NAME_PREFIX_OP; InternalName[i+1] = (char) NumSegments; Result = &InternalName[i+2]; } } /* Build the name (minus path separators) */ for (; NumSegments; NumSegments--) { for (i = 0; i < ACPI_NAME_SIZE; i++) { if (AcpiNsValidPathSeparator (*ExternalName) || (*ExternalName == 0)) { /* Pad the segment with underscore(s) if segment is short */ Result[i] = '_'; } else { /* Convert the character to uppercase and save it */ Result[i] = (char) TOUPPER (*ExternalName); ExternalName++; } } /* Now we must have a path separator, or the pathname is bad */ if (!AcpiNsValidPathSeparator (*ExternalName) && (*ExternalName != 0)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Move on the next segment */ ExternalName++; Result += ACPI_NAME_SIZE; } /* Terminate the string */ *Result = 0; if (Info->FullyQualified) { - DEBUG_PRINTP (TRACE_EXEC, ("returning [%p] (abs) \"\\%s\"\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "returning [%p] (abs) \"\\%s\"\n", InternalName, &InternalName[0])); } else { - DEBUG_PRINTP (TRACE_EXEC, ("returning [%p] (rel) \"%s\"\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "returning [%p] (rel) \"%s\"\n", InternalName, &InternalName[2])); } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiNsInternalizeName * * PARAMETERS: *ExternalName - External representation of name * **Converted Name - Where to return the resulting * internal represention of the name * * RETURN: Status * * DESCRIPTION: Convert an external representation (e.g. "\_PR_.CPU0") * to internal form (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30) * *******************************************************************************/ ACPI_STATUS AcpiNsInternalizeName ( NATIVE_CHAR *ExternalName, NATIVE_CHAR **ConvertedName) { NATIVE_CHAR *InternalName; ACPI_NAMESTRING_INFO Info; ACPI_STATUS Status; FUNCTION_TRACE ("NsInternalizeName"); if ((!ExternalName) || (*ExternalName == 0) || (!ConvertedName)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Get the length of the new internal name */ Info.ExternalName = ExternalName; AcpiNsGetInternalNameLength (&Info); /* We need a segment to store the internal name */ InternalName = ACPI_MEM_CALLOCATE (Info.Length); if (!InternalName) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Build the name */ Info.InternalName = InternalName; Status = AcpiNsBuildInternalName (&Info); if (ACPI_FAILURE (Status)) { ACPI_MEM_FREE (InternalName); return_ACPI_STATUS (Status); } *ConvertedName = InternalName; return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiNsExternalizeName * * PARAMETERS: *InternalName - Internal representation of name * **ConvertedName - Where to return the resulting * external representation of name * * RETURN: Status * * DESCRIPTION: Convert internal name (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30) * to its external form (e.g. "\_PR_.CPU0") * ******************************************************************************/ ACPI_STATUS AcpiNsExternalizeName ( UINT32 InternalNameLength, char *InternalName, UINT32 *ConvertedNameLength, char **ConvertedName) { UINT32 PrefixLength = 0; UINT32 NamesIndex = 0; UINT32 NamesCount = 0; UINT32 i = 0; UINT32 j = 0; FUNCTION_TRACE ("NsExternalizeName"); if (!InternalNameLength || !InternalName || !ConvertedNameLength || !ConvertedName) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* * Check for a prefix (one '\' | one or more '^'). */ switch (InternalName[0]) { case '\\': PrefixLength = 1; break; case '^': for (i = 0; i < InternalNameLength; i++) { if (InternalName[i] != '^') { PrefixLength = i + 1; } } if (i == InternalNameLength) { PrefixLength = i; } break; } /* * Check for object names. Note that there could be 0-255 of these * 4-byte elements. */ if (PrefixLength < InternalNameLength) { switch (InternalName[PrefixLength]) { /* 4-byte names */ case AML_MULTI_NAME_PREFIX_OP: NamesIndex = PrefixLength + 2; NamesCount = (UINT32) InternalName[PrefixLength + 1]; break; /* two 4-byte names */ case AML_DUAL_NAME_PREFIX: NamesIndex = PrefixLength + 1; NamesCount = 2; break; /* NullName */ case 0: NamesIndex = 0; NamesCount = 0; break; /* one 4-byte name */ default: NamesIndex = PrefixLength; NamesCount = 1; break; } } /* * Calculate the length of ConvertedName, which equals the length * of the prefix, length of all object names, length of any required * punctuation ('.') between object names, plus the NULL terminator. */ *ConvertedNameLength = PrefixLength + (4 * NamesCount) + ((NamesCount > 0) ? (NamesCount - 1) : 0) + 1; /* * Check to see if we're still in bounds. If not, there's a problem * with InternalName (invalid format). */ if (*ConvertedNameLength > InternalNameLength) { REPORT_ERROR (("NsExternalizeName: Invalid internal name\n")); return_ACPI_STATUS (AE_BAD_PATHNAME); } /* * Build ConvertedName... */ (*ConvertedName) = ACPI_MEM_CALLOCATE (*ConvertedNameLength); if (!(*ConvertedName)) { return_ACPI_STATUS (AE_NO_MEMORY); } j = 0; for (i = 0; i < PrefixLength; i++) { (*ConvertedName)[j++] = InternalName[i]; } if (NamesCount > 0) { for (i = 0; i < NamesCount; i++) { if (i > 0) { (*ConvertedName)[j++] = '.'; } (*ConvertedName)[j++] = InternalName[NamesIndex++]; (*ConvertedName)[j++] = InternalName[NamesIndex++]; (*ConvertedName)[j++] = InternalName[NamesIndex++]; (*ConvertedName)[j++] = InternalName[NamesIndex++]; } } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiNsConvertHandleToEntry * * PARAMETERS: Handle - Handle to be converted to an Node * * RETURN: A Name table entry pointer * * DESCRIPTION: Convert a namespace handle to a real Node * ******************************************************************************/ ACPI_NAMESPACE_NODE * AcpiNsConvertHandleToEntry ( ACPI_HANDLE Handle) { /* * Simple implementation for now; * TBD: [Future] Real integer handles allow for more verification * and keep all pointers within this subsystem! */ if (!Handle) { return (NULL); } if (Handle == ACPI_ROOT_OBJECT) { return (AcpiGbl_RootNode); } /* We can at least attempt to verify the handle */ if (!VALID_DESCRIPTOR_TYPE (Handle, ACPI_DESC_TYPE_NAMED)) { return (NULL); } return ((ACPI_NAMESPACE_NODE *) Handle); } /******************************************************************************* * * FUNCTION: AcpiNsConvertEntryToHandle * * PARAMETERS: Node - Node to be converted to a Handle * * RETURN: An USER ACPI_HANDLE * * DESCRIPTION: Convert a real Node to a namespace handle * ******************************************************************************/ ACPI_HANDLE AcpiNsConvertEntryToHandle ( ACPI_NAMESPACE_NODE *Node) { /* * Simple implementation for now; * TBD: [Future] Real integer handles allow for more verification * and keep all pointers within this subsystem! */ return ((ACPI_HANDLE) Node); /* --------------------------------------------------- if (!Node) { return (NULL); } if (Node == AcpiGbl_RootNode) { return (ACPI_ROOT_OBJECT); } return ((ACPI_HANDLE) Node); ------------------------------------------------------*/ } /******************************************************************************* * * FUNCTION: AcpiNsTerminate * * PARAMETERS: none * * RETURN: none * * DESCRIPTION: free memory allocated for table storage. * ******************************************************************************/ void AcpiNsTerminate (void) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_NAMESPACE_NODE *ThisNode; FUNCTION_TRACE ("NsTerminate"); ThisNode = AcpiGbl_RootNode; /* * 1) Free the entire namespace -- all objects, tables, and stacks * * Delete all objects linked to the root * (additional table descriptors) */ AcpiNsDeleteNamespaceSubtree (ThisNode); /* Detach any object(s) attached to the root */ ObjDesc = AcpiNsGetAttachedObject (ThisNode); if (ObjDesc) { AcpiNsDetachObject (ThisNode); AcpiUtRemoveReference (ObjDesc); } AcpiNsDeleteChildren (ThisNode); - DEBUG_PRINTP (ACPI_INFO, ("Namespace freed\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Namespace freed\n")); /* * 2) Now we can delete the ACPI tables */ AcpiTbDeleteAcpiTables (); - DEBUG_PRINTP (ACPI_INFO, ("ACPI Tables freed\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ACPI Tables freed\n")); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiNsOpensScope * * PARAMETERS: Type - A valid namespace type * * RETURN: NEWSCOPE if the passed type "opens a name scope" according * to the ACPI specification, else 0 * ******************************************************************************/ UINT32 AcpiNsOpensScope ( ACPI_OBJECT_TYPE8 Type) { FUNCTION_TRACE_U32 ("NsOpensScope", Type); if (!AcpiUtValidObjectType (Type)) { /* type code out of range */ REPORT_WARNING (("NsOpensScope: Invalid Object Type\n")); return_VALUE (NSP_NORMAL); } return_VALUE (((UINT32) AcpiGbl_NsProperties[Type]) & NSP_NEWSCOPE); } /******************************************************************************* * * FUNCTION: AcpiNsGetNode * * PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The * \ (backslash) and ^ (carat) prefixes, and the * . (period) to separate segments are supported. * StartNode - Root of subtree to be searched, or NS_ALL for the * root of the name space. If Name is fully * qualified (first INT8 is '\'), the passed value * of Scope will not be accessed. * ReturnNode - Where the Node is returned * * DESCRIPTION: Look up a name relative to a given scope and return the * corresponding Node. NOTE: Scope can be null. * * MUTEX: Locks namespace * ******************************************************************************/ ACPI_STATUS AcpiNsGetNode ( NATIVE_CHAR *Pathname, ACPI_NAMESPACE_NODE *StartNode, ACPI_NAMESPACE_NODE **ReturnNode) { ACPI_GENERIC_STATE ScopeInfo; ACPI_STATUS Status; NATIVE_CHAR *InternalPath = NULL; FUNCTION_TRACE_PTR ("NsGetNode", Pathname); /* Ensure that the namespace has been initialized */ if (!AcpiGbl_RootNode) { return_ACPI_STATUS (AE_NO_NAMESPACE); } if (!Pathname) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Convert path to internal representation */ Status = AcpiNsInternalizeName (Pathname, &InternalPath); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); /* Setup lookup scope (search starting point) */ ScopeInfo.Scope.Node = StartNode; /* Lookup the name in the namespace */ Status = AcpiNsLookup (&ScopeInfo, InternalPath, ACPI_TYPE_ANY, IMODE_EXECUTE, NS_NO_UPSEARCH | NS_DONT_OPEN_SCOPE, NULL, ReturnNode); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_INFO, ("%s, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s, %s\n", InternalPath, AcpiFormatException (Status))); } AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); /* Cleanup */ ACPI_MEM_FREE (InternalPath); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsFindParentName * * PARAMETERS: *ChildNode - Named Obj whose name is to be found * * RETURN: The ACPI name * * DESCRIPTION: Search for the given obj in its parent scope and return the * name segment, or "????" if the parent name can't be found * (which "should not happen"). * ******************************************************************************/ ACPI_NAME AcpiNsFindParentName ( ACPI_NAMESPACE_NODE *ChildNode) { ACPI_NAMESPACE_NODE *ParentNode; FUNCTION_TRACE ("FindParentName"); if (ChildNode) { /* Valid entry. Get the parent Node */ ParentNode = AcpiNsGetParentObject (ChildNode); if (ParentNode) { - DEBUG_PRINTP (TRACE_EXEC, ("Parent of %p [%4.4s] is %p [%4.4s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Parent of %p [%4.4s] is %p [%4.4s]\n", ChildNode, &ChildNode->Name, ParentNode, &ParentNode->Name)); if (ParentNode->Name) { return_VALUE (ParentNode->Name); } } - DEBUG_PRINTP (TRACE_EXEC, ("unable to find parent of %p (%4.4s)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "unable to find parent of %p (%4.4s)\n", ChildNode, &ChildNode->Name)); } return_VALUE (ACPI_UNKNOWN_NAME); } #if defined(ACPI_DEBUG) || defined(ENABLE_DEBUGGER) /******************************************************************************* * * FUNCTION: AcpiNsExistDownstreamSibling * * PARAMETERS: *Node - pointer to first Node to examine * * RETURN: TRUE if sibling is found, FALSE otherwise * * DESCRIPTION: Searches remainder of scope being processed to determine * whether there is a downstream sibling to the current * object. This function is used to determine what type of * line drawing character to use when displaying namespace * trees. * ******************************************************************************/ BOOLEAN AcpiNsExistDownstreamSibling ( ACPI_NAMESPACE_NODE *Node) { if (!Node) { return (FALSE); } if (Node->Name) { return (TRUE); } return (FALSE); } #endif /* ACPI_DEBUG */ /******************************************************************************* * * FUNCTION: AcpiNsGetParentObject * * PARAMETERS: Node - Current table entry * * RETURN: Parent entry of the given entry * * DESCRIPTION: Obtain the parent entry for a given entry in the namespace. * ******************************************************************************/ ACPI_NAMESPACE_NODE * AcpiNsGetParentObject ( ACPI_NAMESPACE_NODE *Node) { if (!Node) { return (NULL); } /* * Walk to the end of this peer list. * The last entry is marked with a flag and the peer * pointer is really a pointer back to the parent. * This saves putting a parent back pointer in each and * every named object! */ while (!(Node->Flags & ANOBJ_END_OF_PEER_LIST)) { Node = Node->Peer; } return (Node->Peer); } /******************************************************************************* * * FUNCTION: AcpiNsGetNextValidObject * * PARAMETERS: Node - Current table entry * * RETURN: Next valid object in the table. NULL if no more valid * objects * * DESCRIPTION: Find the next valid object within a name table. * Useful for implementing NULL-end-of-list loops. * ******************************************************************************/ ACPI_NAMESPACE_NODE * AcpiNsGetNextValidObject ( ACPI_NAMESPACE_NODE *Node) { /* If we are at the end of this peer list, return NULL */ if (Node->Flags & ANOBJ_END_OF_PEER_LIST) { return NULL; } /* Otherwise just return the next peer */ return (Node->Peer); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nswalk.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nswalk.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nswalk.c (revision 82367) @@ -1,384 +1,384 @@ /****************************************************************************** * - * Module Name: nswalk - Functions for walking the APCI namespace - * $Revision: 22 $ + * Module Name: nswalk - Functions for walking the ACPI namespace + * $Revision: 23 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSWALK_C__ #include "acpi.h" #include "acinterp.h" #include "acnamesp.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nswalk") /**************************************************************************** * * FUNCTION: AcpiGetNextObject * * PARAMETERS: Type - Type of object to be searched for * Parent - Parent object whose children we are * getting * LastChild - Previous child that was found. * The NEXT child will be returned * * RETURN: ACPI_NAMESPACE_NODE - Pointer to the NEXT child or NULL if * none is found. * * DESCRIPTION: Return the next peer object within the namespace. If Handle * is valid, Scope is ignored. Otherwise, the first object * within Scope is returned. * ****************************************************************************/ ACPI_NAMESPACE_NODE * AcpiNsGetNextObject ( ACPI_OBJECT_TYPE8 Type, ACPI_NAMESPACE_NODE *ParentNode, ACPI_NAMESPACE_NODE *ChildNode) { ACPI_NAMESPACE_NODE *NextNode = NULL; if (!ChildNode) { /* It's really the parent's _scope_ that we want */ if (ParentNode->Child) { NextNode = ParentNode->Child; } } else { /* Start search at the NEXT object */ NextNode = AcpiNsGetNextValidObject (ChildNode); } /* If any type is OK, we are done */ if (Type == ACPI_TYPE_ANY) { /* NextNode is NULL if we are at the end-of-list */ return (NextNode); } /* Must search for the object -- but within this scope only */ while (NextNode) { /* If type matches, we are done */ if (NextNode->Type == Type) { return (NextNode); } /* Otherwise, move on to the next object */ NextNode = AcpiNsGetNextValidObject (NextNode); } /* Not found */ return (NULL); } /****************************************************************************** * * FUNCTION: AcpiNsWalkNamespace * * PARAMETERS: Type - ACPI_OBJECT_TYPE to search for * StartNode - Handle in namespace where search begins * MaxDepth - Depth to which search is to reach * UnlockBeforeCallback- Whether to unlock the NS before invoking * the callback routine * UserFunction - Called when an object of "Type" is found * Context - Passed to user function * * RETURNS Return value from the UserFunction if terminated early. * Otherwise, returns NULL. * * DESCRIPTION: Performs a modified depth-first walk of the namespace tree, * starting (and ending) at the object specified by StartHandle. * The UserFunction is called whenever an object that matches * the type parameter is found. If the user function returns * a non-zero value, the search is terminated immediately and this * value is returned to the caller. * * The point of this procedure is to provide a generic namespace * walk routine that can be called from multiple places to * provide multiple services; the User Function can be tailored * to each task, whether it is a print function, a compare * function, etc. * ******************************************************************************/ ACPI_STATUS AcpiNsWalkNamespace ( ACPI_OBJECT_TYPE8 Type, ACPI_HANDLE StartNode, UINT32 MaxDepth, BOOLEAN UnlockBeforeCallback, ACPI_WALK_CALLBACK UserFunction, void *Context, void **ReturnValue) { ACPI_STATUS Status; ACPI_NAMESPACE_NODE *ChildNode; ACPI_NAMESPACE_NODE *ParentNode; ACPI_OBJECT_TYPE8 ChildType; UINT32 Level; FUNCTION_TRACE ("NsWalkNamespace"); /* Special case for the namespace Root Node */ if (StartNode == ACPI_ROOT_OBJECT) { StartNode = AcpiGbl_RootNode; } /* Null child means "get first object" */ ParentNode = StartNode; ChildNode = 0; ChildType = ACPI_TYPE_ANY; Level = 1; /* * Traverse the tree of objects until we bubble back up to where we * started. When Level is zero, the loop is done because we have * bubbled up to (and passed) the original parent handle (StartEntry) */ while (Level > 0) { /* * Get the next typed object in this scope. Null returned * if not found */ Status = AE_OK; ChildNode = AcpiNsGetNextObject (ACPI_TYPE_ANY, ParentNode, ChildNode); if (ChildNode) { /* * Found an object, Get the type if we are not * searching for ANY */ if (Type != ACPI_TYPE_ANY) { ChildType = ChildNode->Type; } if (ChildType == Type) { /* * Found a matching object, invoke the user * callback function */ if (UnlockBeforeCallback) { AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); } Status = UserFunction (ChildNode, Level, Context, ReturnValue); if (UnlockBeforeCallback) { AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); } switch (Status) { case AE_OK: case AE_CTRL_DEPTH: /* Just keep going */ break; case AE_CTRL_TERMINATE: /* Exit now, with OK status */ return_ACPI_STATUS (AE_OK); break; default: /* All others are valid exceptions */ return_ACPI_STATUS (Status); break; } } /* * Depth first search: * Attempt to go down another level in the namespace * if we are allowed to. Don't go any further if we * have reached the caller specified maximum depth * or if the user function has specified that the * maximum depth has been reached. */ if ((Level < MaxDepth) && (Status != AE_CTRL_DEPTH)) { if (AcpiNsGetNextObject (ACPI_TYPE_ANY, ChildNode, 0)) { /* * There is at least one child of this * object, visit the object */ Level++; ParentNode = ChildNode; ChildNode = 0; } } } else { /* * No more children in this object (AcpiNsGetNextObject * failed), go back upwards in the namespace tree to * the object's parent. */ Level--; ChildNode = ParentNode; ParentNode = AcpiNsGetParentObject (ParentNode); } } /* Complete walk, not terminated by user function */ return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsxfobj.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsxfobj.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/nsxfobj.c (revision 82367) @@ -1,890 +1,890 @@ /******************************************************************************* * * Module Name: nsxfobj - Public interfaces to the ACPI subsystem * ACPI Object oriented interfaces - * $Revision: 87 $ + * $Revision: 88 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __NSXFOBJ_C__ #include "acpi.h" #include "acinterp.h" #include "acnamesp.h" #include "acdispat.h" #define _COMPONENT ACPI_NAMESPACE MODULE_NAME ("nsxfobj") /******************************************************************************* * * FUNCTION: AcpiEvaluateObject * * PARAMETERS: Handle - Object handle (optional) * *Pathname - Object pathname (optional) * **Params - List of parameters to pass to * method, terminated by NULL. * Params itself may be NULL * if no parameters are being * passed. * *ReturnObject - Where to put method's return value (if * any). If NULL, no value is returned. * * RETURN: Status * * DESCRIPTION: Find and evaluate the given object, passing the given * parameters if necessary. One of "Handle" or "Pathname" must * be valid (non-null) * ******************************************************************************/ ACPI_STATUS AcpiEvaluateObject ( ACPI_HANDLE Handle, ACPI_STRING Pathname, ACPI_OBJECT_LIST *ParamObjects, ACPI_BUFFER *ReturnBuffer) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT **ParamPtr = NULL; ACPI_OPERAND_OBJECT *ReturnObj = NULL; ACPI_OPERAND_OBJECT *ObjectPtr = NULL; UINT32 BufferSpaceNeeded; UINT32 UserBufferLength; UINT32 Count; UINT32 i; UINT32 ParamLength; UINT32 ObjectLength; FUNCTION_TRACE ("AcpiEvaluateObject"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * If there are parameters to be passed to the object * (which must be a control method), the external objects * must be converted to internal objects */ if (ParamObjects && ParamObjects->Count) { /* * Allocate a new parameter block for the internal objects * Add 1 to count to allow for null terminated internal list */ Count = ParamObjects->Count; ParamLength = (Count + 1) * sizeof (void *); ObjectLength = Count * sizeof (ACPI_OPERAND_OBJECT); ParamPtr = ACPI_MEM_CALLOCATE (ParamLength + /* Parameter List part */ ObjectLength); /* Actual objects */ if (!ParamPtr) { return_ACPI_STATUS (AE_NO_MEMORY); } ObjectPtr = (ACPI_OPERAND_OBJECT *) ((UINT8 *) ParamPtr + ParamLength); /* * Init the param array of pointers and NULL terminate * the list */ for (i = 0; i < Count; i++) { ParamPtr[i] = &ObjectPtr[i]; AcpiUtInitStaticObject (&ObjectPtr[i]); } ParamPtr[Count] = NULL; /* * Convert each external object in the list to an * internal object */ for (i = 0; i < Count; i++) { Status = AcpiUtCopyEobjectToIobject (&ParamObjects->Pointer[i], ParamPtr[i]); if (ACPI_FAILURE (Status)) { AcpiUtDeleteInternalObjectList (ParamPtr); return_ACPI_STATUS (Status); } } } /* * Three major cases: * 1) Fully qualified pathname * 2) No handle, not fully qualified pathname (error) * 3) Valid handle */ if ((Pathname) && (AcpiNsValidRootPrefix (Pathname[0]))) { /* * The path is fully qualified, just evaluate by name */ Status = AcpiNsEvaluateByName (Pathname, ParamPtr, &ReturnObj); } else if (!Handle) { /* * A handle is optional iff a fully qualified pathname * is specified. Since we've already handled fully * qualified names above, this is an error */ if (!Pathname) { - DEBUG_PRINTP (ACPI_ERROR, ("Both Handle and Pathname are NULL\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Both Handle and Pathname are NULL\n")); } else { - DEBUG_PRINTP (ACPI_ERROR, ("Handle is NULL and Pathname is relative\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Handle is NULL and Pathname is relative\n")); } Status = AE_BAD_PARAMETER; } else { /* * We get here if we have a handle -- and if we have a * pathname it is relative. The handle will be validated * in the lower procedures */ if (!Pathname) { /* * The null pathname case means the handle is for * the actual object to be evaluated */ Status = AcpiNsEvaluateByHandle (Handle, ParamPtr, &ReturnObj); } else { /* * Both a Handle and a relative Pathname */ Status = AcpiNsEvaluateRelative (Handle, Pathname, ParamPtr, &ReturnObj); } } /* * If we are expecting a return value, and all went well above, * copy the return value to an external object. */ if (ReturnBuffer) { UserBufferLength = ReturnBuffer->Length; ReturnBuffer->Length = 0; if (ReturnObj) { if (VALID_DESCRIPTOR_TYPE (ReturnObj, ACPI_DESC_TYPE_NAMED)) { /* * If we got an Node as a return object, * this means the object we are evaluating * has nothing interesting to return (such * as a mutex, etc.) We return an error * because these types are essentially * unsupported by this interface. We * don't check up front because this makes * it easier to add support for various * types at a later date if necessary. */ Status = AE_TYPE; ReturnObj = NULL; /* No need to delete an Node */ } if (ACPI_SUCCESS (Status)) { /* * Find out how large a buffer is needed * to contain the returned object */ Status = AcpiUtGetObjectSize (ReturnObj, &BufferSpaceNeeded); if (ACPI_SUCCESS (Status)) { /* * Check if there is enough room in the * caller's buffer */ if (UserBufferLength < BufferSpaceNeeded) { /* * Caller's buffer is too small, can't * give him partial results fail the call * but return the buffer size needed */ - DEBUG_PRINTP (ACPI_INFO, - ("Needed buffer size %X, received %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Needed buffer size %X, received %X\n", BufferSpaceNeeded, UserBufferLength)); ReturnBuffer->Length = BufferSpaceNeeded; Status = AE_BUFFER_OVERFLOW; } else { /* * We have enough space for the object, build it */ Status = AcpiUtCopyIobjectToEobject (ReturnObj, ReturnBuffer); ReturnBuffer->Length = BufferSpaceNeeded; } } } } } /* Delete the return and parameter objects */ if (ReturnObj) { /* * Delete the internal return object. (Or at least * decrement the reference count by one) */ AcpiUtRemoveReference (ReturnObj); } /* * Free the input parameter list (if we created one), */ if (ParamPtr) { /* Free the allocated parameter block */ AcpiUtDeleteInternalObjectList (ParamPtr); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiGetNextObject * * PARAMETERS: Type - Type of object to be searched for * Parent - Parent object whose children we are getting * LastChild - Previous child that was found. * The NEXT child will be returned * RetHandle - Where handle to the next object is placed * * RETURN: Status * * DESCRIPTION: Return the next peer object within the namespace. If Handle is * valid, Scope is ignored. Otherwise, the first object within * Scope is returned. * ******************************************************************************/ ACPI_STATUS AcpiGetNextObject ( ACPI_OBJECT_TYPE Type, ACPI_HANDLE Parent, ACPI_HANDLE Child, ACPI_HANDLE *RetHandle) { ACPI_STATUS Status = AE_OK; ACPI_NAMESPACE_NODE *Node; ACPI_NAMESPACE_NODE *ParentNode = NULL; ACPI_NAMESPACE_NODE *ChildNode = NULL; /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return (Status); } /* Parameter validation */ if (Type > ACPI_TYPE_MAX) { return (AE_BAD_PARAMETER); } AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); /* If null handle, use the parent */ if (!Child) { /* Start search at the beginning of the specified scope */ ParentNode = AcpiNsConvertHandleToEntry (Parent); if (!ParentNode) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } } /* Non-null handle, ignore the parent */ else { /* Convert and validate the handle */ ChildNode = AcpiNsConvertHandleToEntry (Child); if (!ChildNode) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } } /* Internal function does the real work */ Node = AcpiNsGetNextObject ((ACPI_OBJECT_TYPE8) Type, ParentNode, ChildNode); if (!Node) { Status = AE_NOT_FOUND; goto UnlockAndExit; } if (RetHandle) { *RetHandle = AcpiNsConvertEntryToHandle (Node); } UnlockAndExit: AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return (Status); } /******************************************************************************* * * FUNCTION: AcpiGetType * * PARAMETERS: Handle - Handle of object whose type is desired * *RetType - Where the type will be placed * * RETURN: Status * * DESCRIPTION: This routine returns the type associatd with a particular handle * ******************************************************************************/ ACPI_STATUS AcpiGetType ( ACPI_HANDLE Handle, ACPI_OBJECT_TYPE *RetType) { ACPI_NAMESPACE_NODE *Node; ACPI_STATUS Status; /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return (Status); } /* Parameter Validation */ if (!RetType) { return (AE_BAD_PARAMETER); } /* * Special case for the predefined Root Node * (return type ANY) */ if (Handle == ACPI_ROOT_OBJECT) { *RetType = ACPI_TYPE_ANY; return (AE_OK); } AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); /* Convert and validate the handle */ Node = AcpiNsConvertHandleToEntry (Handle); if (!Node) { AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return (AE_BAD_PARAMETER); } *RetType = Node->Type; AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiGetParent * * PARAMETERS: Handle - Handle of object whose parent is desired * RetHandle - Where the parent handle will be placed * * RETURN: Status * * DESCRIPTION: Returns a handle to the parent of the object represented by * Handle. * ******************************************************************************/ ACPI_STATUS AcpiGetParent ( ACPI_HANDLE Handle, ACPI_HANDLE *RetHandle) { ACPI_NAMESPACE_NODE *Node; ACPI_STATUS Status = AE_OK; /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return (Status); } if (!RetHandle) { return (AE_BAD_PARAMETER); } /* Special case for the predefined Root Node (no parent) */ if (Handle == ACPI_ROOT_OBJECT) { return (AE_NULL_ENTRY); } AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); /* Convert and validate the handle */ Node = AcpiNsConvertHandleToEntry (Handle); if (!Node) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } /* Get the parent entry */ *RetHandle = AcpiNsConvertEntryToHandle (AcpiNsGetParentObject (Node)); /* Return exeption if parent is null */ if (!AcpiNsGetParentObject (Node)) { Status = AE_NULL_ENTRY; } UnlockAndExit: AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return (Status); } /******************************************************************************* * * FUNCTION: AcpiWalkNamespace * * PARAMETERS: Type - ACPI_OBJECT_TYPE to search for * StartObject - Handle in namespace where search begins * MaxDepth - Depth to which search is to reach * UserFunction - Called when an object of "Type" is found * Context - Passed to user function * ReturnValue - Location where return value of * UserFunction is put if terminated early * * RETURNS Return value from the UserFunction if terminated early. * Otherwise, returns NULL. * * DESCRIPTION: Performs a modified depth-first walk of the namespace tree, * starting (and ending) at the object specified by StartHandle. * The UserFunction is called whenever an object that matches * the type parameter is found. If the user function returns * a non-zero value, the search is terminated immediately and this * value is returned to the caller. * * The point of this procedure is to provide a generic namespace * walk routine that can be called from multiple places to * provide multiple services; the User Function can be tailored * to each task, whether it is a print function, a compare * function, etc. * ******************************************************************************/ ACPI_STATUS AcpiWalkNamespace ( ACPI_OBJECT_TYPE Type, ACPI_HANDLE StartObject, UINT32 MaxDepth, ACPI_WALK_CALLBACK UserFunction, void *Context, void **ReturnValue) { ACPI_STATUS Status; FUNCTION_TRACE ("AcpiWalkNamespace"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parameter validation */ if ((Type > ACPI_TYPE_MAX) || (!MaxDepth) || (!UserFunction)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* * Lock the namespace around the walk. * The namespace will be unlocked/locked around each call * to the user function - since this function * must be allowed to make Acpi calls itself. */ AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); Status = AcpiNsWalkNamespace ((ACPI_OBJECT_TYPE8) Type, StartObject, MaxDepth, NS_WALK_UNLOCK, UserFunction, Context, ReturnValue); AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiNsGetDeviceCallback * * PARAMETERS: Callback from AcpiGetDevice * * RETURN: Status * * DESCRIPTION: Takes callbacks from WalkNamespace and filters out all non- * present devices, or if they specified a HID, it filters based * on that. * ******************************************************************************/ static ACPI_STATUS AcpiNsGetDeviceCallback ( ACPI_HANDLE ObjHandle, UINT32 NestingLevel, void *Context, void **ReturnValue) { ACPI_STATUS Status; ACPI_NAMESPACE_NODE *Node; UINT32 Flags; ACPI_DEVICE_ID DeviceId; ACPI_GET_DEVICES_INFO *Info; Info = Context; AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); Node = AcpiNsConvertHandleToEntry (ObjHandle); AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); if (!Node) { return (AE_BAD_PARAMETER); } /* * Run _STA to determine if device is present */ Status = AcpiUtExecute_STA (Node, &Flags); if (ACPI_FAILURE (Status)) { return (AE_CTRL_DEPTH); } if (!(Flags & 0x01)) { /* don't return at the device or children of the device if not there */ return (AE_CTRL_DEPTH); } /* * Filter based on device HID */ if (Info->Hid != NULL) { Status = AcpiUtExecute_HID (Node, &DeviceId); if (Status == AE_NOT_FOUND) { return (AE_OK); } else if (ACPI_FAILURE (Status)) { return (AE_CTRL_DEPTH); } if (STRNCMP (DeviceId.Buffer, Info->Hid, sizeof (DeviceId.Buffer)) != 0) { return (AE_OK); } } Info->UserFunction (ObjHandle, NestingLevel, Info->Context, ReturnValue); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiGetDevices * * PARAMETERS: HID - HID to search for. Can be NULL. * UserFunction - Called when a matching object is found * Context - Passed to user function * ReturnValue - Location where return value of * UserFunction is put if terminated early * * RETURNS Return value from the UserFunction if terminated early. * Otherwise, returns NULL. * * DESCRIPTION: Performs a modified depth-first walk of the namespace tree, * starting (and ending) at the object specified by StartHandle. * The UserFunction is called whenever an object that matches * the type parameter is found. If the user function returns * a non-zero value, the search is terminated immediately and this * value is returned to the caller. * * This is a wrapper for WalkNamespace, but the callback performs * additional filtering. Please see AcpiGetDeviceCallback. * ******************************************************************************/ ACPI_STATUS AcpiGetDevices ( NATIVE_CHAR *HID, ACPI_WALK_CALLBACK UserFunction, void *Context, void **ReturnValue) { ACPI_STATUS Status; ACPI_GET_DEVICES_INFO Info; FUNCTION_TRACE ("AcpiGetDevices"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parameter validation */ if (!UserFunction) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* * We're going to call their callback from OUR callback, so we need * to know what it is, and their context parameter. */ Info.Context = Context; Info.UserFunction = UserFunction; Info.Hid = HID; /* * Lock the namespace around the walk. * The namespace will be unlocked/locked around each call * to the user function - since this function * must be allowed to make Acpi calls itself. */ AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); Status = AcpiNsWalkNamespace (ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, NS_WALK_UNLOCK, AcpiNsGetDeviceCallback, &Info, ReturnValue); AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/psargs.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/psargs.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/psargs.c (revision 82367) @@ -1,889 +1,900 @@ /****************************************************************************** * * Module Name: psargs - Parse AML opcode arguments - * $Revision: 47 $ + * $Revision: 50 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __PSARGS_C__ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #include "acnamesp.h" #define _COMPONENT ACPI_PARSER MODULE_NAME ("psargs") /******************************************************************************* * * FUNCTION: AcpiPsGetNextPackageLength * * PARAMETERS: ParserState - Current parser state object * * RETURN: Decoded package length. On completion, the AML pointer points * past the length byte or bytes. * * DESCRIPTION: Decode and return a package length field * ******************************************************************************/ UINT32 AcpiPsGetNextPackageLength ( ACPI_PARSE_STATE *ParserState) { UINT32 EncodedLength; UINT32 Length = 0; FUNCTION_TRACE ("PsGetNextPackageLength"); EncodedLength = (UINT32) GET8 (ParserState->Aml); ParserState->Aml++; switch (EncodedLength >> 6) /* bits 6-7 contain encoding scheme */ { case 0: /* 1-byte encoding (bits 0-5) */ Length = (EncodedLength & 0x3F); break; case 1: /* 2-byte encoding (next byte + bits 0-3) */ Length = ((GET8 (ParserState->Aml) << 04) | (EncodedLength & 0x0F)); ParserState->Aml++; break; case 2: /* 3-byte encoding (next 2 bytes + bits 0-3) */ Length = ((GET8 (ParserState->Aml + 1) << 12) | (GET8 (ParserState->Aml) << 04) | (EncodedLength & 0x0F)); ParserState->Aml += 2; break; case 3: /* 4-byte encoding (next 3 bytes + bits 0-3) */ Length = ((GET8 (ParserState->Aml + 2) << 20) | (GET8 (ParserState->Aml + 1) << 12) | (GET8 (ParserState->Aml) << 04) | (EncodedLength & 0x0F)); ParserState->Aml += 3; break; } return_VALUE (Length); } /******************************************************************************* * * FUNCTION: AcpiPsGetNextPackageEnd * * PARAMETERS: ParserState - Current parser state object * * RETURN: Pointer to end-of-package +1 * * DESCRIPTION: Get next package length and return a pointer past the end of * the package. Consumes the package length field * ******************************************************************************/ UINT8 * AcpiPsGetNextPackageEnd ( ACPI_PARSE_STATE *ParserState) { UINT8 *Start = ParserState->Aml; NATIVE_UINT Length; FUNCTION_TRACE ("PsGetNextPackageEnd"); Length = (NATIVE_UINT) AcpiPsGetNextPackageLength (ParserState); return_PTR (Start + Length); /* end of package */ } /******************************************************************************* * * FUNCTION: AcpiPsGetNextNamestring * * PARAMETERS: ParserState - Current parser state object * * RETURN: Pointer to the start of the name string (pointer points into * the AML. * * DESCRIPTION: Get next raw namestring within the AML stream. Handles all name * prefix characters. Set parser state to point past the string. * (Name is consumed from the AML.) * ******************************************************************************/ NATIVE_CHAR * AcpiPsGetNextNamestring ( ACPI_PARSE_STATE *ParserState) { UINT8 *Start = ParserState->Aml; UINT8 *End = ParserState->Aml; UINT32 Length; FUNCTION_TRACE ("PsGetNextNamestring"); /* Handle multiple prefix characters */ while (AcpiPsIsPrefixChar (GET8 (End))) { /* include prefix '\\' or '^' */ End++; } /* Decode the path */ switch (GET8 (End)) { case 0: /* NullName */ if (End == Start) { Start = NULL; } End++; break; case AML_DUAL_NAME_PREFIX: /* two name segments */ End += 9; break; case AML_MULTI_NAME_PREFIX_OP: /* multiple name segments */ Length = (UINT32) GET8 (End + 1) * 4; End += 2 + Length; break; default: /* single name segment */ /* assert (AcpiPsIsLead (GET8 (End))); */ End += 4; break; } ParserState->Aml = (UINT8*) End; return_PTR ((NATIVE_CHAR *) Start); } /******************************************************************************* * * FUNCTION: AcpiPsGetNextNamepath * * PARAMETERS: ParserState - Current parser state object * Arg - Where the namepath will be stored * ArgCount - If the namepath points to a control method * the method's argument is returned here. * MethodCall - Whether the namepath can be the start * of a method call * * RETURN: None * * DESCRIPTION: Get next name (if method call, push appropriate # args). Names * are looked up in either the parsed or internal namespace to * determine if the name represents a control method. If a method * is found, the number of arguments to the method is returned. * This information is critical for parsing to continue correctly. * ******************************************************************************/ #ifdef PARSER_ONLY void AcpiPsGetNextNamepath ( ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT *Arg, UINT32 *ArgCount, BOOLEAN MethodCall) { NATIVE_CHAR *Path; ACPI_PARSE_OBJECT *NameOp; ACPI_PARSE_OBJECT *Op; ACPI_PARSE_OBJECT *Count; FUNCTION_TRACE ("PsGetNextNamepath"); Path = AcpiPsGetNextNamestring (ParserState); if (!Path || !MethodCall) { /* Null name case, create a null namepath object */ AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP); Arg->Value.Name = Path; return_VOID; } if (AcpiGbl_ParsedNamespaceRoot) { /* * Lookup the name in the parsed namespace */ Op = NULL; if (MethodCall) { Op = AcpiPsFind (AcpiPsGetParentScope (ParserState), Path, AML_METHOD_OP, 0); } if (Op) { if (Op->Opcode == AML_METHOD_OP) { /* * The name refers to a control method, so this namepath is a * method invocation. We need to 1) Get the number of arguments * associated with this method, and 2) Change the NAMEPATH * object into a METHODCALL object. */ Count = AcpiPsGetArg (Op, 0); if (Count && Count->Opcode == AML_BYTE_OP) { NameOp = AcpiPsAllocOp (AML_INT_NAMEPATH_OP); if (NameOp) { /* Change arg into a METHOD CALL and attach the name */ AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP); NameOp->Value.Name = Path; /* Point METHODCALL/NAME to the METHOD Node */ NameOp->Node = (ACPI_NAMESPACE_NODE *) Op; AcpiPsAppendArg (Arg, NameOp); - *ArgCount = Count->Value.Integer & + *ArgCount = (UINT32) Count->Value.Integer & METHOD_FLAGS_ARG_COUNT; } } return_VOID; } /* * Else this is normal named object reference. * Just init the NAMEPATH object with the pathname. * (See code below) */ } } /* * Either we didn't find the object in the namespace, or the object is * something other than a control method. Just initialize the Op with the * pathname */ AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP); Arg->Value.Name = Path; return_VOID; } #else void AcpiPsGetNextNamepath ( ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT *Arg, UINT32 *ArgCount, BOOLEAN MethodCall) { NATIVE_CHAR *Path; ACPI_PARSE_OBJECT *NameOp; ACPI_STATUS Status; ACPI_NAMESPACE_NODE *MethodNode = NULL; ACPI_NAMESPACE_NODE *Node; ACPI_GENERIC_STATE ScopeInfo; FUNCTION_TRACE ("PsGetNextNamepath"); Path = AcpiPsGetNextNamestring (ParserState); if (!Path || !MethodCall) { /* Null name case, create a null namepath object */ AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP); Arg->Value.Name = Path; return_VOID; } if (MethodCall) { /* * Lookup the name in the internal namespace */ ScopeInfo.Scope.Node = NULL; Node = ParserState->StartNode; if (Node) { ScopeInfo.Scope.Node = Node; } /* * Lookup object. We don't want to add anything new to the namespace * here, however. So we use MODE_EXECUTE. Allow searching of the * parent tree, but don't open a new scope -- we just want to lookup the * object (MUST BE mode EXECUTE to perform upsearch) */ Status = AcpiNsLookup (&ScopeInfo, Path, ACPI_TYPE_ANY, IMODE_EXECUTE, NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE, NULL, &Node); if (ACPI_SUCCESS (Status)) { if (Node->Type == ACPI_TYPE_METHOD) { MethodNode = Node; - DEBUG_PRINTP (TRACE_PARSE, ("method - %p Path=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "method - %p Path=%p\n", MethodNode, Path)); NameOp = AcpiPsAllocOp (AML_INT_NAMEPATH_OP); if (NameOp) { /* Change arg into a METHOD CALL and attach name to it */ AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP); NameOp->Value.Name = Path; /* Point METHODCALL/NAME to the METHOD Node */ NameOp->Node = MethodNode; AcpiPsAppendArg (Arg, NameOp); if (!(ACPI_OPERAND_OBJECT *) MethodNode->Object) { return_VOID; } *ArgCount = ((ACPI_OPERAND_OBJECT *) MethodNode->Object)->Method.ParamCount; } return_VOID; } /* * Else this is normal named object reference. * Just init the NAMEPATH object with the pathname. * (See code below) */ } } /* * Either we didn't find the object in the namespace, or the object is * something other than a control method. Just initialize the Op with the * pathname. */ AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP); Arg->Value.Name = Path; return_VOID; } #endif /******************************************************************************* * * FUNCTION: AcpiPsGetNextSimpleArg * * PARAMETERS: ParserState - Current parser state object * ArgType - The argument type (AML_*_ARG) * Arg - Where the argument is returned * * RETURN: None * * DESCRIPTION: Get the next simple argument (constant, string, or namestring) * ******************************************************************************/ void AcpiPsGetNextSimpleArg ( ACPI_PARSE_STATE *ParserState, UINT32 ArgType, ACPI_PARSE_OBJECT *Arg) { FUNCTION_TRACE_U32 ("PsGetNextSimpleArg", ArgType); switch (ArgType) { case ARGP_BYTEDATA: AcpiPsInitOp (Arg, AML_BYTE_OP); Arg->Value.Integer = (UINT32) GET8 (ParserState->Aml); ParserState->Aml++; break; case ARGP_WORDDATA: AcpiPsInitOp (Arg, AML_WORD_OP); /* Get 2 bytes from the AML stream */ MOVE_UNALIGNED16_TO_32 (&Arg->Value.Integer, ParserState->Aml); ParserState->Aml += 2; break; case ARGP_DWORDDATA: AcpiPsInitOp (Arg, AML_DWORD_OP); /* Get 4 bytes from the AML stream */ MOVE_UNALIGNED32_TO_32 (&Arg->Value.Integer, ParserState->Aml); ParserState->Aml += 4; + break; + + + case ARGP_QWORDDATA: + + AcpiPsInitOp (Arg, AML_QWORD_OP); + + /* Get 8 bytes from the AML stream */ + + MOVE_UNALIGNED64_TO_64 (&Arg->Value.Integer, ParserState->Aml); + ParserState->Aml += 8; break; case ARGP_CHARLIST: AcpiPsInitOp (Arg, AML_STRING_OP); Arg->Value.String = (char*) ParserState->Aml; while (GET8 (ParserState->Aml) != '\0') { ParserState->Aml++; } ParserState->Aml++; break; case ARGP_NAME: case ARGP_NAMESTRING: AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP); Arg->Value.Name = AcpiPsGetNextNamestring (ParserState); break; } return_VOID; } /******************************************************************************* * * FUNCTION: AcpiPsGetNextField * * PARAMETERS: ParserState - Current parser state object * * RETURN: A newly allocated FIELD op * * DESCRIPTION: Get next field (NamedField, ReservedField, or AccessField) * ******************************************************************************/ ACPI_PARSE_OBJECT * AcpiPsGetNextField ( ACPI_PARSE_STATE *ParserState) { UINT32 AmlOffset = ParserState->Aml - ParserState->AmlStart; ACPI_PARSE_OBJECT *Field; UINT16 Opcode; UINT32 Name; FUNCTION_TRACE ("PsGetNextField"); /* determine field type */ switch (GET8 (ParserState->Aml)) { default: Opcode = AML_INT_NAMEDFIELD_OP; break; case 0x00: Opcode = AML_INT_RESERVEDFIELD_OP; ParserState->Aml++; break; case 0x01: Opcode = AML_INT_ACCESSFIELD_OP; ParserState->Aml++; break; } /* Allocate a new field op */ Field = AcpiPsAllocOp (Opcode); if (Field) { Field->AmlOffset = AmlOffset; /* Decode the field type */ switch (Opcode) { case AML_INT_NAMEDFIELD_OP: /* Get the 4-character name */ MOVE_UNALIGNED32_TO_32 (&Name, ParserState->Aml); AcpiPsSetName (Field, Name); ParserState->Aml += 4; /* Get the length which is encoded as a package length */ Field->Value.Size = AcpiPsGetNextPackageLength (ParserState); break; case AML_INT_RESERVEDFIELD_OP: /* Get the length which is encoded as a package length */ Field->Value.Size = AcpiPsGetNextPackageLength (ParserState); break; case AML_INT_ACCESSFIELD_OP: /* Get AccessType and AccessAtrib and merge into the field Op */ Field->Value.Integer = ((GET8 (ParserState->Aml) << 8) | GET8 (ParserState->Aml)); ParserState->Aml += 2; break; } } return_PTR (Field); } /******************************************************************************* * * FUNCTION: AcpiPsGetNextArg * * PARAMETERS: ParserState - Current parser state object * ArgType - The argument type (AML_*_ARG) * ArgCount - If the argument points to a control method * the method's argument is returned here. * * RETURN: An op object containing the next argument. * * DESCRIPTION: Get next argument (including complex list arguments that require * pushing the parser stack) * ******************************************************************************/ ACPI_PARSE_OBJECT * AcpiPsGetNextArg ( ACPI_PARSE_STATE *ParserState, UINT32 ArgType, UINT32 *ArgCount) { ACPI_PARSE_OBJECT *Arg = NULL; ACPI_PARSE_OBJECT *Prev = NULL; ACPI_PARSE_OBJECT *Field; UINT32 Subop; FUNCTION_TRACE_PTR ("PsGetNextArg", ParserState); switch (ArgType) { case ARGP_BYTEDATA: case ARGP_WORDDATA: case ARGP_DWORDDATA: case ARGP_CHARLIST: case ARGP_NAME: case ARGP_NAMESTRING: /* constants, strings, and namestrings are all the same size */ Arg = AcpiPsAllocOp (AML_BYTE_OP); if (Arg) { AcpiPsGetNextSimpleArg (ParserState, ArgType, Arg); } break; case ARGP_PKGLENGTH: /* package length, nothing returned */ ParserState->PkgEnd = AcpiPsGetNextPackageEnd (ParserState); break; case ARGP_FIELDLIST: if (ParserState->Aml < ParserState->PkgEnd) { /* non-empty list */ while (ParserState->Aml < ParserState->PkgEnd) { Field = AcpiPsGetNextField (ParserState); if (!Field) { break; } if (Prev) { Prev->Next = Field; } else { Arg = Field; } Prev = Field; } /* skip to End of byte data */ ParserState->Aml = ParserState->PkgEnd; } break; case ARGP_BYTELIST: if (ParserState->Aml < ParserState->PkgEnd) { /* non-empty list */ Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP); if (Arg) { /* fill in bytelist data */ Arg->Value.Size = (ParserState->PkgEnd - ParserState->Aml); ((ACPI_PARSE2_OBJECT *) Arg)->Data = ParserState->Aml; } /* skip to End of byte data */ ParserState->Aml = ParserState->PkgEnd; } break; case ARGP_TARGET: case ARGP_SUPERNAME: { Subop = AcpiPsPeekOpcode (ParserState); if (Subop == 0 || AcpiPsIsLeadingChar (Subop) || AcpiPsIsPrefixChar (Subop)) { /* NullName or NameString */ Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP); if (Arg) { AcpiPsGetNextNamepath (ParserState, Arg, ArgCount, 0); } } else { /* single complex argument, nothing returned */ *ArgCount = 1; } } break; case ARGP_DATAOBJ: case ARGP_TERMARG: /* single complex argument, nothing returned */ *ArgCount = 1; break; case ARGP_DATAOBJLIST: case ARGP_TERMLIST: case ARGP_OBJLIST: if (ParserState->Aml < ParserState->PkgEnd) { /* non-empty list of variable arguments, nothing returned */ *ArgCount = ACPI_VAR_ARGS; } break; } return_PTR (Arg); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/psfind.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/psfind.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/psfind.c (revision 82367) @@ -1,461 +1,461 @@ /****************************************************************************** * * Module Name: psfind - Parse tree search routine - * $Revision: 24 $ + * $Revision: 25 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __PSFIND_C__ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #define _COMPONENT ACPI_PARSER MODULE_NAME ("psfind") /******************************************************************************* * * FUNCTION: AcpiPsGetParent * * PARAMETERS: Op - Get the parent of this Op * * RETURN: The Parent op. * * DESCRIPTION: Get op's parent * ******************************************************************************/ static ACPI_PARSE_OBJECT* AcpiPsGetParent ( ACPI_PARSE_OBJECT *Op) { ACPI_PARSE_OBJECT *Parent = Op; /* Traverse the tree upward (to root if necessary) */ while (Parent) { switch (Parent->Opcode) { case AML_SCOPE_OP: case AML_PACKAGE_OP: case AML_METHOD_OP: case AML_DEVICE_OP: case AML_POWER_RES_OP: case AML_THERMAL_ZONE_OP: return (Parent->Parent); } Parent = Parent->Parent; } return (Parent); } /******************************************************************************* * * FUNCTION: AcpiPsFindName * * PARAMETERS: Scope - Scope to search * Name - ACPI name to search for * Opcode - Opcode to search for * * RETURN: Op containing the name * * DESCRIPTION: Find name segment from a list of acpi_ops. Searches a single * scope, no more. * ******************************************************************************/ static ACPI_PARSE_OBJECT * AcpiPsFindName ( ACPI_PARSE_OBJECT *Scope, UINT32 Name, UINT32 Opcode) { ACPI_PARSE_OBJECT *Op; ACPI_PARSE_OBJECT *Field; /* search scope level for matching name segment */ Op = AcpiPsGetChild (Scope); while (Op) { if (AcpiPsIsFieldOp (Op->Opcode)) { /* Field, search named fields */ Field = AcpiPsGetChild (Op); while (Field) { if (AcpiPsIsNamedOp (Field->Opcode) && AcpiPsGetName (Field) == Name && (!Opcode || Field->Opcode == Opcode)) { return (Field); } Field = Field->Next; } } else if (AcpiPsIsCreateFieldOp (Op->Opcode)) { if (Op->Opcode == AML_CREATE_FIELD_OP) { Field = AcpiPsGetArg (Op, 3); } else { /* CreateXXXField, check name */ Field = AcpiPsGetArg (Op, 2); } if ((Field) && (Field->Value.String) && (!STRNCMP (Field->Value.String, (char *) &Name, ACPI_NAME_SIZE))) { return (Op); } } else if ((AcpiPsIsNamedOp (Op->Opcode)) && (AcpiPsGetName (Op) == Name) && (!Opcode || Op->Opcode == Opcode || Opcode == AML_SCOPE_OP)) { break; } Op = Op->Next; } return (Op); } /******************************************************************************* * * FUNCTION: AcpiPsFind * * PARAMETERS: Scope - Where to begin the search * Path - ACPI Path to the named object * Opcode - Opcode associated with the object * Create - if TRUE, create the object if not found. * * RETURN: Op if found, NULL otherwise. * * DESCRIPTION: Find object within scope * ******************************************************************************/ ACPI_PARSE_OBJECT* AcpiPsFind ( ACPI_PARSE_OBJECT *Scope, NATIVE_CHAR *Path, UINT16 Opcode, UINT32 Create) { UINT32 SegCount; UINT32 Name; UINT32 NameOp; ACPI_PARSE_OBJECT *Op = NULL; BOOLEAN Unprefixed = TRUE; FUNCTION_TRACE_PTR ("PsFind", Scope); if (!Scope || !Path) { - DEBUG_PRINTP (TRACE_PARSE, ("Null path (%p) or scope (%p)!\n", + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Null path (%p) or scope (%p)!\n", Path, Scope)); return_PTR (NULL); } AcpiGbl_PsFindCount++; /* Handle all prefixes in the name path */ while (AcpiPsIsPrefixChar (GET8 (Path))) { switch (GET8 (Path)) { case '\\': /* Could just use a global for "root scope" here */ while (Scope->Parent) { Scope = Scope->Parent; } /* get first object within the scope */ /* TBD: [Investigate] OR - set next in root scope to point to the same value as arg */ /* Scope = Scope->Value.Arg; */ break; case '^': /* Go up to the next valid scoping Op (method, scope, etc.) */ if (AcpiPsGetParent (Scope)) { Scope = AcpiPsGetParent (Scope); } break; } Unprefixed = FALSE; Path++; } /* get name segment count */ switch (GET8 (Path)) { case '\0': SegCount = 0; /* Null name case */ if (Unprefixed) { Op = NULL; } else { Op = Scope; } - DEBUG_PRINTP (TRACE_PARSE, ("Null path, returning current root scope Op=%p\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Null path, returning current root scope Op=%p\n", Op)); return_PTR (Op); break; case AML_DUAL_NAME_PREFIX: SegCount = 2; Path++; break; case AML_MULTI_NAME_PREFIX_OP: SegCount = GET8 (Path + 1); Path += 2; break; default: SegCount = 1; break; } - DEBUG_PRINTP (TRACE_PARSE, ("Search scope %p Segs=%d Opcode=%4.4X Create=%d\n", + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Search scope %p Segs=%d Opcode=%4.4X Create=%d\n", Scope, SegCount, Opcode, Create)); /* match each name segment */ while (Scope && SegCount) { MOVE_UNALIGNED32_TO_32 (&Name, Path); Path += 4; SegCount --; if (SegCount) { NameOp = 0; } else { NameOp = Opcode; } Op = AcpiPsFindName (Scope, Name, NameOp); if (Op) { - DEBUG_PRINTP (TRACE_PARSE, ("[%4.4s] Found! Op=%p Opcode=%4.4X\n", &Name, Op, Op->Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "[%4.4s] Found! Op=%p Opcode=%4.4X\n", &Name, Op, Op->Opcode)); } if (!Op) { if (Create) { /* Create a new Scope level */ if (SegCount) { Op = AcpiPsAllocOp (AML_SCOPE_OP); } else { Op = AcpiPsAllocOp (Opcode); } if (Op) { AcpiPsSetName (Op, Name); AcpiPsAppendArg (Scope, Op); - DEBUG_PRINTP (TRACE_PARSE, ("[%4.4s] Not found, created Op=%p Opcode=%4.4X\n", &Name, Op, Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "[%4.4s] Not found, created Op=%p Opcode=%4.4X\n", &Name, Op, Opcode)); } } else if (Unprefixed) { /* Search higher scopes for unprefixed name */ while (!Op && Scope->Parent) { Scope = Scope->Parent; Op = AcpiPsFindName (Scope, Name, Opcode); if (Op) { - DEBUG_PRINTP (TRACE_PARSE, ("[%4.4s] Found in parent tree! Op=%p Opcode=%4.4X\n", &Name, Op, Op->Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "[%4.4s] Found in parent tree! Op=%p Opcode=%4.4X\n", &Name, Op, Op->Opcode)); } else { - DEBUG_PRINTP (TRACE_PARSE, ("[%4.4s] Not found in parent=%p\n", &Name, Scope)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "[%4.4s] Not found in parent=%p\n", &Name, Scope)); } } } else { - DEBUG_PRINTP (TRACE_PARSE, ("Segment [%4.4s] Not Found in scope %p!\n", &Name, Scope)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Segment [%4.4s] Not Found in scope %p!\n", &Name, Scope)); } } Unprefixed = FALSE; Scope = Op; } return_PTR (Op); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/psopcode.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/psopcode.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/psopcode.c (revision 82367) @@ -1,752 +1,752 @@ /****************************************************************************** * * Module Name: psopcode - Parser opcode information table - * $Revision: 33 $ + * $Revision: 35 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #define _COMPONENT ACPI_PARSER MODULE_NAME ("psopcode") #define _UNK 0x6B /* * Reserved ASCII characters. Do not use any of these for * internal opcodes, since they are used to differentiate * name strings from AML opcodes */ #define _ASC 0x6C #define _NAM 0x6C #define _PFX 0x6D #define _UNKNOWN_OPCODE 0x02 /* An example unknown opcode */ #define MAX_EXTENDED_OPCODE 0x88 #define NUM_EXTENDED_OPCODE MAX_EXTENDED_OPCODE + 1 #define MAX_INTERNAL_OPCODE #define NUM_INTERNAL_OPCODE MAX_INTERNAL_OPCODE + 1 /******************************************************************************* * * NAME: AcpiGbl_AmlOpInfo * * DESCRIPTION: Opcode table. Each entry contains * The name is a simple ascii string, the operand specifier is an * ascii string with one letter per operand. The letter specifies * the operand type. * ******************************************************************************/ /* * Flags byte: 0-4 (5 bits) = Opcode Type * 5 (1 bit) = Has arguments flag * 6-7 (2 bits) = Reserved */ #define AML_NO_ARGS 0 #define AML_HAS_ARGS ACPI_OP_ARGS_MASK /* * All AML opcodes and the parse-time arguments for each. Used by the AML parser Each list is compressed * into a 32-bit number and stored in the master opcode table at the end of this file. */ #define ARGP_ZERO_OP ARG_NONE #define ARGP_ONE_OP ARG_NONE #define ARGP_ALIAS_OP ARGP_LIST2 (ARGP_NAMESTRING, ARGP_NAME) #define ARGP_NAME_OP ARGP_LIST2 (ARGP_NAME, ARGP_DATAOBJ) #define ARGP_BYTE_OP ARGP_LIST1 (ARGP_BYTEDATA) #define ARGP_WORD_OP ARGP_LIST1 (ARGP_WORDDATA) #define ARGP_DWORD_OP ARGP_LIST1 (ARGP_DWORDDATA) #define ARGP_STRING_OP ARGP_LIST1 (ARGP_CHARLIST) #define ARGP_QWORD_OP ARGP_LIST1 (ARGP_QWORDDATA) #define ARGP_SCOPE_OP ARGP_LIST3 (ARGP_PKGLENGTH, ARGP_NAME, ARGP_TERMLIST) #define ARGP_BUFFER_OP ARGP_LIST3 (ARGP_PKGLENGTH, ARGP_TERMARG, ARGP_BYTELIST) #define ARGP_PACKAGE_OP ARGP_LIST3 (ARGP_PKGLENGTH, ARGP_BYTEDATA, ARGP_DATAOBJLIST) #define ARGP_VAR_PACKAGE_OP ARGP_LIST3 (ARGP_PKGLENGTH, ARGP_BYTEDATA, ARGP_DATAOBJLIST) #define ARGP_METHOD_OP ARGP_LIST4 (ARGP_PKGLENGTH, ARGP_NAME, ARGP_BYTEDATA, ARGP_TERMLIST) #define ARGP_LOCAL0 ARG_NONE #define ARGP_LOCAL1 ARG_NONE #define ARGP_LOCAL2 ARG_NONE #define ARGP_LOCAL3 ARG_NONE #define ARGP_LOCAL4 ARG_NONE #define ARGP_LOCAL5 ARG_NONE #define ARGP_LOCAL6 ARG_NONE #define ARGP_LOCAL7 ARG_NONE #define ARGP_ARG0 ARG_NONE #define ARGP_ARG1 ARG_NONE #define ARGP_ARG2 ARG_NONE #define ARGP_ARG3 ARG_NONE #define ARGP_ARG4 ARG_NONE #define ARGP_ARG5 ARG_NONE #define ARGP_ARG6 ARG_NONE #define ARGP_STORE_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_SUPERNAME) #define ARGP_REF_OF_OP ARGP_LIST1 (ARGP_SUPERNAME) #define ARGP_ADD_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_CONCAT_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_SUBTRACT_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_INCREMENT_OP ARGP_LIST1 (ARGP_SUPERNAME) #define ARGP_DECREMENT_OP ARGP_LIST1 (ARGP_SUPERNAME) #define ARGP_MULTIPLY_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_DIVIDE_OP ARGP_LIST4 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET, ARGP_TARGET) #define ARGP_SHIFT_LEFT_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_SHIFT_RIGHT_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_BIT_AND_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_BIT_NAND_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_BIT_OR_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_BIT_NOR_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_BIT_XOR_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_BIT_NOT_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TARGET) #define ARGP_FIND_SET_LEFT_BIT_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TARGET) #define ARGP_FIND_SET_RIGHT_BIT_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TARGET) #define ARGP_DEREF_OF_OP ARGP_LIST1 (ARGP_TERMARG) #define ARGP_CONCAT_RES_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_MOD_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_NOTIFY_OP ARGP_LIST2 (ARGP_SUPERNAME, ARGP_TERMARG) #define ARGP_SIZE_OF_OP ARGP_LIST1 (ARGP_SUPERNAME) #define ARGP_INDEX_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_MATCH_OP ARGP_LIST6 (ARGP_TERMARG, ARGP_BYTEDATA, ARGP_TERMARG, ARGP_BYTEDATA, ARGP_TERMARG, ARGP_TERMARG) #define ARGP_CREATE_DWORD_FIELD_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_NAME) #define ARGP_CREATE_WORD_FIELD_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_NAME) #define ARGP_CREATE_BYTE_FIELD_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_NAME) #define ARGP_CREATE_BIT_FIELD_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_NAME) #define ARGP_TYPE_OP ARGP_LIST1 (ARGP_SUPERNAME) #define ARGP_CREATE_QWORD_FIELD_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_NAME) #define ARGP_LAND_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TERMARG) #define ARGP_LOR_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TERMARG) #define ARGP_LNOT_OP ARGP_LIST1 (ARGP_TERMARG) #define ARGP_LEQUAL_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TERMARG) #define ARGP_LGREATER_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TERMARG) #define ARGP_LLESS_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TERMARG) #define ARGP_TO_BUFFER_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TARGET) #define ARGP_TO_DEC_STR_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TARGET) #define ARGP_TO_HEX_STR_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TARGET) #define ARGP_TO_INTEGER_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TARGET) #define ARGP_TO_STRING_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_COPY_OP ARGP_LIST2 (ARGP_SUPERNAME, ARGP_SIMPLENAME) #define ARGP_MID_OP ARGP_LIST4 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET) #define ARGP_CONTINUE_OP ARG_NONE #define ARGP_IF_OP ARGP_LIST3 (ARGP_PKGLENGTH, ARGP_TERMARG, ARGP_TERMLIST) #define ARGP_ELSE_OP ARGP_LIST2 (ARGP_PKGLENGTH, ARGP_TERMLIST) #define ARGP_WHILE_OP ARGP_LIST3 (ARGP_PKGLENGTH, ARGP_TERMARG, ARGP_TERMLIST) #define ARGP_NOOP_OP ARG_NONE #define ARGP_RETURN_OP ARGP_LIST1 (ARGP_TERMARG) #define ARGP_BREAK_OP ARG_NONE #define ARGP_BREAK_POINT_OP ARG_NONE #define ARGP_ONES_OP ARG_NONE #define ARGP_MUTEX_OP ARGP_LIST2 (ARGP_NAME, ARGP_BYTEDATA) #define ARGP_EVENT_OP ARGP_LIST1 (ARGP_NAME) #define ARGP_COND_REF_OF_OP ARGP_LIST2 (ARGP_SUPERNAME, ARGP_SUPERNAME) #define ARGP_CREATE_FIELD_OP ARGP_LIST4 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TERMARG, ARGP_NAME) #define ARGP_LOAD_TABLE_OP ARGP_LIST6 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TERMARG, ARGP_TERMARG, ARGP_TERMARG, ARGP_TERMARG) #define ARGP_LOAD_OP ARGP_LIST2 (ARGP_NAMESTRING, ARGP_SUPERNAME) #define ARGP_STALL_OP ARGP_LIST1 (ARGP_TERMARG) #define ARGP_SLEEP_OP ARGP_LIST1 (ARGP_TERMARG) #define ARGP_ACQUIRE_OP ARGP_LIST2 (ARGP_SUPERNAME, ARGP_WORDDATA) #define ARGP_SIGNAL_OP ARGP_LIST1 (ARGP_SUPERNAME) #define ARGP_WAIT_OP ARGP_LIST2 (ARGP_SUPERNAME, ARGP_TERMARG) #define ARGP_RESET_OP ARGP_LIST1 (ARGP_SUPERNAME) #define ARGP_RELEASE_OP ARGP_LIST1 (ARGP_SUPERNAME) #define ARGP_FROM_BCD_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TARGET) #define ARGP_TO_BCD_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TARGET) #define ARGP_UNLOAD_OP ARGP_LIST1 (ARGP_SUPERNAME) #define ARGP_REVISION_OP ARG_NONE #define ARGP_DEBUG_OP ARG_NONE #define ARGP_FATAL_OP ARGP_LIST3 (ARGP_BYTEDATA, ARGP_DWORDDATA, ARGP_TERMARG) #define ARGP_REGION_OP ARGP_LIST4 (ARGP_NAME, ARGP_BYTEDATA, ARGP_TERMARG, ARGP_TERMARG) #define ARGP_FIELD_OP ARGP_LIST4 (ARGP_PKGLENGTH, ARGP_NAMESTRING, ARGP_BYTEDATA, ARGP_FIELDLIST) #define ARGP_DEVICE_OP ARGP_LIST3 (ARGP_PKGLENGTH, ARGP_NAME, ARGP_OBJLIST) #define ARGP_PROCESSOR_OP ARGP_LIST6 (ARGP_PKGLENGTH, ARGP_NAME, ARGP_BYTEDATA, ARGP_DWORDDATA, ARGP_BYTEDATA, ARGP_OBJLIST) #define ARGP_POWER_RES_OP ARGP_LIST5 (ARGP_PKGLENGTH, ARGP_NAME, ARGP_BYTEDATA, ARGP_WORDDATA, ARGP_OBJLIST) #define ARGP_THERMAL_ZONE_OP ARGP_LIST3 (ARGP_PKGLENGTH, ARGP_NAME, ARGP_OBJLIST) #define ARGP_INDEX_FIELD_OP ARGP_LIST5 (ARGP_PKGLENGTH, ARGP_NAMESTRING, ARGP_NAMESTRING,ARGP_BYTEDATA, ARGP_FIELDLIST) #define ARGP_BANK_FIELD_OP ARGP_LIST6 (ARGP_PKGLENGTH, ARGP_NAMESTRING, ARGP_NAMESTRING,ARGP_TERMARG, ARGP_BYTEDATA, ARGP_FIELDLIST) #define ARGP_DATA_REGION_OP ARGP_LIST4 (ARGP_NAMESTRING, ARGP_TERMARG, ARGP_TERMARG, ARGP_TERMARG) #define ARGP_LNOTEQUAL_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TERMARG) #define ARGP_LLESSEQUAL_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TERMARG) #define ARGP_LGREATEREQUAL_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_TERMARG) #define ARGP_NAMEPATH_OP ARGP_LIST1 (ARGP_NAMESTRING) #define ARGP_METHODCALL_OP ARGP_LIST1 (ARGP_NAMESTRING) #define ARGP_BYTELIST_OP ARGP_LIST1 (ARGP_NAMESTRING) #define ARGP_RESERVEDFIELD_OP ARGP_LIST1 (ARGP_NAMESTRING) #define ARGP_NAMEDFIELD_OP ARGP_LIST1 (ARGP_NAMESTRING) #define ARGP_ACCESSFIELD_OP ARGP_LIST1 (ARGP_NAMESTRING) #define ARGP_STATICSTRING_OP ARGP_LIST1 (ARGP_NAMESTRING) /* * All AML opcodes and the runtime arguments for each. Used by the AML interpreter Each list is compressed * into a 32-bit number and stored in the master opcode table at the end of this file. * * (Used by PrepOperands procedure and the ASL Compiler) */ #define ARGI_ZERO_OP ARG_NONE #define ARGI_ONE_OP ARG_NONE #define ARGI_ALIAS_OP ARGI_INVALID_OPCODE #define ARGI_NAME_OP ARGI_INVALID_OPCODE #define ARGI_BYTE_OP ARGI_INVALID_OPCODE #define ARGI_WORD_OP ARGI_INVALID_OPCODE #define ARGI_DWORD_OP ARGI_INVALID_OPCODE #define ARGI_STRING_OP ARGI_INVALID_OPCODE #define ARGI_QWORD_OP ARGI_INVALID_OPCODE #define ARGI_SCOPE_OP ARGI_INVALID_OPCODE #define ARGI_BUFFER_OP ARGI_INVALID_OPCODE #define ARGI_PACKAGE_OP ARGI_INVALID_OPCODE #define ARGI_VAR_PACKAGE_OP ARGI_INVALID_OPCODE #define ARGI_METHOD_OP ARGI_INVALID_OPCODE #define ARGI_LOCAL0 ARG_NONE #define ARGI_LOCAL1 ARG_NONE #define ARGI_LOCAL2 ARG_NONE #define ARGI_LOCAL3 ARG_NONE #define ARGI_LOCAL4 ARG_NONE #define ARGI_LOCAL5 ARG_NONE #define ARGI_LOCAL6 ARG_NONE #define ARGI_LOCAL7 ARG_NONE #define ARGI_ARG0 ARG_NONE #define ARGI_ARG1 ARG_NONE #define ARGI_ARG2 ARG_NONE #define ARGI_ARG3 ARG_NONE #define ARGI_ARG4 ARG_NONE #define ARGI_ARG5 ARG_NONE #define ARGI_ARG6 ARG_NONE #define ARGI_STORE_OP ARGI_LIST2 (ARGI_ANYTYPE, ARGI_TARGETREF) #define ARGI_REF_OF_OP ARGI_LIST1 (ARGI_OBJECT_REF) #define ARGI_ADD_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_CONCAT_OP ARGI_LIST3 (ARGI_COMPUTEDATA,ARGI_COMPUTEDATA, ARGI_TARGETREF) #define ARGI_SUBTRACT_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_INCREMENT_OP ARGI_LIST1 (ARGI_INTEGER_REF) #define ARGI_DECREMENT_OP ARGI_LIST1 (ARGI_INTEGER_REF) #define ARGI_MULTIPLY_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_DIVIDE_OP ARGI_LIST4 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF, ARGI_TARGETREF) #define ARGI_SHIFT_LEFT_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_SHIFT_RIGHT_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_BIT_AND_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_BIT_NAND_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_BIT_OR_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_BIT_NOR_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_BIT_XOR_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_BIT_NOT_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_FIND_SET_LEFT_BIT_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_FIND_SET_RIGHT_BIT_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_DEREF_OF_OP ARGI_LIST1 (ARGI_REFERENCE) #define ARGI_CONCAT_RES_OP ARGI_LIST3 (ARGI_BUFFER, ARGI_BUFFER, ARGI_TARGETREF) #define ARGI_MOD_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_NOTIFY_OP ARGI_LIST2 (ARGI_DEVICE_REF, ARGI_INTEGER) #define ARGI_SIZE_OF_OP ARGI_LIST1 (ARGI_DATAOBJECT) #define ARGI_INDEX_OP ARGI_LIST3 (ARGI_COMPLEXOBJ, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_MATCH_OP ARGI_LIST6 (ARGI_PACKAGE, ARGI_INTEGER, ARGI_INTEGER, ARGI_INTEGER, ARGI_INTEGER, ARGI_INTEGER) #define ARGI_CREATE_DWORD_FIELD_OP ARGI_LIST3 (ARGI_BUFFER, ARGI_INTEGER, ARGI_REFERENCE) #define ARGI_CREATE_WORD_FIELD_OP ARGI_LIST3 (ARGI_BUFFER, ARGI_INTEGER, ARGI_REFERENCE) #define ARGI_CREATE_BYTE_FIELD_OP ARGI_LIST3 (ARGI_BUFFER, ARGI_INTEGER, ARGI_REFERENCE) #define ARGI_CREATE_BIT_FIELD_OP ARGI_LIST3 (ARGI_BUFFER, ARGI_INTEGER, ARGI_REFERENCE) #define ARGI_TYPE_OP ARGI_LIST1 (ARGI_ANYTYPE) #define ARGI_CREATE_QWORD_FIELD_OP ARGI_LIST3 (ARGI_BUFFER, ARGI_INTEGER, ARGI_REFERENCE) #define ARGI_LAND_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_INTEGER) #define ARGI_LOR_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_INTEGER) #define ARGI_LNOT_OP ARGI_LIST1 (ARGI_INTEGER) #define ARGI_LEQUAL_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_INTEGER) #define ARGI_LGREATER_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_INTEGER) #define ARGI_LLESS_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_INTEGER) #define ARGI_TO_BUFFER_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET) #define ARGI_TO_DEC_STR_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET) #define ARGI_TO_HEX_STR_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET) #define ARGI_TO_INTEGER_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET) #define ARGI_TO_STRING_OP ARGI_LIST3 (ARGI_BUFFER, ARGI_INTEGER, ARGI_FIXED_TARGET) #define ARGI_COPY_OP ARGI_LIST2 (ARGI_ANYTYPE, ARGI_SIMPLE_TARGET) #define ARGI_MID_OP ARGI_LIST4 (ARGI_BUFFERSTRING,ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_CONTINUE_OP ARGI_INVALID_OPCODE #define ARGI_IF_OP ARGI_INVALID_OPCODE #define ARGI_ELSE_OP ARGI_INVALID_OPCODE #define ARGI_WHILE_OP ARGI_INVALID_OPCODE #define ARGI_NOOP_OP ARG_NONE #define ARGI_RETURN_OP ARGI_INVALID_OPCODE #define ARGI_BREAK_OP ARG_NONE #define ARGI_BREAK_POINT_OP ARG_NONE #define ARGI_ONES_OP ARG_NONE #define ARGI_MUTEX_OP ARGI_INVALID_OPCODE #define ARGI_EVENT_OP ARGI_INVALID_OPCODE #define ARGI_COND_REF_OF_OP ARGI_LIST2 (ARGI_OBJECT_REF, ARGI_TARGETREF) #define ARGI_CREATE_FIELD_OP ARGI_LIST4 (ARGI_BUFFER, ARGI_INTEGER, ARGI_INTEGER, ARGI_REFERENCE) #define ARGI_LOAD_TABLE_OP ARGI_LIST6 (ARGI_STRING, ARGI_STRING, ARGI_STRING, ARGI_STRING, ARGI_STRING, ARGI_TARGETREF) #define ARGI_LOAD_OP ARGI_LIST2 (ARGI_REGION, ARGI_TARGETREF) #define ARGI_STALL_OP ARGI_LIST1 (ARGI_INTEGER) #define ARGI_SLEEP_OP ARGI_LIST1 (ARGI_INTEGER) #define ARGI_ACQUIRE_OP ARGI_LIST2 (ARGI_MUTEX, ARGI_INTEGER) #define ARGI_SIGNAL_OP ARGI_LIST1 (ARGI_EVENT) #define ARGI_WAIT_OP ARGI_LIST2 (ARGI_EVENT, ARGI_INTEGER) #define ARGI_RESET_OP ARGI_LIST1 (ARGI_EVENT) #define ARGI_RELEASE_OP ARGI_LIST1 (ARGI_MUTEX) #define ARGI_FROM_BCD_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF) #define ARGI_TO_BCD_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_FIXED_TARGET) #define ARGI_UNLOAD_OP ARGI_LIST1 (ARGI_DDBHANDLE) #define ARGI_REVISION_OP ARG_NONE #define ARGI_DEBUG_OP ARG_NONE #define ARGI_FATAL_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_INTEGER) #define ARGI_REGION_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_INTEGER) #define ARGI_FIELD_OP ARGI_INVALID_OPCODE #define ARGI_DEVICE_OP ARGI_INVALID_OPCODE #define ARGI_PROCESSOR_OP ARGI_INVALID_OPCODE #define ARGI_POWER_RES_OP ARGI_INVALID_OPCODE #define ARGI_THERMAL_ZONE_OP ARGI_INVALID_OPCODE #define ARGI_INDEX_FIELD_OP ARGI_INVALID_OPCODE #define ARGI_BANK_FIELD_OP ARGI_INVALID_OPCODE #define ARGI_DATA_REGION_OP ARGI_LIST3 (ARGI_STRING, ARGI_STRING, ARGI_STRING) #define ARGI_LNOTEQUAL_OP ARGI_INVALID_OPCODE #define ARGI_LLESSEQUAL_OP ARGI_INVALID_OPCODE #define ARGI_LGREATEREQUAL_OP ARGI_INVALID_OPCODE #define ARGI_NAMEPATH_OP ARGI_INVALID_OPCODE #define ARGI_METHODCALL_OP ARGI_INVALID_OPCODE #define ARGI_BYTELIST_OP ARGI_INVALID_OPCODE #define ARGI_RESERVEDFIELD_OP ARGI_INVALID_OPCODE #define ARGI_NAMEDFIELD_OP ARGI_INVALID_OPCODE #define ARGI_ACCESSFIELD_OP ARGI_INVALID_OPCODE #define ARGI_STATICSTRING_OP ARGI_INVALID_OPCODE /* * Master Opcode information table. A summary of everything we know about each opcode, all in one place. */ static ACPI_OPCODE_INFO AmlOpInfo[] = { /* Index Opcode Type Class Has Arguments? Name Parser Args Interpreter Args */ /* 00 */ /* AML_ZERO_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONSTANT| AML_NO_ARGS, "Zero", ARGP_ZERO_OP, ARGI_ZERO_OP), /* 01 */ /* AML_ONE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONSTANT| AML_NO_ARGS, "One", ARGP_ONE_OP, ARGI_ONE_OP), /* 02 */ /* AML_ALIAS_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "Alias", ARGP_ALIAS_OP, ARGI_ALIAS_OP), /* 03 */ /* AML_NAME_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "Name", ARGP_NAME_OP, ARGI_NAME_OP), /* 04 */ /* AML_BYTE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LITERAL| AML_NO_ARGS, "ByteConst", ARGP_BYTE_OP, ARGI_BYTE_OP), /* 05 */ /* AML_WORD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LITERAL| AML_NO_ARGS, "WordConst", ARGP_WORD_OP, ARGI_WORD_OP), /* 06 */ /* AML_DWORD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LITERAL| AML_NO_ARGS, "DwordConst", ARGP_DWORD_OP, ARGI_DWORD_OP), /* 07 */ /* AML_STRING_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LITERAL| AML_NO_ARGS, "String", ARGP_STRING_OP, ARGI_STRING_OP), /* 08 */ /* AML_SCOPE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "Scope", ARGP_SCOPE_OP, ARGI_SCOPE_OP), /* 09 */ /* AML_BUFFER_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DATA_TERM| AML_HAS_ARGS, "Buffer", ARGP_BUFFER_OP, ARGI_BUFFER_OP), /* 0A */ /* AML_PACKAGE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DATA_TERM| AML_HAS_ARGS, "Package", ARGP_PACKAGE_OP, ARGI_PACKAGE_OP), /* 0B */ /* AML_METHOD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "Method", ARGP_METHOD_OP, ARGI_METHOD_OP), /* 0C */ /* AML_LOCAL0 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LOCAL_VARIABLE| AML_NO_ARGS, "Local0", ARGP_LOCAL0, ARGI_LOCAL0), /* 0D */ /* AML_LOCAL1 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LOCAL_VARIABLE| AML_NO_ARGS, "Local1", ARGP_LOCAL1, ARGI_LOCAL1), /* 0E */ /* AML_LOCAL2 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LOCAL_VARIABLE| AML_NO_ARGS, "Local2", ARGP_LOCAL2, ARGI_LOCAL2), /* 0F */ /* AML_LOCAL3 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LOCAL_VARIABLE| AML_NO_ARGS, "Local3", ARGP_LOCAL3, ARGI_LOCAL3), /* 10 */ /* AML_LOCAL4 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LOCAL_VARIABLE| AML_NO_ARGS, "Local4", ARGP_LOCAL4, ARGI_LOCAL4), /* 11 */ /* AML_LOCAL5 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LOCAL_VARIABLE| AML_NO_ARGS, "Local5", ARGP_LOCAL5, ARGI_LOCAL5), /* 12 */ /* AML_LOCAL6 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LOCAL_VARIABLE| AML_NO_ARGS, "Local6", ARGP_LOCAL6, ARGI_LOCAL6), /* 13 */ /* AML_LOCAL7 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LOCAL_VARIABLE| AML_NO_ARGS, "Local7", ARGP_LOCAL7, ARGI_LOCAL7), /* 14 */ /* AML_ARG0 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_METHOD_ARGUMENT| AML_NO_ARGS, "Arg0", ARGP_ARG0, ARGI_ARG0), /* 15 */ /* AML_ARG1 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_METHOD_ARGUMENT| AML_NO_ARGS, "Arg1", ARGP_ARG1, ARGI_ARG1), /* 16 */ /* AML_ARG2 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_METHOD_ARGUMENT| AML_NO_ARGS, "Arg2", ARGP_ARG2, ARGI_ARG2), /* 17 */ /* AML_ARG3 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_METHOD_ARGUMENT| AML_NO_ARGS, "Arg3", ARGP_ARG3, ARGI_ARG3), /* 18 */ /* AML_ARG4 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_METHOD_ARGUMENT| AML_NO_ARGS, "Arg4", ARGP_ARG4, ARGI_ARG4), /* 19 */ /* AML_ARG5 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_METHOD_ARGUMENT| AML_NO_ARGS, "Arg5", ARGP_ARG5, ARGI_ARG5), /* 1A */ /* AML_ARG6 */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_METHOD_ARGUMENT| AML_NO_ARGS, "Arg6", ARGP_ARG6, ARGI_ARG6), /* 1B */ /* AML_STORE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "Store", ARGP_STORE_OP, ARGI_STORE_OP), /* 1C */ /* AML_REF_OF_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2| AML_HAS_ARGS, "RefOf", ARGP_REF_OF_OP, ARGI_REF_OF_OP), /* 1D */ /* AML_ADD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "Add", ARGP_ADD_OP, ARGI_ADD_OP), /* 1E */ /* AML_CONCAT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "Concatenate", ARGP_CONCAT_OP, ARGI_CONCAT_OP), /* 1F */ /* AML_SUBTRACT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "Subtract", ARGP_SUBTRACT_OP, ARGI_SUBTRACT_OP), /* 20 */ /* AML_INCREMENT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2| AML_HAS_ARGS, "Increment", ARGP_INCREMENT_OP, ARGI_INCREMENT_OP), /* 21 */ /* AML_DECREMENT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2| AML_HAS_ARGS, "Decrement", ARGP_DECREMENT_OP, ARGI_DECREMENT_OP), /* 22 */ /* AML_MULTIPLY_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "Multiply", ARGP_MULTIPLY_OP, ARGI_MULTIPLY_OP), /* 23 */ /* AML_DIVIDE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "Divide", ARGP_DIVIDE_OP, ARGI_DIVIDE_OP), /* 24 */ /* AML_SHIFT_LEFT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "ShiftLeft", ARGP_SHIFT_LEFT_OP, ARGI_SHIFT_LEFT_OP), /* 25 */ /* AML_SHIFT_RIGHT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "ShiftRight", ARGP_SHIFT_RIGHT_OP, ARGI_SHIFT_RIGHT_OP), /* 26 */ /* AML_BIT_AND_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "And", ARGP_BIT_AND_OP, ARGI_BIT_AND_OP), /* 27 */ /* AML_BIT_NAND_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "NAnd", ARGP_BIT_NAND_OP, ARGI_BIT_NAND_OP), /* 28 */ /* AML_BIT_OR_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "Or", ARGP_BIT_OR_OP, ARGI_BIT_OR_OP), /* 29 */ /* AML_BIT_NOR_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "NOr", ARGP_BIT_NOR_OP, ARGI_BIT_NOR_OP), /* 2A */ /* AML_BIT_XOR_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "XOr", ARGP_BIT_XOR_OP, ARGI_BIT_XOR_OP), /* 2B */ /* AML_BIT_NOT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "Not", ARGP_BIT_NOT_OP, ARGI_BIT_NOT_OP), /* 2C */ /* AML_FIND_SET_LEFT_BIT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "FindSetLeftBit", ARGP_FIND_SET_LEFT_BIT_OP, ARGI_FIND_SET_LEFT_BIT_OP), /* 2D */ /* AML_FIND_SET_RIGHT_BIT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "FindSetRightBit", ARGP_FIND_SET_RIGHT_BIT_OP,ARGI_FIND_SET_RIGHT_BIT_OP), /* 2E */ /* AML_DEREF_OF_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2| AML_HAS_ARGS, "DerefOf", ARGP_DEREF_OF_OP, ARGI_DEREF_OF_OP), /* 2F */ /* AML_NOTIFY_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC1| AML_HAS_ARGS, "Notify", ARGP_NOTIFY_OP, ARGI_NOTIFY_OP), /* 30 */ /* AML_SIZE_OF_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2| AML_HAS_ARGS, "SizeOf", ARGP_SIZE_OF_OP, ARGI_SIZE_OF_OP), /* 31 */ /* AML_INDEX_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_TRIADIC| AML_HAS_ARGS, "Index", ARGP_INDEX_OP, ARGI_INDEX_OP), /* 32 */ /* AML_MATCH_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_HEXADIC| AML_HAS_ARGS, "Match", ARGP_MATCH_OP, ARGI_MATCH_OP), /* 33 */ /* AML_CREATE_DWORD_FIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CREATE_FIELD| AML_HAS_ARGS, "CreateDWordField", ARGP_CREATE_DWORD_FIELD_OP,ARGI_CREATE_DWORD_FIELD_OP), /* 34 */ /* AML_CREATE_WORD_FIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CREATE_FIELD| AML_HAS_ARGS, "CreateWordField", ARGP_CREATE_WORD_FIELD_OP, ARGI_CREATE_WORD_FIELD_OP), /* 35 */ /* AML_CREATE_BYTE_FIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CREATE_FIELD| AML_HAS_ARGS, "CreateByteField", ARGP_CREATE_BYTE_FIELD_OP, ARGI_CREATE_BYTE_FIELD_OP), /* 36 */ /* AML_CREATE_BIT_FIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CREATE_FIELD| AML_HAS_ARGS, "CreateBitField", ARGP_CREATE_BIT_FIELD_OP, ARGI_CREATE_BIT_FIELD_OP), /* 37 */ /* AML_TYPE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2| AML_HAS_ARGS, "ObjectType", ARGP_TYPE_OP, ARGI_TYPE_OP), /* 38 */ /* AML_LAND_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2| AML_HAS_ARGS, "LAnd", ARGP_LAND_OP, ARGI_LAND_OP), /* 39 */ /* AML_LOR_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2| AML_HAS_ARGS, "LOr", ARGP_LOR_OP, ARGI_LOR_OP), /* 3A */ /* AML_LNOT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2| AML_HAS_ARGS, "LNot", ARGP_LNOT_OP, ARGI_LNOT_OP), /* 3B */ /* AML_LEQUAL_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2| AML_HAS_ARGS, "LEqual", ARGP_LEQUAL_OP, ARGI_LEQUAL_OP), /* 3C */ /* AML_LGREATER_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2| AML_HAS_ARGS, "LGreater", ARGP_LGREATER_OP, ARGI_LGREATER_OP), /* 3D */ /* AML_LLESS_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2| AML_HAS_ARGS, "LLess", ARGP_LLESS_OP, ARGI_LLESS_OP), /* 3E */ /* AML_IF_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONTROL| AML_HAS_ARGS, "If", ARGP_IF_OP, ARGI_IF_OP), /* 3F */ /* AML_ELSE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONTROL| AML_HAS_ARGS, "Else", ARGP_ELSE_OP, ARGI_ELSE_OP), /* 40 */ /* AML_WHILE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONTROL| AML_HAS_ARGS, "While", ARGP_WHILE_OP, ARGI_WHILE_OP), /* 41 */ /* AML_NOOP_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONTROL| AML_NO_ARGS, "Noop", ARGP_NOOP_OP, ARGI_NOOP_OP), /* 42 */ /* AML_RETURN_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONTROL| AML_HAS_ARGS, "Return", ARGP_RETURN_OP, ARGI_RETURN_OP), /* 43 */ /* AML_BREAK_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONTROL| AML_NO_ARGS, "Break", ARGP_BREAK_OP, ARGI_BREAK_OP), /* 44 */ /* AML_BREAK_POINT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONTROL| AML_NO_ARGS, "BreakPoint", ARGP_BREAK_POINT_OP, ARGI_BREAK_POINT_OP), /* 45 */ /* AML_ONES_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONSTANT| AML_NO_ARGS, "Ones", ARGP_ONES_OP, ARGI_ONES_OP), /* Prefixed opcodes (Two-byte opcodes with a prefix op) */ /* 46 */ /* AML_MUTEX_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "Mutex", ARGP_MUTEX_OP, ARGI_MUTEX_OP), /* 47 */ /* AML_EVENT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_NO_ARGS, "Event", ARGP_EVENT_OP, ARGI_EVENT_OP), /* 48 */ /* AML_COND_REF_OF_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "CondRefOf", ARGP_COND_REF_OF_OP, ARGI_COND_REF_OF_OP), /* 49 */ /* AML_CREATE_FIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CREATE_FIELD| AML_HAS_ARGS, "CreateField", ARGP_CREATE_FIELD_OP, ARGI_CREATE_FIELD_OP), /* 4A */ /* AML_LOAD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_RECONFIGURATION| AML_HAS_ARGS, "Load", ARGP_LOAD_OP, ARGI_LOAD_OP), /* 4B */ /* AML_STALL_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC1| AML_HAS_ARGS, "Stall", ARGP_STALL_OP, ARGI_STALL_OP), /* 4C */ /* AML_SLEEP_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC1| AML_HAS_ARGS, "Sleep", ARGP_SLEEP_OP, ARGI_SLEEP_OP), /* 4D */ /* AML_ACQUIRE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2S| AML_HAS_ARGS, "Acquire", ARGP_ACQUIRE_OP, ARGI_ACQUIRE_OP), /* 4E */ /* AML_SIGNAL_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC1| AML_HAS_ARGS, "Signal", ARGP_SIGNAL_OP, ARGI_SIGNAL_OP), /* 4F */ /* AML_WAIT_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2S| AML_HAS_ARGS, "Wait", ARGP_WAIT_OP, ARGI_WAIT_OP), /* 50 */ /* AML_RESET_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC1| AML_HAS_ARGS, "Reset", ARGP_RESET_OP, ARGI_RESET_OP), /* 51 */ /* AML_RELEASE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC1| AML_HAS_ARGS, "Release", ARGP_RELEASE_OP, ARGI_RELEASE_OP), /* 52 */ /* AML_FROM_BCD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "FromBCD", ARGP_FROM_BCD_OP, ARGI_FROM_BCD_OP), /* 53 */ /* AML_TO_BCD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "ToBCD", ARGP_TO_BCD_OP, ARGI_TO_BCD_OP), /* 54 */ /* AML_UNLOAD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_RECONFIGURATION| AML_HAS_ARGS, "Unload", ARGP_UNLOAD_OP, ARGI_UNLOAD_OP), /* 55 */ /* AML_REVISION_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONSTANT| AML_NO_ARGS, "Revision", ARGP_REVISION_OP, ARGI_REVISION_OP), /* 56 */ /* AML_DEBUG_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONSTANT| AML_NO_ARGS, "Debug", ARGP_DEBUG_OP, ARGI_DEBUG_OP), /* 57 */ /* AML_FATAL_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_TRIADIC| AML_HAS_ARGS, "Fatal", ARGP_FATAL_OP, ARGI_FATAL_OP), /* 58 */ /* AML_REGION_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "OpRegion", ARGP_REGION_OP, ARGI_REGION_OP), /* 59 */ /* AML_FIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "Field", ARGP_FIELD_OP, ARGI_FIELD_OP), /* 5A */ /* AML_DEVICE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "Device", ARGP_DEVICE_OP, ARGI_DEVICE_OP), /* 5B */ /* AML_PROCESSOR_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "Processor", ARGP_PROCESSOR_OP, ARGI_PROCESSOR_OP), /* 5C */ /* AML_POWER_RES_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "PowerResource", ARGP_POWER_RES_OP, ARGI_POWER_RES_OP), /* 5D */ /* AML_THERMAL_ZONE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "ThermalZone", ARGP_THERMAL_ZONE_OP, ARGI_THERMAL_ZONE_OP), /* 5E */ /* AML_INDEX_FIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "IndexField", ARGP_INDEX_FIELD_OP, ARGI_INDEX_FIELD_OP), /* 5F */ /* AML_BANK_FIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_NAMED_OBJECT| AML_HAS_ARGS, "BankField", ARGP_BANK_FIELD_OP, ARGI_BANK_FIELD_OP), /* Internal opcodes that map to invalid AML opcodes */ /* 60 */ /* AML_LNOTEQUAL_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_BOGUS| AML_HAS_ARGS, "LNotEqual", ARGP_LNOTEQUAL_OP, ARGI_LNOTEQUAL_OP), /* 61 */ /* AML_LLESSEQUAL_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_BOGUS| AML_HAS_ARGS, "LLessEqual", ARGP_LLESSEQUAL_OP, ARGI_LLESSEQUAL_OP), /* 62 */ /* AML_LGREATEREQUAL_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_BOGUS| AML_HAS_ARGS, "LGreaterEqual", ARGP_LGREATEREQUAL_OP, ARGI_LGREATEREQUAL_OP), /* 63 */ /* AML_INT_NAMEPATH_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LITERAL| AML_NO_ARGS, "NamePath", ARGP_NAMEPATH_OP, ARGI_NAMEPATH_OP), /* 64 */ /* AML_INT_METHODCALL_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_METHOD_CALL| AML_HAS_ARGS, "MethodCall", ARGP_METHODCALL_OP, ARGI_METHODCALL_OP), /* 65 */ /* AML_INT_BYTELIST_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LITERAL| AML_NO_ARGS, "ByteList", ARGP_BYTELIST_OP, ARGI_BYTELIST_OP), /* 66 */ /* AML_INT_RESERVEDFIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_BOGUS| AML_NO_ARGS, "ReservedField", ARGP_RESERVEDFIELD_OP, ARGI_RESERVEDFIELD_OP), /* 67 */ /* AML_INT_NAMEDFIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_BOGUS| AML_NO_ARGS, "NamedField", ARGP_NAMEDFIELD_OP, ARGI_NAMEDFIELD_OP), /* 68 */ /* AML_INT_ACCESSFIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_BOGUS| AML_NO_ARGS, "AccessField", ARGP_ACCESSFIELD_OP, ARGI_ACCESSFIELD_OP), /* 69 */ /* AML_INT_STATICSTRING_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_BOGUS| AML_NO_ARGS, "StaticString", ARGP_STATICSTRING_OP, ARGI_STATICSTRING_OP), /* 6A */ /* AML_INT_RETURN_VALUE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_RETURN| AML_HAS_ARGS, "[Return Value]", ARG_NONE, ARG_NONE), /* 6B */ /* UNKNOWN OPCODES */ OP_INFO_ENTRY (ACPI_OP_TYPE_UNKNOWN | OPTYPE_BOGUS| AML_HAS_ARGS, "UNKNOWN_OP!", ARG_NONE, ARG_NONE), /* 6C */ /* ASCII CHARACTERS */ OP_INFO_ENTRY (ACPI_OP_TYPE_ASCII | OPTYPE_BOGUS| AML_HAS_ARGS, "ASCII_ONLY!", ARG_NONE, ARG_NONE), /* 6D */ /* PREFIX CHARACTERS */ OP_INFO_ENTRY (ACPI_OP_TYPE_PREFIX | OPTYPE_BOGUS| AML_HAS_ARGS, "PREFIX_ONLY!", ARG_NONE, ARG_NONE), /* ACPI 2.0 (new) opcodes */ /* 6E */ /* AML_QWORD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_LITERAL| AML_NO_ARGS, "QwordConst", ARGP_QWORD_OP, ARGI_QWORD_OP), /* 6F */ /* AML_VAR_PACKAGE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DATA_TERM| AML_HAS_ARGS, "VarPackage", ARGP_VAR_PACKAGE_OP, ARGI_VAR_PACKAGE_OP), /* 70 */ /* AML_CONCAT_RES_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "ConcatRes", ARGP_CONCAT_RES_OP, ARGI_CONCAT_RES_OP), /* 71 */ /* AML_MOD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "Mod", ARGP_MOD_OP, ARGI_MOD_OP), /* 72 */ /* AML_CREATE_QWORD_FIELD_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CREATE_FIELD| AML_HAS_ARGS, "CreateQWordField", ARGP_CREATE_QWORD_FIELD_OP,ARGI_CREATE_QWORD_FIELD_OP), /* 73 */ /* AML_TO_BUFFER_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "ToBuffer", ARGP_TO_BUFFER_OP, ARGI_TO_BUFFER_OP), -/* 74 */ /* AML_TO_DECSTR_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "ToDecString", ARGP_TO_DEC_STR_OP, ARGI_TO_DEC_STR_OP), +/* 74 */ /* AML_TO_DECSTR_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "ToDecimalString", ARGP_TO_DEC_STR_OP, ARGI_TO_DEC_STR_OP), /* 75 */ /* AML_TO_HEXSTR_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "ToHexString", ARGP_TO_HEX_STR_OP, ARGI_TO_HEX_STR_OP), /* 76 */ /* AML_TO_INTEGER_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "ToInteger", ARGP_TO_INTEGER_OP, ARGI_TO_INTEGER_OP), /* 77 */ /* AML_TO_STRING_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_DYADIC2R| AML_HAS_ARGS, "ToString", ARGP_TO_STRING_OP, ARGI_TO_STRING_OP), /* 78 */ /* AML_COPY_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "CopyObject", ARGP_COPY_OP, ARGI_COPY_OP), /* 79 */ /* AML_MID_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "Mid", ARGP_MID_OP, ARGI_MID_OP), /* 7A */ /* AML_CONTINUE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_CONTROL| AML_NO_ARGS, "Continue", ARGP_CONTINUE_OP, ARGI_CONTINUE_OP), /* 7B */ /* AML_LOAD_TABLE_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "LoadTable", ARGP_LOAD_TABLE_OP, ARGI_LOAD_TABLE_OP), /* 7C */ /* AML_DATA_REGION_OP */ OP_INFO_ENTRY (ACPI_OP_TYPE_OPCODE | OPTYPE_MONADIC2R| AML_HAS_ARGS, "DataOpRegion", ARGP_DATA_REGION_OP, ARGI_DATA_REGION_OP), }; /* * This table is directly indexed by the opcodes, and returns an * index into the table above */ static UINT8 AmlShortOpInfoIndex[256] = { /* 0 1 2 3 4 5 6 7 */ /* 8 9 A B C D E F */ /* 0x00 */ 0x00, 0x01, _UNK, _UNK, _UNK, _UNK, 0x02, _UNK, /* 0x08 */ 0x03, _UNK, 0x04, 0x05, 0x06, 0x07, 0x6E, _UNK, /* 0x10 */ 0x08, 0x09, 0x0a, 0x6F, 0x0b, _UNK, _UNK, _UNK, /* 0x18 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x20 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x28 */ _UNK, _UNK, _UNK, _UNK, _UNK, 0x63, _PFX, _PFX, /* 0x30 */ 0x67, 0x66, 0x68, 0x65, 0x69, 0x64, 0x6A, _UNK, /* 0x38 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x40 */ _UNK, _ASC, _ASC, _ASC, _ASC, _ASC, _ASC, _ASC, /* 0x48 */ _ASC, _ASC, _ASC, _ASC, _ASC, _ASC, _ASC, _ASC, /* 0x50 */ _ASC, _ASC, _ASC, _ASC, _ASC, _ASC, _ASC, _ASC, /* 0x58 */ _ASC, _ASC, _ASC, _UNK, _PFX, _UNK, _PFX, _ASC, /* 0x60 */ 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, /* 0x68 */ 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, _UNK, /* 0x70 */ 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, /* 0x78 */ 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, /* 0x80 */ 0x2b, 0x2c, 0x2d, 0x2e, 0x70, 0x71, 0x2f, 0x30, /* 0x88 */ 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x72, /* 0x90 */ 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x73, 0x74, /* 0x98 */ 0x75, 0x76, _UNK, _UNK, 0x77, 0x78, 0x79, 0x7A, /* 0xA0 */ 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x60, 0x61, /* 0xA8 */ 0x62, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0xB0 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0xB8 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0xC0 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0xC8 */ _UNK, _UNK, _UNK, _UNK, 0x44, _UNK, _UNK, _UNK, /* 0xD0 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0xD8 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0xE0 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0xE8 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0xF0 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0xF8 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, 0x45, }; static UINT8 AmlLongOpInfoIndex[NUM_EXTENDED_OPCODE] = { /* 0 1 2 3 4 5 6 7 */ /* 8 9 A B C D E F */ /* 0x00 */ _UNK, 0x46, 0x47, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x08 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x10 */ _UNK, _UNK, 0x48, 0x49, _UNK, _UNK, _UNK, _UNK, /* 0x18 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, 0x7B, /* 0x20 */ 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, /* 0x28 */ 0x52, 0x53, 0x54, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x30 */ 0x55, 0x56, 0x57, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x38 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x40 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x48 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x50 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x58 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x60 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x68 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x70 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x78 */ _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, _UNK, /* 0x80 */ 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, /* 0x88 */ 0x7C, }; /******************************************************************************* * * FUNCTION: AcpiPsGetOpcodeInfo * * PARAMETERS: Opcode - The AML opcode * * RETURN: A pointer to the info about the opcode. NULL if the opcode was * not found in the table. * * DESCRIPTION: Find AML opcode description based on the opcode. * NOTE: This procedure must ALWAYS return a valid pointer! * ******************************************************************************/ ACPI_OPCODE_INFO * AcpiPsGetOpcodeInfo ( UINT16 Opcode) { ACPI_OPCODE_INFO *OpInfo; UINT8 UpperOpcode; UINT8 LowerOpcode; PROC_NAME ("PsGetOpcodeInfo"); /* Split the 16-bit opcode into separate bytes */ UpperOpcode = (UINT8) (Opcode >> 8); LowerOpcode = (UINT8) Opcode; /* Default is "unknown opcode" */ OpInfo = &AmlOpInfo [_UNK]; /* * Detect normal 8-bit opcode or extended 16-bit opcode */ switch (UpperOpcode) { case 0: /* Simple (8-bit) opcode: 0-255, can't index beyond table */ OpInfo = &AmlOpInfo [AmlShortOpInfoIndex [LowerOpcode]]; break; case AML_EXTOP: /* Extended (16-bit, prefix+opcode) opcode */ if (LowerOpcode <= MAX_EXTENDED_OPCODE) { OpInfo = &AmlOpInfo [AmlLongOpInfoIndex [LowerOpcode]]; } break; case AML_LNOT_OP: /* This case is for the bogus opcodes LNOTEQUAL, LLESSEQUAL, LGREATEREQUAL */ /* TBD: [Investigate] remove this case? */ - DEBUG_PRINTP (ACPI_ERROR, ("Bad multi-byte opcode=%X\n", Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Bad multi-byte opcode=%X\n", Opcode)); break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Unknown extended opcode=%X\n", Opcode)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown extended opcode=%X\n", Opcode)); break; } /* Get the Op info pointer for this opcode */ return (OpInfo); } /******************************************************************************* * * FUNCTION: AcpiPsGetOpcodeName * * PARAMETERS: Opcode - The AML opcode * * RETURN: A pointer to the name of the opcode (ASCII String) * Note: Never returns NULL. * * DESCRIPTION: Translate an opcode into a human-readable string * ******************************************************************************/ NATIVE_CHAR * AcpiPsGetOpcodeName ( UINT16 Opcode) { ACPI_OPCODE_INFO *Op; Op = AcpiPsGetOpcodeInfo (Opcode); /* Always guaranteed to return a valid pointer */ #ifdef ACPI_DEBUG return (Op->Name); #else return ("AE_NOT_CONFIGURED"); #endif } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/psparse.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/psparse.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/psparse.c (revision 82367) @@ -1,1461 +1,1462 @@ /****************************************************************************** * * Module Name: psparse - Parser top level AML parse routines - * $Revision: 87 $ + * $Revision: 89 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ /* * Parse the AML and build an operation tree as most interpreters, * like Perl, do. Parsing is done by hand rather than with a YACC * generated parser to tightly constrain stack and dynamic memory * usage. At the same time, parsing is kept flexible and the code * fairly compact by parsing based on a list of AML opcode * templates in AmlOpInfo[] */ #include "acpi.h" #include "acparser.h" #include "acdispat.h" #include "amlcode.h" #include "acnamesp.h" #include "acdebug.h" #include "acinterp.h" #define _COMPONENT ACPI_PARSER MODULE_NAME ("psparse") UINT32 AcpiGbl_Depth = 0; extern UINT32 AcpiGbl_ScopeDepth; /******************************************************************************* * * FUNCTION: AcpiPsPeekOpcode * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Get next AML opcode (without incrementing AML pointer) * ******************************************************************************/ static UINT32 AcpiPsGetOpcodeSize ( UINT32 Opcode) { /* Extended (2-byte) opcode if > 255 */ if (Opcode > 0x00FF) { return (2); } /* Otherwise, just a single byte opcode */ return (1); } /******************************************************************************* * * FUNCTION: AcpiPsPeekOpcode * * PARAMETERS: ParserState - A parser state object * * RETURN: Status * * DESCRIPTION: Get next AML opcode (without incrementing AML pointer) * ******************************************************************************/ UINT16 AcpiPsPeekOpcode ( ACPI_PARSE_STATE *ParserState) { UINT8 *Aml; UINT16 Opcode; Aml = ParserState->Aml; Opcode = (UINT16) GET8 (Aml); Aml++; /* * Original code special cased LNOTEQUAL, LLESSEQUAL, LGREATEREQUAL. * These opcodes are no longer recognized. Instead, they are broken into * two opcodes. * * * if (Opcode == AML_EXTOP * || (Opcode == AML_LNOT * && (GET8 (Aml) == AML_LEQUAL * || GET8 (Aml) == AML_LGREATER * || GET8 (Aml) == AML_LLESS))) * * extended Opcode, !=, <=, or >= */ if (Opcode == AML_EXTOP) { /* Extended opcode */ Opcode = (UINT16) ((Opcode << 8) | GET8 (Aml)); Aml++; } /* don't convert bare name to a namepath */ return (Opcode); } /******************************************************************************* * * FUNCTION: AcpiPsCreateState * * PARAMETERS: Aml - Aml code pointer * AmlSize - Length of AML code * * RETURN: A new parser state object * * DESCRIPTION: Create and initialize a new parser state object * ******************************************************************************/ ACPI_PARSE_STATE * AcpiPsCreateState ( UINT8 *Aml, UINT32 AmlSize) { ACPI_PARSE_STATE *ParserState; FUNCTION_TRACE ("PsCreateState"); ParserState = ACPI_MEM_CALLOCATE (sizeof (ACPI_PARSE_STATE)); if (!ParserState) { return_PTR (NULL); } ParserState->Aml = Aml; ParserState->AmlEnd = Aml + AmlSize; ParserState->PkgEnd = ParserState->AmlEnd; ParserState->AmlStart = Aml; return_PTR (ParserState); } /******************************************************************************* * * FUNCTION: AcpiPsFindObject * * PARAMETERS: Opcode - Current opcode * ParserState - Current state * WalkState - Current state * *Op - Where found/new op is returned * * RETURN: Status * * DESCRIPTION: Find a named object. Two versions - one to search the parse * tree (for parser-only applications such as acpidump), another * to search the ACPI internal namespace (the parse tree may no * longer exist) * ******************************************************************************/ #ifdef PARSER_ONLY ACPI_STATUS AcpiPsFindObject ( UINT16 Opcode, ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **OutOp) { NATIVE_CHAR *Path; /* We are only interested in opcodes that have an associated name */ if (!AcpiPsIsNamedOp (Opcode)) { *OutOp = Op; return (AE_OK); } /* Find the name in the parse tree */ Path = AcpiPsGetNextNamestring (WalkState->ParserState); *OutOp = AcpiPsFind (AcpiPsGetParentScope (WalkState->ParserState), Path, Opcode, 1); if (!(*OutOp)) { return (AE_NOT_FOUND); } return (AE_OK); } #endif /******************************************************************************* * * FUNCTION: AcpiPsCompleteThisOp * * PARAMETERS: WalkState - Current State * Op - Op to complete * * RETURN: TRUE if Op and subtree was deleted * * DESCRIPTION: Perform any cleanup at the completion of an Op. * ******************************************************************************/ static BOOLEAN AcpiPsCompleteThisOp ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { #ifndef PARSER_ONLY ACPI_PARSE_OBJECT *Prev; ACPI_PARSE_OBJECT *Next; ACPI_OPCODE_INFO *OpInfo; ACPI_OPCODE_INFO *ParentInfo; UINT32 OpcodeClass; ACPI_PARSE_OBJECT *ReplacementOp = NULL; FUNCTION_TRACE_PTR ("PsCompleteThisOp", Op); OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode); OpcodeClass = ACPI_GET_OP_CLASS (OpInfo); /* Delete this op and the subtree below it if asked to */ if (((WalkState->ParseFlags & ACPI_PARSE_TREE_MASK) == ACPI_PARSE_DELETE_TREE) && (OpcodeClass != OPTYPE_CONSTANT) && (OpcodeClass != OPTYPE_LITERAL) && (OpcodeClass != OPTYPE_LOCAL_VARIABLE) && (OpcodeClass != OPTYPE_METHOD_ARGUMENT) && (OpcodeClass != OPTYPE_DATA_TERM) && (Op->Opcode != AML_INT_NAMEPATH_OP)) { /* Make sure that we only delete this subtree */ if (Op->Parent) { /* * Check if we need to replace the operator and its subtree * with a return value op (placeholder op) */ ParentInfo = AcpiPsGetOpcodeInfo (Op->Parent->Opcode); switch (ACPI_GET_OP_CLASS (ParentInfo)) { case OPTYPE_CONTROL: /* IF, ELSE, WHILE only */ break; case OPTYPE_NAMED_OBJECT: /* Scope, method, etc. */ /* * These opcodes contain TermArg operands. The current * op must be replace by a placeholder return op */ if ((Op->Parent->Opcode == AML_REGION_OP) || (Op->Parent->Opcode == AML_CREATE_FIELD_OP) || (Op->Parent->Opcode == AML_CREATE_BIT_FIELD_OP) || (Op->Parent->Opcode == AML_CREATE_BYTE_FIELD_OP) || (Op->Parent->Opcode == AML_CREATE_WORD_FIELD_OP) || (Op->Parent->Opcode == AML_CREATE_DWORD_FIELD_OP) || (Op->Parent->Opcode == AML_CREATE_QWORD_FIELD_OP)) { ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP); if (!ReplacementOp) { return_VALUE (FALSE); } } break; default: ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP); if (!ReplacementOp) { return_VALUE (FALSE); } } /* We must unlink this op from the parent tree */ Prev = Op->Parent->Value.Arg; if (Prev == Op) { /* This op is the first in the list */ if (ReplacementOp) { ReplacementOp->Parent = Op->Parent; ReplacementOp->Value.Arg = NULL; Op->Parent->Value.Arg = ReplacementOp; ReplacementOp->Next = Op->Next; } else { Op->Parent->Value.Arg = Op->Next; } } /* Search the parent list */ else while (Prev) { /* Traverse all siblings in the parent's argument list */ Next = Prev->Next; if (Next == Op) { if (ReplacementOp) { ReplacementOp->Parent = Op->Parent; ReplacementOp->Value.Arg = NULL; Prev->Next = ReplacementOp; ReplacementOp->Next = Op->Next; Next = NULL; } else { Prev->Next = Op->Next; Next = NULL; } } Prev = Next; } } /* Now we can actually delete the subtree rooted at op */ AcpiPsDeleteParseTree (Op); return_VALUE (TRUE); } return_VALUE (FALSE); #else return (FALSE); #endif } /******************************************************************************* * * FUNCTION: AcpiPsNextParseState * * PARAMETERS: ParserState - Current parser state object * * RETURN: * * DESCRIPTION: * ******************************************************************************/ static ACPI_STATUS AcpiPsNextParseState ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_STATUS CallbackStatus) { ACPI_PARSE_STATE *ParserState = WalkState->ParserState; ACPI_STATUS Status = AE_CTRL_PENDING; UINT8 *Start; UINT32 PackageLength; FUNCTION_TRACE_PTR ("PsNextParseState", Op); switch (CallbackStatus) { case AE_CTRL_TERMINATE: /* * A control method was terminated via a RETURN statement. * The walk of this method is complete. */ ParserState->Aml = ParserState->AmlEnd; Status = AE_CTRL_TERMINATE; break; case AE_CTRL_PENDING: /* * Predicate of a WHILE was true and the loop just completed an * execution. Go back to the start of the loop and reevaluate the * predicate. */ /* WalkState->ControlState->Common.State = CONTROL_PREDICATE_EXECUTING;*/ /* TBD: How to handle a break within a while. */ /* This code attempts it */ ParserState->Aml = WalkState->AmlLastWhile; break; case AE_CTRL_TRUE: /* * Predicate of an IF was true, and we are at the matching ELSE. * Just close out this package * * Note: ParserState->Aml is modified by the package length procedure * TBD: [Investigate] perhaps it shouldn't, too much trouble */ Start = ParserState->Aml; PackageLength = AcpiPsGetNextPackageLength (ParserState); ParserState->Aml = Start + PackageLength; break; case AE_CTRL_FALSE: /* * Either an IF/WHILE Predicate was false or we encountered a BREAK * opcode. In both cases, we do not execute the rest of the * package; We simply close out the parent (finishing the walk of * this branch of the tree) and continue execution at the parent * level. */ ParserState->Aml = ParserState->Scope->ParseScope.PkgEnd; /* In the case of a BREAK, just force a predicate (if any) to FALSE */ WalkState->ControlState->Common.Value = FALSE; Status = AE_CTRL_END; break; case AE_CTRL_TRANSFER: /* * A method call (invocation) -- transfer control */ Status = AE_CTRL_TRANSFER; WalkState->PrevOp = Op; WalkState->MethodCallOp = Op; WalkState->MethodCallNode = (Op->Value.Arg)->Node; /* Will return value (if any) be used by the caller? */ WalkState->ReturnUsed = AcpiDsIsResultUsed (Op, WalkState); break; default: Status = CallbackStatus; if ((CallbackStatus & AE_CODE_MASK) == AE_CODE_CONTROL) { Status = AE_OK; } break; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiPsParseLoop * * PARAMETERS: ParserState - Current parser state object * * RETURN: Status * * DESCRIPTION: Parse AML (pointed to by the current parser state) and return * a tree of ops. * ******************************************************************************/ ACPI_STATUS AcpiPsParseLoop ( ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_OK; ACPI_PARSE_OBJECT *Op = NULL; /* current op */ ACPI_OPCODE_INFO *OpInfo; ACPI_PARSE_OBJECT *Arg = NULL; ACPI_PARSE2_OBJECT *DeferredOp; UINT32 ArgCount; /* push for fixed or var args */ UINT32 ArgTypes = 0; UINT32 AmlOffset; UINT16 Opcode; ACPI_PARSE_OBJECT PreOp; ACPI_PARSE_STATE *ParserState; UINT8 *AmlOpStart; FUNCTION_TRACE_PTR ("PsParseLoop", WalkState); ParserState = WalkState->ParserState; #ifndef PARSER_ONLY if (WalkState->WalkType & WALK_METHOD_RESTART) { /* We are restarting a preempted control method */ if (AcpiPsHasCompletedScope (ParserState)) { /* * We must check if a predicate to an IF or WHILE statement * was just completed */ if ((ParserState->Scope->ParseScope.Op) && ((ParserState->Scope->ParseScope.Op->Opcode == AML_IF_OP) || (ParserState->Scope->ParseScope.Op->Opcode == AML_WHILE_OP)) && (WalkState->ControlState) && (WalkState->ControlState->Common.State == CONTROL_PREDICATE_EXECUTING)) { /* * A predicate was just completed, get the value of the * predicate and branch based on that value */ Status = AcpiDsGetPredicateValue (WalkState, NULL, TRUE); if (ACPI_FAILURE (Status) && ((Status & AE_CODE_MASK) != AE_CODE_CONTROL)) { if (Status == AE_AML_NO_RETURN_VALUE) { - DEBUG_PRINTP (ACPI_ERROR, - ("Invoked method did not return a value, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Invoked method did not return a value, %s\n", AcpiFormatException (Status))); } - DEBUG_PRINTP (ACPI_ERROR, ("GetPredicate Failed, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "GetPredicate Failed, %s\n", AcpiFormatException (Status))); return_ACPI_STATUS (Status); } Status = AcpiPsNextParseState (WalkState, Op, Status); } AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount); - DEBUG_PRINTP (TRACE_PARSE, ("Popped scope, Op=%p\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op)); } else if (WalkState->PrevOp) { /* We were in the middle of an op */ Op = WalkState->PrevOp; ArgTypes = WalkState->PrevArgTypes; } } #endif /* * Iterative parsing loop, while there is more aml to process: */ while ((ParserState->Aml < ParserState->AmlEnd) || (Op)) { if (!Op) { /* Get the next opcode from the AML stream */ AmlOpStart = ParserState->Aml; AmlOffset = ParserState->Aml - ParserState->AmlStart; Opcode = AcpiPsPeekOpcode (ParserState); /* * First cut to determine what we have found: * 1) A valid AML opcode * 2) A name string * 3) An unknown/invalid opcode */ OpInfo = AcpiPsGetOpcodeInfo (Opcode); switch (ACPI_GET_OP_TYPE (OpInfo)) { case ACPI_OP_TYPE_OPCODE: /* Found opcode info, this is a normal opcode */ ParserState->Aml += AcpiPsGetOpcodeSize (Opcode); ArgTypes = OpInfo->ParseArgs; break; case ACPI_OP_TYPE_ASCII: case ACPI_OP_TYPE_PREFIX: /* * Starts with a valid prefix or ASCII char, this is a name * string. Convert the bare name string to a namepath. */ Opcode = AML_INT_NAMEPATH_OP; ArgTypes = ARGP_NAMESTRING; break; case ACPI_OP_TYPE_UNKNOWN: /* The opcode is unrecognized. Just skip unknown opcodes */ - DEBUG_PRINTP (ACPI_ERROR, - ("Found unknown opcode %lX at AML offset %X, ignoring\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Found unknown opcode %lX at AML offset %X, ignoring\n", Opcode, AmlOffset)); DUMP_BUFFER (ParserState->Aml, 128); /* Assume one-byte bad opcode */ ParserState->Aml++; continue; } /* Create Op structure and append to parent's argument list */ if (AcpiPsIsNamedOp (Opcode)) { PreOp.Value.Arg = NULL; PreOp.Opcode = Opcode; while (GET_CURRENT_ARG_TYPE (ArgTypes) != ARGP_NAME) { Arg = AcpiPsGetNextArg (ParserState, GET_CURRENT_ARG_TYPE (ArgTypes), &ArgCount); AcpiPsAppendArg (&PreOp, Arg); INCREMENT_ARG_LIST (ArgTypes); } /* We know that this arg is a name, move to next arg */ INCREMENT_ARG_LIST (ArgTypes); if (WalkState->DescendingCallback != NULL) { /* * Find the object. This will either insert the object into * the namespace or simply look it up */ Status = WalkState->DescendingCallback (Opcode, NULL, WalkState, &Op); if (Op == NULL) { continue; } Status = AcpiPsNextParseState (WalkState, Op, Status); if (Status == AE_CTRL_PENDING) { Status = AE_OK; goto CloseThisOp; } if (ACPI_FAILURE (Status)) { goto CloseThisOp; } } AcpiPsAppendArg (Op, PreOp.Value.Arg); AcpiGbl_Depth++; if (Op->Opcode == AML_REGION_OP) { DeferredOp = AcpiPsToExtendedOp (Op); if (DeferredOp) { /* * Defer final parsing of an OperationRegion body, * because we don't have enough info in the first pass * to parse it correctly (i.e., there may be method * calls within the TermArg elements of the body. * * However, we must continue parsing because * the opregion is not a standalone package -- * we don't know where the end is at this point. * * (Length is unknown until parse of the body complete) */ DeferredOp->Data = AmlOpStart; DeferredOp->Length = 0; } } } else { /* Not a named opcode, just allocate Op and append to parent */ Op = AcpiPsAllocOp (Opcode); if (!Op) { return_ACPI_STATUS (AE_NO_MEMORY); } if ((Op->Opcode == AML_CREATE_FIELD_OP) || (Op->Opcode == AML_CREATE_BIT_FIELD_OP) || (Op->Opcode == AML_CREATE_BYTE_FIELD_OP) || (Op->Opcode == AML_CREATE_WORD_FIELD_OP) || (Op->Opcode == AML_CREATE_DWORD_FIELD_OP) || (Op->Opcode == AML_CREATE_QWORD_FIELD_OP)) { /* * Backup to beginning of CreateXXXfield declaration * BodyLength is unknown until we parse the body */ DeferredOp = (ACPI_PARSE2_OBJECT *) Op; DeferredOp->Data = AmlOpStart; DeferredOp->Length = 0; } AcpiPsAppendArg (AcpiPsGetParentScope (ParserState), Op); if ((WalkState->DescendingCallback != NULL)) { /* * Find the object. This will either insert the object into * the namespace or simply look it up */ Status = WalkState->DescendingCallback (Opcode, Op, WalkState, &Op); Status = AcpiPsNextParseState (WalkState, Op, Status); if (Status == AE_CTRL_PENDING) { Status = AE_OK; goto CloseThisOp; } if (ACPI_FAILURE (Status)) { goto CloseThisOp; } } } Op->AmlOffset = AmlOffset; if (OpInfo) { - DEBUG_PRINTP (TRACE_PARSE, - ("Op=%p Opcode=%4.4lX Aml %p Oft=%5.5lX\n", + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, + "Op=%p Opcode=%4.4lX Aml %p Oft=%5.5lX\n", Op, Op->Opcode, ParserState->Aml, Op->AmlOffset)); } } /* Start ArgCount at zero because we don't know if there are any args yet */ ArgCount = 0; if (ArgTypes) /* Are there any arguments that must be processed? */ { /* get arguments */ switch (Op->Opcode) { case AML_BYTE_OP: /* AML_BYTEDATA_ARG */ case AML_WORD_OP: /* AML_WORDDATA_ARG */ case AML_DWORD_OP: /* AML_DWORDATA_ARG */ + case AML_QWORD_OP: /* AML_QWORDATA_ARG */ case AML_STRING_OP: /* AML_ASCIICHARLIST_ARG */ /* fill in constant or string argument directly */ AcpiPsGetNextSimpleArg (ParserState, GET_CURRENT_ARG_TYPE (ArgTypes), Op); break; case AML_INT_NAMEPATH_OP: /* AML_NAMESTRING_ARG */ AcpiPsGetNextNamepath (ParserState, Op, &ArgCount, 1); ArgTypes = 0; break; default: /* Op is not a constant or string, append each argument */ while (GET_CURRENT_ARG_TYPE (ArgTypes) && !ArgCount) { AmlOffset = ParserState->Aml - ParserState->AmlStart; Arg = AcpiPsGetNextArg (ParserState, GET_CURRENT_ARG_TYPE (ArgTypes), &ArgCount); if (Arg) { Arg->AmlOffset = AmlOffset; AcpiPsAppendArg (Op, Arg); } INCREMENT_ARG_LIST (ArgTypes); } /* For a method, save the length and address of the body */ if (Op->Opcode == AML_METHOD_OP) { DeferredOp = AcpiPsToExtendedOp (Op); if (DeferredOp) { /* * Skip parsing of control method or opregion body, * because we don't have enough info in the first pass * to parse them correctly. */ DeferredOp->Data = ParserState->Aml; DeferredOp->Length = (UINT32) (ParserState->PkgEnd - ParserState->Aml); /* * Skip body of method. For OpRegions, we must continue * parsing because the opregion is not a standalone * package (We don't know where the end is). */ ParserState->Aml = ParserState->PkgEnd; ArgCount = 0; } } break; } } /* * Zero ArgCount means that all arguments for this op have been processed */ if (!ArgCount) { /* completed Op, prepare for next */ if (AcpiPsIsNamedOp (Op->Opcode)) { if (AcpiGbl_Depth) { AcpiGbl_Depth--; } if (Op->Opcode == AML_REGION_OP) { DeferredOp = AcpiPsToExtendedOp (Op); if (DeferredOp) { /* * Skip parsing of control method or opregion body, * because we don't have enough info in the first pass * to parse them correctly. * * Completed parsing an OpRegion declaration, we now * know the length. */ DeferredOp->Length = (UINT32) (ParserState->Aml - DeferredOp->Data); } } } if ((Op->Opcode == AML_CREATE_FIELD_OP) || (Op->Opcode == AML_CREATE_BIT_FIELD_OP) || (Op->Opcode == AML_CREATE_BYTE_FIELD_OP) || (Op->Opcode == AML_CREATE_WORD_FIELD_OP) || (Op->Opcode == AML_CREATE_DWORD_FIELD_OP) || (Op->Opcode == AML_CREATE_QWORD_FIELD_OP)) { /* * Backup to beginning of CreateXXXfield declaration (1 for * Opcode) * * BodyLength is unknown until we parse the body */ DeferredOp = (ACPI_PARSE2_OBJECT *) Op; DeferredOp->Length = (UINT32) (ParserState->Aml - DeferredOp->Data); } /* This op complete, notify the dispatcher */ if (WalkState->AscendingCallback != NULL) { Status = WalkState->AscendingCallback (WalkState, Op); Status = AcpiPsNextParseState (WalkState, Op, Status); if (Status == AE_CTRL_PENDING) { Status = AE_OK; goto CloseThisOp; } } CloseThisOp: /* * Finished one argument of the containing scope */ ParserState->Scope->ParseScope.ArgCount--; /* Close this Op (may result in parse subtree deletion) */ if (AcpiPsCompleteThisOp (WalkState, Op)) { Op = NULL; } switch (Status) { case AE_OK: break; case AE_CTRL_TRANSFER: /* * We are about to transfer to a called method. */ WalkState->PrevOp = Op; WalkState->PrevArgTypes = ArgTypes; return_ACPI_STATUS (Status); break; case AE_CTRL_END: AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount); Status = WalkState->AscendingCallback (WalkState, Op); Status = AcpiPsNextParseState (WalkState, Op, Status); AcpiPsCompleteThisOp (WalkState, Op); Op = NULL; Status = AE_OK; break; case AE_CTRL_TERMINATE: Status = AE_OK; /* Clean up */ do { if (Op) { AcpiPsCompleteThisOp (WalkState, Op); } AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount); } while (Op); return_ACPI_STATUS (Status); break; default: /* All other non-AE_OK status */ if (Op == NULL) { AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount); } WalkState->PrevOp = Op; WalkState->PrevArgTypes = ArgTypes; /* * TEMP: */ return_ACPI_STATUS (Status); break; } /* This scope complete? */ if (AcpiPsHasCompletedScope (ParserState)) { AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount); - DEBUG_PRINTP (TRACE_PARSE, ("Popped scope, Op=%p\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op)); } else { Op = NULL; } } /* ArgCount is non-zero */ else { /* complex argument, push Op and prepare for argument */ AcpiPsPushScope (ParserState, Op, ArgTypes, ArgCount); Op = NULL; } } /* while ParserState->Aml */ /* * Complete the last Op (if not completed), and clear the scope stack. * It is easily possible to end an AML "package" with an unbounded number * of open scopes (such as when several AML blocks are closed with * sequential closing braces). We want to terminate each one cleanly. */ - DEBUG_PRINTP (TRACE_PARSE, ("Package complete at Op %p\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Package complete at Op %p\n", Op)); do { if (Op) { if (WalkState->AscendingCallback != NULL) { Status = WalkState->AscendingCallback (WalkState, Op); Status = AcpiPsNextParseState (WalkState, Op, Status); if (Status == AE_CTRL_PENDING) { Status = AE_OK; goto CloseThisOp; } if (Status == AE_CTRL_TERMINATE) { Status = AE_OK; /* Clean up */ do { if (Op) { AcpiPsCompleteThisOp (WalkState, Op); } AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount); } while (Op); return_ACPI_STATUS (Status); } else if (ACPI_FAILURE (Status)) { AcpiPsCompleteThisOp (WalkState, Op); return_ACPI_STATUS (Status); } } AcpiPsCompleteThisOp (WalkState, Op); } AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount); } while (Op); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiPsParseAml * * PARAMETERS: StartScope - The starting point of the parse. Becomes the * root of the parsed op tree. * Aml - Pointer to the raw AML code to parse * AmlSize - Length of the AML to parse * * RETURN: Status * * DESCRIPTION: Parse raw AML and return a tree of ops * ******************************************************************************/ ACPI_STATUS AcpiPsParseAml ( ACPI_PARSE_OBJECT *StartScope, UINT8 *Aml, UINT32 AmlSize, UINT32 ParseFlags, ACPI_NAMESPACE_NODE *MethodNode, ACPI_OPERAND_OBJECT **Params, ACPI_OPERAND_OBJECT **CallerReturnDesc, ACPI_PARSE_DOWNWARDS DescendingCallback, ACPI_PARSE_UPWARDS AscendingCallback) { ACPI_STATUS Status; ACPI_PARSE_STATE *ParserState; ACPI_WALK_STATE *WalkState; ACPI_WALK_LIST WalkList; ACPI_NAMESPACE_NODE *Node = NULL; ACPI_WALK_LIST *PrevWalkList = AcpiGbl_CurrentWalkList; ACPI_OPERAND_OBJECT *ReturnDesc; ACPI_OPERAND_OBJECT *MthDesc = NULL; FUNCTION_TRACE ("PsParseAml"); - DEBUG_PRINTP (TRACE_PARSE, ("Entered with Scope=%p Aml=%p size=%lX\n", + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Entered with Scope=%p Aml=%p size=%lX\n", StartScope, Aml, AmlSize)); /* Create and initialize a new parser state */ ParserState = AcpiPsCreateState (Aml, AmlSize); if (!ParserState) { return_ACPI_STATUS (AE_NO_MEMORY); } AcpiPsInitScope (ParserState, StartScope); if (MethodNode) { MthDesc = AcpiNsGetAttachedObject (MethodNode); } /* Create and initialize a new walk list */ WalkList.WalkState = NULL; WalkList.AcquiredMutexList.Prev = NULL; WalkList.AcquiredMutexList.Next = NULL; WalkState = AcpiDsCreateWalkState (TABLE_ID_DSDT, ParserState->StartOp, MthDesc, &WalkList); if (!WalkState) { Status = AE_NO_MEMORY; goto Cleanup; } WalkState->MethodNode = MethodNode; WalkState->ParserState = ParserState; WalkState->ParseFlags = ParseFlags; WalkState->DescendingCallback = DescendingCallback; WalkState->AscendingCallback = AscendingCallback; /* TBD: [Restructure] TEMP until we pass WalkState to the interpreter */ AcpiGbl_CurrentWalkList = &WalkList; if (MethodNode) { ParserState->StartNode = MethodNode; WalkState->WalkType = WALK_METHOD; /* Push start scope on scope stack and make it current */ Status = AcpiDsScopeStackPush (MethodNode, ACPI_TYPE_METHOD, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Init arguments if this is a control method */ /* TBD: [Restructure] add walkstate as a param */ AcpiDsMethodDataInitArgs (Params, MTH_NUM_ARGS, WalkState); } else { /* Setup the current scope */ Node = ParserState->StartOp->Node; ParserState->StartNode = Node; if (Node) { /* Push start scope on scope stack and make it current */ Status = AcpiDsScopeStackPush (Node, Node->Type, WalkState); if (ACPI_FAILURE (Status)) { goto Cleanup; } } } Status = AE_OK; /* * Execute the walk loop as long as there is a valid Walk State. This * handles nested control method invocations without recursion. */ - DEBUG_PRINTP (TRACE_PARSE, ("State=%p\n", WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "State=%p\n", WalkState)); while (WalkState) { if (ACPI_SUCCESS (Status)) { Status = AcpiPsParseLoop (WalkState); } - DEBUG_PRINTP (TRACE_PARSE, - ("Completed one call to walk loop, State=%p\n", WalkState)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, + "Completed one call to walk loop, State=%p\n", WalkState)); if (Status == AE_CTRL_TRANSFER) { /* * A method call was detected. * Transfer control to the called control method */ Status = AcpiDsCallControlMethod (&WalkList, WalkState, NULL); /* * If the transfer to the new method method call worked, a new walk * state was created -- get it */ WalkState = AcpiDsGetCurrentWalkState (&WalkList); continue; } else if (Status == AE_CTRL_TERMINATE) { Status = AE_OK; } /* We are done with this walk, move on to the parent if any */ WalkState = AcpiDsPopWalkState (&WalkList); /* Extract return value before we delete WalkState */ ReturnDesc = WalkState->ReturnDesc; - DEBUG_PRINTP (TRACE_PARSE, ("ReturnValue=%p, State=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "ReturnValue=%p, State=%p\n", WalkState->ReturnDesc, WalkState)); /* Reset the current scope to the beginning of scope stack */ AcpiDsScopeStackClear (WalkState); /* * If we just returned from the execution of a control method, * there's lots of cleanup to do */ if ((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) == ACPI_PARSE_EXECUTE) { AcpiDsTerminateControlMethod (WalkState); } /* Delete this walk state and all linked control states */ AcpiPsCleanupScope (WalkState->ParserState); ACPI_MEM_FREE (WalkState->ParserState); AcpiDsDeleteWalkState (WalkState); /* Check if we have restarted a preempted walk */ WalkState = AcpiDsGetCurrentWalkState (&WalkList); if (WalkState && ACPI_SUCCESS (Status)) { /* There is another walk state, restart it */ /* * If the method returned value is not used by the parent, * The object is deleted */ AcpiDsRestartControlMethod (WalkState, ReturnDesc); WalkState->WalkType |= WALK_METHOD_RESTART; } /* * Just completed a 1st-level method, save the final internal return * value (if any) */ else if (CallerReturnDesc) { *CallerReturnDesc = ReturnDesc; /* NULL if no return value */ } else if (ReturnDesc) { /* Caller doesn't want it, must delete it */ AcpiUtRemoveReference (ReturnDesc); } } /* Normal exit */ AcpiExReleaseAllMutexes ((ACPI_OPERAND_OBJECT *) &WalkList.AcquiredMutexList); AcpiGbl_CurrentWalkList = PrevWalkList; return_ACPI_STATUS (Status); Cleanup: /* Cleanup */ AcpiDsDeleteWalkState (WalkState); AcpiPsCleanupScope (ParserState); ACPI_MEM_FREE (ParserState); AcpiExReleaseAllMutexes ((ACPI_OPERAND_OBJECT *)&WalkList.AcquiredMutexList); AcpiGbl_CurrentWalkList = PrevWalkList; return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/psscope.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/psscope.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/psscope.c (revision 82367) @@ -1,374 +1,374 @@ /****************************************************************************** * * Module Name: psscope - Parser scope stack management routines - * $Revision: 27 $ + * $Revision: 28 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acparser.h" #define _COMPONENT ACPI_PARSER MODULE_NAME ("psscope") /******************************************************************************* * * FUNCTION: AcpiPsGetParentScope * * PARAMETERS: ParserState - Current parser state object * * RETURN: Pointer to an Op object * * DESCRIPTION: Get parent of current op being parsed * ******************************************************************************/ ACPI_PARSE_OBJECT * AcpiPsGetParentScope ( ACPI_PARSE_STATE *ParserState) { return (ParserState->Scope->ParseScope.Op); } /******************************************************************************* * * FUNCTION: AcpiPsHasCompletedScope * * PARAMETERS: ParserState - Current parser state object * * RETURN: Boolean, TRUE = scope completed. * * DESCRIPTION: Is parsing of current argument complete? Determined by * 1) AML pointer is at or beyond the end of the scope * 2) The scope argument count has reached zero. * ******************************************************************************/ BOOLEAN AcpiPsHasCompletedScope ( ACPI_PARSE_STATE *ParserState) { return ((BOOLEAN) ((ParserState->Aml >= ParserState->Scope->ParseScope.ArgEnd || !ParserState->Scope->ParseScope.ArgCount))); } /******************************************************************************* * * FUNCTION: AcpiPsInitScope * * PARAMETERS: ParserState - Current parser state object * Root - the Root Node of this new scope * * RETURN: Status * * DESCRIPTION: Allocate and init a new scope object * ******************************************************************************/ ACPI_STATUS AcpiPsInitScope ( ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT *RootOp) { ACPI_GENERIC_STATE *Scope; FUNCTION_TRACE_PTR ("PsInitScope", RootOp); Scope = AcpiUtCreateGenericState (); if (!Scope) { return_ACPI_STATUS (AE_NO_MEMORY); } Scope->ParseScope.Op = RootOp; Scope->ParseScope.ArgCount = ACPI_VAR_ARGS; Scope->ParseScope.ArgEnd = ParserState->AmlEnd; Scope->ParseScope.PkgEnd = ParserState->AmlEnd; ParserState->Scope = Scope; ParserState->StartOp = RootOp; return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiPsPushScope * * PARAMETERS: ParserState - Current parser state object * Op - Current op to be pushed * RemainingArgs - List of args remaining * ArgCount - Fixed or variable number of args * * RETURN: Status * * DESCRIPTION: Push current op to begin parsing its argument * ******************************************************************************/ ACPI_STATUS AcpiPsPushScope ( ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT *Op, UINT32 RemainingArgs, UINT32 ArgCount) { ACPI_GENERIC_STATE *Scope; FUNCTION_TRACE_PTR ("PsPushScope", Op); Scope = AcpiUtCreateGenericState (); if (!Scope) { return (AE_NO_MEMORY); } Scope->ParseScope.Op = Op; Scope->ParseScope.ArgList = RemainingArgs; Scope->ParseScope.ArgCount = ArgCount; Scope->ParseScope.PkgEnd = ParserState->PkgEnd; /* Push onto scope stack */ AcpiUtPushGenericState (&ParserState->Scope, Scope); if (ArgCount == ACPI_VAR_ARGS) { /* multiple arguments */ Scope->ParseScope.ArgEnd = ParserState->PkgEnd; } else { /* single argument */ Scope->ParseScope.ArgEnd = ACPI_MAX_AML; } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiPsPopScope * * PARAMETERS: ParserState - Current parser state object * Op - Where the popped op is returned * ArgList - Where the popped "next argument" is * returned * ArgCount - Count of objects in ArgList * * RETURN: Status * * DESCRIPTION: Return to parsing a previous op * ******************************************************************************/ void AcpiPsPopScope ( ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT **Op, UINT32 *ArgList, UINT32 *ArgCount) { ACPI_GENERIC_STATE *Scope = ParserState->Scope; FUNCTION_TRACE ("PsPopScope"); /* * Only pop the scope if there is in fact a next scope */ if (Scope->Common.Next) { Scope = AcpiUtPopGenericState (&ParserState->Scope); /* return to parsing previous op */ *Op = Scope->ParseScope.Op; *ArgList = Scope->ParseScope.ArgList; *ArgCount = Scope->ParseScope.ArgCount; ParserState->PkgEnd = Scope->ParseScope.PkgEnd; /* All done with this scope state structure */ AcpiUtDeleteGenericState (Scope); } else { /* empty parse stack, prepare to fetch next opcode */ *Op = NULL; *ArgList = 0; *ArgCount = 0; } - DEBUG_PRINTP (TRACE_PARSE, ("Popped Op %p Args %X\n", *Op, *ArgCount)); + ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped Op %p Args %X\n", *Op, *ArgCount)); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiPsCleanupScope * * PARAMETERS: ParserState - Current parser state object * * RETURN: Status * * DESCRIPTION: Destroy available list, remaining stack levels, and return * root scope * ******************************************************************************/ void AcpiPsCleanupScope ( ACPI_PARSE_STATE *ParserState) { ACPI_GENERIC_STATE *Scope; FUNCTION_TRACE_PTR ("PsCleanupScope", ParserState); if (!ParserState) { return; } /* Delete anything on the scope stack */ while (ParserState->Scope) { Scope = AcpiUtPopGenericState (&ParserState->Scope); AcpiUtDeleteGenericState (Scope); } return_VOID; } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/psutils.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/psutils.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/psutils.c (revision 82367) @@ -1,690 +1,556 @@ /****************************************************************************** * * Module Name: psutils - Parser miscellaneous utilities (Parser only) - * $Revision: 38 $ + * $Revision: 40 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include "acpi.h" #include "acparser.h" #include "amlcode.h" #define _COMPONENT ACPI_PARSER MODULE_NAME ("psutils") #define PARSEOP_GENERIC 0x01 #define PARSEOP_NAMED 0x02 #define PARSEOP_DEFERRED 0x03 #define PARSEOP_BYTELIST 0x04 #define PARSEOP_IN_CACHE 0x80 /******************************************************************************* * * FUNCTION: AcpiPsInitOp * * PARAMETERS: Op - A newly allocated Op object * Opcode - Opcode to store in the Op * * RETURN: Status * * DESCRIPTION: Allocate an acpi_op, choose op type (and thus size) based on * opcode * ******************************************************************************/ void AcpiPsInitOp ( ACPI_PARSE_OBJECT *Op, UINT16 Opcode) { ACPI_OPCODE_INFO *AmlOp; Op->DataType = ACPI_DESC_TYPE_PARSER; Op->Opcode = Opcode; AmlOp = AcpiPsGetOpcodeInfo (Opcode); DEBUG_ONLY_MEMBERS (STRNCPY (Op->OpName, AmlOp->Name, sizeof (Op->OpName))); } /******************************************************************************* * * FUNCTION: AcpiPsAllocOp * * PARAMETERS: Opcode - Opcode that will be stored in the new Op * * RETURN: Pointer to the new Op. * * DESCRIPTION: Allocate an acpi_op, choose op type (and thus size) based on * opcode. A cache of opcodes is available for the pure * GENERIC_OP, since this is by far the most commonly used. * ******************************************************************************/ ACPI_PARSE_OBJECT* AcpiPsAllocOp ( UINT16 Opcode) { ACPI_PARSE_OBJECT *Op = NULL; UINT32 Size; UINT8 Flags; - PROC_NAME ("PsAllocOp"); - /* Allocate the minimum required size object */ if (AcpiPsIsDeferredOp (Opcode)) { Size = sizeof (ACPI_PARSE2_OBJECT); Flags = PARSEOP_DEFERRED; } else if (AcpiPsIsNamedOp (Opcode)) { Size = sizeof (ACPI_PARSE2_OBJECT); Flags = PARSEOP_NAMED; } else if (AcpiPsIsBytelistOp (Opcode)) { Size = sizeof (ACPI_PARSE2_OBJECT); Flags = PARSEOP_BYTELIST; } else { Size = sizeof (ACPI_PARSE_OBJECT); Flags = PARSEOP_GENERIC; } + if (Size == sizeof (ACPI_PARSE_OBJECT)) { /* - * The generic op is by far the most common (16 to 1), and therefore - * the op cache is implemented with this type. - * - * Check if there is an Op already available in the cache + * The generic op is by far the most common (16 to 1) */ - - AcpiUtAcquireMutex (ACPI_MTX_CACHES); - AcpiGbl_ParseCacheRequests++; - if (AcpiGbl_ParseCache) - { - /* Extract an op from the front of the cache list */ - - AcpiGbl_ParseCacheDepth--; - AcpiGbl_ParseCacheHits++; - - Op = AcpiGbl_ParseCache; - AcpiGbl_ParseCache = Op->Next; - - if (Op->DataType == 0xFF) - { - DEBUG_PRINTP (ACPI_ERROR, ("Op %p deleted while in cache!\n", Op)); - } - - /* Clear the previously used Op */ - - MEMSET (Op, 0, sizeof (ACPI_PARSE_OBJECT)); - - DEBUG_PRINTP (TRACE_PARSE, ("Op %p from Parse Cache\n", Op)); - } - AcpiUtReleaseMutex (ACPI_MTX_CACHES); + Op = AcpiUtAcquireFromCache (ACPI_MEM_LIST_PSNODE); } else { - /* - * The generic op is by far the most common (16 to 1), and therefore - * the op cache is implemented with this type. - * - * Check if there is an Op already available in the cache - */ - - AcpiUtAcquireMutex (ACPI_MTX_CACHES); - AcpiGbl_ExtParseCacheRequests++; - if (AcpiGbl_ExtParseCache) - { - /* Extract an op from the front of the cache list */ - - AcpiGbl_ExtParseCacheDepth--; - AcpiGbl_ExtParseCacheHits++; - - Op = (ACPI_PARSE_OBJECT *) AcpiGbl_ExtParseCache; - AcpiGbl_ExtParseCache = (ACPI_PARSE2_OBJECT *) Op->Next; - - if (Op->DataType == 0xFF) - { - DEBUG_PRINTP (ACPI_ERROR, ("Op %p deleted while in cache!\n", Op)); - } - - /* Clear the previously used Op */ - - MEMSET (Op, 0, sizeof (ACPI_PARSE2_OBJECT)); - - DEBUG_PRINTP (TRACE_PARSE, ("Op %p from ExtParse Cache\n", Op)); - } - AcpiUtReleaseMutex (ACPI_MTX_CACHES); + Op = AcpiUtAcquireFromCache (ACPI_MEM_LIST_PSNODE_EXT); } - /* Allocate a new Op if necessary */ - - if (!Op) - { - Op = ACPI_MEM_CALLOCATE (Size); - } - /* Initialize the Op */ + if (Op) { AcpiPsInitOp (Op, Opcode); Op->Flags = Flags; } return (Op); } /******************************************************************************* * * FUNCTION: AcpiPsFreeOp * * PARAMETERS: Op - Op to be freed * * RETURN: None. * * DESCRIPTION: Free an Op object. Either put it on the GENERIC_OP cache list * or actually free it. * ******************************************************************************/ void AcpiPsFreeOp ( ACPI_PARSE_OBJECT *Op) { PROC_NAME ("PsFreeOp"); if (Op->Opcode == AML_INT_RETURN_VALUE_OP) { - DEBUG_PRINTP (ACPI_INFO, ("Free retval op: %p\n", Op)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Free retval op: %p\n", Op)); } if (Op->Flags == PARSEOP_GENERIC) { - /* Is the cache full? */ - - if (AcpiGbl_ParseCacheDepth < MAX_PARSE_CACHE_DEPTH) - { - /* Put a GENERIC_OP back into the cache */ - - /* Clear the previously used Op */ - - MEMSET (Op, 0, sizeof (ACPI_PARSE_OBJECT)); - Op->Flags = PARSEOP_IN_CACHE; - - AcpiUtAcquireMutex (ACPI_MTX_CACHES); - AcpiGbl_ParseCacheDepth++; - - Op->Next = AcpiGbl_ParseCache; - AcpiGbl_ParseCache = Op; - - AcpiUtReleaseMutex (ACPI_MTX_CACHES); - return; - } + AcpiUtReleaseToCache (ACPI_MEM_LIST_PSNODE, Op); } else { - /* Is the cache full? */ - - if (AcpiGbl_ExtParseCacheDepth < MAX_EXTPARSE_CACHE_DEPTH) - { - /* Put a GENERIC_OP back into the cache */ - - /* Clear the previously used Op */ - - MEMSET (Op, 0, sizeof (ACPI_PARSE2_OBJECT)); - Op->Flags = PARSEOP_IN_CACHE; - - AcpiUtAcquireMutex (ACPI_MTX_CACHES); - AcpiGbl_ExtParseCacheDepth++; - - Op->Next = (ACPI_PARSE_OBJECT *) AcpiGbl_ExtParseCache; - AcpiGbl_ExtParseCache = (ACPI_PARSE2_OBJECT *) Op; - - AcpiUtReleaseMutex (ACPI_MTX_CACHES); - return; - } + AcpiUtReleaseToCache (ACPI_MEM_LIST_PSNODE_EXT, Op); } - - - /* - * Not a GENERIC OP, or the cache is full, just free the Op - */ - ACPI_MEM_FREE (Op); } /******************************************************************************* * * FUNCTION: AcpiPsDeleteParseCache * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Free all objects that are on the parse cache list. * ******************************************************************************/ void AcpiPsDeleteParseCache ( void) { - ACPI_PARSE_OBJECT *Next; - - FUNCTION_TRACE ("PsDeleteParseCache"); - /* Traverse the global cache list */ - - while (AcpiGbl_ParseCache) - { - /* Delete one cached state object */ - - Next = AcpiGbl_ParseCache->Next; - ACPI_MEM_FREE (AcpiGbl_ParseCache); - - AcpiGbl_ParseCache = Next; - AcpiGbl_ParseCacheDepth--; - } - - /* Traverse the global cache list */ - - while (AcpiGbl_ExtParseCache) - { - /* Delete one cached state object */ - - Next = AcpiGbl_ExtParseCache->Next; - ACPI_MEM_FREE (AcpiGbl_ExtParseCache); - - AcpiGbl_ExtParseCache = (ACPI_PARSE2_OBJECT *) Next; - AcpiGbl_ExtParseCacheDepth--; - } - + AcpiUtDeleteGenericCache (ACPI_MEM_LIST_PSNODE); + AcpiUtDeleteGenericCache (ACPI_MEM_LIST_PSNODE_EXT); return_VOID; } /******************************************************************************* * * FUNCTION: Utility functions * * DESCRIPTION: Low level functions * * TBD: [Restructure] * 1) Some of these functions should be macros * 2) Some can be simplified * ******************************************************************************/ /* * Is "c" a namestring lead character? */ BOOLEAN AcpiPsIsLeadingChar ( UINT32 c) { return ((BOOLEAN) (c == '_' || (c >= 'A' && c <= 'Z'))); } /* * Is "c" a namestring prefix character? */ BOOLEAN AcpiPsIsPrefixChar ( UINT32 c) { return ((BOOLEAN) (c == '\\' || c == '^')); } BOOLEAN AcpiPsIsNamespaceObjectOp ( UINT16 Opcode) { return ((BOOLEAN) (Opcode == AML_SCOPE_OP || Opcode == AML_DEVICE_OP || Opcode == AML_THERMAL_ZONE_OP || Opcode == AML_METHOD_OP || Opcode == AML_POWER_RES_OP || Opcode == AML_PROCESSOR_OP || Opcode == AML_FIELD_OP || Opcode == AML_INDEX_FIELD_OP || Opcode == AML_BANK_FIELD_OP || Opcode == AML_INT_NAMEDFIELD_OP || Opcode == AML_NAME_OP || Opcode == AML_ALIAS_OP || Opcode == AML_MUTEX_OP || Opcode == AML_EVENT_OP || Opcode == AML_REGION_OP || Opcode == AML_CREATE_FIELD_OP || Opcode == AML_CREATE_BIT_FIELD_OP || Opcode == AML_CREATE_BYTE_FIELD_OP || Opcode == AML_CREATE_WORD_FIELD_OP || Opcode == AML_CREATE_DWORD_FIELD_OP || Opcode == AML_CREATE_QWORD_FIELD_OP || Opcode == AML_INT_METHODCALL_OP || Opcode == AML_INT_NAMEPATH_OP)); } BOOLEAN AcpiPsIsNamespaceOp ( UINT16 Opcode) { return ((BOOLEAN) (Opcode == AML_SCOPE_OP || Opcode == AML_DEVICE_OP || Opcode == AML_THERMAL_ZONE_OP || Opcode == AML_METHOD_OP || Opcode == AML_POWER_RES_OP || Opcode == AML_PROCESSOR_OP || Opcode == AML_FIELD_OP || Opcode == AML_INDEX_FIELD_OP || Opcode == AML_BANK_FIELD_OP || Opcode == AML_NAME_OP || Opcode == AML_ALIAS_OP || Opcode == AML_MUTEX_OP || Opcode == AML_EVENT_OP || Opcode == AML_REGION_OP || Opcode == AML_INT_NAMEDFIELD_OP)); } /* * Is opcode for a named object Op? * (Includes all named object opcodes) * * TBD: [Restructure] Need a better way than this brute force approach! */ BOOLEAN AcpiPsIsNodeOp ( UINT16 Opcode) { return ((BOOLEAN) (Opcode == AML_SCOPE_OP || Opcode == AML_DEVICE_OP || Opcode == AML_THERMAL_ZONE_OP || Opcode == AML_METHOD_OP || Opcode == AML_POWER_RES_OP || Opcode == AML_PROCESSOR_OP || Opcode == AML_INT_NAMEDFIELD_OP || Opcode == AML_NAME_OP || Opcode == AML_ALIAS_OP || Opcode == AML_MUTEX_OP || Opcode == AML_EVENT_OP || Opcode == AML_REGION_OP || Opcode == AML_CREATE_FIELD_OP || Opcode == AML_CREATE_BIT_FIELD_OP || Opcode == AML_CREATE_BYTE_FIELD_OP || Opcode == AML_CREATE_WORD_FIELD_OP || Opcode == AML_CREATE_DWORD_FIELD_OP || Opcode == AML_CREATE_QWORD_FIELD_OP || Opcode == AML_INT_METHODCALL_OP || Opcode == AML_INT_NAMEPATH_OP)); } /* * Is opcode for a named Op? */ BOOLEAN AcpiPsIsNamedOp ( UINT16 Opcode) { return ((BOOLEAN) (Opcode == AML_SCOPE_OP || Opcode == AML_DEVICE_OP || Opcode == AML_THERMAL_ZONE_OP || Opcode == AML_METHOD_OP || Opcode == AML_POWER_RES_OP || Opcode == AML_PROCESSOR_OP || Opcode == AML_NAME_OP || Opcode == AML_ALIAS_OP || Opcode == AML_MUTEX_OP || Opcode == AML_EVENT_OP || Opcode == AML_REGION_OP || Opcode == AML_INT_NAMEDFIELD_OP)); } BOOLEAN AcpiPsIsDeferredOp ( UINT16 Opcode) { return ((BOOLEAN) (Opcode == AML_METHOD_OP || + Opcode == AML_VAR_PACKAGE_OP || Opcode == AML_CREATE_FIELD_OP || Opcode == AML_CREATE_BIT_FIELD_OP || Opcode == AML_CREATE_BYTE_FIELD_OP || Opcode == AML_CREATE_WORD_FIELD_OP || Opcode == AML_CREATE_DWORD_FIELD_OP || Opcode == AML_CREATE_QWORD_FIELD_OP || Opcode == AML_REGION_OP)); } /* * Is opcode for a bytelist? */ BOOLEAN AcpiPsIsBytelistOp ( UINT16 Opcode) { return ((BOOLEAN) (Opcode == AML_INT_BYTELIST_OP)); } /* * Is opcode for a Field, IndexField, or BankField */ BOOLEAN AcpiPsIsFieldOp ( UINT16 Opcode) { return ((BOOLEAN) (Opcode == AML_CREATE_FIELD_OP || Opcode == AML_FIELD_OP || Opcode == AML_INDEX_FIELD_OP || Opcode == AML_BANK_FIELD_OP)); } /* * Is field creation op */ BOOLEAN AcpiPsIsCreateFieldOp ( UINT16 Opcode) { return ((BOOLEAN) (Opcode == AML_CREATE_FIELD_OP || Opcode == AML_CREATE_BIT_FIELD_OP || Opcode == AML_CREATE_BYTE_FIELD_OP || Opcode == AML_CREATE_WORD_FIELD_OP || Opcode == AML_CREATE_DWORD_FIELD_OP || Opcode == AML_CREATE_QWORD_FIELD_OP)); } /* * Cast an acpi_op to an acpi_extended_op if possible */ /* TBD: This is very inefficient, fix */ ACPI_PARSE2_OBJECT * AcpiPsToExtendedOp ( ACPI_PARSE_OBJECT *Op) { return ((AcpiPsIsDeferredOp (Op->Opcode) || AcpiPsIsNamedOp (Op->Opcode) || AcpiPsIsBytelistOp (Op->Opcode)) ? ( (ACPI_PARSE2_OBJECT *) Op) : NULL); } /* * Get op's name (4-byte name segment) or 0 if unnamed */ UINT32 AcpiPsGetName ( ACPI_PARSE_OBJECT *Op) { ACPI_PARSE2_OBJECT *Named = AcpiPsToExtendedOp (Op); return (Named ? Named->Name : 0); } /* * Set op's name */ void AcpiPsSetName ( ACPI_PARSE_OBJECT *Op, UINT32 name) { ACPI_PARSE2_OBJECT *Named = AcpiPsToExtendedOp (Op); if (Named) { Named->Name = name; } } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/psxface.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/psxface.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/psxface.c (revision 82367) @@ -1,273 +1,273 @@ /****************************************************************************** * * Module Name: psxface - Parser external interfaces - * $Revision: 45 $ + * $Revision: 46 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __PSXFACE_C__ #include "acpi.h" #include "acparser.h" #include "acdispat.h" #include "acinterp.h" #include "amlcode.h" #include "acnamesp.h" #define _COMPONENT ACPI_PARSER MODULE_NAME ("psxface") /******************************************************************************* * * FUNCTION: AcpiPsxExecute * * PARAMETERS: MethodNode - A method object containing both the AML * address and length. * **Params - List of parameters to pass to method, * terminated by NULL. Params itself may be * NULL if no parameters are being passed. * **ReturnObjDesc - Return object from execution of the * method. * * RETURN: Status * * DESCRIPTION: Execute a control method * ******************************************************************************/ ACPI_STATUS AcpiPsxExecute ( ACPI_NAMESPACE_NODE *MethodNode, ACPI_OPERAND_OBJECT **Params, ACPI_OPERAND_OBJECT **ReturnObjDesc) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *ObjDesc; UINT32 i; ACPI_PARSE_OBJECT *Op; FUNCTION_TRACE ("PsxExecute"); /* Validate the Node and get the attached object */ if (!MethodNode) { return_ACPI_STATUS (AE_NULL_ENTRY); } ObjDesc = AcpiNsGetAttachedObject (MethodNode); if (!ObjDesc) { return_ACPI_STATUS (AE_NULL_OBJECT); } /* Init for new method, wait on concurrency semaphore */ Status = AcpiDsBeginMethodExecution (MethodNode, ObjDesc, NULL); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } if (Params) { /* * The caller "owns" the parameters, so give each one an extra * reference */ for (i = 0; Params[i]; i++) { AcpiUtAddReference (Params[i]); } } /* * Perform the first pass parse of the method to enter any * named objects that it creates into the namespace */ - DEBUG_PRINTP (ACPI_INFO, - ("**** Begin Method Execution **** Entry=%p obj=%p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "**** Begin Method Execution **** Entry=%p obj=%p\n", MethodNode, ObjDesc)); /* Create and init a Root Node */ Op = AcpiPsAllocOp (AML_SCOPE_OP); if (!Op) { return_ACPI_STATUS (AE_NO_MEMORY); } Status = AcpiPsParseAml (Op, ObjDesc->Method.Pcode, ObjDesc->Method.PcodeLength, ACPI_PARSE_LOAD_PASS1 | ACPI_PARSE_DELETE_TREE, MethodNode, Params, ReturnObjDesc, AcpiDsLoad1BeginOp, AcpiDsLoad1EndOp); AcpiPsDeleteParseTree (Op); /* Create and init a Root Node */ Op = AcpiPsAllocOp (AML_SCOPE_OP); if (!Op) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Init new op with the method name and pointer back to the NS node */ AcpiPsSetName (Op, MethodNode->Name); Op->Node = MethodNode; /* * The walk of the parse tree is where we actually execute the method */ Status = AcpiPsParseAml (Op, ObjDesc->Method.Pcode, ObjDesc->Method.PcodeLength, ACPI_PARSE_EXECUTE | ACPI_PARSE_DELETE_TREE, MethodNode, Params, ReturnObjDesc, AcpiDsExecBeginOp, AcpiDsExecEndOp); AcpiPsDeleteParseTree (Op); if (Params) { /* Take away the extra reference that we gave the parameters above */ for (i = 0; Params[i]; i++) { AcpiUtUpdateObjectReference (Params[i], REF_DECREMENT); } } /* * If the method has returned an object, signal this to the caller with * a control exception code */ if (*ReturnObjDesc) { - DEBUG_PRINTP (ACPI_INFO, ("Method returned ObjDesc=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Method returned ObjDesc=%X\n", *ReturnObjDesc)); DUMP_STACK_ENTRY (*ReturnObjDesc); Status = AE_CTRL_RETURN_VALUE; } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/rscreate.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/rscreate.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/rscreate.c (revision 82367) @@ -1,563 +1,563 @@ /******************************************************************************* * * Module Name: rscreate - Create resource lists/tables - * $Revision: 34 $ + * $Revision: 35 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __RSCREATE_C__ #include "acpi.h" #include "acresrc.h" #include "amlcode.h" #include "acnamesp.h" #define _COMPONENT ACPI_RESOURCES MODULE_NAME ("rscreate") /******************************************************************************* * * FUNCTION: AcpiRsCreateResourceList * * PARAMETERS: ByteStreamBuffer - Pointer to the resource byte stream * OutputBuffer - Pointer to the user's buffer * OutputBufferLength - Pointer to the size of OutputBuffer * * RETURN: Status - AE_OK if okay, else a valid ACPI_STATUS code * If OutputBuffer is not large enough, OutputBufferLength * indicates how large OutputBuffer should be, else it * indicates how may UINT8 elements of OutputBuffer are valid. * * DESCRIPTION: Takes the byte stream returned from a _CRS, _PRS control method * execution and parses the stream to create a linked list * of device resources. * ******************************************************************************/ ACPI_STATUS AcpiRsCreateResourceList ( ACPI_OPERAND_OBJECT *ByteStreamBuffer, UINT8 *OutputBuffer, UINT32 *OutputBufferLength) { ACPI_STATUS Status; UINT8 *ByteStreamStart; UINT32 ListSizeNeeded = 0; UINT32 ByteStreamBufferLength; FUNCTION_TRACE ("RsCreateResourceList"); - DEBUG_PRINTP (VERBOSE_INFO, ("ByteStreamBuffer = %p\n", ByteStreamBuffer)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ByteStreamBuffer = %p\n", ByteStreamBuffer)); /* * Params already validated, so we don't re-validate here */ ByteStreamBufferLength = ByteStreamBuffer->Buffer.Length; ByteStreamStart = ByteStreamBuffer->Buffer.Pointer; /* * Pass the ByteStreamBuffer into a module that can calculate * the buffer size needed for the linked list */ Status = AcpiRsCalculateListLength (ByteStreamStart, ByteStreamBufferLength, &ListSizeNeeded); - DEBUG_PRINTP (VERBOSE_INFO, ("Status=%X ListSizeNeeded=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Status=%X ListSizeNeeded=%X\n", Status, ListSizeNeeded)); /* * Exit with the error passed back */ if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * If the linked list will fit into the available buffer * call to fill in the list */ if (ListSizeNeeded <= *OutputBufferLength) { /* * Zero out the return buffer before proceeding */ MEMSET (OutputBuffer, 0x00, *OutputBufferLength); Status = AcpiRsByteStreamToList (ByteStreamStart, ByteStreamBufferLength, &OutputBuffer); /* * Exit with the error passed back */ if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } - DEBUG_PRINTP (VERBOSE_INFO, ("OutputBuffer = %p\n", OutputBuffer)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer = %p\n", OutputBuffer)); } else { *OutputBufferLength = ListSizeNeeded; return_ACPI_STATUS (AE_BUFFER_OVERFLOW); } *OutputBufferLength = ListSizeNeeded; return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiRsCreatePciRoutingTable * * PARAMETERS: PackageObject - Pointer to an ACPI_OPERAND_OBJECT * package * OutputBuffer - Pointer to the user's buffer * OutputBufferLength - Size of OutputBuffer * * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code. * If the OutputBuffer is too small, the error will be * AE_BUFFER_OVERFLOW and OutputBufferLength will point * to the size buffer needed. * * DESCRIPTION: Takes the ACPI_OPERAND_OBJECT package and creates a * linked list of PCI interrupt descriptions * ******************************************************************************/ ACPI_STATUS AcpiRsCreatePciRoutingTable ( ACPI_OPERAND_OBJECT *PackageObject, UINT8 *OutputBuffer, UINT32 *OutputBufferLength) { UINT8 *Buffer = OutputBuffer; ACPI_OPERAND_OBJECT **TopObjectList = NULL; ACPI_OPERAND_OBJECT **SubObjectList = NULL; ACPI_OPERAND_OBJECT *PackageElement = NULL; UINT32 BufferSizeNeeded = 0; UINT32 NumberOfElements = 0; UINT32 Index = 0; PCI_ROUTING_TABLE *UserPrt = NULL; ACPI_NAMESPACE_NODE *Node; ACPI_STATUS Status; FUNCTION_TRACE ("RsCreatePciRoutingTable"); /* * Params already validated, so we don't re-validate here */ Status = AcpiRsCalculatePciRoutingTableLength (PackageObject, &BufferSizeNeeded); if (!ACPI_SUCCESS(Status)) { return_ACPI_STATUS (Status); } - DEBUG_PRINTP (VERBOSE_INFO, ("BufferSizeNeeded = %X\n", BufferSizeNeeded)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "BufferSizeNeeded = %X\n", BufferSizeNeeded)); /* * If the data will fit into the available buffer * call to fill in the list */ if (BufferSizeNeeded <= *OutputBufferLength) { /* * Zero out the return buffer before proceeding */ MEMSET (OutputBuffer, 0x00, *OutputBufferLength); /* * Loop through the ACPI_INTERNAL_OBJECTS - Each object should * contain a UINT32 Address, a UINT8 Pin, a Name and a UINT8 * SourceIndex. */ TopObjectList = PackageObject->Package.Elements; NumberOfElements = PackageObject->Package.Count; UserPrt = (PCI_ROUTING_TABLE *) Buffer; Buffer = ROUND_PTR_UP_TO_8 (Buffer, UINT8); for (Index = 0; Index < NumberOfElements; Index++) { /* * Point UserPrt past this current structure * * NOTE: On the first iteration, UserPrt->Length will * be zero because we cleared the return buffer earlier */ Buffer += UserPrt->Length; UserPrt = (PCI_ROUTING_TABLE *) Buffer; /* * Fill in the Length field with the information we * have at this point. * The minus four is to subtract the size of the * UINT8 Source[4] member because it is added below. */ UserPrt->Length = (sizeof (PCI_ROUTING_TABLE) -4); /* * Dereference the sub-package */ PackageElement = *TopObjectList; /* * The SubObjectList will now point to an array of * the four IRQ elements: Address, Pin, Source and * SourceIndex */ SubObjectList = PackageElement->Package.Elements; /* * 1) First subobject: Dereference the Address */ if (ACPI_TYPE_INTEGER == (*SubObjectList)->Common.Type) { UserPrt->Address = (*SubObjectList)->Integer.Value; } else { - DEBUG_PRINTP (ACPI_ERROR, ("Need Integer, found %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need Integer, found %s\n", AcpiUtGetTypeName ((*SubObjectList)->Common.Type))); return_ACPI_STATUS (AE_BAD_DATA); } /* * 2) Second subobject: Dereference the Pin */ SubObjectList++; if (ACPI_TYPE_INTEGER == (*SubObjectList)->Common.Type) { UserPrt->Pin = (UINT32) (*SubObjectList)->Integer.Value; } else { - DEBUG_PRINTP (ACPI_ERROR, ("Need Integer, found %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need Integer, found %s\n", AcpiUtGetTypeName ((*SubObjectList)->Common.Type))); return_ACPI_STATUS (AE_BAD_DATA); } /* * 3) Third subobject: Dereference the Source Name */ SubObjectList++; switch ((*SubObjectList)->Common.Type) { case INTERNAL_TYPE_REFERENCE: if ((*SubObjectList)->Reference.Opcode != AML_INT_NAMEPATH_OP) { - DEBUG_PRINTP (ACPI_ERROR, ("Need name, found reference op %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need name, found reference op %X\n", (*SubObjectList)->Reference.Opcode)); return_ACPI_STATUS (AE_BAD_DATA); } Node = (*SubObjectList)->Reference.Node; /* TBD: use *remaining* length of the buffer! */ Status = AcpiNsHandleToPathname ((ACPI_HANDLE *) Node, OutputBufferLength, UserPrt->Source); UserPrt->Length += STRLEN (UserPrt->Source) + 1; /* include null terminator */ break; case ACPI_TYPE_STRING: STRCPY (UserPrt->Source, (*SubObjectList)->String.Pointer); /* * Add to the Length field the length of the string */ UserPrt->Length += (*SubObjectList)->String.Length; break; case ACPI_TYPE_INTEGER: /* * If this is a number, then the Source Name * is NULL, since the entire buffer was zeroed * out, we can leave this alone. */ /* * Add to the Length field the length of * the UINT32 NULL */ UserPrt->Length += sizeof (UINT32); break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Need Integer, found %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need Integer, found %s\n", AcpiUtGetTypeName ((*SubObjectList)->Common.Type))); return_ACPI_STATUS (AE_BAD_DATA); break; } /* Now align the current length */ UserPrt->Length = ROUND_UP_TO_64BITS (UserPrt->Length); /* * 4) Fourth subobject: Dereference the Source Index */ SubObjectList++; if (ACPI_TYPE_INTEGER == (*SubObjectList)->Common.Type) { UserPrt->SourceIndex = (UINT32) (*SubObjectList)->Integer.Value; } else { - DEBUG_PRINTP (ACPI_ERROR, ("Need Integer, found %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need Integer, found %s\n", AcpiUtGetTypeName ((*SubObjectList)->Common.Type))); return_ACPI_STATUS (AE_BAD_DATA); } /* * Point to the next ACPI_OPERAND_OBJECT */ TopObjectList++; } - DEBUG_PRINTP (VERBOSE_INFO, ("OutputBuffer = %p\n", OutputBuffer)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer = %p\n", OutputBuffer)); } else { *OutputBufferLength = BufferSizeNeeded; return_ACPI_STATUS (AE_BUFFER_OVERFLOW); } /* * Report the amount of buffer used */ *OutputBufferLength = BufferSizeNeeded; return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiRsCreateByteStream * * PARAMETERS: LinkedListBuffer - Pointer to the resource linked list * OutputBuffer - Pointer to the user's buffer * OutputBufferLength - Size of OutputBuffer * * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code. * If the OutputBuffer is too small, the error will be * AE_BUFFER_OVERFLOW and OutputBufferLength will point * to the size buffer needed. * * DESCRIPTION: Takes the linked list of device resources and * creates a bytestream to be used as input for the * _SRS control method. * ******************************************************************************/ ACPI_STATUS AcpiRsCreateByteStream ( ACPI_RESOURCE *LinkedListBuffer, UINT8 *OutputBuffer, UINT32 *OutputBufferLength) { ACPI_STATUS Status; UINT32 ByteStreamSizeNeeded = 0; FUNCTION_TRACE ("RsCreateByteStream"); - DEBUG_PRINTP (VERBOSE_INFO, ("LinkedListBuffer = %p\n", LinkedListBuffer)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "LinkedListBuffer = %p\n", LinkedListBuffer)); /* * Params already validated, so we don't re-validate here * * Pass the LinkedListBuffer into a module that can calculate * the buffer size needed for the byte stream. */ Status = AcpiRsCalculateByteStreamLength (LinkedListBuffer, &ByteStreamSizeNeeded); - DEBUG_PRINTP (VERBOSE_INFO, ("ByteStreamSizeNeeded=%X, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ByteStreamSizeNeeded=%X, %s\n", ByteStreamSizeNeeded, AcpiFormatException (Status))); /* * Exit with the error passed back */ if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * If the linked list will fit into the available buffer * call to fill in the list */ if (ByteStreamSizeNeeded <= *OutputBufferLength) { /* * Zero out the return buffer before proceeding */ MEMSET (OutputBuffer, 0x00, *OutputBufferLength); Status = AcpiRsListToByteStream (LinkedListBuffer, ByteStreamSizeNeeded, &OutputBuffer); /* * Exit with the error passed back */ if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } - DEBUG_PRINTP (VERBOSE_INFO, ("OutputBuffer = %p\n", OutputBuffer)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer = %p\n", OutputBuffer)); } else { *OutputBufferLength = ByteStreamSizeNeeded; return_ACPI_STATUS (AE_BUFFER_OVERFLOW); } return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/rsdump.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/rsdump.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/rsdump.c (revision 82367) @@ -1,1186 +1,1186 @@ /******************************************************************************* * * Module Name: rsdump - Functions to display the resource structures. - * $Revision: 20 $ + * $Revision: 21 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __RSDUMP_C__ #include "acpi.h" #include "acresrc.h" #define _COMPONENT ACPI_RESOURCES MODULE_NAME ("rsdump") /******************************************************************************* * * FUNCTION: AcpiRsDumpIrq * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpIrq ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_IRQ *IrqData = (ACPI_RESOURCE_IRQ *) Data; UINT8 Index = 0; AcpiOsPrintf ("IRQ Resource\n"); AcpiOsPrintf (" %s Triggered\n", LEVEL_SENSITIVE == IrqData->EdgeLevel ? "Level" : "Edge"); AcpiOsPrintf (" Active %s\n", ACTIVE_LOW == IrqData->ActiveHighLow ? "Low" : "High"); AcpiOsPrintf (" %s\n", SHARED == IrqData->SharedExclusive ? "Shared" : "Exclusive"); AcpiOsPrintf (" %X Interrupts ( ", IrqData->NumberOfInterrupts); for (Index = 0; Index < IrqData->NumberOfInterrupts; Index++) { AcpiOsPrintf ("%X ", IrqData->Interrupts[Index]); } AcpiOsPrintf (")\n"); return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpDma * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpDma ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_DMA *DmaData = (ACPI_RESOURCE_DMA *) Data; UINT8 Index = 0; AcpiOsPrintf ("DMA Resource\n"); switch (DmaData->Type) { case COMPATIBILITY: AcpiOsPrintf (" Compatibility mode\n"); break; case TYPE_A: AcpiOsPrintf (" Type A\n"); break; case TYPE_B: AcpiOsPrintf (" Type B\n"); break; case TYPE_F: AcpiOsPrintf (" Type F\n"); break; default: AcpiOsPrintf (" Invalid DMA type\n"); break; } AcpiOsPrintf (" %sBus Master\n", BUS_MASTER == DmaData->BusMaster ? "" : "Not a "); switch (DmaData->Transfer) { case TRANSFER_8: AcpiOsPrintf (" 8-bit only transfer\n"); break; case TRANSFER_8_16: AcpiOsPrintf (" 8 and 16-bit transfer\n"); break; case TRANSFER_16: AcpiOsPrintf (" 16 bit only transfer\n"); break; default: AcpiOsPrintf (" Invalid transfer preference\n"); break; } AcpiOsPrintf (" Number of Channels: %X ( ", DmaData->NumberOfChannels); for (Index = 0; Index < DmaData->NumberOfChannels; Index++) { AcpiOsPrintf ("%X ", DmaData->Channels[Index]); } AcpiOsPrintf (")\n"); return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpStartDependentFunctions * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpStartDependentFunctions ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_START_DPF *SdfData = (ACPI_RESOURCE_START_DPF *) Data; AcpiOsPrintf ("Start Dependent Functions Resource\n"); switch (SdfData->CompatibilityPriority) { case GOOD_CONFIGURATION: AcpiOsPrintf (" Good configuration\n"); break; case ACCEPTABLE_CONFIGURATION: AcpiOsPrintf (" Acceptable configuration\n"); break; case SUB_OPTIMAL_CONFIGURATION: AcpiOsPrintf (" Sub-optimal configuration\n"); break; default: AcpiOsPrintf (" Invalid compatibility priority\n"); break; } switch(SdfData->PerformanceRobustness) { case GOOD_CONFIGURATION: AcpiOsPrintf (" Good configuration\n"); break; case ACCEPTABLE_CONFIGURATION: AcpiOsPrintf (" Acceptable configuration\n"); break; case SUB_OPTIMAL_CONFIGURATION: AcpiOsPrintf (" Sub-optimal configuration\n"); break; default: AcpiOsPrintf (" Invalid performance " "robustness preference\n"); break; } return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpIo * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpIo ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_IO *IoData = (ACPI_RESOURCE_IO *) Data; AcpiOsPrintf ("Io Resource\n"); AcpiOsPrintf (" %d bit decode\n", DECODE_16 == IoData->IoDecode ? 16 : 10); AcpiOsPrintf (" Range minimum base: %08X\n", IoData->MinBaseAddress); AcpiOsPrintf (" Range maximum base: %08X\n", IoData->MaxBaseAddress); AcpiOsPrintf (" Alignment: %08X\n", IoData->Alignment); AcpiOsPrintf (" Range Length: %08X\n", IoData->RangeLength); return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpFixedIo * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpFixedIo ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_FIXED_IO *FixedIoData = (ACPI_RESOURCE_FIXED_IO *) Data; AcpiOsPrintf ("Fixed Io Resource\n"); AcpiOsPrintf (" Range base address: %08X", FixedIoData->BaseAddress); AcpiOsPrintf (" Range length: %08X", FixedIoData->RangeLength); return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpVendorSpecific * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpVendorSpecific ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_VENDOR *VendorData = (ACPI_RESOURCE_VENDOR *) Data; UINT16 Index = 0; AcpiOsPrintf ("Vendor Specific Resource\n"); AcpiOsPrintf (" Length: %08X\n", VendorData->Length); for (Index = 0; Index < VendorData->Length; Index++) { AcpiOsPrintf (" Byte %X: %08X\n", Index, VendorData->Reserved[Index]); } return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpMemory24 * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpMemory24 ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_MEM24 *Memory24Data = (ACPI_RESOURCE_MEM24 *) Data; AcpiOsPrintf ("24-Bit Memory Range Resource\n"); AcpiOsPrintf (" Read%s\n", READ_WRITE_MEMORY == Memory24Data->ReadWriteAttribute ? "/Write" : " only"); AcpiOsPrintf (" Range minimum base: %08X\n", Memory24Data->MinBaseAddress); AcpiOsPrintf (" Range maximum base: %08X\n", Memory24Data->MaxBaseAddress); AcpiOsPrintf (" Alignment: %08X\n", Memory24Data->Alignment); AcpiOsPrintf (" Range length: %08X\n", Memory24Data->RangeLength); return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpMemory32 * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpMemory32 ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_MEM32 *Memory32Data = (ACPI_RESOURCE_MEM32 *) Data; AcpiOsPrintf ("32-Bit Memory Range Resource\n"); AcpiOsPrintf (" Read%s\n", READ_WRITE_MEMORY == Memory32Data->ReadWriteAttribute ? "/Write" : " only"); AcpiOsPrintf (" Range minimum base: %08X\n", Memory32Data->MinBaseAddress); AcpiOsPrintf (" Range maximum base: %08X\n", Memory32Data->MaxBaseAddress); AcpiOsPrintf (" Alignment: %08X\n", Memory32Data->Alignment); AcpiOsPrintf (" Range length: %08X\n", Memory32Data->RangeLength); return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpFixedMemory32 * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpFixedMemory32 ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_FIXED_MEM32 *FixedMemory32Data = (ACPI_RESOURCE_FIXED_MEM32 *) Data; AcpiOsPrintf ("32-Bit Fixed Location Memory Range Resource\n"); AcpiOsPrintf (" Read%s\n", READ_WRITE_MEMORY == FixedMemory32Data->ReadWriteAttribute ? "/Write" : " Only"); AcpiOsPrintf (" Range base address: %08X\n", FixedMemory32Data->RangeBaseAddress); AcpiOsPrintf (" Range length: %08X\n", FixedMemory32Data->RangeLength); return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpAddress16 * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpAddress16 ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_ADDRESS16 *Address16Data = (ACPI_RESOURCE_ADDRESS16 *) Data; AcpiOsPrintf ("16-Bit Address Space Resource\n"); AcpiOsPrintf (" Resource Type: "); switch (Address16Data->ResourceType) { case MEMORY_RANGE: AcpiOsPrintf ("Memory Range\n"); switch (Address16Data->Attribute.Memory.CacheAttribute) { case NON_CACHEABLE_MEMORY: AcpiOsPrintf (" Type Specific: " "Noncacheable memory\n"); break; case CACHABLE_MEMORY: AcpiOsPrintf (" Type Specific: " "Cacheable memory\n"); break; case WRITE_COMBINING_MEMORY: AcpiOsPrintf (" Type Specific: " "Write-combining memory\n"); break; case PREFETCHABLE_MEMORY: AcpiOsPrintf (" Type Specific: " "Prefetchable memory\n"); break; default: AcpiOsPrintf (" Type Specific: " "Invalid cache attribute\n"); break; } AcpiOsPrintf (" Type Specific: Read%s\n", READ_WRITE_MEMORY == Address16Data->Attribute.Memory.ReadWriteAttribute ? "/Write" : " Only"); break; case IO_RANGE: AcpiOsPrintf ("I/O Range\n"); switch (Address16Data->Attribute.Io.RangeAttribute) { case NON_ISA_ONLY_RANGES: AcpiOsPrintf (" Type Specific: " "Non-ISA Io Addresses\n"); break; case ISA_ONLY_RANGES: AcpiOsPrintf (" Type Specific: " "ISA Io Addresses\n"); break; case ENTIRE_RANGE: AcpiOsPrintf (" Type Specific: " "ISA and non-ISA Io Addresses\n"); break; default: AcpiOsPrintf (" Type Specific: " "Invalid range attribute\n"); break; } break; case BUS_NUMBER_RANGE: AcpiOsPrintf ("Bus Number Range\n"); break; default: AcpiOsPrintf ("Invalid resource type. Exiting.\n"); return; } AcpiOsPrintf (" Resource %s\n", CONSUMER == Address16Data->ProducerConsumer ? "Consumer" : "Producer"); AcpiOsPrintf (" %s decode\n", SUB_DECODE == Address16Data->Decode ? "Subtractive" : "Positive"); AcpiOsPrintf (" Min address is %s fixed\n", ADDRESS_FIXED == Address16Data->MinAddressFixed ? "" : "not"); AcpiOsPrintf (" Max address is %s fixed\n", ADDRESS_FIXED == Address16Data->MaxAddressFixed ? "" : "not"); AcpiOsPrintf (" Granularity: %08X\n", Address16Data->Granularity); AcpiOsPrintf (" Address range min: %08X\n", Address16Data->MinAddressRange); AcpiOsPrintf (" Address range max: %08X\n", Address16Data->MaxAddressRange); AcpiOsPrintf (" Address translation offset: %08X\n", Address16Data->AddressTranslationOffset); AcpiOsPrintf (" Address Length: %08X\n", Address16Data->AddressLength); if (0xFF != Address16Data->ResourceSource.Index) { AcpiOsPrintf (" Resource Source Index: %X\n", Address16Data->ResourceSource.Index); AcpiOsPrintf (" Resource Source: %s\n", Address16Data->ResourceSource.StringPtr); } return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpAddress32 * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpAddress32 ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_ADDRESS32 *Address32Data = (ACPI_RESOURCE_ADDRESS32 *) Data; AcpiOsPrintf ("32-Bit Address Space Resource\n"); switch (Address32Data->ResourceType) { case MEMORY_RANGE: AcpiOsPrintf (" Resource Type: Memory Range\n"); switch (Address32Data->Attribute.Memory.CacheAttribute) { case NON_CACHEABLE_MEMORY: AcpiOsPrintf (" Type Specific: " "Noncacheable memory\n"); break; case CACHABLE_MEMORY: AcpiOsPrintf (" Type Specific: " "Cacheable memory\n"); break; case WRITE_COMBINING_MEMORY: AcpiOsPrintf (" Type Specific: " "Write-combining memory\n"); break; case PREFETCHABLE_MEMORY: AcpiOsPrintf (" Type Specific: " "Prefetchable memory\n"); break; default: AcpiOsPrintf (" Type Specific: " "Invalid cache attribute\n"); break; } AcpiOsPrintf (" Type Specific: Read%s\n", READ_WRITE_MEMORY == Address32Data->Attribute.Memory.ReadWriteAttribute ? "/Write" : " Only"); break; case IO_RANGE: AcpiOsPrintf (" Resource Type: Io Range\n"); switch (Address32Data->Attribute.Io.RangeAttribute) { case NON_ISA_ONLY_RANGES: AcpiOsPrintf (" Type Specific: " "Non-ISA Io Addresses\n"); break; case ISA_ONLY_RANGES: AcpiOsPrintf (" Type Specific: " "ISA Io Addresses\n"); break; case ENTIRE_RANGE: AcpiOsPrintf (" Type Specific: " "ISA and non-ISA Io Addresses\n"); break; default: AcpiOsPrintf (" Type Specific: " "Invalid Range attribute"); break; } break; case BUS_NUMBER_RANGE: AcpiOsPrintf (" Resource Type: Bus Number Range\n"); break; default: AcpiOsPrintf (" Invalid Resource Type..exiting.\n"); return; } AcpiOsPrintf (" Resource %s\n", CONSUMER == Address32Data->ProducerConsumer ? "Consumer" : "Producer"); AcpiOsPrintf (" %s decode\n", SUB_DECODE == Address32Data->Decode ? "Subtractive" : "Positive"); AcpiOsPrintf (" Min address is %s fixed\n", ADDRESS_FIXED == Address32Data->MinAddressFixed ? "" : "not "); AcpiOsPrintf (" Max address is %s fixed\n", ADDRESS_FIXED == Address32Data->MaxAddressFixed ? "" : "not "); AcpiOsPrintf (" Granularity: %08X\n", Address32Data->Granularity); AcpiOsPrintf (" Address range min: %08X\n", Address32Data->MinAddressRange); AcpiOsPrintf (" Address range max: %08X\n", Address32Data->MaxAddressRange); AcpiOsPrintf (" Address translation offset: %08X\n", Address32Data->AddressTranslationOffset); AcpiOsPrintf (" Address Length: %08X\n", Address32Data->AddressLength); if(0xFF != Address32Data->ResourceSource.Index) { AcpiOsPrintf (" Resource Source Index: %X\n", Address32Data->ResourceSource.Index); AcpiOsPrintf (" Resource Source: %s\n", Address32Data->ResourceSource.StringPtr); } return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpAddress64 * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpAddress64 ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_ADDRESS64 *Address64Data = (ACPI_RESOURCE_ADDRESS64 *) Data; AcpiOsPrintf ("64-Bit Address Space Resource\n"); switch (Address64Data->ResourceType) { case MEMORY_RANGE: AcpiOsPrintf (" Resource Type: Memory Range\n"); switch (Address64Data->Attribute.Memory.CacheAttribute) { case NON_CACHEABLE_MEMORY: AcpiOsPrintf (" Type Specific: " "Noncacheable memory\n"); break; case CACHABLE_MEMORY: AcpiOsPrintf (" Type Specific: " "Cacheable memory\n"); break; case WRITE_COMBINING_MEMORY: AcpiOsPrintf (" Type Specific: " "Write-combining memory\n"); break; case PREFETCHABLE_MEMORY: AcpiOsPrintf (" Type Specific: " "Prefetchable memory\n"); break; default: AcpiOsPrintf (" Type Specific: " "Invalid cache attribute\n"); break; } AcpiOsPrintf (" Type Specific: Read%s\n", READ_WRITE_MEMORY == Address64Data->Attribute.Memory.ReadWriteAttribute ? "/Write" : " Only"); break; case IO_RANGE: AcpiOsPrintf (" Resource Type: Io Range\n"); switch (Address64Data->Attribute.Io.RangeAttribute) { case NON_ISA_ONLY_RANGES: AcpiOsPrintf (" Type Specific: " "Non-ISA Io Addresses\n"); break; case ISA_ONLY_RANGES: AcpiOsPrintf (" Type Specific: " "ISA Io Addresses\n"); break; case ENTIRE_RANGE: AcpiOsPrintf (" Type Specific: " "ISA and non-ISA Io Addresses\n"); break; default: AcpiOsPrintf (" Type Specific: " "Invalid Range attribute"); break; } break; case BUS_NUMBER_RANGE: AcpiOsPrintf (" Resource Type: Bus Number Range\n"); break; default: AcpiOsPrintf (" Invalid Resource Type..exiting.\n"); return; } AcpiOsPrintf (" Resource %s\n", CONSUMER == Address64Data->ProducerConsumer ? "Consumer" : "Producer"); AcpiOsPrintf (" %s decode\n", SUB_DECODE == Address64Data->Decode ? "Subtractive" : "Positive"); AcpiOsPrintf (" Min address is %s fixed\n", ADDRESS_FIXED == Address64Data->MinAddressFixed ? "" : "not "); AcpiOsPrintf (" Max address is %s fixed\n", ADDRESS_FIXED == Address64Data->MaxAddressFixed ? "" : "not "); AcpiOsPrintf (" Granularity: %16X\n", Address64Data->Granularity); AcpiOsPrintf (" Address range min: %16X\n", Address64Data->MinAddressRange); AcpiOsPrintf (" Address range max: %16X\n", Address64Data->MaxAddressRange); AcpiOsPrintf (" Address translation offset: %16X\n", Address64Data->AddressTranslationOffset); AcpiOsPrintf (" Address Length: %16X\n", Address64Data->AddressLength); if(0xFF != Address64Data->ResourceSource.Index) { AcpiOsPrintf (" Resource Source Index: %X\n", Address64Data->ResourceSource.Index); AcpiOsPrintf (" Resource Source: %s\n", Address64Data->ResourceSource.StringPtr); } return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpExtendedIrq * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Prints out the various members of the Data structure type. * ******************************************************************************/ void AcpiRsDumpExtendedIrq ( ACPI_RESOURCE_DATA *Data) { ACPI_RESOURCE_EXT_IRQ *ExtIrqData = (ACPI_RESOURCE_EXT_IRQ *) Data; UINT8 Index = 0; AcpiOsPrintf ("Extended IRQ Resource\n"); AcpiOsPrintf (" Resource %s\n", CONSUMER == ExtIrqData->ProducerConsumer ? "Consumer" : "Producer"); AcpiOsPrintf (" %s\n", LEVEL_SENSITIVE == ExtIrqData->EdgeLevel ? "Level" : "Edge"); AcpiOsPrintf (" Active %s\n", ACTIVE_LOW == ExtIrqData->ActiveHighLow ? "low" : "high"); AcpiOsPrintf (" %s\n", SHARED == ExtIrqData->SharedExclusive ? "Shared" : "Exclusive"); AcpiOsPrintf (" Interrupts : %X ( ", ExtIrqData->NumberOfInterrupts); for (Index = 0; Index < ExtIrqData->NumberOfInterrupts; Index++) { AcpiOsPrintf ("%X ", ExtIrqData->Interrupts[Index]); } AcpiOsPrintf (")\n"); if(0xFF != ExtIrqData->ResourceSource.Index) { AcpiOsPrintf (" Resource Source Index: %X", ExtIrqData->ResourceSource.Index); AcpiOsPrintf (" Resource Source: %s", ExtIrqData->ResourceSource.StringPtr); } return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpResourceList * * PARAMETERS: Data - pointer to the resource structure to dump. * * RETURN: None * * DESCRIPTION: Dispatches the structure to the correct dump routine. * ******************************************************************************/ void AcpiRsDumpResourceList ( ACPI_RESOURCE *Resource) { UINT8 Count = 0; BOOLEAN Done = FALSE; - if (AcpiDbgLevel & TRACE_RESOURCES && _COMPONENT & AcpiDbgLayer) + if (AcpiDbgLevel & ACPI_LV_RESOURCES && _COMPONENT & AcpiDbgLayer) { while (!Done) { AcpiOsPrintf ("Resource structure %x.\n", Count++); switch (Resource->Id) { case ACPI_RSTYPE_IRQ: AcpiRsDumpIrq (&Resource->Data); break; case ACPI_RSTYPE_DMA: AcpiRsDumpDma (&Resource->Data); break; case ACPI_RSTYPE_START_DPF: AcpiRsDumpStartDependentFunctions (&Resource->Data); break; case ACPI_RSTYPE_END_DPF: AcpiOsPrintf ("EndDependentFunctions Resource\n"); /* AcpiRsDumpEndDependentFunctions (Resource->Data);*/ break; case ACPI_RSTYPE_IO: AcpiRsDumpIo (&Resource->Data); break; case ACPI_RSTYPE_FIXED_IO: AcpiRsDumpFixedIo (&Resource->Data); break; case ACPI_RSTYPE_VENDOR: AcpiRsDumpVendorSpecific (&Resource->Data); break; case ACPI_RSTYPE_END_TAG: /*RsDumpEndTag (Resource->Data);*/ AcpiOsPrintf ("EndTag Resource\n"); Done = TRUE; break; case ACPI_RSTYPE_MEM24: AcpiRsDumpMemory24 (&Resource->Data); break; case ACPI_RSTYPE_MEM32: AcpiRsDumpMemory32 (&Resource->Data); break; case ACPI_RSTYPE_FIXED_MEM32: AcpiRsDumpFixedMemory32 (&Resource->Data); break; case ACPI_RSTYPE_ADDRESS16: AcpiRsDumpAddress16 (&Resource->Data); break; case ACPI_RSTYPE_ADDRESS32: AcpiRsDumpAddress32 (&Resource->Data); break; case ACPI_RSTYPE_ADDRESS64: AcpiRsDumpAddress64 (&Resource->Data); break; case ACPI_RSTYPE_EXT_IRQ: AcpiRsDumpExtendedIrq (&Resource->Data); break; default: AcpiOsPrintf ("Invalid resource type\n"); break; } Resource = POINTER_ADD (ACPI_RESOURCE, Resource, Resource->Length); } } return; } /******************************************************************************* * * FUNCTION: AcpiRsDumpIrqList * * PARAMETERS: Data - pointer to the routing table to dump. * * RETURN: None * * DESCRIPTION: Dispatches the structures to the correct dump routine. * ******************************************************************************/ void AcpiRsDumpIrqList ( UINT8 *RouteTable) { UINT8 *Buffer = RouteTable; UINT8 Count = 0; BOOLEAN Done = FALSE; PCI_ROUTING_TABLE *PrtElement; - if (AcpiDbgLevel & TRACE_RESOURCES && _COMPONENT & AcpiDbgLayer) + if (AcpiDbgLevel & ACPI_LV_RESOURCES && _COMPONENT & AcpiDbgLayer) { PrtElement = (PCI_ROUTING_TABLE *) Buffer; while (!Done) { AcpiOsPrintf ("PCI IRQ Routing Table structure %X.\n", Count++); AcpiOsPrintf (" Address: %X\n", PrtElement->Address); AcpiOsPrintf (" Pin: %X\n", PrtElement->Pin); AcpiOsPrintf (" Source: %s\n", PrtElement->Source); AcpiOsPrintf (" SourceIndex: %X\n", PrtElement->SourceIndex); Buffer += PrtElement->Length; PrtElement = (PCI_ROUTING_TABLE *) Buffer; if(0 == PrtElement->Length) { Done = TRUE; } } } return; } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/rsutils.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/rsutils.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/rsutils.c (revision 82367) @@ -1,497 +1,497 @@ /******************************************************************************* * * Module Name: rsutils - Utilities for the resource manager - * $Revision: 20 $ + * $Revision: 21 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __RSUTILS_C__ #include "acpi.h" #include "acnamesp.h" #include "acresrc.h" #define _COMPONENT ACPI_RESOURCES MODULE_NAME ("rsutils") /******************************************************************************* * * FUNCTION: AcpiRsGetPrtMethodData * * PARAMETERS: Handle - a handle to the containing object * RetBuffer - a pointer to a buffer structure for the * results * * RETURN: Status * * DESCRIPTION: This function is called to get the _PRT value of an object * contained in an object specified by the handle passed in * * If the function fails an appropriate status will be returned * and the contents of the callers buffer is undefined. * ******************************************************************************/ ACPI_STATUS AcpiRsGetPrtMethodData ( ACPI_HANDLE Handle, ACPI_BUFFER *RetBuffer) { ACPI_OPERAND_OBJECT *RetObj; ACPI_STATUS Status; UINT32 BufferSpaceNeeded; FUNCTION_TRACE ("RsGetPrtMethodData"); /* already validated params, so we won't repeat here */ BufferSpaceNeeded = RetBuffer->Length; /* * Execute the method, no parameters */ Status = AcpiNsEvaluateRelative (Handle, "_PRT", NULL, &RetObj); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } if (!RetObj) { /* Return object is required */ - DEBUG_PRINTP (ACPI_ERROR, ("No object was returned from _PRT\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No object was returned from _PRT\n")); return_ACPI_STATUS (AE_TYPE); } /* * The return object will be a package, so check the * parameters. If the return object is not a package, * then the underlying AML code is corrupt or improperly * written. */ if (ACPI_TYPE_PACKAGE != RetObj->Common.Type) { Status = AE_AML_OPERAND_TYPE; goto Cleanup; } /* * Make the call to create a resource linked list from the * byte stream buffer that comes back from the _CRS method * execution. */ Status = AcpiRsCreatePciRoutingTable (RetObj, RetBuffer->Pointer, &BufferSpaceNeeded); /* * Tell the user how much of the buffer we have used or is needed * and return the final status. */ RetBuffer->Length = BufferSpaceNeeded; /* On exit, we must delete the object returned by evaluateObject */ Cleanup: AcpiUtRemoveReference (RetObj); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiRsGetCrsMethodData * * PARAMETERS: Handle - a handle to the containing object * RetBuffer - a pointer to a buffer structure for the * results * * RETURN: Status * * DESCRIPTION: This function is called to get the _CRS value of an object * contained in an object specified by the handle passed in * * If the function fails an appropriate status will be returned * and the contents of the callers buffer is undefined. * ******************************************************************************/ ACPI_STATUS AcpiRsGetCrsMethodData ( ACPI_HANDLE Handle, ACPI_BUFFER *RetBuffer) { ACPI_OPERAND_OBJECT *RetObj; ACPI_STATUS Status; UINT32 BufferSpaceNeeded = RetBuffer->Length; FUNCTION_TRACE ("RsGetCrsMethodData"); /* already validated params, so we won't repeat here */ /* * Execute the method, no parameters */ Status = AcpiNsEvaluateRelative (Handle, "_CRS", NULL, &RetObj); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } if (!RetObj) { /* Return object is required */ - DEBUG_PRINTP (ACPI_ERROR, ("No object was returned from _CRS\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No object was returned from _CRS\n")); return_ACPI_STATUS (AE_TYPE); } /* * The return object will be a buffer, but check the * parameters. If the return object is not a buffer, * then the underlying AML code is corrupt or improperly * written. */ if (ACPI_TYPE_BUFFER != RetObj->Common.Type) { Status = AE_AML_OPERAND_TYPE; goto Cleanup; } /* * Make the call to create a resource linked list from the * byte stream buffer that comes back from the _CRS method * execution. */ Status = AcpiRsCreateResourceList (RetObj, RetBuffer->Pointer, &BufferSpaceNeeded); /* * Tell the user how much of the buffer we have used or is needed * and return the final status. */ RetBuffer->Length = BufferSpaceNeeded; /* On exit, we must delete the object returned by evaluateObject */ Cleanup: AcpiUtRemoveReference (RetObj); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiRsGetPrsMethodData * * PARAMETERS: Handle - a handle to the containing object * RetBuffer - a pointer to a buffer structure for the * results * * RETURN: Status * * DESCRIPTION: This function is called to get the _PRS value of an object * contained in an object specified by the handle passed in * * If the function fails an appropriate status will be returned * and the contents of the callers buffer is undefined. * ******************************************************************************/ ACPI_STATUS AcpiRsGetPrsMethodData ( ACPI_HANDLE Handle, ACPI_BUFFER *RetBuffer) { ACPI_OPERAND_OBJECT *RetObj; ACPI_STATUS Status; UINT32 BufferSpaceNeeded = RetBuffer->Length; FUNCTION_TRACE ("RsGetPrsMethodData"); /* already validated params, so we won't repeat here */ /* * Execute the method, no parameters */ Status = AcpiNsEvaluateRelative (Handle, "_PRS", NULL, &RetObj); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } if (!RetObj) { /* Return object is required */ - DEBUG_PRINTP (ACPI_ERROR, ("No object was returned from _PRS\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No object was returned from _PRS\n")); return_ACPI_STATUS (AE_TYPE); } /* * The return object will be a buffer, but check the * parameters. If the return object is not a buffer, * then the underlying AML code is corrupt or improperly * written.. */ if (ACPI_TYPE_BUFFER != RetObj->Common.Type) { Status = AE_AML_OPERAND_TYPE; goto Cleanup; } /* * Make the call to create a resource linked list from the * byte stream buffer that comes back from the _CRS method * execution. */ Status = AcpiRsCreateResourceList (RetObj, RetBuffer->Pointer, &BufferSpaceNeeded); /* * Tell the user how much of the buffer we have used or is needed * and return the final status. */ RetBuffer->Length = BufferSpaceNeeded; /* On exit, we must delete the object returned by evaluateObject */ Cleanup: AcpiUtRemoveReference (RetObj); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiRsSetSrsMethodData * * PARAMETERS: Handle - a handle to the containing object * InBuffer - a pointer to a buffer structure of the * parameter * * RETURN: Status * * DESCRIPTION: This function is called to set the _SRS of an object contained * in an object specified by the handle passed in * * If the function fails an appropriate status will be returned * and the contents of the callers buffer is undefined. * ******************************************************************************/ ACPI_STATUS AcpiRsSetSrsMethodData ( ACPI_HANDLE Handle, ACPI_BUFFER *InBuffer) { ACPI_OPERAND_OBJECT *Params[2]; ACPI_OPERAND_OBJECT ParamObj; ACPI_STATUS Status; UINT8 *ByteStream = NULL; UINT32 BufferSizeNeeded = 0; FUNCTION_TRACE ("RsSetSrsMethodData"); /* already validated params, so we won't repeat here */ /* * The InBuffer parameter will point to a linked list of * resource parameters. It needs to be formatted into a * byte stream to be sent in as an input parameter. */ BufferSizeNeeded = 0; /* * First call is to get the buffer size needed */ Status = AcpiRsCreateByteStream (InBuffer->Pointer, ByteStream, &BufferSizeNeeded); /* * We expect a return of AE_BUFFER_OVERFLOW * if not, exit with the error */ if (AE_BUFFER_OVERFLOW != Status) { return_ACPI_STATUS (Status); } /* * Allocate the buffer needed */ ByteStream = ACPI_MEM_CALLOCATE (BufferSizeNeeded); if (NULL == ByteStream) { return_ACPI_STATUS (AE_NO_MEMORY); } /* * Now call to convert the linked list into a byte stream */ Status = AcpiRsCreateByteStream (InBuffer->Pointer, ByteStream, &BufferSizeNeeded); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* * Init the param object */ AcpiUtInitStaticObject (&ParamObj); /* * Method requires one parameter. Set it up */ Params [0] = &ParamObj; Params [1] = NULL; /* * Set up the parameter object */ ParamObj.Common.Type = ACPI_TYPE_BUFFER; ParamObj.Buffer.Length = BufferSizeNeeded; ParamObj.Buffer.Pointer = ByteStream; /* * Execute the method, no return value */ Status = AcpiNsEvaluateRelative (Handle, "_SRS", Params, NULL); /* * Clean up and return the status from AcpiNsEvaluateRelative */ Cleanup: ACPI_MEM_FREE (ByteStream); return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbconvrt.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbconvrt.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbconvrt.c (revision 82367) @@ -1,668 +1,668 @@ /****************************************************************************** * * Module Name: tbconvrt - ACPI Table conversion utilities - * $Revision: 24 $ + * $Revision: 25 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __TBCONVRT_C__ #include "acpi.h" #include "achware.h" #include "actables.h" #include "actbl.h" #define _COMPONENT ACPI_TABLES MODULE_NAME ("tbconvrt") /******************************************************************************* * * FUNCTION: AcpiTbGetTableCount * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ******************************************************************************/ UINT32 AcpiTbGetTableCount ( RSDP_DESCRIPTOR *RSDP, ACPI_TABLE_HEADER *RSDT) { UINT32 PointerSize; #ifndef _IA64 if (RSDP->Revision < 2) { PointerSize = sizeof (UINT32); } else #endif { PointerSize = sizeof (UINT64); } /* * Determine the number of tables pointed to by the RSDT/XSDT. * This is defined by the ACPI Specification to be the number of * pointers contained within the RSDT/XSDT. The size of the pointers * is architecture-dependent. */ return ((RSDT->Length - sizeof (ACPI_TABLE_HEADER)) / PointerSize); } /******************************************************************************* * * FUNCTION: AcpiTbConvertToXsdt * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ******************************************************************************/ ACPI_STATUS AcpiTbConvertToXsdt ( ACPI_TABLE_DESC *TableInfo, UINT32 *NumberOfTables) { UINT32 TableSize; UINT32 i; XSDT_DESCRIPTOR *NewTable; *NumberOfTables = AcpiTbGetTableCount (AcpiGbl_RSDP, TableInfo->Pointer); /* Compute size of the converted XSDT */ TableSize = (*NumberOfTables * sizeof (UINT64)) + sizeof (ACPI_TABLE_HEADER); /* Allocate an XSDT */ NewTable = ACPI_MEM_CALLOCATE (TableSize); if (!NewTable) { return (AE_NO_MEMORY); } /* Copy the header and set the length */ MEMCPY (NewTable, TableInfo->Pointer, sizeof (ACPI_TABLE_HEADER)); NewTable->Header.Length = TableSize; /* Copy the table pointers */ for (i = 0; i < *NumberOfTables; i++) { if (AcpiGbl_RSDP->Revision < 2) { #ifdef _IA64 NewTable->TableOffsetEntry[i] = ((RSDT_DESCRIPTOR_REV071 *) TableInfo->Pointer)->TableOffsetEntry[i]; #else ACPI_STORE_ADDRESS (NewTable->TableOffsetEntry[i], ((RSDT_DESCRIPTOR_REV1 *) TableInfo->Pointer)->TableOffsetEntry[i]); #endif } else { NewTable->TableOffsetEntry[i] = ((XSDT_DESCRIPTOR *) TableInfo->Pointer)->TableOffsetEntry[i]; } } /* Delete the original table (either mapped or in a buffer) */ AcpiTbDeleteSingleTable (TableInfo); /* Point the table descriptor to the new table */ TableInfo->Pointer = (ACPI_TABLE_HEADER *) NewTable; TableInfo->BasePointer = (ACPI_TABLE_HEADER *) NewTable; TableInfo->Length = TableSize; TableInfo->Allocation = ACPI_MEM_ALLOCATED; return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiTbConvertTableFadt * * PARAMETERS: * * RETURN: * * DESCRIPTION: * Converts BIOS supplied 1.0 and 0.71 ACPI FADT to an intermediate * ACPI 2.0 FADT. If the BIOS supplied a 2.0 FADT then it is simply * copied to the intermediate FADT. The ACPI CA software uses this * intermediate FADT. Thus a significant amount of special #ifdef * type codeing is saved. This intermediate FADT will need to be * freed at some point. * ******************************************************************************/ ACPI_STATUS AcpiTbConvertTableFadt (void) { #ifdef _IA64 FADT_DESCRIPTOR_REV071 *FADT71; UINT8 Pm1AddressSpace; UINT8 Pm2AddressSpace; UINT8 PmTimerAddressSpace; UINT8 Gpe0AddressSpace; UINT8 Gpe1AddressSpace; #else FADT_DESCRIPTOR_REV1 *FADT1; #endif FADT_DESCRIPTOR_REV2 *FADT2; ACPI_TABLE_DESC *TableDesc; FUNCTION_TRACE ("AcpiTbConvertTableFadt"); /* AcpiGbl_FADT is valid */ /* Allocate and zero the 2.0 buffer */ FADT2 = ACPI_MEM_CALLOCATE (sizeof (FADT_DESCRIPTOR_REV2)); if (FADT2 == NULL) { return_ACPI_STATUS (AE_NO_MEMORY); } /* The ACPI FADT revision number is FADT2_REVISION_ID=3 */ /* So, if the current table revision is less than 3 it is type 1.0 or 0.71 */ if (AcpiGbl_FADT->header.Revision >= FADT2_REVISION_ID) { /* We have an ACPI 2.0 FADT but we must copy it to our local buffer */ *FADT2 = *((FADT_DESCRIPTOR_REV2*) AcpiGbl_FADT); } else { #ifdef _IA64 /* * For the 64-bit case only, a revision ID less than V2.0 means the * tables are the 0.71 extensions */ /* The BIOS stored FADT should agree with Revision 0.71 */ FADT71 = (FADT_DESCRIPTOR_REV071 *) AcpiGbl_FADT; /* Copy the table header*/ FADT2->header = FADT71->header; /* Copy the common fields */ FADT2->SciInt = FADT71->SciInt; FADT2->AcpiEnable = FADT71->AcpiEnable; FADT2->AcpiDisable = FADT71->AcpiDisable; FADT2->S4BiosReq = FADT71->S4BiosReq; FADT2->Plvl2Lat = FADT71->Plvl2Lat; FADT2->Plvl3Lat = FADT71->Plvl3Lat; FADT2->DayAlrm = FADT71->DayAlrm; FADT2->MonAlrm = FADT71->MonAlrm; FADT2->Century = FADT71->Century; FADT2->Gpe1Base = FADT71->Gpe1Base; /* * We still use the block length registers even though * the GAS structure should obsolete them. This is because * these registers are byte lengths versus the GAS which * contains a bit width */ FADT2->Pm1EvtLen = FADT71->Pm1EvtLen; FADT2->Pm1CntLen = FADT71->Pm1CntLen; FADT2->Pm2CntLen = FADT71->Pm2CntLen; FADT2->PmTmLen = FADT71->PmTmLen; FADT2->Gpe0BlkLen = FADT71->Gpe0BlkLen; FADT2->Gpe1BlkLen = FADT71->Gpe1BlkLen; FADT2->Gpe1Base = FADT71->Gpe1Base; /* Copy the existing 0.71 flags to 2.0. The other bits are zero.*/ FADT2->WbInvd = FADT71->FlushCash; FADT2->ProcC1 = FADT71->ProcC1; FADT2->Plvl2Up = FADT71->Plvl2Up; FADT2->PwrButton = FADT71->PwrButton; FADT2->SleepButton = FADT71->SleepButton; FADT2->FixedRTC = FADT71->FixedRTC; FADT2->Rtcs4 = FADT71->Rtcs4; FADT2->TmrValExt = FADT71->TmrValExt; FADT2->DockCap = FADT71->DockCap; /* We should not use these next two addresses */ /* Since our buffer is pre-zeroed nothing to do for */ /* the next three data items in the structure */ /* FADT2->FirmwareCtrl = 0; */ /* FADT2->Dsdt = 0; */ /* System Interrupt Model isn't used in ACPI 2.0*/ /* FADT2->Reserved1 = 0; */ /* This field is set by the OEM to convey the preferred */ /* power management profile to OSPM. It doesn't have any*/ /* 0.71 equivalence. Since we don't know what kind of */ /* 64-bit system this is, we will pick unspecified. */ FADT2->Prefer_PM_Profile = PM_UNSPECIFIED; /* Port address of SMI command port */ /* We shouldn't use this port because IA64 doesn't */ /* have or use SMI. It has PMI. */ FADT2->SmiCmd = (UINT32)(FADT71->SmiCmd & 0xFFFFFFFF); /* processor performance state control*/ /* The value OSPM writes to the SMI_CMD register to assume */ /* processor performance state control responsibility. */ /* There isn't any equivalence in 0.71 */ /* Again this should be meaningless for IA64 */ /* FADT2->PstateCnt = 0; */ /* The 32-bit Power management and GPE registers are */ /* not valid in IA-64 and we are not going to use them */ /* so leaving them pre-zeroed. */ /* Support for the _CST object and C States change notification.*/ /* This data item hasn't any 0.71 equivalence so leaving it zero.*/ /* FADT2->CstCnt = 0; */ /* number of flush strides that need to be read */ /* No 0.71 equivalence. Leave pre-zeroed. */ /* FADT2->FlushSize = 0; */ /* Processor's memory cache line width, in bytes */ /* No 0.71 equivalence. Leave pre-zeroed. */ /* FADT2->FlushStride = 0; */ /* Processor's duty cycle index in processor's P_CNT reg*/ /* No 0.71 equivalence. Leave pre-zeroed. */ /* FADT2->DutyOffset = 0; */ /* Processor's duty cycle value bit width in P_CNT register.*/ /* No 0.71 equivalence. Leave pre-zeroed. */ /* FADT2->DutyWidth = 0; */ /* Since there isn't any equivalence in 0.71 */ /* and since BigSur had to support legacy */ FADT2->IapcBootArch = BAF_LEGACY_DEVICES; /* Copy to ACPI 2.0 64-BIT Extended Addresses */ FADT2->XFirmwareCtrl = FADT71->FirmwareCtrl; FADT2->XDsdt = FADT71->Dsdt; /* Extract the address space IDs */ Pm1AddressSpace = (UINT8)((FADT71->AddressSpace & PM1_BLK_ADDRESS_SPACE) >> 1); Pm2AddressSpace = (UINT8)((FADT71->AddressSpace & PM2_CNT_BLK_ADDRESS_SPACE) >> 2); PmTimerAddressSpace = (UINT8)((FADT71->AddressSpace & PM_TMR_BLK_ADDRESS_SPACE) >> 3); Gpe0AddressSpace = (UINT8)((FADT71->AddressSpace & GPE0_BLK_ADDRESS_SPACE) >> 4); Gpe1AddressSpace = (UINT8)((FADT71->AddressSpace & GPE1_BLK_ADDRESS_SPACE) >> 5); /* * Convert the 0.71 (non-GAS style) Block addresses to V2.0 GAS structures, * in this order: * * PM 1A Events * PM 1B Events * PM 1A Control * PM 1B Control * PM 2 Control * PM Timer Control * GPE Block 0 * GPE Block 1 */ ASL_BUILD_GAS_FROM_ENTRY (FADT2->XPm1aEvtBlk, FADT71->Pm1EvtLen, FADT71->Pm1aEvtBlk, Pm1AddressSpace); ASL_BUILD_GAS_FROM_ENTRY (FADT2->XPm1bEvtBlk, FADT71->Pm1EvtLen, FADT71->Pm1bEvtBlk, Pm1AddressSpace); ASL_BUILD_GAS_FROM_ENTRY (FADT2->XPm1aCntBlk, FADT71->Pm1CntLen, FADT71->Pm1aCntBlk, Pm1AddressSpace); ASL_BUILD_GAS_FROM_ENTRY (FADT2->XPm1bCntBlk, FADT71->Pm1CntLen, FADT71->Pm1bCntBlk, Pm1AddressSpace); ASL_BUILD_GAS_FROM_ENTRY (FADT2->XPm2CntBlk, FADT71->Pm2CntLen, FADT71->Pm2CntBlk, Pm2AddressSpace); ASL_BUILD_GAS_FROM_ENTRY (FADT2->XPmTmrBlk, FADT71->PmTmLen, FADT71->PmTmrBlk, PmTimerAddressSpace); ASL_BUILD_GAS_FROM_ENTRY (FADT2->XGpe0Blk, FADT71->Gpe0BlkLen, FADT71->Gpe0Blk, Gpe0AddressSpace); ASL_BUILD_GAS_FROM_ENTRY (FADT2->XGpe1Blk, FADT71->Gpe1BlkLen, FADT71->Gpe1Blk, Gpe1AddressSpace); #else /* ACPI 1.0 FACS */ /* The BIOS stored FADT should agree with Revision 1.0 */ FADT1 = (FADT_DESCRIPTOR_REV1*) AcpiGbl_FADT; /* * Copy the table header and the common part of the tables * The 2.0 table is an extension of the 1.0 table, so the * entire 1.0 table can be copied first, then expand some * fields to 64 bits. */ MEMCPY (FADT2, FADT1, sizeof (FADT_DESCRIPTOR_REV1)); /* Convert table pointers to 64-bit fields */ ACPI_STORE_ADDRESS (FADT2->XFirmwareCtrl, FADT1->FirmwareCtrl); ACPI_STORE_ADDRESS (FADT2->XDsdt, FADT1->Dsdt); /* System Interrupt Model isn't used in ACPI 2.0*/ /* FADT2->Reserved1 = 0; */ /* This field is set by the OEM to convey the preferred */ /* power management profile to OSPM. It doesn't have any*/ /* 1.0 equivalence. Since we don't know what kind of */ /* 32-bit system this is, we will pick unspecified. */ FADT2->Prefer_PM_Profile = PM_UNSPECIFIED; /* Processor Performance State Control. This is the value */ /* OSPM writes to the SMI_CMD register to assume processor */ /* performance state control responsibility. There isn't */ /* any equivalence in 1.0. So leave it zeroed. */ FADT2->PstateCnt = 0; /* Support for the _CST object and C States change notification.*/ /* This data item hasn't any 1.0 equivalence so leaving it zero.*/ FADT2->CstCnt = 0; /* Since there isn't any equivalence in 1.0 and since it */ /* is highly likely that a 1.0 system has legacy support. */ FADT2->IapcBootArch = BAF_LEGACY_DEVICES; /* * Convert the V1.0 Block addresses to V2.0 GAS structures * in this order: * * PM 1A Events * PM 1B Events * PM 1A Control * PM 1B Control * PM 2 Control * PM Timer Control * GPE Block 0 * GPE Block 1 */ ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->XPm1aEvtBlk, FADT1->Pm1EvtLen, FADT1->Pm1aEvtBlk); ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->XPm1bEvtBlk, FADT1->Pm1EvtLen, FADT1->Pm1bEvtBlk); ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->XPm1aCntBlk, FADT1->Pm1CntLen, FADT1->Pm1aCntBlk); ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->XPm1bCntBlk, FADT1->Pm1CntLen, FADT1->Pm1bCntBlk); ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->XPm2CntBlk, FADT1->Pm2CntLen, FADT1->Pm2CntBlk); ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->XPmTmrBlk, FADT1->PmTmLen, FADT1->PmTmrBlk); ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->XGpe0Blk, FADT1->Gpe0BlkLen, FADT1->Gpe0Blk); ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->XGpe1Blk, FADT1->Gpe1BlkLen, FADT1->Gpe1Blk); #endif } /* * Global FADT pointer will point to the common V2.0 FADT */ AcpiGbl_FADT = FADT2; AcpiGbl_FADT->header.Length = sizeof (FADT_DESCRIPTOR); /* Free the original table */ TableDesc = &AcpiGbl_AcpiTables[ACPI_TABLE_FADT]; AcpiTbDeleteSingleTable (TableDesc); /* Install the new table */ TableDesc->Pointer = (ACPI_TABLE_HEADER *) AcpiGbl_FADT; TableDesc->BasePointer = AcpiGbl_FADT; TableDesc->Allocation = ACPI_MEM_ALLOCATED; TableDesc->Length = sizeof (FADT_DESCRIPTOR_REV2); /* Dump the entire FADT */ - DEBUG_PRINT (TRACE_TABLES, - ("Hex dump of common internal FADT, size %ld (%lX)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, + "Hex dump of common internal FADT, size %ld (%lX)\n", AcpiGbl_FADT->header.Length, AcpiGbl_FADT->header.Length)); DUMP_BUFFER ((UINT8 *) (AcpiGbl_FADT), AcpiGbl_FADT->header.Length); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiTbConvertTableFacs * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ******************************************************************************/ ACPI_STATUS AcpiTbBuildCommonFacs ( ACPI_TABLE_DESC *TableInfo) { ACPI_COMMON_FACS *CommonFacs; #ifdef _IA64 FACS_DESCRIPTOR_REV071 *FACS71; #else FACS_DESCRIPTOR_REV1 *FACS1; #endif FACS_DESCRIPTOR_REV2 *FACS2; FUNCTION_TRACE ("AcpiTbBuildCommonFacs"); /* Allocate a common FACS */ CommonFacs = ACPI_MEM_CALLOCATE (sizeof (ACPI_COMMON_FACS)); if (!CommonFacs) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Copy fields to the new FACS */ if (AcpiGbl_RSDP->Revision < 2) { #ifdef _IA64 /* 0.71 FACS */ FACS71 = (FACS_DESCRIPTOR_REV071 *) AcpiGbl_FACS; CommonFacs->GlobalLock = (UINT32 *) &(FACS71->GlobalLock); CommonFacs->FirmwareWakingVector = &FACS71->FirmwareWakingVector; CommonFacs->VectorWidth = 64; #else /* ACPI 1.0 FACS */ FACS1 = (FACS_DESCRIPTOR_REV1 *) AcpiGbl_FACS; CommonFacs->GlobalLock = &(FACS1->GlobalLock); CommonFacs->FirmwareWakingVector = (UINT64 *) &FACS1->FirmwareWakingVector; CommonFacs->VectorWidth = 32; #endif } else { /* ACPI 2.0 FACS */ FACS2 = (FACS_DESCRIPTOR_REV2 *) AcpiGbl_FACS; CommonFacs->GlobalLock = &(FACS2->GlobalLock); CommonFacs->FirmwareWakingVector = &FACS2->XFirmwareWakingVector; CommonFacs->VectorWidth = 64; } /* Set the global FACS pointer to point to the common FACS */ AcpiGbl_FACS = CommonFacs; return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbget.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbget.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbget.c (revision 82367) @@ -1,889 +1,891 @@ /****************************************************************************** * * Module Name: tbget - ACPI Table get* routines - * $Revision: 51 $ + * $Revision: 52 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __TBGET_C__ #include "acpi.h" #include "achware.h" #include "actables.h" #define _COMPONENT ACPI_TABLES MODULE_NAME ("tbget") #define RSDP_CHECKSUM_LENGTH 20 /******************************************************************************* * * FUNCTION: AcpiTbGetTablePtr * * PARAMETERS: TableType - one of the defined table types * Instance - Which table of this type * TablePtrLoc - pointer to location to place the pointer for * return * * RETURN: Status * * DESCRIPTION: This function is called to get the pointer to an ACPI table. * ******************************************************************************/ ACPI_STATUS AcpiTbGetTablePtr ( ACPI_TABLE_TYPE TableType, UINT32 Instance, ACPI_TABLE_HEADER **TablePtrLoc) { ACPI_TABLE_DESC *TableDesc; UINT32 i; FUNCTION_TRACE ("TbGetTablePtr"); if (!AcpiGbl_DSDT) { return_ACPI_STATUS (AE_NO_ACPI_TABLES); } if (TableType > ACPI_TABLE_MAX) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* * For all table types (Single/Multiple), the first * instance is always in the list head. */ if (Instance == 1) { /* * Just pluck the pointer out of the global table! * Will be null if no table is present */ *TablePtrLoc = AcpiGbl_AcpiTables[TableType].Pointer; return_ACPI_STATUS (AE_OK); } /* * Check for instance out of range */ if (Instance > AcpiGbl_AcpiTables[TableType].Count) { return_ACPI_STATUS (AE_NOT_EXIST); } /* Walk the list to get the desired table * Since the if (Instance == 1) check above checked for the * first table, setting TableDesc equal to the .Next member * is actually pointing to the second table. Therefore, we * need to walk from the 2nd table until we reach the Instance * that the user is looking for and return its table pointer. */ TableDesc = AcpiGbl_AcpiTables[TableType].Next; for (i = 2; i < Instance; i++) { TableDesc = TableDesc->Next; } /* We are now pointing to the requested table's descriptor */ *TablePtrLoc = TableDesc->Pointer; return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiTbGetTable * * PARAMETERS: PhysicalAddress - Physical address of table to retrieve * *BufferPtr - If BufferPtr is valid, read data from * buffer rather than searching memory * *TableInfo - Where the table info is returned * * RETURN: Status * * DESCRIPTION: Maps the physical address of table into a logical address * ******************************************************************************/ ACPI_STATUS AcpiTbGetTable ( ACPI_PHYSICAL_ADDRESS PhysicalAddress, ACPI_TABLE_HEADER *BufferPtr, ACPI_TABLE_DESC *TableInfo) { ACPI_TABLE_HEADER *TableHeader = NULL; ACPI_TABLE_HEADER *FullTable = NULL; UINT32 Size; UINT8 Allocation; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("TbGetTable"); if (!TableInfo) { return_ACPI_STATUS (AE_BAD_PARAMETER); } if (BufferPtr) { /* * Getting data from a buffer, not BIOS tables */ TableHeader = BufferPtr; Status = AcpiTbValidateTableHeader (TableHeader); if (ACPI_FAILURE (Status)) { /* Table failed verification, map all errors to BAD_DATA */ return_ACPI_STATUS (AE_BAD_DATA); } /* Allocate buffer for the entire table */ FullTable = ACPI_MEM_ALLOCATE (TableHeader->Length); if (!FullTable) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Copy the entire table (including header) to the local buffer */ Size = TableHeader->Length; MEMCPY (FullTable, BufferPtr, Size); /* Save allocation type */ Allocation = ACPI_MEM_ALLOCATED; } /* * Not reading from a buffer, just map the table's physical memory * into our address space. */ else { Size = SIZE_IN_HEADER; Status = AcpiTbMapAcpiTable (PhysicalAddress, &Size, &FullTable); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Save allocation type */ Allocation = ACPI_MEM_MAPPED; } /* Return values */ TableInfo->Pointer = FullTable; TableInfo->Length = Size; TableInfo->Allocation = Allocation; TableInfo->BasePointer = FullTable; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiTbGetAllTables * * PARAMETERS: NumberOfTables - Number of tables to get * TablePtr - Input buffer pointer, optional * * RETURN: Status * * DESCRIPTION: Load and validate all tables other than the RSDT. The RSDT must * already be loaded and validated. * ******************************************************************************/ ACPI_STATUS AcpiTbGetAllTables ( UINT32 NumberOfTables, ACPI_TABLE_HEADER *TablePtr) { ACPI_STATUS Status = AE_OK; UINT32 Index; ACPI_TABLE_DESC TableInfo; FUNCTION_TRACE ("TbGetAllTables"); - DEBUG_PRINT (ACPI_INFO, ("Number of tables: %d\n", NumberOfTables)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Number of tables: %d\n", NumberOfTables)); /* * Loop through all table pointers found in RSDT. * This will NOT include the FACS and DSDT - we must get * them after the loop */ for (Index = 0; Index < NumberOfTables; Index++) { /* Clear the TableInfo each time */ MEMSET (&TableInfo, 0, sizeof (ACPI_TABLE_DESC)); /* Get the table via the XSDT */ Status = AcpiTbGetTable ((ACPI_PHYSICAL_ADDRESS) ACPI_GET_ADDRESS (AcpiGbl_XSDT->TableOffsetEntry[Index]), TablePtr, &TableInfo); /* Ignore a table that failed verification */ if (Status == AE_BAD_DATA) { continue; } /* However, abort on serious errors */ if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Recognize and install the table */ Status = AcpiTbInstallTable (TablePtr, &TableInfo); if (ACPI_FAILURE (Status)) { /* * Unrecognized or unsupported table, delete it and ignore the * error. Just get as many tables as we can, later we will * determine if there are enough tables to continue. */ AcpiTbUninstallTable (&TableInfo); } } /* * Convert the FADT to a common format. This allows earlier revisions of the * table to coexist with newer versions, using common access code. */ Status = AcpiTbConvertTableFadt (); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Get the minimum set of ACPI tables, namely: * * 1) FADT (via RSDT in loop above) * 2) FACS * 3) DSDT * */ /* * Get the FACS (must have the FADT first, from loop above) * AcpiTbGetTableFacs will fail if FADT pointer is not valid */ Status = AcpiTbGetTableFacs (TablePtr, &TableInfo); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Install the FACS */ Status = AcpiTbInstallTable (TablePtr, &TableInfo); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Create the common FACS pointer table * (Contains pointers to the original table) */ Status = AcpiTbBuildCommonFacs (&TableInfo); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Get the DSDT (We know that the FADT is valid now) */ Status = AcpiTbGetTable ((ACPI_PHYSICAL_ADDRESS) ACPI_GET_ADDRESS (AcpiGbl_FADT->XDsdt), TablePtr, &TableInfo); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Install the DSDT */ Status = AcpiTbInstallTable (TablePtr, &TableInfo); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Dump the DSDT Header */ - DEBUG_PRINT (TRACE_TABLES, ("Hex dump of DSDT Header:\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "Hex dump of DSDT Header:\n")); DUMP_BUFFER ((UINT8 *) AcpiGbl_DSDT, sizeof (ACPI_TABLE_HEADER)); /* Dump the entire DSDT */ - DEBUG_PRINT (TRACE_TABLES, - ("Hex dump of DSDT (After header), size %d (%x)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, + "Hex dump of DSDT (After header), size %d (%x)\n", AcpiGbl_DSDT->Length, AcpiGbl_DSDT->Length)); DUMP_BUFFER ((UINT8 *) (AcpiGbl_DSDT + 1), AcpiGbl_DSDT->Length); /* * Initialize the capabilities flags. * Assumes that platform supports ACPI_MODE since we have tables! */ AcpiGbl_SystemFlags |= AcpiHwGetModeCapabilities (); /* Always delete the RSDP mapping, we are done with it */ AcpiTbDeleteAcpiTable (ACPI_TABLE_RSDP); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiTbVerifyRsdp * * PARAMETERS: NumberOfTables - Where the table count is placed * * RETURN: Status * * DESCRIPTION: Load and validate the RSDP (ptr) and RSDT (table) * ******************************************************************************/ ACPI_STATUS AcpiTbVerifyRsdp ( ACPI_PHYSICAL_ADDRESS RsdpPhysicalAddress) { ACPI_TABLE_DESC TableInfo; ACPI_STATUS Status; UINT8 *TablePtr; FUNCTION_TRACE ("AcpiTbVerifyRsdp"); /* * Obtain access to the RSDP structure */ Status = AcpiOsMapMemory (RsdpPhysicalAddress, sizeof (RSDP_DESCRIPTOR), (void **) &TablePtr); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * The signature and checksum must both be correct */ if (STRNCMP ((NATIVE_CHAR *) TablePtr, RSDP_SIG, sizeof (RSDP_SIG)-1) != 0) { /* Nope, BAD Signature */ Status = AE_BAD_SIGNATURE; goto Cleanup; } if (AcpiTbChecksum (TablePtr, RSDP_CHECKSUM_LENGTH) != 0) { /* Nope, BAD Checksum */ Status = AE_BAD_CHECKSUM; goto Cleanup; } /* TBD: Check extended checksum if table version >= 2 */ /* The RSDP supplied is OK */ TableInfo.Pointer = (ACPI_TABLE_HEADER *) TablePtr; TableInfo.Length = sizeof (RSDP_DESCRIPTOR); TableInfo.Allocation = ACPI_MEM_MAPPED; TableInfo.BasePointer = TablePtr; /* Save the table pointers and allocation info */ Status = AcpiTbInitTableDescriptor (ACPI_TABLE_RSDP, &TableInfo); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* Save the RSDP in a global for easy access */ AcpiGbl_RSDP = (RSDP_DESCRIPTOR *) TableInfo.Pointer; return_ACPI_STATUS (Status); /* Error exit */ Cleanup: AcpiOsUnmapMemory (TablePtr, sizeof (RSDP_DESCRIPTOR)); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiTbGetRsdtAddress * * PARAMETERS: None * * RETURN: RSDT physical address * * DESCRIPTION: Extract the address of the RSDT or XSDT, depending on the * version of the RSDP * ******************************************************************************/ ACPI_PHYSICAL_ADDRESS AcpiTbGetRsdtAddress (void) { ACPI_PHYSICAL_ADDRESS PhysicalAddress; /* * For RSDP revision 0 or 1, we use the RSDT. * For RSDP revision 2 (and above), we use the XSDT */ if (AcpiGbl_RSDP->Revision < 2) { #ifdef _IA64 /* 0.71 RSDP has 64bit Rsdt address field */ PhysicalAddress = ((RSDP_DESCRIPTOR_REV071 *)AcpiGbl_RSDP)->RsdtPhysicalAddress; #else PhysicalAddress = (ACPI_PHYSICAL_ADDRESS) AcpiGbl_RSDP->RsdtPhysicalAddress; #endif } else { PhysicalAddress = (ACPI_PHYSICAL_ADDRESS) ACPI_GET_ADDRESS (AcpiGbl_RSDP->XsdtPhysicalAddress); } return (PhysicalAddress); } /******************************************************************************* * * FUNCTION: AcpiTbValidateRsdt * * PARAMETERS: TablePtr - Addressable pointer to the RSDT. * * RETURN: Status * * DESCRIPTION: Validate signature for the RSDT or XSDT * ******************************************************************************/ ACPI_STATUS AcpiTbValidateRsdt ( ACPI_TABLE_HEADER *TablePtr) { UINT32 NoMatch; + PROC_NAME ("TbValidateRsdt"); + /* * For RSDP revision 0 or 1, we use the RSDT. * For RSDP revision 2 (and above), we use the XSDT */ if (AcpiGbl_RSDP->Revision < 2) { NoMatch = STRNCMP ((char *) TablePtr, RSDT_SIG, sizeof (RSDT_SIG) -1); } else { NoMatch = STRNCMP ((char *) TablePtr, XSDT_SIG, sizeof (XSDT_SIG) -1); } if (NoMatch) { /* Invalid RSDT or XSDT signature */ REPORT_ERROR (("Invalid signature where RSDP indicates RSDT/XSDT should be located\n")); DUMP_BUFFER (AcpiGbl_RSDP, 20); - DEBUG_PRINT_RAW (ACPI_ERROR, - ("RSDT/XSDT signature at %X is invalid\n", + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ERROR, + "RSDT/XSDT signature at %X is invalid\n", AcpiGbl_RSDP->RsdtPhysicalAddress)); return (AE_BAD_SIGNATURE); } return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiTbGetTablePointer * * PARAMETERS: PhysicalAddress - Address from RSDT * Flags - virtual or physical addressing * TablePtr - Addressable address (output) * * RETURN: Status * * DESCRIPTION: Create an addressable pointer to an ACPI table * ******************************************************************************/ ACPI_STATUS AcpiTbGetTablePointer ( ACPI_PHYSICAL_ADDRESS PhysicalAddress, UINT32 Flags, UINT32 *Size, ACPI_TABLE_HEADER **TablePtr) { ACPI_STATUS Status; if ((Flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING) { *Size = SIZE_IN_HEADER; Status = AcpiTbMapAcpiTable (PhysicalAddress, Size, TablePtr); } else { *Size = 0; *TablePtr = (ACPI_TABLE_HEADER *) (ACPI_TBLPTR) PhysicalAddress; Status = AE_OK; } return (Status); } /******************************************************************************* * * FUNCTION: AcpiTbGetTableRsdt * * PARAMETERS: NumberOfTables - Where the table count is placed * * RETURN: Status * * DESCRIPTION: Load and validate the RSDP (ptr) and RSDT (table) * ******************************************************************************/ ACPI_STATUS AcpiTbGetTableRsdt ( UINT32 *NumberOfTables) { ACPI_TABLE_DESC TableInfo; ACPI_STATUS Status; ACPI_PHYSICAL_ADDRESS PhysicalAddress; FUNCTION_TRACE ("TbGetTableRsdt"); /* * Get the RSDT from the RSDP */ - DEBUG_PRINTP (ACPI_INFO, - ("RSDP located at %p, RSDT physical=%8.8lX%8.8lX \n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "RSDP located at %p, RSDT physical=%8.8lX%8.8lX \n", AcpiGbl_RSDP, HIDWORD(AcpiGbl_RSDP->RsdtPhysicalAddress), LODWORD(AcpiGbl_RSDP->RsdtPhysicalAddress))); PhysicalAddress = AcpiTbGetRsdtAddress (); /* Get the RSDT/XSDT */ Status = AcpiTbGetTable (PhysicalAddress, NULL, &TableInfo); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("Could not get the RSDT, %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not get the RSDT, %s\n", AcpiFormatException (Status))); return_ACPI_STATUS (Status); } /* Check the RSDT or XSDT signature */ Status = AcpiTbValidateRsdt (TableInfo.Pointer); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Valid RSDT signature, verify the checksum. If it fails, just * print a warning and ignore it. */ Status = AcpiTbVerifyTableChecksum (TableInfo.Pointer); /* Convert and/or copy to an XSDT structure */ Status = AcpiTbConvertToXsdt (&TableInfo, NumberOfTables); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Save the table pointers and allocation info */ Status = AcpiTbInitTableDescriptor (ACPI_TABLE_XSDT, &TableInfo); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } AcpiGbl_XSDT = (XSDT_DESCRIPTOR *) TableInfo.Pointer; - DEBUG_PRINTP (ACPI_INFO, ("XSDT located at %p\n", AcpiGbl_XSDT)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "XSDT located at %p\n", AcpiGbl_XSDT)); return_ACPI_STATUS (Status); } /****************************************************************************** * * FUNCTION: AcpiTbGetTableFacs * * PARAMETERS: *BufferPtr - If BufferPtr is valid, read data from * buffer rather than searching memory * *TableInfo - Where the table info is returned * * RETURN: Status * * DESCRIPTION: Returns a pointer to the FACS as defined in FADT. This * function assumes the global variable FADT has been * correctly initialized. The value of FADT->FirmwareCtrl * into a far pointer which is returned. * *****************************************************************************/ ACPI_STATUS AcpiTbGetTableFacs ( ACPI_TABLE_HEADER *BufferPtr, ACPI_TABLE_DESC *TableInfo) { ACPI_TABLE_HEADER *TablePtr = NULL; UINT32 Size; UINT8 Allocation; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("TbGetTableFacs"); /* Must have a valid FADT pointer */ if (!AcpiGbl_FADT) { return_ACPI_STATUS (AE_NO_ACPI_TABLES); } Size = sizeof (FACS_DESCRIPTOR); if (BufferPtr) { /* * Getting table from a file -- allocate a buffer and * read the table. */ TablePtr = ACPI_MEM_ALLOCATE (Size); if(!TablePtr) { return_ACPI_STATUS (AE_NO_MEMORY); } MEMCPY (TablePtr, BufferPtr, Size); /* Save allocation type */ Allocation = ACPI_MEM_ALLOCATED; } else { /* Just map the physical memory to our address space */ Status = AcpiTbMapAcpiTable ((ACPI_PHYSICAL_ADDRESS) ACPI_GET_ADDRESS (AcpiGbl_FADT->XFirmwareCtrl), &Size, &TablePtr); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Save allocation type */ Allocation = ACPI_MEM_MAPPED; } /* Return values */ TableInfo->Pointer = TablePtr; TableInfo->Length = Size; TableInfo->Allocation = Allocation; TableInfo->BasePointer = TablePtr; return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbinstal.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbinstal.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbinstal.c (revision 82367) @@ -1,677 +1,677 @@ /****************************************************************************** * * Module Name: tbinstal - ACPI table installation and removal - * $Revision: 40 $ + * $Revision: 41 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __TBINSTAL_C__ #include "acpi.h" #include "achware.h" #include "actables.h" #define _COMPONENT ACPI_TABLES MODULE_NAME ("tbinstal") /******************************************************************************* * * FUNCTION: AcpiTbInstallTable * * PARAMETERS: TablePtr - Input buffer pointer, optional * TableInfo - Return value from AcpiTbGetTable * * RETURN: Status * * DESCRIPTION: Load and validate all tables other than the RSDT. The RSDT must * already be loaded and validated. * Install the table into the global data structs. * ******************************************************************************/ ACPI_STATUS AcpiTbInstallTable ( ACPI_TABLE_HEADER *TablePtr, ACPI_TABLE_DESC *TableInfo) { ACPI_STATUS Status; FUNCTION_TRACE ("TbInstallTable"); /* * Check the table signature and make sure it is recognized * Also checks the header checksum */ Status = AcpiTbRecognizeTable (TablePtr, TableInfo); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Lock tables while installing */ AcpiUtAcquireMutex (ACPI_MTX_TABLES); /* Install the table into the global data structure */ Status = AcpiTbInitTableDescriptor (TableInfo->Type, TableInfo); - DEBUG_PRINTP (ACPI_INFO, ("%s located at %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s located at %p\n", AcpiGbl_AcpiTableData[TableInfo->Type].Name, TableInfo->Pointer)); AcpiUtReleaseMutex (ACPI_MTX_TABLES); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiTbRecognizeTable * * PARAMETERS: TablePtr - Input buffer pointer, optional * TableInfo - Return value from AcpiTbGetTable * * RETURN: Status * * DESCRIPTION: Check a table signature for a match against known table types * * NOTE: All table pointers are validated as follows: * 1) Table pointer must point to valid physical memory * 2) Signature must be 4 ASCII chars, even if we don't recognize the * name * 3) Table must be readable for length specified in the header * 4) Table checksum must be valid (with the exception of the FACS * which has no checksum for some odd reason) * ******************************************************************************/ ACPI_STATUS AcpiTbRecognizeTable ( ACPI_TABLE_HEADER *TablePtr, ACPI_TABLE_DESC *TableInfo) { ACPI_TABLE_HEADER *TableHeader; ACPI_STATUS Status; ACPI_TABLE_TYPE TableType = 0; UINT32 i; FUNCTION_TRACE ("TbRecognizeTable"); /* Ensure that we have a valid table pointer */ TableHeader = (ACPI_TABLE_HEADER *) TableInfo->Pointer; if (!TableHeader) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* * Search for a signature match among the known table types * Start at index one -> Skip the RSDP */ Status = AE_SUPPORT; for (i = 1; i < NUM_ACPI_TABLES; i++) { if (!STRNCMP (TableHeader->Signature, AcpiGbl_AcpiTableData[i].Signature, AcpiGbl_AcpiTableData[i].SigLength)) { /* * Found a signature match, get the pertinent info from the * TableData structure */ TableType = i; Status = AcpiGbl_AcpiTableData[i].Status; - DEBUG_PRINTP (ACPI_INFO, ("Found %4.4s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Found %4.4s\n", AcpiGbl_AcpiTableData[i].Signature)); break; } } /* Return the table type and length via the info struct */ TableInfo->Type = (UINT8) TableType; TableInfo->Length = TableHeader->Length; /* * Validate checksum for _most_ tables, * even the ones whose signature we don't recognize */ if (TableType != ACPI_TABLE_FACS) { /* But don't abort if the checksum is wrong */ /* TBD: [Future] make this a configuration option? */ AcpiTbVerifyTableChecksum (TableHeader); } /* * An AE_SUPPORT means that the table was not recognized. * We basically ignore this; just print a debug message */ if (Status == AE_SUPPORT) { - DEBUG_PRINTP (ACPI_INFO, - ("Unsupported table %s (Type %X) was found and discarded\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Unsupported table %s (Type %X) was found and discarded\n", AcpiGbl_AcpiTableData[TableType].Name, TableType)); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiTbInitTableDescriptor * * PARAMETERS: TableType - The type of the table * TableInfo - A table info struct * * RETURN: None. * * DESCRIPTION: Install a table into the global data structs. * ******************************************************************************/ ACPI_STATUS AcpiTbInitTableDescriptor ( ACPI_TABLE_TYPE TableType, ACPI_TABLE_DESC *TableInfo) { ACPI_TABLE_DESC *ListHead; ACPI_TABLE_DESC *TableDesc; FUNCTION_TRACE_U32 ("TbInitTableDescriptor", TableType); /* * Install the table into the global data structure */ ListHead = &AcpiGbl_AcpiTables[TableType]; TableDesc = ListHead; /* * Two major types of tables: 1) Only one instance is allowed. This * includes most ACPI tables such as the DSDT. 2) Multiple instances of * the table are allowed. This includes SSDT and PSDTs. */ if (IS_SINGLE_TABLE (AcpiGbl_AcpiTableData[TableType].Flags)) { /* * Only one table allowed, and a table has alread been installed * at this location, so return an error. */ if (ListHead->Pointer) { return_ACPI_STATUS (AE_EXIST); } TableDesc->Count = 1; } else { /* * Multiple tables allowed for this table type, we must link * the new table in to the list of tables of this type. */ if (ListHead->Pointer) { TableDesc = ACPI_MEM_CALLOCATE (sizeof (ACPI_TABLE_DESC)); if (!TableDesc) { return_ACPI_STATUS (AE_NO_MEMORY); } ListHead->Count++; /* Update the original previous */ ListHead->Prev->Next = TableDesc; /* Update new entry */ TableDesc->Prev = ListHead->Prev; TableDesc->Next = ListHead; /* Update list head */ ListHead->Prev = TableDesc; } else { TableDesc->Count = 1; } } /* Common initialization of the table descriptor */ TableDesc->Pointer = TableInfo->Pointer; TableDesc->BasePointer = TableInfo->BasePointer; TableDesc->Length = TableInfo->Length; TableDesc->Allocation = TableInfo->Allocation; TableDesc->AmlPointer = (UINT8 *) (TableDesc->Pointer + 1), TableDesc->AmlLength = (UINT32) (TableDesc->Length - (UINT32) sizeof (ACPI_TABLE_HEADER)); TableDesc->TableId = AcpiUtAllocateOwnerId (OWNER_TYPE_TABLE); TableDesc->LoadedIntoNamespace = FALSE; /* * Set the appropriate global pointer (if there is one) to point to the * newly installed table */ if (AcpiGbl_AcpiTableData[TableType].GlobalPtr) { *(AcpiGbl_AcpiTableData[TableType].GlobalPtr) = TableInfo->Pointer; } /* Return Data */ TableInfo->TableId = TableDesc->TableId; TableInfo->InstalledDesc = TableDesc; return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiTbDeleteAcpiTables * * PARAMETERS: None. * * RETURN: None. * * DESCRIPTION: Delete all internal ACPI tables * ******************************************************************************/ void AcpiTbDeleteAcpiTables (void) { ACPI_TABLE_TYPE Type; /* * Free memory allocated for ACPI tables * Memory can either be mapped or allocated */ for (Type = 0; Type < NUM_ACPI_TABLES; Type++) { AcpiTbDeleteAcpiTable (Type); } } /******************************************************************************* * * FUNCTION: AcpiTbDeleteAcpiTable * * PARAMETERS: Type - The table type to be deleted * * RETURN: None. * * DESCRIPTION: Delete an internal ACPI table * Locks the ACPI table mutex * ******************************************************************************/ void AcpiTbDeleteAcpiTable ( ACPI_TABLE_TYPE Type) { FUNCTION_TRACE_U32 ("TbDeleteAcpiTable", Type); if (Type > ACPI_TABLE_MAX) { return_VOID; } AcpiUtAcquireMutex (ACPI_MTX_TABLES); /* Free the table */ AcpiTbFreeAcpiTablesOfType (&AcpiGbl_AcpiTables[Type]); /* Clear the appropriate "typed" global table pointer */ switch (Type) { case ACPI_TABLE_RSDP: AcpiGbl_RSDP = NULL; break; case ACPI_TABLE_DSDT: AcpiGbl_DSDT = NULL; break; case ACPI_TABLE_FADT: AcpiGbl_FADT = NULL; break; case ACPI_TABLE_FACS: AcpiGbl_FACS = NULL; break; case ACPI_TABLE_XSDT: AcpiGbl_XSDT = NULL; break; case ACPI_TABLE_SSDT: case ACPI_TABLE_PSDT: default: break; } AcpiUtReleaseMutex (ACPI_MTX_TABLES); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiTbFreeAcpiTablesOfType * * PARAMETERS: TableInfo - A table info struct * * RETURN: None. * * DESCRIPTION: Free the memory associated with an internal ACPI table * Table mutex should be locked. * ******************************************************************************/ void AcpiTbFreeAcpiTablesOfType ( ACPI_TABLE_DESC *ListHead) { ACPI_TABLE_DESC *TableDesc; UINT32 Count; UINT32 i; FUNCTION_TRACE_PTR ("TbFreeAcpiTablesOfType", ListHead); /* Get the head of the list */ TableDesc = ListHead; Count = ListHead->Count; /* * Walk the entire list, deleting both the allocated tables * and the table descriptors */ for (i = 0; i < Count; i++) { TableDesc = AcpiTbUninstallTable (TableDesc); } return_VOID; } /******************************************************************************* * * FUNCTION: AcpiTbDeleteSingleTable * * PARAMETERS: TableInfo - A table info struct * * RETURN: None. * * DESCRIPTION: Low-level free for a single ACPI table. Handles cases where * the table was allocated a buffer or was mapped. * ******************************************************************************/ void AcpiTbDeleteSingleTable ( ACPI_TABLE_DESC *TableDesc) { if (!TableDesc) { return; } if (TableDesc->Pointer) { /* Valid table, determine type of memory allocation */ switch (TableDesc->Allocation) { case ACPI_MEM_NOT_ALLOCATED: break; case ACPI_MEM_ALLOCATED: ACPI_MEM_FREE (TableDesc->BasePointer); break; case ACPI_MEM_MAPPED: AcpiOsUnmapMemory (TableDesc->BasePointer, TableDesc->Length); break; } } } /******************************************************************************* * * FUNCTION: AcpiTbUninstallTable * * PARAMETERS: TableInfo - A table info struct * * RETURN: None. * * DESCRIPTION: Free the memory associated with an internal ACPI table that * is either installed or has never been installed. * Table mutex should be locked. * ******************************************************************************/ ACPI_TABLE_DESC * AcpiTbUninstallTable ( ACPI_TABLE_DESC *TableDesc) { ACPI_TABLE_DESC *NextDesc; FUNCTION_TRACE_PTR ("TbDeleteSingleTable", TableDesc); if (!TableDesc) { return_PTR (NULL); } /* Unlink the descriptor */ if (TableDesc->Prev) { TableDesc->Prev->Next = TableDesc->Next; } if (TableDesc->Next) { TableDesc->Next->Prev = TableDesc->Prev; } /* Free the memory allocated for the table itself */ AcpiTbDeleteSingleTable (TableDesc); /* Free the table descriptor (Don't delete the list head, tho) */ if ((TableDesc->Prev) == (TableDesc->Next)) { NextDesc = NULL; /* Clear the list head */ TableDesc->Pointer = NULL; TableDesc->Length = 0; TableDesc->Count = 0; } else { /* Free the table descriptor */ NextDesc = TableDesc->Next; ACPI_MEM_FREE (TableDesc); } return_PTR (NextDesc); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbutils.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbutils.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbutils.c (revision 82367) @@ -1,489 +1,494 @@ /****************************************************************************** * * Module Name: tbutils - Table manipulation utilities - * $Revision: 38 $ + * $Revision: 39 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __TBUTILS_C__ #include "acpi.h" #include "actables.h" #include "acinterp.h" #define _COMPONENT ACPI_TABLES MODULE_NAME ("tbutils") /******************************************************************************* * * FUNCTION: AcpiTbHandleToObject * * PARAMETERS: TableId - Id for which the function is searching * TableDesc - Pointer to return the matching table * descriptor. * * RETURN: Search the tables to find one with a matching TableId and * return a pointer to that table descriptor. * ******************************************************************************/ ACPI_STATUS AcpiTbHandleToObject ( UINT16 TableId, ACPI_TABLE_DESC **TableDesc) { UINT32 i; ACPI_TABLE_DESC *ListHead; + PROC_NAME ("TbHandleToObject"); + for (i = 0; i < ACPI_TABLE_MAX; i++) { ListHead = &AcpiGbl_AcpiTables[i]; do { if (ListHead->TableId == TableId) { *TableDesc = ListHead; return (AE_OK); } ListHead = ListHead->Next; } while (ListHead != &AcpiGbl_AcpiTables[i]); } - DEBUG_PRINT (ACPI_ERROR, ("TableId=%X does not exist\n", TableId)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "TableId=%X does not exist\n", TableId)); return (AE_BAD_PARAMETER); } /******************************************************************************* * * FUNCTION: AcpiTbSystemTablePointer * * PARAMETERS: *Where - Pointer to be examined * * RETURN: TRUE if Where is within the AML stream (in one of the ACPI * system tables such as the DSDT or an SSDT.) * FALSE otherwise * ******************************************************************************/ BOOLEAN AcpiTbSystemTablePointer ( void *Where) { UINT32 i; ACPI_TABLE_DESC *TableDesc; ACPI_TABLE_HEADER *Table; /* No function trace, called too often! */ /* Ignore null pointer */ if (!Where) { return (FALSE); } /* Check for a pointer within the DSDT */ if ((AcpiGbl_DSDT) && (IS_IN_ACPI_TABLE (Where, AcpiGbl_DSDT))) { return (TRUE); } /* Check each of the loaded SSDTs (if any)*/ TableDesc = &AcpiGbl_AcpiTables[ACPI_TABLE_SSDT]; for (i = 0; i < AcpiGbl_AcpiTables[ACPI_TABLE_SSDT].Count; i++) { Table = TableDesc->Pointer; if (IS_IN_ACPI_TABLE (Where, Table)) { return (TRUE); } TableDesc = TableDesc->Next; } /* Check each of the loaded PSDTs (if any)*/ TableDesc = &AcpiGbl_AcpiTables[ACPI_TABLE_PSDT]; for (i = 0; i < AcpiGbl_AcpiTables[ACPI_TABLE_PSDT].Count; i++) { Table = TableDesc->Pointer; if (IS_IN_ACPI_TABLE (Where, Table)) { return (TRUE); } TableDesc = TableDesc->Next; } /* Pointer does not point into any system table */ return (FALSE); } /******************************************************************************* * * FUNCTION: AcpiTbValidateTableHeader * * PARAMETERS: TableHeader - Logical pointer to the table * * RETURN: Status * * DESCRIPTION: Check an ACPI table header for validity * * NOTE: Table pointers are validated as follows: * 1) Table pointer must point to valid physical memory * 2) Signature must be 4 ASCII chars, even if we don't recognize the * name * 3) Table must be readable for length specified in the header * 4) Table checksum must be valid (with the exception of the FACS * which has no checksum for some odd reason) * ******************************************************************************/ ACPI_STATUS AcpiTbValidateTableHeader ( ACPI_TABLE_HEADER *TableHeader) { ACPI_NAME Signature; PROC_NAME ("TbValidateTableHeader"); /* Verify that this is a valid address */ if (!AcpiOsReadable (TableHeader, sizeof (ACPI_TABLE_HEADER))) { - DEBUG_PRINTP (ACPI_ERROR, - ("Cannot read table header at %p\n", TableHeader)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Cannot read table header at %p\n", TableHeader)); return (AE_BAD_ADDRESS); } /* Ensure that the signature is 4 ASCII characters */ MOVE_UNALIGNED32_TO_32 (&Signature, &TableHeader->Signature); if (!AcpiUtValidAcpiName (Signature)) { - DEBUG_PRINTP (ACPI_ERROR, - ("Table signature at %p [%X] has invalid characters\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Table signature at %p [%X] has invalid characters\n", TableHeader, &Signature)); REPORT_WARNING (("Invalid table signature %4.4s found\n", &Signature)); DUMP_BUFFER (TableHeader, sizeof (ACPI_TABLE_HEADER)); return (AE_BAD_SIGNATURE); } /* Validate the table length */ if (TableHeader->Length < sizeof (ACPI_TABLE_HEADER)) { - DEBUG_PRINTP (ACPI_ERROR, - ("Invalid length in table header %p name %4.4s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Invalid length in table header %p name %4.4s\n", TableHeader, &Signature)); REPORT_WARNING (("Invalid table header length found\n")); DUMP_BUFFER (TableHeader, sizeof (ACPI_TABLE_HEADER)); return (AE_BAD_HEADER); } return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiTbMapAcpiTable * * PARAMETERS: PhysicalAddress - Physical address of table to map * *Size - Size of the table. If zero, the size * from the table header is used. * Actual size is returned here. * **LogicalAddress - Logical address of mapped table * * RETURN: Logical address of the mapped table. * * DESCRIPTION: Maps the physical address of table into a logical address * ******************************************************************************/ ACPI_STATUS AcpiTbMapAcpiTable ( ACPI_PHYSICAL_ADDRESS PhysicalAddress, UINT32 *Size, ACPI_TABLE_HEADER **LogicalAddress) { ACPI_TABLE_HEADER *Table; UINT32 TableSize = *Size; ACPI_STATUS Status = AE_OK; + PROC_NAME ("TbMapAcpiTable"); + + /* If size is zero, look at the table header to get the actual size */ if ((*Size) == 0) { /* Get the table header so we can extract the table length */ Status = AcpiOsMapMemory (PhysicalAddress, sizeof (ACPI_TABLE_HEADER), (void **) &Table); if (ACPI_FAILURE (Status)) { return (Status); } /* Extract the full table length before we delete the mapping */ TableSize = Table->Length; /* * Validate the header and delete the mapping. * We will create a mapping for the full table below. */ Status = AcpiTbValidateTableHeader (Table); /* Always unmap the memory for the header */ AcpiOsUnmapMemory (Table, sizeof (ACPI_TABLE_HEADER)); /* Exit if header invalid */ if (ACPI_FAILURE (Status)) { return (Status); } } /* Map the physical memory for the correct length */ Status = AcpiOsMapMemory (PhysicalAddress, TableSize, (void **) &Table); if (ACPI_FAILURE (Status)) { return (Status); } - DEBUG_PRINT (ACPI_INFO, - ("Mapped memory for ACPI table, length=%d(%X) at %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Mapped memory for ACPI table, length=%d(%X) at %p\n", TableSize, TableSize, Table)); *Size = TableSize; *LogicalAddress = Table; return (Status); } /******************************************************************************* * * FUNCTION: AcpiTbVerifyTableChecksum * * PARAMETERS: *TableHeader - ACPI table to verify * * RETURN: 8 bit checksum of table * * DESCRIPTION: Does an 8 bit checksum of table and returns status. A correct * table should have a checksum of 0. * ******************************************************************************/ ACPI_STATUS AcpiTbVerifyTableChecksum ( ACPI_TABLE_HEADER *TableHeader) { UINT8 Checksum; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("TbVerifyTableChecksum"); /* Compute the checksum on the table */ Checksum = AcpiTbChecksum (TableHeader, TableHeader->Length); /* Return the appropriate exception */ if (Checksum) { REPORT_WARNING (("Invalid checksum (%X) in table %4.4s\n", Checksum, &TableHeader->Signature)); Status = AE_BAD_CHECKSUM; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiTbChecksum * * PARAMETERS: Buffer - Buffer to checksum * Length - Size of the buffer * * RETURNS 8 bit checksum of buffer * * DESCRIPTION: Computes an 8 bit checksum of the buffer(length) and returns it. * ******************************************************************************/ UINT8 AcpiTbChecksum ( void *Buffer, UINT32 Length) { UINT8 *limit; UINT8 *rover; UINT8 sum = 0; if (Buffer && Length) { /* Buffer and Length are valid */ limit = (UINT8 *) Buffer + Length; for (rover = Buffer; rover < limit; rover++) { sum = (UINT8) (sum + *rover); } } return (sum); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbxface.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbxface.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbxface.c (revision 82367) @@ -1,562 +1,562 @@ /****************************************************************************** * * Module Name: tbxface - Public interfaces to the ACPI subsystem * ACPI table oriented interfaces - * $Revision: 41 $ + * $Revision: 42 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __TBXFACE_C__ #include "acpi.h" #include "acnamesp.h" #include "acinterp.h" #include "actables.h" #define _COMPONENT ACPI_TABLES MODULE_NAME ("tbxface") /******************************************************************************* * * FUNCTION: AcpiLoadTables * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: This function is called to load the ACPI tables from the * provided RSDT * ******************************************************************************/ ACPI_STATUS AcpiLoadTables (void) { ACPI_PHYSICAL_ADDRESS RsdpPhysicalAddress; ACPI_STATUS Status; UINT32 NumberOfTables = 0; FUNCTION_TRACE ("AcpiLoadTables"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Get the RSDP */ Status = AcpiOsGetRootPointer (ACPI_LOGICAL_ADDRESSING, &RsdpPhysicalAddress); if (ACPI_FAILURE (Status)) { REPORT_ERROR (("AcpiLoadTables: Could not get RSDP, %s\n", AcpiFormatException (Status))); goto ErrorExit; } /* Map and validate the RSDP */ Status = AcpiTbVerifyRsdp (RsdpPhysicalAddress); if (ACPI_FAILURE (Status)) { REPORT_ERROR (("AcpiLoadTables: RSDP Failed validation: %s\n", AcpiFormatException (Status))); goto ErrorExit; } /* Get the RSDT via the RSDP */ Status = AcpiTbGetTableRsdt (&NumberOfTables); if (ACPI_FAILURE (Status)) { REPORT_ERROR (("AcpiLoadTables: Could not load RSDT: %s\n", AcpiFormatException (Status))); goto ErrorExit; } /* Now get the rest of the tables */ Status = AcpiTbGetAllTables (NumberOfTables, NULL); if (ACPI_FAILURE (Status)) { REPORT_ERROR (("AcpiLoadTables: Error getting required tables (DSDT/FADT/FACS): %s\n", AcpiFormatException (Status))); goto ErrorExit; } - DEBUG_PRINTP (ACPI_OK, ("ACPI Tables successfully loaded\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_OK, "ACPI Tables successfully loaded\n")); /* Load the namespace from the tables */ Status = AcpiNsLoadNamespace (); if (ACPI_FAILURE (Status)) { REPORT_ERROR (("AcpiLoadTables: Could not load namespace: %s\n", AcpiFormatException (Status))); goto ErrorExit; } return_ACPI_STATUS (AE_OK); ErrorExit: REPORT_ERROR (("AcpiLoadTables: Could not load tables: %s\n", AcpiFormatException (Status))); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiLoadTable * * PARAMETERS: TablePtr - pointer to a buffer containing the entire * table to be loaded * * RETURN: Status * * DESCRIPTION: This function is called to load a table from the caller's * buffer. The buffer must contain an entire ACPI Table including * a valid header. The header fields will be verified, and if it * is determined that the table is invalid, the call will fail. * ******************************************************************************/ ACPI_STATUS AcpiLoadTable ( ACPI_TABLE_HEADER *TablePtr) { ACPI_STATUS Status; ACPI_TABLE_DESC TableInfo; FUNCTION_TRACE ("AcpiLoadTable"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } if (!TablePtr) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Copy the table to a local buffer */ Status = AcpiTbGetTable (0, TablePtr, &TableInfo); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Install the new table into the local data structures */ Status = AcpiTbInstallTable (NULL, &TableInfo); if (ACPI_FAILURE (Status)) { /* Free table allocated by AcpiTbGetTable */ AcpiTbDeleteSingleTable (&TableInfo); return_ACPI_STATUS (Status); } Status = AcpiNsLoadTable (TableInfo.InstalledDesc, AcpiGbl_RootNode); if (ACPI_FAILURE (Status)) { /* Uninstall table and free the buffer */ AcpiTbUninstallTable (TableInfo.InstalledDesc); return_ACPI_STATUS (Status); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUnloadTable * * PARAMETERS: TableType - Type of table to be unloaded * * RETURN: Status * * DESCRIPTION: This routine is used to force the unload of a table * ******************************************************************************/ ACPI_STATUS AcpiUnloadTable ( ACPI_TABLE_TYPE TableType) { ACPI_TABLE_DESC *ListHead; ACPI_STATUS Status; FUNCTION_TRACE ("AcpiUnloadTable"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Parameter validation */ if (TableType > ACPI_TABLE_MAX) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Find all tables of the requested type */ ListHead = &AcpiGbl_AcpiTables[TableType]; do { /* * Delete all namespace entries owned by this table. Note that these * entries can appear anywhere in the namespace by virtue of the AML * "Scope" operator. Thus, we need to track ownership by an ID, not * simply a position within the hierarchy */ AcpiNsDeleteNamespaceByOwner (ListHead->TableId); /* Delete (or unmap) the actual table */ AcpiTbDeleteAcpiTable (TableType); } while (ListHead != &AcpiGbl_AcpiTables[TableType]); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiGetTableHeader * * PARAMETERS: TableType - one of the defined table types * Instance - the non zero instance of the table, allows * support for multiple tables of the same type * see AcpiGbl_AcpiTableFlag * OutTableHeader - pointer to the ACPI_TABLE_HEADER if successful * * DESCRIPTION: This function is called to get an ACPI table header. The caller * supplies an pointer to a data area sufficient to contain an ACPI * ACPI_TABLE_HEADER structure. * * The header contains a length field that can be used to determine * the size of the buffer needed to contain the entire table. This * function is not valid for the RSD PTR table since it does not * have a standard header and is fixed length. * ******************************************************************************/ ACPI_STATUS AcpiGetTableHeader ( ACPI_TABLE_TYPE TableType, UINT32 Instance, ACPI_TABLE_HEADER *OutTableHeader) { ACPI_TABLE_HEADER *TblPtr; ACPI_STATUS Status; FUNCTION_TRACE ("AcpiGetTableHeader"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } if ((Instance == 0) || (TableType == ACPI_TABLE_RSDP) || (!OutTableHeader)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Check the table type and instance */ if ((TableType > ACPI_TABLE_MAX) || (IS_SINGLE_TABLE (AcpiGbl_AcpiTableData[TableType].Flags) && Instance > 1)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Get a pointer to the entire table */ Status = AcpiTbGetTablePtr (TableType, Instance, &TblPtr); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * The function will return a NULL pointer if the table is not loaded */ if (TblPtr == NULL) { return_ACPI_STATUS (AE_NOT_EXIST); } /* * Copy the header to the caller's buffer */ MEMCPY ((void *) OutTableHeader, (void *) TblPtr, sizeof (ACPI_TABLE_HEADER)); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiGetTable * * PARAMETERS: TableType - one of the defined table types * Instance - the non zero instance of the table, allows * support for multiple tables of the same type * see AcpiGbl_AcpiTableFlag * RetBuffer - pointer to a structure containing a buffer to * receive the table * * RETURN: Status * * DESCRIPTION: This function is called to get an ACPI table. The caller * supplies an OutBuffer large enough to contain the entire ACPI * table. The caller should call the AcpiGetTableHeader function * first to determine the buffer size needed. Upon completion * the OutBuffer->Length field will indicate the number of bytes * copied into the OutBuffer->BufPtr buffer. This table will be * a complete table including the header. * ******************************************************************************/ ACPI_STATUS AcpiGetTable ( ACPI_TABLE_TYPE TableType, UINT32 Instance, ACPI_BUFFER *RetBuffer) { ACPI_TABLE_HEADER *TblPtr; ACPI_STATUS Status; UINT32 RetBufLen; FUNCTION_TRACE ("AcpiGetTable"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * If we have a buffer, we must have a length too */ if ((Instance == 0) || (!RetBuffer) || ((!RetBuffer->Pointer) && (RetBuffer->Length))) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Check the table type and instance */ if ((TableType > ACPI_TABLE_MAX) || (IS_SINGLE_TABLE (AcpiGbl_AcpiTableData[TableType].Flags) && Instance > 1)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Get a pointer to the entire table */ Status = AcpiTbGetTablePtr (TableType, Instance, &TblPtr); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * AcpiTbGetTablePtr will return a NULL pointer if the * table is not loaded. */ if (TblPtr == NULL) { return_ACPI_STATUS (AE_NOT_EXIST); } /* * Got a table ptr, assume it's ok and copy it to the user's buffer */ if (TableType == ACPI_TABLE_RSDP) { /* * RSD PTR is the only "table" without a header */ RetBufLen = sizeof (RSDP_DESCRIPTOR); } else { RetBufLen = TblPtr->Length; } /* * Verify we have space in the caller's buffer for the table */ if (RetBuffer->Length < RetBufLen) { RetBuffer->Length = RetBufLen; return_ACPI_STATUS (AE_BUFFER_OVERFLOW); } RetBuffer->Length = RetBufLen; MEMCPY ((void *) RetBuffer->Pointer, (void *) TblPtr, RetBufLen); return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbxfroot.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbxfroot.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/tbxfroot.c (revision 82367) @@ -1,511 +1,511 @@ /****************************************************************************** * * Module Name: tbxfroot - Find the root ACPI table (RSDT) - * $Revision: 46 $ + * $Revision: 47 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __TBXFROOT_C__ #include "acpi.h" #include "achware.h" #include "actables.h" #define _COMPONENT ACPI_TABLES MODULE_NAME ("tbxfroot") #define RSDP_CHECKSUM_LENGTH 20 /******************************************************************************* * * FUNCTION: AcpiFindRootPointer * * PARAMETERS: **RsdpPhysicalAddress - Where to place the RSDP address * Flags - Logical/Physical addressing * * RETURN: Status, Physical address of the RSDP * * DESCRIPTION: Find the RSDP * ******************************************************************************/ ACPI_STATUS AcpiFindRootPointer ( UINT32 Flags, ACPI_PHYSICAL_ADDRESS *RsdpPhysicalAddress) { ACPI_TABLE_DESC TableInfo; ACPI_STATUS Status; FUNCTION_TRACE ("AcpiFindRootPointer"); /* Get the RSDP */ Status = AcpiTbFindRsdp (&TableInfo, Flags); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("RSDP structure not found\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "RSDP structure not found\n")); return_ACPI_STATUS (AE_NO_ACPI_TABLES); } *RsdpPhysicalAddress = TableInfo.PhysicalAddress; return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiTbScanMemoryForRsdp * * PARAMETERS: StartAddress - Starting pointer for search * Length - Maximum length to search * * RETURN: Pointer to the RSDP if found, otherwise NULL. * * DESCRIPTION: Search a block of memory for the RSDP signature * ******************************************************************************/ UINT8 * AcpiTbScanMemoryForRsdp ( UINT8 *StartAddress, UINT32 Length) { UINT32 Offset; UINT8 *MemRover; FUNCTION_TRACE ("TbScanMemoryForRsdp"); /* Search from given start addr for the requested length */ for (Offset = 0, MemRover = StartAddress; Offset < Length; Offset += RSDP_SCAN_STEP, MemRover += RSDP_SCAN_STEP) { /* The signature and checksum must both be correct */ if (STRNCMP ((NATIVE_CHAR *) MemRover, RSDP_SIG, sizeof (RSDP_SIG)-1) == 0 && AcpiTbChecksum (MemRover, RSDP_CHECKSUM_LENGTH) == 0) { /* If so, we have found the RSDP */ - DEBUG_PRINTP (ACPI_INFO, - ("RSDP located at physical address %p\n",MemRover)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "RSDP located at physical address %p\n",MemRover)); return_PTR (MemRover); } } /* Searched entire block, no RSDP was found */ - DEBUG_PRINTP (ACPI_INFO,("Searched entire block, no RSDP was found.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO,"Searched entire block, no RSDP was found.\n")); return_PTR (NULL); } /******************************************************************************* * * FUNCTION: AcpiTbFindRsdp * * PARAMETERS: *TableInfo - Where the table info is returned * Flags - Current memory mode (logical vs. * physical addressing) * * RETURN: Status * * DESCRIPTION: Search lower 1Mbyte of memory for the root system descriptor * pointer structure. If it is found, set *RSDP to point to it. * * NOTE: The RSDP must be either in the first 1K of the Extended * BIOS Data Area or between E0000 and FFFFF (ACPI 1.0 section * 5.2.2; assertion #421). * ******************************************************************************/ ACPI_STATUS AcpiTbFindRsdp ( ACPI_TABLE_DESC *TableInfo, UINT32 Flags) { UINT8 *TablePtr; UINT8 *MemRover; UINT64 PhysAddr; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("TbFindRsdp"); /* * Scan supports either 1) Logical addressing or 2) Physical addressing */ if ((Flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING) { /* * 1) Search EBDA (low memory) paragraphs */ Status = AcpiOsMapMemory (LO_RSDP_WINDOW_BASE, LO_RSDP_WINDOW_SIZE, (void **) &TablePtr); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } MemRover = AcpiTbScanMemoryForRsdp (TablePtr, LO_RSDP_WINDOW_SIZE); AcpiOsUnmapMemory (TablePtr, LO_RSDP_WINDOW_SIZE); if (MemRover) { /* Found it, return the physical address */ PhysAddr = LO_RSDP_WINDOW_BASE; PhysAddr += (MemRover - TablePtr); TableInfo->PhysicalAddress = PhysAddr; return_ACPI_STATUS (AE_OK); } /* * 2) Search upper memory: 16-byte boundaries in E0000h-F0000h */ Status = AcpiOsMapMemory (HI_RSDP_WINDOW_BASE, HI_RSDP_WINDOW_SIZE, (void **) &TablePtr); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } MemRover = AcpiTbScanMemoryForRsdp (TablePtr, HI_RSDP_WINDOW_SIZE); AcpiOsUnmapMemory (TablePtr, HI_RSDP_WINDOW_SIZE); if (MemRover) { /* Found it, return the physical address */ PhysAddr = HI_RSDP_WINDOW_BASE; PhysAddr += (MemRover - TablePtr); TableInfo->PhysicalAddress = PhysAddr; return_ACPI_STATUS (AE_OK); } } /* * Physical addressing */ else { /* * 1) Search EBDA (low memory) paragraphs */ MemRover = AcpiTbScanMemoryForRsdp ((UINT8 *) LO_RSDP_WINDOW_BASE, LO_RSDP_WINDOW_SIZE); if (MemRover) { /* Found it, return the physical address */ TableInfo->PhysicalAddress = (ACPI_TBLPTR) MemRover; return_ACPI_STATUS (AE_OK); } /* * 2) Search upper memory: 16-byte boundaries in E0000h-F0000h */ MemRover = AcpiTbScanMemoryForRsdp ((UINT8 *) HI_RSDP_WINDOW_BASE, HI_RSDP_WINDOW_SIZE); if (MemRover) { /* Found it, return the physical address */ TableInfo->PhysicalAddress = (ACPI_TBLPTR) MemRover; return_ACPI_STATUS (AE_OK); } } /* RSDP signature was not found */ return_ACPI_STATUS (AE_NOT_FOUND); } /******************************************************************************* * * FUNCTION: AcpiGetFirmwareTable * * PARAMETERS: Signature - Any ACPI table signature * Instance - the non zero instance of the table, allows * support for multiple tables of the same type * Flags - 0: Physical/Virtual support * RetBuffer - pointer to a structure containing a buffer to * receive the table * * RETURN: Status * * DESCRIPTION: This function is called to get an ACPI table. The caller * supplies an OutBuffer large enough to contain the entire ACPI * table. Upon completion * the OutBuffer->Length field will indicate the number of bytes * copied into the OutBuffer->BufPtr buffer. This table will be * a complete table including the header. * ******************************************************************************/ ACPI_STATUS AcpiGetFirmwareTable ( ACPI_STRING Signature, UINT32 Instance, UINT32 Flags, ACPI_TABLE_HEADER **TablePointer) { ACPI_PHYSICAL_ADDRESS PhysicalAddress; ACPI_TABLE_HEADER *RsdtPtr; ACPI_TABLE_HEADER *TablePtr; ACPI_STATUS Status; UINT32 RsdtSize; UINT32 TableSize; UINT32 TableCount; UINT32 i; UINT32 j; FUNCTION_TRACE ("AcpiGetFirmwareTable"); /* * Ensure that at least the table manager is initialized. We don't * require that the entire ACPI subsystem is up for this interface */ /* * If we have a buffer, we must have a length too */ if ((Instance == 0) || (!Signature) || (!TablePointer)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Get the RSDP */ Status = AcpiOsGetRootPointer (Flags, &PhysicalAddress); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_INFO, ("RSDP not found\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "RSDP not found\n")); return_ACPI_STATUS (AE_NO_ACPI_TABLES); } AcpiGbl_RSDP = (RSDP_DESCRIPTOR *) (ACPI_TBLPTR) PhysicalAddress; - DEBUG_PRINTP (ACPI_INFO, - ("RSDP located at %p, RSDT physical=%8.8lX%8.8lX \n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "RSDP located at %p, RSDT physical=%8.8lX%8.8lX \n", AcpiGbl_RSDP, HIDWORD(AcpiGbl_RSDP->RsdtPhysicalAddress), LODWORD(AcpiGbl_RSDP->RsdtPhysicalAddress))); /* Get the RSDT and validate it */ PhysicalAddress = AcpiTbGetRsdtAddress (); Status = AcpiTbGetTablePointer (PhysicalAddress, Flags, &RsdtSize, &RsdtPtr); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } Status = AcpiTbValidateRsdt (RsdtPtr); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* Get the number of table pointers within the RSDT */ TableCount = AcpiTbGetTableCount (AcpiGbl_RSDP, RsdtPtr); /* * Search the RSDT/XSDT for the correct instance of the * requested table */ for (i = 0, j = 0; i < TableCount; i++) { /* Get the next table pointer */ if (AcpiGbl_RSDP->Revision < 2) { PhysicalAddress = ((RSDT_DESCRIPTOR *) RsdtPtr)->TableOffsetEntry[i]; } else { PhysicalAddress = (ACPI_PHYSICAL_ADDRESS) ACPI_GET_ADDRESS (((XSDT_DESCRIPTOR *) RsdtPtr)->TableOffsetEntry[i]); } /* Get addressibility if necessary */ Status = AcpiTbGetTablePointer (PhysicalAddress, Flags, &TableSize, &TablePtr); if (ACPI_FAILURE (Status)) { goto Cleanup; } /* Compare table signatures and table instance */ if (!STRNCMP ((char *) TablePtr, Signature, STRLEN (Signature))) { /* An instance of the table was found */ j++; if (j >= Instance) { /* Found the correct instance */ *TablePointer = TablePtr; goto Cleanup; } } /* Delete table mapping if using virtual addressing */ if (TableSize) { AcpiOsUnmapMemory (TablePtr, TableSize); } } /* Did not find the table */ Status = AE_NOT_EXIST; Cleanup: if (RsdtSize) { AcpiOsUnmapMemory (RsdtPtr, RsdtSize); } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/utalloc.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/utalloc.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/utalloc.c (revision 82367) @@ -1,788 +1,848 @@ /****************************************************************************** * - * Module Name: utalloc - local memory allocation routines - * $Revision: 93 $ + * Module Name: utalloc - local cache and memory allocation routines + * $Revision: 95 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __UTALLOC_C__ #include "acpi.h" #include "acparser.h" #include "acinterp.h" #include "acnamesp.h" #include "acglobal.h" #define _COMPONENT ACPI_UTILITIES MODULE_NAME ("utalloc") + +/****************************************************************************** + * + * FUNCTION: AcpiUtReleaseToCache + * + * PARAMETERS: ListId - Memory list/cache ID + * Object - The object to be released + * + * RETURN: None + * + * DESCRIPTION: Release an object to the specified cache. If cache is full, + * the object is deleted. + * + ******************************************************************************/ + +void +AcpiUtReleaseToCache ( + UINT32 ListId, + void *Object) +{ + ACPI_MEMORY_LIST *CacheInfo; + + + /* If walk cache is full, just free this wallkstate object */ + + CacheInfo = &AcpiGbl_MemoryLists[ListId]; + if (CacheInfo->CacheDepth >= CacheInfo->MaxCacheDepth) + { + ACPI_MEM_FREE (Object); + ACPI_MEM_TRACKING (CacheInfo->TotalFreed++); + } + + /* Otherwise put this object back into the cache */ + + else + { + AcpiUtAcquireMutex (ACPI_MTX_CACHES); + + /* Mark the object as cached */ + + MEMSET (Object, 0xCA, CacheInfo->ObjectSize); + + /* Put the object at the head of the cache list */ + + * (char **) (((char *) Object) + CacheInfo->LinkOffset) = CacheInfo->ListHead; + CacheInfo->ListHead = Object; + CacheInfo->CacheDepth++; + + AcpiUtReleaseMutex (ACPI_MTX_CACHES); + } +} + + +/****************************************************************************** + * + * FUNCTION: AcpiUtAcquireFromCache + * + * PARAMETERS: ListId - Memory list ID + * + * RETURN: A requested object. NULL if the object could not be + * allocated. + * + * DESCRIPTION: Get an object from the specified cache. If cache is empty, + * the object is allocated. + * + ******************************************************************************/ + +void * +AcpiUtAcquireFromCache ( + UINT32 ListId) +{ + ACPI_MEMORY_LIST *CacheInfo; + void *Object; + + + PROC_NAME ("AcpiUtAcquireFromCache"); + + CacheInfo = &AcpiGbl_MemoryLists[ListId]; + AcpiUtAcquireMutex (ACPI_MTX_CACHES); + ACPI_MEM_TRACKING (CacheInfo->CacheRequests++); + + /* Check the cache first */ + + if (CacheInfo->ListHead) + { + /* There is an object available, use it */ + + Object = CacheInfo->ListHead; + CacheInfo->ListHead = * (char **) (((char *) Object) + CacheInfo->LinkOffset); + + ACPI_MEM_TRACKING (CacheInfo->CacheHits++); + CacheInfo->CacheDepth--; + + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Object %p from cache %d\n", Object, ListId)); + + AcpiUtReleaseMutex (ACPI_MTX_CACHES); + + /* Clear (zero) the previously used Object */ + + MEMSET (Object, 0, CacheInfo->ObjectSize); + } + + else + { + /* The cache is empty, create a new object */ + + /* Avoid deadlock with ACPI_MEM_CALLOCATE */ + + AcpiUtReleaseMutex (ACPI_MTX_CACHES); + + Object = ACPI_MEM_CALLOCATE (CacheInfo->ObjectSize); + ACPI_MEM_TRACKING (CacheInfo->TotalAllocated++); + } + + return (Object); +} + + +/****************************************************************************** + * + * FUNCTION: AcpiUtDeleteGenericCache + * + * PARAMETERS: ListId - Memory list ID + * + * RETURN: None + * + * DESCRIPTION: Free all objects within the requested cache. + * + ******************************************************************************/ + +void +AcpiUtDeleteGenericCache ( + UINT32 ListId) +{ + ACPI_MEMORY_LIST *CacheInfo; + char *Next; + + + CacheInfo = &AcpiGbl_MemoryLists[ListId]; + while (CacheInfo->ListHead) + { + /* Delete one cached state object */ + + Next = * (char **) (((char *) CacheInfo->ListHead) + CacheInfo->LinkOffset); + ACPI_MEM_FREE (CacheInfo->ListHead); + + CacheInfo->ListHead = Next; + CacheInfo->CacheDepth--; + } +} + + + #ifdef ACPI_DBG_TRACK_ALLOCATIONS /* - * This module is used for tracking memory leaks in the subsystem, and it - * gets compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set. + * These procedures are used for tracking memory leaks in the subsystem, and + * they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set. * * Each memory allocation is tracked via a doubly linked list. Each * element contains the caller's component, module name, function name, and * line number. AcpiUtAllocate and AcpiUtCallocate call * AcpiUtAddElementToAllocList to add an element to the list; deletion * occurs in the body of AcpiUtFree. */ /******************************************************************************* * * FUNCTION: AcpiUtSearchAllocList * * PARAMETERS: Address - Address of allocated memory * * RETURN: A list element if found; NULL otherwise. * * DESCRIPTION: Searches for an element in the global allocation tracking list. * ******************************************************************************/ -ACPI_ALLOCATION_INFO * +ACPI_DEBUG_MEM_BLOCK * AcpiUtSearchAllocList ( + UINT32 ListId, void *Address) { - ACPI_ALLOCATION_INFO *Element = AcpiGbl_HeadAllocPtr; + ACPI_DEBUG_MEM_BLOCK *Element; + if (ListId > ACPI_MEM_LIST_MAX) + { + return (NULL); + } + + Element = AcpiGbl_MemoryLists[ListId].ListHead; + /* Search for the address. */ while (Element) { - if (Element->Address == Address) + if (Element == Address) { return (Element); } Element = Element->Next; } return (NULL); } /******************************************************************************* * * FUNCTION: AcpiUtAddElementToAllocList * * PARAMETERS: Address - Address of allocated memory * Size - Size of the allocation * AllocType - MEM_MALLOC or MEM_CALLOC * Component - Component type of caller * Module - Source file name of caller * Line - Line number of caller * * RETURN: None. * * DESCRIPTION: Inserts an element into the global allocation tracking list. * ******************************************************************************/ ACPI_STATUS AcpiUtAddElementToAllocList ( - void *Address, + UINT32 ListId, + ACPI_DEBUG_MEM_BLOCK *Address, UINT32 Size, UINT8 AllocType, UINT32 Component, NATIVE_CHAR *Module, UINT32 Line) { - ACPI_ALLOCATION_INFO *Element; + ACPI_MEMORY_LIST *MemList; + ACPI_DEBUG_MEM_BLOCK *Element; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE_PTR ("UtAddElementToAllocList", Address); - AcpiUtAcquireMutex (ACPI_MTX_MEMORY); - - /* Keep track of the running total of all allocations. */ - - AcpiGbl_CurrentAllocCount++; - AcpiGbl_RunningAllocCount++; - - if (AcpiGbl_MaxConcurrentAllocCount < AcpiGbl_CurrentAllocCount) + if (ListId > ACPI_MEM_LIST_MAX) { - AcpiGbl_MaxConcurrentAllocCount = AcpiGbl_CurrentAllocCount; + return_ACPI_STATUS (AE_BAD_PARAMETER); } - AcpiGbl_CurrentAllocSize += Size; - AcpiGbl_RunningAllocSize += Size; + MemList = &AcpiGbl_MemoryLists[ListId]; + AcpiUtAcquireMutex (ACPI_MTX_MEMORY); - if (AcpiGbl_MaxConcurrentAllocSize < AcpiGbl_CurrentAllocSize) - { - AcpiGbl_MaxConcurrentAllocSize = AcpiGbl_CurrentAllocSize; - } - - /* If the head pointer is null, create the first element and fill it in. */ - - if (NULL == AcpiGbl_HeadAllocPtr) - { - AcpiGbl_HeadAllocPtr = AcpiOsCallocate (sizeof (ACPI_ALLOCATION_INFO)); - if (!AcpiGbl_HeadAllocPtr) - { - DEBUG_PRINTP (ACPI_ERROR, ("Could not allocate mem info block\n")); - Status = AE_NO_MEMORY; - goto UnlockAndExit; - } - - AcpiGbl_TailAllocPtr = AcpiGbl_HeadAllocPtr; - } - - else - { - AcpiGbl_TailAllocPtr->Next = AcpiOsCallocate (sizeof (ACPI_ALLOCATION_INFO)); - if (!AcpiGbl_TailAllocPtr->Next) - { - DEBUG_PRINTP (ACPI_ERROR, ("Could not allocate mem info block\n")); - Status = AE_NO_MEMORY; - goto UnlockAndExit; - } - - /* error check */ - - AcpiGbl_TailAllocPtr->Next->Previous = AcpiGbl_TailAllocPtr; - AcpiGbl_TailAllocPtr = AcpiGbl_TailAllocPtr->Next; - } - /* * Search list for this address to make sure it is not already on the list. * This will catch several kinds of problems. */ - Element = AcpiUtSearchAllocList (Address); + Element = AcpiUtSearchAllocList (ListId, Address); if (Element) { REPORT_ERROR (("UtAddElementToAllocList: Address already present in list! (%p)\n", Address)); - DEBUG_PRINTP (ACPI_ERROR, ("Element %p Address %p\n", Element, Address)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Element %p Address %p\n", Element, Address)); - BREAKPOINT3; + goto UnlockAndExit; } /* Fill in the instance data. */ - AcpiGbl_TailAllocPtr->Address = Address; - AcpiGbl_TailAllocPtr->Size = Size; - AcpiGbl_TailAllocPtr->AllocType = AllocType; - AcpiGbl_TailAllocPtr->Component = Component; - AcpiGbl_TailAllocPtr->Line = Line; + Address->Size = Size; + Address->AllocType = AllocType; + Address->Component = Component; + Address->Line = Line; - STRNCPY (AcpiGbl_TailAllocPtr->Module, Module, MAX_MODULE_NAME); + STRNCPY (Address->Module, Module, MAX_MODULE_NAME); + /* Insert at list head */ + if (MemList->ListHead) + { + ((ACPI_DEBUG_MEM_BLOCK *)(MemList->ListHead))->Previous = Address; + } + + Address->Next = MemList->ListHead; + Address->Previous = NULL; + + MemList->ListHead = Address; + + UnlockAndExit: AcpiUtReleaseMutex (ACPI_MTX_MEMORY); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUtDeleteElementFromAllocList * * PARAMETERS: Address - Address of allocated memory * Component - Component type of caller * Module - Source file name of caller * Line - Line number of caller * * RETURN: * * DESCRIPTION: Deletes an element from the global allocation tracking list. * ******************************************************************************/ -void +ACPI_STATUS AcpiUtDeleteElementFromAllocList ( - void *Address, + UINT32 ListId, + ACPI_DEBUG_MEM_BLOCK *Address, UINT32 Component, NATIVE_CHAR *Module, UINT32 Line) { - ACPI_ALLOCATION_INFO *Element; - UINT32 *DwordPtr; - UINT32 DwordLen; - UINT32 Size; - UINT32 i; + ACPI_MEMORY_LIST *MemList; FUNCTION_TRACE ("UtDeleteElementFromAllocList"); - if (NULL == AcpiGbl_HeadAllocPtr) + + if (ListId > ACPI_MEM_LIST_MAX) { - /* Boy we got problems. */ + return_ACPI_STATUS (AE_BAD_PARAMETER); + } + MemList = &AcpiGbl_MemoryLists[ListId]; + if (NULL == MemList->ListHead) + { + /* No allocations! */ + _REPORT_ERROR (Module, Line, Component, ("UtDeleteElementFromAllocList: Empty allocation list, nothing to free!\n")); - return_VOID; + return_ACPI_STATUS (AE_OK); } AcpiUtAcquireMutex (ACPI_MTX_MEMORY); + + /* Unlink */ - /* Keep track of the amount of memory allocated. */ - - Size = 0; - AcpiGbl_CurrentAllocCount--; - - if (AcpiGbl_HeadAllocPtr == AcpiGbl_TailAllocPtr) + if (Address->Previous) { - if (Address != AcpiGbl_HeadAllocPtr->Address) - { - _REPORT_ERROR (Module, Line, Component, - ("UtDeleteElementFromAllocList: Deleting non-allocated memory\n")); - - goto Cleanup; - } - - Size = AcpiGbl_HeadAllocPtr->Size; - - AcpiOsFree (AcpiGbl_HeadAllocPtr); - AcpiGbl_HeadAllocPtr = NULL; - AcpiGbl_TailAllocPtr = NULL; - - DEBUG_PRINTP (TRACE_ALLOCATIONS, - ("Allocation list deleted. There are no outstanding allocations\n")); - - goto Cleanup; + (Address->Previous)->Next = Address->Next; } - - - /* Search list for this address */ - - Element = AcpiUtSearchAllocList (Address); - if (Element) + else { - /* cases: head, tail, other */ - - if (Element == AcpiGbl_HeadAllocPtr) - { - Element->Next->Previous = NULL; - AcpiGbl_HeadAllocPtr = Element->Next; - } - - else - { - if (Element == AcpiGbl_TailAllocPtr) - { - Element->Previous->Next = NULL; - AcpiGbl_TailAllocPtr = Element->Previous; - } - - else - { - Element->Previous->Next = Element->Next; - Element->Next->Previous = Element->Previous; - } - } - - - /* Mark the segment as deleted */ - - if (Element->Size >= 4) - { - DwordLen = DIV_4 (Element->Size); - DwordPtr = (UINT32 *) Element->Address; - - for (i = 0; i < DwordLen; i++) - { - DwordPtr[i] = 0x00DEAD00; - } - - /* Set obj type, desc, and ref count fields to all ones */ - - DwordPtr[0] = ACPI_UINT32_MAX; - if (Element->Size >= 8) - { - DwordPtr[1] = ACPI_UINT32_MAX; - } - } - - Size = Element->Size; - - MEMSET (Element, 0xEA, sizeof (ACPI_ALLOCATION_INFO)); - - - if (Size == sizeof (ACPI_OPERAND_OBJECT)) - { - DEBUG_PRINTP (TRACE_ALLOCATIONS, - ("Freeing size %X (ACPI_OPERAND_OBJECT)\n", Size)); - } - else - { - DEBUG_PRINTP (TRACE_ALLOCATIONS, ("Freeing size %X\n", Size)); - } - - AcpiOsFree (Element); + MemList->ListHead = Address->Next; } - else + if (Address->Next) { - _REPORT_ERROR (Module, Line, Component, - ("AcpiUtFree: Entry not found in list\n")); - DEBUG_PRINTP (ACPI_ERROR, ("Entry %p was not found in allocation list\n", - Address)); - AcpiUtReleaseMutex (ACPI_MTX_MEMORY); - return_VOID; + (Address->Next)->Previous = Address->Previous; } -Cleanup: + /* Mark the segment as deleted */ - AcpiGbl_CurrentAllocSize -= Size; - AcpiUtReleaseMutex (ACPI_MTX_MEMORY); + MEMSET (&Address->UserSpace, 0xEA, Address->Size); - return_VOID; + ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Freeing size %X\n", Address->Size)); + + AcpiUtReleaseMutex (ACPI_MTX_MEMORY); + return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiUtDumpAllocationInfo * * PARAMETERS: * * RETURN: None * * DESCRIPTION: Print some info about the outstanding allocations. * ******************************************************************************/ void AcpiUtDumpAllocationInfo ( void) { +/* + ACPI_MEMORY_LIST *MemList; +*/ + FUNCTION_TRACE ("UtDumpAllocationInfo"); - - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, +/* + ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, ("%30s: %4d (%3d Kb)\n", "Current allocations", - AcpiGbl_CurrentAllocCount, - ROUND_UP_TO_1K (AcpiGbl_CurrentAllocSize))); + MemList->CurrentCount, + ROUND_UP_TO_1K (MemList->CurrentSize))); - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, + ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, ("%30s: %4d (%3d Kb)\n", "Max concurrent allocations", - AcpiGbl_MaxConcurrentAllocCount, - ROUND_UP_TO_1K (AcpiGbl_MaxConcurrentAllocSize))); + MemList->MaxConcurrentCount, + ROUND_UP_TO_1K (MemList->MaxConcurrentSize))); - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, - ("%30s: %4d (%3d Kb)\n", "Current Internal objects", - AcpiGbl_CurrentObjectCount, - ROUND_UP_TO_1K (AcpiGbl_CurrentObjectSize))); - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, - ("%30s: %4d (%3d Kb)\n", "Max internal objects", - AcpiGbl_MaxConcurrentObjectCount, - ROUND_UP_TO_1K (AcpiGbl_MaxConcurrentObjectSize))); + ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, + ("%30s: %4d (%3d Kb)\n", "Total (all) internal objects", + RunningObjectCount, + ROUND_UP_TO_1K (RunningObjectSize))); - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, + ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, + ("%30s: %4d (%3d Kb)\n", "Total (all) allocations", + RunningAllocCount, + ROUND_UP_TO_1K (RunningAllocSize))); + + + ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, ("%30s: %4d (%3d Kb)\n", "Current Nodes", AcpiGbl_CurrentNodeCount, ROUND_UP_TO_1K (AcpiGbl_CurrentNodeSize))); - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, + ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, ("%30s: %4d (%3d Kb)\n", "Max Nodes", AcpiGbl_MaxConcurrentNodeCount, ROUND_UP_TO_1K ((AcpiGbl_MaxConcurrentNodeCount * sizeof (ACPI_NAMESPACE_NODE))))); - - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, - ("%30s: %4d (%3d Kb)\n", "Total (all) internal objects", - AcpiGbl_RunningObjectCount, - ROUND_UP_TO_1K (AcpiGbl_RunningObjectSize))); - - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, - ("%30s: %4d (%3d Kb)\n", "Total (all) allocations", - AcpiGbl_RunningAllocCount, - ROUND_UP_TO_1K (AcpiGbl_RunningAllocSize))); - +*/ return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtDumpCurrentAllocations * * PARAMETERS: Component - Component(s) to dump info for. * Module - Module to dump info for. NULL means all. * * RETURN: None * * DESCRIPTION: Print a list of all outstanding allocations. * ******************************************************************************/ void AcpiUtDumpCurrentAllocations ( UINT32 Component, NATIVE_CHAR *Module) { - ACPI_ALLOCATION_INFO *Element = AcpiGbl_HeadAllocPtr; + ACPI_DEBUG_MEM_BLOCK *Element; UINT32 i; FUNCTION_TRACE ("UtDumpCurrentAllocations"); + Element = AcpiGbl_MemoryLists[0].ListHead; if (Element == NULL) { - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, - ("No outstanding allocations.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, + "No outstanding allocations.\n")); return_VOID; } /* * Walk the allocation list. */ - AcpiUtAcquireMutex (ACPI_MTX_MEMORY); - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, - ("Outstanding allocations:\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, + "Outstanding allocations:\n")); for (i = 1; ; i++) /* Just a counter */ { if ((Element->Component & Component) && ((Module == NULL) || (0 == STRCMP (Module, Element->Module)))) { - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, - ("%p Len %04lX %9.9s-%ld", - Element->Address, Element->Size, Element->Module, + ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, + "%p Len %04lX %9.9s-%ld", + &Element->UserSpace, Element->Size, Element->Module, Element->Line)); /* Most of the elements will be internal objects. */ switch (((ACPI_OPERAND_OBJECT *) - (Element->Address))->Common.DataType) + (&Element->UserSpace))->Common.DataType) { case ACPI_DESC_TYPE_INTERNAL: - DEBUG_PRINT_RAW (TRACE_ALLOCATIONS | TRACE_TABLES, - (" ObjType %s", - AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *)(Element->Address))->Common.Type))); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS, + " ObjType %s", + AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *)(&Element->UserSpace))->Common.Type))); break; case ACPI_DESC_TYPE_PARSER: - DEBUG_PRINT_RAW (TRACE_ALLOCATIONS | TRACE_TABLES, - (" ParseObj Opcode %04X", - ((ACPI_PARSE_OBJECT *)(Element->Address))->Opcode)); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS, + " ParseObj Opcode %04X", + ((ACPI_PARSE_OBJECT *)(&Element->UserSpace))->Opcode)); break; case ACPI_DESC_TYPE_NAMED: - DEBUG_PRINT_RAW (TRACE_ALLOCATIONS | TRACE_TABLES, - (" Node %4.4s", - &((ACPI_NAMESPACE_NODE *)(Element->Address))->Name)); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS, + " Node %4.4s", + &((ACPI_NAMESPACE_NODE *)(&Element->UserSpace))->Name)); break; case ACPI_DESC_TYPE_STATE: - DEBUG_PRINT_RAW (TRACE_ALLOCATIONS | TRACE_TABLES, - (" StateObj")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS, + " StateObj")); break; } - DEBUG_PRINT_RAW (TRACE_ALLOCATIONS | TRACE_TABLES, ("\n")); + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS, "\n")); } if (Element->Next == NULL) { break; } Element = Element->Next; } AcpiUtReleaseMutex (ACPI_MTX_MEMORY); - DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, - ("Total number of unfreed allocations = %d(%X)\n", i,i)); + ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, + "Total number of unfreed allocations = %d(%X)\n", i,i)); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtAllocate * * PARAMETERS: Size - Size of the allocation * Component - Component type of caller * Module - Source file name of caller * Line - Line number of caller * * RETURN: Address of the allocated memory on success, NULL on failure. * * DESCRIPTION: The subsystem's equivalent of malloc. * ******************************************************************************/ void * AcpiUtAllocate ( UINT32 Size, UINT32 Component, NATIVE_CHAR *Module, UINT32 Line) { - void *Address = NULL; + ACPI_DEBUG_MEM_BLOCK *Address; + ACPI_STATUS Status; FUNCTION_TRACE_U32 ("AcpiUtAllocate", Size); /* Check for an inadvertent size of zero bytes */ if (!Size) { _REPORT_ERROR (Module, Line, Component, ("UtAllocate: Attempt to allocate zero bytes\n")); Size = 1; } - Address = AcpiOsAllocate (Size); + Address = AcpiOsAllocate (Size + sizeof (ACPI_DEBUG_MEM_BLOCK)); if (!Address) { /* Report allocation error */ _REPORT_ERROR (Module, Line, Component, ("UtAllocate: Could not allocate size %X\n", Size)); return_PTR (NULL); } - - if (ACPI_FAILURE (AcpiUtAddElementToAllocList (Address, Size, MEM_MALLOC, - Component, Module, Line))) + Status = AcpiUtAddElementToAllocList (ACPI_MEM_LIST_GLOBAL, Address, Size, + MEM_MALLOC, Component, Module, Line); + if (ACPI_FAILURE (Status)) { AcpiOsFree (Address); return_PTR (NULL); } - DEBUG_PRINTP (TRACE_ALLOCATIONS, ("%p Size %X\n", Address, Size)); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_GLOBAL].TotalAllocated++; + AcpiGbl_MemoryLists[ACPI_MEM_LIST_GLOBAL].CurrentTotalSize += Size; - return_PTR (Address); + ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n", Address, Size)); + + return_PTR ((void *) &Address->UserSpace); } /******************************************************************************* * * FUNCTION: AcpiUtCallocate * * PARAMETERS: Size - Size of the allocation * Component - Component type of caller * Module - Source file name of caller * Line - Line number of caller * * RETURN: Address of the allocated memory on success, NULL on failure. * * DESCRIPTION: Subsystem equivalent of calloc. * ******************************************************************************/ void * AcpiUtCallocate ( UINT32 Size, UINT32 Component, NATIVE_CHAR *Module, UINT32 Line) { - void *Address = NULL; + ACPI_DEBUG_MEM_BLOCK *Address; + ACPI_STATUS Status; FUNCTION_TRACE_U32 ("AcpiUtCallocate", Size); /* Check for an inadvertent size of zero bytes */ if (!Size) { _REPORT_ERROR (Module, Line, Component, ("UtCallocate: Attempt to allocate zero bytes\n")); return_PTR (NULL); } - Address = AcpiOsCallocate (Size); + Address = AcpiOsCallocate (Size + sizeof (ACPI_DEBUG_MEM_BLOCK)); if (!Address) { /* Report allocation error */ _REPORT_ERROR (Module, Line, Component, ("UtCallocate: Could not allocate size %X\n", Size)); return_PTR (NULL); } - - if (ACPI_FAILURE (AcpiUtAddElementToAllocList (Address, Size, MEM_CALLOC, - Component,Module, Line))) + Status = AcpiUtAddElementToAllocList (ACPI_MEM_LIST_GLOBAL, Address, Size, + MEM_CALLOC, Component, Module, Line); + if (ACPI_FAILURE (Status)) { AcpiOsFree (Address); return_PTR (NULL); } - DEBUG_PRINTP (TRACE_ALLOCATIONS, ("%p Size %X\n", Address, Size)); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_GLOBAL].TotalAllocated++; + AcpiGbl_MemoryLists[ACPI_MEM_LIST_GLOBAL].CurrentTotalSize += Size; - return_PTR (Address); + ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n", Address, Size)); + return_PTR ((void *) &Address->UserSpace); } /******************************************************************************* * * FUNCTION: AcpiUtFree * * PARAMETERS: Address - Address of the memory to deallocate * Component - Component type of caller * Module - Source file name of caller * Line - Line number of caller * * RETURN: None * * DESCRIPTION: Frees the memory at Address * ******************************************************************************/ void AcpiUtFree ( void *Address, UINT32 Component, NATIVE_CHAR *Module, UINT32 Line) { + ACPI_DEBUG_MEM_BLOCK *DebugBlock; + + FUNCTION_TRACE_PTR ("AcpiUtFree", Address); if (NULL == Address) { _REPORT_ERROR (Module, Line, Component, ("AcpiUtFree: Trying to delete a NULL address\n")); return_VOID; } - AcpiUtDeleteElementFromAllocList (Address, Component, Module, Line); - AcpiOsFree (Address); + DebugBlock = (ACPI_DEBUG_MEM_BLOCK *) + (((char *) Address) - sizeof (ACPI_DEBUG_MEM_HEADER)); - DEBUG_PRINTP (TRACE_ALLOCATIONS, ("%p freed\n", Address)); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_GLOBAL].TotalFreed++; + AcpiGbl_MemoryLists[ACPI_MEM_LIST_GLOBAL].CurrentTotalSize -= DebugBlock->Size; + + AcpiUtDeleteElementFromAllocList (ACPI_MEM_LIST_GLOBAL, DebugBlock, + Component, Module, Line); + AcpiOsFree (DebugBlock); + + ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p freed\n", Address)); return_VOID; } #endif /* #ifdef ACPI_DBG_TRACK_ALLOCATIONS */ Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/utcopy.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/utcopy.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/utcopy.c (revision 82367) @@ -1,838 +1,837 @@ /****************************************************************************** * * Module Name: utcopy - Internal to external object translation utilities - * $Revision: 76 $ + * $Revision: 77 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __UTCOPY_C__ #include "acpi.h" #include "acinterp.h" #include "acnamesp.h" #include "amlcode.h" #define _COMPONENT ACPI_UTILITIES MODULE_NAME ("utcopy") /******************************************************************************* * * FUNCTION: AcpiUtCopyIsimpleToEsimple * * PARAMETERS: *InternalObject - Pointer to the object we are examining * *Buffer - Where the object is returned * *SpaceUsed - Where the data length is returned * * RETURN: Status * * DESCRIPTION: This function is called to place a simple object in a user * buffer. * * The buffer is assumed to have sufficient space for the object. * ******************************************************************************/ static ACPI_STATUS AcpiUtCopyIsimpleToEsimple ( ACPI_OPERAND_OBJECT *InternalObject, ACPI_OBJECT *ExternalObject, UINT8 *DataSpace, UINT32 *BufferSpaceUsed) { UINT32 Length = 0; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("UtCopyIsimpleToEsimple"); /* * Check for NULL object case (could be an uninitialized * package element */ if (!InternalObject) { *BufferSpaceUsed = 0; return_ACPI_STATUS (AE_OK); } /* Always clear the external object */ MEMSET (ExternalObject, 0, sizeof (ACPI_OBJECT)); /* * In general, the external object will be the same type as * the internal object */ ExternalObject->Type = InternalObject->Common.Type; /* However, only a limited number of external types are supported */ switch (InternalObject->Common.Type) { case ACPI_TYPE_STRING: Length = InternalObject->String.Length + 1; ExternalObject->String.Length = InternalObject->String.Length; ExternalObject->String.Pointer = (NATIVE_CHAR *) DataSpace; MEMCPY ((void *) DataSpace, (void *) InternalObject->String.Pointer, Length); break; case ACPI_TYPE_BUFFER: Length = InternalObject->Buffer.Length; ExternalObject->Buffer.Length = InternalObject->Buffer.Length; ExternalObject->Buffer.Pointer = DataSpace; MEMCPY ((void *) DataSpace, (void *) InternalObject->Buffer.Pointer, Length); break; case ACPI_TYPE_INTEGER: ExternalObject->Integer.Value= InternalObject->Integer.Value; break; case INTERNAL_TYPE_REFERENCE: /* * This is an object reference. Attempt to dereference it. */ switch (InternalObject->Reference.Opcode) { case AML_ZERO_OP: ExternalObject->Type = ACPI_TYPE_INTEGER; ExternalObject->Integer.Value = 0; break; case AML_ONE_OP: ExternalObject->Type = ACPI_TYPE_INTEGER; ExternalObject->Integer.Value = 1; break; case AML_ONES_OP: ExternalObject->Type = ACPI_TYPE_INTEGER; ExternalObject->Integer.Value = ACPI_INTEGER_MAX; break; case AML_INT_NAMEPATH_OP: /* * This is a named reference, get the string. We already know that * we have room for it, use max length */ Length = MAX_STRING_LENGTH; ExternalObject->Type = ACPI_TYPE_STRING; ExternalObject->String.Pointer = (NATIVE_CHAR *) DataSpace; Status = AcpiNsHandleToPathname ((ACPI_HANDLE *) InternalObject->Reference.Node, &Length, (char *) DataSpace); /* Converted (external) string length is returned from above */ ExternalObject->String.Length = Length; break; default: /* * Use the object type of "Any" to indicate a reference * to object containing a handle to an ACPI named object. */ ExternalObject->Type = ACPI_TYPE_ANY; ExternalObject->Reference.Handle = InternalObject->Reference.Node; break; } break; case ACPI_TYPE_PROCESSOR: ExternalObject->Processor.ProcId = InternalObject->Processor.ProcId; ExternalObject->Processor.PblkAddress = InternalObject->Processor.Address; ExternalObject->Processor.PblkLength = InternalObject->Processor.Length; break; case ACPI_TYPE_POWER: ExternalObject->PowerResource.SystemLevel = InternalObject->PowerResource.SystemLevel; ExternalObject->PowerResource.ResourceOrder = InternalObject->PowerResource.ResourceOrder; break; default: /* * There is no corresponding external object type */ return_ACPI_STATUS (AE_SUPPORT); break; } *BufferSpaceUsed = (UINT32) ROUND_UP_TO_NATIVE_WORD (Length); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUtCopyIelementToEelement * * PARAMETERS: ACPI_PKG_CALLBACK * * RETURN: Status * * DESCRIPTION: Copy one package element to another package element * ******************************************************************************/ ACPI_STATUS AcpiUtCopyIelementToEelement ( UINT8 ObjectType, ACPI_OPERAND_OBJECT *SourceObject, ACPI_GENERIC_STATE *State, void *Context) { ACPI_STATUS Status = AE_OK; ACPI_PKG_INFO *Info = (ACPI_PKG_INFO *) Context; UINT32 ObjectSpace; UINT32 ThisIndex; ACPI_OBJECT *TargetObject; - ThisIndex = State->Pkg.Index; - TargetObject = (ACPI_OBJECT *) - &((ACPI_OBJECT *)(State->Pkg.DestObject))->Package.Elements[ThisIndex]; + ThisIndex = State->Pkg.Index; + TargetObject = (ACPI_OBJECT *) + &((ACPI_OBJECT *)(State->Pkg.DestObject))->Package.Elements[ThisIndex]; - switch (ObjectType) { case ACPI_COPY_TYPE_SIMPLE: /* * This is a simple or null object -- get the size */ - Status = AcpiUtCopyIsimpleToEsimple (SourceObject, TargetObject, Info->FreeSpace, &ObjectSpace); if (ACPI_FAILURE (Status)) { return (Status); } break; case ACPI_COPY_TYPE_PACKAGE: /* * Build the package object */ TargetObject->Type = ACPI_TYPE_PACKAGE; TargetObject->Package.Count = SourceObject->Package.Count; TargetObject->Package.Elements = (ACPI_OBJECT *) Info->FreeSpace; /* * Pass the new package object back to the package walk routine */ State->Pkg.ThisTargetObj = TargetObject; /* * Save space for the array of objects (Package elements) * update the buffer length counter */ ObjectSpace = (UINT32) ROUND_UP_TO_NATIVE_WORD ( TargetObject->Package.Count * sizeof (ACPI_OBJECT)); break; default: return (AE_BAD_PARAMETER); } Info->FreeSpace += ObjectSpace; Info->Length += ObjectSpace; return (Status); } /******************************************************************************* * * FUNCTION: AcpiUtCopyIpackageToEpackage * * PARAMETERS: *InternalObject - Pointer to the object we are returning * *Buffer - Where the object is returned * *SpaceUsed - Where the object length is returned * * RETURN: Status * * DESCRIPTION: This function is called to place a package object in a user * buffer. A package object by definition contains other objects. * * The buffer is assumed to have sufficient space for the object. * The caller must have verified the buffer length needed using the * AcpiUtGetObjectSize function before calling this function. * ******************************************************************************/ static ACPI_STATUS AcpiUtCopyIpackageToEpackage ( ACPI_OPERAND_OBJECT *InternalObject, UINT8 *Buffer, UINT32 *SpaceUsed) { ACPI_OBJECT *ExternalObject; ACPI_STATUS Status; ACPI_PKG_INFO Info; FUNCTION_TRACE ("UtCopyIpackageToEpackage"); /* * First package at head of the buffer */ ExternalObject = (ACPI_OBJECT *) Buffer; /* * Free space begins right after the first package */ Info.Length = 0; Info.ObjectSpace = 0; Info.NumPackages = 1; Info.FreeSpace = Buffer + ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT)); ExternalObject->Type = InternalObject->Common.Type; ExternalObject->Package.Count = InternalObject->Package.Count; ExternalObject->Package.Elements = (ACPI_OBJECT *) Info.FreeSpace; /* * Build an array of ACPI_OBJECTS in the buffer * and move the free space past it */ Info.FreeSpace += ExternalObject->Package.Count * ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT)); Status = AcpiUtWalkPackageTree (InternalObject, ExternalObject, AcpiUtCopyIelementToEelement, &Info); *SpaceUsed = Info.Length; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUtCopyIobjectToEobject * * PARAMETERS: *InternalObject - The internal object to be converted * *BufferPtr - Where the object is returned * * RETURN: Status * * DESCRIPTION: This function is called to build an API object to be returned to * the caller. * ******************************************************************************/ ACPI_STATUS AcpiUtCopyIobjectToEobject ( ACPI_OPERAND_OBJECT *InternalObject, ACPI_BUFFER *RetBuffer) { ACPI_STATUS Status; FUNCTION_TRACE ("UtCopyIobjectToEobject"); if (IS_THIS_OBJECT_TYPE (InternalObject, ACPI_TYPE_PACKAGE)) { /* * Package object: Copy all subobjects (including * nested packages) */ Status = AcpiUtCopyIpackageToEpackage (InternalObject, RetBuffer->Pointer, &RetBuffer->Length); } else { /* * Build a simple object (no nested objects) */ Status = AcpiUtCopyIsimpleToEsimple (InternalObject, (ACPI_OBJECT *) RetBuffer->Pointer, ((UINT8 *) RetBuffer->Pointer + ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT))), &RetBuffer->Length); /* * build simple does not include the object size in the length * so we add it in here */ RetBuffer->Length += sizeof (ACPI_OBJECT); } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUtCopyEsimpleToIsimple * * PARAMETERS: *ExternalObject - The external object to be converted * *InternalObject - Where the internal object is returned * * RETURN: Status * * DESCRIPTION: This function copies an external object to an internal one. * NOTE: Pointers can be copied, we don't need to copy data. * (The pointers have to be valid in our address space no matter * what we do with them!) * ******************************************************************************/ ACPI_STATUS AcpiUtCopyEsimpleToIsimple ( ACPI_OBJECT *ExternalObject, ACPI_OPERAND_OBJECT *InternalObject) { FUNCTION_TRACE ("UtCopyEsimpleToIsimple"); InternalObject->Common.Type = (UINT8) ExternalObject->Type; /* * Simple types supported are: String, Buffer, Integer */ switch (ExternalObject->Type) { case ACPI_TYPE_STRING: InternalObject->String.Length = ExternalObject->String.Length; InternalObject->String.Pointer = ExternalObject->String.Pointer; break; case ACPI_TYPE_BUFFER: InternalObject->Buffer.Length = ExternalObject->Buffer.Length; InternalObject->Buffer.Pointer = ExternalObject->Buffer.Pointer; break; case ACPI_TYPE_INTEGER: InternalObject->Integer.Value = ExternalObject->Integer.Value; break; default: /* * Whatever other type -- it is not supported */ return_ACPI_STATUS (AE_SUPPORT); break; } return_ACPI_STATUS (AE_OK); } #ifdef ACPI_FUTURE_IMPLEMENTATION /* Code to convert packages that are parameters to control methods */ /******************************************************************************* * * FUNCTION: AcpiUtCopyEpackageToIpackage * * PARAMETERS: *InternalObject - Pointer to the object we are returning * *Buffer - Where the object is returned * *SpaceUsed - Where the length of the object is returned * * RETURN: Status - the status of the call * * DESCRIPTION: This function is called to place a package object in a user * buffer. A package object by definition contains other objects. * * The buffer is assumed to have sufficient space for the object. * The caller must have verified the buffer length needed using the * AcpiUtGetObjectSize function before calling this function. * ******************************************************************************/ static ACPI_STATUS AcpiUtCopyEpackageToIpackage ( ACPI_OPERAND_OBJECT *InternalObject, UINT8 *Buffer, UINT32 *SpaceUsed) { UINT8 *FreeSpace; ACPI_OBJECT *ExternalObject; UINT32 Length = 0; UINT32 ThisIndex; UINT32 ObjectSpace = 0; ACPI_OPERAND_OBJECT *ThisInternalObj; ACPI_OBJECT *ThisExternalObj; FUNCTION_TRACE ("UtCopyEpackageToIpackage"); /* * First package at head of the buffer */ ExternalObject = (ACPI_OBJECT *)Buffer; /* * Free space begins right after the first package */ FreeSpace = Buffer + sizeof(ACPI_OBJECT); ExternalObject->Type = InternalObject->Common.Type; ExternalObject->Package.Count = InternalObject->Package.Count; ExternalObject->Package.Elements = (ACPI_OBJECT *)FreeSpace; /* * Build an array of ACPI_OBJECTS in the buffer * and move the free space past it */ FreeSpace += ExternalObject->Package.Count * sizeof(ACPI_OBJECT); /* Call WalkPackage */ } #endif /* Future implementation */ /******************************************************************************* * * FUNCTION: AcpiUtCopyEobjectToIobject * * PARAMETERS: *InternalObject - The external object to be converted * *BufferPtr - Where the internal object is returned * * RETURN: Status - the status of the call * * DESCRIPTION: Converts an external object to an internal object. * ******************************************************************************/ ACPI_STATUS AcpiUtCopyEobjectToIobject ( ACPI_OBJECT *ExternalObject, ACPI_OPERAND_OBJECT *InternalObject) { ACPI_STATUS Status; FUNCTION_TRACE ("UtCopyEobjectToIobject"); if (ExternalObject->Type == ACPI_TYPE_PACKAGE) { /* * Package objects contain other objects (which can be objects) * buildpackage does it all * * TBD: Package conversion must be completed and tested * NOTE: this code converts packages as input parameters to * control methods only. This is a very, very rare case. */ /* Status = AcpiUtCopyEpackageToIpackage(InternalObject, RetBuffer->Pointer, &RetBuffer->Length); */ - DEBUG_PRINTP (ACPI_ERROR, ("Packages as parameters not implemented!\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Packages as parameters not implemented!\n")); return_ACPI_STATUS (AE_NOT_IMPLEMENTED); } else { /* * Build a simple object (no nested objects) */ Status = AcpiUtCopyEsimpleToIsimple (ExternalObject, InternalObject); /* * build simple does not include the object size in the length * so we add it in here */ } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUtCopyIelementToIelement * * PARAMETERS: ACPI_PKG_CALLBACK * * RETURN: Status - the status of the call * * DESCRIPTION: Copy one package element to another package element * ******************************************************************************/ ACPI_STATUS AcpiUtCopyIelementToIelement ( UINT8 ObjectType, ACPI_OPERAND_OBJECT *SourceObject, ACPI_GENERIC_STATE *State, void *Context) { ACPI_STATUS Status = AE_OK; UINT32 ThisIndex; ACPI_OPERAND_OBJECT **ThisTargetPtr; ACPI_OPERAND_OBJECT *TargetObject; ThisIndex = State->Pkg.Index; ThisTargetPtr = (ACPI_OPERAND_OBJECT **) &State->Pkg.DestObject->Package.Elements[ThisIndex]; switch (ObjectType) { case 0: /* * This is a simple object, just copy it */ TargetObject = AcpiUtCreateInternalObject (SourceObject->Common.Type); if (!TargetObject) { return (AE_NO_MEMORY); } Status = AcpiExStoreObjectToObject (SourceObject, TargetObject, (ACPI_WALK_STATE *) Context); if (ACPI_FAILURE (Status)) { return (Status); } *ThisTargetPtr = TargetObject; break; case 1: /* * This object is a package - go down another nesting level * Create and build the package object */ TargetObject = AcpiUtCreateInternalObject (ACPI_TYPE_PACKAGE); if (!TargetObject) { /* TBD: must delete package created up to this point */ return (AE_NO_MEMORY); } TargetObject->Package.Count = SourceObject->Package.Count; /* * Pass the new package object back to the package walk routine */ State->Pkg.ThisTargetObj = TargetObject; /* * Store the object pointer in the parent package object */ *ThisTargetPtr = TargetObject; break; default: return (AE_BAD_PARAMETER); } return (Status); } /******************************************************************************* * * FUNCTION: AcpiUtCopyIpackageToIpackage * * PARAMETERS: *SourceObj - Pointer to the source package object * *DestObj - Where the internal object is returned * * RETURN: Status - the status of the call * * DESCRIPTION: This function is called to copy an internal package object * into another internal package object. * ******************************************************************************/ ACPI_STATUS AcpiUtCopyIpackageToIpackage ( ACPI_OPERAND_OBJECT *SourceObj, ACPI_OPERAND_OBJECT *DestObj, ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("UtCopyIpackageToIpackage"); DestObj->Common.Type = SourceObj->Common.Type; DestObj->Package.Count = SourceObj->Package.Count; /* * Create the object array and walk the source package tree */ DestObj->Package.Elements = ACPI_MEM_CALLOCATE ((SourceObj->Package.Count + 1) * sizeof (void *)); DestObj->Package.NextElement = DestObj->Package.Elements; if (!DestObj->Package.Elements) { REPORT_ERROR ( ("AmlBuildCopyInternalPackageObject: Package allocation failure\n")); return_ACPI_STATUS (AE_NO_MEMORY); } Status = AcpiUtWalkPackageTree (SourceObj, DestObj, AcpiUtCopyIelementToIelement, WalkState); return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/utdebug.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/utdebug.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/utdebug.c (revision 82367) @@ -1,701 +1,668 @@ /****************************************************************************** * * Module Name: utdebug - Debug print routines - * $Revision: 73 $ + * $Revision: 76 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __UTDEBUG_C__ #include "acpi.h" #define _COMPONENT ACPI_UTILITIES MODULE_NAME ("utdebug") UINT32 PrevThreadId = 0xFFFFFFFF; /***************************************************************************** * * FUNCTION: Get/Set debug level * * DESCRIPTION: Get or set value of the debug flag * * These are used to allow user's to get/set the debug level * ****************************************************************************/ UINT32 GetDebugLevel (void) { return (AcpiDbgLevel); } void SetDebugLevel ( UINT32 NewDebugLevel) { AcpiDbgLevel = NewDebugLevel; } /***************************************************************************** * + * FUNCTION: AcpiUtDebugPrint + * + * PARAMETERS: DebugLevel - Requested debug print level + * ProcName - Caller's procedure name + * ModuleName - Caller's module name (for error output) + * LineNumber - Caller's line number (for error output) + * ComponentId - Caller's component ID (for error output) + * + * Format - Printf format field + * ... - Optional printf arguments + * + * RETURN: None + * + * DESCRIPTION: Print error message with prefix consisting of the module name, + * line number, and component ID. + * + ****************************************************************************/ + +void +AcpiUtDebugPrint ( + UINT32 RequestedDebugLevel, + UINT32 ComponentId, + NATIVE_CHAR *ProcName, + NATIVE_CHAR *ModuleName, + UINT32 LineNumber, + char *Format, + ...) +{ + UINT32 ThreadId; + va_list args; + + + if (!(RequestedDebugLevel & AcpiDbgLevel) || + !(ComponentId & AcpiDbgLayer)) + { + return; + } + + + ThreadId = AcpiOsGetThreadId (); + + if (ThreadId != PrevThreadId) + { + if (ACPI_LV_THREADS & AcpiDbgLevel) + { + AcpiOsPrintf ("\n**** Context Switch from TID %X to TID %X ****\n\n", + PrevThreadId, ThreadId); + } + + PrevThreadId = ThreadId; + } + + if (ACPI_LV_THREADS & AcpiDbgLevel) + { + AcpiOsPrintf ("%8s-%04d[%04X][%02d] %s: ", ModuleName, LineNumber, ThreadId, AcpiGbl_NestingLevel, ProcName); + } + else + { + AcpiOsPrintf ("%8s-%04d[%02d] %s: ", ModuleName, LineNumber, AcpiGbl_NestingLevel, ProcName); + } + + + + va_start (args, Format); + AcpiOsVprintf (Format, args); +} + + +/***************************************************************************** + * + * FUNCTION: AcpiUtDebugPrintRaw + * + * PARAMETERS: DebugLevel - Requested debug print level + * ProcName - Caller's procedure name + * ModuleName - Caller's module name (for error output) + * LineNumber - Caller's line number (for error output) + * ComponentId - Caller's component ID (for error output) + * + * Format - Printf format field + * ... - Optional printf arguments + * + * RETURN: None + * + * DESCRIPTION: Print message with no headers. Has same interface as + * DebugPrint so that the same macros can be used. + * + ****************************************************************************/ + +void +AcpiUtDebugPrintRaw ( + UINT32 RequestedDebugLevel, + UINT32 ComponentId, + NATIVE_CHAR *ProcName, + NATIVE_CHAR *ModuleName, + UINT32 LineNumber, + char *Format, + ...) +{ + va_list args; + + + + if (!(RequestedDebugLevel & AcpiDbgLevel) || + !(ComponentId & AcpiDbgLayer)) + { + return; + } + + va_start (args, Format); + + AcpiOsVprintf (Format, args); +} + + +/***************************************************************************** + * * FUNCTION: FunctionTrace * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * FunctionName - Name of Caller's function * * RETURN: None * * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is * set in DebugLevel * ****************************************************************************/ void FunctionTrace ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName) { AcpiGbl_NestingLevel++; - DebugPrint (ModuleName, LineNumber, ComponentId, - TRACE_FUNCTIONS, - " %2.2ld Entered Function: %s\n", - AcpiGbl_NestingLevel, FunctionName); + AcpiUtDebugPrint (ACPI_LV_FUNCTIONS, ComponentId, FunctionName, + ModuleName, LineNumber, "----Entered Function----\n"); } /***************************************************************************** * * FUNCTION: FunctionTracePtr * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * FunctionName - Name of Caller's function * Pointer - Pointer to display * * RETURN: None * * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is * set in DebugLevel * ****************************************************************************/ void FunctionTracePtr ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, void *Pointer) { - AcpiGbl_NestingLevel++; - DebugPrint (ModuleName, LineNumber, ComponentId, TRACE_FUNCTIONS, - " %2.2ld Entered Function: %s, %p\n", - AcpiGbl_NestingLevel, FunctionName, Pointer); + AcpiUtDebugPrint (ACPI_LV_FUNCTIONS, ComponentId, FunctionName, + ModuleName, LineNumber, "----Entered Function---- %p\n", Pointer); } + /***************************************************************************** * * FUNCTION: FunctionTraceStr * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * FunctionName - Name of Caller's function * String - Additional string to display * * RETURN: None * * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is * set in DebugLevel * ****************************************************************************/ void FunctionTraceStr ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, NATIVE_CHAR *String) { AcpiGbl_NestingLevel++; - DebugPrint (ModuleName, LineNumber, ComponentId, TRACE_FUNCTIONS, - " %2.2ld Entered Function: %s, %s\n", - AcpiGbl_NestingLevel, FunctionName, String); + AcpiUtDebugPrint (ACPI_LV_FUNCTIONS, ComponentId, FunctionName, + ModuleName, LineNumber, "----Entered Function---- %s\n", String); } /***************************************************************************** * * FUNCTION: FunctionTraceU32 * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * FunctionName - Name of Caller's function * Integer - Integer to display * * RETURN: None * * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is * set in DebugLevel * ****************************************************************************/ void FunctionTraceU32 ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, UINT32 Integer) { AcpiGbl_NestingLevel++; - DebugPrint (ModuleName, LineNumber, ComponentId, TRACE_FUNCTIONS, - " %2.2ld Entered Function: %s, %lX\n", - AcpiGbl_NestingLevel, FunctionName, Integer); + AcpiUtDebugPrint (ACPI_LV_FUNCTIONS, ComponentId, FunctionName, + ModuleName, LineNumber, "----Entered Function---- %08X\n", Integer); } /***************************************************************************** * * FUNCTION: FunctionExit * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * FunctionName - Name of Caller's function * * RETURN: None * * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is * set in DebugLevel * ****************************************************************************/ void FunctionExit ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName) { - DebugPrint (ModuleName, LineNumber, ComponentId, TRACE_FUNCTIONS, - " %2.2ld Exiting Function: %s\n", - AcpiGbl_NestingLevel, FunctionName); + AcpiUtDebugPrint (ACPI_LV_FUNCTIONS, ComponentId, FunctionName, + ModuleName, LineNumber, "----Exiting Function----\n"); AcpiGbl_NestingLevel--; } /***************************************************************************** * * FUNCTION: FunctionStatusExit * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * FunctionName - Name of Caller's function * Status - Exit status code * * RETURN: None * * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is * set in DebugLevel. Prints exit status also. * ****************************************************************************/ void FunctionStatusExit ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, ACPI_STATUS Status) { - DebugPrint (ModuleName, LineNumber, ComponentId, - TRACE_FUNCTIONS, " %2.2ld Exiting Function: %s, %s\n", - AcpiGbl_NestingLevel, FunctionName, AcpiFormatException (Status)); + AcpiUtDebugPrint (ACPI_LV_FUNCTIONS, ComponentId, FunctionName, + ModuleName, LineNumber, "----Exiting Function---- %s\n", + AcpiFormatException (Status)); AcpiGbl_NestingLevel--; } /***************************************************************************** * * FUNCTION: FunctionValueExit * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * FunctionName - Name of Caller's function * Value - Value to be printed with exit msg * * RETURN: None * * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is * set in DebugLevel. Prints exit value also. * ****************************************************************************/ void FunctionValueExit ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, ACPI_INTEGER Value) { - DebugPrint (ModuleName, LineNumber, ComponentId, TRACE_FUNCTIONS, - " %2.2ld Exiting Function: %s, %X\n", - AcpiGbl_NestingLevel, FunctionName, Value); + AcpiUtDebugPrint (ACPI_LV_FUNCTIONS, ComponentId, FunctionName, + ModuleName, LineNumber, "----Exiting Function---- %08X\n", + Value); AcpiGbl_NestingLevel--; } /***************************************************************************** * * FUNCTION: FunctionPtrExit * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * FunctionName - Name of Caller's function * Value - Value to be printed with exit msg * * RETURN: None * * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is * set in DebugLevel. Prints exit value also. * ****************************************************************************/ void FunctionPtrExit ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, NATIVE_CHAR *FunctionName, UINT8 *Ptr) { - DebugPrint (ModuleName, LineNumber, ComponentId, TRACE_FUNCTIONS, - " %2.2ld Exiting Function: %s, %p\n", - AcpiGbl_NestingLevel, FunctionName, Ptr); + AcpiUtDebugPrint (ACPI_LV_FUNCTIONS, ComponentId, FunctionName, + ModuleName, LineNumber, "----Exiting Function----, %p\n", + Ptr); AcpiGbl_NestingLevel--; } /***************************************************************************** * - * FUNCTION: DebugPrint - * - * PARAMETERS: ModuleName - Caller's module name (for error output) - * LineNumber - Caller's line number (for error output) - * ComponentId - Caller's component ID (for error output) - * PrintLevel - Requested debug print level - * Format - Printf format field - * ... - Optional printf arguments - * - * RETURN: None - * - * DESCRIPTION: Print error message with prefix consisting of the module name, - * line number, and component ID. - * - ****************************************************************************/ - -void -DebugPrint ( - NATIVE_CHAR *ModuleName, - UINT32 LineNumber, - UINT32 ComponentId, - UINT32 PrintLevel, - NATIVE_CHAR *Format, - ...) -{ - va_list args; - UINT32 ThreadId; - - - ThreadId = AcpiOsGetThreadId (); - - - /* Both the level and the component must be enabled */ - - if ((PrintLevel & AcpiDbgLevel) && - (ComponentId & AcpiDbgLayer)) - { - va_start (args, Format); - - if (ThreadId != PrevThreadId) - { - if (TRACE_THREADS & AcpiDbgLevel) - { - AcpiOsPrintf ("\n**** Context Switch from TID %X to TID %X ****\n\n", - PrevThreadId, ThreadId); - } - - PrevThreadId = ThreadId; - } - - if (TRACE_THREADS & AcpiDbgLevel) - { - AcpiOsPrintf ("%8s-%04d[%04X]: ", ModuleName, LineNumber, ThreadId); - } - else - { - AcpiOsPrintf ("%8s-%04d: ", ModuleName, LineNumber); - } - - AcpiOsVprintf (Format, args); - } -} - - -/***************************************************************************** - * - * FUNCTION: DebugPrintPrefix - * - * PARAMETERS: ModuleName - Caller's module name (for error output) - * LineNumber - Caller's line number (for error output) - * ComponentId - Caller's component ID (for error output) - * - * RETURN: None - * - * DESCRIPTION: Print the prefix part of an error message, consisting of the - * module name, and line number - * - ****************************************************************************/ - -void -DebugPrintPrefix ( - NATIVE_CHAR *ModuleName, - UINT32 LineNumber) -{ - UINT32 ThreadId; - - - ThreadId = AcpiOsGetThreadId (); - - if (ThreadId != PrevThreadId) - { - if (TRACE_THREADS & AcpiDbgLevel) - { - AcpiOsPrintf ("\n**** Context Switch from TID %X to TID %X ****\n\n", - PrevThreadId, ThreadId); - } - - PrevThreadId = ThreadId; - } - - if (TRACE_THREADS & AcpiDbgLevel) - { - AcpiOsPrintf ("%8s-%04d[%04X]: ", ModuleName, LineNumber, ThreadId); - } - else - { - AcpiOsPrintf ("%8s-%04d: ", ModuleName, LineNumber); - } - -} - - -/***************************************************************************** - * - * FUNCTION: DebugPrintRaw - * - * PARAMETERS: Format - Printf format field - * ... - Optional printf arguments - * - * RETURN: None - * - * DESCRIPTION: Print error message -- without module/line indentifiers - * - ****************************************************************************/ - -void -DebugPrintRaw ( - NATIVE_CHAR *Format, - ...) -{ - va_list args; - - - va_start (args, Format); - - AcpiOsVprintf (Format, args); - - va_end (args); -} - - -/***************************************************************************** - * * FUNCTION: AcpiUtDumpBuffer * * PARAMETERS: Buffer - Buffer to dump * Count - Amount to dump, in bytes * ComponentID - Caller's component ID * * RETURN: None * * DESCRIPTION: Generic dump buffer in both hex and ascii. * ****************************************************************************/ void AcpiUtDumpBuffer ( UINT8 *Buffer, UINT32 Count, UINT32 Display, UINT32 ComponentId) { UINT32 i = 0; UINT32 j; UINT32 Temp32; UINT8 BufChar; /* Only dump the buffer if tracing is enabled */ - if (!((TRACE_TABLES & AcpiDbgLevel) && + if (!((ACPI_LV_TABLES & AcpiDbgLevel) && (ComponentId & AcpiDbgLayer))) { return; } /* * Nasty little dump buffer routine! */ while (i < Count) { /* Print current offset */ AcpiOsPrintf ("%05X ", i); /* Print 16 hex chars */ for (j = 0; j < 16;) { if (i + j >= Count) { AcpiOsPrintf ("\n"); return; } /* Make sure that the INT8 doesn't get sign-extended! */ switch (Display) { /* Default is BYTE display */ default: AcpiOsPrintf ("%02X ", *((UINT8 *) &Buffer[i + j])); j += 1; break; case DB_WORD_DISPLAY: MOVE_UNALIGNED16_TO_32 (&Temp32, &Buffer[i + j]); AcpiOsPrintf ("%04X ", Temp32); j += 2; break; case DB_DWORD_DISPLAY: MOVE_UNALIGNED32_TO_32 (&Temp32, &Buffer[i + j]); AcpiOsPrintf ("%08X ", Temp32); j += 4; break; case DB_QWORD_DISPLAY: MOVE_UNALIGNED32_TO_32 (&Temp32, &Buffer[i + j]); AcpiOsPrintf ("%08X", Temp32); MOVE_UNALIGNED32_TO_32 (&Temp32, &Buffer[i + j + 4]); AcpiOsPrintf ("%08X ", Temp32); j += 8; break; } } /* * Print the ASCII equivalent characters * But watch out for the bad unprintable ones... */ for (j = 0; j < 16; j++) { if (i + j >= Count) { AcpiOsPrintf ("\n"); return; } BufChar = Buffer[i + j]; if ((BufChar > 0x1F && BufChar < 0x2E) || (BufChar > 0x2F && BufChar < 0x61) || (BufChar > 0x60 && BufChar < 0x7F)) { AcpiOsPrintf ("%c", BufChar); } else { AcpiOsPrintf ("."); } } /* Done with that line. */ AcpiOsPrintf ("\n"); i += 16; } return; } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/utdelete.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/utdelete.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/utdelete.c (revision 82367) @@ -1,799 +1,802 @@ /******************************************************************************* * * Module Name: utdelete - object deletion and reference count utilities - * $Revision: 72 $ + * $Revision: 74 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __UTDELETE_C__ #include "acpi.h" #include "acinterp.h" #include "acnamesp.h" #include "actables.h" #include "acparser.h" #define _COMPONENT ACPI_UTILITIES MODULE_NAME ("utdelete") /******************************************************************************* * * FUNCTION: AcpiUtDeleteInternalObj * * PARAMETERS: *Object - Pointer to the list to be deleted * * RETURN: None * * DESCRIPTION: Low level object deletion, after reference counts have been * updated (All reference counts, including sub-objects!) * ******************************************************************************/ void AcpiUtDeleteInternalObj ( ACPI_OPERAND_OBJECT *Object) { void *ObjPointer = NULL; ACPI_OPERAND_OBJECT *HandlerDesc; FUNCTION_TRACE_PTR ("UtDeleteInternalObj", Object); if (!Object) { return_VOID; } /* * Must delete or free any pointers within the object that are not * actual ACPI objects (for example, a raw buffer pointer). */ switch (Object->Common.Type) { case ACPI_TYPE_STRING: - DEBUG_PRINTP (ACPI_INFO, ("**** String %p, ptr %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "**** String %p, ptr %p\n", Object, Object->String.Pointer)); /* Free the actual string buffer */ - ObjPointer = Object->String.Pointer; + if (!(Object->Common.Flags & AOPOBJ_STATIC_POINTER)) + { + ObjPointer = Object->String.Pointer; + } break; case ACPI_TYPE_BUFFER: - DEBUG_PRINTP (ACPI_INFO, ("**** Buffer %p, ptr %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "**** Buffer %p, ptr %p\n", Object, Object->Buffer.Pointer)); /* Free the actual buffer */ ObjPointer = Object->Buffer.Pointer; break; case ACPI_TYPE_PACKAGE: - DEBUG_PRINTP (ACPI_INFO, (" **** Package of count %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, " **** Package of count %X\n", Object->Package.Count)); /* * Elements of the package are not handled here, they are deleted * separately */ /* Free the (variable length) element pointer array */ ObjPointer = Object->Package.Elements; break; case ACPI_TYPE_MUTEX: - DEBUG_PRINTP (ACPI_INFO, ("***** Mutex %p, Semaphore %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "***** Mutex %p, Semaphore %p\n", Object, Object->Mutex.Semaphore)); AcpiExUnlinkMutex (Object); AcpiOsDeleteSemaphore (Object->Mutex.Semaphore); break; case ACPI_TYPE_EVENT: - DEBUG_PRINTP (ACPI_INFO, ("***** Event %p, Semaphore %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "***** Event %p, Semaphore %p\n", Object, Object->Event.Semaphore)); AcpiOsDeleteSemaphore (Object->Event.Semaphore); Object->Event.Semaphore = NULL; break; case ACPI_TYPE_METHOD: - DEBUG_PRINTP (ACPI_INFO, ("***** Method %p\n", Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "***** Method %p\n", Object)); /* Delete the method semaphore if it exists */ if (Object->Method.Semaphore) { AcpiOsDeleteSemaphore (Object->Method.Semaphore); Object->Method.Semaphore = NULL; } break; case ACPI_TYPE_REGION: - DEBUG_PRINTP (ACPI_INFO, ("***** Region %p\n", Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "***** Region %p\n", Object)); if (Object->Region.Extra) { /* * Free the RegionContext if and only if the handler is one of the * default handlers -- and therefore, we created the context object * locally, it was not created by an external caller. */ HandlerDesc = Object->Region.AddrHandler; if ((HandlerDesc) && (HandlerDesc->AddrHandler.Hflags == ADDR_HANDLER_DEFAULT_INSTALLED)) { ObjPointer = Object->Region.Extra->Extra.RegionContext; } /* Now we can free the Extra object */ AcpiUtDeleteObjectDesc (Object->Region.Extra); } break; case ACPI_TYPE_BUFFER_FIELD: - DEBUG_PRINTP (ACPI_INFO, ("***** Buffer Field %p\n", Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "***** Buffer Field %p\n", Object)); if (Object->BufferField.Extra) { AcpiUtDeleteObjectDesc (Object->BufferField.Extra); } break; default: break; } /* * Delete any allocated memory found above */ if (ObjPointer) { if (!AcpiTbSystemTablePointer (ObjPointer)) { - DEBUG_PRINTP (ACPI_INFO, ("Deleting Obj Ptr %p \n", ObjPointer)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Deleting Obj Ptr %p \n", ObjPointer)); ACPI_MEM_FREE (ObjPointer); } } /* Only delete the object if it was dynamically allocated */ if (Object->Common.Flags & AOPOBJ_STATIC_ALLOCATION) { - DEBUG_PRINTP (ACPI_INFO, ("Object %p [%s] static allocation, no delete\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Object %p [%s] static allocation, no delete\n", Object, AcpiUtGetTypeName (Object->Common.Type))); } if (!(Object->Common.Flags & AOPOBJ_STATIC_ALLOCATION)) { - DEBUG_PRINTP (ACPI_INFO, ("Deleting object %p [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Deleting object %p [%s]\n", Object, AcpiUtGetTypeName (Object->Common.Type))); AcpiUtDeleteObjectDesc (Object); } return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtDeleteInternalObjectList * * PARAMETERS: *ObjList - Pointer to the list to be deleted * * RETURN: Status - the status of the call * * DESCRIPTION: This function deletes an internal object list, including both * simple objects and package objects * ******************************************************************************/ ACPI_STATUS AcpiUtDeleteInternalObjectList ( ACPI_OPERAND_OBJECT **ObjList) { ACPI_OPERAND_OBJECT **InternalObj; FUNCTION_TRACE ("UtDeleteInternalObjectList"); /* Walk the null-terminated internal list */ for (InternalObj = ObjList; *InternalObj; InternalObj++) { /* * Check for a package * Simple objects are simply stored in the array and do not * need to be deleted separately. */ if (IS_THIS_OBJECT_TYPE ((*InternalObj), ACPI_TYPE_PACKAGE)) { /* Delete the package */ /* * TBD: [Investigate] This might not be the right thing to do, * depending on how the internal package object was allocated!!! */ AcpiUtDeleteInternalObj (*InternalObj); } } /* Free the combined parameter pointer list and object array */ ACPI_MEM_FREE (ObjList); return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiUtUpdateRefCount * * PARAMETERS: *Object - Object whose ref count is to be updated * Action - What to do * * RETURN: New ref count * * DESCRIPTION: Modify the ref count and return it. * ******************************************************************************/ static void AcpiUtUpdateRefCount ( ACPI_OPERAND_OBJECT *Object, UINT32 Action) { UINT16 Count; UINT16 NewCount; PROC_NAME ("UtUpdateRefCount"); if (!Object) { return; } Count = Object->Common.ReferenceCount; NewCount = Count; /* * Reference count action (increment, decrement, or force delete) */ switch (Action) { case REF_INCREMENT: NewCount++; Object->Common.ReferenceCount = NewCount; - DEBUG_PRINTP (ACPI_INFO, ("Obj %p Refs=%X, [Incremented]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Obj %p Refs=%X, [Incremented]\n", Object, NewCount)); break; case REF_DECREMENT: if (Count < 1) { - DEBUG_PRINTP (ACPI_INFO, ("Obj %p Refs=%X, can't decrement! (Set to 0)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Obj %p Refs=%X, can't decrement! (Set to 0)\n", Object, NewCount)); NewCount = 0; } else { NewCount--; - DEBUG_PRINTP (ACPI_INFO, ("Obj %p Refs=%X, [Decremented]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Obj %p Refs=%X, [Decremented]\n", Object, NewCount)); } if (Object->Common.Type == ACPI_TYPE_METHOD) { - DEBUG_PRINTP (ACPI_INFO, ("Method Obj %p Refs=%X, [Decremented]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Method Obj %p Refs=%X, [Decremented]\n", Object, NewCount)); } Object->Common.ReferenceCount = NewCount; if (NewCount == 0) { AcpiUtDeleteInternalObj (Object); } break; case REF_FORCE_DELETE: - DEBUG_PRINTP (ACPI_INFO, ("Obj %p Refs=%X, Force delete! (Set to 0)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Obj %p Refs=%X, Force delete! (Set to 0)\n", Object, Count)); NewCount = 0; Object->Common.ReferenceCount = NewCount; AcpiUtDeleteInternalObj (Object); break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Unknown action (%X)\n", Action)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown action (%X)\n", Action)); break; } /* * Sanity check the reference count, for debug purposes only. * (A deleted object will have a huge reference count) */ if (Count > MAX_REFERENCE_COUNT) { - DEBUG_PRINTP (ACPI_ERROR, - ("**** AE_ERROR **** Invalid Reference Count (%X) in object %p\n\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "**** AE_ERROR **** Invalid Reference Count (%X) in object %p\n\n", Count, Object)); } return; } /******************************************************************************* * * FUNCTION: AcpiUtUpdateObjectReference * * PARAMETERS: *Object - Increment ref count for this object * and all sub-objects * Action - Either REF_INCREMENT or REF_DECREMENT or * REF_FORCE_DELETE * * RETURN: Status * * DESCRIPTION: Increment the object reference count * * Object references are incremented when: * 1) An object is attached to a Node (namespace object) * 2) An object is copied (all subobjects must be incremented) * * Object references are decremented when: * 1) An object is detached from an Node * ******************************************************************************/ ACPI_STATUS AcpiUtUpdateObjectReference ( ACPI_OPERAND_OBJECT *Object, UINT16 Action) { ACPI_STATUS Status; UINT32 i; ACPI_OPERAND_OBJECT *Next; ACPI_OPERAND_OBJECT *New; ACPI_GENERIC_STATE *StateList = NULL; ACPI_GENERIC_STATE *State; FUNCTION_TRACE_PTR ("UtUpdateObjectReference", Object); /* Ignore a null object ptr */ if (!Object) { return_ACPI_STATUS (AE_OK); } /* * Make sure that this isn't a namespace handle or an AML pointer */ if (VALID_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_NAMED)) { - DEBUG_PRINTP (ACPI_INFO, ("Object %p is NS handle\n", Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Object %p is NS handle\n", Object)); return_ACPI_STATUS (AE_OK); } if (AcpiTbSystemTablePointer (Object)) { - DEBUG_PRINTP (ACPI_INFO, ("**** Object %p is Pcode Ptr\n", Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "**** Object %p is Pcode Ptr\n", Object)); return_ACPI_STATUS (AE_OK); } State = AcpiUtCreateUpdateState (Object, Action); while (State) { Object = State->Update.Object; Action = State->Update.Value; AcpiUtDeleteGenericState (State); /* * All sub-objects must have their reference count incremented also. * Different object types have different subobjects. */ switch (Object->Common.Type) { case ACPI_TYPE_DEVICE: Status = AcpiUtCreateUpdateStateAndPush (Object->Device.AddrHandler, Action, &StateList); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } AcpiUtUpdateRefCount (Object->Device.SysHandler, Action); AcpiUtUpdateRefCount (Object->Device.DrvHandler, Action); break; case INTERNAL_TYPE_ADDRESS_HANDLER: /* Must walk list of address handlers */ Next = Object->AddrHandler.Next; while (Next) { New = Next->AddrHandler.Next; AcpiUtUpdateRefCount (Next, Action); Next = New; } break; case ACPI_TYPE_PACKAGE: /* * We must update all the sub-objects of the package * (Each of whom may have their own sub-objects, etc. */ for (i = 0; i < Object->Package.Count; i++) { /* * Push each element onto the stack for later processing. * Note: There can be null elements within the package, * these are simply ignored */ Status = AcpiUtCreateUpdateStateAndPush ( Object->Package.Elements[i], Action, &StateList); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } break; case ACPI_TYPE_BUFFER_FIELD: Status = AcpiUtCreateUpdateStateAndPush ( Object->BufferField.BufferObj, Action, &StateList); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } break; case INTERNAL_TYPE_REGION_FIELD: Status = AcpiUtCreateUpdateStateAndPush ( Object->Field.RegionObj, Action, &StateList); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } break; case INTERNAL_TYPE_BANK_FIELD: Status = AcpiUtCreateUpdateStateAndPush ( Object->BankField.BankRegisterObj, Action, &StateList); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } Status = AcpiUtCreateUpdateStateAndPush ( Object->BankField.RegionObj, Action, &StateList); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } break; case INTERNAL_TYPE_INDEX_FIELD: Status = AcpiUtCreateUpdateStateAndPush ( Object->IndexField.IndexObj, Action, &StateList); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } Status = AcpiUtCreateUpdateStateAndPush ( Object->IndexField.DataObj, Action, &StateList); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } break; case ACPI_TYPE_REGION: /* TBD: [Investigate] AcpiUtUpdateRefCount (Object->Region.AddrHandler, Action); */ /* Status = AcpiUtCreateUpdateStateAndPush (Object->Region.AddrHandler, Action, &StateList); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } */ break; case INTERNAL_TYPE_REFERENCE: break; } /* * Now we can update the count in the main object. This can only * happen after we update the sub-objects in case this causes the * main object to be deleted. */ AcpiUtUpdateRefCount (Object, Action); /* Move on to the next object to be updated */ State = AcpiUtPopGenericState (&StateList); } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiUtAddReference * * PARAMETERS: *Object - Object whose reference count is to be * incremented * * RETURN: None * * DESCRIPTION: Add one reference to an ACPI object * ******************************************************************************/ void AcpiUtAddReference ( ACPI_OPERAND_OBJECT *Object) { FUNCTION_TRACE_PTR ("UtAddReference", Object); /* * Ensure that we have a valid object */ if (!AcpiUtValidInternalObject (Object)) { return_VOID; } /* * We have a valid ACPI internal object, now increment the reference count */ AcpiUtUpdateObjectReference (Object, REF_INCREMENT); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtRemoveReference * * PARAMETERS: *Object - Object whose ref count will be decremented * * RETURN: None * * DESCRIPTION: Decrement the reference count of an ACPI internal object * ******************************************************************************/ void AcpiUtRemoveReference ( ACPI_OPERAND_OBJECT *Object) { FUNCTION_TRACE_PTR ("UtRemoveReference", Object); /* * Ensure that we have a valid object */ if (!AcpiUtValidInternalObject (Object)) { return_VOID; } - DEBUG_PRINTP (ACPI_INFO, ("Obj %p Refs=%X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Obj %p Refs=%X\n", Object, Object->Common.ReferenceCount)); /* * Decrement the reference count, and only actually delete the object * if the reference count becomes 0. (Must also decrement the ref count * of all subobjects!) */ AcpiUtUpdateObjectReference (Object, REF_DECREMENT); return_VOID; } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/uteval.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/uteval.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/uteval.c (revision 82367) @@ -1,489 +1,489 @@ /****************************************************************************** * * Module Name: uteval - Object evaluation - * $Revision: 28 $ + * $Revision: 29 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __UTEVAL_C__ #include "acpi.h" #include "acnamesp.h" #include "acinterp.h" #define _COMPONENT ACPI_UTILITIES MODULE_NAME ("uteval") /******************************************************************************* * * FUNCTION: AcpiUtEvaluateNumericObject * * PARAMETERS: *ObjectName - Object name to be evaluated * DeviceNode - Node for the device * *Address - Where the value is returned * * RETURN: Status * * DESCRIPTION: evaluates a numeric namespace object for a selected device * and stores results in *Address. * * NOTE: Internal function, no parameter validation * ******************************************************************************/ ACPI_STATUS AcpiUtEvaluateNumericObject ( NATIVE_CHAR *ObjectName, ACPI_NAMESPACE_NODE *DeviceNode, ACPI_INTEGER *Address) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_STATUS Status; FUNCTION_TRACE ("UtEvaluateNumericObject"); /* Execute the method */ Status = AcpiNsEvaluateRelative (DeviceNode, ObjectName, NULL, &ObjDesc); if (ACPI_FAILURE (Status)) { if (Status == AE_NOT_FOUND) { - DEBUG_PRINTP (ACPI_INFO, ("%s on %4.4s was not found\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s on %4.4s was not found\n", ObjectName, &DeviceNode->Name)); } else { - DEBUG_PRINTP (ACPI_ERROR, ("%s on %4.4s failed with status %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%s on %4.4s failed with status %s\n", ObjectName, &DeviceNode->Name, AcpiFormatException (Status))); } return_ACPI_STATUS (Status); } /* Did we get a return object? */ if (!ObjDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("No object was returned from %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No object was returned from %s\n", ObjectName)); return_ACPI_STATUS (AE_TYPE); } /* Is the return object of the correct type? */ if (ObjDesc->Common.Type != ACPI_TYPE_INTEGER) { Status = AE_TYPE; - DEBUG_PRINTP (ACPI_ERROR, - ("Type returned from %s was not a number: %X \n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Type returned from %s was not a number: %X \n", ObjectName, ObjDesc->Common.Type)); } else { /* * Since the structure is a union, setting any field will set all * of the variables in the union */ *Address = ObjDesc->Integer.Value; } /* On exit, we must delete the return object */ AcpiUtRemoveReference (ObjDesc); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUtExecute_HID * * PARAMETERS: DeviceNode - Node for the device * *Hid - Where the HID is returned * * RETURN: Status * * DESCRIPTION: Executes the _HID control method that returns the hardware * ID of the device. * * NOTE: Internal function, no parameter validation * ******************************************************************************/ ACPI_STATUS AcpiUtExecute_HID ( ACPI_NAMESPACE_NODE *DeviceNode, ACPI_DEVICE_ID *Hid) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_STATUS Status; FUNCTION_TRACE ("UtExecute_HID"); /* Execute the method */ Status = AcpiNsEvaluateRelative (DeviceNode, METHOD_NAME__HID, NULL, &ObjDesc); if (ACPI_FAILURE (Status)) { if (Status == AE_NOT_FOUND) { - DEBUG_PRINTP (ACPI_INFO, ("_HID on %4.4s was not found\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "_HID on %4.4s was not found\n", &DeviceNode->Name)); } else { - DEBUG_PRINTP (ACPI_ERROR, ("_HID on %4.4s failed %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "_HID on %4.4s failed %s\n", &DeviceNode->Name, AcpiFormatException (Status))); } return_ACPI_STATUS (Status); } /* Did we get a return object? */ if (!ObjDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("No object was returned from _HID\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No object was returned from _HID\n")); return_ACPI_STATUS (AE_TYPE); } /* * A _HID can return either a Number (32 bit compressed EISA ID) or * a string */ if ((ObjDesc->Common.Type != ACPI_TYPE_INTEGER) && (ObjDesc->Common.Type != ACPI_TYPE_STRING)) { Status = AE_TYPE; - DEBUG_PRINTP (ACPI_ERROR, - ("Type returned from _HID not a number or string: %s(%X) \n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Type returned from _HID not a number or string: %s(%X) \n", AcpiUtGetTypeName (ObjDesc->Common.Type), ObjDesc->Common.Type)); } else { if (ObjDesc->Common.Type == ACPI_TYPE_INTEGER) { /* Convert the Numeric HID to string */ AcpiExEisaIdToString ((UINT32) ObjDesc->Integer.Value, Hid->Buffer); } else { /* Copy the String HID from the returned object */ STRNCPY(Hid->Buffer, ObjDesc->String.Pointer, sizeof(Hid->Buffer)); } } /* On exit, we must delete the return object */ AcpiUtRemoveReference (ObjDesc); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUtExecute_UID * * PARAMETERS: DeviceNode - Node for the device * *Uid - Where the UID is returned * * RETURN: Status * * DESCRIPTION: Executes the _UID control method that returns the hardware * ID of the device. * * NOTE: Internal function, no parameter validation * ******************************************************************************/ ACPI_STATUS AcpiUtExecute_UID ( ACPI_NAMESPACE_NODE *DeviceNode, ACPI_DEVICE_ID *Uid) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_STATUS Status; PROC_NAME ("UtExecute_UID"); /* Execute the method */ Status = AcpiNsEvaluateRelative (DeviceNode, METHOD_NAME__UID, NULL, &ObjDesc); if (ACPI_FAILURE (Status)) { if (Status == AE_NOT_FOUND) { - DEBUG_PRINTP (ACPI_INFO, ("_UID on %4.4s was not found\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "_UID on %4.4s was not found\n", &DeviceNode->Name)); } else { - DEBUG_PRINTP (ACPI_ERROR, - ("_UID on %4.4s failed %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "_UID on %4.4s failed %s\n", &DeviceNode->Name, AcpiFormatException (Status))); } return (Status); } /* Did we get a return object? */ if (!ObjDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("No object was returned from _UID\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No object was returned from _UID\n")); return (AE_TYPE); } /* * A _UID can return either a Number (32 bit compressed EISA ID) or * a string */ if ((ObjDesc->Common.Type != ACPI_TYPE_INTEGER) && (ObjDesc->Common.Type != ACPI_TYPE_STRING)) { Status = AE_TYPE; - DEBUG_PRINTP (ACPI_ERROR, - ("Type returned from _UID was not a number or string: %X \n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Type returned from _UID was not a number or string: %X \n", ObjDesc->Common.Type)); } else { if (ObjDesc->Common.Type == ACPI_TYPE_INTEGER) { /* Convert the Numeric UID to string */ AcpiExUnsignedIntegerToString (ObjDesc->Integer.Value, Uid->Buffer); } else { /* Copy the String UID from the returned object */ STRNCPY(Uid->Buffer, ObjDesc->String.Pointer, sizeof(Uid->Buffer)); } } /* On exit, we must delete the return object */ AcpiUtRemoveReference (ObjDesc); return (Status); } /******************************************************************************* * * FUNCTION: AcpiUtExecute_STA * * PARAMETERS: DeviceNode - Node for the device * *Flags - Where the status flags are returned * * RETURN: Status * * DESCRIPTION: Executes _STA for selected device and stores results in * *Flags. * * NOTE: Internal function, no parameter validation * ******************************************************************************/ ACPI_STATUS AcpiUtExecute_STA ( ACPI_NAMESPACE_NODE *DeviceNode, UINT32 *Flags) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_STATUS Status; FUNCTION_TRACE ("UtExecute_STA"); /* Execute the method */ Status = AcpiNsEvaluateRelative (DeviceNode, METHOD_NAME__STA, NULL, &ObjDesc); if (AE_NOT_FOUND == Status) { - DEBUG_PRINTP (ACPI_INFO, - ("_STA on %4.4s was not found, assuming present.\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "_STA on %4.4s was not found, assuming present.\n", &DeviceNode->Name)); *Flags = 0x0F; Status = AE_OK; } else if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("_STA on %4.4s failed %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "_STA on %4.4s failed %s\n", &DeviceNode->Name, AcpiFormatException (Status))); } else /* success */ { /* Did we get a return object? */ if (!ObjDesc) { - DEBUG_PRINTP (ACPI_ERROR, ("No object was returned from _STA\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No object was returned from _STA\n")); return_ACPI_STATUS (AE_TYPE); } /* Is the return object of the correct type? */ if (ObjDesc->Common.Type != ACPI_TYPE_INTEGER) { Status = AE_TYPE; - DEBUG_PRINTP (ACPI_ERROR, - ("Type returned from _STA was not a number: %X \n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Type returned from _STA was not a number: %X \n", ObjDesc->Common.Type)); } else { /* Extract the status flags */ *Flags = (UINT32) ObjDesc->Integer.Value; } /* On exit, we must delete the return object */ AcpiUtRemoveReference (ObjDesc); } return_ACPI_STATUS (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/utglobal.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/utglobal.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/utglobal.c (revision 82367) @@ -1,795 +1,808 @@ /****************************************************************************** * * Module Name: utglobal - Global variables for the ACPI subsystem - * $Revision: 125 $ + * $Revision: 127 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __UTGLOBAL_C__ #define DEFINE_ACPI_GLOBALS #include "acpi.h" #include "acevents.h" #include "acnamesp.h" #include "acinterp.h" #include "amlcode.h" #define _COMPONENT ACPI_UTILITIES MODULE_NAME ("utglobal") /****************************************************************************** * * FUNCTION: AcpiFormatException * * PARAMETERS: Status - The ACPI_STATUS code to be formatted * * RETURN: A string containing the exception text * * DESCRIPTION: This function translates an ACPI exception into an ASCII string. * ******************************************************************************/ const char * AcpiFormatException ( ACPI_STATUS Status) { char *Exception = "UNKNOWN_STATUS_CODE"; ACPI_STATUS SubStatus; SubStatus = (Status & ~AE_CODE_MASK); switch (Status & AE_CODE_MASK) { case AE_CODE_ENVIRONMENTAL: if (SubStatus <= AE_CODE_ENV_MAX) { Exception = AcpiGbl_ExceptionNames_Env [SubStatus]; } break; case AE_CODE_PROGRAMMER: if (SubStatus <= AE_CODE_PGM_MAX) { Exception = AcpiGbl_ExceptionNames_Pgm [SubStatus -1]; } break; case AE_CODE_ACPI_TABLES: if (SubStatus <= AE_CODE_TBL_MAX) { Exception = AcpiGbl_ExceptionNames_Tbl [SubStatus -1]; } break; case AE_CODE_AML: if (SubStatus <= AE_CODE_AML_MAX) { Exception = AcpiGbl_ExceptionNames_Aml [SubStatus -1]; } break; case AE_CODE_CONTROL: if (SubStatus <= AE_CODE_CTRL_MAX) { Exception = AcpiGbl_ExceptionNames_Ctrl [SubStatus -1]; } break; default: break; } return ((const char *) Exception); } /****************************************************************************** * * Static global variable initialization. * ******************************************************************************/ /* * We want the debug switches statically initialized so they * are already set when the debugger is entered. */ /* Debug switch - level and trace mask */ #ifdef ACPI_DEBUG UINT32 AcpiDbgLevel = DEBUG_DEFAULT; #else UINT32 AcpiDbgLevel = NORMAL_DEFAULT; #endif /* Debug switch - layer (component) mask */ UINT32 AcpiDbgLayer = ACPI_COMPONENT_DEFAULT; UINT32 AcpiGbl_NestingLevel = 0; /* Debugger globals */ BOOLEAN AcpiGbl_DbTerminateThreads = FALSE; BOOLEAN AcpiGbl_MethodExecuting = FALSE; /* System flags */ UINT32 AcpiGbl_SystemFlags = 0; UINT32 AcpiGbl_StartupFlags = 0; /* System starts unitialized! */ BOOLEAN AcpiGbl_Shutdown = TRUE; UINT8 AcpiGbl_DecodeTo8bit [8] = {1,2,4,8,16,32,64,128}; /****************************************************************************** * * Namespace globals * ******************************************************************************/ /* * Names built-in to the interpreter * * Initial values are currently supported only for types String and Number. * To avoid type punning, both are specified as strings in this table. * * NOTES: * 1) _SB_ is defined to be a device to allow _SB_/_INI to be run * during the initialization sequence. */ PREDEFINED_NAMES AcpiGbl_PreDefinedNames[] = { {"_GPE", INTERNAL_TYPE_DEF_ANY}, {"_PR_", INTERNAL_TYPE_DEF_ANY}, {"_SB_", ACPI_TYPE_DEVICE}, {"_SI_", INTERNAL_TYPE_DEF_ANY}, {"_TZ_", INTERNAL_TYPE_DEF_ANY}, {"_REV", ACPI_TYPE_INTEGER, "2"}, {"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME}, {"_GL_", ACPI_TYPE_MUTEX, "0"}, {NULL, ACPI_TYPE_ANY} /* Table terminator */ }; /* * Properties of the ACPI Object Types, both internal and external. * * Elements of AcpiNsProperties are bit significant * and the table is indexed by values of ACPI_OBJECT_TYPE */ UINT8 AcpiGbl_NsProperties[] = { NSP_NORMAL, /* 00 Any */ NSP_NORMAL, /* 01 Number */ NSP_NORMAL, /* 02 String */ NSP_NORMAL, /* 03 Buffer */ NSP_LOCAL, /* 04 Package */ NSP_NORMAL, /* 05 FieldUnit */ NSP_NEWSCOPE | NSP_LOCAL, /* 06 Device */ NSP_LOCAL, /* 07 AcpiEvent */ NSP_NEWSCOPE | NSP_LOCAL, /* 08 Method */ NSP_LOCAL, /* 09 Mutex */ NSP_LOCAL, /* 10 Region */ NSP_NEWSCOPE | NSP_LOCAL, /* 11 Power */ NSP_NEWSCOPE | NSP_LOCAL, /* 12 Processor */ NSP_NEWSCOPE | NSP_LOCAL, /* 13 Thermal */ NSP_NORMAL, /* 14 BufferField */ NSP_NORMAL, /* 15 DdbHandle */ NSP_NORMAL, /* 16 Debug Object */ NSP_NORMAL, /* 17 DefField */ NSP_NORMAL, /* 18 BankField */ NSP_NORMAL, /* 19 IndexField */ NSP_NORMAL, /* 20 Reference */ NSP_NORMAL, /* 21 Alias */ NSP_NORMAL, /* 22 Notify */ NSP_NORMAL, /* 23 Address Handler */ NSP_NEWSCOPE | NSP_LOCAL, /* 24 Resource Desc */ NSP_NEWSCOPE | NSP_LOCAL, /* 25 Resource Field */ NSP_NORMAL, /* 26 DefFieldDefn */ NSP_NORMAL, /* 27 BankFieldDefn */ NSP_NORMAL, /* 28 IndexFieldDefn */ NSP_NORMAL, /* 29 If */ NSP_NORMAL, /* 30 Else */ NSP_NORMAL, /* 31 While */ NSP_NEWSCOPE, /* 32 Scope */ NSP_LOCAL, /* 33 DefAny */ NSP_NORMAL, /* 34 Extra */ NSP_NORMAL /* 35 Invalid */ }; /* Hex to ASCII conversion table */ NATIVE_CHAR AcpiGbl_HexToAscii[] = {'0','1','2','3','4','5','6','7', '8','9','A','B','C','D','E','F'}; +UINT8 +AcpiUtHexToAsciiChar ( + ACPI_INTEGER Integer, + UINT32 Position) +{ + return (AcpiGbl_HexToAscii[(Integer >> Position) & 0xF]); +} + /****************************************************************************** * * Table globals * * NOTE: This table includes ONLY the ACPI tables that the subsystem consumes. * it is NOT an exhaustive list of all possible ACPI tables. All ACPI tables * that are not used by the subsystem are simply ignored. * ******************************************************************************/ ACPI_TABLE_DESC AcpiGbl_AcpiTables[NUM_ACPI_TABLES]; ACPI_TABLE_SUPPORT AcpiGbl_AcpiTableData[NUM_ACPI_TABLES] = { /*********** Name, Signature, Signature size, How many allowed?, Supported? Global typed pointer */ /* RSDP 0 */ {RSDP_NAME, RSDP_SIG, sizeof (RSDP_SIG)-1, ACPI_TABLE_SINGLE, AE_OK, NULL}, /* DSDT 1 */ {DSDT_SIG, DSDT_SIG, sizeof (DSDT_SIG)-1, ACPI_TABLE_SINGLE, AE_OK, (void **) &AcpiGbl_DSDT}, /* FADT 2 */ {FADT_SIG, FADT_SIG, sizeof (FADT_SIG)-1, ACPI_TABLE_SINGLE, AE_OK, (void **) &AcpiGbl_FADT}, /* FACS 3 */ {FACS_SIG, FACS_SIG, sizeof (FACS_SIG)-1, ACPI_TABLE_SINGLE, AE_OK, (void **) &AcpiGbl_FACS}, /* PSDT 4 */ {PSDT_SIG, PSDT_SIG, sizeof (PSDT_SIG)-1, ACPI_TABLE_MULTIPLE, AE_OK, NULL}, /* SSDT 5 */ {SSDT_SIG, SSDT_SIG, sizeof (SSDT_SIG)-1, ACPI_TABLE_MULTIPLE, AE_OK, NULL}, /* XSDT 6 */ {XSDT_SIG, XSDT_SIG, sizeof (RSDT_SIG)-1, ACPI_TABLE_SINGLE, AE_OK, NULL}, }; #ifdef ACPI_DEBUG /****************************************************************************** * * Strings and procedures used for debug only * ******************************************************************************/ NATIVE_CHAR *MsgAcpiErrorBreak = "*** Break on ACPI_ERROR ***\n"; /***************************************************************************** * * FUNCTION: AcpiUtGetMutexName * * PARAMETERS: None. * * RETURN: Status * * DESCRIPTION: Translate a mutex ID into a name string (Debug only) * ****************************************************************************/ NATIVE_CHAR * AcpiUtGetMutexName ( UINT32 MutexId) { if (MutexId > MAX_MTX) { return ("Invalid Mutex ID"); } return (AcpiGbl_MutexNames[MutexId]); } /* * Elements of AcpiGbl_NsTypeNames below must match * one-to-one with values of ACPI_OBJECT_TYPE * * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching; when * stored in a table it really means that we have thus far seen no evidence to * indicatewhat type is actually going to be stored for this entry. */ static NATIVE_CHAR AcpiGbl_BadType[] = "UNDEFINED"; #define TYPE_NAME_LENGTH 9 /* Maximum length of each string */ static NATIVE_CHAR *AcpiGbl_NsTypeNames[] = /* printable names of ACPI types */ { /* 00 */ "Untyped", /* 01 */ "Integer", /* 02 */ "String", /* 03 */ "Buffer", /* 04 */ "Package", /* 05 */ "FieldUnit", /* 06 */ "Device", /* 07 */ "Event", /* 08 */ "Method", /* 09 */ "Mutex", /* 10 */ "Region", /* 11 */ "Power", /* 12 */ "Processor", /* 13 */ "Thermal", /* 14 */ "BuffField", /* 15 */ "DdbHandle", /* 16 */ "DebugObj", /* 17 */ "RegnField", /* 18 */ "BankField", /* 19 */ "IndxField", /* 20 */ "Reference", /* 21 */ "Alias", /* 22 */ "Notify", /* 23 */ "AddrHndlr", /* 24 */ "RsrcDesc", /* 25 */ "RsrcField", /* 26 */ "RgnFldDfn", /* 27 */ "BnkFldDfn", /* 28 */ "IdxFldDfn", /* 29 */ "If", /* 30 */ "Else", /* 31 */ "While", /* 32 */ "Scope", /* 33 */ "DefAny", /* 34 */ "Extra", /* 35 */ "Invalid" }; /***************************************************************************** * * FUNCTION: AcpiUtGetTypeName * * PARAMETERS: None. * * RETURN: Status * * DESCRIPTION: Translate a Type ID into a name string (Debug only) * ****************************************************************************/ NATIVE_CHAR * AcpiUtGetTypeName ( UINT32 Type) { if (Type > INTERNAL_TYPE_INVALID) { return (AcpiGbl_BadType); } return (AcpiGbl_NsTypeNames[Type]); } /* Region type decoding */ NATIVE_CHAR *AcpiGbl_RegionTypes[NUM_REGION_TYPES] = { "SystemMemory", "SystemIO", "PCIConfig", "EmbeddedControl", "SMBus", "CMOS", "PCIBarTarget", }; /***************************************************************************** * * FUNCTION: AcpiUtGetRegionName * * PARAMETERS: None. * * RETURN: Status * * DESCRIPTION: Translate a Space ID into a name string (Debug only) * ****************************************************************************/ NATIVE_CHAR * AcpiUtGetRegionName ( UINT8 SpaceId) { if (SpaceId >= USER_REGION_BEGIN) { return ("UserDefinedRegion"); } else if (SpaceId >= NUM_REGION_TYPES) { return ("InvalidSpaceID"); } return (AcpiGbl_RegionTypes[SpaceId]); } /* Data used in keeping track of fields */ NATIVE_CHAR *AcpiGbl_FENames[NUM_FIELD_NAMES] = { "skip", "?access?" }; /* FE = Field Element */ NATIVE_CHAR *AcpiGbl_MatchOps[NUM_MATCH_OPS] = { "Error", "MTR", "MEQ", "MLE", "MLT", "MGE", "MGT" }; /* Access type decoding */ NATIVE_CHAR *AcpiGbl_AccessTypes[NUM_ACCESS_TYPES] = { "AnyAcc", "ByteAcc", "WordAcc", "DWordAcc", "BlockAcc", "SMBSendRecvAcc", "SMBQuickAcc" }; /* Update rule decoding */ NATIVE_CHAR *AcpiGbl_UpdateRules[NUM_UPDATE_RULES] = { "Preserve", "WriteAsOnes", "WriteAsZeros" }; #endif /***************************************************************************** * * FUNCTION: AcpiUtValidObjectType * * PARAMETERS: None. * * RETURN: TRUE if valid object type * * DESCRIPTION: Validate an object type * ****************************************************************************/ BOOLEAN AcpiUtValidObjectType ( UINT32 Type) { if (Type > ACPI_TYPE_MAX) { if ((Type < INTERNAL_TYPE_BEGIN) || (Type > INTERNAL_TYPE_MAX)) { return (FALSE); } } return (TRUE); } /**************************************************************************** * * FUNCTION: AcpiUtAllocateOwnerId * * PARAMETERS: IdType - Type of ID (method or table) * * DESCRIPTION: Allocate a table or method owner id * ***************************************************************************/ ACPI_OWNER_ID AcpiUtAllocateOwnerId ( UINT32 IdType) { ACPI_OWNER_ID OwnerId = 0xFFFF; FUNCTION_TRACE ("UtAllocateOwnerId"); AcpiUtAcquireMutex (ACPI_MTX_CACHES); switch (IdType) { case OWNER_TYPE_TABLE: OwnerId = AcpiGbl_NextTableOwnerId; AcpiGbl_NextTableOwnerId++; if (AcpiGbl_NextTableOwnerId == FIRST_METHOD_ID) { AcpiGbl_NextTableOwnerId = FIRST_TABLE_ID; } break; case OWNER_TYPE_METHOD: OwnerId = AcpiGbl_NextMethodOwnerId; AcpiGbl_NextMethodOwnerId++; if (AcpiGbl_NextMethodOwnerId == FIRST_TABLE_ID) { AcpiGbl_NextMethodOwnerId = FIRST_METHOD_ID; } break; } AcpiUtReleaseMutex (ACPI_MTX_CACHES); return_VALUE (OwnerId); } /**************************************************************************** * * FUNCTION: AcpiUtInitGlobals * * PARAMETERS: none * * DESCRIPTION: Init library globals. All globals that require specific * initialization should be initialized here! * ***************************************************************************/ void AcpiUtInitGlobals ( void) { UINT32 i; FUNCTION_TRACE ("UtInitGlobals"); + + /* Memory allocation and cache lists */ + + MEMSET (AcpiGbl_MemoryLists, 0, + sizeof (ACPI_MEMORY_LIST) * ACPI_NUM_MEM_LISTS); + + AcpiGbl_MemoryLists[ACPI_MEM_LIST_STATE].LinkOffset = (UINT16) (NATIVE_UINT) &(((ACPI_GENERIC_STATE *) NULL)->Common.Next); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE].LinkOffset = (UINT16) (NATIVE_UINT) &(((ACPI_PARSE_OBJECT *) NULL)->Next); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE_EXT].LinkOffset = (UINT16) (NATIVE_UINT) &(((ACPI_PARSE2_OBJECT *) NULL)->Next); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_OPERAND].LinkOffset = (UINT16) (NATIVE_UINT) &(((ACPI_OPERAND_OBJECT *) NULL)->Cache.Next); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_WALK].LinkOffset = (UINT16) (NATIVE_UINT) &(((ACPI_WALK_STATE *) NULL)->Next); + + AcpiGbl_MemoryLists[ACPI_MEM_LIST_NSNODE].ObjectSize = sizeof (ACPI_NAMESPACE_NODE); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_STATE].ObjectSize = sizeof (ACPI_GENERIC_STATE); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE].ObjectSize = sizeof (ACPI_PARSE_OBJECT); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE_EXT].ObjectSize = sizeof (ACPI_PARSE2_OBJECT); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_OPERAND].ObjectSize = sizeof (ACPI_OPERAND_OBJECT); + AcpiGbl_MemoryLists[ACPI_MEM_LIST_WALK].ObjectSize = sizeof (ACPI_WALK_STATE); + + AcpiGbl_MemoryLists[ACPI_MEM_LIST_STATE].MaxCacheDepth = MAX_STATE_CACHE_DEPTH; + AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE].MaxCacheDepth = MAX_PARSE_CACHE_DEPTH; + AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE_EXT].MaxCacheDepth = MAX_EXTPARSE_CACHE_DEPTH; + AcpiGbl_MemoryLists[ACPI_MEM_LIST_OPERAND].MaxCacheDepth = MAX_OBJECT_CACHE_DEPTH; + AcpiGbl_MemoryLists[ACPI_MEM_LIST_WALK].MaxCacheDepth = MAX_WALK_CACHE_DEPTH; + + + ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_GLOBAL].ListName = "Global Memory Allocation"); + ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_NSNODE].ListName = "Namespace Nodes"); + ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_STATE].ListName = "State Object Cache"); + ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE].ListName = "Parse Node Cache"); + ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE_EXT].ListName = "Extended Parse Node Cache"); + ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_OPERAND].ListName = "Operand Object Cache"); + ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_WALK].ListName = "Tree Walk Node Cache"); + /* ACPI table structure */ for (i = 0; i < NUM_ACPI_TABLES; i++) { AcpiGbl_AcpiTables[i].Prev = &AcpiGbl_AcpiTables[i]; AcpiGbl_AcpiTables[i].Next = &AcpiGbl_AcpiTables[i]; AcpiGbl_AcpiTables[i].Pointer = NULL; AcpiGbl_AcpiTables[i].Length = 0; AcpiGbl_AcpiTables[i].Allocation = ACPI_MEM_NOT_ALLOCATED; AcpiGbl_AcpiTables[i].Count = 0; } /* Address Space handler array */ for (i = 0; i < ACPI_NUM_ADDRESS_SPACES; i++) { AcpiGbl_AddressSpaces[i].Handler = NULL; AcpiGbl_AddressSpaces[i].Context = NULL; } /* Mutex locked flags */ for (i = 0; i < NUM_MTX; i++) { AcpiGbl_AcpiMutexInfo[i].Mutex = NULL; AcpiGbl_AcpiMutexInfo[i].OwnerId = ACPI_MUTEX_NOT_ACQUIRED; AcpiGbl_AcpiMutexInfo[i].UseCount = 0; } /* Global notify handlers */ AcpiGbl_SysNotify.Handler = NULL; AcpiGbl_DrvNotify.Handler = NULL; /* Global "typed" ACPI table pointers */ AcpiGbl_RSDP = NULL; AcpiGbl_XSDT = NULL; AcpiGbl_FACS = NULL; AcpiGbl_FADT = NULL; AcpiGbl_DSDT = NULL; /* Global Lock support */ AcpiGbl_GlobalLockAcquired = FALSE; AcpiGbl_GlobalLockThreadCount = 0; /* Miscellaneous variables */ AcpiGbl_SystemFlags = 0; AcpiGbl_StartupFlags = 0; AcpiGbl_RsdpOriginalLocation = 0; AcpiGbl_CmSingleStep = FALSE; AcpiGbl_DbTerminateThreads = FALSE; AcpiGbl_Shutdown = FALSE; AcpiGbl_NsLookupCount = 0; AcpiGbl_PsFindCount = 0; AcpiGbl_AcpiHardwarePresent = TRUE; AcpiGbl_NextTableOwnerId = FIRST_TABLE_ID; AcpiGbl_NextMethodOwnerId = FIRST_METHOD_ID; AcpiGbl_DebuggerConfiguration = DEBUGGER_THREADING; - /* Cache of small "state" objects */ - AcpiGbl_GenericStateCache = NULL; - AcpiGbl_GenericStateCacheDepth = 0; - AcpiGbl_StateCacheRequests = 0; - AcpiGbl_StateCacheHits = 0; - - AcpiGbl_ParseCache = NULL; - AcpiGbl_ParseCacheDepth = 0; - AcpiGbl_ParseCacheRequests = 0; - AcpiGbl_ParseCacheHits = 0; - - AcpiGbl_ExtParseCache = NULL; - AcpiGbl_ExtParseCacheDepth = 0; - AcpiGbl_ExtParseCacheRequests = 0; - AcpiGbl_ExtParseCacheHits = 0; - - AcpiGbl_ObjectCache = NULL; - AcpiGbl_ObjectCacheDepth = 0; - AcpiGbl_ObjectCacheRequests = 0; - AcpiGbl_ObjectCacheHits = 0; - - AcpiGbl_WalkStateCache = NULL; - AcpiGbl_WalkStateCacheDepth = 0; - AcpiGbl_WalkStateCacheRequests = 0; - AcpiGbl_WalkStateCacheHits = 0; - /* Hardware oriented */ AcpiGbl_Gpe0EnableRegisterSave = NULL; AcpiGbl_Gpe1EnableRegisterSave = NULL; AcpiGbl_OriginalMode = SYS_MODE_UNKNOWN; /* original ACPI/legacy mode */ AcpiGbl_GpeRegisters = NULL; AcpiGbl_GpeInfo = NULL; /* Namespace */ AcpiGbl_RootNode = NULL; AcpiGbl_RootNodeStruct.Name = ACPI_ROOT_NAME; AcpiGbl_RootNodeStruct.DataType = ACPI_DESC_TYPE_NAMED; AcpiGbl_RootNodeStruct.Type = ACPI_TYPE_ANY; AcpiGbl_RootNodeStruct.Child = NULL; AcpiGbl_RootNodeStruct.Peer = NULL; AcpiGbl_RootNodeStruct.Object = NULL; AcpiGbl_RootNodeStruct.Flags = ANOBJ_END_OF_PEER_LIST; - /* Memory allocation metrics - compiled out in non-debug mode. */ - - INITIALIZE_ALLOCATION_METRICS(); return_VOID; } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/utinit.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/utinit.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/utinit.c (revision 82367) @@ -1,360 +1,360 @@ /****************************************************************************** * * Module Name: utinit - Common ACPI subsystem initialization - * $Revision: 98 $ + * $Revision: 99 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __UTINIT_C__ #include "acpi.h" #include "achware.h" #include "acnamesp.h" #include "acevents.h" #include "acparser.h" #include "acdispat.h" #define _COMPONENT ACPI_UTILITIES MODULE_NAME ("utinit") #define ACPI_OFFSET(d,o) ((UINT32) &(((d *)0)->o)) #define ACPI_FADT_OFFSET(o) ACPI_OFFSET (FADT_DESCRIPTOR, o) /******************************************************************************* * * FUNCTION: AcpiUtFadtRegisterError * * PARAMETERS: *RegisterName - Pointer to string identifying register * Value - Actual register contents value * AcpiTestSpecSection - TDS section containing assertion * AcpiAssertion - Assertion number being tested * * RETURN: AE_BAD_VALUE * * DESCRIPTION: Display failure message and link failure to TDS assertion * ******************************************************************************/ static ACPI_STATUS AcpiUtFadtRegisterError ( NATIVE_CHAR *RegisterName, UINT32 Value, UINT32 Offset) { REPORT_ERROR ( ("Invalid FADT value %s=%lX at offset %lX FADT=%p\n", RegisterName, Value, Offset, AcpiGbl_FADT)); return (AE_BAD_VALUE); } /****************************************************************************** * * FUNCTION: AcpiUtValidateFadt * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Validate various ACPI registers in the FADT * ******************************************************************************/ ACPI_STATUS AcpiUtValidateFadt ( void) { ACPI_STATUS Status = AE_OK; /* * Verify Fixed ACPI Description Table fields, * but don't abort on any problems, just display error */ if (AcpiGbl_FADT->Pm1EvtLen < 4) { Status = AcpiUtFadtRegisterError ("PM1_EVT_LEN", (UINT32) AcpiGbl_FADT->Pm1EvtLen, ACPI_FADT_OFFSET (Pm1EvtLen)); } if (!AcpiGbl_FADT->Pm1CntLen) { Status = AcpiUtFadtRegisterError ("PM1_CNT_LEN", 0, ACPI_FADT_OFFSET (Pm1CntLen)); } if (!ACPI_VALID_ADDRESS (AcpiGbl_FADT->XPm1aEvtBlk.Address)) { Status = AcpiUtFadtRegisterError ("X_PM1a_EVT_BLK", 0, ACPI_FADT_OFFSET (XPm1aEvtBlk.Address)); } if (!ACPI_VALID_ADDRESS (AcpiGbl_FADT->XPm1aCntBlk.Address)) { Status = AcpiUtFadtRegisterError ("X_PM1a_CNT_BLK", 0, ACPI_FADT_OFFSET (XPm1aCntBlk.Address)); } if (!ACPI_VALID_ADDRESS (AcpiGbl_FADT->XPmTmrBlk.Address)) { Status = AcpiUtFadtRegisterError ("X_PM_TMR_BLK", 0, ACPI_FADT_OFFSET (XPmTmrBlk.Address)); } if ((ACPI_VALID_ADDRESS (AcpiGbl_FADT->XPm2CntBlk.Address) && !AcpiGbl_FADT->Pm2CntLen)) { Status = AcpiUtFadtRegisterError ("PM2_CNT_LEN", (UINT32) AcpiGbl_FADT->Pm2CntLen, ACPI_FADT_OFFSET (Pm2CntLen)); } if (AcpiGbl_FADT->PmTmLen < 4) { Status = AcpiUtFadtRegisterError ("PM_TM_LEN", (UINT32) AcpiGbl_FADT->PmTmLen, ACPI_FADT_OFFSET (PmTmLen)); } /* length of GPE blocks must be a multiple of 2 */ if (ACPI_VALID_ADDRESS (AcpiGbl_FADT->XGpe0Blk.Address) && (AcpiGbl_FADT->Gpe0BlkLen & 1)) { Status = AcpiUtFadtRegisterError ("(x)GPE0_BLK_LEN", (UINT32) AcpiGbl_FADT->Gpe0BlkLen, ACPI_FADT_OFFSET (Gpe0BlkLen)); } if (ACPI_VALID_ADDRESS (AcpiGbl_FADT->XGpe1Blk.Address) && (AcpiGbl_FADT->Gpe1BlkLen & 1)) { Status = AcpiUtFadtRegisterError ("(x)GPE1_BLK_LEN", (UINT32) AcpiGbl_FADT->Gpe1BlkLen, ACPI_FADT_OFFSET (Gpe1BlkLen)); } return (Status); } /****************************************************************************** * * FUNCTION: AcpiUtTerminate * * PARAMETERS: none * * RETURN: none * * DESCRIPTION: free memory allocated for table storage. * ******************************************************************************/ void AcpiUtTerminate (void) { FUNCTION_TRACE ("UtTerminate"); /* Free global tables, etc. */ if (AcpiGbl_Gpe0EnableRegisterSave) { ACPI_MEM_FREE (AcpiGbl_Gpe0EnableRegisterSave); } if (AcpiGbl_Gpe1EnableRegisterSave) { ACPI_MEM_FREE (AcpiGbl_Gpe1EnableRegisterSave); } return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtSubsystemShutdown * * PARAMETERS: none * * RETURN: none * * DESCRIPTION: Shutdown the various subsystems. Don't delete the mutex * objects here -- because the AML debugger may be still running. * ******************************************************************************/ ACPI_STATUS AcpiUtSubsystemShutdown (void) { FUNCTION_TRACE ("UtSubsystemShutdown"); /* Just exit if subsystem is already shutdown */ if (AcpiGbl_Shutdown) { - DEBUG_PRINTP (ACPI_ERROR, ("ACPI Subsystem is already terminated\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "ACPI Subsystem is already terminated\n")); return_ACPI_STATUS (AE_OK); } /* Subsystem appears active, go ahead and shut it down */ AcpiGbl_Shutdown = TRUE; - DEBUG_PRINTP (ACPI_INFO, ("Shutting down ACPI Subsystem...\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Shutting down ACPI Subsystem...\n")); /* Close the Namespace */ AcpiNsTerminate (); /* Close the AcpiEvent Handling */ AcpiEvTerminate (); /* Close the globals */ AcpiUtTerminate (); /* Flush the local cache(s) */ AcpiUtDeleteGenericStateCache (); AcpiUtDeleteObjectCache (); AcpiDsDeleteWalkStateCache (); /* Close the Parser */ /* TBD: [Restructure] AcpiPsTerminate () */ AcpiPsDeleteParseCache (); /* Debug only - display leftover memory allocation, if any */ #ifdef ACPI_DBG_TRACK_ALLOCATIONS AcpiUtDumpCurrentAllocations (ACPI_UINT32_MAX, NULL); #endif return_ACPI_STATUS (AE_OK); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/utmisc.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/utmisc.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/utmisc.c (revision 82367) @@ -1,1305 +1,1234 @@ /******************************************************************************* * * Module Name: utmisc - common utility procedures - * $Revision: 44 $ + * $Revision: 46 $ * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __UTMISC_C__ #include "acpi.h" #include "acevents.h" #include "achware.h" #include "acnamesp.h" #include "acinterp.h" #include "amlcode.h" #include "acdebug.h" #define _COMPONENT ACPI_UTILITIES MODULE_NAME ("utmisc") /******************************************************************************* * * FUNCTION: AcpiUtValidAcpiName * * PARAMETERS: Character - The character to be examined * * RETURN: 1 if Character may appear in a name, else 0 * * DESCRIPTION: Check for a valid ACPI name. Each character must be one of: * 1) Upper case alpha * 2) numeric * 3) underscore * ******************************************************************************/ BOOLEAN AcpiUtValidAcpiName ( UINT32 Name) { NATIVE_CHAR *NamePtr = (NATIVE_CHAR *) &Name; UINT32 i; for (i = 0; i < ACPI_NAME_SIZE; i++) { if (!((NamePtr[i] == '_') || (NamePtr[i] >= 'A' && NamePtr[i] <= 'Z') || (NamePtr[i] >= '0' && NamePtr[i] <= '9'))) { return (FALSE); } } return (TRUE); } /******************************************************************************* * * FUNCTION: AcpiUtValidAcpiCharacter * * PARAMETERS: Character - The character to be examined * * RETURN: 1 if Character may appear in a name, else 0 * * DESCRIPTION: Check for a printable character * ******************************************************************************/ BOOLEAN AcpiUtValidAcpiCharacter ( NATIVE_CHAR Character) { return ((BOOLEAN) ((Character == '_') || (Character >= 'A' && Character <= 'Z') || (Character >= '0' && Character <= '9'))); } /******************************************************************************* * * FUNCTION: AcpiUtStrupr * * PARAMETERS: SrcString - The source string to convert to * * RETURN: SrcString * * DESCRIPTION: Convert string to uppercase * ******************************************************************************/ NATIVE_CHAR * AcpiUtStrupr ( NATIVE_CHAR *SrcString) { NATIVE_CHAR *String; /* Walk entire string, uppercasing the letters */ for (String = SrcString; *String; ) { *String = (char) TOUPPER (*String); String++; } return (SrcString); } /******************************************************************************* * * FUNCTION: AcpiUtMutexInitialize * * PARAMETERS: None. * * RETURN: Status * * DESCRIPTION: Create the system mutex objects. * ******************************************************************************/ ACPI_STATUS AcpiUtMutexInitialize ( void) { UINT32 i; ACPI_STATUS Status; FUNCTION_TRACE ("UtMutexInitialize"); /* * Create each of the predefined mutex objects */ for (i = 0; i < NUM_MTX; i++) { Status = AcpiUtCreateMutex (i); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } return_ACPI_STATUS (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiUtMutexTerminate * * PARAMETERS: None. * * RETURN: None. * * DESCRIPTION: Delete all of the system mutex objects. * ******************************************************************************/ void AcpiUtMutexTerminate ( void) { UINT32 i; FUNCTION_TRACE ("UtMutexTerminate"); /* * Delete each predefined mutex object */ for (i = 0; i < NUM_MTX; i++) { AcpiUtDeleteMutex (i); } return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtCreateMutex * * PARAMETERS: MutexID - ID of the mutex to be created * * RETURN: Status * * DESCRIPTION: Create a mutex object. * ******************************************************************************/ ACPI_STATUS AcpiUtCreateMutex ( ACPI_MUTEX_HANDLE MutexId) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE_U32 ("UtCreateMutex", MutexId); if (MutexId > MAX_MTX) { return_ACPI_STATUS (AE_BAD_PARAMETER); } if (!AcpiGbl_AcpiMutexInfo[MutexId].Mutex) { Status = AcpiOsCreateSemaphore (1, 1, &AcpiGbl_AcpiMutexInfo[MutexId].Mutex); AcpiGbl_AcpiMutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED; AcpiGbl_AcpiMutexInfo[MutexId].UseCount = 0; } return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUtDeleteMutex * * PARAMETERS: MutexID - ID of the mutex to be deleted * * RETURN: Status * * DESCRIPTION: Delete a mutex object. * ******************************************************************************/ ACPI_STATUS AcpiUtDeleteMutex ( ACPI_MUTEX_HANDLE MutexId) { ACPI_STATUS Status; FUNCTION_TRACE_U32 ("UtDeleteMutex", MutexId); if (MutexId > MAX_MTX) { return_ACPI_STATUS (AE_BAD_PARAMETER); } Status = AcpiOsDeleteSemaphore (AcpiGbl_AcpiMutexInfo[MutexId].Mutex); AcpiGbl_AcpiMutexInfo[MutexId].Mutex = NULL; AcpiGbl_AcpiMutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUtAcquireMutex * * PARAMETERS: MutexID - ID of the mutex to be acquired * * RETURN: Status * * DESCRIPTION: Acquire a mutex object. * ******************************************************************************/ ACPI_STATUS AcpiUtAcquireMutex ( ACPI_MUTEX_HANDLE MutexId) { ACPI_STATUS Status; UINT32 i; UINT32 ThisThreadId; PROC_NAME ("UtAcquireMutex"); if (MutexId > MAX_MTX) { return (AE_BAD_PARAMETER); } ThisThreadId = AcpiOsGetThreadId (); /* * Deadlock prevention. Check if this thread owns any mutexes of value * greater than or equal to this one. If so, the thread has violated * the mutex ordering rule. This indicates a coding error somewhere in * the ACPI subsystem code. */ for (i = MutexId; i < MAX_MTX; i++) { if (AcpiGbl_AcpiMutexInfo[i].OwnerId == ThisThreadId) { if (i == MutexId) { - DEBUG_PRINTP (ACPI_ERROR, - ("Mutex [%s] already acquired by this thread [%X]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Mutex [%s] already acquired by this thread [%X]\n", AcpiUtGetMutexName (MutexId), ThisThreadId)); return (AE_ALREADY_ACQUIRED); } - DEBUG_PRINTP (ACPI_ERROR, - ("Invalid acquire order: Thread %X owns [%s], wants [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Invalid acquire order: Thread %X owns [%s], wants [%s]\n", ThisThreadId, AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId))); return (AE_ACQUIRE_DEADLOCK); } } - DEBUG_PRINTP (TRACE_MUTEX, - ("Thread %X attempting to acquire Mutex [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, + "Thread %X attempting to acquire Mutex [%s]\n", ThisThreadId, AcpiUtGetMutexName (MutexId))); Status = AcpiOsWaitSemaphore (AcpiGbl_AcpiMutexInfo[MutexId].Mutex, 1, WAIT_FOREVER); if (ACPI_SUCCESS (Status)) { - DEBUG_PRINTP (TRACE_MUTEX, ("Thread %X acquired Mutex [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X acquired Mutex [%s]\n", ThisThreadId, AcpiUtGetMutexName (MutexId))); AcpiGbl_AcpiMutexInfo[MutexId].UseCount++; AcpiGbl_AcpiMutexInfo[MutexId].OwnerId = ThisThreadId; } else { - DEBUG_PRINTP (ACPI_ERROR, ("Thread %X could not acquire Mutex [%s] %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Thread %X could not acquire Mutex [%s] %s\n", ThisThreadId, AcpiUtGetMutexName (MutexId), AcpiFormatException (Status))); } return (Status); } /******************************************************************************* * * FUNCTION: AcpiUtReleaseMutex * * PARAMETERS: MutexID - ID of the mutex to be released * * RETURN: Status * * DESCRIPTION: Release a mutex object. * ******************************************************************************/ ACPI_STATUS AcpiUtReleaseMutex ( ACPI_MUTEX_HANDLE MutexId) { ACPI_STATUS Status; UINT32 i; UINT32 ThisThreadId; PROC_NAME ("UtReleaseMutex"); ThisThreadId = AcpiOsGetThreadId (); - DEBUG_PRINTP (TRACE_MUTEX, - ("Thread %X releasing Mutex [%s]\n", ThisThreadId, + ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, + "Thread %X releasing Mutex [%s]\n", ThisThreadId, AcpiUtGetMutexName (MutexId))); if (MutexId > MAX_MTX) { return (AE_BAD_PARAMETER); } /* * Mutex must be acquired in order to release it! */ if (AcpiGbl_AcpiMutexInfo[MutexId].OwnerId == ACPI_MUTEX_NOT_ACQUIRED) { - DEBUG_PRINTP (ACPI_ERROR, - ("Mutex [%s] is not acquired, cannot release\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Mutex [%s] is not acquired, cannot release\n", AcpiUtGetMutexName (MutexId))); return (AE_NOT_ACQUIRED); } /* * Deadlock prevention. Check if this thread owns any mutexes of value * greater than this one. If so, the thread has violated the mutex * ordering rule. This indicates a coding error somewhere in * the ACPI subsystem code. */ for (i = MutexId; i < MAX_MTX; i++) { if (AcpiGbl_AcpiMutexInfo[i].OwnerId == ThisThreadId) { if (i == MutexId) { continue; } - DEBUG_PRINTP (ACPI_ERROR, - ("Invalid release order: owns [%s], releasing [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Invalid release order: owns [%s], releasing [%s]\n", AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId))); return (AE_RELEASE_DEADLOCK); } } /* Mark unlocked FIRST */ AcpiGbl_AcpiMutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED; Status = AcpiOsSignalSemaphore (AcpiGbl_AcpiMutexInfo[MutexId].Mutex, 1); if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("Thread %X could not release Mutex [%s] %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Thread %X could not release Mutex [%s] %s\n", ThisThreadId, AcpiUtGetMutexName (MutexId), AcpiFormatException (Status))); } else { - DEBUG_PRINTP (TRACE_MUTEX, ("Thread %X released Mutex [%s]\n", + ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X released Mutex [%s]\n", ThisThreadId, AcpiUtGetMutexName (MutexId))); } return (Status); } /******************************************************************************* * * FUNCTION: AcpiUtCreateUpdateStateAndPush * * PARAMETERS: *Object - Object to be added to the new state * Action - Increment/Decrement * StateList - List the state will be added to * * RETURN: None * * DESCRIPTION: Create a new state and push it * ******************************************************************************/ ACPI_STATUS AcpiUtCreateUpdateStateAndPush ( ACPI_OPERAND_OBJECT *Object, UINT16 Action, ACPI_GENERIC_STATE **StateList) { ACPI_GENERIC_STATE *State; /* Ignore null objects; these are expected */ if (!Object) { return (AE_OK); } State = AcpiUtCreateUpdateState (Object, Action); if (!State) { return (AE_NO_MEMORY); } AcpiUtPushGenericState (StateList, State); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiUtCreatePkgStateAndPush * * PARAMETERS: *Object - Object to be added to the new state * Action - Increment/Decrement * StateList - List the state will be added to * * RETURN: None * * DESCRIPTION: Create a new state and push it * ******************************************************************************/ ACPI_STATUS AcpiUtCreatePkgStateAndPush ( void *InternalObject, void *ExternalObject, UINT16 Index, ACPI_GENERIC_STATE **StateList) { ACPI_GENERIC_STATE *State; State = AcpiUtCreatePkgState (InternalObject, ExternalObject, Index); if (!State) { return (AE_NO_MEMORY); } AcpiUtPushGenericState (StateList, State); return (AE_OK); } /******************************************************************************* * * FUNCTION: AcpiUtPushGenericState * * PARAMETERS: ListHead - Head of the state stack * State - State object to push * * RETURN: Status * * DESCRIPTION: Push a state object onto a state stack * ******************************************************************************/ void AcpiUtPushGenericState ( ACPI_GENERIC_STATE **ListHead, ACPI_GENERIC_STATE *State) { FUNCTION_TRACE ("UtPushGenericState"); /* Push the state object onto the front of the list (stack) */ State->Common.Next = *ListHead; *ListHead = State; return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtPopGenericState * * PARAMETERS: ListHead - Head of the state stack * * RETURN: Status * * DESCRIPTION: Pop a state object from a state stack * ******************************************************************************/ ACPI_GENERIC_STATE * AcpiUtPopGenericState ( ACPI_GENERIC_STATE **ListHead) { ACPI_GENERIC_STATE *State; FUNCTION_TRACE ("DsPopGenericState"); /* Remove the state object at the head of the list (stack) */ State = *ListHead; if (State) { /* Update the list head */ *ListHead = State->Common.Next; } return_PTR (State); } /******************************************************************************* * * FUNCTION: AcpiUtCreateGenericState * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Create a generic state object. Attempt to obtain one from * the global state cache; If none available, create a new one. * ******************************************************************************/ ACPI_GENERIC_STATE * AcpiUtCreateGenericState (void) { ACPI_GENERIC_STATE *State; - AcpiUtAcquireMutex (ACPI_MTX_CACHES); + State = AcpiUtAcquireFromCache (ACPI_MEM_LIST_STATE); - AcpiGbl_StateCacheRequests++; - - /* Check the cache first */ - - if (AcpiGbl_GenericStateCache) - { - /* There is an object available, use it */ - - State = AcpiGbl_GenericStateCache; - AcpiGbl_GenericStateCache = State->Common.Next; - State->Common.Next = NULL; - - AcpiGbl_StateCacheHits++; - AcpiGbl_GenericStateCacheDepth--; - - AcpiUtReleaseMutex (ACPI_MTX_CACHES); - - DEBUG_PRINT (TRACE_EXEC, ("CreateGenState: State %p from cache\n", State)); - } - - else - { - /* The cache is empty, create a new object */ - - AcpiUtReleaseMutex (ACPI_MTX_CACHES); - - State = ACPI_MEM_CALLOCATE (sizeof (ACPI_GENERIC_STATE)); - } - /* Initialize */ if (State) { - /* Always zero out the object before init */ - - MEMSET (State, 0, sizeof (ACPI_GENERIC_STATE)); - State->Common.DataType = ACPI_DESC_TYPE_STATE; } return (State); } /******************************************************************************* * * FUNCTION: AcpiUtCreateUpdateState * * PARAMETERS: Object - Initial Object to be installed in the * state * Action - Update action to be performed * * RETURN: Status * * DESCRIPTION: Create an "Update State" - a flavor of the generic state used * to update reference counts and delete complex objects such * as packages. * ******************************************************************************/ ACPI_GENERIC_STATE * AcpiUtCreateUpdateState ( ACPI_OPERAND_OBJECT *Object, UINT16 Action) { ACPI_GENERIC_STATE *State; FUNCTION_TRACE_PTR ("UtCreateUpdateState", Object); /* Create the generic state object */ State = AcpiUtCreateGenericState (); if (!State) { return (NULL); } /* Init fields specific to the update struct */ State->Update.Object = Object; State->Update.Value = Action; return_PTR (State); } /******************************************************************************* * * FUNCTION: AcpiUtCreatePkgState * * PARAMETERS: Object - Initial Object to be installed in the * state * Action - Update action to be performed * * RETURN: Status * * DESCRIPTION: Create an "Update State" - a flavor of the generic state used * to update reference counts and delete complex objects such * as packages. * ******************************************************************************/ ACPI_GENERIC_STATE * AcpiUtCreatePkgState ( void *InternalObject, void *ExternalObject, UINT16 Index) { ACPI_GENERIC_STATE *State; FUNCTION_TRACE_PTR ("UtCreatePkgState", InternalObject); /* Create the generic state object */ State = AcpiUtCreateGenericState (); if (!State) { return (NULL); } /* Init fields specific to the update struct */ State->Pkg.SourceObject = (ACPI_OPERAND_OBJECT *) InternalObject; State->Pkg.DestObject = ExternalObject; State->Pkg.Index = Index; State->Pkg.NumPackages = 1; return_PTR (State); } /******************************************************************************* * * FUNCTION: AcpiUtCreateControlState * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Create a "Control State" - a flavor of the generic state used * to support nested IF/WHILE constructs in the AML. * ******************************************************************************/ ACPI_GENERIC_STATE * AcpiUtCreateControlState ( void) { ACPI_GENERIC_STATE *State; FUNCTION_TRACE ("UtCreateControlState"); /* Create the generic state object */ State = AcpiUtCreateGenericState (); if (!State) { return (NULL); } /* Init fields specific to the control struct */ State->Common.State = CONTROL_CONDITIONAL_EXECUTING; return_PTR (State); } /******************************************************************************* * * FUNCTION: AcpiUtDeleteGenericState * * PARAMETERS: State - The state object to be deleted * * RETURN: Status * * DESCRIPTION: Put a state object back into the global state cache. The object * is not actually freed at this time. * ******************************************************************************/ void AcpiUtDeleteGenericState ( ACPI_GENERIC_STATE *State) { FUNCTION_TRACE ("UtDeleteGenericState"); - /* If cache is full, just free this state object */ - - if (AcpiGbl_GenericStateCacheDepth >= MAX_STATE_CACHE_DEPTH) - { - ACPI_MEM_FREE (State); - } - - /* Otherwise put this object back into the cache */ - - else - { - AcpiUtAcquireMutex (ACPI_MTX_CACHES); - - /* Clear the state */ - - MEMSET (State, 0, sizeof (ACPI_GENERIC_STATE)); - State->Common.DataType = ACPI_DESC_TYPE_STATE; - - /* Put the object at the head of the global cache list */ - - State->Common.Next = AcpiGbl_GenericStateCache; - AcpiGbl_GenericStateCache = State; - AcpiGbl_GenericStateCacheDepth++; - - - AcpiUtReleaseMutex (ACPI_MTX_CACHES); - } + AcpiUtReleaseToCache (ACPI_MEM_LIST_STATE, State); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtDeleteGenericStateCache * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Purge the global state object cache. Used during subsystem * termination. * ******************************************************************************/ void AcpiUtDeleteGenericStateCache ( void) { - ACPI_GENERIC_STATE *Next; - - FUNCTION_TRACE ("UtDeleteGenericStateCache"); - /* Traverse the global cache list */ - - while (AcpiGbl_GenericStateCache) - { - /* Delete one cached state object */ - - Next = AcpiGbl_GenericStateCache->Common.Next; - ACPI_MEM_FREE (AcpiGbl_GenericStateCache); - - AcpiGbl_GenericStateCache = Next; - AcpiGbl_GenericStateCacheDepth--; - } - + AcpiUtDeleteGenericCache (ACPI_MEM_LIST_STATE); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtResolvePackageReferences * * PARAMETERS: ObjDesc - The Package object on which to resolve refs * * RETURN: Status * * DESCRIPTION: Walk through a package and turn internal references into values * ******************************************************************************/ ACPI_STATUS AcpiUtResolvePackageReferences ( ACPI_OPERAND_OBJECT *ObjDesc) { UINT32 Count; ACPI_OPERAND_OBJECT *SubObject; FUNCTION_TRACE ("AcpiUtResolvePackageReferences"); if (ObjDesc->Common.Type != ACPI_TYPE_PACKAGE) { /* The object must be a package */ REPORT_ERROR (("Must resolve Package Refs on a Package\n")); return_ACPI_STATUS(AE_ERROR); } /* * TBD: what about nested packages? */ for (Count = 0; Count < ObjDesc->Package.Count; Count++) { SubObject = ObjDesc->Package.Elements[Count]; if (SubObject->Common.Type == INTERNAL_TYPE_REFERENCE) { if (SubObject->Reference.Opcode == AML_ZERO_OP) { SubObject->Common.Type = ACPI_TYPE_INTEGER; SubObject->Integer.Value = 0; } else if (SubObject->Reference.Opcode == AML_ONE_OP) { SubObject->Common.Type = ACPI_TYPE_INTEGER; SubObject->Integer.Value = 1; } else if (SubObject->Reference.Opcode == AML_ONES_OP) { SubObject->Common.Type = ACPI_TYPE_INTEGER; SubObject->Integer.Value = ACPI_INTEGER_MAX; } } } return_ACPI_STATUS(AE_OK); } #ifdef ACPI_DEBUG /******************************************************************************* * * FUNCTION: AcpiUtDisplayInitPathname * * PARAMETERS: ObjHandle - Handle whose pathname will be displayed * Path - Additional path string to be appended * * RETURN: ACPI_STATUS * * DESCRIPTION: Display full pathnbame of an object, DEBUG ONLY * ******************************************************************************/ void AcpiUtDisplayInitPathname ( ACPI_HANDLE ObjHandle, char *Path) { ACPI_STATUS Status; UINT32 Length = 128; char Buffer[128]; + PROC_NAME ("AcpiUtDisplayInitPathname"); + + Status = AcpiNsHandleToPathname (ObjHandle, &Length, Buffer); if (ACPI_SUCCESS (Status)) { if (Path) { - DEBUG_PRINT (TRACE_INIT, ("%s.%s\n", Buffer, Path)) + ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "%s.%s\n", Buffer, Path)); } else { - DEBUG_PRINT (TRACE_INIT, ("%s\n", Buffer)) + ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "%s\n", Buffer)); } } } #endif /******************************************************************************* * * FUNCTION: AcpiUtWalkPackageTree * * PARAMETERS: ObjDesc - The Package object on which to resolve refs * * RETURN: Status * * DESCRIPTION: Walk through a package * ******************************************************************************/ ACPI_STATUS AcpiUtWalkPackageTree ( ACPI_OPERAND_OBJECT *SourceObject, void *TargetObject, ACPI_PKG_CALLBACK WalkCallback, void *Context) { ACPI_STATUS Status = AE_OK; ACPI_GENERIC_STATE *StateList = NULL; ACPI_GENERIC_STATE *State; UINT32 ThisIndex; ACPI_OPERAND_OBJECT *ThisSourceObj; FUNCTION_TRACE ("AcpiUtWalkPackageTree"); State = AcpiUtCreatePkgState (SourceObject, TargetObject, 0); if (!State) { return_ACPI_STATUS (AE_NO_MEMORY); } while (State) { ThisIndex = State->Pkg.Index; ThisSourceObj = (ACPI_OPERAND_OBJECT *) State->Pkg.SourceObject->Package.Elements[ThisIndex]; /* * Check for * 1) An uninitialized package element. It is completely * legal to declare a package and leave it uninitialized * 2) Not an internal object - can be a namespace node instead * 3) Any type other than a package. Packages are handled in else * case below. */ if ((!ThisSourceObj) || (!VALID_DESCRIPTOR_TYPE ( ThisSourceObj, ACPI_DESC_TYPE_INTERNAL)) || (!IS_THIS_OBJECT_TYPE ( ThisSourceObj, ACPI_TYPE_PACKAGE))) { Status = WalkCallback (ACPI_COPY_TYPE_SIMPLE, ThisSourceObj, State, Context); if (ACPI_FAILURE (Status)) { /* TBD: must delete package created up to this point */ return_ACPI_STATUS (Status); } State->Pkg.Index++; while (State->Pkg.Index >= State->Pkg.SourceObject->Package.Count) { /* * We've handled all of the objects at this level, This means * that we have just completed a package. That package may * have contained one or more packages itself. * * Delete this state and pop the previous state (package). */ AcpiUtDeleteGenericState (State); State = AcpiUtPopGenericState (&StateList); /* Finished when there are no more states */ if (!State) { /* * We have handled all of the objects in the top level * package just add the length of the package objects * and exit */ return_ACPI_STATUS (AE_OK); } /* * Go back up a level and move the index past the just * completed package object. */ State->Pkg.Index++; } } else { /* This is a sub-object of type package */ Status = WalkCallback (ACPI_COPY_TYPE_PACKAGE, ThisSourceObj, State, Context); if (ACPI_FAILURE (Status)) { /* TBD: must delete package created up to this point */ return_ACPI_STATUS (Status); } /* * The callback above returned a new target package object. */ /* * Push the current state and create a new one */ AcpiUtPushGenericState (&StateList, State); State = AcpiUtCreatePkgState (ThisSourceObj, State->Pkg.ThisTargetObj, 0); if (!State) { /* TBD: must delete package created up to this point */ return_ACPI_STATUS (AE_NO_MEMORY); } } } /* We should never get here */ return (AE_AML_INTERNAL); } /******************************************************************************* * * FUNCTION: _ReportError * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * Message - Error message to use on failure * * RETURN: None * * DESCRIPTION: Print error message * ******************************************************************************/ void _ReportError ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId) { AcpiOsPrintf ("%8s-%04d: *** Error: ", ModuleName, LineNumber); } /******************************************************************************* * * FUNCTION: _ReportWarning * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * Message - Error message to use on failure * * RETURN: None * * DESCRIPTION: Print warning message * ******************************************************************************/ void _ReportWarning ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId) { AcpiOsPrintf ("%8s-%04d: *** Warning: ", ModuleName, LineNumber); } /******************************************************************************* * * FUNCTION: _ReportInfo * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * Message - Error message to use on failure * * RETURN: None * * DESCRIPTION: Print information message * ******************************************************************************/ void _ReportInfo ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId) { AcpiOsPrintf ("%8s-%04d: *** Info: ", ModuleName, LineNumber); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/utobject.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/utobject.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/utobject.c (revision 82367) @@ -1,785 +1,691 @@ /****************************************************************************** * * Module Name: utobject - ACPI object create/delete/size/cache routines - * $Revision: 49 $ + * $Revision: 51 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __UTOBJECT_C__ #include "acpi.h" #include "acinterp.h" #include "acnamesp.h" #include "actables.h" #include "amlcode.h" #define _COMPONENT ACPI_UTILITIES MODULE_NAME ("utobject") /******************************************************************************* * * FUNCTION: _UtCreateInternalObject * * PARAMETERS: Address - Address of the memory to deallocate * Component - Component type of caller * Module - Source file name of caller * Line - Line number of caller * Type - ACPI Type of the new object * * RETURN: Object - The new object. Null on failure * * DESCRIPTION: Create and initialize a new internal object. * * NOTE: We always allocate the worst-case object descriptor because * these objects are cached, and we want them to be * one-size-satisifies-any-request. This in itself may not be * the most memory efficient, but the efficiency of the object * cache should more than make up for this! * ******************************************************************************/ ACPI_OPERAND_OBJECT * _UtCreateInternalObject ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId, ACPI_OBJECT_TYPE8 Type) { ACPI_OPERAND_OBJECT *Object; FUNCTION_TRACE_STR ("UtCreateInternalObject", AcpiUtGetTypeName (Type)); /* Allocate the raw object descriptor */ Object = _UtAllocateObjectDesc (ModuleName, LineNumber, ComponentId); if (!Object) { /* Allocation failure */ return_PTR (NULL); } /* Save the object type in the object descriptor */ Object->Common.Type = Type; /* Init the reference count */ Object->Common.ReferenceCount = 1; /* Any per-type initialization should go here */ return_PTR (Object); } /******************************************************************************* * * FUNCTION: AcpiUtValidInternalObject * * PARAMETERS: Operand - Object to be validated * * RETURN: Validate a pointer to be an ACPI_OPERAND_OBJECT * ******************************************************************************/ BOOLEAN AcpiUtValidInternalObject ( void *Object) { PROC_NAME ("UtValidInternalObject"); /* Check for a null pointer */ if (!Object) { - DEBUG_PRINT (ACPI_INFO, - ("**** Null Object Ptr\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "**** Null Object Ptr\n")); return (FALSE); } /* Check for a pointer within one of the ACPI tables */ if (AcpiTbSystemTablePointer (Object)) { - DEBUG_PRINTP (ACPI_INFO, ("**** Object %p is a Pcode Ptr\n", Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "**** Object %p is a Pcode Ptr\n", Object)); return (FALSE); } /* Check the descriptor type field */ if (!VALID_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_INTERNAL)) { /* Not an ACPI internal object, do some further checking */ if (VALID_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_NAMED)) { - DEBUG_PRINTP (ACPI_INFO, - ("**** Obj %p is a named obj, not ACPI obj\n", Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "**** Obj %p is a named obj, not ACPI obj\n", Object)); } else if (VALID_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_PARSER)) { - DEBUG_PRINTP (ACPI_INFO, - ("**** Obj %p is a parser obj, not ACPI obj\n", Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "**** Obj %p is a parser obj, not ACPI obj\n", Object)); } else { - DEBUG_PRINTP (ACPI_INFO, - ("**** Obj %p is of unknown type\n", Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "**** Obj %p is of unknown type\n", Object)); } return (FALSE); } /* The object appears to be a valid ACPI_OPERAND_OBJECT */ return (TRUE); } /******************************************************************************* * * FUNCTION: _UtAllocateObjectDesc * * PARAMETERS: ModuleName - Caller's module name (for error output) * LineNumber - Caller's line number (for error output) * ComponentId - Caller's component ID (for error output) * Message - Error message to use on failure * * RETURN: Pointer to newly allocated object descriptor. Null on error * * DESCRIPTION: Allocate a new object descriptor. Gracefully handle * error conditions. * ******************************************************************************/ void * _UtAllocateObjectDesc ( NATIVE_CHAR *ModuleName, UINT32 LineNumber, UINT32 ComponentId) { ACPI_OPERAND_OBJECT *Object; FUNCTION_TRACE ("_AllocateObjectDesc"); - AcpiUtAcquireMutex (ACPI_MTX_CACHES); - - AcpiGbl_ObjectCacheRequests++; - - /* Check the cache first */ - - if (AcpiGbl_ObjectCache) + Object = AcpiUtAcquireFromCache (ACPI_MEM_LIST_OPERAND); + if (!Object) { - /* There is an object available, use it */ + _REPORT_ERROR (ModuleName, LineNumber, ComponentId, + ("Could not allocate an object descriptor\n")); - Object = AcpiGbl_ObjectCache; - AcpiGbl_ObjectCache = Object->Cache.Next; - Object->Cache.Next = NULL; - - AcpiGbl_ObjectCacheHits++; - AcpiGbl_ObjectCacheDepth--; - - AcpiUtReleaseMutex (ACPI_MTX_CACHES); + return_PTR (NULL); } - else - { - /* The cache is empty, create a new object */ - AcpiUtReleaseMutex (ACPI_MTX_CACHES); - - /* Attempt to allocate new descriptor */ - - Object = ACPI_MEM_CALLOCATE (sizeof (ACPI_OPERAND_OBJECT)); - if (!Object) - { - /* Allocation failed */ - - _REPORT_ERROR (ModuleName, LineNumber, ComponentId, - ("Could not allocate an object descriptor\n")); - - return_PTR (NULL); - } - - /* Memory allocation metrics - compiled out in non debug mode. */ - - INCREMENT_OBJECT_METRICS (sizeof (ACPI_OPERAND_OBJECT)); - } - /* Mark the descriptor type */ Object->Common.DataType = ACPI_DESC_TYPE_INTERNAL; - DEBUG_PRINTP (TRACE_ALLOCATIONS, ("%p Size %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n", Object, sizeof (ACPI_OPERAND_OBJECT))); return_PTR (Object); } /******************************************************************************* * * FUNCTION: AcpiUtDeleteObjectDesc * * PARAMETERS: Object - Acpi internal object to be deleted * * RETURN: None. * * DESCRIPTION: Free an ACPI object descriptor or add it to the object cache * ******************************************************************************/ void AcpiUtDeleteObjectDesc ( ACPI_OPERAND_OBJECT *Object) { - FUNCTION_TRACE_PTR ("AcpiUtDeleteObjectDesc", Object); - /* Make sure that the object isn't already in the cache */ - - if (Object->Common.DataType == (ACPI_DESC_TYPE_INTERNAL | ACPI_CACHED_OBJECT)) - { - DEBUG_PRINTP (ACPI_ERROR, - ("Obj %p is already in the object cache\n", Object)); - return_VOID; - } - /* Object must be an ACPI_OPERAND_OBJECT */ if (Object->Common.DataType != ACPI_DESC_TYPE_INTERNAL) { - DEBUG_PRINTP (ACPI_ERROR, - ("Obj %p is not an ACPI object\n", Object)); + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Obj %p is not an ACPI object\n", Object)); return_VOID; } + AcpiUtReleaseToCache (ACPI_MEM_LIST_OPERAND, Object); - /* If cache is full, just free this object */ - - if (AcpiGbl_ObjectCacheDepth >= MAX_OBJECT_CACHE_DEPTH) - { - /* - * Memory allocation metrics. Call the macro here since we only - * care about dynamically allocated objects. - */ - DECREMENT_OBJECT_METRICS (sizeof (ACPI_OPERAND_OBJECT)); - - ACPI_MEM_FREE (Object); - return_VOID; - } - - AcpiUtAcquireMutex (ACPI_MTX_CACHES); - - /* Clear the entire object. This is important! */ - - MEMSET (Object, 0, sizeof (ACPI_OPERAND_OBJECT)); - Object->Common.DataType = ACPI_DESC_TYPE_INTERNAL | ACPI_CACHED_OBJECT; - - /* Put the object at the head of the global cache list */ - - Object->Cache.Next = AcpiGbl_ObjectCache; - AcpiGbl_ObjectCache = Object; - AcpiGbl_ObjectCacheDepth++; - - - AcpiUtReleaseMutex (ACPI_MTX_CACHES); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtDeleteObjectCache * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Purge the global state object cache. Used during subsystem * termination. * ******************************************************************************/ void AcpiUtDeleteObjectCache ( void) { - ACPI_OPERAND_OBJECT *Next; - - FUNCTION_TRACE ("UtDeleteObjectCache"); - /* Traverse the global cache list */ - - while (AcpiGbl_ObjectCache) - { - /* Delete one cached state object */ - - Next = AcpiGbl_ObjectCache->Cache.Next; - AcpiGbl_ObjectCache->Cache.Next = NULL; - - /* - * Memory allocation metrics. Call the macro here since we only - * care about dynamically allocated objects. - */ - DECREMENT_OBJECT_METRICS (sizeof (ACPI_OPERAND_OBJECT)); - - ACPI_MEM_FREE (AcpiGbl_ObjectCache); - AcpiGbl_ObjectCache = Next; - AcpiGbl_ObjectCacheDepth--; - } - + AcpiUtDeleteGenericCache (ACPI_MEM_LIST_OPERAND); return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtInitStaticObject * * PARAMETERS: ObjDesc - Pointer to a "static" object - on stack * or in the data segment. * * RETURN: None. * * DESCRIPTION: Initialize a static object. Sets flags to disallow dynamic * deletion of the object. * ******************************************************************************/ void AcpiUtInitStaticObject ( ACPI_OPERAND_OBJECT *ObjDesc) { FUNCTION_TRACE_PTR ("UtInitStaticObject", ObjDesc); if (!ObjDesc) { return_VOID; } /* * Clear the entire descriptor */ MEMSET ((void *) ObjDesc, 0, sizeof (ACPI_OPERAND_OBJECT)); /* * Initialize the header fields * 1) This is an ACPI_OPERAND_OBJECT descriptor * 2) The size is the full object (worst case) * 3) The flags field indicates static allocation * 4) Reference count starts at one (not really necessary since the * object can't be deleted, but keeps everything sane) */ ObjDesc->Common.DataType = ACPI_DESC_TYPE_INTERNAL; ObjDesc->Common.Flags = AOPOBJ_STATIC_ALLOCATION; ObjDesc->Common.ReferenceCount = 1; return_VOID; } /******************************************************************************* * * FUNCTION: AcpiUtGetSimpleObjectSize * * PARAMETERS: *InternalObject - Pointer to the object we are examining * *RetLength - Where the length is returned * * RETURN: Status * * DESCRIPTION: This function is called to determine the space required to * contain a simple object for return to an API user. * * The length includes the object structure plus any additional * needed space. * ******************************************************************************/ ACPI_STATUS AcpiUtGetSimpleObjectSize ( ACPI_OPERAND_OBJECT *InternalObject, UINT32 *ObjLength) { UINT32 Length; ACPI_STATUS Status = AE_OK; FUNCTION_TRACE_PTR ("UtGetSimpleObjectSize", InternalObject); /* Handle a null object (Could be a uninitialized package element -- which is legal) */ if (!InternalObject) { *ObjLength = 0; return_ACPI_STATUS (AE_OK); } /* Start with the length of the Acpi object */ Length = sizeof (ACPI_OBJECT); if (VALID_DESCRIPTOR_TYPE (InternalObject, ACPI_DESC_TYPE_NAMED)) { /* Object is a named object (reference), just return the length */ *ObjLength = (UINT32) ROUND_UP_TO_NATIVE_WORD (Length); return_ACPI_STATUS (Status); } /* * The final length depends on the object type * Strings and Buffers are packed right up against the parent object and * must be accessed bytewise or there may be alignment problems on * certain processors */ switch (InternalObject->Common.Type) { case ACPI_TYPE_STRING: Length += InternalObject->String.Length + 1; break; case ACPI_TYPE_BUFFER: Length += InternalObject->Buffer.Length; break; case ACPI_TYPE_INTEGER: case ACPI_TYPE_PROCESSOR: case ACPI_TYPE_POWER: /* * No extra data for these types */ break; case INTERNAL_TYPE_REFERENCE: /* * The only type that should be here is internal opcode NAMEPATH_OP -- since * this means an object reference */ if (InternalObject->Reference.Opcode != AML_INT_NAMEPATH_OP) { - DEBUG_PRINTP (ACPI_ERROR, - ("Unsupported Reference opcode=%X in object %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Unsupported Reference opcode=%X in object %p\n", InternalObject->Reference.Opcode, InternalObject)); Status = AE_TYPE; } else { /* * Get the actual length of the full pathname to this object. * The reference will be converted to the pathname to the object */ Length += ROUND_UP_TO_NATIVE_WORD (AcpiNsGetPathnameLength (InternalObject->Reference.Node)); } break; default: - DEBUG_PRINTP (ACPI_ERROR, ("Unsupported type=%X in object %p\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unsupported type=%X in object %p\n", InternalObject->Common.Type, InternalObject)); Status = AE_TYPE; break; } /* * Account for the space required by the object rounded up to the next * multiple of the machine word size. This keeps each object aligned * on a machine word boundary. (preventing alignment faults on some * machines.) */ *ObjLength = (UINT32) ROUND_UP_TO_NATIVE_WORD (Length); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUtGetElementLength * * PARAMETERS: ACPI_PKG_CALLBACK * * RETURN: Status - the status of the call * * DESCRIPTION: Get the length of one package element. * ******************************************************************************/ ACPI_STATUS AcpiUtGetElementLength ( UINT8 ObjectType, ACPI_OPERAND_OBJECT *SourceObject, ACPI_GENERIC_STATE *State, void *Context) { ACPI_STATUS Status = AE_OK; ACPI_PKG_INFO *Info = (ACPI_PKG_INFO *) Context; UINT32 ObjectSpace; switch (ObjectType) { case 0: /* * Simple object - just get the size (Null object/entry is handled * here also) and sum it into the running package length */ Status = AcpiUtGetSimpleObjectSize (SourceObject, &ObjectSpace); if (ACPI_FAILURE (Status)) { return (Status); } Info->Length += ObjectSpace; break; case 1: /* Package - nothing much to do here, let the walk handle it */ Info->NumPackages++; State->Pkg.ThisTargetObj = NULL; break; default: return (AE_BAD_PARAMETER); } return (Status); } /******************************************************************************* * * FUNCTION: AcpiUtGetPackageObjectSize * * PARAMETERS: *InternalObject - Pointer to the object we are examining * *RetLength - Where the length is returned * * RETURN: Status * * DESCRIPTION: This function is called to determine the space required to * contain a package object for return to an API user. * * This is moderately complex since a package contains other * objects including packages. * ******************************************************************************/ ACPI_STATUS AcpiUtGetPackageObjectSize ( ACPI_OPERAND_OBJECT *InternalObject, UINT32 *ObjLength) { ACPI_STATUS Status; ACPI_PKG_INFO Info; FUNCTION_TRACE_PTR ("UtGetPackageObjectSize", InternalObject); Info.Length = 0; Info.ObjectSpace = 0; Info.NumPackages = 1; Status = AcpiUtWalkPackageTree (InternalObject, NULL, AcpiUtGetElementLength, &Info); /* * We have handled all of the objects in all levels of the package. * just add the length of the package objects themselves. * Round up to the next machine word. */ Info.Length += ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT)) * Info.NumPackages; /* Return the total package length */ *ObjLength = Info.Length; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiUtGetObjectSize * * PARAMETERS: *InternalObject - Pointer to the object we are examining * *RetLength - Where the length will be returned * * RETURN: Status * * DESCRIPTION: This function is called to determine the space required to * contain an object for return to an API user. * ******************************************************************************/ ACPI_STATUS AcpiUtGetObjectSize( ACPI_OPERAND_OBJECT *InternalObject, UINT32 *ObjLength) { ACPI_STATUS Status; if ((VALID_DESCRIPTOR_TYPE (InternalObject, ACPI_DESC_TYPE_INTERNAL)) && (IS_THIS_OBJECT_TYPE (InternalObject, ACPI_TYPE_PACKAGE))) { Status = AcpiUtGetPackageObjectSize (InternalObject, ObjLength); } else { Status = AcpiUtGetSimpleObjectSize (InternalObject, ObjLength); } return (Status); } Index: vendor-sys/acpica/dist/sys/contrib/dev/acpica/utxface.c =================================================================== --- vendor-sys/acpica/dist/sys/contrib/dev/acpica/utxface.c (revision 82366) +++ vendor-sys/acpica/dist/sys/contrib/dev/acpica/utxface.c (revision 82367) @@ -1,529 +1,529 @@ /****************************************************************************** * * Module Name: utxface - External interfaces for "global" ACPI functions - * $Revision: 76 $ + * $Revision: 77 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #define __UTXFACE_C__ #include "acpi.h" #include "acevents.h" #include "achware.h" #include "acnamesp.h" #include "acinterp.h" #include "amlcode.h" #include "acdebug.h" #include "acexcep.h" #define _COMPONENT ACPI_UTILITIES MODULE_NAME ("utxface") /******************************************************************************* * * FUNCTION: AcpiInitializeSubsystem * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Initializes all global variables. This is the first function * called, so any early initialization belongs here. * ******************************************************************************/ ACPI_STATUS AcpiInitializeSubsystem ( void) { ACPI_STATUS Status; FUNCTION_TRACE ("AcpiInitializeSubsystem"); /* Initialize all globals used by the subsystem */ AcpiUtInitGlobals (); /* Initialize the OS-Dependent layer */ Status = AcpiOsInitialize (); if (ACPI_FAILURE (Status)) { REPORT_ERROR (("OSD failed to initialize, %s\n", AcpiFormatException (Status))); return_ACPI_STATUS (Status); } /* Create the default mutex objects */ Status = AcpiUtMutexInitialize (); if (ACPI_FAILURE (Status)) { REPORT_ERROR (("Global mutex creation failure, %s\n", AcpiFormatException (Status))); return_ACPI_STATUS (Status); } /* * Initialize the namespace manager and * the root of the namespace tree */ Status = AcpiNsRootInitialize (); if (ACPI_FAILURE (Status)) { REPORT_ERROR (("Namespace initialization failure, %s\n", AcpiFormatException (Status))); return_ACPI_STATUS (Status); } /* If configured, initialize the AML debugger */ DEBUGGER_EXEC (AcpiDbInitialize ()); return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiEnableSubsystem * * PARAMETERS: Flags - Init/enable Options * * RETURN: Status * * DESCRIPTION: Completes the subsystem initialization including hardware. * Puts system into ACPI mode if it isn't already. * ******************************************************************************/ ACPI_STATUS AcpiEnableSubsystem ( UINT32 Flags) { ACPI_STATUS Status = AE_OK; FUNCTION_TRACE ("AcpiEnableSubsystem"); /* Sanity check the FADT for valid values */ Status = AcpiUtValidateFadt (); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Install the default OpRegion handlers. These are * installed unless other handlers have already been * installed via the InstallAddressSpaceHandler interface */ if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT)) { - DEBUG_PRINT (TRACE_EXEC, ("[Init] Installing default address space handlers\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Installing default address space handlers\n")); Status = AcpiEvInstallDefaultAddressSpaceHandlers (); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* * We must initialize the hardware before we can enable ACPI. */ if (!(Flags & ACPI_NO_HARDWARE_INIT)) { - DEBUG_PRINT (TRACE_EXEC, ("[Init] Initializing ACPI hardware\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Initializing ACPI hardware\n")); Status = AcpiHwInitialize (); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* * Enable ACPI on this platform */ if (!(Flags & ACPI_NO_ACPI_ENABLE)) { - DEBUG_PRINT (TRACE_EXEC, ("[Init] Going into ACPI mode\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n")); Status = AcpiEnable (); if (ACPI_FAILURE (Status)) { - DEBUG_PRINT(ACPI_WARN, ("AcpiEnable failed.\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "AcpiEnable failed.\n")); return_ACPI_STATUS (Status); } } /* * Note: * We must have the hardware AND events initialized before we can execute * ANY control methods SAFELY. Any control method can require ACPI hardware * support, so the hardware MUST be initialized before execution! */ if (!(Flags & ACPI_NO_EVENT_INIT)) { - DEBUG_PRINT (TRACE_EXEC, ("[Init] Initializing ACPI events\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Initializing ACPI events\n")); Status = AcpiEvInitialize (); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* * Initialize all device objects in the namespace * This runs the _STA and _INI methods. */ if (!(Flags & ACPI_NO_DEVICE_INIT)) { - DEBUG_PRINT (TRACE_EXEC, ("[Init] Initializing ACPI Devices\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Initializing ACPI Devices\n")); Status = AcpiNsInitializeDevices (); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* * Initialize the objects that remain uninitialized. This * runs the executable AML that is part of the declaration of OpRegions * and Fields. */ if (!(Flags & ACPI_NO_OBJECT_INIT)) { - DEBUG_PRINT (TRACE_EXEC, ("[Init] Initializing ACPI Objects\n")); + ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Initializing ACPI Objects\n")); Status = AcpiNsInitializeObjects (); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } AcpiGbl_StartupFlags |= ACPI_INITIALIZED_OK; return_ACPI_STATUS (Status); } /******************************************************************************* * * FUNCTION: AcpiTerminate * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Shutdown the ACPI subsystem. Release all resources. * ******************************************************************************/ ACPI_STATUS AcpiTerminate (void) { ACPI_STATUS Status; FUNCTION_TRACE ("AcpiTerminate"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Terminate the AML Debugger if present */ DEBUGGER_EXEC(AcpiGbl_DbTerminateThreads = TRUE); /* TBD: [Investigate] This is no longer needed?*/ /* AcpiUtReleaseMutex (ACPI_MTX_DEBUG_CMD_READY); */ /* Shutdown and free all resources */ AcpiUtSubsystemShutdown (); /* Free the mutex objects */ AcpiUtMutexTerminate (); /* Now we can shutdown the OS-dependent layer */ AcpiOsTerminate (); return_ACPI_STATUS (AE_OK); } /***************************************************************************** * * FUNCTION: AcpiSubsystemStatus * * PARAMETERS: None * * RETURN: Status of the ACPI subsystem * * DESCRIPTION: Other drivers that use the ACPI subsystem should call this * before making any other calls, to ensure the subsystem initial- * ized successfully. * ****************************************************************************/ ACPI_STATUS AcpiSubsystemStatus (void) { if (AcpiGbl_StartupFlags & ACPI_INITIALIZED_OK) { return (AE_OK); } else { return (AE_ERROR); } } /****************************************************************************** * * FUNCTION: AcpiGetSystemInfo * * PARAMETERS: OutBuffer - a pointer to a buffer to receive the * resources for the device * BufferLength - the number of bytes available in the buffer * * RETURN: Status - the status of the call * * DESCRIPTION: This function is called to get information about the current * state of the ACPI subsystem. It will return system information * in the OutBuffer. * * If the function fails an appropriate status will be returned * and the value of OutBuffer is undefined. * ******************************************************************************/ ACPI_STATUS AcpiGetSystemInfo ( ACPI_BUFFER *OutBuffer) { ACPI_SYSTEM_INFO *InfoPtr; UINT32 i; ACPI_STATUS Status; FUNCTION_TRACE ("AcpiGetSystemInfo"); /* Ensure that ACPI has been initialized */ ACPI_IS_INITIALIZATION_COMPLETE (Status); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Must have a valid buffer */ if ((!OutBuffer) || (!OutBuffer->Pointer)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } if (OutBuffer->Length < sizeof (ACPI_SYSTEM_INFO)) { /* * Caller's buffer is too small */ OutBuffer->Length = sizeof (ACPI_SYSTEM_INFO); return_ACPI_STATUS (AE_BUFFER_OVERFLOW); } /* * Set return length and get data */ OutBuffer->Length = sizeof (ACPI_SYSTEM_INFO); InfoPtr = (ACPI_SYSTEM_INFO *) OutBuffer->Pointer; InfoPtr->AcpiCaVersion = ACPI_CA_VERSION; /* System flags (ACPI capabilities) */ InfoPtr->Flags = AcpiGbl_SystemFlags; /* Timer resolution - 24 or 32 bits */ if (!AcpiGbl_FADT) { InfoPtr->TimerResolution = 0; } else if (AcpiGbl_FADT->TmrValExt == 0) { InfoPtr->TimerResolution = 24; } else { InfoPtr->TimerResolution = 32; } /* Clear the reserved fields */ InfoPtr->Reserved1 = 0; InfoPtr->Reserved2 = 0; /* Current debug levels */ InfoPtr->DebugLayer = AcpiDbgLayer; InfoPtr->DebugLevel = AcpiDbgLevel; /* Current status of the ACPI tables, per table type */ InfoPtr->NumTableTypes = NUM_ACPI_TABLES; for (i = 0; i < NUM_ACPI_TABLES; i++) { InfoPtr->TableInfo[i].Count = AcpiGbl_AcpiTables[i].Count; } return_ACPI_STATUS (AE_OK); }