acresrc.h File Reference

#include "amlresrc.h"

Include dependency graph for acresrc.h:

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

Go to the source code of this file.

Classes
struct	acpi_rsconvert_info
struct	acpi_rsdump_info
struct	acpi_vendor_walk_info

Macros
#define	ACPI_RSC_COMPARE_AML_LENGTH   0
#define	ACPI_RSC_COMPARE_VALUE   1
#define	ACPI_RSC_TABLE_SIZE(d)   (sizeof (d) / sizeof (ACPI_RSCONVERT_INFO))
#define	ACPI_RS_OFFSET(f)   (UINT8) ACPI_OFFSET (ACPI_RESOURCE,f)
#define	AML_OFFSET(f)   (UINT8) ACPI_OFFSET (AML_RESOURCE,f)

Typedefs
typedef const struct acpi_rsconvert_info	ACPI_RSCONVERT_INFO
typedef const struct acpi_rsdump_info	ACPI_RSDUMP_INFO
typedef struct acpi_vendor_walk_info	ACPI_VENDOR_WALK_INFO

Enumerations
enum	ACPI_RSCONVERT_OPCODES {   ACPI_RSC_INITGET = 0 , ACPI_RSC_INITSET , ACPI_RSC_FLAGINIT , ACPI_RSC_1BITFLAG ,   ACPI_RSC_2BITFLAG , ACPI_RSC_3BITFLAG , ACPI_RSC_6BITFLAG , ACPI_RSC_ADDRESS ,   ACPI_RSC_BITMASK , ACPI_RSC_BITMASK16 , ACPI_RSC_COUNT , ACPI_RSC_COUNT16 ,   ACPI_RSC_COUNT_GPIO_PIN , ACPI_RSC_COUNT_GPIO_RES , ACPI_RSC_COUNT_GPIO_VEN , ACPI_RSC_COUNT_SERIAL_RES ,   ACPI_RSC_COUNT_SERIAL_VEN , ACPI_RSC_DATA8 , ACPI_RSC_EXIT_EQ , ACPI_RSC_EXIT_LE ,   ACPI_RSC_EXIT_NE , ACPI_RSC_LENGTH , ACPI_RSC_MOVE_GPIO_PIN , ACPI_RSC_MOVE_GPIO_RES ,   ACPI_RSC_MOVE_SERIAL_RES , ACPI_RSC_MOVE_SERIAL_VEN , ACPI_RSC_MOVE8 , ACPI_RSC_MOVE16 ,   ACPI_RSC_MOVE32 , ACPI_RSC_MOVE64 , ACPI_RSC_SET8 , ACPI_RSC_SOURCE ,   ACPI_RSC_SOURCEX }
enum	ACPI_RSDUMP_OPCODES {   ACPI_RSD_TITLE = 0 , ACPI_RSD_1BITFLAG , ACPI_RSD_2BITFLAG , ACPI_RSD_3BITFLAG ,   ACPI_RSD_6BITFLAG , ACPI_RSD_ADDRESS , ACPI_RSD_DWORDLIST , ACPI_RSD_LITERAL ,   ACPI_RSD_LONGLIST , ACPI_RSD_SHORTLIST , ACPI_RSD_SHORTLISTX , ACPI_RSD_SOURCE ,   ACPI_RSD_STRING , ACPI_RSD_UINT8 , ACPI_RSD_UINT16 , ACPI_RSD_UINT32 ,   ACPI_RSD_UINT64 , ACPI_RSD_WORDLIST , ACPI_RSD_LABEL , ACPI_RSD_SOURCE_LABEL }

Functions
ACPI_STATUS	AcpiRsCreateResourceList (ACPI_OPERAND_OBJECT *AmlBuffer, ACPI_BUFFER *OutputBuffer)
ACPI_STATUS	AcpiRsCreateAmlResources (ACPI_BUFFER *ResourceList, ACPI_BUFFER *OutputBuffer)
ACPI_STATUS	AcpiRsCreatePciRoutingTable (ACPI_OPERAND_OBJECT *PackageObject, ACPI_BUFFER *OutputBuffer)
ACPI_STATUS	AcpiRsGetPrtMethodData (ACPI_NAMESPACE_NODE *Node, ACPI_BUFFER *RetBuffer)
ACPI_STATUS	AcpiRsGetCrsMethodData (ACPI_NAMESPACE_NODE *Node, ACPI_BUFFER *RetBuffer)
ACPI_STATUS	AcpiRsGetPrsMethodData (ACPI_NAMESPACE_NODE *Node, ACPI_BUFFER *RetBuffer)
ACPI_STATUS	AcpiRsGetMethodData (ACPI_HANDLE Handle, const char *Path, ACPI_BUFFER *RetBuffer)
ACPI_STATUS	AcpiRsSetSrsMethodData (ACPI_NAMESPACE_NODE *Node, ACPI_BUFFER *RetBuffer)
ACPI_STATUS	AcpiRsGetAeiMethodData (ACPI_NAMESPACE_NODE *Node, ACPI_BUFFER *RetBuffer)
ACPI_STATUS	AcpiRsGetListLength (UINT8 *AmlBuffer, UINT32 AmlBufferLength, ACPI_SIZE *SizeNeeded)
ACPI_STATUS	AcpiRsGetAmlLength (ACPI_RESOURCE *ResourceList, ACPI_SIZE ResourceListSize, ACPI_SIZE *SizeNeeded)
ACPI_STATUS	AcpiRsGetPciRoutingTableLength (ACPI_OPERAND_OBJECT *PackageObject, ACPI_SIZE *BufferSizeNeeded)
ACPI_STATUS	AcpiRsConvertAmlToResources (UINT8 *Aml, UINT32 Length, UINT32 Offset, UINT8 ResourceIndex, void **Context)
ACPI_STATUS	AcpiRsConvertResourcesToAml (ACPI_RESOURCE *Resource, ACPI_SIZE AmlSizeNeeded, UINT8 *OutputBuffer)
void	AcpiRsSetAddressCommon (AML_RESOURCE *Aml, ACPI_RESOURCE *Resource)
BOOLEAN	AcpiRsGetAddressCommon (ACPI_RESOURCE *Resource, AML_RESOURCE *Aml)
ACPI_STATUS	AcpiRsConvertAmlToResource (ACPI_RESOURCE *Resource, AML_RESOURCE *Aml, ACPI_RSCONVERT_INFO *Info)
ACPI_STATUS	AcpiRsConvertResourceToAml (ACPI_RESOURCE *Resource, AML_RESOURCE *Aml, ACPI_RSCONVERT_INFO *Info)
void	AcpiRsMoveData (void *Destination, void *Source, UINT16 ItemCount, UINT8 MoveType)
UINT8	AcpiRsDecodeBitmask (UINT16 Mask, UINT8 *List)
UINT16	AcpiRsEncodeBitmask (UINT8 *List, UINT8 Count)
ACPI_RS_LENGTH	AcpiRsGetResourceSource (ACPI_RS_LENGTH ResourceLength, ACPI_RS_LENGTH MinimumLength, ACPI_RESOURCE_SOURCE *ResourceSource, AML_RESOURCE *Aml, char *StringPtr)
ACPI_RSDESC_SIZE	AcpiRsSetResourceSource (AML_RESOURCE *Aml, ACPI_RS_LENGTH MinimumLength, ACPI_RESOURCE_SOURCE *ResourceSource)
void	AcpiRsSetResourceHeader (UINT8 DescriptorType, ACPI_RSDESC_SIZE TotalLength, AML_RESOURCE *Aml)
void	AcpiRsSetResourceLength (ACPI_RSDESC_SIZE TotalLength, AML_RESOURCE *Aml)

Variables
const UINT8	AcpiGbl_AmlResourceSizes []
const UINT8	AcpiGbl_AmlResourceSerialBusSizes []
ACPI_RSCONVERT_INFO *	AcpiGbl_SetResourceDispatch []
const UINT8	AcpiGbl_ResourceStructSizes []
const UINT8	AcpiGbl_ResourceStructSerialBusSizes []
ACPI_RSCONVERT_INFO *	AcpiGbl_GetResourceDispatch []
ACPI_RSCONVERT_INFO *	AcpiGbl_ConvertResourceSerialBusDispatch []
ACPI_RSCONVERT_INFO	AcpiRsConvertDma []
ACPI_RSCONVERT_INFO	AcpiRsConvertEndDpf []
ACPI_RSCONVERT_INFO	AcpiRsConvertIo []
ACPI_RSCONVERT_INFO	AcpiRsConvertFixedIo []
ACPI_RSCONVERT_INFO	AcpiRsConvertEndTag []
ACPI_RSCONVERT_INFO	AcpiRsConvertMemory24 []
ACPI_RSCONVERT_INFO	AcpiRsConvertGenericReg []
ACPI_RSCONVERT_INFO	AcpiRsConvertMemory32 []
ACPI_RSCONVERT_INFO	AcpiRsConvertFixedMemory32 []
ACPI_RSCONVERT_INFO	AcpiRsConvertAddress32 []
ACPI_RSCONVERT_INFO	AcpiRsConvertAddress16 []
ACPI_RSCONVERT_INFO	AcpiRsConvertExtIrq []
ACPI_RSCONVERT_INFO	AcpiRsConvertAddress64 []
ACPI_RSCONVERT_INFO	AcpiRsConvertExtAddress64 []
ACPI_RSCONVERT_INFO	AcpiRsConvertGpio []
ACPI_RSCONVERT_INFO	AcpiRsConvertFixedDma []
ACPI_RSCONVERT_INFO	AcpiRsConvertCsi2SerialBus []
ACPI_RSCONVERT_INFO	AcpiRsConvertI2cSerialBus []
ACPI_RSCONVERT_INFO	AcpiRsConvertSpiSerialBus []
ACPI_RSCONVERT_INFO	AcpiRsConvertUartSerialBus []
ACPI_RSCONVERT_INFO	AcpiRsConvertPinFunction []
ACPI_RSCONVERT_INFO	AcpiRsConvertPinConfig []
ACPI_RSCONVERT_INFO	AcpiRsConvertPinGroup []
ACPI_RSCONVERT_INFO	AcpiRsConvertPinGroupFunction []
ACPI_RSCONVERT_INFO	AcpiRsConvertPinGroupConfig []
ACPI_RSCONVERT_INFO	AcpiRsGetIrq []
ACPI_RSCONVERT_INFO	AcpiRsGetStartDpf []
ACPI_RSCONVERT_INFO	AcpiRsGetVendorSmall []
ACPI_RSCONVERT_INFO	AcpiRsGetVendorLarge []
ACPI_RSCONVERT_INFO	AcpiRsSetIrq []
ACPI_RSCONVERT_INFO	AcpiRsSetStartDpf []
ACPI_RSCONVERT_INFO	AcpiRsSetVendor []

Macro Definition Documentation

ACPI_RS_OFFSET

#define ACPI_RS_OFFSET

(

f

)

(UINT8) ACPI_OFFSET (ACPI_RESOURCE,f)

Definition at line 123 of file acresrc.h.

ACPI_RSC_COMPARE_AML_LENGTH

#define ACPI_RSC_COMPARE_AML_LENGTH   0

Definition at line 118 of file acresrc.h.

ACPI_RSC_COMPARE_VALUE

#define ACPI_RSC_COMPARE_VALUE   1

Definition at line 119 of file acresrc.h.

ACPI_RSC_TABLE_SIZE

#define ACPI_RSC_TABLE_SIZE

(

d

)

(sizeof (d) / sizeof (ACPI_RSCONVERT_INFO))

Definition at line 121 of file acresrc.h.

AML_OFFSET

#define AML_OFFSET

(

f

)

(UINT8) ACPI_OFFSET (AML_RESOURCE,f)

Definition at line 124 of file acresrc.h.

Typedef Documentation

ACPI_RSCONVERT_INFO

typedef const struct acpi_rsconvert_info ACPI_RSCONVERT_INFO

ACPI_RSDUMP_INFO

typedef const struct acpi_rsdump_info ACPI_RSDUMP_INFO

ACPI_VENDOR_WALK_INFO

typedef struct acpi_vendor_walk_info ACPI_VENDOR_WALK_INFO

Enumeration Type Documentation

ACPI_RSCONVERT_OPCODES

enum ACPI_RSCONVERT_OPCODES

Enumerator
ACPI_RSC_INITGET
ACPI_RSC_INITSET
ACPI_RSC_FLAGINIT
ACPI_RSC_1BITFLAG
ACPI_RSC_2BITFLAG
ACPI_RSC_3BITFLAG
ACPI_RSC_6BITFLAG
ACPI_RSC_ADDRESS
ACPI_RSC_BITMASK
ACPI_RSC_BITMASK16
ACPI_RSC_COUNT
ACPI_RSC_COUNT16
ACPI_RSC_COUNT_GPIO_PIN
ACPI_RSC_COUNT_GPIO_RES
ACPI_RSC_COUNT_GPIO_VEN
ACPI_RSC_COUNT_SERIAL_RES
ACPI_RSC_COUNT_SERIAL_VEN
ACPI_RSC_DATA8
ACPI_RSC_EXIT_EQ
ACPI_RSC_EXIT_LE
ACPI_RSC_EXIT_NE
ACPI_RSC_LENGTH
ACPI_RSC_MOVE_GPIO_PIN
ACPI_RSC_MOVE_GPIO_RES
ACPI_RSC_MOVE_SERIAL_RES
ACPI_RSC_MOVE_SERIAL_VEN
ACPI_RSC_MOVE8
ACPI_RSC_MOVE16
ACPI_RSC_MOVE32
ACPI_RSC_MOVE64
ACPI_RSC_SET8
ACPI_RSC_SOURCE
ACPI_RSC_SOURCEX

Definition at line 78 of file acresrc.h.

{
    ACPI_RSC_INITGET        = 0,
    ACPI_RSC_INITSET,
    ACPI_RSC_FLAGINIT,
    ACPI_RSC_1BITFLAG,
    ACPI_RSC_2BITFLAG,
    ACPI_RSC_3BITFLAG,
    ACPI_RSC_6BITFLAG,
    ACPI_RSC_ADDRESS,
    ACPI_RSC_BITMASK,
    ACPI_RSC_BITMASK16,
    ACPI_RSC_COUNT,
    ACPI_RSC_COUNT16,
    ACPI_RSC_COUNT_GPIO_PIN,
    ACPI_RSC_COUNT_GPIO_RES,
    ACPI_RSC_COUNT_GPIO_VEN,
    ACPI_RSC_COUNT_SERIAL_RES,
    ACPI_RSC_COUNT_SERIAL_VEN,
    ACPI_RSC_DATA8,
    ACPI_RSC_EXIT_EQ,
    ACPI_RSC_EXIT_LE,
    ACPI_RSC_EXIT_NE,
    ACPI_RSC_LENGTH,
    ACPI_RSC_MOVE_GPIO_PIN,
    ACPI_RSC_MOVE_GPIO_RES,
    ACPI_RSC_MOVE_SERIAL_RES,
    ACPI_RSC_MOVE_SERIAL_VEN,
    ACPI_RSC_MOVE8,
    ACPI_RSC_MOVE16,
    ACPI_RSC_MOVE32,
    ACPI_RSC_MOVE64,
    ACPI_RSC_SET8,
    ACPI_RSC_SOURCE,
    ACPI_RSC_SOURCEX
 
} ACPI_RSCONVERT_OPCODES;

ACPI_RSDUMP_OPCODES

enum ACPI_RSDUMP_OPCODES

Enumerator
ACPI_RSD_TITLE
ACPI_RSD_1BITFLAG
ACPI_RSD_2BITFLAG
ACPI_RSD_3BITFLAG
ACPI_RSD_6BITFLAG
ACPI_RSD_ADDRESS
ACPI_RSD_DWORDLIST
ACPI_RSD_LITERAL
ACPI_RSD_LONGLIST
ACPI_RSD_SHORTLIST
ACPI_RSD_SHORTLISTX
ACPI_RSD_SOURCE
ACPI_RSD_STRING
ACPI_RSD_UINT8
ACPI_RSD_UINT16
ACPI_RSD_UINT32
ACPI_RSD_UINT64
ACPI_RSD_WORDLIST
ACPI_RSD_LABEL
ACPI_RSD_SOURCE_LABEL

Definition at line 141 of file acresrc.h.

{
    ACPI_RSD_TITLE          = 0,
    ACPI_RSD_1BITFLAG,
    ACPI_RSD_2BITFLAG,
    ACPI_RSD_3BITFLAG,
    ACPI_RSD_6BITFLAG,
    ACPI_RSD_ADDRESS,
    ACPI_RSD_DWORDLIST,
    ACPI_RSD_LITERAL,
    ACPI_RSD_LONGLIST,
    ACPI_RSD_SHORTLIST,
    ACPI_RSD_SHORTLISTX,
    ACPI_RSD_SOURCE,
    ACPI_RSD_STRING,
    ACPI_RSD_UINT8,
    ACPI_RSD_UINT16,
    ACPI_RSD_UINT32,
    ACPI_RSD_UINT64,
    ACPI_RSD_WORDLIST,
    ACPI_RSD_LABEL,
    ACPI_RSD_SOURCE_LABEL,
 
} ACPI_RSDUMP_OPCODES;

Function Documentation

AcpiRsConvertAmlToResource()

ACPI_STATUS AcpiRsConvertAmlToResource	(	ACPI_RESOURCE *	Resource,
		AML_RESOURCE *	Aml,
		ACPI_RSCONVERT_INFO *	Info
	)

Definition at line 77 of file rsmisc.c.

{
    ACPI_RS_LENGTH          AmlResourceLength;
    void                    *Source;
    void                    *Destination;
    char                    *Target;
    UINT8                   Count;
    UINT8                   FlagsMode = FALSE;
    UINT16                  ItemCount = 0;
    UINT16                  Temp16 = 0;
 
 
    ACPI_FUNCTION_TRACE (RsConvertAmlToResource);
 
 
    if (!Info)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    if (((ACPI_SIZE) Resource) & 0x3)
    {
        /* Each internal resource struct is expected to be 32-bit aligned */
 
        ACPI_WARNING ((AE_INFO,
            "Misaligned resource pointer (get): %p Type 0x%2.2X Length %u",
            Resource, Resource->Type, Resource->Length));
    }
 
    /* Extract the resource Length field (does not include header length) */
 
    AmlResourceLength = AcpiUtGetResourceLength (Aml);
 
    /*
     * First table entry must be ACPI_RSC_INITxxx and must contain the
     * table length (# of table entries)
     */
    Count = INIT_TABLE_LENGTH (Info);
    while (Count)
    {
        Target = NULL;
 
        /*
         * Source is the external AML byte stream buffer,
         * destination is the internal resource descriptor
         */
        Source = ACPI_ADD_PTR (void, Aml, Info->AmlOffset);
        Destination = ACPI_ADD_PTR (void, Resource, Info->ResourceOffset);
 
        switch (Info->Opcode)
        {
        case ACPI_RSC_INITGET:
            /*
             * Get the resource type and the initial (minimum) length
             */
            memset (Resource, 0, INIT_RESOURCE_LENGTH (Info));
            Resource->Type = INIT_RESOURCE_TYPE (Info);
            Resource->Length = INIT_RESOURCE_LENGTH (Info);
            break;
 
        case ACPI_RSC_INITSET:
            break;
 
        case ACPI_RSC_FLAGINIT:
 
            FlagsMode = TRUE;
            break;
 
        case ACPI_RSC_1BITFLAG:
            /*
             * Mask and shift the flag bit
             */
            ACPI_SET8 (Destination,
                ((ACPI_GET8 (Source) >> Info->Value) & 0x01));
            break;
 
        case ACPI_RSC_2BITFLAG:
            /*
             * Mask and shift the flag bits
             */
            ACPI_SET8 (Destination,
                ((ACPI_GET8 (Source) >> Info->Value) & 0x03));
            break;
 
        case ACPI_RSC_3BITFLAG:
            /*
             * Mask and shift the flag bits
             */
            ACPI_SET8 (Destination,
                ((ACPI_GET8 (Source) >> Info->Value) & 0x07));
            break;
 
        case ACPI_RSC_6BITFLAG:
            /*
             * Mask and shift the flag bits
             */
            ACPI_SET8 (Destination,
                ((ACPI_GET8 (Source) >> Info->Value) & 0x3F));
            break;
 
        case ACPI_RSC_COUNT:
 
            ItemCount = ACPI_GET8 (Source);
            ACPI_SET8 (Destination, ItemCount);
 
            Resource->Length = Resource->Length +
                (Info->Value * (ItemCount - 1));
            break;
 
        case ACPI_RSC_COUNT16:
 
            ItemCount = AmlResourceLength;
            ACPI_SET16 (Destination, ItemCount);
 
            Resource->Length = Resource->Length +
                (Info->Value * (ItemCount - 1));
            break;
 
        case ACPI_RSC_COUNT_GPIO_PIN:
 
            Target = ACPI_ADD_PTR (void, Aml, Info->Value);
            ItemCount = ACPI_GET16 (Target) - ACPI_GET16 (Source);
 
            Resource->Length = Resource->Length + ItemCount;
            ItemCount = ItemCount / 2;
            ACPI_SET16 (Destination, ItemCount);
            break;
 
        case ACPI_RSC_COUNT_GPIO_VEN:
 
            ItemCount = ACPI_GET8 (Source);
            ACPI_SET8 (Destination, ItemCount);
 
            Resource->Length = Resource->Length + (Info->Value * ItemCount);
            break;
 
        case ACPI_RSC_COUNT_GPIO_RES:
            /*
             * Vendor data is optional (length/offset may both be zero)
             * Examine vendor data length field first
             */
            Target = ACPI_ADD_PTR (void, Aml, (Info->Value + 2));
            if (ACPI_GET16 (Target))
            {
                /* Use vendor offset to get resource source length */
 
                Target = ACPI_ADD_PTR (void, Aml, Info->Value);
                ItemCount = ACPI_GET16 (Target) - ACPI_GET16 (Source);
            }
            else
            {
                /* No vendor data to worry about */
 
                ItemCount = Aml->LargeHeader.ResourceLength +
                    sizeof (AML_RESOURCE_LARGE_HEADER) -
                    ACPI_GET16 (Source);
            }
 
            Resource->Length = Resource->Length + ItemCount;
            ACPI_SET16 (Destination, ItemCount);
            break;
 
        case ACPI_RSC_COUNT_SERIAL_VEN:
 
            ItemCount = ACPI_GET16 (Source) - Info->Value;
 
            Resource->Length = Resource->Length + ItemCount;
            ACPI_SET16 (Destination, ItemCount);
            break;
 
        case ACPI_RSC_COUNT_SERIAL_RES:
 
            ItemCount = (AmlResourceLength +
                sizeof (AML_RESOURCE_LARGE_HEADER)) -
                ACPI_GET16 (Source) - Info->Value;
 
            Resource->Length = Resource->Length + ItemCount;
            ACPI_SET16 (Destination, ItemCount);
            break;
 
        case ACPI_RSC_LENGTH:
 
            Resource->Length = Resource->Length + Info->Value;
            break;
 
        case ACPI_RSC_MOVE8:
        case ACPI_RSC_MOVE16:
        case ACPI_RSC_MOVE32:
        case ACPI_RSC_MOVE64:
            /*
             * Raw data move. Use the Info value field unless ItemCount has
             * been previously initialized via a COUNT opcode
             */
            if (Info->Value)
            {
                ItemCount = Info->Value;
            }
            AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
            break;
 
        case ACPI_RSC_MOVE_GPIO_PIN:
 
            /* Generate and set the PIN data pointer */
 
            Target = (char *) ACPI_ADD_PTR (void, Resource,
                (Resource->Length - ItemCount * 2));
            *(UINT16 **) Destination = ACPI_CAST_PTR (UINT16, Target);
 
            /* Copy the PIN data */
 
            Source = ACPI_ADD_PTR (void, Aml, ACPI_GET16 (Source));
            AcpiRsMoveData (Target, Source, ItemCount, Info->Opcode);
            break;
 
        case ACPI_RSC_MOVE_GPIO_RES:
 
            /* Generate and set the ResourceSource string pointer */
 
            Target = (char *) ACPI_ADD_PTR (void, Resource,
                (Resource->Length - ItemCount));
            *(UINT8 **) Destination = ACPI_CAST_PTR (UINT8, Target);
 
            /* Copy the ResourceSource string */
 
            Source = ACPI_ADD_PTR (void, Aml, ACPI_GET16 (Source));
            AcpiRsMoveData (Target, Source, ItemCount, Info->Opcode);
            break;
 
        case ACPI_RSC_MOVE_SERIAL_VEN:
 
            /* Generate and set the Vendor Data pointer */
 
            Target = (char *) ACPI_ADD_PTR (void, Resource,
                (Resource->Length - ItemCount));
            *(UINT8 **) Destination = ACPI_CAST_PTR (UINT8, Target);
 
            /* Copy the Vendor Data */
 
            Source = ACPI_ADD_PTR (void, Aml, Info->Value);
            AcpiRsMoveData (Target, Source, ItemCount, Info->Opcode);
            break;
 
        case ACPI_RSC_MOVE_SERIAL_RES:
 
            /* Generate and set the ResourceSource string pointer */
 
            Target = (char *) ACPI_ADD_PTR (void, Resource,
                (Resource->Length - ItemCount));
            *(UINT8 **) Destination = ACPI_CAST_PTR (UINT8, Target);
 
            /* Copy the ResourceSource string */
 
            Source = ACPI_ADD_PTR (
                void, Aml, (ACPI_GET16 (Source) + Info->Value));
            AcpiRsMoveData (Target, Source, ItemCount, Info->Opcode);
            break;
 
        case ACPI_RSC_SET8:
 
            memset (Destination, Info->AmlOffset, Info->Value);
            break;
 
        case ACPI_RSC_DATA8:
 
            Target = ACPI_ADD_PTR (char, Resource, Info->Value);
            memcpy (Destination, Source,  ACPI_GET16 (Target));
            break;
 
        case ACPI_RSC_ADDRESS:
            /*
             * Common handler for address descriptor flags
             */
            if (!AcpiRsGetAddressCommon (Resource, Aml))
            {
                return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
            }
            break;
 
        case ACPI_RSC_SOURCE:
            /*
             * Optional ResourceSource (Index and String)
             */
            Resource->Length +=
                AcpiRsGetResourceSource (AmlResourceLength, Info->Value,
                    Destination, Aml, NULL);
            break;
 
        case ACPI_RSC_SOURCEX:
            /*
             * Optional ResourceSource (Index and String). This is the more
             * complicated case used by the Interrupt() macro
             */
            Target = ACPI_ADD_PTR (char, Resource,
                Info->AmlOffset + (ItemCount * 4));
 
            Resource->Length +=
                AcpiRsGetResourceSource (AmlResourceLength, (ACPI_RS_LENGTH)
                    (((ItemCount - 1) * sizeof (UINT32)) + Info->Value),
                    Destination, Aml, Target);
            break;
 
        case ACPI_RSC_BITMASK:
            /*
             * 8-bit encoded bitmask (DMA macro)
             */
            ItemCount = AcpiRsDecodeBitmask (ACPI_GET8 (Source), Destination);
            if (ItemCount)
            {
                Resource->Length += (ItemCount - 1);
            }
 
            Target = ACPI_ADD_PTR (char, Resource, Info->Value);
            ACPI_SET8 (Target, ItemCount);
            break;
 
        case ACPI_RSC_BITMASK16:
            /*
             * 16-bit encoded bitmask (IRQ macro)
             */
            ACPI_MOVE_16_TO_16 (&Temp16, Source);
 
            ItemCount = AcpiRsDecodeBitmask (Temp16, Destination);
            if (ItemCount)
            {
                Resource->Length += (ItemCount - 1);
            }
 
            Target = ACPI_ADD_PTR (char, Resource, Info->Value);
            ACPI_SET8 (Target, ItemCount);
            break;
 
        case ACPI_RSC_EXIT_NE:
            /*
             * Control - Exit conversion if not equal
             */
            switch (Info->ResourceOffset)
            {
            case ACPI_RSC_COMPARE_AML_LENGTH:
 
                if (AmlResourceLength != Info->Value)
                {
                    goto Exit;
                }
                break;
 
            case ACPI_RSC_COMPARE_VALUE:
 
                if (ACPI_GET8 (Source) != Info->Value)
                {
                    goto Exit;
                }
                break;
 
            default:
 
                ACPI_ERROR ((AE_INFO, "Invalid conversion sub-opcode"));
                return_ACPI_STATUS (AE_BAD_PARAMETER);
            }
            break;
 
        default:
 
            ACPI_ERROR ((AE_INFO, "Invalid conversion opcode"));
            return_ACPI_STATUS (AE_BAD_PARAMETER);
        }
 
        Count--;
        Info++;
    }
 
Exit:
    if (!FlagsMode)
    {
        /* Round the resource struct length up to the next boundary (32 or 64) */
 
        Resource->Length = (UINT32)
            ACPI_ROUND_UP_TO_NATIVE_WORD (Resource->Length);
    }
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiRsConvertAmlToResources(), and AcpiRsGetAddressCommon().

AcpiRsConvertAmlToResources()

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

Definition at line 68 of file rslist.c.

{
    ACPI_RESOURCE           **ResourcePtr = ACPI_CAST_INDIRECT_PTR (
                                ACPI_RESOURCE, Context);
    ACPI_RESOURCE           *Resource;
    AML_RESOURCE            *AmlResource;
    ACPI_RSCONVERT_INFO     *ConversionTable;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (RsConvertAmlToResources);
 
 
    /*
     * Check that the input buffer and all subsequent pointers into it
     * are aligned on a native word boundary. Most important on IA64
     */
    Resource = *ResourcePtr;
    if (ACPI_IS_MISALIGNED (Resource))
    {
        ACPI_WARNING ((AE_INFO,
            "Misaligned resource pointer %p", Resource));
    }
 
    /* Get the appropriate conversion info table */
 
    AmlResource = ACPI_CAST_PTR (AML_RESOURCE, Aml);
 
    if (AcpiUtGetResourceType (Aml) ==
        ACPI_RESOURCE_NAME_SERIAL_BUS)
    {
        if (AmlResource->CommonSerialBus.Type >
            AML_RESOURCE_MAX_SERIALBUSTYPE)
        {
            ConversionTable = NULL;
        }
        else
        {
            /* This is an I2C, SPI, UART, or CSI2 SerialBus descriptor */
 
            ConversionTable = AcpiGbl_ConvertResourceSerialBusDispatch [
                AmlResource->CommonSerialBus.Type];
        }
    }
    else
    {
        ConversionTable = AcpiGbl_GetResourceDispatch[ResourceIndex];
    }
 
    if (!ConversionTable)
    {
        ACPI_ERROR ((AE_INFO,
            "Invalid/unsupported resource descriptor: Type 0x%2.2X",
            ResourceIndex));
        return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
    }
 
     /* Convert the AML byte stream resource to a local resource struct */
 
    Status = AcpiRsConvertAmlToResource (
        Resource, AmlResource, ConversionTable);
    if (ACPI_FAILURE (Status))
    {
        ACPI_EXCEPTION ((AE_INFO, Status,
            "Could not convert AML resource (Type 0x%X)", *Aml));
        return_ACPI_STATUS (Status);
    }
 
    if (!Resource->Length)
    {
        ACPI_EXCEPTION ((AE_INFO, Status,
            "Zero-length resource returned from RsConvertAmlToResource"));
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_RESOURCES,
        "Type %.2X, AmlLength %.2X InternalLength %.2X\n",
        AcpiUtGetResourceType (Aml), Length,
        Resource->Length));
 
    /* Point to the next structure in the output buffer */
 
    *ResourcePtr = ACPI_NEXT_RESOURCE (Resource);
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiBufferToResource(), and AcpiRsCreateResourceList().

AcpiRsConvertResourcesToAml()

ACPI_STATUS AcpiRsConvertResourcesToAml	(	ACPI_RESOURCE *	Resource,
		ACPI_SIZE	AmlSizeNeeded,
		UINT8 *	OutputBuffer
	)

Definition at line 179 of file rslist.c.

{
    UINT8                   *Aml = OutputBuffer;
    UINT8                   *EndAml = OutputBuffer + AmlSizeNeeded;
    ACPI_RSCONVERT_INFO     *ConversionTable;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (RsConvertResourcesToAml);
 
 
    /* Walk the resource descriptor list, convert each descriptor */
 
    while (Aml < EndAml)
    {
        /* Validate the (internal) Resource Type */
 
        if (Resource->Type > ACPI_RESOURCE_TYPE_MAX)
        {
            ACPI_ERROR ((AE_INFO,
                "Invalid descriptor type (0x%X) in resource list",
                Resource->Type));
            return_ACPI_STATUS (AE_BAD_DATA);
        }
 
        /* Sanity check the length. It must not be zero, or we loop forever */
 
        if (!Resource->Length)
        {
            ACPI_ERROR ((AE_INFO,
                "Invalid zero length descriptor in resource list\n"));
            return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH);
        }
 
        /* Perform the conversion */
 
        if (Resource->Type == ACPI_RESOURCE_TYPE_SERIAL_BUS)
        {
            if (Resource->Data.CommonSerialBus.Type >
                AML_RESOURCE_MAX_SERIALBUSTYPE)
            {
                ConversionTable = NULL;
            }
            else
            {
                /* This is an I2C, SPI, UART or CSI2 SerialBus descriptor */
 
                ConversionTable = AcpiGbl_ConvertResourceSerialBusDispatch[
                    Resource->Data.CommonSerialBus.Type];
            }
        }
        else
        {
            ConversionTable = AcpiGbl_SetResourceDispatch[Resource->Type];
        }
 
        if (!ConversionTable)
        {
            ACPI_ERROR ((AE_INFO,
                "Invalid/unsupported resource descriptor: Type 0x%2.2X",
                Resource->Type));
            return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
        }
 
        Status = AcpiRsConvertResourceToAml (Resource,
            ACPI_CAST_PTR (AML_RESOURCE, Aml), ConversionTable);
        if (ACPI_FAILURE (Status))
        {
            ACPI_EXCEPTION ((AE_INFO, Status,
                "Could not convert resource (type 0x%X) to AML",
                Resource->Type));
            return_ACPI_STATUS (Status);
        }
 
        /* Perform final sanity check on the new AML resource descriptor */
 
        Status = AcpiUtValidateResource (
            NULL, ACPI_CAST_PTR (AML_RESOURCE, Aml), NULL);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        /* Check for end-of-list, normal exit */
 
        if (Resource->Type == ACPI_RESOURCE_TYPE_END_TAG)
        {
            /* An End Tag indicates the end of the input Resource Template */
 
            return_ACPI_STATUS (AE_OK);
        }
 
        /*
         * Extract the total length of the new descriptor and set the
         * Aml to point to the next (output) resource descriptor
         */
        Aml += AcpiUtGetDescriptorLength (Aml);
 
        /* Point to the next input resource descriptor */
 
        Resource = ACPI_NEXT_RESOURCE (Resource);
    }
 
    /* Completed buffer, but did not find an EndTag resource descriptor */
 
    return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
}

Referenced by AcpiRsCreateAmlResources().

AcpiRsConvertResourceToAml()

ACPI_STATUS AcpiRsConvertResourceToAml	(	ACPI_RESOURCE *	Resource,
		AML_RESOURCE *	Aml,
		ACPI_RSCONVERT_INFO *	Info
	)

Definition at line 478 of file rsmisc.c.

{
    void                    *Source = NULL;
    void                    *Destination;
    char                    *Target;
    ACPI_RSDESC_SIZE        AmlLength = 0;
    UINT8                   Count;
    UINT16                  Temp16 = 0;
    UINT16                  ItemCount = 0;
 
 
    ACPI_FUNCTION_TRACE (RsConvertResourceToAml);
 
 
    if (!Info)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /*
     * First table entry must be ACPI_RSC_INITxxx and must contain the
     * table length (# of table entries)
     */
    Count = INIT_TABLE_LENGTH (Info);
 
    while (Count)
    {
        /*
         * Source is the internal resource descriptor,
         * destination is the external AML byte stream buffer
         */
        Source = ACPI_ADD_PTR (void, Resource, Info->ResourceOffset);
        Destination = ACPI_ADD_PTR (void, Aml, Info->AmlOffset);
 
        switch (Info->Opcode)
        {
        case ACPI_RSC_INITSET:
 
            memset (Aml, 0, INIT_RESOURCE_LENGTH (Info));
            AmlLength = INIT_RESOURCE_LENGTH (Info);
            AcpiRsSetResourceHeader (
                INIT_RESOURCE_TYPE (Info), AmlLength, Aml);
            break;
 
        case ACPI_RSC_INITGET:
            break;
 
        case ACPI_RSC_FLAGINIT:
            /*
             * Clear the flag byte
             */
            ACPI_SET8 (Destination, 0);
            break;
 
        case ACPI_RSC_1BITFLAG:
            /*
             * Mask and shift the flag bit
             */
            ACPI_SET_BIT (*ACPI_CAST8 (Destination), (UINT8)
                ((ACPI_GET8 (Source) & 0x01) << Info->Value));
            break;
 
        case ACPI_RSC_2BITFLAG:
            /*
             * Mask and shift the flag bits
             */
            ACPI_SET_BIT (*ACPI_CAST8 (Destination), (UINT8)
                ((ACPI_GET8 (Source) & 0x03) << Info->Value));
            break;
 
        case ACPI_RSC_3BITFLAG:
            /*
             * Mask and shift the flag bits
             */
            ACPI_SET_BIT (*ACPI_CAST8 (Destination), (UINT8)
                ((ACPI_GET8 (Source) & 0x07) << Info->Value));
            break;
 
        case ACPI_RSC_6BITFLAG:
            /*
             * Mask and shift the flag bits
             */
            ACPI_SET_BIT (*ACPI_CAST8 (Destination), (UINT8)
                ((ACPI_GET8 (Source) & 0x3F) << Info->Value));
            break;
 
        case ACPI_RSC_COUNT:
 
            ItemCount = ACPI_GET8 (Source);
            ACPI_SET8 (Destination, ItemCount);
 
            AmlLength = (UINT16)
                (AmlLength + (Info->Value * (ItemCount - 1)));
            break;
 
        case ACPI_RSC_COUNT16:
 
            ItemCount = ACPI_GET16 (Source);
            AmlLength = (UINT16) (AmlLength + ItemCount);
            AcpiRsSetResourceLength (AmlLength, Aml);
            break;
 
        case ACPI_RSC_COUNT_GPIO_PIN:
 
            ItemCount = ACPI_GET16 (Source);
            ACPI_SET16 (Destination, AmlLength);
 
            AmlLength = (UINT16) (AmlLength + ItemCount * 2);
            Target = ACPI_ADD_PTR (void, Aml, Info->Value);
            ACPI_SET16 (Target, AmlLength);
            AcpiRsSetResourceLength (AmlLength, Aml);
            break;
 
        case ACPI_RSC_COUNT_GPIO_VEN:
 
            ItemCount = ACPI_GET16 (Source);
            ACPI_SET16 (Destination, ItemCount);
 
            AmlLength = (UINT16) (
                AmlLength + (Info->Value * ItemCount));
            AcpiRsSetResourceLength (AmlLength, Aml);
            break;
 
        case ACPI_RSC_COUNT_GPIO_RES:
 
            /* Set resource source string length */
 
            ItemCount = ACPI_GET16 (Source);
            ACPI_SET16 (Destination, AmlLength);
 
            /* Compute offset for the Vendor Data */
 
            AmlLength = (UINT16) (AmlLength + ItemCount);
            Target = ACPI_ADD_PTR (void, Aml, Info->Value);
 
            /* Set vendor offset only if there is vendor data */
 
            ACPI_SET16 (Target, AmlLength);
 
            AcpiRsSetResourceLength (AmlLength, Aml);
            break;
 
        case ACPI_RSC_COUNT_SERIAL_VEN:
 
            ItemCount = ACPI_GET16 (Source);
            ACPI_SET16 (Destination, ItemCount + Info->Value);
            AmlLength = (UINT16) (AmlLength + ItemCount);
            AcpiRsSetResourceLength (AmlLength, Aml);
            break;
 
        case ACPI_RSC_COUNT_SERIAL_RES:
 
            ItemCount = ACPI_GET16 (Source);
            AmlLength = (UINT16) (AmlLength + ItemCount);
            AcpiRsSetResourceLength (AmlLength, Aml);
            break;
 
        case ACPI_RSC_LENGTH:
 
            AcpiRsSetResourceLength (Info->Value, Aml);
            break;
 
        case ACPI_RSC_MOVE8:
        case ACPI_RSC_MOVE16:
        case ACPI_RSC_MOVE32:
        case ACPI_RSC_MOVE64:
 
            if (Info->Value)
            {
                ItemCount = Info->Value;
            }
            AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
            break;
 
        case ACPI_RSC_MOVE_GPIO_PIN:
 
            Destination = (char *) ACPI_ADD_PTR (void, Aml,
                ACPI_GET16 (Destination));
            Source = * (UINT16 **) Source;
            AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
            break;
 
        case ACPI_RSC_MOVE_GPIO_RES:
 
            /* Used for both ResourceSource string and VendorData */
 
            Destination = (char *) ACPI_ADD_PTR (void, Aml,
                ACPI_GET16 (Destination));
            Source = * (UINT8 **) Source;
            AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
            break;
 
        case ACPI_RSC_MOVE_SERIAL_VEN:
 
            Destination = (char *) ACPI_ADD_PTR (void, Aml,
                (AmlLength - ItemCount));
            Source = * (UINT8 **) Source;
            AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
            break;
 
        case ACPI_RSC_MOVE_SERIAL_RES:
 
            Destination = (char *) ACPI_ADD_PTR (void, Aml,
                (AmlLength - ItemCount));
            Source = * (UINT8 **) Source;
            AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
            break;
 
        case ACPI_RSC_ADDRESS:
 
            /* Set the Resource Type, General Flags, and Type-Specific Flags */
 
            AcpiRsSetAddressCommon (Aml, Resource);
            break;
 
        case ACPI_RSC_SOURCEX:
            /*
             * Optional ResourceSource (Index and String)
             */
            AmlLength = AcpiRsSetResourceSource (
                Aml, (ACPI_RS_LENGTH) AmlLength, Source);
            AcpiRsSetResourceLength (AmlLength, Aml);
            break;
 
        case ACPI_RSC_SOURCE:
            /*
             * Optional ResourceSource (Index and String). This is the more
             * complicated case used by the Interrupt() macro
             */
            AmlLength = AcpiRsSetResourceSource (Aml, Info->Value, Source);
            AcpiRsSetResourceLength (AmlLength, Aml);
            break;
 
        case ACPI_RSC_BITMASK:
            /*
             * 8-bit encoded bitmask (DMA macro)
             */
            ACPI_SET8 (Destination,
                AcpiRsEncodeBitmask (Source,
                    *ACPI_ADD_PTR (UINT8, Resource, Info->Value)));
            break;
 
        case ACPI_RSC_BITMASK16:
            /*
             * 16-bit encoded bitmask (IRQ macro)
             */
            Temp16 = AcpiRsEncodeBitmask (
                Source, *ACPI_ADD_PTR (UINT8, Resource, Info->Value));
            ACPI_MOVE_16_TO_16 (Destination, &Temp16);
            break;
 
        case ACPI_RSC_EXIT_LE:
            /*
             * Control - Exit conversion if less than or equal
             */
            if (ItemCount <= Info->Value)
            {
                goto Exit;
            }
            break;
 
        case ACPI_RSC_EXIT_NE:
            /*
             * Control - Exit conversion if not equal
             */
            switch (COMPARE_OPCODE (Info))
            {
            case ACPI_RSC_COMPARE_VALUE:
 
                if (*ACPI_ADD_PTR (UINT8, Resource,
                    COMPARE_TARGET (Info)) != COMPARE_VALUE (Info))
                {
                    goto Exit;
                }
                break;
 
            default:
 
                ACPI_ERROR ((AE_INFO, "Invalid conversion sub-opcode"));
                return_ACPI_STATUS (AE_BAD_PARAMETER);
            }
            break;
 
        case ACPI_RSC_EXIT_EQ:
            /*
             * Control - Exit conversion if equal
             */
            if (*ACPI_ADD_PTR (UINT8, Resource,
                COMPARE_TARGET (Info)) == COMPARE_VALUE (Info))
            {
                goto Exit;
            }
            break;
 
        default:
 
            ACPI_ERROR ((AE_INFO, "Invalid conversion opcode"));
            return_ACPI_STATUS (AE_BAD_PARAMETER);
        }
 
        Count--;
        Info++;
    }
 
Exit:
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiRsConvertResourcesToAml(), and AcpiRsSetAddressCommon().

AcpiRsCreateAmlResources()

ACPI_STATUS AcpiRsCreateAmlResources	(	ACPI_BUFFER *	ResourceList,
		ACPI_BUFFER *	OutputBuffer
	)

Definition at line 462 of file rscreate.c.

{
    ACPI_STATUS             Status;
    ACPI_SIZE               AmlSizeNeeded = 0;
 
 
    ACPI_FUNCTION_TRACE (RsCreateAmlResources);
 
 
    /* Params already validated, no need to re-validate here */
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ResourceList Buffer = %p\n",
        ResourceList->Pointer));
 
    /* Get the buffer size needed for the AML byte stream */
 
    Status = AcpiRsGetAmlLength (
        ResourceList->Pointer, ResourceList->Length, &AmlSizeNeeded);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "AmlSizeNeeded=%X, %s\n",
        (UINT32) AmlSizeNeeded, AcpiFormatException (Status)));
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Validate/Allocate/Clear caller buffer */
 
    Status = AcpiUtInitializeBuffer (OutputBuffer, AmlSizeNeeded);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Do the conversion */
 
    Status = AcpiRsConvertResourcesToAml (ResourceList->Pointer,
        AmlSizeNeeded, OutputBuffer->Pointer);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
        OutputBuffer->Pointer, (UINT32) OutputBuffer->Length));
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiRsSetSrsMethodData().

AcpiRsCreatePciRoutingTable()

ACPI_STATUS AcpiRsCreatePciRoutingTable	(	ACPI_OPERAND_OBJECT *	PackageObject,
		ACPI_BUFFER *	OutputBuffer
	)

Definition at line 234 of file rscreate.c.

{
    UINT8                   *Buffer;
    ACPI_OPERAND_OBJECT     **TopObjectList;
    ACPI_OPERAND_OBJECT     **SubObjectList;
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_SIZE               BufferSizeNeeded = 0;
    UINT32                  NumberOfElements;
    UINT32                  Index;
    ACPI_PCI_ROUTING_TABLE  *UserPrt;
    ACPI_NAMESPACE_NODE     *Node;
    ACPI_STATUS             Status;
    ACPI_BUFFER             PathBuffer;
 
 
    ACPI_FUNCTION_TRACE (RsCreatePciRoutingTable);
 
 
    /* Params already validated, so we don't re-validate here */
 
    /* Get the required buffer length */
 
    Status = AcpiRsGetPciRoutingTableLength (
        PackageObject,&BufferSizeNeeded);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "BufferSizeNeeded = %X\n",
        (UINT32) BufferSizeNeeded));
 
    /* Validate/Allocate/Clear caller buffer */
 
    Status = AcpiUtInitializeBuffer (OutputBuffer, BufferSizeNeeded);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Loop through the ACPI_INTERNAL_OBJECTS - Each object should be a
     * package that in turn contains an UINT64 Address, a UINT8 Pin,
     * a Name, and a UINT8 SourceIndex.
     */
    TopObjectList = PackageObject->Package.Elements;
    NumberOfElements = PackageObject->Package.Count;
    Buffer = OutputBuffer->Pointer;
    UserPrt = ACPI_CAST_PTR (ACPI_PCI_ROUTING_TABLE, Buffer);
 
    for (Index = 0; Index < NumberOfElements; Index++)
    {
        /*
         * Point UserPrt past this current structure
         *
         * NOTE: On the first iteration, UserPrt->Length will
         * be zero because we cleared the return buffer earlier
         */
        Buffer += UserPrt->Length;
        UserPrt = ACPI_CAST_PTR (ACPI_PCI_ROUTING_TABLE, Buffer);
 
        /*
         * Fill in the Length field with the information we have at this
         * point. The minus four is to subtract the size of the UINT8
         * Source[4] member because it is added below.
         */
        UserPrt->Length = (sizeof (ACPI_PCI_ROUTING_TABLE) - 4);
 
        /* Each subpackage must be of length 4 */
 
        if ((*TopObjectList)->Package.Count != 4)
        {
            ACPI_ERROR ((AE_INFO,
                "(PRT[%u]) Need package of length 4, found length %u",
                Index, (*TopObjectList)->Package.Count));
            return_ACPI_STATUS (AE_AML_PACKAGE_LIMIT);
        }
 
        /*
         * Dereference the subpackage.
         * The SubObjectList will now point to an array of the four IRQ
         * elements: [Address, Pin, Source, SourceIndex]
         */
        SubObjectList = (*TopObjectList)->Package.Elements;
 
        /* 1) First subobject: Dereference the PRT.Address */
 
        ObjDesc = SubObjectList[0];
        if (!ObjDesc || ObjDesc->Common.Type != ACPI_TYPE_INTEGER)
        {
            ACPI_ERROR ((AE_INFO,
                "(PRT[%u].Address) Need Integer, found %s",
                Index, AcpiUtGetObjectTypeName (ObjDesc)));
            return_ACPI_STATUS (AE_BAD_DATA);
        }
 
        UserPrt->Address = ObjDesc->Integer.Value;
 
        /* 2) Second subobject: Dereference the PRT.Pin */
 
        ObjDesc = SubObjectList[1];
        if (!ObjDesc || ObjDesc->Common.Type != ACPI_TYPE_INTEGER)
        {
            ACPI_ERROR ((AE_INFO, "(PRT[%u].Pin) Need Integer, found %s",
                Index, AcpiUtGetObjectTypeName (ObjDesc)));
            return_ACPI_STATUS (AE_BAD_DATA);
        }
 
        UserPrt->Pin = (UINT32) ObjDesc->Integer.Value;
 
        /*
         * 3) Third subobject: Dereference the PRT.SourceName
         * The name may be unresolved (slack mode), so allow a null object
         */
        ObjDesc = SubObjectList[2];
        if (ObjDesc)
        {
            switch (ObjDesc->Common.Type)
            {
            case ACPI_TYPE_LOCAL_REFERENCE:
 
                if (ObjDesc->Reference.Class != ACPI_REFCLASS_NAME)
                {
                    ACPI_ERROR ((AE_INFO,
                        "(PRT[%u].Source) Need name, found Reference Class 0x%X",
                        Index, ObjDesc->Reference.Class));
                    return_ACPI_STATUS (AE_BAD_DATA);
                }
 
                Node = ObjDesc->Reference.Node;
 
                /* Use *remaining* length of the buffer as max for pathname */
 
                PathBuffer.Length = OutputBuffer->Length -
                    (UINT32) ((UINT8 *) UserPrt->Source -
                    (UINT8 *) OutputBuffer->Pointer);
                PathBuffer.Pointer = UserPrt->Source;
 
                Status = AcpiNsHandleToPathname (
                    (ACPI_HANDLE) Node, &PathBuffer, FALSE);
                if (ACPI_FAILURE (Status))
                {
                    return_ACPI_STATUS (Status);
                }
 
                /* +1 to include null terminator */
 
                UserPrt->Length += (UINT32) strlen (UserPrt->Source) + 1;
                break;
 
            case ACPI_TYPE_STRING:
 
                strcpy (UserPrt->Source, ObjDesc->String.Pointer);
 
                /*
                 * Add to the Length field the length of the string
                 * (add 1 for terminator)
                 */
                UserPrt->Length += ObjDesc->String.Length + 1;
                break;
 
            case ACPI_TYPE_INTEGER:
                /*
                 * If this is a number, then the Source Name is NULL, since
                 * the entire buffer was zeroed out, we can leave this alone.
                 *
                 * Add to the Length field the length of the UINT32 NULL
                 */
                UserPrt->Length += sizeof (UINT32);
                break;
 
            default:
 
               ACPI_ERROR ((AE_INFO,
                   "(PRT[%u].Source) Need Ref/String/Integer, found %s",
                   Index, AcpiUtGetObjectTypeName (ObjDesc)));
               return_ACPI_STATUS (AE_BAD_DATA);
            }
        }
 
        /* Now align the current length */
 
        UserPrt->Length = (UINT32) ACPI_ROUND_UP_TO_64BIT (UserPrt->Length);
 
        /* 4) Fourth subobject: Dereference the PRT.SourceIndex */
 
        ObjDesc = SubObjectList[3];
        if (!ObjDesc || ObjDesc->Common.Type != ACPI_TYPE_INTEGER)
        {
            ACPI_ERROR ((AE_INFO,
                "(PRT[%u].SourceIndex) Need Integer, found %s",
                Index, AcpiUtGetObjectTypeName (ObjDesc)));
            return_ACPI_STATUS (AE_BAD_DATA);
        }
 
        UserPrt->SourceIndex = (UINT32) ObjDesc->Integer.Value;
 
        /* Point to the next ACPI_OPERAND_OBJECT in the top level package */
 
        TopObjectList++;
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
        OutputBuffer->Pointer, (UINT32) OutputBuffer->Length));
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiRsGetPrtMethodData().

AcpiRsCreateResourceList()

ACPI_STATUS AcpiRsCreateResourceList	(	ACPI_OPERAND_OBJECT *	AmlBuffer,
		ACPI_BUFFER *	OutputBuffer
	)

Definition at line 151 of file rscreate.c.

{
 
    ACPI_STATUS             Status;
    UINT8                   *AmlStart;
    ACPI_SIZE               ListSizeNeeded = 0;
    UINT32                  AmlBufferLength;
    void                    *Resource;
 
 
    ACPI_FUNCTION_TRACE (RsCreateResourceList);
 
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "AmlBuffer = %p\n",
        AmlBuffer));
 
    /* Params already validated, so we don't re-validate here */
 
    AmlBufferLength = AmlBuffer->Buffer.Length;
    AmlStart = AmlBuffer->Buffer.Pointer;
 
    /*
     * Pass the AmlBuffer into a module that can calculate
     * the buffer size needed for the linked list
     */
    Status = AcpiRsGetListLength (AmlStart, AmlBufferLength,
                &ListSizeNeeded);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Status=%X ListSizeNeeded=%X\n",
        Status, (UINT32) ListSizeNeeded));
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Validate/Allocate/Clear caller buffer */
 
    Status = AcpiUtInitializeBuffer (OutputBuffer, ListSizeNeeded);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Do the conversion */
 
    Resource = OutputBuffer->Pointer;
    Status = AcpiUtWalkAmlResources (NULL, AmlStart, AmlBufferLength,
        AcpiRsConvertAmlToResources, &Resource);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
        OutputBuffer->Pointer, (UINT32) OutputBuffer->Length));
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiRsGetAeiMethodData(), AcpiRsGetCrsMethodData(), AcpiRsGetMethodData(), and AcpiRsGetPrsMethodData().

AcpiRsDecodeBitmask()

UINT8 AcpiRsDecodeBitmask	(	UINT16	Mask,
		UINT8 *	List
	)

Definition at line 68 of file rsutils.c.

{
    UINT8                   i;
    UINT8                   BitCount;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Decode the mask bits */
 
    for (i = 0, BitCount = 0; Mask; i++)
    {
        if (Mask & 0x0001)
        {
            List[BitCount] = i;
            BitCount++;
        }
 
        Mask >>= 1;
    }
 
    return (BitCount);
}

Referenced by AcpiRsConvertAmlToResource().

AcpiRsEncodeBitmask()

UINT16 AcpiRsEncodeBitmask	(	UINT8 *	List,
		UINT8	Count
	)

Definition at line 110 of file rsutils.c.

{
    UINT32                  i;
    UINT16                  Mask;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Encode the list into a single bitmask */
 
    for (i = 0, Mask = 0; i < Count; i++)
    {
        Mask |= (0x1 << List[i]);
    }
 
    return (Mask);
}

Referenced by AcpiRsConvertResourceToAml().

AcpiRsGetAddressCommon()

BOOLEAN AcpiRsGetAddressCommon	(	ACPI_RESOURCE *	Resource,
		AML_RESOURCE *	Aml
	)

Definition at line 322 of file rsaddr.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Validate the Resource Type */
 
    if ((Aml->Address.ResourceType > 2) &&
        (Aml->Address.ResourceType < 0xC0))
    {
        return (FALSE);
    }
 
    /* Get the Resource Type and General Flags */
 
    (void) AcpiRsConvertAmlToResource (
        Resource, Aml, AcpiRsConvertGeneralFlags);
 
    /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
 
    if (Resource->Data.Address.ResourceType == ACPI_MEMORY_RANGE)
    {
        (void) AcpiRsConvertAmlToResource (
            Resource, Aml, AcpiRsConvertMemFlags);
    }
    else if (Resource->Data.Address.ResourceType == ACPI_IO_RANGE)
    {
        (void) AcpiRsConvertAmlToResource (
            Resource, Aml, AcpiRsConvertIoFlags);
    }
    else
    {
        /* Generic resource type, just grab the TypeSpecific byte */
 
        Resource->Data.Address.Info.TypeSpecific =
            Aml->Address.SpecificFlags;
    }
 
    return (TRUE);
}

Referenced by AcpiRsConvertAmlToResource().

AcpiRsGetAeiMethodData()

ACPI_STATUS AcpiRsGetAeiMethodData	(	ACPI_NAMESPACE_NODE *	Node,
		ACPI_BUFFER *	RetBuffer
	)

Definition at line 685 of file rsutils.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (RsGetAeiMethodData);
 
 
    /* Parameters guaranteed valid by caller */
 
    /* Execute the method, no parameters */
 
    Status = AcpiUtEvaluateObject (
        Node, METHOD_NAME__AEI, ACPI_BTYPE_BUFFER, &ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Make the call to create a resource linked list from the
     * byte stream buffer that comes back from the _CRS method
     * execution.
     */
    Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
 
    /* On exit, we must delete the object returned by evaluateObject */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiGetEventResources().

AcpiRsGetAmlLength()

ACPI_STATUS AcpiRsGetAmlLength	(	ACPI_RESOURCE *	ResourceList,
		ACPI_SIZE	ResourceListSize,
		ACPI_SIZE *	SizeNeeded
	)

Definition at line 211 of file rscalc.c.

{
    ACPI_SIZE               AmlSizeNeeded = 0;
    ACPI_RESOURCE           *ResourceEnd;
    ACPI_RS_LENGTH          TotalSize;
 
 
    ACPI_FUNCTION_TRACE (RsGetAmlLength);
 
 
    /* Traverse entire list of internal resource descriptors */
 
    ResourceEnd = ACPI_ADD_PTR (ACPI_RESOURCE, Resource, ResourceListSize);
    while (Resource < ResourceEnd)
    {
        /* Validate the descriptor type */
 
        if (Resource->Type > ACPI_RESOURCE_TYPE_MAX)
        {
            return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
        }
 
        /* Sanity check the length. It must not be zero, or we loop forever */
 
        if (!Resource->Length)
        {
            return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH);
        }
 
        /* Get the base size of the (external stream) resource descriptor */
 
        TotalSize = AcpiGbl_AmlResourceSizes [Resource->Type];
 
        /*
         * Augment the base size for descriptors with optional and/or
         * variable-length fields
         */
        switch (Resource->Type)
        {
        case ACPI_RESOURCE_TYPE_IRQ:
 
            /* Length can be 3 or 2 */
 
            if (Resource->Data.Irq.DescriptorLength == 2)
            {
                TotalSize--;
            }
            break;
 
 
        case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 
            /* Length can be 1 or 0 */
 
            if (Resource->Data.Irq.DescriptorLength == 0)
            {
                TotalSize--;
            }
            break;
 
 
        case ACPI_RESOURCE_TYPE_VENDOR:
            /*
             * Vendor Defined Resource:
             * For a Vendor Specific resource, if the Length is between 1 and 7
             * it will be created as a Small Resource data type, otherwise it
             * is a Large Resource data type.
             */
            if (Resource->Data.Vendor.ByteLength > 7)
            {
                /* Base size of a Large resource descriptor */
 
                TotalSize = sizeof (AML_RESOURCE_LARGE_HEADER);
            }
 
            /* Add the size of the vendor-specific data */
 
            TotalSize = (ACPI_RS_LENGTH)
                (TotalSize + Resource->Data.Vendor.ByteLength);
            break;
 
 
        case ACPI_RESOURCE_TYPE_END_TAG:
            /*
             * End Tag:
             * We are done -- return the accumulated total size.
             */
            *SizeNeeded = AmlSizeNeeded + TotalSize;
 
            /* Normal exit */
 
            return_ACPI_STATUS (AE_OK);
 
 
        case ACPI_RESOURCE_TYPE_ADDRESS16:
            /*
             * 16-Bit Address Resource:
             * Add the size of the optional ResourceSource info
             */
            TotalSize = (ACPI_RS_LENGTH) (TotalSize +
                AcpiRsStructOptionLength (
                    &Resource->Data.Address16.ResourceSource));
            break;
 
 
        case ACPI_RESOURCE_TYPE_ADDRESS32:
            /*
             * 32-Bit Address Resource:
             * Add the size of the optional ResourceSource info
             */
            TotalSize = (ACPI_RS_LENGTH) (TotalSize +
                AcpiRsStructOptionLength (
                    &Resource->Data.Address32.ResourceSource));
            break;
 
 
        case ACPI_RESOURCE_TYPE_ADDRESS64:
            /*
             * 64-Bit Address Resource:
             * Add the size of the optional ResourceSource info
             */
            TotalSize = (ACPI_RS_LENGTH) (TotalSize +
                AcpiRsStructOptionLength (
                    &Resource->Data.Address64.ResourceSource));
            break;
 
 
        case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
            /*
             * Extended IRQ Resource:
             * Add the size of each additional optional interrupt beyond the
             * required 1 (4 bytes for each UINT32 interrupt number)
             */
            TotalSize = (ACPI_RS_LENGTH) (TotalSize +
                ((Resource->Data.ExtendedIrq.InterruptCount - 1) * 4) +
 
                /* Add the size of the optional ResourceSource info */
 
                AcpiRsStructOptionLength (
                    &Resource->Data.ExtendedIrq.ResourceSource));
            break;
 
 
        case ACPI_RESOURCE_TYPE_GPIO:
 
            TotalSize = (ACPI_RS_LENGTH) (TotalSize +
                (Resource->Data.Gpio.PinTableLength * 2) +
                Resource->Data.Gpio.ResourceSource.StringLength +
                Resource->Data.Gpio.VendorLength);
 
            break;
 
        case ACPI_RESOURCE_TYPE_PIN_FUNCTION:
 
            TotalSize = (ACPI_RS_LENGTH) (TotalSize +
                (Resource->Data.PinFunction.PinTableLength * 2) +
                Resource->Data.PinFunction.ResourceSource.StringLength +
                Resource->Data.PinFunction.VendorLength);
 
            break;
 
 
        case ACPI_RESOURCE_TYPE_SERIAL_BUS:
 
            TotalSize = AcpiGbl_AmlResourceSerialBusSizes [
                Resource->Data.CommonSerialBus.Type];
 
            TotalSize = (ACPI_RS_LENGTH) (TotalSize +
                Resource->Data.I2cSerialBus.ResourceSource.StringLength +
                Resource->Data.I2cSerialBus.VendorLength);
 
            break;
 
        case ACPI_RESOURCE_TYPE_PIN_CONFIG:
 
            TotalSize = (ACPI_RS_LENGTH) (TotalSize +
                (Resource->Data.PinConfig.PinTableLength * 2) +
                Resource->Data.PinConfig.ResourceSource.StringLength +
                Resource->Data.PinConfig.VendorLength);
 
            break;
 
        case ACPI_RESOURCE_TYPE_PIN_GROUP:
 
            TotalSize = (ACPI_RS_LENGTH) (TotalSize +
                (Resource->Data.PinGroup.PinTableLength * 2) +
                Resource->Data.PinGroup.ResourceLabel.StringLength +
                Resource->Data.PinGroup.VendorLength);
 
            break;
 
        case ACPI_RESOURCE_TYPE_PIN_GROUP_FUNCTION:
 
            TotalSize = (ACPI_RS_LENGTH) (TotalSize +
                Resource->Data.PinGroupFunction.ResourceSource.StringLength +
                Resource->Data.PinGroupFunction.ResourceSourceLabel.StringLength +
                Resource->Data.PinGroupFunction.VendorLength);
 
            break;
 
        case ACPI_RESOURCE_TYPE_PIN_GROUP_CONFIG:
 
            TotalSize = (ACPI_RS_LENGTH) (TotalSize +
                Resource->Data.PinGroupConfig.ResourceSource.StringLength +
                Resource->Data.PinGroupConfig.ResourceSourceLabel.StringLength +
                Resource->Data.PinGroupConfig.VendorLength);
 
            break;
 
        default:
 
            break;
        }
 
        /* Update the total */
 
        AmlSizeNeeded += TotalSize;
 
        /* Point to the next object */
 
        Resource = ACPI_ADD_PTR (ACPI_RESOURCE, Resource, Resource->Length);
    }
 
    /* Did not find an EndTag resource descriptor */
 
    return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
}

Referenced by AcpiRsCreateAmlResources().

AcpiRsGetCrsMethodData()

ACPI_STATUS AcpiRsGetCrsMethodData	(	ACPI_NAMESPACE_NODE *	Node,
		ACPI_BUFFER *	RetBuffer
	)

Definition at line 575 of file rsutils.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (RsGetCrsMethodData);
 
 
    /* Parameters guaranteed valid by caller */
 
    /* Execute the method, no parameters */
 
    Status = AcpiUtEvaluateObject (
        Node, METHOD_NAME__CRS, ACPI_BTYPE_BUFFER, &ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Make the call to create a resource linked list from the
     * byte stream buffer that comes back from the _CRS method
     * execution.
     */
    Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
 
    /* On exit, we must delete the object returned by evaluateObject */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiGetCurrentResources().

AcpiRsGetListLength()

ACPI_STATUS AcpiRsGetListLength	(	UINT8 *	AmlBuffer,
		UINT32	AmlBufferLength,
		ACPI_SIZE *	SizeNeeded
	)

Definition at line 460 of file rscalc.c.

{
    ACPI_STATUS             Status;
    UINT8                   *EndAml;
    UINT8                   *Buffer;
    UINT32                  BufferSize;
    UINT16                  Temp16;
    UINT16                  ResourceLength;
    UINT32                  ExtraStructBytes;
    UINT8                   ResourceIndex;
    UINT8                   MinimumAmlResourceLength;
    AML_RESOURCE            *AmlResource;
 
 
    ACPI_FUNCTION_TRACE (RsGetListLength);
 
 
    *SizeNeeded = ACPI_RS_SIZE_MIN;         /* Minimum size is one EndTag */
    EndAml = AmlBuffer + AmlBufferLength;
 
    /* Walk the list of AML resource descriptors */
 
    while (AmlBuffer < EndAml)
    {
        /* Validate the Resource Type and Resource Length */
 
        Status = AcpiUtValidateResource (NULL, AmlBuffer, &ResourceIndex);
        if (ACPI_FAILURE (Status))
        {
            /*
             * Exit on failure. Cannot continue because the descriptor length
             * may be bogus also.
             */
            return_ACPI_STATUS (Status);
        }
 
        AmlResource = (void *) AmlBuffer;
 
        /* Get the resource length and base (minimum) AML size */
 
        ResourceLength = AcpiUtGetResourceLength (AmlBuffer);
        MinimumAmlResourceLength = AcpiGbl_ResourceAmlSizes[ResourceIndex];
 
        /*
         * Augment the size for descriptors with optional
         * and/or variable length fields
         */
        ExtraStructBytes = 0;
        Buffer = AmlBuffer + AcpiUtGetResourceHeaderLength (AmlBuffer);
 
        switch (AcpiUtGetResourceType (AmlBuffer))
        {
        case ACPI_RESOURCE_NAME_IRQ:
            /*
             * IRQ Resource:
             * Get the number of bits set in the 16-bit IRQ mask
             */
            ACPI_MOVE_16_TO_16 (&Temp16, Buffer);
            ExtraStructBytes = AcpiRsCountSetBits (Temp16);
            break;
 
 
        case ACPI_RESOURCE_NAME_DMA:
            /*
             * DMA Resource:
             * Get the number of bits set in the 8-bit DMA mask
             */
            ExtraStructBytes = AcpiRsCountSetBits (*Buffer);
            break;
 
 
        case ACPI_RESOURCE_NAME_VENDOR_SMALL:
        case ACPI_RESOURCE_NAME_VENDOR_LARGE:
            /*
             * Vendor Resource:
             * Get the number of vendor data bytes
             */
            ExtraStructBytes = ResourceLength;
 
            /*
             * There is already one byte included in the minimum
             * descriptor size. If there are extra struct bytes,
             * subtract one from the count.
             */
            if (ExtraStructBytes)
            {
                ExtraStructBytes--;
            }
            break;
 
 
        case ACPI_RESOURCE_NAME_END_TAG:
            /*
             * End Tag: This is the normal exit
             */
            return_ACPI_STATUS (AE_OK);
 
 
        case ACPI_RESOURCE_NAME_ADDRESS32:
        case ACPI_RESOURCE_NAME_ADDRESS16:
        case ACPI_RESOURCE_NAME_ADDRESS64:
            /*
             * Address Resource:
             * Add the size of the optional ResourceSource
             */
            ExtraStructBytes = AcpiRsStreamOptionLength (
                ResourceLength, MinimumAmlResourceLength);
            break;
 
 
        case ACPI_RESOURCE_NAME_EXTENDED_IRQ:
            /*
             * Extended IRQ Resource:
             * Using the InterruptTableLength, add 4 bytes for each additional
             * interrupt. Note: at least one interrupt is required and is
             * included in the minimum descriptor size (reason for the -1)
             */
            ExtraStructBytes = (Buffer[1] - 1) * sizeof (UINT32);
 
            /* Add the size of the optional ResourceSource */
 
            ExtraStructBytes += AcpiRsStreamOptionLength (
                ResourceLength - ExtraStructBytes, MinimumAmlResourceLength);
            break;
 
        case ACPI_RESOURCE_NAME_GPIO:
 
            /* Vendor data is optional */
 
            if (AmlResource->Gpio.VendorLength)
            {
                ExtraStructBytes +=
                    AmlResource->Gpio.VendorOffset -
                    AmlResource->Gpio.PinTableOffset +
                    AmlResource->Gpio.VendorLength;
            }
            else
            {
                ExtraStructBytes +=
                    AmlResource->LargeHeader.ResourceLength +
                    sizeof (AML_RESOURCE_LARGE_HEADER) -
                    AmlResource->Gpio.PinTableOffset;
            }
            break;
 
        case ACPI_RESOURCE_NAME_PIN_FUNCTION:
 
            /* Vendor data is optional */
 
            if (AmlResource->PinFunction.VendorLength)
            {
                ExtraStructBytes +=
                    AmlResource->PinFunction.VendorOffset -
                    AmlResource->PinFunction.PinTableOffset +
                    AmlResource->PinFunction.VendorLength;
            }
            else
            {
                ExtraStructBytes +=
                    AmlResource->LargeHeader.ResourceLength +
                    sizeof (AML_RESOURCE_LARGE_HEADER) -
                    AmlResource->PinFunction.PinTableOffset;
            }
            break;
 
        case ACPI_RESOURCE_NAME_SERIAL_BUS:
 
            MinimumAmlResourceLength = AcpiGbl_ResourceAmlSerialBusSizes[
                AmlResource->CommonSerialBus.Type];
            ExtraStructBytes +=
                AmlResource->CommonSerialBus.ResourceLength -
                MinimumAmlResourceLength;
            break;
 
        case ACPI_RESOURCE_NAME_PIN_CONFIG:
 
            /* Vendor data is optional */
 
            if (AmlResource->PinConfig.VendorLength)
            {
                ExtraStructBytes +=
                    AmlResource->PinConfig.VendorOffset -
                    AmlResource->PinConfig.PinTableOffset +
                    AmlResource->PinConfig.VendorLength;
            }
            else
            {
                ExtraStructBytes +=
                    AmlResource->LargeHeader.ResourceLength +
                    sizeof (AML_RESOURCE_LARGE_HEADER) -
                    AmlResource->PinConfig.PinTableOffset;
            }
            break;
 
        case ACPI_RESOURCE_NAME_PIN_GROUP:
 
            ExtraStructBytes +=
                AmlResource->PinGroup.VendorOffset -
                AmlResource->PinGroup.PinTableOffset +
                AmlResource->PinGroup.VendorLength;
 
            break;
 
        case ACPI_RESOURCE_NAME_PIN_GROUP_FUNCTION:
 
            ExtraStructBytes +=
                AmlResource->PinGroupFunction.VendorOffset -
                AmlResource->PinGroupFunction.ResSourceOffset +
                AmlResource->PinGroupFunction.VendorLength;
 
            break;
 
        case ACPI_RESOURCE_NAME_PIN_GROUP_CONFIG:
 
            ExtraStructBytes +=
                AmlResource->PinGroupConfig.VendorOffset -
                AmlResource->PinGroupConfig.ResSourceOffset +
                AmlResource->PinGroupConfig.VendorLength;
 
            break;
 
        default:
 
            break;
        }
 
        /*
         * Update the required buffer size for the internal descriptor structs
         *
         * Important: Round the size up for the appropriate alignment. This
         * is a requirement on IA64.
         */
        if (AcpiUtGetResourceType (AmlBuffer) ==
            ACPI_RESOURCE_NAME_SERIAL_BUS)
        {
            BufferSize = AcpiGbl_ResourceStructSerialBusSizes[
                AmlResource->CommonSerialBus.Type] + ExtraStructBytes;
        }
        else
        {
            BufferSize = AcpiGbl_ResourceStructSizes[ResourceIndex] +
                ExtraStructBytes;
        }
 
        BufferSize = (UINT32) ACPI_ROUND_UP_TO_NATIVE_WORD (BufferSize);
        *SizeNeeded += BufferSize;
 
        ACPI_DEBUG_PRINT ((ACPI_DB_RESOURCES,
            "Type %.2X, AmlLength %.2X InternalLength %.2X%8X\n",
            AcpiUtGetResourceType (AmlBuffer),
            AcpiUtGetDescriptorLength (AmlBuffer), ACPI_FORMAT_UINT64(*SizeNeeded)));
 
        /*
         * Point to the next resource within the AML stream using the length
         * contained in the resource descriptor header
         */
        AmlBuffer += AcpiUtGetDescriptorLength (AmlBuffer);
    }
 
    /* Did not find an EndTag resource descriptor */
 
    return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
}

Referenced by AcpiBufferToResource(), and AcpiRsCreateResourceList().

AcpiRsGetMethodData()

ACPI_STATUS AcpiRsGetMethodData	(	ACPI_HANDLE	Handle,
		const char *	Path,
		ACPI_BUFFER *	RetBuffer
	)

Definition at line 741 of file rsutils.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (RsGetMethodData);
 
 
    /* Parameters guaranteed valid by caller */
 
    /* Execute the method, no parameters */
 
    Status = AcpiUtEvaluateObject (
        ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Handle),
        Path, ACPI_BTYPE_BUFFER, &ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Make the call to create a resource linked list from the
     * byte stream buffer that comes back from the method
     * execution.
     */
    Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
 
    /* On exit, we must delete the object returned by EvaluateObject */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiWalkResources().

AcpiRsGetPciRoutingTableLength()

ACPI_STATUS AcpiRsGetPciRoutingTableLength	(	ACPI_OPERAND_OBJECT *	PackageObject,
		ACPI_SIZE *	BufferSizeNeeded
	)

Definition at line 746 of file rscalc.c.

{
    UINT32                  NumberOfElements;
    ACPI_SIZE               TempSizeNeeded = 0;
    ACPI_OPERAND_OBJECT     **TopObjectList;
    UINT32                  Index;
    ACPI_OPERAND_OBJECT     *PackageElement;
    ACPI_OPERAND_OBJECT     **SubObjectList;
    BOOLEAN                 NameFound;
    UINT32                  TableIndex;
 
 
    ACPI_FUNCTION_TRACE (RsGetPciRoutingTableLength);
 
 
    NumberOfElements = PackageObject->Package.Count;
 
    /*
     * Calculate the size of the return buffer.
     * The base size is the number of elements * the sizes of the
     * structures. Additional space for the strings is added below.
     * The minus one is to subtract the size of the UINT8 Source[1]
     * member because it is added below.
     *
     * But each PRT_ENTRY structure has a pointer to a string and
     * the size of that string must be found.
     */
    TopObjectList = PackageObject->Package.Elements;
 
    for (Index = 0; Index < NumberOfElements; Index++)
    {
        /* Dereference the subpackage */
 
        PackageElement = *TopObjectList;
 
        /* We must have a valid Package object */
 
        if (!PackageElement ||
            (PackageElement->Common.Type != ACPI_TYPE_PACKAGE))
        {
            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
 
        /*
         * The SubObjectList will now point to an array of the
         * four IRQ elements: Address, Pin, Source and SourceIndex
         */
        SubObjectList = PackageElement->Package.Elements;
 
        /* Scan the IrqTableElements for the Source Name String */
 
        NameFound = FALSE;
 
        for (TableIndex = 0;
             TableIndex < PackageElement->Package.Count && !NameFound;
             TableIndex++)
        {
            if (*SubObjectList && /* Null object allowed */
 
                ((ACPI_TYPE_STRING ==
                    (*SubObjectList)->Common.Type) ||
 
                ((ACPI_TYPE_LOCAL_REFERENCE ==
                    (*SubObjectList)->Common.Type) &&
 
                    ((*SubObjectList)->Reference.Class ==
                        ACPI_REFCLASS_NAME))))
            {
                NameFound = TRUE;
            }
            else
            {
                /* Look at the next element */
 
                SubObjectList++;
            }
        }
 
        TempSizeNeeded += (sizeof (ACPI_PCI_ROUTING_TABLE) - 4);
 
        /* Was a String type found? */
 
        if (NameFound)
        {
            if ((*SubObjectList)->Common.Type == ACPI_TYPE_STRING)
            {
                /*
                 * The length String.Length field does not include the
                 * terminating NULL, add 1
                 */
                TempSizeNeeded += ((ACPI_SIZE)
                    (*SubObjectList)->String.Length + 1);
            }
            else
            {
                TempSizeNeeded += AcpiNsGetPathnameLength (
                    (*SubObjectList)->Reference.Node);
            }
        }
        else
        {
            /*
             * If no name was found, then this is a NULL, which is
             * translated as a UINT32 zero.
             */
            TempSizeNeeded += sizeof (UINT32);
        }
 
        /* Round up the size since each element must be aligned */
 
        TempSizeNeeded = ACPI_ROUND_UP_TO_64BIT (TempSizeNeeded);
 
        /* Point to the next ACPI_OPERAND_OBJECT */
 
        TopObjectList++;
    }
 
    /*
     * Add an extra element to the end of the list, essentially a
     * NULL terminator
     */
    *BufferSizeNeeded = TempSizeNeeded + sizeof (ACPI_PCI_ROUTING_TABLE);
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiRsCreatePciRoutingTable().

AcpiRsGetPrsMethodData()

ACPI_STATUS AcpiRsGetPrsMethodData	(	ACPI_NAMESPACE_NODE *	Node,
		ACPI_BUFFER *	RetBuffer
	)

Definition at line 630 of file rsutils.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (RsGetPrsMethodData);
 
 
    /* Parameters guaranteed valid by caller */
 
    /* Execute the method, no parameters */
 
    Status = AcpiUtEvaluateObject (
        Node, METHOD_NAME__PRS, ACPI_BTYPE_BUFFER, &ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Make the call to create a resource linked list from the
     * byte stream buffer that comes back from the _CRS method
     * execution.
     */
    Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
 
    /* On exit, we must delete the object returned by evaluateObject */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiGetPossibleResources().

AcpiRsGetPrtMethodData()

ACPI_STATUS AcpiRsGetPrtMethodData	(	ACPI_NAMESPACE_NODE *	Node,
		ACPI_BUFFER *	RetBuffer
	)

Definition at line 521 of file rsutils.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (RsGetPrtMethodData);
 
 
    /* Parameters guaranteed valid by caller */
 
    /* Execute the method, no parameters */
 
    Status = AcpiUtEvaluateObject (
        Node, METHOD_NAME__PRT, ACPI_BTYPE_PACKAGE, &ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Create a resource linked list from the byte stream buffer that comes
     * back from the _CRS method execution.
     */
    Status = AcpiRsCreatePciRoutingTable (ObjDesc, RetBuffer);
 
    /* On exit, we must delete the object returned by EvaluateObject */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiGetIrqRoutingTable().

AcpiRsGetResourceSource()

ACPI_RS_LENGTH AcpiRsGetResourceSource	(	ACPI_RS_LENGTH	ResourceLength,
		ACPI_RS_LENGTH	MinimumLength,
		ACPI_RESOURCE_SOURCE *	ResourceSource,
		AML_RESOURCE *	Aml,
		char *	StringPtr
	)

Definition at line 366 of file rsutils.c.

{
    ACPI_RSDESC_SIZE        TotalLength;
    UINT8                   *AmlResourceSource;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    TotalLength = ResourceLength + sizeof (AML_RESOURCE_LARGE_HEADER);
    AmlResourceSource = ACPI_ADD_PTR (UINT8, Aml, MinimumLength);
 
    /*
     * ResourceSource is present if the length of the descriptor is longer
     * than the minimum length.
     *
     * Note: Some resource descriptors will have an additional null, so
     * we add 1 to the minimum length.
     */
    if (TotalLength > (ACPI_RSDESC_SIZE) (MinimumLength + 1))
    {
        /* Get the ResourceSourceIndex */
 
        ResourceSource->Index = AmlResourceSource[0];
 
        ResourceSource->StringPtr = StringPtr;
        if (!StringPtr)
        {
            /*
             * String destination pointer is not specified; Set the String
             * pointer to the end of the current ResourceSource structure.
             */
            ResourceSource->StringPtr = ACPI_ADD_PTR (
                char, ResourceSource, sizeof (ACPI_RESOURCE_SOURCE));
        }
 
        /*
         * In order for the Resource length to be a multiple of the native
         * word, calculate the length of the string (+1 for NULL terminator)
         * and expand to the next word multiple.
         *
         * Zero the entire area of the buffer.
         */
        TotalLength = (UINT32) strlen (
            ACPI_CAST_PTR (char, &AmlResourceSource[1])) + 1;
 
        TotalLength = (UINT32) ACPI_ROUND_UP_TO_NATIVE_WORD (TotalLength);
 
        memset (ResourceSource->StringPtr, 0, TotalLength);
 
        /* Copy the ResourceSource string to the destination */
 
        ResourceSource->StringLength = AcpiRsStrcpy (
            ResourceSource->StringPtr,
            ACPI_CAST_PTR (char, &AmlResourceSource[1]));
 
        return ((ACPI_RS_LENGTH) TotalLength);
    }
 
    /* ResourceSource is not present */
 
    ResourceSource->Index = 0;
    ResourceSource->StringLength = 0;
    ResourceSource->StringPtr = NULL;
    return (0);
}

Referenced by AcpiRsConvertAmlToResource().

AcpiRsMoveData()

void AcpiRsMoveData	(	void *	Destination,
		void *	Source,
		UINT16	ItemCount,
		UINT8	MoveType
	)

Definition at line 150 of file rsutils.c.

{
    UINT32                  i;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* One move per item */
 
    for (i = 0; i < ItemCount; i++)
    {
        switch (MoveType)
        {
        /*
         * For the 8-bit case, we can perform the move all at once
         * since there are no alignment or endian issues
         */
        case ACPI_RSC_MOVE8:
        case ACPI_RSC_MOVE_GPIO_RES:
        case ACPI_RSC_MOVE_SERIAL_VEN:
        case ACPI_RSC_MOVE_SERIAL_RES:
 
            memcpy (Destination, Source, ItemCount);
            return;
 
        /*
         * 16-, 32-, and 64-bit cases must use the move macros that perform
         * endian conversion and/or accommodate hardware that cannot perform
         * misaligned memory transfers
         */
        case ACPI_RSC_MOVE16:
        case ACPI_RSC_MOVE_GPIO_PIN:
 
            ACPI_MOVE_16_TO_16 (
                &ACPI_CAST_PTR (UINT16, Destination)[i],
                &ACPI_CAST_PTR (UINT16, Source)[i]);
            break;
 
        case ACPI_RSC_MOVE32:
 
            ACPI_MOVE_32_TO_32 (
                &ACPI_CAST_PTR (UINT32, Destination)[i],
                &ACPI_CAST_PTR (UINT32, Source)[i]);
            break;
 
        case ACPI_RSC_MOVE64:
 
            ACPI_MOVE_64_TO_64 (
                &ACPI_CAST_PTR (UINT64, Destination)[i],
                &ACPI_CAST_PTR (UINT64, Source)[i]);
            break;
 
        default:
 
            return;
        }
    }
}

Referenced by AcpiRsConvertAmlToResource(), and AcpiRsConvertResourceToAml().

AcpiRsSetAddressCommon()

void AcpiRsSetAddressCommon	(	AML_RESOURCE *	Aml,
		ACPI_RESOURCE *	Resource
	)

Definition at line 381 of file rsaddr.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Set the Resource Type and General Flags */
 
    (void) AcpiRsConvertResourceToAml (
        Resource, Aml, AcpiRsConvertGeneralFlags);
 
    /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
 
    if (Resource->Data.Address.ResourceType == ACPI_MEMORY_RANGE)
    {
        (void) AcpiRsConvertResourceToAml (
            Resource, Aml, AcpiRsConvertMemFlags);
    }
    else if (Resource->Data.Address.ResourceType == ACPI_IO_RANGE)
    {
        (void) AcpiRsConvertResourceToAml (
            Resource, Aml, AcpiRsConvertIoFlags);
    }
    else
    {
        /* Generic resource type, just copy the TypeSpecific byte */
 
        Aml->Address.SpecificFlags =
            Resource->Data.Address.Info.TypeSpecific;
    }
}

Referenced by AcpiRsConvertResourceToAml().

AcpiRsSetResourceHeader()

void AcpiRsSetResourceHeader	(	UINT8	DescriptorType,
		ACPI_RSDESC_SIZE	TotalLength,
		AML_RESOURCE *	Aml
	)

Definition at line 289 of file rsutils.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Set the Resource Type */
 
    Aml->SmallHeader.DescriptorType = DescriptorType;
 
    /* Set the Resource Length */
 
    AcpiRsSetResourceLength (TotalLength, Aml);
}

Referenced by AcpiRsConvertResourceToAml().

AcpiRsSetResourceLength()

void AcpiRsSetResourceLength	(	ACPI_RSDESC_SIZE	TotalLength,
		AML_RESOURCE *	Aml
	)

Definition at line 233 of file rsutils.c.

{
    ACPI_RS_LENGTH          ResourceLength;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Length is the total descriptor length minus the header length */
 
    ResourceLength = (ACPI_RS_LENGTH)
        (TotalLength - AcpiUtGetResourceHeaderLength (Aml));
 
    /* Length is stored differently for large and small descriptors */
 
    if (Aml->SmallHeader.DescriptorType & ACPI_RESOURCE_NAME_LARGE)
    {
        /* Large descriptor -- bytes 1-2 contain the 16-bit length */
 
        ACPI_MOVE_16_TO_16 (
            &Aml->LargeHeader.ResourceLength, &ResourceLength);
    }
    else
    {
        /*
         * Small descriptor -- bits 2:0 of byte 0 contain the length
         * Clear any existing length, preserving descriptor type bits
         */
        Aml->SmallHeader.DescriptorType = (UINT8)
            ((Aml->SmallHeader.DescriptorType &
                ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK)
            | ResourceLength);
    }
}

Referenced by AcpiRsConvertResourceToAml(), and AcpiRsSetResourceHeader().

AcpiRsSetResourceSource()

ACPI_RSDESC_SIZE AcpiRsSetResourceSource	(	AML_RESOURCE *	Aml,
		ACPI_RS_LENGTH	MinimumLength,
		ACPI_RESOURCE_SOURCE *	ResourceSource
	)

Definition at line 457 of file rsutils.c.

{
    UINT8                   *AmlResourceSource;
    ACPI_RSDESC_SIZE        DescriptorLength;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    DescriptorLength = MinimumLength;
 
    /* Non-zero string length indicates presence of a ResourceSource */
 
    if (ResourceSource->StringLength)
    {
        /* Point to the end of the AML descriptor */
 
        AmlResourceSource = ACPI_ADD_PTR (UINT8, Aml, MinimumLength);
 
        /* Copy the ResourceSourceIndex */
 
        AmlResourceSource[0] = (UINT8) ResourceSource->Index;
 
        /* Copy the ResourceSource string */
 
        strcpy (ACPI_CAST_PTR (char, &AmlResourceSource[1]),
            ResourceSource->StringPtr);
 
        /*
         * Add the length of the string (+ 1 for null terminator) to the
         * final descriptor length
         */
        DescriptorLength += ((ACPI_RSDESC_SIZE)
            ResourceSource->StringLength + 1);
    }
 
    /* Return the new total length of the AML descriptor */
 
    return (DescriptorLength);
}

Referenced by AcpiRsConvertResourceToAml().

AcpiRsSetSrsMethodData()

ACPI_STATUS AcpiRsSetSrsMethodData	(	ACPI_NAMESPACE_NODE *	Node,
		ACPI_BUFFER *	RetBuffer
	)

Definition at line 800 of file rsutils.c.

{
    ACPI_EVALUATE_INFO      *Info;
    ACPI_OPERAND_OBJECT     *Args[2];
    ACPI_STATUS             Status;
    ACPI_BUFFER             Buffer;
 
 
    ACPI_FUNCTION_TRACE (RsSetSrsMethodData);
 
 
    /* Allocate and initialize the evaluation information block */
 
    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
    if (!Info)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    Info->PrefixNode = Node;
    Info->RelativePathname = METHOD_NAME__SRS;
    Info->Parameters = Args;
    Info->Flags = ACPI_IGNORE_RETURN_VALUE;
 
    /*
     * The InBuffer parameter will point to a linked list of
     * resource parameters. It needs to be formatted into a
     * byte stream to be sent in as an input parameter to _SRS
     *
     * Convert the linked list into a byte stream
     */
    Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
    Status = AcpiRsCreateAmlResources (InBuffer, &Buffer);
    if (ACPI_FAILURE (Status))
    {
        goto Cleanup;
    }
 
    /* Create and initialize the method parameter object */
 
    Args[0] = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER);
    if (!Args[0])
    {
        /*
         * Must free the buffer allocated above (otherwise it is freed
         * later)
         */
        ACPI_FREE (Buffer.Pointer);
        Status = AE_NO_MEMORY;
        goto Cleanup;
    }
 
    Args[0]->Buffer.Length  = (UINT32) Buffer.Length;
    Args[0]->Buffer.Pointer = Buffer.Pointer;
    Args[0]->Common.Flags   = AOPOBJ_DATA_VALID;
    Args[1] = NULL;
 
    /* Execute the method, no return value is expected */
 
    Status = AcpiNsEvaluate (Info);
 
    /* Clean up and return the status from AcpiNsEvaluate */
 
    AcpiUtRemoveReference (Args[0]);
 
Cleanup:
    ACPI_FREE (Info);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiSetCurrentResources().

Variable Documentation

AcpiGbl_AmlResourceSerialBusSizes

const UINT8 AcpiGbl_AmlResourceSerialBusSizes[]

extern

Definition at line 275 of file rsinfo.c.

Referenced by AcpiRsGetAmlLength().

AcpiGbl_AmlResourceSizes

const UINT8 AcpiGbl_AmlResourceSizes[]

extern

Definition at line 201 of file rsinfo.c.

Referenced by AcpiRsGetAmlLength().

AcpiGbl_ConvertResourceSerialBusDispatch

ACPI_RSCONVERT_INFO* AcpiGbl_ConvertResourceSerialBusDispatch[]

extern

Definition at line 142 of file rsinfo.c.

Referenced by AcpiRsConvertAmlToResources(), and AcpiRsConvertResourcesToAml().

AcpiGbl_GetResourceDispatch

ACPI_RSCONVERT_INFO* AcpiGbl_GetResourceDispatch[]

extern

Definition at line 96 of file rsinfo.c.

Referenced by AcpiRsConvertAmlToResources().

AcpiGbl_ResourceStructSerialBusSizes

const UINT8 AcpiGbl_ResourceStructSerialBusSizes[]

extern

Definition at line 284 of file rsinfo.c.

Referenced by AcpiRsGetListLength().

AcpiGbl_ResourceStructSizes

const UINT8 AcpiGbl_ResourceStructSizes[]

extern

Definition at line 231 of file rsinfo.c.

Referenced by AcpiRsGetListLength().

AcpiGbl_SetResourceDispatch

ACPI_RSCONVERT_INFO* AcpiGbl_SetResourceDispatch[]

extern

Definition at line 65 of file rsinfo.c.

Referenced by AcpiRsConvertResourcesToAml().

AcpiRsConvertAddress16

ACPI_RSCONVERT_INFO AcpiRsConvertAddress16[]

extern

Definition at line 58 of file rsaddr.c.

AcpiRsConvertAddress32

ACPI_RSCONVERT_INFO AcpiRsConvertAddress32[]

extern

Definition at line 98 of file rsaddr.c.

AcpiRsConvertAddress64

ACPI_RSCONVERT_INFO AcpiRsConvertAddress64[]

extern

Definition at line 138 of file rsaddr.c.

AcpiRsConvertCsi2SerialBus

ACPI_RSCONVERT_INFO AcpiRsConvertCsi2SerialBus[]

extern

Definition at line 228 of file rsserial.c.

AcpiRsConvertDma

ACPI_RSCONVERT_INFO AcpiRsConvertDma[]

extern

Definition at line 258 of file rsirq.c.

AcpiRsConvertEndDpf

ACPI_RSCONVERT_INFO AcpiRsConvertEndDpf[]

extern

Definition at line 160 of file rsio.c.

AcpiRsConvertEndTag

ACPI_RSCONVERT_INFO AcpiRsConvertEndTag[]

extern

Definition at line 178 of file rsio.c.

AcpiRsConvertExtAddress64

ACPI_RSCONVERT_INFO AcpiRsConvertExtAddress64[]

extern

Definition at line 178 of file rsaddr.c.

AcpiRsConvertExtIrq

ACPI_RSCONVERT_INFO AcpiRsConvertExtIrq[]

extern

Definition at line 198 of file rsirq.c.

AcpiRsConvertFixedDma

ACPI_RSCONVERT_INFO AcpiRsConvertFixedDma[]

extern

Definition at line 296 of file rsirq.c.

AcpiRsConvertFixedIo

ACPI_RSCONVERT_INFO AcpiRsConvertFixedIo[]

extern

Definition at line 96 of file rsio.c.

AcpiRsConvertFixedMemory32

ACPI_RSCONVERT_INFO AcpiRsConvertFixedMemory32[]

extern

Definition at line 126 of file rsmemory.c.

AcpiRsConvertGenericReg

ACPI_RSCONVERT_INFO AcpiRsConvertGenericReg[]

extern

Definition at line 126 of file rsio.c.

AcpiRsConvertGpio

ACPI_RSCONVERT_INFO AcpiRsConvertGpio[]

extern

Definition at line 58 of file rsserial.c.

AcpiRsConvertI2cSerialBus

ACPI_RSCONVERT_INFO AcpiRsConvertI2cSerialBus[]

extern

Definition at line 298 of file rsserial.c.

AcpiRsConvertIo

ACPI_RSCONVERT_INFO AcpiRsConvertIo[]

extern

Definition at line 58 of file rsio.c.

AcpiRsConvertMemory24

ACPI_RSCONVERT_INFO AcpiRsConvertMemory24[]

extern

Definition at line 58 of file rsmemory.c.

AcpiRsConvertMemory32

ACPI_RSCONVERT_INFO AcpiRsConvertMemory32[]

extern

Definition at line 92 of file rsmemory.c.

AcpiRsConvertPinConfig

ACPI_RSCONVERT_INFO AcpiRsConvertPinConfig[]

extern

Definition at line 590 of file rsserial.c.

AcpiRsConvertPinFunction

ACPI_RSCONVERT_INFO AcpiRsConvertPinFunction[]

extern

Definition at line 155 of file rsserial.c.

AcpiRsConvertPinGroup

ACPI_RSCONVERT_INFO AcpiRsConvertPinGroup[]

extern

Definition at line 666 of file rsserial.c.

AcpiRsConvertPinGroupConfig

ACPI_RSCONVERT_INFO AcpiRsConvertPinGroupConfig[]

extern

Definition at line 793 of file rsserial.c.

AcpiRsConvertPinGroupFunction

ACPI_RSCONVERT_INFO AcpiRsConvertPinGroupFunction[]

extern

Definition at line 726 of file rsserial.c.

AcpiRsConvertSpiSerialBus

ACPI_RSCONVERT_INFO AcpiRsConvertSpiSerialBus[]

extern

Definition at line 382 of file rsserial.c.

AcpiRsConvertUartSerialBus

ACPI_RSCONVERT_INFO AcpiRsConvertUartSerialBus[]

extern

Definition at line 482 of file rsserial.c.

AcpiRsGetIrq

ACPI_RSCONVERT_INFO AcpiRsGetIrq[]

extern

Definition at line 58 of file rsirq.c.

AcpiRsGetStartDpf

ACPI_RSCONVERT_INFO AcpiRsGetStartDpf[]

extern

Definition at line 201 of file rsio.c.

AcpiRsGetVendorLarge

ACPI_RSCONVERT_INFO AcpiRsGetVendorLarge[]

extern

Definition at line 184 of file rsmemory.c.

AcpiRsGetVendorSmall

ACPI_RSCONVERT_INFO AcpiRsGetVendorSmall[]

extern

Definition at line 158 of file rsmemory.c.

AcpiRsSetIrq

ACPI_RSCONVERT_INFO AcpiRsSetIrq[]

extern

Definition at line 112 of file rsirq.c.

AcpiRsSetStartDpf

ACPI_RSCONVERT_INFO AcpiRsSetStartDpf[]

extern

Definition at line 241 of file rsio.c.

AcpiRsSetVendor

ACPI_RSCONVERT_INFO AcpiRsSetVendor[]

extern

Definition at line 210 of file rsmemory.c.