/****************************************************************************** * * Name: aclocal.h - Internal data types used across the ACPI subsystem * *****************************************************************************/ /* * Copyright (C) 2000 - 2006, R. Byron Moore * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions, and the following disclaimer, *    without modification. * 2. Redistributions in binary form must reproduce at minimum a disclaimer *    substantially similar to the "NO WARRANTY" disclaimer below *    ("Disclaimer") and any redistribution must be conditioned upon *    including a substantially similar Disclaimer requirement for further *    binary redistribution. * 3. Neither the names of the above-listed copyright holders nor the names *    of any contributors may be used to endorse or promote products derived *    from this software without specific prior written permission. * * Alternatively, this software may be distributed under the terms of the * GNU General Public License ("GPL") version 2 as published by the Free * Software Foundation. * * NO WARRANTY * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGES. */ #ifndef __ACLOCAL_H__#define __ACLOCAL_H__ #define ACPI_WAIT_FOREVER               0xFFFF	/* u16, as per ACPI spec */ typedef void *acpi_mutex;typedef u32 acpi_mutex_handle; /* Total number of aml opcodes defined */ #define AML_NUM_OPCODES                 0x7F /* Forward declarations */ struct acpi_walk_state;struct acpi_obj_mutex;union acpi_parse_object; /***************************************************************************** * * Mutex typedefs and structs * ****************************************************************************/ /* * Predefined handles for the mutex objects used within the subsystem * All mutex objects are automatically created by acpi_ut_mutex_initialize. * * The acquire/release ordering protocol is implied via this list.  Mutexes * with a lower value must be acquired before mutexes with a higher value. * * NOTE: any changes here must be reflected in the acpi_gbl_mutex_names table also! */#define ACPI_MTX_EXECUTE                0#define ACPI_MTX_INTERPRETER            1#define ACPI_MTX_PARSER                 2#define ACPI_MTX_DISPATCHER             3#define ACPI_MTX_TABLES                 4#define ACPI_MTX_OP_REGIONS             5#define ACPI_MTX_NAMESPACE              6#define ACPI_MTX_EVENTS                 7#define ACPI_MTX_HARDWARE               8#define ACPI_MTX_CACHES                 9#define ACPI_MTX_MEMORY                 10#define ACPI_MTX_DEBUG_CMD_COMPLETE     11#define ACPI_MTX_DEBUG_CMD_READY        12 #define MAX_MUTEX                       12#define NUM_MUTEX                       MAX_MUTEX+1 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)#ifdef DEFINE_ACPI_GLOBALS /* Names for the mutexes used in the subsystem */ static char *acpi_gbl_mutex_names[] = {	"ACPI_MTX_Execute",	"ACPI_MTX_Interpreter",	"ACPI_MTX_Parser",	"ACPI_MTX_Dispatcher",	"ACPI_MTX_Tables",	"ACPI_MTX_op_regions",	"ACPI_MTX_Namespace",	"ACPI_MTX_Events",	"ACPI_MTX_Hardware",	"ACPI_MTX_Caches",	"ACPI_MTX_Memory",	"ACPI_MTX_debug_cmd_complete",	"ACPI_MTX_debug_cmd_ready",}; #endif#endif /* Owner IDs are used to track namespace nodes for selective deletion */ typedef u8 acpi_owner_id;#define ACPI_OWNER_ID_MAX               0xFF /* This Thread ID means that the mutex is not in use (unlocked) */ #define ACPI_MUTEX_NOT_ACQUIRED         (u32) -1 /* Table for the global mutexes */ struct acpi_mutex_info {	acpi_mutex mutex;	u32 use_count;	u32 thread_id;}; /* Lock flag parameter for various interfaces */ #define ACPI_MTX_DO_NOT_LOCK            0#define ACPI_MTX_LOCK                   1 /* Field access granularities */ #define ACPI_FIELD_BYTE_GRANULARITY     1#define ACPI_FIELD_WORD_GRANULARITY     2#define ACPI_FIELD_DWORD_GRANULARITY    4#define ACPI_FIELD_QWORD_GRANULARITY    8 /***************************************************************************** * * Namespace typedefs and structs * ****************************************************************************/ /* Operational modes of the AML interpreter/scanner */ typedef enum {	ACPI_IMODE_LOAD_PASS1 = 0x01,	ACPI_IMODE_LOAD_PASS2 = 0x02,	ACPI_IMODE_EXECUTE = 0x0E} acpi_interpreter_mode; /* * The Node describes a named object that appears in the AML * An acpi_node is used to store Nodes. * * data_type is used to differentiate between internal descriptors, and MUST * be the first byte in this structure. */union acpi_name_union {	u32 integer;	char ascii[4];}; struct acpi_namespace_node {	u8 descriptor;		/* Used to differentiate object descriptor types */	u8 type;		/* Type associated with this name */	u16 reference_count;	/* Current count of references and children */	union acpi_name_union name;	/* ACPI Name, always 4 chars per ACPI spec */	union acpi_operand_object *object;	/* Pointer to attached ACPI object (optional) */	struct acpi_namespace_node *child;	/* First child */	struct acpi_namespace_node *peer;	/* Next peer */	u8 owner_id;		/* Who created this node */	u8 flags; 	/* Fields used by the ASL compiler only */ #ifdef ACPI_ASL_COMPILER	u32 value;	union acpi_parse_object *op;#endif}; #define ACPI_ENTRY_NOT_FOUND            NULL /* Node flags */ #define ANOBJ_RESERVED                  0x01#define ANOBJ_END_OF_PEER_LIST          0x02#define ANOBJ_DATA_WIDTH_32             0x04	/* Parent table is 64-bits */#define ANOBJ_METHOD_ARG                0x08#define ANOBJ_METHOD_LOCAL              0x10#define ANOBJ_METHOD_NO_RETVAL          0x20#define ANOBJ_METHOD_SOME_NO_RETVAL     0x40#define ANOBJ_IS_BIT_OFFSET             0x80 /* * ACPI Table Descriptor.  One per ACPI table */struct acpi_table_desc {	struct acpi_table_desc *prev;	struct acpi_table_desc *next;	struct acpi_table_desc *installed_desc;	struct acpi_table_header *pointer;	u8 *aml_start;	u64 physical_address;	u32 aml_length;	acpi_size length;	acpi_owner_id owner_id;	u8 type;	u8 allocation;	u8 loaded_into_namespace;}; struct acpi_table_list {	struct acpi_table_desc *next;	u32 count;}; struct acpi_find_context {	char *search_for;	acpi_handle *list;	u32 *count;}; struct acpi_ns_search_data {	struct acpi_namespace_node *node;}; /* * Predefined Namespace items */struct acpi_predefined_names {	char *name;	u8 type;	char *val;}; /* Object types used during package copies */ #define ACPI_COPY_TYPE_SIMPLE           0#define ACPI_COPY_TYPE_PACKAGE          1 /* Info structure used to convert external<->internal namestrings */ struct acpi_namestring_info {	char *external_name;	char *next_external_char;	char *internal_name;	u32 length;	u32 num_segments;	u32 num_carats;	u8 fully_qualified;}; /* Field creation info */ struct acpi_create_field_info {	struct acpi_namespace_node *region_node;	struct acpi_namespace_node *field_node;	struct acpi_namespace_node *register_node;	struct acpi_namespace_node *data_register_node;	u32 bank_value;	u32 field_bit_position;	u32 field_bit_length;	u8 field_flags;	u8 attribute;	u8 field_type;}; /* * 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 */ struct acpi_handler_info {	acpi_event_handler address;	/* Address of handler, if any */	void *context;		/* Context to be passed to handler */	struct acpi_namespace_node *method_node;	/* Method node for this GPE level (saved) */}; union acpi_gpe_dispatch_info {	struct acpi_namespace_node *method_node;	/* Method node for this GPE level */	struct acpi_handler_info *handler;}; /* * Information about a GPE, one per each GPE in an array. * NOTE: Important to keep this struct as small as possible. */struct acpi_gpe_event_info {	union acpi_gpe_dispatch_info dispatch;	/* Either Method or Handler */	struct acpi_gpe_register_info *register_info;	/* Backpointer to register info */	u8 flags;		/* Misc info about this GPE */	u8 register_bit;	/* This GPE bit within the register */}; /* Information about a GPE register pair, one per each status/enable pair in an array */ struct acpi_gpe_register_info {	struct acpi_generic_address status_address;	/* Address of status reg */	struct acpi_generic_address enable_address;	/* Address of enable reg */	u8 enable_for_wake;	/* GPEs to keep enabled when sleeping */	u8 enable_for_run;	/* GPEs to keep enabled when running */	u8 base_gpe_number;	/* Base GPE number for this register */}; /* * Information about a GPE register block, one per each installed block -- * GPE0, GPE1, and one per each installed GPE Block Device. */struct acpi_gpe_block_info {	struct acpi_namespace_node *node;	struct acpi_gpe_block_info *previous;	struct acpi_gpe_block_info *next;	struct acpi_gpe_xrupt_info *xrupt_block;	/* Backpointer to interrupt block */	struct acpi_gpe_register_info *register_info;	/* One per GPE register pair */	struct acpi_gpe_event_info *event_info;	/* One for each GPE */	struct acpi_generic_address block_address;	/* Base address of the block */	u32 register_count;	/* Number of register pairs in block */	u8 block_base_number;	/* Base GPE number for this block */}; /* Information about GPE interrupt handlers, one per each interrupt level used for GPEs */ struct acpi_gpe_xrupt_info {	struct acpi_gpe_xrupt_info *previous;	struct acpi_gpe_xrupt_info *next;	struct acpi_gpe_block_info *gpe_block_list_head;	/* List of GPE blocks for this xrupt */	u32 interrupt_number;	/* System interrupt number */}; struct acpi_gpe_walk_info {	struct acpi_namespace_node *gpe_device;	struct acpi_gpe_block_info *gpe_block;}; typedef acpi_status(*ACPI_GPE_CALLBACK) (struct acpi_gpe_xrupt_info *					 gpe_xrupt_info,					 struct acpi_gpe_block_info *					 gpe_block); /* Information about each particular fixed event */ struct acpi_fixed_event_handler {	acpi_event_handler handler;	/* Address of handler. */	void *context;		/* Context to be passed to handler */}; struct acpi_fixed_event_info {	u8 status_register_id;	u8 enable_register_id;	u16 status_bit_mask;	u16 enable_bit_mask;}; /* Information used during field processing */ struct acpi_field_info {	u8 skip_field;	u8 field_flag;	u32 pkg_length;}; /***************************************************************************** * * 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   /* Two 32-bit fields and a pointer */\	u8                                  data_type;  /* To differentiate various internal objs */\	u8                                  flags;      \	u16                                 value;      \	u16                                 state;      \	u16                                 reserved;   \	void                                *next; struct acpi_common_state {ACPI_STATE_COMMON}; /* * Update state - used to traverse complex objects such as packages */struct acpi_update_state {	ACPI_STATE_COMMON union acpi_operand_object *object;}; /* * Pkg state - used to traverse nested package structures */struct acpi_pkg_state {	ACPI_STATE_COMMON union acpi_operand_object *source_object;	union acpi_operand_object *dest_object;	struct acpi_walk_state *walk_state;	void *this_target_obj;	u32 num_packages;	u16 index;}; /* * Control state - one per if/else and while constructs. * Allows nesting of these constructs */struct acpi_control_state {	ACPI_STATE_COMMON union acpi_parse_object *predicate_op;	u8 *aml_predicate_start;	/* Start of if/while predicate */	u8 *package_end;	/* End of if/while block */	u16 opcode;}; /* * Scope state - current scope during namespace lookups */struct acpi_scope_state {	ACPI_STATE_COMMON struct acpi_namespace_node *node;}; struct acpi_pscope_state {	ACPI_STATE_COMMON union acpi_parse_object *op;	/* Current op being parsed */	u8 *arg_end;		/* Current argument end */	u8 *pkg_end;		/* Current package end */	u32 arg_list;		/* Next argument to parse */	u32 arg_count;		/* Number of fixed arguments */}; /* * Thread state - one per thread across multiple walk states.  Multiple walk * states are created when there are nested control methods executing. */struct acpi_thread_state {	ACPI_STATE_COMMON struct acpi_walk_state *walk_state_list;	/* Head of list of walk_states for this thread */	union acpi_operand_object *acquired_mutex_list;	/* List of all currently acquired mutexes */	u32 thread_id;		/* Running thread ID */	u8 current_sync_level;	/* Mutex Sync (nested acquire) level */}; /* * Result values - used to accumulate the results of nested * AML arguments */struct acpi_result_values {	ACPI_STATE_COMMON	    union acpi_operand_object *obj_desc[ACPI_OBJ_NUM_OPERANDS];	u8 num_results;	u8 last_insert;}; typedefacpi_status(*acpi_parse_downwards) (struct acpi_walk_state * walk_state,				    union acpi_parse_object ** out_op); 

Lines 1–500 of 902. Load more