acutils.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	acpi_pkg_info

Macros
#define	ACPI_MSG_REDIRECT_BEGIN
#define	ACPI_MSG_REDIRECT_END
#define	ACPI_MSG_ERROR   "ACPI Error: "
#define	ACPI_MSG_WARNING   "ACPI Warning: "
#define	ACPI_MSG_INFO   "ACPI: "
#define	ACPI_MSG_BIOS_ERROR   "Firmware Error (ACPI): "
#define	ACPI_MSG_BIOS_WARNING   "Firmware Warning (ACPI): "
#define	ACPI_MSG_SUFFIX    AcpiOsPrintf (" (%8.8X/%s-%u)\n", ACPI_CA_VERSION, ModuleName, LineNumber)
#define	ACPI_IMPLICIT_CONVERSION   TRUE
#define	ACPI_NO_IMPLICIT_CONVERSION   FALSE
#define	ACPI_INVALID_RESOURCE   0
#define	ACPI_FIXED_LENGTH   1
#define	ACPI_VARIABLE_LENGTH   2
#define	ACPI_SMALL_VARIABLE_LENGTH   3
#define	REF_INCREMENT   (UINT16) 0
#define	REF_DECREMENT   (UINT16) 1
#define	DB_BYTE_DISPLAY   0x01
#define	DB_WORD_DISPLAY   0x02
#define	DB_DWORD_DISPLAY   0x04
#define	DB_QWORD_DISPLAY   0x08
#define	DB_DISPLAY_DATA_ONLY   0x10
#define	AcpiUtCreateInternalObject(t)   AcpiUtCreateInternalObjectDbg (_AcpiModuleName,__LINE__,_COMPONENT,t)
#define	AcpiUtAllocateObjectDesc()   AcpiUtAllocateObjectDescDbg (_AcpiModuleName,__LINE__,_COMPONENT)
#define	ACPI_ANY_BASE   0

Typedefs
typedef ACPI_STATUS(*	ACPI_WALK_AML_CALLBACK) (UINT8 *Aml, UINT32 Length, UINT32 Offset, UINT8 ResourceIndex, void **Context)
typedef ACPI_STATUS(*	ACPI_PKG_CALLBACK) (UINT8 ObjectType, ACPI_OPERAND_OBJECT *SourceObject, ACPI_GENERIC_STATE *State, void *Context)
typedef struct acpi_pkg_info	ACPI_PKG_INFO

Functions
BOOLEAN	AcpiUtValidNameseg (char *Signature)
BOOLEAN	AcpiUtValidNameChar (char Character, UINT32 Position)
void	AcpiUtCheckAndRepairAscii (UINT8 *Name, char *RepairedName, UINT32 Count)
UINT8	AcpiUtGenerateChecksum (void *Table, UINT32 Length, UINT8 OriginalChecksum)
UINT8	AcpiUtChecksum (UINT8 *Buffer, UINT32 Length)
ACPI_STATUS	AcpiUtVerifyCdatChecksum (ACPI_TABLE_CDAT *CdatTable, UINT32 Length)
ACPI_STATUS	AcpiUtVerifyChecksum (ACPI_TABLE_HEADER *Table, UINT32 Length)
void	AcpiUtStrupr (char *SrcString)
void	AcpiUtStrlwr (char *SrcString)
int	AcpiUtStricmp (char *String1, char *String2)
ACPI_STATUS	AcpiUtConvertOctalString (char *String, UINT64 *ReturnValue)
ACPI_STATUS	AcpiUtConvertDecimalString (char *String, UINT64 *ReturnValuePtr)
ACPI_STATUS	AcpiUtConvertHexString (char *String, UINT64 *ReturnValuePtr)
char	AcpiUtRemoveWhitespace (char **String)
char	AcpiUtRemoveLeadingZeros (char **String)
BOOLEAN	AcpiUtDetectHexPrefix (char **String)
void	AcpiUtRemoveHexPrefix (char **String)
BOOLEAN	AcpiUtDetectOctalPrefix (char **String)
ACPI_STATUS	AcpiUtStrtoul64 (char *String, UINT64 *RetInteger)
UINT64	AcpiUtExplicitStrtoul64 (char *String)
UINT64	AcpiUtImplicitStrtoul64 (char *String)
ACPI_STATUS	AcpiUtInitGlobals (void)
const char *	AcpiUtGetMutexName (UINT32 MutexId)
const char *	AcpiUtGetTypeName (ACPI_OBJECT_TYPE Type)
const char *	AcpiUtGetNodeName (void *Object)
const char *	AcpiUtGetDescriptorName (void *Object)
const char *	AcpiUtGetReferenceName (ACPI_OPERAND_OBJECT *Object)
const char *	AcpiUtGetObjectTypeName (ACPI_OPERAND_OBJECT *ObjDesc)
const char *	AcpiUtGetRegionName (UINT8 SpaceId)
const char *	AcpiUtGetEventName (UINT32 EventId)
const char *	AcpiUtGetArgumentTypeName (UINT32 ArgType)
char	AcpiUtHexToAsciiChar (UINT64 Integer, UINT32 Position)
ACPI_STATUS	AcpiUtAsciiToHexByte (char *TwoAsciiChars, UINT8 *ReturnByte)
UINT8	AcpiUtAsciiCharToHex (int HexChar)
BOOLEAN	AcpiUtValidObjectType (ACPI_OBJECT_TYPE Type)
ACPI_STATUS	AcpiUtHardwareInitialize (void)
void	AcpiUtSubsystemShutdown (void)
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	AcpiUtCopyEobjectToIobject (ACPI_OBJECT *Obj, ACPI_OPERAND_OBJECT **InternalObj)
ACPI_STATUS	AcpiUtCopyISimpleToIsimple (ACPI_OPERAND_OBJECT *SourceObj, ACPI_OPERAND_OBJECT *DestObj)
ACPI_STATUS	AcpiUtCopyIobjectToIobject (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT **DestDesc, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiUtUpdateObjectReference (ACPI_OPERAND_OBJECT *Object, UINT16 Action)
void	AcpiUtInitStackPtrTrace (void)
void	AcpiUtTrackStackPtr (void)
void	AcpiUtTrace (UINT32 LineNumber, const char *FunctionName, const char *ModuleName, UINT32 ComponentId)
void	AcpiUtTracePtr (UINT32 LineNumber, const char *FunctionName, const char *ModuleName, UINT32 ComponentId, const void *Pointer)
void	AcpiUtTraceU32 (UINT32 LineNumber, const char *FunctionName, const char *ModuleName, UINT32 ComponentId, UINT32 Integer)
void	AcpiUtTraceStr (UINT32 LineNumber, const char *FunctionName, const char *ModuleName, UINT32 ComponentId, const char *String)
void	AcpiUtExit (UINT32 LineNumber, const char *FunctionName, const char *ModuleName, UINT32 ComponentId)
void	AcpiUtStatusExit (UINT32 LineNumber, const char *FunctionName, const char *ModuleName, UINT32 ComponentId, ACPI_STATUS Status)
void	AcpiUtValueExit (UINT32 LineNumber, const char *FunctionName, const char *ModuleName, UINT32 ComponentId, UINT64 Value)
void	AcpiUtPtrExit (UINT32 LineNumber, const char *FunctionName, const char *ModuleName, UINT32 ComponentId, UINT8 *Ptr)
void	AcpiUtStrExit (UINT32 LineNumber, const char *FunctionName, const char *ModuleName, UINT32 ComponentId, const char *String)
void	AcpiUtDebugDumpBuffer (UINT8 *Buffer, UINT32 Count, UINT32 Display, UINT32 ComponentId)
void	AcpiUtDumpBuffer (UINT8 *Buffer, UINT32 Count, UINT32 Display, UINT32 Offset)
void	AcpiUtReportError (char *ModuleName, UINT32 LineNumber)
void	AcpiUtReportInfo (char *ModuleName, UINT32 LineNumber)
void	AcpiUtReportWarning (char *ModuleName, UINT32 LineNumber)
void	AcpiUtAddReference (ACPI_OPERAND_OBJECT *Object)
void	AcpiUtRemoveReference (ACPI_OPERAND_OBJECT *Object)
void	AcpiUtDeleteInternalPackageObject (ACPI_OPERAND_OBJECT *Object)
void	AcpiUtDeleteInternalSimpleObject (ACPI_OPERAND_OBJECT *Object)
void	AcpiUtDeleteInternalObjectList (ACPI_OPERAND_OBJECT **ObjList)
ACPI_STATUS	AcpiUtEvaluateObject (ACPI_NAMESPACE_NODE *PrefixNode, const char *Path, UINT32 ExpectedReturnBtypes, ACPI_OPERAND_OBJECT **ReturnDesc)
ACPI_STATUS	AcpiUtEvaluateNumericObject (const char *ObjectName, ACPI_NAMESPACE_NODE *DeviceNode, UINT64 *Value)
ACPI_STATUS	AcpiUtExecute_STA (ACPI_NAMESPACE_NODE *DeviceNode, UINT32 *StatusFlags)
ACPI_STATUS	AcpiUtExecutePowerMethods (ACPI_NAMESPACE_NODE *DeviceNode, const char **MethodNames, UINT8 MethodCount, UINT8 *OutValues)
ACPI_STATUS	AcpiUtExecute_HID (ACPI_NAMESPACE_NODE *DeviceNode, ACPI_PNP_DEVICE_ID **ReturnId)
ACPI_STATUS	AcpiUtExecute_UID (ACPI_NAMESPACE_NODE *DeviceNode, ACPI_PNP_DEVICE_ID **ReturnId)
ACPI_STATUS	AcpiUtExecute_CID (ACPI_NAMESPACE_NODE *DeviceNode, ACPI_PNP_DEVICE_ID_LIST **ReturnCidList)
ACPI_STATUS	AcpiUtExecute_CLS (ACPI_NAMESPACE_NODE *DeviceNode, ACPI_PNP_DEVICE_ID **ReturnId)
ACPI_STATUS	AcpiUtCreateRwLock (ACPI_RW_LOCK *Lock)
void	AcpiUtDeleteRwLock (ACPI_RW_LOCK *Lock)
ACPI_STATUS	AcpiUtAcquireReadLock (ACPI_RW_LOCK *Lock)
ACPI_STATUS	AcpiUtReleaseReadLock (ACPI_RW_LOCK *Lock)
ACPI_STATUS	AcpiUtAcquireWriteLock (ACPI_RW_LOCK *Lock)
void	AcpiUtReleaseWriteLock (ACPI_RW_LOCK *Lock)
ACPI_OPERAND_OBJECT *	AcpiUtCreateInternalObjectDbg (const char *ModuleName, UINT32 LineNumber, UINT32 ComponentId, ACPI_OBJECT_TYPE Type)
void *	AcpiUtAllocateObjectDescDbg (const char *ModuleName, UINT32 LineNumber, UINT32 ComponentId)
void	AcpiUtDeleteObjectDesc (ACPI_OPERAND_OBJECT *Object)
BOOLEAN	AcpiUtValidInternalObject (void *Object)
ACPI_OPERAND_OBJECT *	AcpiUtCreatePackageObject (UINT32 Count)
ACPI_OPERAND_OBJECT *	AcpiUtCreateIntegerObject (UINT64 Value)
ACPI_OPERAND_OBJECT *	AcpiUtCreateBufferObject (ACPI_SIZE BufferSize)
ACPI_OPERAND_OBJECT *	AcpiUtCreateStringObject (ACPI_SIZE StringSize)
ACPI_STATUS	AcpiUtGetObjectSize (ACPI_OPERAND_OBJECT *Obj, ACPI_SIZE *ObjLength)
ACPI_STATUS	AcpiUtInitializeInterfaces (void)
ACPI_STATUS	AcpiUtInterfaceTerminate (void)
ACPI_STATUS	AcpiUtInstallInterface (ACPI_STRING InterfaceName)
ACPI_STATUS	AcpiUtRemoveInterface (ACPI_STRING InterfaceName)
ACPI_STATUS	AcpiUtUpdateInterfaces (UINT8 Action)
ACPI_INTERFACE_INFO *	AcpiUtGetInterface (ACPI_STRING InterfaceName)
ACPI_STATUS	AcpiUtOsiImplementation (ACPI_WALK_STATE *WalkState)
const ACPI_PREDEFINED_INFO *	AcpiUtGetNextPredefinedMethod (const ACPI_PREDEFINED_INFO *ThisName)
const ACPI_PREDEFINED_INFO *	AcpiUtMatchPredefinedMethod (char *Name)
void	AcpiUtGetExpectedReturnTypes (char *Buffer, UINT32 ExpectedBtypes)
void	AcpiUtPushGenericState (ACPI_GENERIC_STATE **ListHead, ACPI_GENERIC_STATE *State)
ACPI_GENERIC_STATE *	AcpiUtPopGenericState (ACPI_GENERIC_STATE **ListHead)
ACPI_GENERIC_STATE *	AcpiUtCreateGenericState (void)
ACPI_THREAD_STATE *	AcpiUtCreateThreadState (void)
ACPI_GENERIC_STATE *	AcpiUtCreateUpdateState (ACPI_OPERAND_OBJECT *Object, UINT16 Action)
ACPI_GENERIC_STATE *	AcpiUtCreatePkgState (void *InternalObject, void *ExternalObject, UINT32 Index)
ACPI_STATUS	AcpiUtCreateUpdateStateAndPush (ACPI_OPERAND_OBJECT *Object, UINT16 Action, ACPI_GENERIC_STATE **StateList)
ACPI_GENERIC_STATE *	AcpiUtCreateControlState (void)
void	AcpiUtDeleteGenericState (ACPI_GENERIC_STATE *State)
ACPI_STATUS	AcpiUtDivide (UINT64 InDividend, UINT64 InDivisor, UINT64 *OutQuotient, UINT64 *OutRemainder)
ACPI_STATUS	AcpiUtShortDivide (UINT64 InDividend, UINT32 Divisor, UINT64 *OutQuotient, UINT32 *OutRemainder)
ACPI_STATUS	AcpiUtShortMultiply (UINT64 InMultiplicand, UINT32 Multiplier, UINT64 *Outproduct)
ACPI_STATUS	AcpiUtShortShiftLeft (UINT64 Operand, UINT32 Count, UINT64 *OutResult)
ACPI_STATUS	AcpiUtShortShiftRight (UINT64 Operand, UINT32 Count, UINT64 *OutResult)
const ACPI_EXCEPTION_INFO *	AcpiUtValidateException (ACPI_STATUS Status)
BOOLEAN	AcpiUtIsPciRootBridge (char *Id)
ACPI_STATUS	AcpiUtWalkPackageTree (ACPI_OPERAND_OBJECT *SourceObject, void *TargetObject, ACPI_PKG_CALLBACK WalkCallback, void *Context)
UINT32	AcpiUtDwordByteSwap (UINT32 Value)
void	AcpiUtSetIntegerWidth (UINT8 Revision)
ACPI_STATUS	AcpiUtAllocateOwnerId (ACPI_OWNER_ID *OwnerId)
void	AcpiUtReleaseOwnerId (ACPI_OWNER_ID *OwnerId)
ACPI_STATUS	AcpiUtWalkAmlResources (ACPI_WALK_STATE *WalkState, UINT8 *Aml, ACPI_SIZE AmlLength, ACPI_WALK_AML_CALLBACK UserFunction, void **Context)
ACPI_STATUS	AcpiUtValidateResource (ACPI_WALK_STATE *WalkState, void *Aml, UINT8 *ReturnIndex)
UINT32	AcpiUtGetDescriptorLength (void *Aml)
UINT16	AcpiUtGetResourceLength (void *Aml)
UINT8	AcpiUtGetResourceHeaderLength (void *Aml)
UINT8	AcpiUtGetResourceType (void *Aml)
ACPI_STATUS	AcpiUtGetResourceEndTag (ACPI_OPERAND_OBJECT *ObjDesc, UINT8 **EndTag)
void	AcpiUtPrintString (char *String, UINT16 MaxLength)
void	AcpiUtRepairName (char *Name)
ACPI_STATUS	AcpiUtMutexInitialize (void)
void	AcpiUtMutexTerminate (void)
ACPI_STATUS	AcpiUtAcquireMutex (ACPI_MUTEX_HANDLE MutexId)
ACPI_STATUS	AcpiUtReleaseMutex (ACPI_MUTEX_HANDLE MutexId)
ACPI_STATUS	AcpiUtCreateCaches (void)
ACPI_STATUS	AcpiUtDeleteCaches (void)
ACPI_STATUS	AcpiUtValidateBuffer (ACPI_BUFFER *Buffer)
ACPI_STATUS	AcpiUtInitializeBuffer (ACPI_BUFFER *Buffer, ACPI_SIZE RequiredLength)
ACPI_STATUS	AcpiUtAddAddressRange (ACPI_ADR_SPACE_TYPE SpaceId, ACPI_PHYSICAL_ADDRESS Address, UINT32 Length, ACPI_NAMESPACE_NODE *RegionNode)
void	AcpiUtRemoveAddressRange (ACPI_ADR_SPACE_TYPE SpaceId, ACPI_NAMESPACE_NODE *RegionNode)
UINT32	AcpiUtCheckAddressRange (ACPI_ADR_SPACE_TYPE SpaceId, ACPI_PHYSICAL_ADDRESS Address, UINT32 Length, BOOLEAN Warn)
void	AcpiUtDeleteAddressLists (void)
void ACPI_INTERNAL_VAR_XFACE	AcpiUtPredefinedWarning (const char *ModuleName, UINT32 LineNumber, char *Pathname, UINT16 NodeFlags, const char *Format,...)
void ACPI_INTERNAL_VAR_XFACE	AcpiUtPredefinedInfo (const char *ModuleName, UINT32 LineNumber, char *Pathname, UINT16 NodeFlags, const char *Format,...)
void ACPI_INTERNAL_VAR_XFACE	AcpiUtPredefinedBiosError (const char *ModuleName, UINT32 LineNumber, char *Pathname, UINT16 NodeFlags, const char *Format,...)
void	AcpiUtPrefixedNamespaceError (const char *ModuleName, UINT32 LineNumber, ACPI_GENERIC_STATE *PrefixScope, const char *InternalName, ACPI_STATUS LookupStatus)
void	AcpiUtMethodError (const char *ModuleName, UINT32 LineNumber, const char *Message, ACPI_NAMESPACE_NODE *Node, const char *Path, ACPI_STATUS LookupStatus)
const AH_PREDEFINED_NAME *	AcpiAhMatchPredefinedName (char *Nameseg)
const AH_DEVICE_ID *	AcpiAhMatchHardwareId (char *Hid)
const char *	AcpiAhMatchUuid (UINT8 *Data)

Variables
const UINT8	AcpiGbl_ResourceAmlSizes []
const UINT8	AcpiGbl_ResourceAmlSerialBusSizes []

Macro Definition Documentation

ACPI_ANY_BASE

#define ACPI_ANY_BASE   0

Definition at line 889 of file acutils.h.

ACPI_FIXED_LENGTH

#define ACPI_FIXED_LENGTH   1

Definition at line 151 of file acutils.h.

ACPI_IMPLICIT_CONVERSION

#define ACPI_IMPLICIT_CONVERSION   TRUE

Definition at line 145 of file acutils.h.

ACPI_INVALID_RESOURCE

#define ACPI_INVALID_RESOURCE   0

Definition at line 150 of file acutils.h.

ACPI_MSG_BIOS_ERROR

#define ACPI_MSG_BIOS_ERROR   "Firmware Error (ACPI): "

Definition at line 131 of file acutils.h.

ACPI_MSG_BIOS_WARNING

#define ACPI_MSG_BIOS_WARNING   "Firmware Warning (ACPI): "

Definition at line 134 of file acutils.h.

ACPI_MSG_ERROR

#define ACPI_MSG_ERROR   "ACPI Error: "

Definition at line 121 of file acutils.h.

ACPI_MSG_INFO

#define ACPI_MSG_INFO   "ACPI: "

Definition at line 127 of file acutils.h.

ACPI_MSG_REDIRECT_BEGIN

#define ACPI_MSG_REDIRECT_BEGIN

Definition at line 113 of file acutils.h.

ACPI_MSG_REDIRECT_END

#define ACPI_MSG_REDIRECT_END

Definition at line 114 of file acutils.h.

ACPI_MSG_SUFFIX

#define ACPI_MSG_SUFFIX    AcpiOsPrintf (" (%8.8X/%s-%u)\n", ACPI_CA_VERSION, ModuleName, LineNumber)

Definition at line 140 of file acutils.h.

ACPI_MSG_WARNING

#define ACPI_MSG_WARNING   "ACPI Warning: "

Definition at line 124 of file acutils.h.

ACPI_NO_IMPLICIT_CONVERSION

#define ACPI_NO_IMPLICIT_CONVERSION   FALSE

Definition at line 146 of file acutils.h.

ACPI_SMALL_VARIABLE_LENGTH

#define ACPI_SMALL_VARIABLE_LENGTH   3

Definition at line 153 of file acutils.h.

ACPI_VARIABLE_LENGTH

#define ACPI_VARIABLE_LENGTH   2

Definition at line 152 of file acutils.h.

AcpiUtAllocateObjectDesc

#define AcpiUtAllocateObjectDesc

(

)

AcpiUtAllocateObjectDescDbg (_AcpiModuleName,__LINE__,_COMPONENT)

Definition at line 682 of file acutils.h.

AcpiUtCreateInternalObject

#define AcpiUtCreateInternalObject

(

t

)

AcpiUtCreateInternalObjectDbg (_AcpiModuleName,__LINE__,_COMPONENT,t)

Definition at line 681 of file acutils.h.

DB_BYTE_DISPLAY

#define DB_BYTE_DISPLAY   0x01

Definition at line 186 of file acutils.h.

DB_DISPLAY_DATA_ONLY

#define DB_DISPLAY_DATA_ONLY   0x10

Definition at line 190 of file acutils.h.

DB_DWORD_DISPLAY

#define DB_DWORD_DISPLAY   0x04

Definition at line 188 of file acutils.h.

DB_QWORD_DISPLAY

#define DB_QWORD_DISPLAY   0x08

Definition at line 189 of file acutils.h.

DB_WORD_DISPLAY

#define DB_WORD_DISPLAY   0x02

Definition at line 187 of file acutils.h.

REF_DECREMENT

#define REF_DECREMENT   (UINT16) 1

Definition at line 182 of file acutils.h.

REF_INCREMENT

#define REF_INCREMENT   (UINT16) 0

Definition at line 181 of file acutils.h.

Typedef Documentation

ACPI_PKG_CALLBACK

typedef ACPI_STATUS(* ACPI_PKG_CALLBACK) (UINT8 ObjectType, ACPI_OPERAND_OBJECT *SourceObject, ACPI_GENERIC_STATE *State, void *Context)

Definition at line 164 of file acutils.h.

ACPI_PKG_INFO

typedef struct acpi_pkg_info ACPI_PKG_INFO

ACPI_WALK_AML_CALLBACK

typedef ACPI_STATUS(* ACPI_WALK_AML_CALLBACK) (UINT8 *Aml, UINT32 Length, UINT32 Offset, UINT8 ResourceIndex, void **Context)

Definition at line 156 of file acutils.h.

Function Documentation

AcpiAhMatchHardwareId()

const AH_DEVICE_ID * AcpiAhMatchHardwareId

(

char *

Hid

)

AcpiAhMatchPredefinedName()

const AH_PREDEFINED_NAME * AcpiAhMatchPredefinedName

(

char *

Nameseg

)

AcpiAhMatchUuid()

const char * AcpiAhMatchUuid

(

UINT8 *

Data

)

AcpiUtAcquireMutex()

ACPI_STATUS AcpiUtAcquireMutex

(

ACPI_MUTEX_HANDLE

MutexId

)

Definition at line 256 of file utmutex.c.

{
    ACPI_STATUS             Status;
    ACPI_THREAD_ID          ThisThreadId;
 
 
    ACPI_FUNCTION_NAME (UtAcquireMutex);
 
 
    if (MutexId > ACPI_MAX_MUTEX)
    {
        return (AE_BAD_PARAMETER);
    }
 
    ThisThreadId = AcpiOsGetThreadId ();
 
#ifdef ACPI_MUTEX_DEBUG
    {
        UINT32                  i;
        /*
         * Mutex debug code, for internal debugging only.
         *
         * 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 < ACPI_NUM_MUTEX; i++)
        {
            if (AcpiGbl_MutexInfo[i].ThreadId == ThisThreadId)
            {
                if (i == MutexId)
                {
                    ACPI_ERROR ((AE_INFO,
                        "Mutex [%s] already acquired by this thread [%u]",
                        AcpiUtGetMutexName (MutexId),
                        (UINT32) ThisThreadId));
 
                    return (AE_ALREADY_ACQUIRED);
                }
 
                ACPI_ERROR ((AE_INFO,
                    "Invalid acquire order: Thread %u owns [%s], wants [%s]",
                    (UINT32) ThisThreadId, AcpiUtGetMutexName (i),
                    AcpiUtGetMutexName (MutexId)));
 
                return (AE_ACQUIRE_DEADLOCK);
            }
        }
    }
#endif
 
    ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
        "Thread %u attempting to acquire Mutex [%s]\n",
        (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId)));
 
    Status = AcpiOsAcquireMutex (
        AcpiGbl_MutexInfo[MutexId].Mutex, ACPI_WAIT_FOREVER);
    if (ACPI_SUCCESS (Status))
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
            "Thread %u acquired Mutex [%s]\n",
            (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId)));
 
        AcpiGbl_MutexInfo[MutexId].UseCount++;
        AcpiGbl_MutexInfo[MutexId].ThreadId = ThisThreadId;
    }
    else
    {
        ACPI_EXCEPTION ((AE_INFO, Status,
            "Thread %u could not acquire Mutex [%s] (0x%X)",
            (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId), MutexId));
    }
 
    return (Status);
}

Referenced by AcpiAnyGpeStatusSet(), AcpiAttachData(), AcpiCheckAddressRange(), AcpiDebugTrace(), AcpiDetachData(), AcpiDisableAllGpes(), AcpiEnableAllRuntimeGpes(), AcpiEnableAllWakeupGpes(), AcpiEvDeleteGpeBlock(), AcpiEvDetachRegion(), AcpiEvExecuteOrphanRegMethod(), AcpiEvGpeInitialize(), AcpiEvInitializeOpRegions(), AcpiEvInstallGpeBlock(), AcpiEvInstallGpeHandler(), AcpiEvInstallRegionHandlers(), AcpiEvUpdateGpes(), AcpiExEnterInterpreter(), AcpiGetData(), AcpiGetDevices(), AcpiGetName(), AcpiGetNextObject(), AcpiGetObjectInfo(), AcpiGetParent(), AcpiGetTable(), AcpiGetTableByIndex(), AcpiGetType(), AcpiInstallAddressSpaceHandler(), AcpiInstallExceptionHandler(), AcpiInstallFixedEventHandler(), AcpiInstallGlobalEventHandler(), AcpiInstallGpeBlock(), AcpiInstallMethod(), AcpiInstallNotifyHandler(), AcpiInstallSciHandler(), AcpiInstallTableHandler(), AcpiNsDeleteNamespaceByOwner(), AcpiNsDeleteNamespaceSubtree(), AcpiNsGetDeviceCallback(), AcpiNsGetNode(), AcpiNsRootInitialize(), AcpiNsTerminate(), AcpiNsWalkNamespace(), AcpiPutTable(), AcpiReallocateRootTable(), AcpiRemoveAddressSpaceHandler(), AcpiRemoveFixedEventHandler(), AcpiRemoveGpeBlock(), AcpiRemoveGpeHandler(), AcpiRemoveNotifyHandler(), AcpiRemoveSciHandler(), AcpiRemoveTableHandler(), AcpiTbAllocateOwnerId(), AcpiTbDeleteNamespaceByOwner(), AcpiTbFindTable(), AcpiTbGetOwnerId(), AcpiTbInstallStandardTable(), AcpiTbIsTableLoaded(), AcpiTbLoadNamespace(), AcpiTbReleaseOwnerId(), AcpiTbSetTableLoadedFlag(), AcpiTbTerminate(), AcpiUnloadParentTable(), AcpiUpdateAllGpes(), AcpiUtAllocateOwnerId(), AcpiUtReleaseOwnerId(), and AcpiWalkNamespace().

AcpiUtAcquireReadLock()

ACPI_STATUS AcpiUtAcquireReadLock

(

ACPI_RW_LOCK *

Lock

)

Definition at line 117 of file utlock.c.

{
    ACPI_STATUS             Status;
 
 
    Status = AcpiOsAcquireMutex (Lock->ReaderMutex, ACPI_WAIT_FOREVER);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    /* Acquire the write lock only for the first reader */
 
    Lock->NumReaders++;
    if (Lock->NumReaders == 1)
    {
        Status = AcpiOsAcquireMutex (Lock->WriterMutex, ACPI_WAIT_FOREVER);
    }
 
    AcpiOsReleaseMutex (Lock->ReaderMutex);
    return (Status);
}

Referenced by AcpiWalkNamespace().

AcpiUtAcquireWriteLock()

ACPI_STATUS AcpiUtAcquireWriteLock

(

ACPI_RW_LOCK *

Lock

)

Definition at line 185 of file utlock.c.

{
    ACPI_STATUS             Status;
 
 
    Status = AcpiOsAcquireMutex (Lock->WriterMutex, ACPI_WAIT_FOREVER);
    return (Status);
}

Referenced by AcpiTbDeleteNamespaceByOwner().

AcpiUtAddAddressRange()

ACPI_STATUS AcpiUtAddAddressRange	(	ACPI_ADR_SPACE_TYPE	SpaceId,
		ACPI_PHYSICAL_ADDRESS	Address,
		UINT32	Length,
		ACPI_NAMESPACE_NODE *	RegionNode
	)

Definition at line 78 of file utaddress.c.

{
    ACPI_ADDRESS_RANGE      *RangeInfo;
 
 
    ACPI_FUNCTION_TRACE (UtAddAddressRange);
 
 
    if ((SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
        (SpaceId != ACPI_ADR_SPACE_SYSTEM_IO))
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    /* Allocate/init a new info block, add it to the appropriate list */
 
    RangeInfo = ACPI_ALLOCATE (sizeof (ACPI_ADDRESS_RANGE));
    if (!RangeInfo)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    RangeInfo->StartAddress = Address;
    RangeInfo->EndAddress = (Address + Length - 1);
    RangeInfo->RegionNode = RegionNode;
 
    RangeInfo->Next = AcpiGbl_AddressRangeList[SpaceId];
    AcpiGbl_AddressRangeList[SpaceId] = RangeInfo;
 
    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
        "\nAdded [%4.4s] address range: 0x%8.8X%8.8X-0x%8.8X%8.8X\n",
        AcpiUtGetNodeName (RangeInfo->RegionNode),
        ACPI_FORMAT_UINT64 (Address),
        ACPI_FORMAT_UINT64 (RangeInfo->EndAddress)));
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiDsEvalRegionOperands(), and AcpiDsGetRegionArguments().

AcpiUtAddReference()

void AcpiUtAddReference

(

ACPI_OPERAND_OBJECT *

Object

)

Definition at line 752 of file utdelete.c.

{
 
    ACPI_FUNCTION_NAME (UtAddReference);
 
 
    /* Ensure that we have a valid object */
 
    if (!AcpiUtValidInternalObject (Object))
    {
        return;
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
        "Obj %p Current Refs=%X [To Be Incremented]\n",
        Object, Object->Common.ReferenceCount));
 
    /* Increment the reference count */
 
    (void) AcpiUtUpdateObjectReference (Object, REF_INCREMENT);
    return;
}

Referenced by AcpiDsBuildInternalPackageObj(), AcpiDsDoImplicitReturn(), AcpiDsExecEndOp(), AcpiDsMethodDataGetValue(), AcpiDsMethodDataSetValue(), AcpiEvAttachRegion(), AcpiExOpcode_1A_0T_1R(), AcpiExOpcode_1A_1T_1R(), AcpiExOpcode_2A_1T_1R(), AcpiExPrepFieldValue(), AcpiExResolveNodeToValue(), AcpiExResolveObjectToValue(), AcpiExStoreObjectToIndex(), AcpiInstallNotifyHandler(), AcpiNsAttachObject(), AcpiNsConvertToReference(), AcpiNsResolveReferences(), and AcpiUtCopySimpleObject().

AcpiUtAllocateObjectDescDbg()

void * AcpiUtAllocateObjectDescDbg	(	const char *	ModuleName,
		UINT32	LineNumber,
		UINT32	ComponentId
	)

Definition at line 429 of file utobject.c.

{
    ACPI_OPERAND_OBJECT     *Object;
 
 
    ACPI_FUNCTION_TRACE (UtAllocateObjectDescDbg);
 
 
    Object = AcpiOsAcquireObject (AcpiGbl_OperandCache);
    if (!Object)
    {
        ACPI_ERROR ((ModuleName, LineNumber,
            "Could not allocate an object descriptor"));
 
        return_PTR (NULL);
    }
 
    /* Mark the descriptor type */
 
    ACPI_SET_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_OPERAND);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
        Object, (UINT32) sizeof (ACPI_OPERAND_OBJECT)));
 
    return_PTR (Object);
}

Referenced by AcpiUtCreateInternalObjectDbg().

AcpiUtAllocateOwnerId()

ACPI_STATUS AcpiUtAllocateOwnerId

(

ACPI_OWNER_ID *

OwnerId

)

Definition at line 68 of file utownerid.c.

{
    UINT32                  i;
    UINT32                  j;
    UINT32                  k;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (UtAllocateOwnerId);
 
 
    /* Guard against multiple allocations of ID to the same location */
 
    if (*OwnerId)
    {
        ACPI_ERROR ((AE_INFO,
            "Owner ID [0x%3.3X] already exists", *OwnerId));
        return_ACPI_STATUS (AE_ALREADY_EXISTS);
    }
 
    /* Mutex for the global ID mask */
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Find a free owner ID, cycle through all possible IDs on repeated
     * allocations. (ACPI_NUM_OWNERID_MASKS + 1) because first index
     * may have to be scanned twice.
     */
    for (i = 0, j = AcpiGbl_LastOwnerIdIndex;
         i < (ACPI_NUM_OWNERID_MASKS + 1);
         i++, j++)
    {
        if (j >= ACPI_NUM_OWNERID_MASKS)
        {
            j = 0;  /* Wraparound to start of mask array */
        }
 
        for (k = AcpiGbl_NextOwnerIdOffset; k < 32; k++)
        {
            if (AcpiGbl_OwnerIdMask[j] == ACPI_UINT32_MAX)
            {
                /* There are no free IDs in this mask */
 
                break;
            }
 
            /*
             * Note: the UINT32 cast ensures that 1 is stored as a unsigned
             * integer. Omitting the cast may result in 1 being stored as an
             * int. Some compilers or runtime error detection may flag this as
             * an error.
             */
            if (!(AcpiGbl_OwnerIdMask[j] & ((UINT32) 1 << k)))
            {
                /*
                 * Found a free ID. The actual ID is the bit index plus one,
                 * making zero an invalid Owner ID. Save this as the last ID
                 * allocated and update the global ID mask.
                 */
                AcpiGbl_OwnerIdMask[j] |= ((UINT32) 1 << k);
 
                AcpiGbl_LastOwnerIdIndex = (UINT8) j;
                AcpiGbl_NextOwnerIdOffset = (UINT8) (k + 1);
 
                /*
                 * Construct encoded ID from the index and bit position
                 *
                 * Note: Last [j].k (bit 4095) is never used and is marked
                 * permanently allocated (prevents +1 overflow)
                 */
                *OwnerId = (ACPI_OWNER_ID) ((k + 1) + ACPI_MUL_32 (j));
 
                ACPI_DEBUG_PRINT ((ACPI_DB_VALUES,
                    "Allocated OwnerId: 0x%3.3X\n", (unsigned int) *OwnerId));
                goto Exit;
            }
        }
 
        AcpiGbl_NextOwnerIdOffset = 0;
    }
 
    /*
     * All OwnerIds have been allocated. This typically should
     * not happen since the IDs are reused after deallocation. The IDs are
     * allocated upon table load (one per table) and method execution, and
     * they are released when a table is unloaded or a method completes
     * execution.
     *
     * If this error happens, there may be very deep nesting of invoked
     * control methods, or there may be a bug where the IDs are not released.
     */
    Status = AE_OWNER_ID_LIMIT;
    ACPI_ERROR ((AE_INFO,
        "Could not allocate new OwnerId (4095 max), AE_OWNER_ID_LIMIT"));
 
Exit:
    (void) AcpiUtReleaseMutex (ACPI_MTX_CACHES);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsBeginMethodExecution(), and AcpiTbAllocateOwnerId().

AcpiUtAsciiCharToHex()

UINT8 AcpiUtAsciiCharToHex

(

int

HexChar

)

Definition at line 135 of file uthex.c.

{
 
    /* Values 0-9 */
 
    if (HexChar <= '9')
    {
        return ((UINT8) (HexChar - '0'));
    }
 
    /* Upper case A-F */
 
    if (HexChar <= 'F')
    {
        return ((UINT8) (HexChar - 0x37));
    }
 
    /* Lower case a-f */
 
    return ((UINT8) (HexChar - 0x57));
}

Referenced by AcpiUtAsciiToHexByte(), and AcpiUtInsertDigit().

AcpiUtAsciiToHexByte()

ACPI_STATUS AcpiUtAsciiToHexByte	(	char *	TwoAsciiChars,
		UINT8 *	ReturnByte
	)

Definition at line 100 of file uthex.c.

{
 
    /* Both ASCII characters must be valid hex digits */
 
    if (!isxdigit ((int) TwoAsciiChars[0]) ||
        !isxdigit ((int) TwoAsciiChars[1]))
    {
        return (AE_BAD_HEX_CONSTANT);
    }
 
    *ReturnByte =
        AcpiUtAsciiCharToHex (TwoAsciiChars[1]) |
        (AcpiUtAsciiCharToHex (TwoAsciiChars[0]) << 4);
 
    return (AE_OK);
}

Referenced by AcpiEvMatchGpeMethod().

AcpiUtBuildPackageObject()

ACPI_STATUS AcpiUtBuildPackageObject	(	ACPI_OPERAND_OBJECT *	Obj,
		UINT8 *	Buffer,
		UINT32 *	SpaceUsed
	)

AcpiUtBuildSimpleObject()

ACPI_STATUS AcpiUtBuildSimpleObject	(	ACPI_OPERAND_OBJECT *	Obj,
		ACPI_OBJECT *	UserObj,
		UINT8 *	DataSpace,
		UINT32 *	BufferSpaceUsed
	)

AcpiUtCheckAddressRange()

UINT32 AcpiUtCheckAddressRange	(	ACPI_ADR_SPACE_TYPE	SpaceId,
		ACPI_PHYSICAL_ADDRESS	Address,
		UINT32	Length,
		BOOLEAN	Warn
	)

Definition at line 211 of file utaddress.c.

{
    ACPI_ADDRESS_RANGE      *RangeInfo;
    ACPI_PHYSICAL_ADDRESS   EndAddress;
    char                    *Pathname;
    UINT32                  OverlapCount = 0;
 
 
    ACPI_FUNCTION_TRACE (UtCheckAddressRange);
 
 
    if ((SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
        (SpaceId != ACPI_ADR_SPACE_SYSTEM_IO))
    {
        return_UINT32 (0);
    }
 
    RangeInfo = AcpiGbl_AddressRangeList[SpaceId];
    EndAddress = Address + Length - 1;
 
    /* Check entire list for all possible conflicts */
 
    while (RangeInfo)
    {
        /*
         * Check if the requested address/length overlaps this
         * address range. There are four cases to consider:
         *
         * 1) Input address/length is contained completely in the
         *    address range
         * 2) Input address/length overlaps range at the range start
         * 3) Input address/length overlaps range at the range end
         * 4) Input address/length completely encompasses the range
         */
        if ((Address <= RangeInfo->EndAddress) &&
            (EndAddress >= RangeInfo->StartAddress))
        {
            /* Found an address range overlap */
 
            OverlapCount++;
            if (Warn)   /* Optional warning message */
            {
                Pathname = AcpiNsGetNormalizedPathname (RangeInfo->RegionNode, TRUE);
 
                ACPI_WARNING ((AE_INFO,
                    "%s range 0x%8.8X%8.8X-0x%8.8X%8.8X conflicts with OpRegion 0x%8.8X%8.8X-0x%8.8X%8.8X (%s)",
                    AcpiUtGetRegionName (SpaceId),
                    ACPI_FORMAT_UINT64 (Address),
                    ACPI_FORMAT_UINT64 (EndAddress),
                    ACPI_FORMAT_UINT64 (RangeInfo->StartAddress),
                    ACPI_FORMAT_UINT64 (RangeInfo->EndAddress),
                    Pathname));
                ACPI_FREE (Pathname);
            }
        }
 
        RangeInfo = RangeInfo->Next;
    }
 
    return_UINT32 (OverlapCount);
}

Referenced by AcpiCheckAddressRange().

AcpiUtCheckAndRepairAscii()

void AcpiUtCheckAndRepairAscii	(	UINT8 *	Name,
		char *	RepairedName,
		UINT32	Count
	)

Definition at line 140 of file utascii.c.

{
    UINT32                  i;
 
 
    for (i = 0; i < Count; i++)
    {
        RepairedName[i] = (char) Name[i];
 
        if (!Name[i])
        {
            return;
        }
        if (!isprint (Name[i]))
        {
            RepairedName[i] = ' ';
        }
    }
}

AcpiUtChecksum()

UINT8 AcpiUtChecksum	(	UINT8 *	Buffer,
		UINT32	Length
	)

Definition at line 213 of file utcksum.c.

{
    UINT8                   Sum = 0;
    UINT8                   *End = Buffer + Length;
 
 
    while (Buffer < End)
    {
        Sum = (UINT8) (Sum + *(Buffer++));
    }
 
    return (Sum);
}

Referenced by AcpiTbValidateRsdp(), and AcpiUtGenerateChecksum().

AcpiUtConvertDecimalString()

ACPI_STATUS AcpiUtConvertDecimalString	(	char *	String,
		UINT64 *	ReturnValuePtr
	)

Definition at line 152 of file utstrsuppt.c.

{
    UINT64                  AccumulatedValue = 0;
    ACPI_STATUS             Status = AE_OK;
 
 
    /* Convert each ASCII byte in the input string */
 
    while (*String)
    {
        /*
         * Character must be ASCII 0-9, otherwise:
         * 1) Runtime: terminate with no error, per the ACPI spec
         * 2) Compiler: return an error
         */
        if (!isdigit ((int) *String))
        {
#ifdef ACPI_ASL_COMPILER
            Status = AE_BAD_DECIMAL_CONSTANT;
#endif
           break;
        }
 
        /* Convert and insert this decimal digit into the accumulator */
 
        Status = AcpiUtInsertDigit (&AccumulatedValue, 10, *String);
        if (ACPI_FAILURE (Status))
        {
            Status = AE_DECIMAL_OVERFLOW;
            break;
        }
 
        String++;
    }
 
    /* Always return the value that has been accumulated */
 
    *ReturnValuePtr = AccumulatedValue;
    return (Status);
}

Referenced by AcpiUtExplicitStrtoul64(), and AcpiUtStrtoul64().

AcpiUtConvertHexString()

ACPI_STATUS AcpiUtConvertHexString	(	char *	String,
		UINT64 *	ReturnValuePtr
	)

Definition at line 214 of file utstrsuppt.c.

{
    UINT64                  AccumulatedValue = 0;
    ACPI_STATUS             Status = AE_OK;
 
 
    /* Convert each ASCII byte in the input string */
 
    while (*String)
    {
        /*
         * Character must be ASCII A-F, a-f, or 0-9, otherwise:
         * 1) Runtime: terminate with no error, per the ACPI spec
         * 2) Compiler: return an error
         */
        if (!isxdigit ((int) *String))
        {
#ifdef ACPI_ASL_COMPILER
            Status = AE_BAD_HEX_CONSTANT;
#endif
            break;
        }
 
        /* Convert and insert this hex digit into the accumulator */
 
        Status = AcpiUtInsertDigit (&AccumulatedValue, 16, *String);
        if (ACPI_FAILURE (Status))
        {
            Status = AE_HEX_OVERFLOW;
            break;
        }
 
        String++;
    }
 
    /* Always return the value that has been accumulated */
 
    *ReturnValuePtr = AccumulatedValue;
    return (Status);
}

Referenced by AcpiUtExplicitStrtoul64(), AcpiUtImplicitStrtoul64(), and AcpiUtStrtoul64().

AcpiUtConvertOctalString()

ACPI_STATUS AcpiUtConvertOctalString	(	char *	String,
		UINT64 *	ReturnValue
	)

Definition at line 90 of file utstrsuppt.c.

{
    UINT64                  AccumulatedValue = 0;
    ACPI_STATUS             Status = AE_OK;
 
 
    /* Convert each ASCII byte in the input string */
 
    while (*String)
    {
        /*
         * Character must be ASCII 0-7, otherwise:
         * 1) Runtime: terminate with no error, per the ACPI spec
         * 2) Compiler: return an error
         */
        if (!(ACPI_IS_OCTAL_DIGIT (*String)))
        {
#ifdef ACPI_ASL_COMPILER
            Status = AE_BAD_OCTAL_CONSTANT;
#endif
            break;
        }
 
        /* Convert and insert this octal digit into the accumulator */
 
        Status = AcpiUtInsertDigit (&AccumulatedValue, 8, *String);
        if (ACPI_FAILURE (Status))
        {
            Status = AE_OCTAL_OVERFLOW;
            break;
        }
 
        String++;
    }
 
    /* Always return the value that has been accumulated */
 
    *ReturnValuePtr = AccumulatedValue;
    return (Status);
}

Referenced by AcpiUtStrtoul64().

AcpiUtCopyEobjectToIobject()

ACPI_STATUS AcpiUtCopyEobjectToIobject	(	ACPI_OBJECT *	Obj,
		ACPI_OPERAND_OBJECT **	InternalObj
	)

Definition at line 670 of file utcopy.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (UtCopyEobjectToIobject);
 
 
    if (ExternalObject->Type == ACPI_TYPE_PACKAGE)
    {
        Status = AcpiUtCopyEpackageToIpackage (
            ExternalObject, InternalObject);
    }
    else
    {
        /*
         * Build a simple object (no nested objects)
         */
        Status = AcpiUtCopyEsimpleToIsimple (ExternalObject,
            InternalObject);
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvaluateObject(), and AcpiUtCopyEpackageToIpackage().

AcpiUtCopyIobjectToEobject()

ACPI_STATUS AcpiUtCopyIobjectToEobject	(	ACPI_OPERAND_OBJECT *	Obj,
		ACPI_BUFFER *	RetBuffer
	)

Definition at line 414 of file utcopy.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (UtCopyIobjectToEobject);
 
 
    if (InternalObject->Common.Type == 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_CAST_PTR (ACPI_OBJECT, RetBuffer->Pointer),
            ACPI_ADD_PTR (UINT8, RetBuffer->Pointer,
                ACPI_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);
}

Referenced by AcpiEvaluateObject().

AcpiUtCopyIobjectToIobject()

ACPI_STATUS AcpiUtCopyIobjectToIobject	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_OPERAND_OBJECT **	DestDesc,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 1037 of file utcopy.c.

{
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE (UtCopyIobjectToIobject);
 
 
    /* Create the top level object */
 
    *DestDesc = AcpiUtCreateInternalObject (SourceDesc->Common.Type);
    if (!*DestDesc)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /* Copy the object and possible subobjects */
 
    if (SourceDesc->Common.Type == ACPI_TYPE_PACKAGE)
    {
        Status = AcpiUtCopyIpackageToIpackage (
            SourceDesc, *DestDesc, WalkState);
    }
    else
    {
        Status = AcpiUtCopySimpleObject (SourceDesc, *DestDesc);
    }
 
    /* Delete the allocated object if copy failed */
 
    if (ACPI_FAILURE (Status))
    {
        AcpiUtRemoveReference (*DestDesc);
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsEvaluateNamePath(), AcpiDsStoreObjectToLocal(), AcpiExOpcode_1A_1T_1R(), AcpiExStoreDirectToNode(), AcpiExStoreObjectToIndex(), and AcpiExStoreObjectToObject().

AcpiUtCopyISimpleToIsimple()

ACPI_STATUS AcpiUtCopyISimpleToIsimple	(	ACPI_OPERAND_OBJECT *	SourceObj,
		ACPI_OPERAND_OBJECT *	DestObj
	)

AcpiUtCreateBufferObject()

ACPI_OPERAND_OBJECT * AcpiUtCreateBufferObject

(

ACPI_SIZE

BufferSize

)

Definition at line 258 of file utobject.c.

{
    ACPI_OPERAND_OBJECT     *BufferDesc;
    UINT8                   *Buffer = NULL;
 
 
    ACPI_FUNCTION_TRACE_U32 (UtCreateBufferObject, BufferSize);
 
 
    /* Create a new Buffer object */
 
    BufferDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER);
    if (!BufferDesc)
    {
        return_PTR (NULL);
    }
 
    /* Create an actual buffer only if size > 0 */
 
    if (BufferSize > 0)
    {
        /* Allocate the actual buffer */
 
        Buffer = ACPI_ALLOCATE_ZEROED (BufferSize);
        if (!Buffer)
        {
            ACPI_ERROR ((AE_INFO, "Could not allocate size %u",
                (UINT32) BufferSize));
 
            AcpiUtRemoveReference (BufferDesc);
            return_PTR (NULL);
        }
    }
 
    /* Complete buffer object initialization */
 
    BufferDesc->Buffer.Flags |= AOPOBJ_DATA_VALID;
    BufferDesc->Buffer.Pointer = Buffer;
    BufferDesc->Buffer.Length = (UINT32) BufferSize;
 
    /* Return the new buffer descriptor */
 
    return_PTR (BufferDesc);
}

Referenced by AcpiExConcatTemplate(), AcpiExConvertToBuffer(), AcpiExDoConcatenate(), AcpiExReadDataFromField(), AcpiExReadSerialBus(), AcpiExWriteSerialBus(), AcpiNsConvertToBuffer(), AcpiNsConvertToResource(), AcpiNsConvertToUnicode(), AcpiNsRepair_FDE(), and AcpiNsRepairNullElement().

AcpiUtCreateCaches()

ACPI_STATUS AcpiUtCreateCaches

(

void

)

Definition at line 104 of file utalloc.c.

{
    ACPI_STATUS             Status;
 
 
    /* Object Caches, for frequently used objects */
 
    Status = AcpiOsCreateCache ("Acpi-Namespace", sizeof (ACPI_NAMESPACE_NODE),
        ACPI_MAX_NAMESPACE_CACHE_DEPTH, &AcpiGbl_NamespaceCache);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    Status = AcpiOsCreateCache ("Acpi-State", sizeof (ACPI_GENERIC_STATE),
        ACPI_MAX_STATE_CACHE_DEPTH, &AcpiGbl_StateCache);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    Status = AcpiOsCreateCache ("Acpi-Parse", sizeof (ACPI_PARSE_OBJ_COMMON),
        ACPI_MAX_PARSE_CACHE_DEPTH, &AcpiGbl_PsNodeCache);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    Status = AcpiOsCreateCache ("Acpi-ParseExt", sizeof (ACPI_PARSE_OBJ_NAMED),
        ACPI_MAX_EXTPARSE_CACHE_DEPTH, &AcpiGbl_PsNodeExtCache);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    Status = AcpiOsCreateCache ("Acpi-Operand", sizeof (ACPI_OPERAND_OBJECT),
        ACPI_MAX_OBJECT_CACHE_DEPTH, &AcpiGbl_OperandCache);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
#ifdef ACPI_ASL_COMPILER
    /*
     * For use with the ASL-/ASL+ option. This cache keeps track of regular
     * 0xA9 0x01 comments.
     */
    Status = AcpiOsCreateCache ("Acpi-Comment", sizeof (ACPI_COMMENT_NODE),
        ACPI_MAX_COMMENT_CACHE_DEPTH, &AcpiGbl_RegCommentCache);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    /*
     * This cache keeps track of the starting addresses of where the comments
     * lie. This helps prevent duplication of comments.
     */
    Status = AcpiOsCreateCache ("Acpi-Comment-Addr", sizeof (ACPI_COMMENT_ADDR_NODE),
        ACPI_MAX_COMMENT_CACHE_DEPTH, &AcpiGbl_CommentAddrCache);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    /*
     * This cache will be used for nodes that represent files.
     */
    Status = AcpiOsCreateCache ("Acpi-File", sizeof (ACPI_FILE_NODE),
        ACPI_MAX_COMMENT_CACHE_DEPTH, &AcpiGbl_FileCache);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
#endif
 
 
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
 
    /* Memory allocation lists */
 
    Status = AcpiUtCreateList ("Acpi-Global", 0,
        &AcpiGbl_GlobalList);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    Status = AcpiUtCreateList ("Acpi-Namespace", sizeof (ACPI_NAMESPACE_NODE),
        &AcpiGbl_NsNodeList);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
#endif
 
    return (AE_OK);
}

Referenced by AcpiUtInitGlobals().

AcpiUtCreateControlState()

ACPI_GENERIC_STATE * AcpiUtCreateControlState

(

void

)

Definition at line 300 of file utstate.c.

{
    ACPI_GENERIC_STATE      *State;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Create the generic state object */
 
    State = AcpiUtCreateGenericState ();
    if (!State)
    {
        return (NULL);
    }
 
    /* Init fields specific to the control struct */
 
    State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_CONTROL;
    State->Common.State = ACPI_CONTROL_CONDITIONAL_EXECUTING;
 
    return (State);
}

Referenced by AcpiDsExecBeginControlOp().

AcpiUtCreateGenericState()

ACPI_GENERIC_STATE * AcpiUtCreateGenericState

(

void

)

Definition at line 130 of file utstate.c.

{
    ACPI_GENERIC_STATE      *State;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    State = AcpiOsAcquireObject (AcpiGbl_StateCache);
    if (State)
    {
        /* Initialize */
        State->Common.DescriptorType = ACPI_DESC_TYPE_STATE;
    }
 
    return (State);
}

Referenced by AcpiDsResultStackPush(), AcpiDsScopeStackPush(), AcpiEvQueueNotifyRequest(), AcpiPsInitScope(), AcpiPsPushScope(), AcpiUtCreateControlState(), AcpiUtCreatePkgState(), AcpiUtCreateThreadState(), and AcpiUtCreateUpdateState().

AcpiUtCreateIntegerObject()

ACPI_OPERAND_OBJECT * AcpiUtCreateIntegerObject

(

UINT64

Value

)

Definition at line 223 of file utobject.c.

{
    ACPI_OPERAND_OBJECT     *IntegerDesc;
 
 
    ACPI_FUNCTION_TRACE (UtCreateIntegerObject);
 
 
    /* Create and initialize a new integer object */
 
    IntegerDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
    if (!IntegerDesc)
    {
        return_PTR (NULL);
    }
 
    IntegerDesc->Integer.Value = InitialValue;
    return_PTR (IntegerDesc);
}

Referenced by AcpiDsMethodDataGetValue(), AcpiEvExecuteRegMethod(), AcpiExConvertToInteger(), AcpiExLoadTableOp(), AcpiExOpcode_0A_0T_1R(), AcpiExOpcode_1A_0T_1R(), AcpiExOpcode_6A_0T_1R(), AcpiExReadDataFromField(), AcpiNsConvertToInteger(), AcpiNsRepairNullElement(), AcpiPsExecuteMethod(), and AcpiPsParseAml().

AcpiUtCreateInternalObjectDbg()

ACPI_OPERAND_OBJECT * AcpiUtCreateInternalObjectDbg	(	const char *	ModuleName,
		UINT32	LineNumber,
		UINT32	ComponentId,
		ACPI_OBJECT_TYPE	Type
	)

Definition at line 94 of file utobject.c.

{
    ACPI_OPERAND_OBJECT     *Object;
    ACPI_OPERAND_OBJECT     *SecondObject;
 
 
    ACPI_FUNCTION_TRACE_STR (UtCreateInternalObjectDbg,
        AcpiUtGetTypeName (Type));
 
 
    /* Allocate the raw object descriptor */
 
    Object = AcpiUtAllocateObjectDescDbg (
        ModuleName, LineNumber, ComponentId);
    if (!Object)
    {
        return_PTR (NULL);
    }
 
    switch (Type)
    {
    case ACPI_TYPE_REGION:
    case ACPI_TYPE_BUFFER_FIELD:
    case ACPI_TYPE_LOCAL_BANK_FIELD:
 
        /* These types require a secondary object */
 
        SecondObject = AcpiUtAllocateObjectDescDbg (
            ModuleName, LineNumber, ComponentId);
        if (!SecondObject)
        {
            AcpiUtDeleteObjectDesc (Object);
            return_PTR (NULL);
        }
 
        SecondObject->Common.Type = ACPI_TYPE_LOCAL_EXTRA;
        SecondObject->Common.ReferenceCount = 1;
 
        /* Link the second object to the first */
 
        Object->Common.NextObject = SecondObject;
        break;
 
    default:
 
        /* All others have no secondary object */
        break;
    }
 
    /* Save the object type in the object descriptor */
 
    Object->Common.Type = (UINT8) Type;
 
    /* Init the reference count */
 
    Object->Common.ReferenceCount = 1;
 
    /* Any per-type initialization should go here */
 
    return_PTR (Object);
}

AcpiUtCreatePackageObject()

ACPI_OPERAND_OBJECT * AcpiUtCreatePackageObject

(

UINT32

Count

)

Definition at line 174 of file utobject.c.

{
    ACPI_OPERAND_OBJECT     *PackageDesc;
    ACPI_OPERAND_OBJECT     **PackageElements;
 
 
    ACPI_FUNCTION_TRACE_U32 (UtCreatePackageObject, Count);
 
 
    /* Create a new Package object */
 
    PackageDesc = AcpiUtCreateInternalObject (ACPI_TYPE_PACKAGE);
    if (!PackageDesc)
    {
        return_PTR (NULL);
    }
 
    /*
     * Create the element array. Count+1 allows the array to be null
     * terminated.
     */
    PackageElements = ACPI_ALLOCATE_ZEROED (
        ((ACPI_SIZE) Count + 1) * sizeof (void *));
    if (!PackageElements)
    {
        ACPI_FREE (PackageDesc);
        return_PTR (NULL);
    }
 
    PackageDesc->Package.Count = Count;
    PackageDesc->Package.Elements = PackageElements;
    return_PTR (PackageDesc);
}

Referenced by AcpiNsWrapWithPackage(), AcpiUtCopyEpackageToIpackage(), and AcpiUtCopyIelementToIelement().

AcpiUtCreatePkgState()

ACPI_GENERIC_STATE * AcpiUtCreatePkgState	(	void *	InternalObject,
		void *	ExternalObject,
		UINT32	Index
	)

Definition at line 255 of file utstate.c.

{
    ACPI_GENERIC_STATE      *State;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Create the generic state object */
 
    State = AcpiUtCreateGenericState ();
    if (!State)
    {
        return (NULL);
    }
 
    /* Init fields specific to the update struct */
 
    State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_PACKAGE;
    State->Pkg.SourceObject = (ACPI_OPERAND_OBJECT *) InternalObject;
    State->Pkg.DestObject = ExternalObject;
    State->Pkg.Index= Index;
    State->Pkg.NumPackages = 1;
 
    return (State);
}

Referenced by AcpiUtWalkPackageTree().

AcpiUtCreateRwLock()

ACPI_STATUS AcpiUtCreateRwLock

(

ACPI_RW_LOCK *

Lock

)

Definition at line 66 of file utlock.c.

{
    ACPI_STATUS             Status;
 
 
    Lock->NumReaders = 0;
    Status = AcpiOsCreateMutex (&Lock->ReaderMutex);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    Status = AcpiOsCreateMutex (&Lock->WriterMutex);
    return (Status);
}

Referenced by AcpiUtMutexInitialize().

AcpiUtCreateStringObject()

ACPI_OPERAND_OBJECT * AcpiUtCreateStringObject

(

ACPI_SIZE

StringSize

)

Definition at line 320 of file utobject.c.

{
    ACPI_OPERAND_OBJECT     *StringDesc;
    char                    *String;
 
 
    ACPI_FUNCTION_TRACE_U32 (UtCreateStringObject, StringSize);
 
 
    /* Create a new String object */
 
    StringDesc = AcpiUtCreateInternalObject (ACPI_TYPE_STRING);
    if (!StringDesc)
    {
        return_PTR (NULL);
    }
 
    /*
     * Allocate the actual string buffer -- (Size + 1) for NULL terminator.
     * NOTE: Zero-length strings are NULL terminated
     */
    String = ACPI_ALLOCATE_ZEROED (StringSize + 1);
    if (!String)
    {
        ACPI_ERROR ((AE_INFO, "Could not allocate size %u",
            (UINT32) StringSize));
 
        AcpiUtRemoveReference (StringDesc);
        return_PTR (NULL);
    }
 
    /* Complete string object initialization */
 
    StringDesc->String.Pointer = String;
    StringDesc->String.Length = (UINT32) StringSize;
 
    /* Return the new string descriptor */
 
    return_PTR (StringDesc);
}

Referenced by AcpiExConvertToObjectTypeString(), AcpiExConvertToString(), AcpiExDoConcatenate(), AcpiExOpcode_2A_1T_1R(), AcpiNsConvertToString(), AcpiNsRepair_HID(), and AcpiNsRepairNullElement().

AcpiUtCreateThreadState()

ACPI_THREAD_STATE * AcpiUtCreateThreadState

(

void

)

Definition at line 164 of file utstate.c.

{
    ACPI_GENERIC_STATE      *State;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Create the generic state object */
 
    State = AcpiUtCreateGenericState ();
    if (!State)
    {
        return (NULL);
    }
 
    /* Init fields specific to the update struct */
 
    State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_THREAD;
    State->Thread.ThreadId = AcpiOsGetThreadId ();
 
    /* Check for invalid thread ID - zero is very bad, it will break things */
 
    if (!State->Thread.ThreadId)
    {
        ACPI_ERROR ((AE_INFO, "Invalid zero ID from AcpiOsGetThreadId"));
        State->Thread.ThreadId = (ACPI_THREAD_ID) 1;
    }
 
    return ((ACPI_THREAD_STATE *) State);
}

Referenced by AcpiPsParseAml().

AcpiUtCreateUpdateState()

ACPI_GENERIC_STATE * AcpiUtCreateUpdateState	(	ACPI_OPERAND_OBJECT *	Object,
		UINT16	Action
	)

Definition at line 214 of file utstate.c.

{
    ACPI_GENERIC_STATE      *State;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Create the generic state object */
 
    State = AcpiUtCreateGenericState ();
    if (!State)
    {
        return (NULL);
    }
 
    /* Init fields specific to the update struct */
 
    State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_UPDATE;
    State->Update.Object = Object;
    State->Update.Value = Action;
    return (State);
}

Referenced by AcpiUtCreateUpdateStateAndPush().

AcpiUtCreateUpdateStateAndPush()

ACPI_STATUS AcpiUtCreateUpdateStateAndPush	(	ACPI_OPERAND_OBJECT *	Object,
		UINT16	Action,
		ACPI_GENERIC_STATE **	StateList
	)

Definition at line 219 of file utmisc.c.

{
    ACPI_GENERIC_STATE       *State;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* 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);
}

Referenced by AcpiUtUpdateObjectReference().

AcpiUtDebugDumpBuffer()

void AcpiUtDebugDumpBuffer	(	UINT8 *	Buffer,
		UINT32	Count,
		UINT32	Display,
		UINT32	ComponentId
	)

Definition at line 219 of file utbuffer.c.

{
 
    /* Only dump the buffer if tracing is enabled */
 
    if (!((ACPI_LV_TABLES & AcpiDbgLevel) &&
        (ComponentId & AcpiDbgLayer)))
    {
        return;
    }
 
    AcpiUtDumpBuffer (Buffer, Count, Display, 0);
}

AcpiUtDeleteAddressLists()

void AcpiUtDeleteAddressLists

(

void

)

Definition at line 292 of file utaddress.c.

{
    ACPI_ADDRESS_RANGE      *Next;
    ACPI_ADDRESS_RANGE      *RangeInfo;
    int                     i;
 
 
    /* Delete all elements in all address range lists */
 
    for (i = 0; i < ACPI_ADDRESS_RANGE_MAX; i++)
    {
        Next = AcpiGbl_AddressRangeList[i];
 
        while (Next)
        {
            RangeInfo = Next;
            Next = RangeInfo->Next;
            ACPI_FREE (RangeInfo);
        }
 
        AcpiGbl_AddressRangeList[i] = NULL;
    }
}

Referenced by AcpiUtTerminate().

AcpiUtDeleteCaches()

ACPI_STATUS AcpiUtDeleteCaches

(

void

)

Definition at line 218 of file utalloc.c.

{
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
    char                    Buffer[7];
 
 
    if (AcpiGbl_DisplayFinalMemStats)
    {
        strcpy (Buffer, "MEMORY");
        (void) AcpiDbDisplayStatistics (Buffer);
    }
#endif
 
    (void) AcpiOsDeleteCache (AcpiGbl_NamespaceCache);
    AcpiGbl_NamespaceCache = NULL;
 
    (void) AcpiOsDeleteCache (AcpiGbl_StateCache);
    AcpiGbl_StateCache = NULL;
 
    (void) AcpiOsDeleteCache (AcpiGbl_OperandCache);
    AcpiGbl_OperandCache = NULL;
 
    (void) AcpiOsDeleteCache (AcpiGbl_PsNodeCache);
    AcpiGbl_PsNodeCache = NULL;
 
    (void) AcpiOsDeleteCache (AcpiGbl_PsNodeExtCache);
    AcpiGbl_PsNodeExtCache = NULL;
 
#ifdef ACPI_ASL_COMPILER
    (void) AcpiOsDeleteCache (AcpiGbl_RegCommentCache);
    AcpiGbl_RegCommentCache = NULL;
 
    (void) AcpiOsDeleteCache (AcpiGbl_CommentAddrCache);
    AcpiGbl_CommentAddrCache = NULL;
 
    (void) AcpiOsDeleteCache (AcpiGbl_FileCache);
    AcpiGbl_FileCache = NULL;
#endif
 
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
 
    /* Debug only - display leftover memory allocation, if any */
 
    AcpiUtDumpAllocations (ACPI_UINT32_MAX, NULL);
 
    /* Free memory lists */
 
    AcpiOsFree (AcpiGbl_GlobalList);
    AcpiGbl_GlobalList = NULL;
 
    AcpiOsFree (AcpiGbl_NsNodeList);
    AcpiGbl_NsNodeList = NULL;
#endif
 
    return (AE_OK);
}

Referenced by AcpiUtSubsystemShutdown().

AcpiUtDeleteGenericState()

void AcpiUtDeleteGenericState

(

ACPI_GENERIC_STATE *

State

)

Definition at line 340 of file utstate.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Ignore null state */
 
    if (State)
    {
        (void) AcpiOsReleaseObject (AcpiGbl_StateCache, State);
    }
 
    return;
}

Referenced by AcpiDsDeleteWalkState(), AcpiDsExecEndControlOp(), AcpiDsResultStackPop(), AcpiDsScopeStackClear(), AcpiDsScopeStackPop(), AcpiEvNotifyDispatch(), AcpiEvQueueNotifyRequest(), AcpiPsCleanupScope(), AcpiPsCompleteOp(), AcpiPsParseAml(), AcpiPsPopScope(), AcpiUtUpdateObjectReference(), and AcpiUtWalkPackageTree().

AcpiUtDeleteInternalObjectList()

void AcpiUtDeleteInternalObjectList

(

ACPI_OPERAND_OBJECT **

ObjList

)

Definition at line 384 of file utdelete.c.

{
    ACPI_OPERAND_OBJECT     **InternalObj;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Walk the null-terminated internal list */
 
    for (InternalObj = ObjList; *InternalObj; InternalObj++)
    {
        AcpiUtRemoveReference (*InternalObj);
    }
 
    /* Free the combined parameter pointer list and object array */
 
    ACPI_FREE (ObjList);
    return;
}

Referenced by AcpiEvaluateObject().

AcpiUtDeleteInternalPackageObject()

void AcpiUtDeleteInternalPackageObject

(

ACPI_OPERAND_OBJECT *

Object

)

AcpiUtDeleteInternalSimpleObject()

void AcpiUtDeleteInternalSimpleObject

(

ACPI_OPERAND_OBJECT *

Object

)

AcpiUtDeleteObjectDesc()

void AcpiUtDeleteObjectDesc

(

ACPI_OPERAND_OBJECT *

Object

)

Definition at line 473 of file utobject.c.

{
    ACPI_FUNCTION_TRACE_PTR (UtDeleteObjectDesc, Object);
 
 
    /* Object must be of type ACPI_OPERAND_OBJECT */
 
    if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
    {
        ACPI_ERROR ((AE_INFO,
            "%p is not an ACPI Operand object [%s]", Object,
            AcpiUtGetDescriptorName (Object)));
        return_VOID;
    }
 
    (void) AcpiOsReleaseObject (AcpiGbl_OperandCache, Object);
    return_VOID;
}

Referenced by AcpiDsBuildInternalBufferObj(), AcpiDsBuildInternalPackageObj(), AcpiDsCreateMethodMutex(), AcpiDsCreateOperand(), AcpiExPrepFieldValue(), AcpiUtCreateInternalObjectDbg(), and AcpiUtDeleteInternalObj().

AcpiUtDeleteRwLock()

void AcpiUtDeleteRwLock

(

ACPI_RW_LOCK *

Lock

)

Definition at line 85 of file utlock.c.

{
 
    AcpiOsDeleteMutex (Lock->ReaderMutex);
    AcpiOsDeleteMutex (Lock->WriterMutex);
 
    Lock->NumReaders = 0;
    Lock->ReaderMutex = NULL;
    Lock->WriterMutex = NULL;
}

Referenced by AcpiUtMutexTerminate().

AcpiUtDetectHexPrefix()

BOOLEAN AcpiUtDetectHexPrefix

(

char **

String

)

Definition at line 329 of file utstrsuppt.c.

{
    char                    *InitialPosition = *String;
 
    AcpiUtRemoveHexPrefix (String);
    if (*String != InitialPosition)
    {
        return (TRUE); /* String is past leading 0x */
    }
 
    return (FALSE);     /* Not a hex string */
}

Referenced by AcpiUtExplicitStrtoul64(), and AcpiUtStrtoul64().

AcpiUtDetectOctalPrefix()

BOOLEAN AcpiUtDetectOctalPrefix

(

char **

String

)

Definition at line 382 of file utstrsuppt.c.

{
 
    if (**String == ACPI_ASCII_ZERO)
    {
        *String += 1;       /* Go past the leading 0 */
        return (TRUE);
    }
 
    return (FALSE);     /* Not an octal string */
}

Referenced by AcpiUtStrtoul64().

AcpiUtDivide()

ACPI_STATUS AcpiUtDivide	(	UINT64	InDividend,
		UINT64	InDivisor,
		UINT64 *	OutQuotient,
		UINT64 *	OutRemainder
	)

Definition at line 402 of file utmath.c.

{
    UINT64_OVERLAY          Dividend;
    UINT64_OVERLAY          Divisor;
    UINT64_OVERLAY          Quotient;
    UINT64_OVERLAY          Remainder;
    UINT64_OVERLAY          NormalizedDividend;
    UINT64_OVERLAY          NormalizedDivisor;
    UINT32                  Partial1;
    UINT64_OVERLAY          Partial2;
    UINT64_OVERLAY          Partial3;
 
 
    ACPI_FUNCTION_TRACE (UtDivide);
 
 
    /* Always check for a zero divisor */
 
    if (InDivisor == 0)
    {
        ACPI_ERROR ((AE_INFO, "Divide by zero"));
        return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
    }
 
    Divisor.Full  = InDivisor;
    Dividend.Full = InDividend;
    if (Divisor.Part.Hi == 0)
    {
        /*
         * 1) Simplest case is where the divisor is 32 bits, we can
         * just do two divides
         */
        Remainder.Part.Hi = 0;
 
        /*
         * The quotient is 64 bits, the remainder is always 32 bits,
         * and is generated by the second divide.
         */
        ACPI_DIV_64_BY_32 (0, Dividend.Part.Hi, Divisor.Part.Lo,
            Quotient.Part.Hi, Partial1);
 
        ACPI_DIV_64_BY_32 (Partial1, Dividend.Part.Lo, Divisor.Part.Lo,
            Quotient.Part.Lo, Remainder.Part.Lo);
    }
 
    else
    {
        /*
         * 2) The general case where the divisor is a full 64 bits
         * is more difficult
         */
        Quotient.Part.Hi   = 0;
        NormalizedDividend = Dividend;
        NormalizedDivisor  = Divisor;
 
        /* Normalize the operands (shift until the divisor is < 32 bits) */
 
        do
        {
            ACPI_SHIFT_RIGHT_64 (
                NormalizedDivisor.Part.Hi, NormalizedDivisor.Part.Lo);
            ACPI_SHIFT_RIGHT_64 (
                NormalizedDividend.Part.Hi, NormalizedDividend.Part.Lo);
 
        } while (NormalizedDivisor.Part.Hi != 0);
 
        /* Partial divide */
 
        ACPI_DIV_64_BY_32 (
            NormalizedDividend.Part.Hi, NormalizedDividend.Part.Lo,
            NormalizedDivisor.Part.Lo, Quotient.Part.Lo, Partial1);
 
        /*
         * The quotient is always 32 bits, and simply requires
         * adjustment. The 64-bit remainder must be generated.
         */
        Partial1 = Quotient.Part.Lo * Divisor.Part.Hi;
        Partial2.Full = (UINT64) Quotient.Part.Lo * Divisor.Part.Lo;
        Partial3.Full = (UINT64) Partial2.Part.Hi + Partial1;
 
        Remainder.Part.Hi = Partial3.Part.Lo;
        Remainder.Part.Lo = Partial2.Part.Lo;
 
        if (Partial3.Part.Hi == 0)
        {
            if (Partial3.Part.Lo >= Dividend.Part.Hi)
            {
                if (Partial3.Part.Lo == Dividend.Part.Hi)
                {
                    if (Partial2.Part.Lo > Dividend.Part.Lo)
                    {
                        Quotient.Part.Lo--;
                        Remainder.Full -= Divisor.Full;
                    }
                }
                else
                {
                    Quotient.Part.Lo--;
                    Remainder.Full -= Divisor.Full;
                }
            }
 
            Remainder.Full = Remainder.Full - Dividend.Full;
            Remainder.Part.Hi = (UINT32) -((INT32) Remainder.Part.Hi);
            Remainder.Part.Lo = (UINT32) -((INT32) Remainder.Part.Lo);
 
            if (Remainder.Part.Lo)
            {
                Remainder.Part.Hi--;
            }
        }
    }
 
    /* Return only what was requested */
 
    if (OutQuotient)
    {
        *OutQuotient = Quotient.Full;
    }
    if (OutRemainder)
    {
        *OutRemainder = Remainder.Full;
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExOpcode_2A_1T_1R(), AcpiExOpcode_2A_2T_1R(), and AcpiUtPutNumber().

AcpiUtDumpBuffer()

void AcpiUtDumpBuffer	(	UINT8 *	Buffer,
		UINT32	Count,
		UINT32	Display,
		UINT32	Offset
	)

Definition at line 71 of file utbuffer.c.

{
    UINT32                  i = 0;
    UINT32                  j;
    UINT32                  Temp32;
    UINT8                   BufChar;
    UINT32                  DisplayDataOnly = Display & DB_DISPLAY_DATA_ONLY;
 
 
    Display &= ~DB_DISPLAY_DATA_ONLY;
    if (!Buffer)
    {
        AcpiOsPrintf ("Null Buffer Pointer in DumpBuffer!\n");
        return;
    }
 
    if ((Count < 4) || (Count & 0x01))
    {
        Display = DB_BYTE_DISPLAY;
    }
 
    /* Nasty little dump buffer routine! */
 
    while (i < Count)
    {
        /* Print current offset */
 
        if (!DisplayDataOnly)
        {
            AcpiOsPrintf ("%8.4X: ", (BaseOffset + i));
        }
 
        /* Print 16 hex chars */
 
        for (j = 0; j < 16;)
        {
            if (i + j >= Count)
            {
                /* Dump fill spaces */
 
                AcpiOsPrintf ("%*s", ((Display * 2) + 1), " ");
                j += Display;
                continue;
            }
 
            switch (Display)
            {
            case DB_BYTE_DISPLAY:
            default:    /* Default is BYTE display */
 
                AcpiOsPrintf ("%02X ", Buffer[(ACPI_SIZE) i + j]);
                break;
 
            case DB_WORD_DISPLAY:
 
                ACPI_MOVE_16_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
                AcpiOsPrintf ("%04X ", Temp32);
                break;
 
            case DB_DWORD_DISPLAY:
 
                ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
                AcpiOsPrintf ("%08X ", Temp32);
                break;
 
            case DB_QWORD_DISPLAY:
 
                ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
                AcpiOsPrintf ("%08X", Temp32);
 
                ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j + 4]);
                AcpiOsPrintf ("%08X ", Temp32);
                break;
            }
 
            j += Display;
        }
 
        /*
         * Print the ASCII equivalent characters but watch out for the bad
         * unprintable ones (printable chars are 0x20 through 0x7E)
         */
        if (!DisplayDataOnly)
        {
            AcpiOsPrintf (" ");
            for (j = 0; j < 16; j++)
            {
                if (i + j >= Count)
                {
                    AcpiOsPrintf ("\n");
                    return;
                }
 
                /*
                 * Add comment characters so rest of line is ignored when
                 * compiled
                 */
                if (j == 0)
                {
                    AcpiOsPrintf ("// ");
                }
 
                BufChar = Buffer[(ACPI_SIZE) i + j];
                if (isprint (BufChar))
                {
                    AcpiOsPrintf ("%c", BufChar);
                }
                else
                {
                    AcpiOsPrintf (".");
                }
            }
 
            /* Done with that line. */
 
            AcpiOsPrintf ("\n");
        }
        i += 16;
    }
 
    return;
}

Referenced by AcpiExDoDebugObject(), AcpiPsGetAmlOpcode(), and AcpiUtDebugDumpBuffer().

AcpiUtDwordByteSwap()

UINT32 AcpiUtDwordByteSwap

(

UINT32

Value

)

Definition at line 136 of file utmisc.c.

{
    union
    {
        UINT32              Value;
        UINT8               Bytes[4];
    } Out;
    union
    {
        UINT32              Value;
        UINT8               Bytes[4];
    } In;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    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);
}

Referenced by AcpiExEisaIdToString().

AcpiUtEvaluateNumericObject()

ACPI_STATUS AcpiUtEvaluateNumericObject	(	const char *	ObjectName,
		ACPI_NAMESPACE_NODE *	DeviceNode,
		UINT64 *	Value
	)

Definition at line 221 of file uteval.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (UtEvaluateNumericObject);
 
 
    Status = AcpiUtEvaluateObject (DeviceNode, ObjectName,
        ACPI_BTYPE_INTEGER, &ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Get the returned Integer */
 
    *Value = ObjDesc->Integer.Value;
 
    /* On exit, we must delete the return object */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvPciConfigRegionSetup(), AcpiGetObjectInfo(), and AcpiHwGetPciDeviceInfo().

AcpiUtEvaluateObject()

ACPI_STATUS AcpiUtEvaluateObject	(	ACPI_NAMESPACE_NODE *	PrefixNode,
		const char *	Path,
		UINT32	ExpectedReturnBtypes,
		ACPI_OPERAND_OBJECT **	ReturnDesc
	)

Definition at line 73 of file uteval.c.

{
    ACPI_EVALUATE_INFO      *Info;
    ACPI_STATUS             Status;
    UINT32                  ReturnBtype;
 
 
    ACPI_FUNCTION_TRACE (UtEvaluateObject);
 
 
    /* Allocate the evaluation information block */
 
    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
    if (!Info)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    Info->PrefixNode = PrefixNode;
    Info->RelativePathname = Path;
 
    /* Evaluate the object/method */
 
    Status = AcpiNsEvaluate (Info);
    if (ACPI_FAILURE (Status))
    {
        if (Status == AE_NOT_FOUND)
        {
            ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s.%s] was not found\n",
                AcpiUtGetNodeName (PrefixNode), Path));
        }
        else
        {
            ACPI_ERROR_METHOD ("Method execution failed",
                PrefixNode, Path, Status);
        }
 
        goto Cleanup;
    }
 
    /* Did we get a return object? */
 
    if (!Info->ReturnObject)
    {
        if (ExpectedReturnBtypes)
        {
            ACPI_ERROR_METHOD ("No object was returned from",
                PrefixNode, Path, AE_NOT_EXIST);
 
            Status = AE_NOT_EXIST;
        }
 
        goto Cleanup;
    }
 
    /* Map the return object type to the bitmapped type */
 
    switch ((Info->ReturnObject)->Common.Type)
    {
    case ACPI_TYPE_INTEGER:
 
        ReturnBtype = ACPI_BTYPE_INTEGER;
        break;
 
    case ACPI_TYPE_BUFFER:
 
        ReturnBtype = ACPI_BTYPE_BUFFER;
        break;
 
    case ACPI_TYPE_STRING:
 
        ReturnBtype = ACPI_BTYPE_STRING;
        break;
 
    case ACPI_TYPE_PACKAGE:
 
        ReturnBtype = ACPI_BTYPE_PACKAGE;
        break;
 
    default:
 
        ReturnBtype = 0;
        break;
    }
 
    if ((AcpiGbl_EnableInterpreterSlack) &&
        (!ExpectedReturnBtypes))
    {
        /*
         * We received a return object, but one was not expected. This can
         * happen frequently if the "implicit return" feature is enabled.
         * Just delete the return object and return AE_OK.
         */
        AcpiUtRemoveReference (Info->ReturnObject);
        goto Cleanup;
    }
 
    /* Is the return object one of the expected types? */
 
    if (!(ExpectedReturnBtypes & ReturnBtype))
    {
        ACPI_ERROR_METHOD ("Return object type is incorrect",
            PrefixNode, Path, AE_TYPE);
 
        ACPI_ERROR ((AE_INFO,
            "Type returned from %s was incorrect: %s, expected Btypes: 0x%X",
            Path, AcpiUtGetObjectTypeName (Info->ReturnObject),
            ExpectedReturnBtypes));
 
        /* On error exit, we must delete the return object */
 
        AcpiUtRemoveReference (Info->ReturnObject);
        Status = AE_TYPE;
        goto Cleanup;
    }
 
    /* Object type is OK, return it */
 
    *ReturnDesc = Info->ReturnObject;
 
Cleanup:
    ACPI_FREE (Info);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiRsGetAeiMethodData(), AcpiRsGetCrsMethodData(), AcpiRsGetMethodData(), AcpiRsGetPrsMethodData(), AcpiRsGetPrtMethodData(), AcpiUtEvaluateNumericObject(), AcpiUtExecute_CID(), AcpiUtExecute_CLS(), AcpiUtExecute_HID(), AcpiUtExecute_STA(), AcpiUtExecute_UID(), and AcpiUtExecutePowerMethods().

AcpiUtExecute_CID()

ACPI_STATUS AcpiUtExecute_CID	(	ACPI_NAMESPACE_NODE *	DeviceNode,
		ACPI_PNP_DEVICE_ID_LIST **	ReturnCidList
	)

Definition at line 253 of file utids.c.

{
    ACPI_OPERAND_OBJECT     **CidObjects;
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_PNP_DEVICE_ID_LIST *CidList;
    char                    *NextIdString;
    UINT32                  StringAreaSize;
    UINT32                  Length;
    UINT32                  CidListSize;
    ACPI_STATUS             Status;
    UINT32                  Count;
    UINT32                  i;
 
 
    ACPI_FUNCTION_TRACE (UtExecute_CID);
 
 
    /* Evaluate the _CID method for this device */
 
    Status = AcpiUtEvaluateObject (DeviceNode, METHOD_NAME__CID,
        ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING | ACPI_BTYPE_PACKAGE,
        &ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Get the count and size of the returned _CIDs. _CID can return either
     * a Package of Integers/Strings or a single Integer or String.
     * Note: This section also validates that all CID elements are of the
     * correct type (Integer or String).
     */
    if (ObjDesc->Common.Type == ACPI_TYPE_PACKAGE)
    {
        Count = ObjDesc->Package.Count;
        CidObjects = ObjDesc->Package.Elements;
    }
    else /* Single Integer or String CID */
    {
        Count = 1;
        CidObjects = &ObjDesc;
    }
 
    StringAreaSize = 0;
    for (i = 0; i < Count; i++)
    {
        /* String lengths include null terminator */
 
        switch (CidObjects[i]->Common.Type)
        {
        case ACPI_TYPE_INTEGER:
 
            StringAreaSize += ACPI_EISAID_STRING_SIZE;
            break;
 
        case ACPI_TYPE_STRING:
 
            StringAreaSize += CidObjects[i]->String.Length + 1;
            break;
 
        default:
 
            Status = AE_TYPE;
            goto Cleanup;
        }
    }
 
    /*
     * Now that we know the length of the CIDs, allocate return buffer:
     * 1) Size of the base structure +
     * 2) Size of the CID PNP_DEVICE_ID array +
     * 3) Size of the actual CID strings
     */
    CidListSize = sizeof (ACPI_PNP_DEVICE_ID_LIST) +
        (Count * sizeof (ACPI_PNP_DEVICE_ID)) +
        StringAreaSize;
 
    CidList = ACPI_ALLOCATE_ZEROED (CidListSize);
    if (!CidList)
    {
        Status = AE_NO_MEMORY;
        goto Cleanup;
    }
 
    /* Area for CID strings starts after the CID PNP_DEVICE_ID array */
 
    NextIdString = ACPI_CAST_PTR (char, CidList->Ids) +
        ((ACPI_SIZE) Count * sizeof (ACPI_PNP_DEVICE_ID));
 
    /* Copy/convert the CIDs to the return buffer */
 
    for (i = 0; i < Count; i++)
    {
        if (CidObjects[i]->Common.Type == ACPI_TYPE_INTEGER)
        {
            /* Convert the Integer (EISAID) CID to a string */
 
            AcpiExEisaIdToString (
                NextIdString, CidObjects[i]->Integer.Value);
            Length = ACPI_EISAID_STRING_SIZE;
        }
        else /* ACPI_TYPE_STRING */
        {
            /* Copy the String CID from the returned object */
 
            strcpy (NextIdString, CidObjects[i]->String.Pointer);
            Length = CidObjects[i]->String.Length + 1;
        }
 
        CidList->Ids[i].String = NextIdString;
        CidList->Ids[i].Length = Length;
        NextIdString += Length;
    }
 
    /* Finish the CID list */
 
    CidList->Count = Count;
    CidList->ListSize = CidListSize;
    *ReturnCidList = CidList;
 
 
Cleanup:
 
    /* On exit, we must delete the _CID return object */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvIsPciRootBridge(), AcpiGetObjectInfo(), and AcpiNsGetDeviceCallback().

AcpiUtExecute_CLS()

ACPI_STATUS AcpiUtExecute_CLS	(	ACPI_NAMESPACE_NODE *	DeviceNode,
		ACPI_PNP_DEVICE_ID **	ReturnId
	)

Definition at line 406 of file utids.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_OPERAND_OBJECT     **ClsObjects;
    UINT32                  Count;
    ACPI_PNP_DEVICE_ID      *Cls;
    UINT32                  Length;
    ACPI_STATUS             Status;
    UINT8                   ClassCode[3] = {0, 0, 0};
 
 
    ACPI_FUNCTION_TRACE (UtExecute_CLS);
 
 
    Status = AcpiUtEvaluateObject (DeviceNode, METHOD_NAME__CLS,
        ACPI_BTYPE_PACKAGE, &ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Get the size of the String to be returned, includes null terminator */
 
    Length = ACPI_PCICLS_STRING_SIZE;
    ClsObjects = ObjDesc->Package.Elements;
    Count = ObjDesc->Package.Count;
 
    if (ObjDesc->Common.Type == ACPI_TYPE_PACKAGE)
    {
        if (Count > 0 && ClsObjects[0]->Common.Type == ACPI_TYPE_INTEGER)
        {
            ClassCode[0] = (UINT8) ClsObjects[0]->Integer.Value;
        }
        if (Count > 1 && ClsObjects[1]->Common.Type == ACPI_TYPE_INTEGER)
        {
            ClassCode[1] = (UINT8) ClsObjects[1]->Integer.Value;
        }
        if (Count > 2 && ClsObjects[2]->Common.Type == ACPI_TYPE_INTEGER)
        {
            ClassCode[2] = (UINT8) ClsObjects[2]->Integer.Value;
        }
    }
 
    /* Allocate a buffer for the CLS */
 
    Cls = ACPI_ALLOCATE_ZEROED (
        sizeof (ACPI_PNP_DEVICE_ID) + (ACPI_SIZE) Length);
    if (!Cls)
    {
        Status = AE_NO_MEMORY;
        goto Cleanup;
    }
 
    /* Area for the string starts after PNP_DEVICE_ID struct */
 
    Cls->String = ACPI_ADD_PTR (char, Cls, sizeof (ACPI_PNP_DEVICE_ID));
 
    /* Simply copy existing string */
 
    AcpiExPciClsToString (Cls->String, ClassCode);
    Cls->Length = Length;
    *ReturnId = Cls;
 
 
Cleanup:
 
    /* On exit, we must delete the return object */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiGetObjectInfo().

AcpiUtExecute_HID()

ACPI_STATUS AcpiUtExecute_HID	(	ACPI_NAMESPACE_NODE *	DeviceNode,
		ACPI_PNP_DEVICE_ID **	ReturnId
	)

Definition at line 72 of file utids.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_PNP_DEVICE_ID      *Hid;
    UINT32                  Length;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (UtExecute_HID);
 
 
    Status = AcpiUtEvaluateObject (DeviceNode, METHOD_NAME__HID,
        ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING, &ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Get the size of the String to be returned, includes null terminator */
 
    if (ObjDesc->Common.Type == ACPI_TYPE_INTEGER)
    {
        Length = ACPI_EISAID_STRING_SIZE;
    }
    else
    {
        Length = ObjDesc->String.Length + 1;
    }
 
    /* Allocate a buffer for the HID */
 
    Hid = ACPI_ALLOCATE_ZEROED (
        sizeof (ACPI_PNP_DEVICE_ID) + (ACPI_SIZE) Length);
    if (!Hid)
    {
        Status = AE_NO_MEMORY;
        goto Cleanup;
    }
 
    /* Area for the string starts after PNP_DEVICE_ID struct */
 
    Hid->String = ACPI_ADD_PTR (char, Hid, sizeof (ACPI_PNP_DEVICE_ID));
 
    /* Convert EISAID to a string or simply copy existing string */
 
    if (ObjDesc->Common.Type == ACPI_TYPE_INTEGER)
    {
        AcpiExEisaIdToString (Hid->String, ObjDesc->Integer.Value);
    }
    else
    {
        strcpy (Hid->String, ObjDesc->String.Pointer);
    }
 
    Hid->Length = Length;
    *ReturnId = Hid;
 
 
Cleanup:
 
    /* On exit, we must delete the return object */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvIsPciRootBridge(), AcpiGetObjectInfo(), and AcpiNsGetDeviceCallback().

AcpiUtExecute_STA()

ACPI_STATUS AcpiUtExecute_STA	(	ACPI_NAMESPACE_NODE *	DeviceNode,
		UINT32 *	StatusFlags
	)

Definition at line 269 of file uteval.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (UtExecute_STA);
 
 
    Status = AcpiUtEvaluateObject (DeviceNode, METHOD_NAME__STA,
        ACPI_BTYPE_INTEGER, &ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        if (AE_NOT_FOUND == Status)
        {
            /*
             * if _STA does not exist, then (as per the ACPI specification),
             * the returned flags will indicate that the device is present,
             * functional, and enabled.
             */
            ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
                "_STA on %4.4s was not found, assuming device is present\n",
                AcpiUtGetNodeName (DeviceNode)));
 
            *Flags = ACPI_UINT32_MAX;
            Status = AE_OK;
        }
 
        return_ACPI_STATUS (Status);
    }
 
    /* Extract the status flags */
 
    *Flags = (UINT32) ObjDesc->Integer.Value;
 
    /* On exit, we must delete the return object */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiNsGetDeviceCallback(), and AcpiNsInitOneDevice().

AcpiUtExecute_UID()

ACPI_STATUS AcpiUtExecute_UID	(	ACPI_NAMESPACE_NODE *	DeviceNode,
		ACPI_PNP_DEVICE_ID **	ReturnId
	)

Definition at line 160 of file utids.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_PNP_DEVICE_ID      *Uid;
    UINT32                  Length;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (UtExecute_UID);
 
 
    Status = AcpiUtEvaluateObject (DeviceNode, METHOD_NAME__UID,
        ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING, &ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Get the size of the String to be returned, includes null terminator */
 
    if (ObjDesc->Common.Type == ACPI_TYPE_INTEGER)
    {
        Length = ACPI_MAX64_DECIMAL_DIGITS + 1;
    }
    else
    {
        Length = ObjDesc->String.Length + 1;
    }
 
    /* Allocate a buffer for the UID */
 
    Uid = ACPI_ALLOCATE_ZEROED (
        sizeof (ACPI_PNP_DEVICE_ID) + (ACPI_SIZE) Length);
    if (!Uid)
    {
        Status = AE_NO_MEMORY;
        goto Cleanup;
    }
 
    /* Area for the string starts after PNP_DEVICE_ID struct */
 
    Uid->String = ACPI_ADD_PTR (char, Uid, sizeof (ACPI_PNP_DEVICE_ID));
 
    /* Convert an Integer to string, or just copy an existing string */
 
    if (ObjDesc->Common.Type == ACPI_TYPE_INTEGER)
    {
        AcpiExIntegerToString (Uid->String, ObjDesc->Integer.Value);
    }
    else
    {
        strcpy (Uid->String, ObjDesc->String.Pointer);
    }
 
    Uid->Length = Length;
    *ReturnId = Uid;
 
 
Cleanup:
 
    /* On exit, we must delete the return object */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiGetObjectInfo().

AcpiUtExecutePowerMethods()

ACPI_STATUS AcpiUtExecutePowerMethods	(	ACPI_NAMESPACE_NODE *	DeviceNode,
		const char **	MethodNames,
		UINT8	MethodCount,
		UINT8 *	OutValues
	)

Definition at line 332 of file uteval.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status;
    ACPI_STATUS             FinalStatus = AE_NOT_FOUND;
    UINT32                  i;
 
 
    ACPI_FUNCTION_TRACE (UtExecutePowerMethods);
 
 
    for (i = 0; i < MethodCount; i++)
    {
        /*
         * Execute the power method (_SxD or _SxW). The only allowable
         * return type is an Integer.
         */
        Status = AcpiUtEvaluateObject (DeviceNode,
            ACPI_CAST_PTR (char, MethodNames[i]),
            ACPI_BTYPE_INTEGER, &ObjDesc);
        if (ACPI_SUCCESS (Status))
        {
            OutValues[i] = (UINT8) ObjDesc->Integer.Value;
 
            /* Delete the return object */
 
            AcpiUtRemoveReference (ObjDesc);
            FinalStatus = AE_OK;            /* At least one value is valid */
            continue;
        }
 
        OutValues[i] = ACPI_UINT8_MAX;
        if (Status == AE_NOT_FOUND)
        {
            continue; /* Ignore if not found */
        }
 
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Failed %s on Device %4.4s, %s\n",
            ACPI_CAST_PTR (char, MethodNames[i]),
            AcpiUtGetNodeName (DeviceNode), AcpiFormatException (Status)));
    }
 
    return_ACPI_STATUS (FinalStatus);
}

Referenced by AcpiGetObjectInfo().

AcpiUtExit()

void AcpiUtExit	(	UINT32	LineNumber,
		const char *	FunctionName,
		const char *	ModuleName,
		UINT32	ComponentId
	)

AcpiUtExplicitStrtoul64()

UINT64 AcpiUtExplicitStrtoul64

(

char *

String

)

Definition at line 347 of file utstrtoul64.c.

{
    UINT64                  ConvertedInteger = 0;
    UINT32                  Base = 10;          /* Default is decimal */
 
 
    ACPI_FUNCTION_TRACE_STR (UtExplicitStrtoul64, String);
 
 
    if (!AcpiUtRemoveWhitespace (&String))
    {
        return_VALUE (0);
    }
 
    /*
     * Only Hex and Decimal are supported, as per the ACPI specification.
     * A "0x" prefix indicates hex; otherwise decimal is assumed.
     */
    if (AcpiUtDetectHexPrefix (&String))
    {
        Base = 16;
    }
 
    if (!AcpiUtRemoveLeadingZeros (&String))
    {
        return_VALUE (0);
    }
 
    /*
     * Ignore overflow as per the ACPI specification. This is implemented by
     * ignoring the return status from the conversion functions called below.
     * On overflow, the input string is simply truncated.
     */
    switch (Base)
    {
    case 10:
    default:
        AcpiUtConvertDecimalString (String, &ConvertedInteger);
        break;
 
    case 16:
        AcpiUtConvertHexString (String, &ConvertedInteger);
        break;
    }
 
    return_VALUE (ConvertedInteger);
}

Referenced by AcpiExConvertToInteger().

AcpiUtGenerateChecksum()

UINT8 AcpiUtGenerateChecksum	(	void *	Table,
		UINT32	Length,
		UINT8	OriginalChecksum
	)

Definition at line 176 of file utcksum.c.

{
    UINT8                   Checksum;
 
 
    /* Sum the entire table as-is */
 
    Checksum = AcpiUtChecksum ((UINT8 *) Table, Length);
 
    /* Subtract off the existing checksum value in the table */
 
    Checksum = (UINT8) (Checksum - OriginalChecksum);
 
    /* Compute and return the final checksum */
 
    Checksum = (UINT8) (0 - Checksum);
    return (Checksum);
}

Referenced by AcpiUtVerifyCdatChecksum(), and AcpiUtVerifyChecksum().

AcpiUtGetArgumentTypeName()

const char * AcpiUtGetArgumentTypeName

(

UINT32

ArgType

)

Referenced by AcpiPsGetNextArg().

AcpiUtGetDescriptorLength()

UINT32 AcpiUtGetDescriptorLength

(

void *

Aml

)

Definition at line 606 of file utresrc.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    /*
     * Get the Resource Length (does not include header length) and add
     * the header length (depends on if this is a small or large resource)
     */
    return (AcpiUtGetResourceLength (Aml) +
        AcpiUtGetResourceHeaderLength (Aml));
}

Referenced by AcpiRsConvertResourcesToAml(), AcpiRsGetListLength(), and AcpiUtWalkAmlResources().

AcpiUtGetDescriptorName()

const char * AcpiUtGetDescriptorName

(

void *

Object

)

Definition at line 382 of file utdecode.c.

{
 
    if (!Object)
    {
        return ("NULL OBJECT");
    }
 
    if (ACPI_GET_DESCRIPTOR_TYPE (Object) > ACPI_DESC_TYPE_MAX)
    {
        return ("Not a Descriptor");
    }
 
    return (AcpiGbl_DescTypeNames[ACPI_GET_DESCRIPTOR_TYPE (Object)]);
}

Referenced by AcpiDsInitBufferField(), AcpiExResolveMultiple(), AcpiExResolveOperands(), AcpiNsAttachObject(), AcpiNsLookup(), AcpiUtDeleteObjectDesc(), AcpiUtGetObjectTypeName(), and AcpiUtValidInternalObject().

AcpiUtGetEventName()

const char * AcpiUtGetEventName

(

UINT32

EventId

)

Definition at line 175 of file utdecode.c.

{
 
    if (EventId > ACPI_EVENT_MAX)
    {
        return ("InvalidEventID");
    }
 
    return (AcpiGbl_EventTypes[EventId]);
}

Referenced by AcpiDisableEvent(), AcpiEnableEvent(), AcpiEvFixedEventDispatch(), AcpiInstallFixedEventHandler(), and AcpiRemoveFixedEventHandler().

AcpiUtGetExpectedReturnTypes()

void AcpiUtGetExpectedReturnTypes	(	char *	Buffer,
		UINT32	ExpectedBtypes
	)

Definition at line 158 of file utpredef.c.

{
    UINT32                  ThisRtype;
    UINT32                  i;
    UINT32                  j;
 
 
    if (!ExpectedBtypes)
    {
        strcpy (Buffer, "NONE");
        return;
    }
 
    j = 1;
    Buffer[0] = 0;
    ThisRtype = ACPI_RTYPE_INTEGER;
 
    for (i = 0; i < ACPI_NUM_RTYPES; i++)
    {
        /* If one of the expected types, concatenate the name of this type */
 
        if (ExpectedBtypes & ThisRtype)
        {
            strcat (Buffer, &UtRtypeNames[i][j]);
            j = 0;              /* Use name separator from now on */
        }
 
        ThisRtype <<= 1;    /* Next Rtype */
    }
}

Referenced by AcpiNsCheckObjectType().

AcpiUtGetInterface()

ACPI_INTERFACE_INFO * AcpiUtGetInterface

(

ACPI_STRING

InterfaceName

)

Definition at line 425 of file utosi.c.

{
    ACPI_INTERFACE_INFO     *NextInterface;
 
 
    NextInterface = AcpiGbl_SupportedInterfaces;
    while (NextInterface)
    {
        if (!strcmp (InterfaceName, NextInterface->Name))
        {
            return (NextInterface);
        }
 
        NextInterface = NextInterface->Next;
    }
 
    return (NULL);
}

Referenced by AcpiInstallInterface(), and AcpiUtOsiImplementation().

AcpiUtGetMutexName()

const char * AcpiUtGetMutexName

(

UINT32

MutexId

)

Definition at line 479 of file utdecode.c.

{
 
    if (MutexId > ACPI_MAX_MUTEX)
    {
        return ("Invalid Mutex ID");
    }
 
    return (AcpiGbl_MutexNames[MutexId]);
}

Referenced by AcpiUtAcquireMutex(), and AcpiUtReleaseMutex().

AcpiUtGetNextPredefinedMethod()

const ACPI_PREDEFINED_INFO * AcpiUtGetNextPredefinedMethod

(

const ACPI_PREDEFINED_INFO *

ThisName

)

Definition at line 82 of file utpredef.c.

{
 
    /*
     * Skip next entry in the table if this name returns a Package
     * (next entry contains the package info)
     */
    if ((ThisName->Info.ExpectedBtypes & ACPI_RTYPE_PACKAGE) &&
        (ThisName->Info.ExpectedBtypes != ACPI_RTYPE_ALL))
    {
        ThisName++;
    }
 
    ThisName++;
    return (ThisName);
}

Referenced by AcpiUtMatchPredefinedMethod().

AcpiUtGetNodeName()

const char * AcpiUtGetNodeName

(

void *

Object

)

Definition at line 306 of file utdecode.c.

{
    ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) Object;
 
 
    /* Must return a string of exactly 4 characters == ACPI_NAMESEG_SIZE */
 
    if (!Object)
    {
        return ("NULL");
    }
 
    /* Check for Root node */
 
    if ((Object == ACPI_ROOT_OBJECT) ||
        (Object == AcpiGbl_RootNode))
    {
        return ("\"\\\" ");
    }
 
    /* Descriptor must be a namespace node */
 
    if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
    {
        return ("####");
    }
 
    /*
     * Ensure name is valid. The name was validated/repaired when the node
     * was created, but make sure it has not been corrupted.
     */
    AcpiUtRepairName (Node->Name.Ascii);
 
    /* Return the name */
 
    return (Node->Name.Ascii);
}

Referenced by AcpiDsAutoSerializeMethod(), AcpiDsBeginMethodExecution(), AcpiDsGetBankFieldArguments(), AcpiDsGetBufferFieldArguments(), AcpiDsGetRegionArguments(), AcpiDsInitBufferField(), AcpiDsInitOneObject(), AcpiDsLoad1BeginOp(), AcpiDsLoad2BeginOp(), AcpiDsRestartControlMethod(), AcpiDsScopeStackPop(), AcpiDsScopeStackPush(), AcpiEvAddressSpaceDispatch(), AcpiEvAsynchExecuteGpeMethod(), AcpiEvAttachRegion(), AcpiEvInstallSpaceHandler(), AcpiEvPciConfigRegionSetup(), AcpiEvQueueNotifyRequest(), AcpiExAcquireMutex(), AcpiExPrepFieldValue(), AcpiExReleaseMutex(), AcpiExResolveMultiple(), AcpiExSetupRegion(), AcpiNsAttachObject(), AcpiNsDetachObject(), AcpiNsHandleToName(), AcpiNsInitOneObject(), AcpiNsInstallNode(), AcpiNsLookup(), AcpiNsSearchOneScope(), AcpiNsSearchParentTree(), AcpiUtAddAddressRange(), AcpiUtEvaluateObject(), AcpiUtExecute_STA(), AcpiUtExecutePowerMethods(), and AcpiUtRemoveAddressRange().

AcpiUtGetObjectSize()

ACPI_STATUS AcpiUtGetObjectSize	(	ACPI_OPERAND_OBJECT *	Obj,
		ACPI_SIZE *	ObjLength
	)

Definition at line 762 of file utobject.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    if ((ACPI_GET_DESCRIPTOR_TYPE (InternalObject) ==
            ACPI_DESC_TYPE_OPERAND) &&
        (InternalObject->Common.Type == ACPI_TYPE_PACKAGE))
    {
        Status = AcpiUtGetPackageObjectSize (InternalObject, ObjLength);
    }
    else
    {
        Status = AcpiUtGetSimpleObjectSize (InternalObject, ObjLength);
    }
 
    return (Status);
}

Referenced by AcpiEvaluateObject().

AcpiUtGetObjectTypeName()

const char * AcpiUtGetObjectTypeName

(

ACPI_OPERAND_OBJECT *

ObjDesc

)

Definition at line 264 of file utdecode.c.

{
    ACPI_FUNCTION_TRACE (UtGetObjectTypeName);
 
 
    if (!ObjDesc)
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Null Object Descriptor\n"));
        return_STR ("[NULL Object Descriptor]");
    }
 
    /* These descriptor types share a common area */
 
    if ((ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND) &&
        (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_NAMED))
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "Invalid object descriptor type: 0x%2.2X [%s] (%p)\n",
            ACPI_GET_DESCRIPTOR_TYPE (ObjDesc),
            AcpiUtGetDescriptorName (ObjDesc), ObjDesc));
 
        return_STR ("Invalid object");
    }
 
    return_STR (AcpiUtGetTypeName (ObjDesc->Common.Type));
}

Referenced by AcpiDsInitBufferField(), AcpiDsObjStackPush(), AcpiDsResultPop(), AcpiDsResultPush(), AcpiExConvertToTargetType(), AcpiExDoDebugObject(), AcpiExGetObjectReference(), AcpiExResolveNodeToValue(), AcpiExResolveObject(), AcpiExResolveOperands(), AcpiExSetupRegion(), AcpiExStore(), AcpiExStoreDirectToNode(), AcpiExStoreObjectToIndex(), AcpiExStoreObjectToNode(), AcpiExStoreObjectToObject(), AcpiExWriteSerialBus(), AcpiNsCheckObjectType(), AcpiNsEvaluate(), AcpiNsRepairNullElement(), AcpiNsSimpleRepair(), AcpiNsWrapWithPackage(), AcpiRsCreatePciRoutingTable(), AcpiUtDeleteInternalObj(), AcpiUtEvaluateObject(), AcpiUtGetSimpleObjectSize(), and AcpiUtUpdateRefCount().

AcpiUtGetReferenceName()

const char * AcpiUtGetReferenceName

(

ACPI_OPERAND_OBJECT *

Object

)

Definition at line 426 of file utdecode.c.

{
 
    if (!Object)
    {
        return ("NULL Object");
    }
 
    if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
    {
        return ("Not an Operand object");
    }
 
    if (Object->Common.Type != ACPI_TYPE_LOCAL_REFERENCE)
    {
        return ("Not a Reference object");
    }
 
    if (Object->Reference.Class > ACPI_REFCLASS_MAX)
    {
        return ("Unknown Reference class");
    }
 
    return (AcpiGbl_RefClassNames[Object->Reference.Class]);
}

Referenced by AcpiExDoDebugObject(), AcpiExResolveOperands(), AcpiNsCheckReference(), and AcpiUtGetSimpleObjectSize().

AcpiUtGetRegionName()

const char * AcpiUtGetRegionName

(

UINT8

SpaceId

)

Definition at line 125 of file utdecode.c.

{
 
    if (SpaceId >= ACPI_USER_REGION_BEGIN)
    {
        return ("UserDefinedRegion");
    }
    else if (SpaceId == ACPI_ADR_SPACE_DATA_TABLE)
    {
        return ("DataTable");
    }
    else if (SpaceId == ACPI_ADR_SPACE_FIXED_HARDWARE)
    {
        return ("FunctionalFixedHW");
    }
    else if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS)
    {
        return ("InvalidSpaceId");
    }
 
    return (AcpiGbl_RegionTypes[SpaceId]);
}

Referenced by AcpiEvAddressSpaceDispatch(), AcpiEvAttachRegion(), AcpiEvDetachRegion(), AcpiEvExecuteRegMethods(), AcpiEvInitializeRegion(), AcpiEvInstallHandler(), AcpiEvInstallSpaceHandler(), AcpiExAccessRegion(), AcpiExCreateRegion(), AcpiHwRead(), AcpiHwWrite(), AcpiRemoveAddressSpaceHandler(), and AcpiUtCheckAddressRange().

AcpiUtGetResourceEndTag()

ACPI_STATUS AcpiUtGetResourceEndTag	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		UINT8 **	EndTag
	)

Definition at line 636 of file utresrc.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (UtGetResourceEndTag);
 
 
    /* Allow a buffer length of zero */
 
    if (!ObjDesc->Buffer.Length)
    {
        *EndTag = ObjDesc->Buffer.Pointer;
        return_ACPI_STATUS (AE_OK);
    }
 
    /* Validate the template and get a pointer to the EndTag */
 
    Status = AcpiUtWalkAmlResources (NULL, ObjDesc->Buffer.Pointer,
        ObjDesc->Buffer.Length, NULL, (void **) EndTag);
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExConcatTemplate().

AcpiUtGetResourceHeaderLength()

UINT8 AcpiUtGetResourceHeaderLength

(

void *

Aml

)

Definition at line 572 of file utresrc.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Examine the large/small bit in the resource header */
 
    if (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_LARGE)
    {
        return (sizeof (AML_RESOURCE_LARGE_HEADER));
    }
    else
    {
        return (sizeof (AML_RESOURCE_SMALL_HEADER));
    }
}

Referenced by AcpiRsGetListLength(), AcpiRsSetResourceLength(), and AcpiUtGetDescriptorLength().

AcpiUtGetResourceLength()

UINT16 AcpiUtGetResourceLength

(

void *

Aml

)

Definition at line 527 of file utresrc.c.

{
    ACPI_RS_LENGTH          ResourceLength;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /*
     * Byte 0 contains the descriptor name (Resource Type)
     * Examine the large/small bit in the resource header
     */
    if (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_LARGE)
    {
        /* Large Resource type -- bytes 1-2 contain the 16-bit length */
 
        ACPI_MOVE_16_TO_16 (&ResourceLength, ACPI_ADD_PTR (UINT8, Aml, 1));
 
    }
    else
    {
        /* Small Resource type -- bits 2:0 of byte 0 contain the length */
 
        ResourceLength = (UINT16) (ACPI_GET8 (Aml) &
            ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK);
    }
 
    return (ResourceLength);
}

Referenced by AcpiRsConvertAmlToResource(), AcpiRsGetListLength(), AcpiUtGetDescriptorLength(), and AcpiUtValidateResource().

AcpiUtGetResourceType()

UINT8 AcpiUtGetResourceType

(

void *

Aml

)

Definition at line 487 of file utresrc.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    /*
     * Byte 0 contains the descriptor name (Resource Type)
     * Examine the large/small bit in the resource header
     */
    if (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_LARGE)
    {
        /* Large Resource Type -- bits 6:0 contain the name */
 
        return (ACPI_GET8 (Aml));
    }
    else
    {
        /* Small Resource Type -- bits 6:3 contain the name */
 
        return ((UINT8) (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_SMALL_MASK));
    }
}

Referenced by AcpiRsConvertAmlToResources(), AcpiRsGetListLength(), and AcpiUtWalkAmlResources().

AcpiUtGetTypeName()

const char * AcpiUtGetTypeName

(

ACPI_OBJECT_TYPE

Type

)

Definition at line 250 of file utdecode.c.

{
 
    if (Type > ACPI_TYPE_INVALID)
    {
        return (AcpiGbl_BadType);
    }
 
    return (AcpiGbl_NsTypeNames[Type]);
}

Referenced by AcpiDsExecBeginOp(), AcpiDsLoad1BeginOp(), AcpiDsLoad1EndOp(), AcpiDsLoad2BeginOp(), AcpiDsLoad2EndOp(), AcpiDsMethodDataSetValue(), AcpiDsScopeStackClear(), AcpiDsScopeStackPop(), AcpiDsScopeStackPush(), AcpiEvaluateObjectTyped(), AcpiEvQueueNotifyRequest(), AcpiExCheckObjectType(), AcpiExConvertToObjectTypeString(), AcpiExConvertToTargetType(), AcpiExDoDebugObject(), AcpiExOpcode_1A_0T_1R(), AcpiExOpcode_2A_0T_0R(), AcpiExPrepFieldValue(), AcpiExResolveNodeToValue(), AcpiExResolveObject(), AcpiExStoreDirectToNode(), AcpiExStoreObjectToNode(), AcpiExWriteDataToField(), AcpiExWriteGpio(), AcpiNsCheckAcpiCompliance(), AcpiNsCheckArgumentCount(), AcpiNsCheckArgumentTypes(), AcpiNsCheckObjectType(), AcpiNsEvaluate(), AcpiNsInitOneObject(), AcpiNsInstallNode(), AcpiNsLookup(), AcpiNsSearchOneScope(), AcpiNsSearchParentTree(), AcpiUtCopyEsimpleToIsimple(), AcpiUtCopyIsimpleToEsimple(), AcpiUtCreateInternalObjectDbg(), and AcpiUtGetObjectTypeName().

AcpiUtHardwareInitialize()

ACPI_STATUS AcpiUtHardwareInitialize

(

void

)

AcpiUtHexToAsciiChar()

char AcpiUtHexToAsciiChar	(	UINT64	Integer,
		UINT32	Position
	)

Definition at line 74 of file uthex.c.

{
    UINT64                  Index;
 
    AcpiUtShortShiftRight (Integer, Position, &Index);
    return (AcpiGbl_HexToAscii[Index & 0xF]);
}

Referenced by AcpiExConvertToAscii(), AcpiExEisaIdToString(), and AcpiExPciClsToString().

AcpiUtImplicitStrtoul64()

UINT64 AcpiUtImplicitStrtoul64

(

char *

String

)

Definition at line 259 of file utstrtoul64.c.

{
    UINT64                  ConvertedInteger = 0;
 
 
    ACPI_FUNCTION_TRACE_STR (UtImplicitStrtoul64, String);
 
 
    if (!AcpiUtRemoveWhitespace (&String))
    {
        return_VALUE (0);
    }
 
    /*
     * Per the ACPI specification, only hexadecimal is supported for
     * implicit conversions, and the "0x" prefix is "not allowed".
     * However, allow a "0x" prefix as an ACPI extension.
     */
    AcpiUtRemoveHexPrefix (&String);
 
    if (!AcpiUtRemoveLeadingZeros (&String))
    {
        return_VALUE (0);
    }
 
    /*
     * Ignore overflow as per the ACPI specification. This is implemented by
     * ignoring the return status from the conversion function called below.
     * On overflow, the input string is simply truncated.
     */
    AcpiUtConvertHexString (String, &ConvertedInteger);
    return_VALUE (ConvertedInteger);
}

Referenced by AcpiExConvertToInteger().

AcpiUtInitGlobals()

ACPI_STATUS AcpiUtInitGlobals

(

void

)

Definition at line 131 of file utinit.c.

{
    ACPI_STATUS             Status;
    UINT32                  i;
 
 
    ACPI_FUNCTION_TRACE (UtInitGlobals);
 
 
    /* Create all memory caches */
 
    Status = AcpiUtCreateCaches ();
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Address Range lists */
 
    for (i = 0; i < ACPI_ADDRESS_RANGE_MAX; i++)
    {
        AcpiGbl_AddressRangeList[i] = NULL;
    }
 
    /* Mutex locked flags */
 
    for (i = 0; i < ACPI_NUM_MUTEX; i++)
    {
        AcpiGbl_MutexInfo[i].Mutex          = NULL;
        AcpiGbl_MutexInfo[i].ThreadId       = ACPI_MUTEX_NOT_ACQUIRED;
        AcpiGbl_MutexInfo[i].UseCount       = 0;
    }
 
    for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++)
    {
        AcpiGbl_OwnerIdMask[i]              = 0;
    }
 
    /* Last OwnerID is never valid */
 
    AcpiGbl_OwnerIdMask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000;
 
    /* Event counters */
 
    AcpiMethodCount                     = 0;
    AcpiSciCount                        = 0;
    AcpiGpeCount                        = 0;
 
    for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++)
    {
        AcpiFixedEventCount[i]              = 0;
    }
 
#if (!ACPI_REDUCED_HARDWARE)
 
    /* GPE/SCI support */
 
    AcpiGbl_AllGpesInitialized          = FALSE;
    AcpiGbl_GpeXruptListHead            = NULL;
    AcpiGbl_GpeFadtBlocks[0]            = NULL;
    AcpiGbl_GpeFadtBlocks[1]            = NULL;
    AcpiCurrentGpeCount                 = 0;
 
    AcpiGbl_GlobalEventHandler          = NULL;
    AcpiGbl_SciHandlerList              = NULL;
 
#endif /* !ACPI_REDUCED_HARDWARE */
 
    /* Global handlers */
 
    AcpiGbl_GlobalNotify[0].Handler     = NULL;
    AcpiGbl_GlobalNotify[1].Handler     = NULL;
    AcpiGbl_ExceptionHandler            = NULL;
    AcpiGbl_InitHandler                 = NULL;
    AcpiGbl_TableHandler                = NULL;
    AcpiGbl_InterfaceHandler            = NULL;
 
    /* Global Lock support */
 
    AcpiGbl_GlobalLockSemaphore         = NULL;
    AcpiGbl_GlobalLockMutex             = NULL;
    AcpiGbl_GlobalLockAcquired          = FALSE;
    AcpiGbl_GlobalLockHandle            = 0;
    AcpiGbl_GlobalLockPresent           = FALSE;
 
    /* Miscellaneous variables */
 
    AcpiGbl_DSDT                        = NULL;
    AcpiGbl_CmSingleStep                = FALSE;
    AcpiGbl_Shutdown                    = FALSE;
    AcpiGbl_NsLookupCount               = 0;
    AcpiGbl_PsFindCount                 = 0;
    AcpiGbl_AcpiHardwarePresent         = TRUE;
    AcpiGbl_LastOwnerIdIndex            = 0;
    AcpiGbl_NextOwnerIdOffset           = 0;
    AcpiGbl_DebuggerConfiguration       = DEBUGGER_THREADING;
    AcpiGbl_OsiMutex                    = NULL;
 
    /* Hardware oriented */
 
    AcpiGbl_EventsInitialized           = FALSE;
    AcpiGbl_SystemAwakeAndRunning       = TRUE;
 
    /* Namespace */
 
    AcpiGbl_RootNode                    = NULL;
    AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME;
    AcpiGbl_RootNodeStruct.DescriptorType = ACPI_DESC_TYPE_NAMED;
    AcpiGbl_RootNodeStruct.Type         = ACPI_TYPE_DEVICE;
    AcpiGbl_RootNodeStruct.Parent       = NULL;
    AcpiGbl_RootNodeStruct.Child        = NULL;
    AcpiGbl_RootNodeStruct.Peer         = NULL;
    AcpiGbl_RootNodeStruct.Object       = NULL;
 
 
#ifdef ACPI_DISASSEMBLER
    AcpiGbl_ExternalList                = NULL;
    AcpiGbl_NumExternalMethods          = 0;
    AcpiGbl_ResolvedExternalMethods     = 0;
#endif
 
#ifdef ACPI_DEBUG_OUTPUT
    AcpiGbl_LowestStackPointer          = ACPI_CAST_PTR (ACPI_SIZE, ACPI_SIZE_MAX);
#endif
 
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
    AcpiGbl_DisplayFinalMemStats        = FALSE;
    AcpiGbl_DisableMemTracking          = FALSE;
#endif
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiInitializeSubsystem().

AcpiUtInitializeBuffer()

ACPI_STATUS AcpiUtInitializeBuffer	(	ACPI_BUFFER *	Buffer,
		ACPI_SIZE	RequiredLength
	)

Definition at line 336 of file utalloc.c.

{
    ACPI_SIZE               InputBufferLength;
 
 
    /* Parameter validation */
 
    if (!Buffer || !RequiredLength)
    {
        return (AE_BAD_PARAMETER);
    }
 
    /*
     * Buffer->Length is used as both an input and output parameter. Get the
     * input actual length and set the output required buffer length.
     */
    InputBufferLength = Buffer->Length;
    Buffer->Length = RequiredLength;
 
    /*
     * The input buffer length contains the actual buffer length, or the type
     * of buffer to be allocated by this routine.
     */
    switch (InputBufferLength)
    {
    case ACPI_NO_BUFFER:
 
        /* Return the exception (and the required buffer length) */
 
        return (AE_BUFFER_OVERFLOW);
 
    case ACPI_ALLOCATE_BUFFER:
        /*
         * Allocate a new buffer. We directectly call AcpiOsAllocate here to
         * purposefully bypass the (optionally enabled) internal allocation
         * tracking mechanism since we only want to track internal
         * allocations. Note: The caller should use AcpiOsFree to free this
         * buffer created via ACPI_ALLOCATE_BUFFER.
         */
        Buffer->Pointer = AcpiOsAllocate (RequiredLength);
        break;
 
    case ACPI_ALLOCATE_LOCAL_BUFFER:
 
        /* Allocate a new buffer with local interface to allow tracking */
 
        Buffer->Pointer = ACPI_ALLOCATE (RequiredLength);
        break;
 
    default:
 
        /* Existing buffer: Validate the size of the buffer */
 
        if (InputBufferLength < RequiredLength)
        {
            return (AE_BUFFER_OVERFLOW);
        }
        break;
    }
 
    /* Validate allocation from above or input buffer pointer */
 
    if (!Buffer->Pointer)
    {
        return (AE_NO_MEMORY);
    }
 
    /* Have a valid buffer, clear it */
 
    memset (Buffer->Pointer, 0, RequiredLength);
    return (AE_OK);
}

Referenced by AcpiEvaluateObject(), AcpiGetSystemInfo(), AcpiNsHandleToName(), AcpiNsHandleToPathname(), AcpiRsCreateAmlResources(), AcpiRsCreatePciRoutingTable(), AcpiRsCreateResourceList(), and AcpiRsMatchVendorResource().

AcpiUtInitializeInterfaces()

ACPI_STATUS AcpiUtInitializeInterfaces

(

void

)

Definition at line 150 of file utosi.c.

{
    ACPI_STATUS             Status;
    UINT32                  i;
 
 
    Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    AcpiGbl_SupportedInterfaces = AcpiDefaultSupportedInterfaces;
 
    /* Link the static list of supported interfaces */
 
    for (i = 0;
        i < (ACPI_ARRAY_LENGTH (AcpiDefaultSupportedInterfaces) - 1);
        i++)
    {
        AcpiDefaultSupportedInterfaces[i].Next =
            &AcpiDefaultSupportedInterfaces[(ACPI_SIZE) i + 1];
    }
 
    AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
    return (AE_OK);
}

Referenced by AcpiInitializeSubsystem().

AcpiUtInitStackPtrTrace()

void AcpiUtInitStackPtrTrace

(

void

)

Referenced by AcpiInitializeSubsystem().

AcpiUtInstallInterface()

ACPI_STATUS AcpiUtInstallInterface

(

ACPI_STRING

InterfaceName

)

Definition at line 255 of file utosi.c.

{
    ACPI_INTERFACE_INFO     *InterfaceInfo;
 
 
    /* Allocate info block and space for the name string */
 
    InterfaceInfo = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_INTERFACE_INFO));
    if (!InterfaceInfo)
    {
        return (AE_NO_MEMORY);
    }
 
    InterfaceInfo->Name = ACPI_ALLOCATE_ZEROED (strlen (InterfaceName) + 1);
    if (!InterfaceInfo->Name)
    {
        ACPI_FREE (InterfaceInfo);
        return (AE_NO_MEMORY);
    }
 
    /* Initialize new info and insert at the head of the global list */
 
    strcpy (InterfaceInfo->Name, InterfaceName);
    InterfaceInfo->Flags = ACPI_OSI_DYNAMIC;
    InterfaceInfo->Next = AcpiGbl_SupportedInterfaces;
 
    AcpiGbl_SupportedInterfaces = InterfaceInfo;
    return (AE_OK);
}

Referenced by AcpiInstallInterface().

AcpiUtInterfaceTerminate()

ACPI_STATUS AcpiUtInterfaceTerminate

(

void

)

Definition at line 194 of file utosi.c.

{
    ACPI_STATUS             Status;
    ACPI_INTERFACE_INFO     *NextInterface;
 
 
    Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    NextInterface = AcpiGbl_SupportedInterfaces;
    while (NextInterface)
    {
        AcpiGbl_SupportedInterfaces = NextInterface->Next;
 
        if (NextInterface->Flags & ACPI_OSI_DYNAMIC)
        {
            /* Only interfaces added at runtime can be freed */
 
            ACPI_FREE (NextInterface->Name);
            ACPI_FREE (NextInterface);
        }
        else
        {
            /* Interface is in static list. Reset it to invalid or valid. */
 
            if (NextInterface->Flags & ACPI_OSI_DEFAULT_INVALID)
            {
                NextInterface->Flags |= ACPI_OSI_INVALID;
            }
            else
            {
                NextInterface->Flags &= ~ACPI_OSI_INVALID;
            }
        }
 
        NextInterface = AcpiGbl_SupportedInterfaces;
    }
 
    AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
    return (AE_OK);
}

Referenced by AcpiUtSubsystemShutdown().

AcpiUtIsPciRootBridge()

BOOLEAN AcpiUtIsPciRootBridge

(

char *

Id

)

Definition at line 66 of file utmisc.c.

{
 
    /*
     * Check if this is a PCI root bridge.
     * ACPI 3.0+: check for a PCI Express root also.
     */
    if (!(strcmp (Id,
        PCI_ROOT_HID_STRING)) ||
 
        !(strcmp (Id,
        PCI_EXPRESS_ROOT_HID_STRING)))
    {
        return (TRUE);
    }
 
    return (FALSE);
}

Referenced by AcpiEvIsPciRootBridge(), and AcpiGetObjectInfo().

AcpiUtMatchPredefinedMethod()

const ACPI_PREDEFINED_INFO * AcpiUtMatchPredefinedMethod

(

char *

Name

)

Definition at line 114 of file utpredef.c.

{
    const ACPI_PREDEFINED_INFO  *ThisName;
 
 
    /* Quick check for a predefined name, first character must be underscore */
 
    if (Name[0] != '_')
    {
        return (NULL);
    }
 
    /* Search info table for a predefined method/object name */
 
    ThisName = AcpiGbl_PredefinedMethods;
    while (ThisName->Info.Name[0])
    {
        if (ACPI_COMPARE_NAMESEG (Name, ThisName->Info.Name))
        {
            return (ThisName);
        }
 
        ThisName = AcpiUtGetNextPredefinedMethod (ThisName);
    }
 
    return (NULL); /* Not found */
}

Referenced by AcpiNsEvaluate().

AcpiUtMethodError()

void AcpiUtMethodError	(	const char *	ModuleName,
		UINT32	LineNumber,
		const char *	Message,
		ACPI_NAMESPACE_NODE *	Node,
		const char *	Path,
		ACPI_STATUS	LookupStatus
	)

Definition at line 369 of file uterror.c.

{
    ACPI_STATUS             Status;
    ACPI_NAMESPACE_NODE     *Node = PrefixNode;
 
 
    ACPI_MSG_REDIRECT_BEGIN;
    AcpiOsPrintf (ACPI_MSG_ERROR);
 
    if (Path)
    {
        Status = AcpiNsGetNode (PrefixNode, Path,
            ACPI_NS_NO_UPSEARCH, &Node);
        if (ACPI_FAILURE (Status))
        {
            AcpiOsPrintf ("[Could not get node by pathname]");
        }
    }
 
    AcpiNsPrintNodePathname (Node, Message);
    AcpiOsPrintf (" due to previous error (%s)",
        AcpiFormatException (MethodStatus));
 
    ACPI_MSG_SUFFIX;
    ACPI_MSG_REDIRECT_END;
}

AcpiUtMutexInitialize()

ACPI_STATUS AcpiUtMutexInitialize

(

void

)

Definition at line 75 of file utmutex.c.

{
    UINT32                  i;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (UtMutexInitialize);
 
 
    /* Create each of the predefined mutex objects */
 
    for (i = 0; i < ACPI_NUM_MUTEX; i++)
    {
        Status = AcpiUtCreateMutex (i);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
    }
 
    /* Create the spinlocks for use at interrupt level or for speed */
 
    Status = AcpiOsCreateLock (&AcpiGbl_GpeLock);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Status = AcpiOsCreateLock (&AcpiGbl_HardwareLock);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Status = AcpiOsCreateLock (&AcpiGbl_ReferenceCountLock);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Mutex for _OSI support */
 
    Status = AcpiOsCreateMutex (&AcpiGbl_OsiMutex);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Create the reader/writer lock for namespace access */
 
    Status = AcpiUtCreateRwLock (&AcpiGbl_NamespaceRwLock);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiInitializeSubsystem().

AcpiUtMutexTerminate()

void AcpiUtMutexTerminate

(

void

)

Definition at line 150 of file utmutex.c.

{
    UINT32                  i;
 
 
    ACPI_FUNCTION_TRACE (UtMutexTerminate);
 
 
    /* Delete each predefined mutex object */
 
    for (i = 0; i < ACPI_NUM_MUTEX; i++)
    {
        AcpiUtDeleteMutex (i);
    }
 
    AcpiOsDeleteMutex (AcpiGbl_OsiMutex);
 
    /* Delete the spinlocks */
 
    AcpiOsDeleteLock (AcpiGbl_GpeLock);
    AcpiOsDeleteLock (AcpiGbl_HardwareLock);
    AcpiOsDeleteLock (AcpiGbl_ReferenceCountLock);
 
    /* Delete the reader/writer lock */
 
    AcpiUtDeleteRwLock (&AcpiGbl_NamespaceRwLock);
    return_VOID;
}

Referenced by AcpiTerminate().

AcpiUtOsiImplementation()

ACPI_STATUS AcpiUtOsiImplementation

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 472 of file utosi.c.

{
    ACPI_OPERAND_OBJECT     *StringDesc;
    ACPI_OPERAND_OBJECT     *ReturnDesc;
    ACPI_INTERFACE_INFO     *InterfaceInfo;
    ACPI_INTERFACE_HANDLER  InterfaceHandler;
    ACPI_STATUS             Status;
    UINT64                  ReturnValue;
 
 
    ACPI_FUNCTION_TRACE (UtOsiImplementation);
 
 
    /* Validate the string input argument (from the AML caller) */
 
    StringDesc = WalkState->Arguments[0].Object;
    if (!StringDesc ||
        (StringDesc->Common.Type != ACPI_TYPE_STRING))
    {
        return_ACPI_STATUS (AE_TYPE);
    }
 
    /* Create a return object */
 
    ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
    if (!ReturnDesc)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /* Default return value is 0, NOT SUPPORTED */
 
    ReturnValue = 0;
    Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
    if (ACPI_FAILURE (Status))
    {
        AcpiUtRemoveReference (ReturnDesc);
        return_ACPI_STATUS (Status);
    }
 
    /* Lookup the interface in the global _OSI list */
 
    InterfaceInfo = AcpiUtGetInterface (StringDesc->String.Pointer);
    if (InterfaceInfo &&
        !(InterfaceInfo->Flags & ACPI_OSI_INVALID))
    {
        /*
         * The interface is supported.
         * Update the OsiData if necessary. We keep track of the latest
         * version of Windows that has been requested by the BIOS.
         */
        if (InterfaceInfo->Value > AcpiGbl_OsiData)
        {
            AcpiGbl_OsiData = InterfaceInfo->Value;
        }
 
        ReturnValue = ACPI_UINT64_MAX;
    }
 
    AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 
    /*
     * Invoke an optional _OSI interface handler. The host OS may wish
     * to do some interface-specific handling. For example, warn about
     * certain interfaces or override the true/false support value.
     */
    InterfaceHandler = AcpiGbl_InterfaceHandler;
    if (InterfaceHandler)
    {
        if (InterfaceHandler (
            StringDesc->String.Pointer, (UINT32) ReturnValue))
        {
            ReturnValue = ACPI_UINT64_MAX;
        }
    }
 
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO,
        "ACPI: BIOS _OSI(\"%s\") is %ssupported\n",
        StringDesc->String.Pointer, ReturnValue == 0 ? "not " : ""));
 
    /* Complete the return object */
 
    ReturnDesc->Integer.Value = ReturnValue;
    WalkState->ReturnDesc = ReturnDesc;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiNsRootInitialize().

AcpiUtPopGenericState()

ACPI_GENERIC_STATE * AcpiUtPopGenericState

(

ACPI_GENERIC_STATE **

ListHead

)

Definition at line 93 of file utstate.c.

{
    ACPI_GENERIC_STATE      *State;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Remove the state object at the head of the list (stack) */
 
    State = *ListHead;
    if (State)
    {
        /* Update the list head */
 
        *ListHead = State->Common.Next;
    }
 
    return (State);
}

Referenced by AcpiDsExecEndControlOp(), AcpiDsResultStackPop(), AcpiDsScopeStackPop(), AcpiPsCleanupScope(), AcpiPsCompleteOp(), AcpiPsParseLoop(), AcpiPsPopScope(), AcpiUtUpdateObjectReference(), and AcpiUtWalkPackageTree().

AcpiUtPredefinedBiosError()

void ACPI_INTERNAL_VAR_XFACE AcpiUtPredefinedBiosError	(	const char *	ModuleName,
		UINT32	LineNumber,
		char *	Pathname,
		UINT16	NodeFlags,
		const char *	Format,
			...
	)

Definition at line 177 of file uterror.c.

{
    va_list                 ArgList;
 
 
    /*
     * Warning messages for this method/object will be disabled after the
     * first time a validation fails or an object is successfully repaired.
     */
    if (NodeFlags & ANOBJ_EVALUATED)
    {
        return;
    }
 
    AcpiOsPrintf (ACPI_MSG_BIOS_ERROR "%s: ", Pathname);
 
    va_start (ArgList, Format);
    AcpiOsVprintf (Format, ArgList);
    ACPI_MSG_SUFFIX;
    va_end (ArgList);
}

AcpiUtPredefinedInfo()

void ACPI_INTERNAL_VAR_XFACE AcpiUtPredefinedInfo	(	const char *	ModuleName,
		UINT32	LineNumber,
		char *	Pathname,
		UINT16	NodeFlags,
		const char *	Format,
			...
	)

Definition at line 128 of file uterror.c.

{
    va_list                 ArgList;
 
 
    /*
     * Warning messages for this method/object will be disabled after the
     * first time a validation fails or an object is successfully repaired.
     */
    if (NodeFlags & ANOBJ_EVALUATED)
    {
        return;
    }
 
    AcpiOsPrintf (ACPI_MSG_INFO "%s: ", Pathname);
 
    va_start (ArgList, Format);
    AcpiOsVprintf (Format, ArgList);
    ACPI_MSG_SUFFIX;
    va_end (ArgList);
}

AcpiUtPredefinedWarning()

void ACPI_INTERNAL_VAR_XFACE AcpiUtPredefinedWarning	(	const char *	ModuleName,
		UINT32	LineNumber,
		char *	Pathname,
		UINT16	NodeFlags,
		const char *	Format,
			...
	)

Definition at line 79 of file uterror.c.

{
    va_list                 ArgList;
 
 
    /*
     * Warning messages for this method/object will be disabled after the
     * first time a validation fails or an object is successfully repaired.
     */
    if (NodeFlags & ANOBJ_EVALUATED)
    {
        return;
    }
 
    AcpiOsPrintf (ACPI_MSG_WARNING "%s: ", Pathname);
 
    va_start (ArgList, Format);
    AcpiOsVprintf (Format, ArgList);
    ACPI_MSG_SUFFIX;
    va_end (ArgList);
}

AcpiUtPrefixedNamespaceError()

void AcpiUtPrefixedNamespaceError	(	const char *	ModuleName,
		UINT32	LineNumber,
		ACPI_GENERIC_STATE *	PrefixScope,
		const char *	InternalName,
		ACPI_STATUS	LookupStatus
	)

Definition at line 227 of file uterror.c.

{
    char                    *FullPath;
    const char              *Message;
 
 
    /*
     * Main cases:
     * 1) Object creation, object must not already exist
     * 2) Object lookup, object must exist
     */
    switch (LookupStatus)
    {
    case AE_ALREADY_EXISTS:
 
        AcpiOsPrintf (ACPI_MSG_BIOS_ERROR);
        Message = "Failure creating named object";
        break;
 
    case AE_NOT_FOUND:
 
        AcpiOsPrintf (ACPI_MSG_BIOS_ERROR);
        Message = "Could not resolve symbol";
        break;
 
    default:
 
        AcpiOsPrintf (ACPI_MSG_ERROR);
        Message = "Failure resolving symbol";
        break;
    }
 
    /* Concatenate the prefix path and the internal path */
 
    FullPath = AcpiNsBuildPrefixedPathname (PrefixScope, InternalPath);
 
    AcpiOsPrintf ("%s [%s], %s", Message,
        FullPath ? FullPath : "Could not get pathname",
        AcpiFormatException (LookupStatus));
 
    if (FullPath)
    {
        ACPI_FREE (FullPath);
    }
 
    ACPI_MSG_SUFFIX;
}

AcpiUtPrintString()

void AcpiUtPrintString	(	char *	String,
		UINT16	MaxLength
	)

Definition at line 69 of file utstring.c.

{
    UINT32                  i;
 
 
    if (!String)
    {
        AcpiOsPrintf ("<\"NULL STRING PTR\">");
        return;
    }
 
    AcpiOsPrintf ("\"");
    for (i = 0; (i < MaxLength) && String[i]; i++)
    {
        /* Escape sequences */
 
        switch (String[i])
        {
        case 0x07:
 
            AcpiOsPrintf ("\\a");       /* BELL */
            break;
 
        case 0x08:
 
            AcpiOsPrintf ("\\b");       /* BACKSPACE */
            break;
 
        case 0x0C:
 
            AcpiOsPrintf ("\\f");       /* FORMFEED */
            break;
 
        case 0x0A:
 
            AcpiOsPrintf ("\\n");       /* LINEFEED */
            break;
 
        case 0x0D:
 
            AcpiOsPrintf ("\\r");       /* CARRIAGE RETURN*/
            break;
 
        case 0x09:
 
            AcpiOsPrintf ("\\t");       /* HORIZONTAL TAB */
            break;
 
        case 0x0B:
 
            AcpiOsPrintf ("\\v");       /* VERTICAL TAB */
            break;
 
        case '\'':                      /* Single Quote */
        case '\"':                      /* Double Quote */
        case '\\':                      /* Backslash */
 
            AcpiOsPrintf ("\\%c", (int) String[i]);
            break;
 
        default:
 
            /* Check for printable character or hex escape */
 
            if (isprint ((int) String[i]))
            {
                /* This is a normal character */
 
                AcpiOsPrintf ("%c", (int) String[i]);
            }
            else
            {
                /* All others will be Hex escapes */
 
                AcpiOsPrintf ("\\x%2.2X", (INT32) String[i]);
            }
            break;
        }
    }
 
    AcpiOsPrintf ("\"");
 
    if (i == MaxLength && String[i])
    {
        AcpiOsPrintf ("...");
    }
}

AcpiUtPtrExit()

void AcpiUtPtrExit	(	UINT32	LineNumber,
		const char *	FunctionName,
		const char *	ModuleName,
		UINT32	ComponentId,
		UINT8 *	Ptr
	)

AcpiUtPushGenericState()

void AcpiUtPushGenericState	(	ACPI_GENERIC_STATE **	ListHead,
		ACPI_GENERIC_STATE *	State
	)

Definition at line 65 of file utstate.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Push the state object onto the front of the list (stack) */
 
    State->Common.Next = *ListHead;
    *ListHead = State;
    return;
}

Referenced by AcpiDsExecBeginControlOp(), AcpiDsResultStackPush(), AcpiDsScopeStackPush(), AcpiPsPushScope(), AcpiUtCreateUpdateStateAndPush(), and AcpiUtWalkPackageTree().

AcpiUtReleaseMutex()

ACPI_STATUS AcpiUtReleaseMutex

(

ACPI_MUTEX_HANDLE

MutexId

)

Definition at line 348 of file utmutex.c.

{
    ACPI_FUNCTION_NAME (UtReleaseMutex);
 
 
    ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n",
        (UINT32) AcpiOsGetThreadId (), AcpiUtGetMutexName (MutexId)));
 
    if (MutexId > ACPI_MAX_MUTEX)
    {
        return (AE_BAD_PARAMETER);
    }
 
    /*
     * Mutex must be acquired in order to release it!
     */
    if (AcpiGbl_MutexInfo[MutexId].ThreadId == ACPI_MUTEX_NOT_ACQUIRED)
    {
        ACPI_ERROR ((AE_INFO,
            "Mutex [%s] (0x%X) is not acquired, cannot release",
            AcpiUtGetMutexName (MutexId), MutexId));
 
        return (AE_NOT_ACQUIRED);
    }
 
#ifdef ACPI_MUTEX_DEBUG
    {
        UINT32                  i;
        /*
         * Mutex debug code, for internal debugging only.
         *
         * 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 < ACPI_NUM_MUTEX; i++)
        {
            if (AcpiGbl_MutexInfo[i].ThreadId == AcpiOsGetThreadId ())
            {
                if (i == MutexId)
                {
                    continue;
                }
 
                ACPI_ERROR ((AE_INFO,
                    "Invalid release order: owns [%s], releasing [%s]",
                    AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId)));
 
                return (AE_RELEASE_DEADLOCK);
            }
        }
    }
#endif
 
    /* Mark unlocked FIRST */
 
    AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED;
 
    AcpiOsReleaseMutex (AcpiGbl_MutexInfo[MutexId].Mutex);
    return (AE_OK);
}

Referenced by AcpiAnyGpeStatusSet(), AcpiAttachData(), AcpiCheckAddressRange(), AcpiDebugTrace(), AcpiDetachData(), AcpiDisableAllGpes(), AcpiEnableAllRuntimeGpes(), AcpiEnableAllWakeupGpes(), AcpiEvDeleteGpeBlock(), AcpiEvDetachRegion(), AcpiEvExecuteOrphanRegMethod(), AcpiEvGpeInitialize(), AcpiEvInitializeOpRegions(), AcpiEvInstallGpeBlock(), AcpiEvInstallGpeHandler(), AcpiEvInstallRegionHandlers(), AcpiEvUpdateGpes(), AcpiExExitInterpreter(), AcpiGetData(), AcpiGetDevices(), AcpiGetName(), AcpiGetNextObject(), AcpiGetObjectInfo(), AcpiGetParent(), AcpiGetTable(), AcpiGetTableByIndex(), AcpiGetType(), AcpiInstallAddressSpaceHandler(), AcpiInstallExceptionHandler(), AcpiInstallFixedEventHandler(), AcpiInstallGlobalEventHandler(), AcpiInstallGpeBlock(), AcpiInstallMethod(), AcpiInstallNotifyHandler(), AcpiInstallSciHandler(), AcpiInstallTableHandler(), AcpiNsDeleteNamespaceByOwner(), AcpiNsDeleteNamespaceSubtree(), AcpiNsGetDeviceCallback(), AcpiNsGetNode(), AcpiNsRootInitialize(), AcpiNsTerminate(), AcpiNsWalkNamespace(), AcpiPutTable(), AcpiReallocateRootTable(), AcpiRemoveAddressSpaceHandler(), AcpiRemoveFixedEventHandler(), AcpiRemoveGpeBlock(), AcpiRemoveGpeHandler(), AcpiRemoveNotifyHandler(), AcpiRemoveSciHandler(), AcpiRemoveTableHandler(), AcpiTbAllocateOwnerId(), AcpiTbDeleteNamespaceByOwner(), AcpiTbFindTable(), AcpiTbGetOwnerId(), AcpiTbInstallStandardTable(), AcpiTbIsTableLoaded(), AcpiTbLoadNamespace(), AcpiTbReleaseOwnerId(), AcpiTbSetTableLoadedFlag(), AcpiTbTerminate(), AcpiUnloadParentTable(), AcpiUpdateAllGpes(), AcpiUtAllocateOwnerId(), AcpiUtReleaseOwnerId(), and AcpiWalkNamespace().

AcpiUtReleaseOwnerId()

void AcpiUtReleaseOwnerId

(

ACPI_OWNER_ID *

OwnerId

)

Definition at line 190 of file utownerid.c.

{
    ACPI_OWNER_ID           OwnerId = *OwnerIdPtr;
    ACPI_STATUS             Status;
    UINT32                  Index;
    UINT32                  Bit;
 
 
    ACPI_FUNCTION_TRACE_U32 (UtReleaseOwnerId, OwnerId);
 
 
    /* Always clear the input OwnerId (zero is an invalid ID) */
 
    *OwnerIdPtr = 0;
 
    /* Zero is not a valid OwnerID */
 
    if (OwnerId == 0)
    {
        ACPI_ERROR ((AE_INFO, "Invalid OwnerId: 0x%3.3X", OwnerId));
        return_VOID;
    }
 
    /* Mutex for the global ID mask */
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES);
    if (ACPI_FAILURE (Status))
    {
        return_VOID;
    }
 
    /* Normalize the ID to zero */
 
    OwnerId--;
 
    /* Decode ID to index/offset pair */
 
    Index = ACPI_DIV_32 (OwnerId);
    Bit = (UINT32) 1 << ACPI_MOD_32 (OwnerId);
 
    /* Free the owner ID only if it is valid */
 
    if (AcpiGbl_OwnerIdMask[Index] & Bit)
    {
        AcpiGbl_OwnerIdMask[Index] ^= Bit;
    }
    else
    {
        ACPI_ERROR ((AE_INFO,
            "Attempted release of non-allocated OwnerId: 0x%3.3X", OwnerId + 1));
    }
 
    (void) AcpiUtReleaseMutex (ACPI_MTX_CACHES);
    return_VOID;
}

Referenced by AcpiDsTerminateControlMethod(), and AcpiTbReleaseOwnerId().

AcpiUtReleaseReadLock()

ACPI_STATUS AcpiUtReleaseReadLock

(

ACPI_RW_LOCK *

Lock

)

Definition at line 143 of file utlock.c.

{
    ACPI_STATUS             Status;
 
 
    Status = AcpiOsAcquireMutex (Lock->ReaderMutex, ACPI_WAIT_FOREVER);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    /* Release the write lock only for the very last reader */
 
    Lock->NumReaders--;
    if (Lock->NumReaders == 0)
    {
        AcpiOsReleaseMutex (Lock->WriterMutex);
    }
 
    AcpiOsReleaseMutex (Lock->ReaderMutex);
    return (Status);
}

Referenced by AcpiWalkNamespace().

AcpiUtReleaseWriteLock()

void AcpiUtReleaseWriteLock

(

ACPI_RW_LOCK *

Lock

)

Definition at line 197 of file utlock.c.

{
 
    AcpiOsReleaseMutex (Lock->WriterMutex);
}

Referenced by AcpiTbDeleteNamespaceByOwner().

AcpiUtRemoveAddressRange()

void AcpiUtRemoveAddressRange	(	ACPI_ADR_SPACE_TYPE	SpaceId,
		ACPI_NAMESPACE_NODE *	RegionNode
	)

Definition at line 139 of file utaddress.c.

{
    ACPI_ADDRESS_RANGE      *RangeInfo;
    ACPI_ADDRESS_RANGE      *Prev;
 
 
    ACPI_FUNCTION_TRACE (UtRemoveAddressRange);
 
 
    if ((SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
        (SpaceId != ACPI_ADR_SPACE_SYSTEM_IO))
    {
        return_VOID;
    }
 
    /* Get the appropriate list head and check the list */
 
    RangeInfo = Prev = AcpiGbl_AddressRangeList[SpaceId];
    while (RangeInfo)
    {
        if (RangeInfo->RegionNode == RegionNode)
        {
            if (RangeInfo == Prev) /* Found at list head */
            {
                AcpiGbl_AddressRangeList[SpaceId] = RangeInfo->Next;
            }
            else
            {
                Prev->Next = RangeInfo->Next;
            }
 
            ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
                "\nRemoved [%4.4s] address range: 0x%8.8X%8.8X-0x%8.8X%8.8X\n",
                AcpiUtGetNodeName (RangeInfo->RegionNode),
                ACPI_FORMAT_UINT64 (RangeInfo->StartAddress),
                ACPI_FORMAT_UINT64 (RangeInfo->EndAddress)));
 
            ACPI_FREE (RangeInfo);
            return_VOID;
        }
 
        Prev = RangeInfo;
        RangeInfo = RangeInfo->Next;
    }
 
    return_VOID;
}

Referenced by AcpiNsDetachObject(), and AcpiUtDeleteInternalObj().

AcpiUtRemoveHexPrefix()

void AcpiUtRemoveHexPrefix

(

char **

String

)

Definition at line 357 of file utstrsuppt.c.

{
    if ((**String == ACPI_ASCII_ZERO) &&
        (tolower ((int) *(*String + 1)) == 'x'))
    {
        *String += 2;        /* Go past the leading 0x */
    }
}

Referenced by AcpiUtDetectHexPrefix(), and AcpiUtImplicitStrtoul64().

AcpiUtRemoveInterface()

ACPI_STATUS AcpiUtRemoveInterface

(

ACPI_STRING

InterfaceName

)

Definition at line 301 of file utosi.c.

{
    ACPI_INTERFACE_INFO     *PreviousInterface;
    ACPI_INTERFACE_INFO     *NextInterface;
 
 
    PreviousInterface = NextInterface = AcpiGbl_SupportedInterfaces;
    while (NextInterface)
    {
        if (!strcmp (InterfaceName, NextInterface->Name))
        {
            /*
             * Found: name is in either the static list
             * or was added at runtime
             */
            if (NextInterface->Flags & ACPI_OSI_DYNAMIC)
            {
                /* Interface was added dynamically, remove and free it */
 
                if (PreviousInterface == NextInterface)
                {
                    AcpiGbl_SupportedInterfaces = NextInterface->Next;
                }
                else
                {
                    PreviousInterface->Next = NextInterface->Next;
                }
 
                ACPI_FREE (NextInterface->Name);
                ACPI_FREE (NextInterface);
            }
            else
            {
                /*
                 * Interface is in static list. If marked invalid, then
                 * it does not actually exist. Else, mark it invalid.
                 */
                if (NextInterface->Flags & ACPI_OSI_INVALID)
                {
                    return (AE_NOT_EXIST);
                }
 
                NextInterface->Flags |= ACPI_OSI_INVALID;
            }
 
            return (AE_OK);
        }
 
        PreviousInterface = NextInterface;
        NextInterface = NextInterface->Next;
    }
 
    /* Interface was not found */
 
    return (AE_NOT_EXIST);
}

Referenced by AcpiRemoveInterface().

AcpiUtRemoveLeadingZeros()

char AcpiUtRemoveLeadingZeros

(

char **

String

)

Definition at line 274 of file utstrsuppt.c.

{
 
    while (**String == ACPI_ASCII_ZERO)
    {
        *String += 1;
    }
 
    return (**String);
}

Referenced by AcpiUtExplicitStrtoul64(), AcpiUtImplicitStrtoul64(), and AcpiUtStrtoul64().

AcpiUtRemoveReference()

void AcpiUtRemoveReference

(

ACPI_OPERAND_OBJECT *

Object

)

Definition at line 790 of file utdelete.c.

{
 
    ACPI_FUNCTION_NAME (UtRemoveReference);
 
 
    /*
     * Allow a NULL pointer to be passed in, just ignore it. This saves
     * each caller from having to check. Also, ignore NS nodes.
     */
    if (!Object ||
        (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED))
 
    {
        return;
    }
 
    /* Ensure that we have a valid object */
 
    if (!AcpiUtValidInternalObject (Object))
    {
        return;
    }
 
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS,
        "%s: Obj %p Current Refs=%X [To Be Decremented]\n",
        ACPI_GET_FUNCTION_NAME, 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!)
     */
    (void) AcpiUtUpdateObjectReference (Object, REF_DECREMENT);
    return;
}

Referenced by AcpiDsBuildInternalBufferObj(), AcpiDsBuildInternalObject(), AcpiDsBuildInternalPackageObj(), AcpiDsCallControlMethod(), AcpiDsClearImplicitReturn(), AcpiDsClearOperands(), AcpiDsCreateBufferField(), AcpiDsCreateNode(), AcpiDsDeleteResultIfNotUsed(), AcpiDsEvalBankFieldOperands(), AcpiDsEvalDataObjectOperands(), AcpiDsEvalRegionOperands(), AcpiDsEvalTableRegionOperands(), AcpiDsEvaluateNamePath(), AcpiDsExecEndControlOp(), AcpiDsGetFieldNames(), AcpiDsGetPredicateValue(), AcpiDsInitBufferField(), AcpiDsLoad2EndOp(), AcpiDsMethodDataDeleteValue(), AcpiDsObjStackPopAndDelete(), AcpiDsResolvePackageElement(), AcpiDsRestartControlMethod(), AcpiDsStoreObjectToLocal(), AcpiEvaluateObject(), AcpiEvDetachRegion(), AcpiEvExecuteRegMethod(), AcpiEvInstallSpaceHandler(), AcpiExCreateEvent(), AcpiExCreateMethod(), AcpiExCreateMutex(), AcpiExCreatePowerResource(), AcpiExCreateProcessor(), AcpiExCreateRegion(), AcpiExDoConcatenate(), AcpiExDoLogicalOp(), AcpiExLoadOp(), AcpiExLoadTableOp(), AcpiExOpcode_0A_0T_1R(), AcpiExOpcode_1A_0T_1R(), AcpiExOpcode_1A_1T_1R(), AcpiExOpcode_2A_0T_1R(), AcpiExOpcode_2A_1T_1R(), AcpiExOpcode_2A_2T_1R(), AcpiExOpcode_3A_1T_1R(), AcpiExOpcode_6A_0T_1R(), AcpiExPrepFieldValue(), AcpiExReadDataFromField(), AcpiExResolveMultiple(), AcpiExResolveObjectToValue(), AcpiExResolveOperands(), AcpiExStoreDirectToNode(), AcpiExStoreObjectToIndex(), AcpiExStoreObjectToObject(), AcpiGetSleepTypeData(), AcpiInstallGpeBlock(), AcpiInstallMethod(), AcpiInstallNotifyHandler(), AcpiNsDeleteNode(), AcpiNsDetachData(), AcpiNsDetachObject(), AcpiNsEvaluate(), AcpiNsExecuteTable(), AcpiNsRemoveElement(), AcpiNsRepair_CID(), AcpiNsRepair_FDE(), AcpiNsRepair_HID(), AcpiNsResolveReferences(), AcpiNsRootInitialize(), AcpiNsSearchAndEnter(), AcpiNsSimpleRepair(), AcpiPsParseAml(), AcpiRemoveAddressSpaceHandler(), AcpiRemoveNotifyHandler(), AcpiRsGetAeiMethodData(), AcpiRsGetCrsMethodData(), AcpiRsGetMethodData(), AcpiRsGetPrsMethodData(), AcpiRsGetPrtMethodData(), AcpiRsSetSrsMethodData(), AcpiUtCopyEpackageToIpackage(), AcpiUtCopyEsimpleToIsimple(), AcpiUtCopyIelementToIelement(), AcpiUtCopyIobjectToIobject(), AcpiUtCopyIpackageToIpackage(), AcpiUtCreateBufferObject(), AcpiUtCreateStringObject(), AcpiUtDeleteInternalObj(), AcpiUtDeleteInternalObjectList(), AcpiUtEvaluateNumericObject(), AcpiUtEvaluateObject(), AcpiUtExecute_CID(), AcpiUtExecute_CLS(), AcpiUtExecute_HID(), AcpiUtExecute_STA(), AcpiUtExecute_UID(), AcpiUtExecutePowerMethods(), and AcpiUtOsiImplementation().

AcpiUtRemoveWhitespace()

char AcpiUtRemoveWhitespace

(

char **

String

)

Definition at line 303 of file utstrsuppt.c.

{
 
    while (isspace ((UINT8) **String))
    {
        *String += 1;
    }
 
    return (**String);
}

Referenced by AcpiUtExplicitStrtoul64(), AcpiUtImplicitStrtoul64(), and AcpiUtStrtoul64().

AcpiUtRepairName()

void AcpiUtRepairName

(

char *

Name

)

Definition at line 183 of file utstring.c.

{
    UINT32                  i;
    BOOLEAN                 FoundBadChar = FALSE;
    UINT32                  OriginalName;
 
 
    ACPI_FUNCTION_NAME (UtRepairName);
 
 
    /*
     * Special case for the root node. This can happen if we get an
     * error during the execution of module-level code.
     */
    if (ACPI_COMPARE_NAMESEG (Name, ACPI_ROOT_PATHNAME))
    {
        return;
    }
 
    ACPI_COPY_NAMESEG (&OriginalName, &Name[0]);
 
    /* Check each character in the name */
 
    for (i = 0; i < ACPI_NAMESEG_SIZE; i++)
    {
        if (AcpiUtValidNameChar (Name[i], i))
        {
            continue;
        }
 
        /*
         * Replace a bad character with something printable, yet technically
         * "odd". This prevents any collisions with existing "good"
         * names in the namespace.
         */
        Name[i] = '_';
        FoundBadChar = TRUE;
    }
 
    if (FoundBadChar)
    {
        /* Report warning only if in strict mode or debug mode */
 
        if (!AcpiGbl_EnableInterpreterSlack)
        {
            ACPI_WARNING ((AE_INFO,
                "Invalid character(s) in name (0x%.8X) %p, repaired: [%4.4s]",
                OriginalName, Name, &Name[0]));
        }
        else
        {
            ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
                "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]",
                OriginalName, Name));
        }
    }
}

Referenced by AcpiNsExternalizeName(), AcpiNsSearchAndEnter(), and AcpiUtGetNodeName().

AcpiUtReportError()

void AcpiUtReportError	(	char *	ModuleName,
		UINT32	LineNumber
	)

AcpiUtReportInfo()

void AcpiUtReportInfo	(	char *	ModuleName,
		UINT32	LineNumber
	)

AcpiUtReportWarning()

void AcpiUtReportWarning	(	char *	ModuleName,
		UINT32	LineNumber
	)

AcpiUtSetIntegerWidth()

void AcpiUtSetIntegerWidth

(

UINT8

Revision

)

Definition at line 181 of file utmisc.c.

{
 
    if (Revision < 2)
    {
        /* 32-bit case */
 
        AcpiGbl_IntegerBitWidth = 32;
        AcpiGbl_IntegerNybbleWidth = 8;
        AcpiGbl_IntegerByteWidth = 4;
    }
    else
    {
        /* 64-bit case (ACPI 2.0+) */
 
        AcpiGbl_IntegerBitWidth = 64;
        AcpiGbl_IntegerNybbleWidth = 16;
        AcpiGbl_IntegerByteWidth = 8;
    }
}

Referenced by AcpiTbInstallTableWithOverride().

AcpiUtShortDivide()

ACPI_STATUS AcpiUtShortDivide	(	UINT64	InDividend,
		UINT32	Divisor,
		UINT64 *	OutQuotient,
		UINT32 *	OutRemainder
	)

Definition at line 337 of file utmath.c.

{
    UINT64_OVERLAY          DividendOvl;
    UINT64_OVERLAY          Quotient;
    UINT32                  Remainder32;
 
 
    ACPI_FUNCTION_TRACE (UtShortDivide);
 
 
    /* Always check for a zero divisor */
 
    if (Divisor == 0)
    {
        ACPI_ERROR ((AE_INFO, "Divide by zero"));
        return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
    }
 
    DividendOvl.Full = Dividend;
 
    /*
     * The quotient is 64 bits, the remainder is always 32 bits,
     * and is generated by the second divide.
     */
    ACPI_DIV_64_BY_32 (0, DividendOvl.Part.Hi, Divisor,
        Quotient.Part.Hi, Remainder32);
 
    ACPI_DIV_64_BY_32 (Remainder32, DividendOvl.Part.Lo, Divisor,
        Quotient.Part.Lo, Remainder32);
 
    /* Return only what was requested */
 
    if (OutQuotient)
    {
        *OutQuotient = Quotient.Full;
    }
    if (OutRemainder)
    {
        *OutRemainder = Remainder32;
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExConvertToAscii(), AcpiExDigitsNeeded(), AcpiExIntegerToString(), AcpiExOpcode_1A_1T_1R(), AcpiExSystemMemorySpaceHandler(), AcpiGetTimerDuration(), and AcpiUtStrtoulMultiply64().

AcpiUtShortMultiply()

ACPI_STATUS AcpiUtShortMultiply	(	UINT64	InMultiplicand,
		UINT32	Multiplier,
		UINT64 *	Outproduct
	)

Definition at line 88 of file utmath.c.

{
    UINT64_OVERLAY          MultiplicandOvl;
    UINT64_OVERLAY          Product;
    UINT32                  Carry32;
 
 
    ACPI_FUNCTION_TRACE (UtShortMultiply);
 
 
    MultiplicandOvl.Full = Multiplicand;
 
    /*
     * The Product is 64 bits, the carry is always 32 bits,
     * and is generated by the second multiply.
     */
    ACPI_MUL_64_BY_32 (0, MultiplicandOvl.Part.Hi, Multiplier,
        Product.Part.Hi, Carry32);
 
    ACPI_MUL_64_BY_32 (0, MultiplicandOvl.Part.Lo, Multiplier,
        Product.Part.Lo, Carry32);
 
    Product.Part.Hi += Carry32;
 
    /* Return only what was requested */
 
    if (OutProduct)
    {
        *OutProduct = Product.Full;
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiUtScanNumber().

AcpiUtShortShiftLeft()

ACPI_STATUS AcpiUtShortShiftLeft	(	UINT64	Operand,
		UINT32	Count,
		UINT64 *	OutResult
	)

Definition at line 139 of file utmath.c.

{
    UINT64_OVERLAY          OperandOvl;
 
 
    ACPI_FUNCTION_TRACE (UtShortShiftLeft);
 
 
    OperandOvl.Full = Operand;
 
    if ((Count & 63) >= 32)
    {
        OperandOvl.Part.Hi = OperandOvl.Part.Lo;
        OperandOvl.Part.Lo = 0;
        Count = (Count & 63) - 32;
    }
    ACPI_SHIFT_LEFT_64_BY_32 (OperandOvl.Part.Hi,
        OperandOvl.Part.Lo, Count);
 
    /* Return only what was requested */
 
    if (OutResult)
    {
        *OutResult = OperandOvl.Full;
    }
 
    return_ACPI_STATUS (AE_OK);
}

AcpiUtShortShiftRight()

ACPI_STATUS AcpiUtShortShiftRight	(	UINT64	Operand,
		UINT32	Count,
		UINT64 *	OutResult
	)

Definition at line 184 of file utmath.c.

{
    UINT64_OVERLAY          OperandOvl;
 
 
    ACPI_FUNCTION_TRACE (UtShortShiftRight);
 
 
    OperandOvl.Full = Operand;
 
    if ((Count & 63) >= 32)
    {
        OperandOvl.Part.Lo = OperandOvl.Part.Hi;
        OperandOvl.Part.Hi = 0;
        Count = (Count & 63) - 32;
    }
    ACPI_SHIFT_RIGHT_64_BY_32 (OperandOvl.Part.Hi,
        OperandOvl.Part.Lo, Count);
 
    /* Return only what was requested */
 
    if (OutResult)
    {
        *OutResult = OperandOvl.Full;
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiUtHexToAsciiChar().

AcpiUtStatusExit()

void AcpiUtStatusExit	(	UINT32	LineNumber,
		const char *	FunctionName,
		const char *	ModuleName,
		UINT32	ComponentId,
		ACPI_STATUS	Status
	)

AcpiUtStrExit()

void AcpiUtStrExit	(	UINT32	LineNumber,
		const char *	FunctionName,
		const char *	ModuleName,
		UINT32	ComponentId,
		const char *	String
	)

AcpiUtStricmp()

int AcpiUtStricmp	(	char *	String1,
		char *	String2
	)

Definition at line 144 of file utnonansi.c.

{
    int                     c1;
    int                     c2;
 
 
    do
    {
        c1 = tolower ((int) *String1);
        c2 = tolower ((int) *String2);
 
        String1++;
        String2++;
    }
    while ((c1 == c2) && (c1));
 
    return (c1 - c2);
}

AcpiUtStrlwr()

void AcpiUtStrlwr

(

char *

SrcString

)

Definition at line 69 of file utnonansi.c.

{
    char                    *String;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    if (!SrcString)
    {
        return;
    }
 
    /* Walk entire string, lowercasing the letters */
 
    for (String = SrcString; *String; String++)
    {
        *String = (char) tolower ((int) *String);
    }
}

AcpiUtStrtoul64()

ACPI_STATUS AcpiUtStrtoul64	(	char *	String,
		UINT64 *	RetInteger
	)

Definition at line 121 of file utstrtoul64.c.

{
    ACPI_STATUS             Status = AE_OK;
    UINT8                   OriginalBitWidth;
    UINT32                  Base = 10;          /* Default is decimal */
 
 
    ACPI_FUNCTION_TRACE_STR (UtStrtoul64, String);
 
 
    *ReturnValue = 0;
 
    /* A NULL return string returns a value of zero */
 
    if (*String == 0)
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    if (!AcpiUtRemoveWhitespace (&String))
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    /*
     * 1) Check for a hex constant. A "0x" prefix indicates base 16.
     */
    if (AcpiUtDetectHexPrefix (&String))
    {
        Base = 16;
    }
 
    /*
     * 2) Check for an octal constant, defined to be a leading zero
     * followed by sequence of octal digits (0-7)
     */
    else if (AcpiUtDetectOctalPrefix (&String))
    {
        Base = 8;
    }
 
    if (!AcpiUtRemoveLeadingZeros (&String))
    {
        return_ACPI_STATUS (AE_OK);     /* Return value 0 */
    }
 
    /*
     * Force a full 64-bit conversion. The caller (usually iASL) must
     * check for a 32-bit overflow later as necessary (If current mode
     * is 32-bit, meaning a 32-bit DSDT).
     */
    OriginalBitWidth = AcpiGbl_IntegerBitWidth;
    AcpiGbl_IntegerBitWidth = 64;
 
    /*
     * Perform the base 8, 10, or 16 conversion. A 64-bit numeric overflow
     * will return an exception (to allow iASL to flag the statement).
     */
    switch (Base)
    {
    case 8:
        Status = AcpiUtConvertOctalString (String, ReturnValue);
        break;
 
    case 10:
        Status = AcpiUtConvertDecimalString (String, ReturnValue);
        break;
 
    case 16:
    default:
        Status = AcpiUtConvertHexString (String, ReturnValue);
        break;
    }
 
    /* Only possible exception from above is a 64-bit overflow */
 
    AcpiGbl_IntegerBitWidth = OriginalBitWidth;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiNsConvertToInteger().

AcpiUtStrupr()

void AcpiUtStrupr

(

char *

SrcString

)

Definition at line 105 of file utnonansi.c.

{
    char                    *String;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    if (!SrcString)
    {
        return;
    }
 
    /* Walk entire string, uppercasing the letters */
 
    for (String = SrcString; *String; String++)
    {
        *String = (char) toupper ((int) *String);
    }
}

AcpiUtSubsystemShutdown()

void AcpiUtSubsystemShutdown

(

void

)

Definition at line 304 of file utinit.c.

{
    ACPI_FUNCTION_TRACE (UtSubsystemShutdown);
 
 
    /* Just exit if subsystem is already shutdown */
 
    if (AcpiGbl_Shutdown)
    {
        ACPI_ERROR ((AE_INFO, "ACPI Subsystem is already terminated"));
        return_VOID;
    }
 
    /* Subsystem appears active, go ahead and shut it down */
 
    AcpiGbl_Shutdown = TRUE;
    AcpiGbl_StartupFlags = 0;
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n"));
 
#ifndef ACPI_ASL_COMPILER
 
    /* Close the AcpiEvent Handling */
 
    AcpiEvTerminate ();
 
    /* Delete any dynamic _OSI interfaces */
 
    AcpiUtInterfaceTerminate ();
#endif
 
    /* Close the Namespace */
 
    AcpiNsTerminate ();
 
    /* Delete the ACPI tables */
 
    AcpiTbTerminate ();
 
    /* Close the globals */
 
    AcpiUtTerminate ();
 
    /* Purge the local caches */
 
    (void) AcpiUtDeleteCaches ();
    return_VOID;
}

Referenced by AcpiTerminate().

AcpiUtTrace()

void AcpiUtTrace	(	UINT32	LineNumber,
		const char *	FunctionName,
		const char *	ModuleName,
		UINT32	ComponentId
	)

AcpiUtTracePtr()

void AcpiUtTracePtr	(	UINT32	LineNumber,
		const char *	FunctionName,
		const char *	ModuleName,
		UINT32	ComponentId,
		const void *	Pointer
	)

AcpiUtTraceStr()

void AcpiUtTraceStr	(	UINT32	LineNumber,
		const char *	FunctionName,
		const char *	ModuleName,
		UINT32	ComponentId,
		const char *	String
	)

AcpiUtTraceU32()

void AcpiUtTraceU32	(	UINT32	LineNumber,
		const char *	FunctionName,
		const char *	ModuleName,
		UINT32	ComponentId,
		UINT32	Integer
	)

AcpiUtTrackStackPtr()

void AcpiUtTrackStackPtr

(

void

)

AcpiUtUpdateInterfaces()

ACPI_STATUS AcpiUtUpdateInterfaces

(

UINT8

Action

)

Definition at line 376 of file utosi.c.

{
    ACPI_INTERFACE_INFO     *NextInterface;
 
 
    NextInterface = AcpiGbl_SupportedInterfaces;
    while (NextInterface)
    {
        if (((NextInterface->Flags & ACPI_OSI_FEATURE) &&
             (Action & ACPI_FEATURE_STRINGS)) ||
            (!(NextInterface->Flags & ACPI_OSI_FEATURE) &&
             (Action & ACPI_VENDOR_STRINGS)))
        {
            if (Action & ACPI_DISABLE_INTERFACES)
            {
                /* Mark the interfaces as invalid */
 
                NextInterface->Flags |= ACPI_OSI_INVALID;
            }
            else
            {
                /* Mark the interfaces as valid */
 
                NextInterface->Flags &= ~ACPI_OSI_INVALID;
            }
        }
 
        NextInterface = NextInterface->Next;
    }
 
    return (AE_OK);
}

Referenced by AcpiUpdateInterfaces().

AcpiUtUpdateObjectReference()

ACPI_STATUS AcpiUtUpdateObjectReference	(	ACPI_OPERAND_OBJECT *	Object,
		UINT16	Action
	)

Definition at line 548 of file utdelete.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_GENERIC_STATE      *StateList = NULL;
    ACPI_OPERAND_OBJECT     *NextObject = NULL;
    ACPI_OPERAND_OBJECT     *PrevObject;
    ACPI_GENERIC_STATE      *State;
    UINT32                  i;
 
 
    ACPI_FUNCTION_NAME (UtUpdateObjectReference);
 
 
    while (Object)
    {
        /* Make sure that this isn't a namespace handle */
 
        if (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED)
        {
            ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
                "Object %p is NS handle\n", Object));
            return (AE_OK);
        }
 
        /*
         * All sub-objects must have their reference count updated
         * also. Different object types have different subobjects.
         */
        switch (Object->Common.Type)
        {
        case ACPI_TYPE_DEVICE:
        case ACPI_TYPE_PROCESSOR:
        case ACPI_TYPE_POWER:
        case ACPI_TYPE_THERMAL:
            /*
             * Update the notify objects for these types (if present)
             * Two lists, system and device notify handlers.
             */
            for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
            {
                PrevObject = Object->CommonNotify.NotifyList[i];
                while (PrevObject)
                {
                    NextObject = PrevObject->Notify.Next[i];
                    AcpiUtUpdateRefCount (PrevObject, Action);
                    PrevObject = NextObject;
                }
            }
            break;
 
        case ACPI_TYPE_PACKAGE:
            /*
             * We must update all the sub-objects of the package,
             * each of whom may have their own sub-objects.
             */
            for (i = 0; i < Object->Package.Count; i++)
            {
                /*
                 * Null package elements are legal and can be simply
                 * ignored.
                 */
                NextObject = Object->Package.Elements[i];
                if (!NextObject)
                {
                    continue;
                }
 
                switch (NextObject->Common.Type)
                {
                case ACPI_TYPE_INTEGER:
                case ACPI_TYPE_STRING:
                case ACPI_TYPE_BUFFER:
                    /*
                     * For these very simple sub-objects, we can just
                     * update the reference count here and continue.
                     * Greatly increases performance of this operation.
                     */
                    AcpiUtUpdateRefCount (NextObject, Action);
                    break;
 
                default:
                    /*
                     * For complex sub-objects, push them onto the stack
                     * for later processing (this eliminates recursion.)
                     */
                    Status = AcpiUtCreateUpdateStateAndPush (
                        NextObject, Action, &StateList);
                    if (ACPI_FAILURE (Status))
                    {
                        goto ErrorExit;
                    }
                    break;
                }
            }
 
            NextObject = NULL;
            break;
 
        case ACPI_TYPE_BUFFER_FIELD:
 
            NextObject = Object->BufferField.BufferObj;
            break;
 
        case ACPI_TYPE_LOCAL_BANK_FIELD:
 
            NextObject = Object->BankField.BankObj;
            Status = AcpiUtCreateUpdateStateAndPush (
                Object->BankField.RegionObj, Action, &StateList);
            if (ACPI_FAILURE (Status))
            {
                goto ErrorExit;
            }
            break;
 
        case ACPI_TYPE_LOCAL_INDEX_FIELD:
 
            NextObject = Object->IndexField.IndexObj;
            Status = AcpiUtCreateUpdateStateAndPush (
                Object->IndexField.DataObj, Action, &StateList);
            if (ACPI_FAILURE (Status))
            {
                goto ErrorExit;
            }
            break;
 
        case ACPI_TYPE_LOCAL_REFERENCE:
            /*
             * The target of an Index (a package, string, or buffer) or a named
             * reference must track changes to the ref count of the index or
             * target object.
             */
            if ((Object->Reference.Class == ACPI_REFCLASS_INDEX) ||
                (Object->Reference.Class== ACPI_REFCLASS_NAME))
            {
                NextObject = Object->Reference.Object;
            }
            break;
 
        case ACPI_TYPE_LOCAL_REGION_FIELD:
        case ACPI_TYPE_REGION:
        default:
 
            break; /* No subobjects for all other types */
        }
 
        /*
         * 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);
        Object = NULL;
 
        /* Move on to the next object to be updated */
 
        if (NextObject)
        {
            Object = NextObject;
            NextObject = NULL;
        }
        else if (StateList)
        {
            State = AcpiUtPopGenericState (&StateList);
            Object = State->Update.Object;
            AcpiUtDeleteGenericState (State);
        }
    }
 
    return (AE_OK);
 
 
ErrorExit:
 
    ACPI_EXCEPTION ((AE_INFO, Status,
        "Could not update object reference count"));
 
    /* Free any stacked Update State objects */
 
    while (StateList)
    {
        State = AcpiUtPopGenericState (&StateList);
        AcpiUtDeleteGenericState (State);
    }
 
    return (Status);
}

Referenced by AcpiPsUpdateParameterList(), AcpiUtAddReference(), and AcpiUtRemoveReference().

AcpiUtValidateBuffer()

ACPI_STATUS AcpiUtValidateBuffer

(

ACPI_BUFFER *

Buffer

)

Definition at line 290 of file utalloc.c.

{
 
    /* Obviously, the structure pointer must be valid */
 
    if (!Buffer)
    {
        return (AE_BAD_PARAMETER);
    }
 
    /* Special semantics for the length */
 
    if ((Buffer->Length == ACPI_NO_BUFFER)              ||
        (Buffer->Length == ACPI_ALLOCATE_BUFFER)        ||
        (Buffer->Length == ACPI_ALLOCATE_LOCAL_BUFFER))
    {
        return (AE_OK);
    }
 
    /* Length is valid, the buffer pointer must be also */
 
    if (!Buffer->Pointer)
    {
        return (AE_BAD_PARAMETER);
    }
 
    return (AE_OK);
}

Referenced by AcpiGetName(), AcpiGetSystemInfo(), and AcpiRsValidateParameters().

AcpiUtValidateException()

const ACPI_EXCEPTION_INFO * AcpiUtValidateException

(

ACPI_STATUS

Status

)

Definition at line 111 of file utexcep.c.

{
    UINT32                      SubStatus;
    const ACPI_EXCEPTION_INFO   *Exception = NULL;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /*
     * Status is composed of two parts, a "type" and an actual code
     */
    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];
        }
        break;
 
    case AE_CODE_ACPI_TABLES:
 
        if (SubStatus <= AE_CODE_TBL_MAX)
        {
            Exception = &AcpiGbl_ExceptionNames_Tbl [SubStatus];
        }
        break;
 
    case AE_CODE_AML:
 
        if (SubStatus <= AE_CODE_AML_MAX)
        {
            Exception = &AcpiGbl_ExceptionNames_Aml [SubStatus];
        }
        break;
 
    case AE_CODE_CONTROL:
 
        if (SubStatus <= AE_CODE_CTRL_MAX)
        {
            Exception = &AcpiGbl_ExceptionNames_Ctrl [SubStatus];
        }
        break;
 
    default:
 
        break;
    }
 
    if (!Exception || !Exception->Name)
    {
        return (NULL);
    }
 
    return (Exception);
}

Referenced by AcpiFormatException().

AcpiUtValidateResource()

ACPI_STATUS AcpiUtValidateResource	(	ACPI_WALK_STATE *	WalkState,
		void *	Aml,
		UINT8 *	ReturnIndex
	)

Definition at line 314 of file utresrc.c.

{
    AML_RESOURCE            *AmlResource;
    UINT8                   ResourceType;
    UINT8                   ResourceIndex;
    ACPI_RS_LENGTH          ResourceLength;
    ACPI_RS_LENGTH          MinimumResourceLength;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /*
     * 1) Validate the ResourceType field (Byte 0)
     */
    ResourceType = ACPI_GET8 (Aml);
 
    /*
     * Byte 0 contains the descriptor name (Resource Type)
     * Examine the large/small bit in the resource header
     */
    if (ResourceType & ACPI_RESOURCE_NAME_LARGE)
    {
        /* Verify the large resource type (name) against the max */
 
        if (ResourceType > ACPI_RESOURCE_NAME_LARGE_MAX)
        {
            goto InvalidResource;
        }
 
        /*
         * Large Resource Type -- bits 6:0 contain the name
         * Translate range 0x80-0x8B to index range 0x10-0x1B
         */
        ResourceIndex = (UINT8) (ResourceType - 0x70);
    }
    else
    {
        /*
         * Small Resource Type -- bits 6:3 contain the name
         * Shift range to index range 0x00-0x0F
         */
        ResourceIndex = (UINT8)
            ((ResourceType & ACPI_RESOURCE_NAME_SMALL_MASK) >> 3);
    }
 
    /*
     * Check validity of the resource type, via AcpiGbl_ResourceTypes.
     * Zero indicates an invalid resource.
     */
    if (!AcpiGbl_ResourceTypes[ResourceIndex])
    {
        goto InvalidResource;
    }
 
    /*
     * Validate the ResourceLength field. This ensures that the length
     * is at least reasonable, and guarantees that it is non-zero.
     */
    ResourceLength = AcpiUtGetResourceLength (Aml);
    MinimumResourceLength = AcpiGbl_ResourceAmlSizes[ResourceIndex];
 
    /* Validate based upon the type of resource - fixed length or variable */
 
    switch (AcpiGbl_ResourceTypes[ResourceIndex])
    {
    case ACPI_FIXED_LENGTH:
 
        /* Fixed length resource, length must match exactly */
 
        if (ResourceLength != MinimumResourceLength)
        {
            goto BadResourceLength;
        }
        break;
 
    case ACPI_VARIABLE_LENGTH:
 
        /* Variable length resource, length must be at least the minimum */
 
        if (ResourceLength < MinimumResourceLength)
        {
            goto BadResourceLength;
        }
        break;
 
    case ACPI_SMALL_VARIABLE_LENGTH:
 
        /* Small variable length resource, length can be (Min) or (Min-1) */
 
        if ((ResourceLength > MinimumResourceLength) ||
            (ResourceLength < (MinimumResourceLength - 1)))
        {
            goto BadResourceLength;
        }
        break;
 
    default:
 
        /* Shouldn't happen (because of validation earlier), but be sure */
 
        goto InvalidResource;
    }
 
    AmlResource = ACPI_CAST_PTR (AML_RESOURCE, Aml);
    if (ResourceType == ACPI_RESOURCE_NAME_SERIAL_BUS)
    {
        /* Validate the BusType field */
 
        if ((AmlResource->CommonSerialBus.Type == 0) ||
            (AmlResource->CommonSerialBus.Type > AML_RESOURCE_MAX_SERIALBUSTYPE))
        {
            if (WalkState)
            {
                ACPI_ERROR ((AE_INFO,
                    "Invalid/unsupported SerialBus resource descriptor: BusType 0x%2.2X",
                    AmlResource->CommonSerialBus.Type));
            }
            return (AE_AML_INVALID_RESOURCE_TYPE);
        }
    }
 
    /* Optionally return the resource table index */
 
    if (ReturnIndex)
    {
        *ReturnIndex = ResourceIndex;
    }
 
    return (AE_OK);
 
 
InvalidResource:
 
    if (WalkState)
    {
        ACPI_ERROR ((AE_INFO,
            "Invalid/unsupported resource descriptor: Type 0x%2.2X",
            ResourceType));
    }
    return (AE_AML_INVALID_RESOURCE_TYPE);
 
BadResourceLength:
 
    if (WalkState)
    {
        ACPI_ERROR ((AE_INFO,
            "Invalid resource descriptor length: Type "
            "0x%2.2X, Length 0x%4.4X, MinLength 0x%4.4X",
            ResourceType, ResourceLength, MinimumResourceLength));
    }
    return (AE_AML_BAD_RESOURCE_LENGTH);
}

Referenced by AcpiRsConvertResourcesToAml(), AcpiRsGetListLength(), and AcpiUtWalkAmlResources().

AcpiUtValidInternalObject()

BOOLEAN AcpiUtValidInternalObject

(

void *

Object

)

Definition at line 376 of file utobject.c.

{
 
    ACPI_FUNCTION_NAME (UtValidInternalObject);
 
 
    /* Check for a null pointer */
 
    if (!Object)
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "**** Null Object Ptr\n"));
        return (FALSE);
    }
 
    /* Check the descriptor type field */
 
    switch (ACPI_GET_DESCRIPTOR_TYPE (Object))
    {
    case ACPI_DESC_TYPE_OPERAND:
 
        /* The object appears to be a valid ACPI_OPERAND_OBJECT */
 
        return (TRUE);
 
    default:
 
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "%p is not an ACPI operand obj [%s]\n",
            Object, AcpiUtGetDescriptorName (Object)));
        break;
    }
 
    return (FALSE);
}

Referenced by AcpiExDoDebugObject(), AcpiUtAddReference(), and AcpiUtRemoveReference().

AcpiUtValidNameChar()

BOOLEAN AcpiUtValidNameChar	(	char	Character,
		UINT32	Position
	)

Definition at line 102 of file utascii.c.

{
 
    if (!((Character >= 'A' && Character <= 'Z') ||
          (Character >= '0' && Character <= '9') ||
          (Character == '_')))
    {
        /* Allow a '!' in the last position */
 
        if (Character == '!' && Position == 3)
        {
            return (TRUE);
        }
 
        return (FALSE);
    }
 
    return (TRUE);
}

Referenced by AcpiExNameSegment(), AcpiUtRepairName(), and AcpiUtValidNameseg().

AcpiUtValidNameseg()

BOOLEAN AcpiUtValidNameseg

(

char *

Signature

)

Definition at line 63 of file utascii.c.

{
    UINT32                  i;
 
 
    /* Validate each character in the signature */
 
    for (i = 0; i < ACPI_NAMESEG_SIZE; i++)
    {
        if (!AcpiUtValidNameChar (Name[i], i))
        {
            return (FALSE);
        }
    }
 
    return (TRUE);
}

Referenced by AcpiTbFindTable(), and AcpiTbVerifyTempTable().

AcpiUtValidObjectType()

BOOLEAN AcpiUtValidObjectType

(

ACPI_OBJECT_TYPE

Type

)

Definition at line 681 of file utdecode.c.

{
 
    if (Type > ACPI_TYPE_LOCAL_MAX)
    {
        /* Note: Assumes all TYPEs are contiguous (external/local) */
 
        return (FALSE);
    }
 
    return (TRUE);
}

Referenced by AcpiDsScopeStackPush(), AcpiExResolveOperands(), and AcpiNsLocal().

AcpiUtValueExit()

void AcpiUtValueExit	(	UINT32	LineNumber,
		const char *	FunctionName,
		const char *	ModuleName,
		UINT32	ComponentId,
		UINT64	Value
	)

AcpiUtVerifyCdatChecksum()

ACPI_STATUS AcpiUtVerifyCdatChecksum	(	ACPI_TABLE_CDAT *	CdatTable,
		UINT32	Length
	)

Definition at line 130 of file utcksum.c.

{
    UINT8                   Checksum;
 
 
    /* Compute the checksum on the table */
 
    Checksum = AcpiUtGenerateChecksum (ACPI_CAST_PTR (UINT8, CdatTable),
                    CdatTable->Length, CdatTable->Checksum);
 
    /* Computed checksum matches table? */
 
    if (Checksum != CdatTable->Checksum)
    {
        ACPI_BIOS_WARNING ((AE_INFO,
            "Incorrect checksum in table [%4.4s] - 0x%2.2X, "
            "should be 0x%2.2X",
            AcpiGbl_CDAT, CdatTable->Checksum, Checksum));
 
#if (ACPI_CHECKSUM_ABORT)
        return (AE_BAD_CHECKSUM);
#endif
    }
 
    CdatTable->Checksum = Checksum;
    return (AE_OK);
}

AcpiUtVerifyChecksum()

ACPI_STATUS AcpiUtVerifyChecksum	(	ACPI_TABLE_HEADER *	Table,
		UINT32	Length
	)

Definition at line 74 of file utcksum.c.

{
    UINT8                   Checksum;
 
 
    /*
     * FACS/S3PT:
     * They are the odd tables, have no standard ACPI header and no checksum
     */
    if (ACPI_COMPARE_NAMESEG (Table->Signature, ACPI_SIG_S3PT) ||
        ACPI_COMPARE_NAMESEG (Table->Signature, ACPI_SIG_FACS))
    {
        return (AE_OK);
    }
 
    /* Compute the checksum on the table */
 
    Length = Table->Length;
    Checksum = AcpiUtGenerateChecksum (ACPI_CAST_PTR (UINT8, Table), Length, Table->Checksum);
 
    /* Computed checksum matches table? */
 
    if (Checksum != Table->Checksum)
    {
        ACPI_BIOS_WARNING ((AE_INFO,
            "Incorrect checksum in table [%4.4s] - 0x%2.2X, "
            "should be 0x%2.2X",
            Table->Signature, Table->Checksum,
            Table->Checksum - Checksum));
 
#if (ACPI_CHECKSUM_ABORT)
        return (AE_BAD_CHECKSUM);
#endif
    }
 
    return (AE_OK);
}

Referenced by AcpiTbParseFadt(), AcpiTbParseRootTable(), and AcpiTbVerifyTempTable().

AcpiUtWalkAmlResources()

ACPI_STATUS AcpiUtWalkAmlResources	(	ACPI_WALK_STATE *	WalkState,
		UINT8 *	Aml,
		ACPI_SIZE	AmlLength,
		ACPI_WALK_AML_CALLBACK	UserFunction,
		void **	Context
	)

Definition at line 181 of file utresrc.c.

{
    ACPI_STATUS             Status;
    UINT8                   *EndAml;
    UINT8                   ResourceIndex;
    UINT32                  Length;
    UINT32                  Offset = 0;
    UINT8                   EndTag[2] = {0x79, 0x00};
 
 
    ACPI_FUNCTION_TRACE (UtWalkAmlResources);
 
 
    /* The absolute minimum resource template is one EndTag descriptor */
 
    if (AmlLength < sizeof (AML_RESOURCE_END_TAG))
    {
        return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
    }
 
    /* Point to the end of the resource template buffer */
 
    EndAml = Aml + AmlLength;
 
    /* Walk the byte list, abort on any invalid descriptor type or length */
 
    while (Aml < EndAml)
    {
        /* Validate the Resource Type and Resource Length */
 
        Status = AcpiUtValidateResource (WalkState, Aml, &ResourceIndex);
        if (ACPI_FAILURE (Status))
        {
            /*
             * Exit on failure. Cannot continue because the descriptor
             * length may be bogus also.
             */
            return_ACPI_STATUS (Status);
        }
 
        /* Get the length of this descriptor */
 
        Length = AcpiUtGetDescriptorLength (Aml);
 
        /* Invoke the user function */
 
        if (UserFunction)
        {
            Status = UserFunction (
                Aml, Length, Offset, ResourceIndex, Context);
            if (ACPI_FAILURE (Status))
            {
                return_ACPI_STATUS (Status);
            }
        }
 
        /* An EndTag descriptor terminates this resource template */
 
        if (AcpiUtGetResourceType (Aml) == ACPI_RESOURCE_NAME_END_TAG)
        {
            /*
             * There must be at least one more byte in the buffer for
             * the 2nd byte of the EndTag
             */
            if ((Aml + 1) >= EndAml)
            {
                return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
            }
 
            /*
             * Don't attempt to perform any validation on the 2nd byte.
             * Although all known ASL compilers insert a zero for the 2nd
             * byte, it can also be a checksum (as per the ACPI spec),
             * and this is occasionally seen in the field. July 2017.
             */
 
            /* Return the pointer to the EndTag if requested */
 
            if (!UserFunction)
            {
                *Context = Aml;
            }
 
            /* Normal exit */
 
            return_ACPI_STATUS (AE_OK);
        }
 
        Aml += Length;
        Offset += Length;
    }
 
    /* Did not find an EndTag descriptor */
 
    if (UserFunction)
    {
        /* Insert an EndTag anyway. AcpiRsGetListLength always leaves room */
 
        (void) AcpiUtValidateResource (WalkState, EndTag, &ResourceIndex);
        Status = UserFunction (EndTag, 2, Offset, ResourceIndex, Context);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
    }
 
    return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
}

Referenced by AcpiBufferToResource(), AcpiRsCreateResourceList(), and AcpiUtGetResourceEndTag().

AcpiUtWalkPackageTree()

ACPI_STATUS AcpiUtWalkPackageTree	(	ACPI_OPERAND_OBJECT *	SourceObject,
		void *	TargetObject,
		ACPI_PKG_CALLBACK	WalkCallback,
		void *	Context
	)

Definition at line 264 of file utmisc.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_GENERIC_STATE      *StateList = NULL;
    ACPI_GENERIC_STATE      *State;
    ACPI_OPERAND_OBJECT     *ThisSourceObj;
    UINT32                  ThisIndex;
 
 
    ACPI_FUNCTION_TRACE (UtWalkPackageTree);
 
 
    State = AcpiUtCreatePkgState (SourceObject, TargetObject, 0);
    if (!State)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    while (State)
    {
        /* Get one element of the package */
 
        ThisIndex = State->Pkg.Index;
        ThisSourceObj =
            State->Pkg.SourceObject->Package.Elements[ThisIndex];
        State->Pkg.ThisTargetObj =
            &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) ||
            (ACPI_GET_DESCRIPTOR_TYPE (ThisSourceObj) !=
                ACPI_DESC_TYPE_OPERAND) ||
            (ThisSourceObj->Common.Type != ACPI_TYPE_PACKAGE))
        {
            Status = WalkCallback (ACPI_COPY_TYPE_SIMPLE, ThisSourceObj,
                State, Context);
            if (ACPI_FAILURE (Status))
            {
                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 subobject of type package */
 
            Status = WalkCallback (
                ACPI_COPY_TYPE_PACKAGE, ThisSourceObj, State, Context);
            if (ACPI_FAILURE (Status))
            {
                return_ACPI_STATUS (Status);
            }
 
            /*
             * Push the current state and create a new one
             * The callback above returned a new target package object.
             */
            AcpiUtPushGenericState (&StateList, State);
            State = AcpiUtCreatePkgState (
                ThisSourceObj, State->Pkg.ThisTargetObj, 0);
            if (!State)
            {
                /* Free any stacked Update State objects */
 
                while (StateList)
                {
                    State = AcpiUtPopGenericState (&StateList);
                    AcpiUtDeleteGenericState (State);
                }
                return_ACPI_STATUS (AE_NO_MEMORY);
            }
        }
    }
 
    /* We should never get here */
 
    ACPI_ERROR ((AE_INFO,
        "State list did not terminate correctly"));
 
    return_ACPI_STATUS (AE_AML_INTERNAL);
}

Referenced by AcpiNsInitOnePackage(), AcpiUtCopyIpackageToEpackage(), AcpiUtCopyIpackageToIpackage(), and AcpiUtGetPackageObjectSize().

Variable Documentation

AcpiGbl_ResourceAmlSerialBusSizes

const UINT8 AcpiGbl_ResourceAmlSerialBusSizes[]

extern

Definition at line 101 of file utresrc.c.

Referenced by AcpiRsGetListLength().

AcpiGbl_ResourceAmlSizes

const UINT8 AcpiGbl_ResourceAmlSizes[]

extern

Definition at line 57 of file utresrc.c.

Referenced by AcpiRsGetListLength(), and AcpiUtValidateResource().