aclocal.h

acpi tools for linux include acpiexec and acpixtract

} ACPI_NAMESTRING_INFO;


/* Field creation info */

typedef struct acpi_create_field_info
{
    ACPI_NAMESPACE_NODE             *RegionNode;
    ACPI_NAMESPACE_NODE             *FieldNode;
    ACPI_NAMESPACE_NODE             *RegisterNode;
    ACPI_NAMESPACE_NODE             *DataRegisterNode;
    UINT32                          BankValue;
    UINT32                          FieldBitPosition;
    UINT32                          FieldBitLength;
    UINT8                           FieldFlags;
    UINT8                           Attribute;
    UINT8                           FieldType;

} ACPI_CREATE_FIELD_INFO;


typedef
ACPI_STATUS (*ACPI_INTERNAL_METHOD) (
    struct acpi_walk_state          *WalkState);


/*
 * Bitmapped ACPI types.  Used internally only
 */
#define ACPI_BTYPE_ANY                  0x00000000
#define ACPI_BTYPE_INTEGER              0x00000001
#define ACPI_BTYPE_STRING               0x00000002
#define ACPI_BTYPE_BUFFER               0x00000004
#define ACPI_BTYPE_PACKAGE              0x00000008
#define ACPI_BTYPE_FIELD_UNIT           0x00000010
#define ACPI_BTYPE_DEVICE               0x00000020
#define ACPI_BTYPE_EVENT                0x00000040
#define ACPI_BTYPE_METHOD               0x00000080
#define ACPI_BTYPE_MUTEX                0x00000100
#define ACPI_BTYPE_REGION               0x00000200
#define ACPI_BTYPE_POWER                0x00000400
#define ACPI_BTYPE_PROCESSOR            0x00000800
#define ACPI_BTYPE_THERMAL              0x00001000
#define ACPI_BTYPE_BUFFER_FIELD         0x00002000
#define ACPI_BTYPE_DDB_HANDLE           0x00004000
#define ACPI_BTYPE_DEBUG_OBJECT         0x00008000
#define ACPI_BTYPE_REFERENCE            0x00010000
#define ACPI_BTYPE_RESOURCE             0x00020000

#define ACPI_BTYPE_COMPUTE_DATA         (ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER)

#define ACPI_BTYPE_DATA                 (ACPI_BTYPE_COMPUTE_DATA  | ACPI_BTYPE_PACKAGE)
#define ACPI_BTYPE_DATA_REFERENCE       (ACPI_BTYPE_DATA | ACPI_BTYPE_REFERENCE | ACPI_BTYPE_DDB_HANDLE)
#define ACPI_BTYPE_DEVICE_OBJECTS       (ACPI_BTYPE_DEVICE | ACPI_BTYPE_THERMAL | ACPI_BTYPE_PROCESSOR)
#define ACPI_BTYPE_OBJECTS_AND_REFS     0x0001FFFF  /* ARG or LOCAL */
#define ACPI_BTYPE_ALL_OBJECTS          0x0000FFFF


/*****************************************************************************
 *
 * Event typedefs and structs
 *
 ****************************************************************************/

/* Dispatch info for each GPE -- either a method or handler, cannot be both */

typedef struct acpi_handler_info
{
    ACPI_EVENT_HANDLER              Address;        /* Address of handler, if any */
    void                            *Context;       /* Context to be passed to handler */
    ACPI_NAMESPACE_NODE             *MethodNode;    /* Method node for this GPE level (saved) */

} ACPI_HANDLER_INFO;

typedef union acpi_gpe_dispatch_info
{
    ACPI_NAMESPACE_NODE             *MethodNode;    /* Method node for this GPE level */
    struct acpi_handler_info        *Handler;

} ACPI_GPE_DISPATCH_INFO;

/*
 * Information about a GPE, one per each GPE in an array.
 * NOTE: Important to keep this struct as small as possible.
 */
typedef struct acpi_gpe_event_info
{
    union acpi_gpe_dispatch_info    Dispatch;       /* Either Method or Handler */
    struct acpi_gpe_register_info   *RegisterInfo;  /* Backpointer to register info */
    UINT8                           Flags;          /* Misc info about this GPE */
    UINT8                           GpeNumber;      /* This GPE */

} ACPI_GPE_EVENT_INFO;

/* Information about a GPE register pair, one per each status/enable pair in an array */

typedef struct acpi_gpe_register_info
{
    ACPI_GENERIC_ADDRESS            StatusAddress;  /* Address of status reg */
    ACPI_GENERIC_ADDRESS            EnableAddress;  /* Address of enable reg */
    UINT8                           EnableForWake;  /* GPEs to keep enabled when sleeping */
    UINT8                           EnableForRun;   /* GPEs to keep enabled when running */
    UINT8                           BaseGpeNumber;  /* Base GPE number for this register */

} ACPI_GPE_REGISTER_INFO;

/*
 * Information about a GPE register block, one per each installed block --
 * GPE0, GPE1, and one per each installed GPE Block Device.
 */
typedef struct acpi_gpe_block_info
{
    ACPI_NAMESPACE_NODE             *Node;
    struct acpi_gpe_block_info      *Previous;
    struct acpi_gpe_block_info      *Next;
    struct acpi_gpe_xrupt_info      *XruptBlock;    /* Backpointer to interrupt block */
    ACPI_GPE_REGISTER_INFO          *RegisterInfo;  /* One per GPE register pair */
    ACPI_GPE_EVENT_INFO             *EventInfo;     /* One for each GPE */
    ACPI_GENERIC_ADDRESS            BlockAddress;   /* Base address of the block */
    UINT32                          RegisterCount;  /* Number of register pairs in block */
    UINT8                           BlockBaseNumber;/* Base GPE number for this block */

} ACPI_GPE_BLOCK_INFO;

/* Information about GPE interrupt handlers, one per each interrupt level used for GPEs */

typedef struct acpi_gpe_xrupt_info
{
    struct acpi_gpe_xrupt_info      *Previous;
    struct acpi_gpe_xrupt_info      *Next;
    ACPI_GPE_BLOCK_INFO             *GpeBlockListHead;  /* List of GPE blocks for this xrupt */
    UINT32                          InterruptNumber;    /* System interrupt number */

} ACPI_GPE_XRUPT_INFO;


typedef struct acpi_gpe_walk_info
{
    ACPI_NAMESPACE_NODE             *GpeDevice;
    ACPI_GPE_BLOCK_INFO             *GpeBlock;

} ACPI_GPE_WALK_INFO;


typedef ACPI_STATUS (*ACPI_GPE_CALLBACK) (
    ACPI_GPE_XRUPT_INFO             *GpeXruptInfo,
    ACPI_GPE_BLOCK_INFO             *GpeBlock);


/* Information about each particular fixed event */

typedef struct acpi_fixed_event_handler
{
    ACPI_EVENT_HANDLER              Handler;        /* Address of handler. */
    void                            *Context;       /* Context to be passed to handler */

} ACPI_FIXED_EVENT_HANDLER;

typedef struct acpi_fixed_event_info
{
    UINT8                           StatusRegisterId;
    UINT8                           EnableRegisterId;
    UINT16                          StatusBitMask;
    UINT16                          EnableBitMask;

} ACPI_FIXED_EVENT_INFO;

/* Information used during field processing */

typedef struct acpi_field_info
{
    UINT8                           SkipField;
    UINT8                           FieldFlag;
    UINT32                          PkgLength;

} ACPI_FIELD_INFO;


/*****************************************************************************
 *
 * Generic "state" object for stacks
 *
 ****************************************************************************/

#define ACPI_CONTROL_NORMAL                  0xC0
#define ACPI_CONTROL_CONDITIONAL_EXECUTING   0xC1
#define ACPI_CONTROL_PREDICATE_EXECUTING     0xC2
#define ACPI_CONTROL_PREDICATE_FALSE         0xC3
#define ACPI_CONTROL_PREDICATE_TRUE          0xC4


#define ACPI_STATE_COMMON \
    void                            *Next; \
    UINT8                           DescriptorType; /* To differentiate various internal objs */\
    UINT8                           Flags; \
    UINT16                          Value; \
    UINT16                          State;

    /* There are 2 bytes available here until the next natural alignment boundary */

typedef struct acpi_common_state
{
    ACPI_STATE_COMMON
} ACPI_COMMON_STATE;


/*
 * Update state - used to traverse complex objects such as packages
 */
typedef struct acpi_update_state
{
    ACPI_STATE_COMMON
    union acpi_operand_object       *Object;

} ACPI_UPDATE_STATE;


/*
 * Pkg state - used to traverse nested package structures
 */
typedef struct acpi_pkg_state
{
    ACPI_STATE_COMMON
    UINT16                          Index;
    union acpi_operand_object       *SourceObject;
    union acpi_operand_object       *DestObject;
    struct acpi_walk_state          *WalkState;
    void                            *ThisTargetObj;
    UINT32                          NumPackages;

} ACPI_PKG_STATE;


/*
 * Control state - one per if/else and while constructs.
 * Allows nesting of these constructs
 */
typedef struct acpi_control_state
{
    ACPI_STATE_COMMON
    UINT16                          Opcode;
    union acpi_parse_object         *PredicateOp;
    UINT8                           *AmlPredicateStart;     /* Start of if/while predicate */
    UINT8                           *PackageEnd;            /* End of if/while block */

} ACPI_CONTROL_STATE;


/*
 * Scope state - current scope during namespace lookups
 */
typedef struct acpi_scope_state
{
    ACPI_STATE_COMMON
    ACPI_NAMESPACE_NODE             *Node;

} ACPI_SCOPE_STATE;


typedef struct acpi_pscope_state
{
    ACPI_STATE_COMMON
    UINT32                          ArgCount;               /* Number of fixed arguments */
    union acpi_parse_object         *Op;                    /* Current op being parsed */
    UINT8                           *ArgEnd;                /* Current argument end */
    UINT8                           *PkgEnd;                /* Current package end */
    UINT32                          ArgList;                /* Next argument to parse */

} ACPI_PSCOPE_STATE;


/*
 * Thread state - one per thread across multiple walk states.  Multiple walk
 * states are created when there are nested control methods executing.
 */
typedef struct acpi_thread_state
{
    ACPI_STATE_COMMON
    UINT8                           CurrentSyncLevel;       /* Mutex Sync (nested acquire) level */
    struct acpi_walk_state          *WalkStateList;         /* Head of list of WalkStates for this thread */
    union acpi_operand_object       *AcquiredMutexList;     /* List of all currently acquired mutexes */
    ACPI_THREAD_ID                  ThreadId;               /* Running thread ID */

} ACPI_THREAD_STATE;


/*
 * Result values - used to accumulate the results of nested
 * AML arguments
 */
typedef struct acpi_result_values
{
    ACPI_STATE_COMMON
    union acpi_operand_object       *ObjDesc [ACPI_RESULTS_FRAME_OBJ_NUM];

} ACPI_RESULT_VALUES;


typedef
ACPI_STATUS (*ACPI_PARSE_DOWNWARDS) (
    struct acpi_walk_state          *WalkState,
    union acpi_parse_object         **OutOp);

typedef
ACPI_STATUS (*ACPI_PARSE_UPWARDS) (
    struct acpi_walk_state          *WalkState);


/*
 * Notify info - used to pass info to the deferred notify
 * handler/dispatcher.
 */
typedef struct acpi_notify_info
{
    ACPI_STATE_COMMON
    ACPI_NAMESPACE_NODE             *Node;
    union acpi_operand_object       *HandlerObj;

} ACPI_NOTIFY_INFO;


/* Generic state is union of structs above */

typedef union acpi_generic_state
{
    ACPI_COMMON_STATE               Common;
    ACPI_CONTROL_STATE              Control;
    ACPI_UPDATE_STATE               Update;
    ACPI_SCOPE_STATE                Scope;
    ACPI_PSCOPE_STATE               ParseScope;
    ACPI_PKG_STATE                  Pkg;
    ACPI_THREAD_STATE               Thread;
    ACPI_RESULT_VALUES              Results;
    ACPI_NOTIFY_INFO                Notify;

} ACPI_GENERIC_STATE;


/*****************************************************************************
 *
 * Interpreter typedefs and structs
 *
 ****************************************************************************/

typedef
ACPI_STATUS (*ACPI_EXECUTE_OP) (
    struct acpi_walk_state          *WalkState);


/*****************************************************************************
 *
 * Parser typedefs and structs
 *
 ****************************************************************************/

/*
 * AML opcode, name, and argument layout
 */
typedef struct acpi_opcode_info
{
#if defined(ACPI_DISASSEMBLER) || defined(ACPI_DEBUG_OUTPUT)
    char                            *Name;          /* Opcode name (disassembler/debug only) */
#endif
    UINT32                          ParseArgs;      /* Grammar/Parse time arguments */
    UINT32                          RuntimeArgs;    /* Interpret time arguments */
    UINT16                          Flags;          /* Misc flags */
    UINT8                           ObjectType;     /* Corresponding internal object type */
    UINT8                           Class;          /* Opcode class */
    UINT8                           Type;           /* Opcode type */

} ACPI_OPCODE_INFO;

typedef union acpi_parse_value
{
    ACPI_INTEGER                    Integer;        /* Integer constant (Up to 64 bits) */
    UINT64_STRUCT                   Integer64;      /* Structure overlay for 2 32-bit Dwords */
    UINT32                          Size;           /* bytelist or field size */
    char                            *String;        /* NULL terminated string */
    UINT8                           *Buffer;        /* buffer or string */
    char                            *Name;          /* NULL terminated string */
    union acpi_parse_object         *Arg;           /* arguments and contained ops */

} ACPI_PARSE_VALUE;

#define ACPI_PARSE_COMMON \
    union acpi_parse_object         *Parent;        /* Parent op */\
    UINT8                           DescriptorType; /* To differentiate various internal objs */\
    UINT8                           Flags;          /* Type of Op */\
    UINT16                          AmlOpcode;      /* AML opcode */\
    UINT32                          AmlOffset;      /* Offset of declaration in AML */\
    union acpi_parse_object         *Next;          /* Next op */\
    ACPI_NAMESPACE_NODE             *Node;          /* For use by interpreter */\
    ACPI_PARSE_VALUE                Value;          /* Value or args associated with the opcode */\
    UINT8                           ArgListLength;  /* Number of elements in the arg list */\
    ACPI_DISASM_ONLY_MEMBERS (\
    UINT8                           DisasmFlags;    /* Used during AML disassembly */\
    UINT8                           DisasmOpcode;   /* Subtype used for disassembly */\
    char                            AmlOpName[16])  /* Op name (debug only) */