Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 091f4d718620a79698e1c8ca3e9acbf78eb62da3

Authored by Bob Moore 2010-01-21 09:28:32 +0800

Committed by Len Brown 2010-01-23 01:30:06 +0800

Exists in master and in 7 other branches

ACPICA: Predefined name repair: fix NULL package elements

For the predefined methods that return fixed-length packages
(or subpackages), attempt repair for a NULL element. Create an
Integer of value 0, a NULL String, or a zero-length buffer as
appropriate.

http://www.acpica.org/bugzilla/show_bug.cgi?id=818

Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Lin Ming <ming.m.lin@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>

Showing 5 changed files with 209 additions and 92 deletions Inline Diff

drivers/acpi/acpica/aclocal.h
drivers/acpi/acpica/acnamesp.h
drivers/acpi/acpica/nspredef.c
drivers/acpi/acpica/nsrepair.c
drivers/acpi/acpica/nsrepair2.c

drivers/acpi/acpica/aclocal.h

Diff comments View file @ 091f4d7

 /******************************************************************************
  *
  * Name: aclocal.h - Internal data types used across the ACPI subsystem
  *
  *****************************************************************************/
 /*
  * Copyright (C) 2000 - 2010, Intel Corp.
  * 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__
 /* acpisrc:struct_defs -- for acpisrc conversion */
 #define ACPI_SERIALIZED                 0xFF
 typedef u32 acpi_mutex_handle;
 #define ACPI_GLOBAL_LOCK                (acpi_semaphore) (-1)
 /* 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 below also!
  */
 #define ACPI_MTX_INTERPRETER            0	/* AML Interpreter, main lock */
 #define ACPI_MTX_NAMESPACE              1	/* ACPI Namespace */
 #define ACPI_MTX_TABLES                 2	/* Data for ACPI tables */
 #define ACPI_MTX_EVENTS                 3	/* Data for ACPI events */
 #define ACPI_MTX_CACHES                 4	/* Internal caches, general purposes */
 #define ACPI_MTX_MEMORY                 5	/* Debug memory tracking lists */
 #define ACPI_MTX_DEBUG_CMD_COMPLETE     6	/* AML debugger */
 #define ACPI_MTX_DEBUG_CMD_READY        7	/* AML debugger */
 #define ACPI_MAX_MUTEX                  7
 #define ACPI_NUM_MUTEX                  ACPI_MAX_MUTEX+1
 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
 #ifdef DEFINE_ACPI_GLOBALS
 /* Debug names for the mutexes above */
 static char *acpi_gbl_mutex_names[ACPI_NUM_MUTEX] = {
 	"ACPI_MTX_Interpreter",
 	"ACPI_MTX_Namespace",
 	"ACPI_MTX_Tables",
 	"ACPI_MTX_Events",
 	"ACPI_MTX_Caches",
 	"ACPI_MTX_Memory",
 	"ACPI_MTX_CommandComplete",
 	"ACPI_MTX_CommandReady"
 };
 #endif
 #endif
 /* Lock structure for reader/writer interfaces */
 struct acpi_rw_lock {
 	acpi_mutex writer_mutex;
 	acpi_mutex reader_mutex;
 	u32 num_readers;
 };
 /*
  * Predefined handles for spinlocks used within the subsystem.
  * These spinlocks are created by acpi_ut_mutex_initialize
  */
 #define ACPI_LOCK_GPES                  0
 #define ACPI_LOCK_HARDWARE              1
 #define ACPI_MAX_LOCK                   1
 #define ACPI_NUM_LOCK                   ACPI_MAX_LOCK+1
 /* This Thread ID means that the mutex is not in use (unlocked) */
 #define ACPI_MUTEX_NOT_ACQUIRED         (acpi_thread_id) 0
 /* Table for the global mutexes */
 struct acpi_mutex_info {
 	acpi_mutex mutex;
 	u32 use_count;
 	acpi_thread_id 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
 #define ACPI_ENTRY_NOT_FOUND            NULL
 /*****************************************************************************
  *
  * 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 = 0x03
 } acpi_interpreter_mode;
 /*
  * The Namespace Node describes a named object that appears in the AML.
  * descriptor_type is used to differentiate between internal descriptors.
  *
  * The node is optimized for both 32-bit and 64-bit platforms:
  * 20 bytes for the 32-bit case, 32 bytes for the 64-bit case.
  *
  * Note: The descriptor_type and Type fields must appear in the identical
  * position in both the struct acpi_namespace_node and union acpi_operand_object
  * structures.
  */
 struct acpi_namespace_node {
 	union acpi_operand_object *object;	/* Interpreter object */
 	u8 descriptor_type;	/* Differentiate object descriptor types */
 	u8 type;		/* ACPI Type associated with this name */
 	u8 flags;		/* Miscellaneous flags */
 	acpi_owner_id owner_id;	/* Node creator */
 	union acpi_name_union name;	/* ACPI Name, always 4 chars per ACPI spec */
 	struct acpi_namespace_node *child;	/* First child */
 	struct acpi_namespace_node *peer;	/* Peer. Parent if ANOBJ_END_OF_PEER_LIST set */
 	/*
 	 * The following fields are used by the ASL compiler and disassembler only
 	 */
 #ifdef ACPI_LARGE_NAMESPACE_NODE
 	union acpi_parse_object *op;
 	u32 value;
 	u32 length;
 #endif
 };
 /* Namespace Node flags */
 #define ANOBJ_END_OF_PEER_LIST          0x01	/* End-of-list, Peer field points to parent */
 #define ANOBJ_TEMPORARY                 0x02	/* Node is create by a method and is temporary */
 #define ANOBJ_METHOD_ARG                0x04	/* Node is a method argument */
 #define ANOBJ_METHOD_LOCAL              0x08	/* Node is a method local */
 #define ANOBJ_SUBTREE_HAS_INI           0x10	/* Used to optimize device initialization */
 #define ANOBJ_EVALUATED                 0x20	/* Set on first evaluation of node */
 #define ANOBJ_ALLOCATED_BUFFER          0x40	/* Method AML buffer is dynamic (install_method) */
 #define ANOBJ_IS_EXTERNAL               0x08	/* i_aSL only: This object created via External() */
 #define ANOBJ_METHOD_NO_RETVAL          0x10	/* i_aSL only: Method has no return value */
 #define ANOBJ_METHOD_SOME_NO_RETVAL     0x20	/* i_aSL only: Method has at least one return value */
 #define ANOBJ_IS_BIT_OFFSET             0x40	/* i_aSL only: Reference is a bit offset */
 #define ANOBJ_IS_REFERENCED             0x80	/* i_aSL only: Object was referenced */
 /* One internal RSDT for table management */
 struct acpi_internal_rsdt {
 	struct acpi_table_desc *tables;
 	u32 count;
 	u32 size;
 	u8 flags;
 };
 /* Flags for above */
 #define ACPI_ROOT_ORIGIN_UNKNOWN        (0)	/* ~ORIGIN_ALLOCATED */
 #define ACPI_ROOT_ORIGIN_ALLOCATED      (1)
 #define ACPI_ROOT_ALLOW_RESIZE          (2)
 /* Predefined (fixed) table indexes */
 #define ACPI_TABLE_INDEX_DSDT           (0)
 #define ACPI_TABLE_INDEX_FACS           (1)
 struct acpi_find_context {
 	char *search_for;
 	acpi_handle *list;
 	u32 *count;
 };
 struct acpi_ns_search_data {
 	struct acpi_namespace_node *node;
 };
 /* 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 {
 	const char *external_name;
 	const 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;
 };
 typedef
 acpi_status(*ACPI_INTERNAL_METHOD) (struct acpi_walk_state * walk_state);
 /*
  * 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
 /*
  * Information structure for ACPI predefined names.
  * Each entry in the table contains the following items:
  *
  * Name                 - The ACPI reserved name
  * param_count          - Number of arguments to the method
  * expected_return_btypes - Allowed type(s) for the return value
  */
 struct acpi_name_info {
 	char name[ACPI_NAME_SIZE];
 	u8 param_count;
 	u8 expected_btypes;
 };
 /*
  * Secondary information structures for ACPI predefined objects that return
  * package objects. This structure appears as the next entry in the table
  * after the NAME_INFO structure above.
  *
  * The reason for this is to minimize the size of the predefined name table.
  */
 /*
  * Used for ACPI_PTYPE1_FIXED, ACPI_PTYPE1_VAR, ACPI_PTYPE2,
  * ACPI_PTYPE2_MIN, ACPI_PTYPE2_PKG_COUNT, ACPI_PTYPE2_COUNT
  */
 struct acpi_package_info {
 	u8 type;
 	u8 object_type1;
 	u8 count1;
 	u8 object_type2;
 	u8 count2;
 	u8 reserved;
 };
 /* Used for ACPI_PTYPE2_FIXED */
 struct acpi_package_info2 {
 	u8 type;
 	u8 count;
 	u8 object_type[4];
 };
 /* Used for ACPI_PTYPE1_OPTION */
 struct acpi_package_info3 {
 	u8 type;
 	u8 count;
 	u8 object_type[2];
 	u8 tail_object_type;
 	u8 reserved;
 };
 union acpi_predefined_info {
 	struct acpi_name_info info;
 	struct acpi_package_info ret_info;
 	struct acpi_package_info2 ret_info2;
 	struct acpi_package_info3 ret_info3;
 };
 /* Data block used during object validation */
 struct acpi_predefined_data {
 	char *pathname;
 	const union acpi_predefined_info *predefined;
+	union acpi_operand_object *parent_package;
 	u32 flags;
 	u8 node_flags;
 };
 /* Defines for Flags field above */
 #define ACPI_OBJECT_REPAIRED    1
 /*
  * Bitmapped return value types
  * Note: the actual data types must be contiguous, a loop in nspredef.c
  * depends on this.
  */
 #define ACPI_RTYPE_ANY                  0x00
 #define ACPI_RTYPE_NONE                 0x01
 #define ACPI_RTYPE_INTEGER              0x02
 #define ACPI_RTYPE_STRING               0x04
 #define ACPI_RTYPE_BUFFER               0x08
 #define ACPI_RTYPE_PACKAGE              0x10
 #define ACPI_RTYPE_REFERENCE            0x20
 #define ACPI_RTYPE_ALL                  0x3F
 #define ACPI_NUM_RTYPES                 5	/* Number of actual object types */
 /*****************************************************************************
  *
  * 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 gpe_number;		/* This GPE */
 };
 /* 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;
 };
 struct acpi_gpe_device_info {
 	u32 index;
 	u32 next_block_base_index;
 	acpi_status status;
 	struct acpi_namespace_node *gpe_device;
 };
 typedef acpi_status(*acpi_gpe_callback) (struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 		struct acpi_gpe_block_info *gpe_block, void *context);
 /* 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 \
 	void                            *next; \
 	u8                              descriptor_type; /* To differentiate various internal objs */\
 	u8                              flags; \
 	u16                             value; \
 	u16                             state;
 	/* There are 2 bytes available here until the next natural alignment boundary */
 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 u16 index;
 	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;
 };
 /*
  * Control state - one per if/else and while constructs.
  * Allows nesting of these constructs
  */
 struct acpi_control_state {
 	ACPI_STATE_COMMON u16 opcode;
 	union acpi_parse_object *predicate_op;
 	u8 *aml_predicate_start;	/* Start of if/while predicate */
 	u8 *package_end;	/* End of if/while block */
 	u32 loop_count;		/* While() loop counter */
 };
 /*
  * 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 u32 arg_count;	/* Number of fixed arguments */
 	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 */
 };
 /*
  * 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 u8 current_sync_level;	/* Mutex Sync (nested acquire) level */
 	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 */
 	acpi_thread_id thread_id;	/* Running thread ID */
 };
 /*
  * 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_RESULTS_FRAME_OBJ_NUM];
 };
 typedef
 acpi_status(*acpi_parse_downwards) (struct acpi_walk_state * walk_state,
 				    union acpi_parse_object ** out_op);
 typedef acpi_status(*acpi_parse_upwards) (struct acpi_walk_state * walk_state);
 /*
  * Notify info - used to pass info to the deferred notify
  * handler/dispatcher.
  */
 struct acpi_notify_info {
 	ACPI_STATE_COMMON struct acpi_namespace_node *node;
 	union acpi_operand_object *handler_obj;
 };
 /* Generic state is union of structs above */
 union acpi_generic_state {
 	struct acpi_common_state common;
 	struct acpi_control_state control;
 	struct acpi_update_state update;
 	struct acpi_scope_state scope;
 	struct acpi_pscope_state parse_scope;
 	struct acpi_pkg_state pkg;
 	struct acpi_thread_state thread;
 	struct acpi_result_values results;
 	struct acpi_notify_info notify;
 };
 /*****************************************************************************
  *
  * Interpreter typedefs and structs
  *
  ****************************************************************************/
 typedef acpi_status(*ACPI_EXECUTE_OP) (struct acpi_walk_state * walk_state);
 /*****************************************************************************
  *
  * Parser typedefs and structs
  *
  ****************************************************************************/
 /*
  * AML opcode, name, and argument layout
  */
 struct acpi_opcode_info {
 #if defined(ACPI_DISASSEMBLER) || defined(ACPI_DEBUG_OUTPUT)
 	char *name;		/* Opcode name (disassembler/debug only) */
 #endif
 	u32 parse_args;		/* Grammar/Parse time arguments */
 	u32 runtime_args;	/* Interpret time arguments */
 	u16 flags;		/* Misc flags */
 	u8 object_type;		/* Corresponding internal object type */
 	u8 class;		/* Opcode class */
 	u8 type;		/* Opcode type */
 };
 union acpi_parse_value {
 	acpi_integer integer;	/* Integer constant (Up to 64 bits) */
 	struct uint64_struct integer64;	/* Structure overlay for 2 32-bit Dwords */
 	u32 size;		/* bytelist or field size */
 	char *string;		/* NULL terminated string */
 	u8 *buffer;		/* buffer or string */
 	char *name;		/* NULL terminated string */
 	union acpi_parse_object *arg;	/* arguments and contained ops */
 };
 #ifdef ACPI_DISASSEMBLER
 #define ACPI_DISASM_ONLY_MEMBERS(a)     a;
 #else
 #define ACPI_DISASM_ONLY_MEMBERS(a)
 #endif
 #define ACPI_PARSE_COMMON \
 	union acpi_parse_object         *parent;        /* Parent op */\
 	u8                              descriptor_type; /* To differentiate various internal objs */\
 	u8                              flags;          /* Type of Op */\
 	u16                             aml_opcode;     /* AML opcode */\
 	u32                             aml_offset;     /* Offset of declaration in AML */\
 	union acpi_parse_object         *next;          /* Next op */\
 	struct acpi_namespace_node      *node;          /* For use by interpreter */\
 	union acpi_parse_value          value;          /* Value or args associated with the opcode */\
 	u8                              arg_list_length; /* Number of elements in the arg list */\
 	ACPI_DISASM_ONLY_MEMBERS (\
 	u8                              disasm_flags;   /* Used during AML disassembly */\
 	u8                              disasm_opcode;  /* Subtype used for disassembly */\
 	char                            aml_op_name[16])	/* Op name (debug only) */
 #define ACPI_DASM_BUFFER                0x00
 #define ACPI_DASM_RESOURCE              0x01
 #define ACPI_DASM_STRING                0x02
 #define ACPI_DASM_UNICODE               0x03
 #define ACPI_DASM_EISAID                0x04
 #define ACPI_DASM_MATCHOP               0x05
 #define ACPI_DASM_LNOT_PREFIX           0x06
 #define ACPI_DASM_LNOT_SUFFIX           0x07
 #define ACPI_DASM_IGNORE                0x08
 /*
  * Generic operation (for example:  If, While, Store)
  */
 struct acpi_parse_obj_common {
 ACPI_PARSE_COMMON};
 /*
  * Extended Op for named ops (Scope, Method, etc.), deferred ops (Methods and op_regions),
  * and bytelists.
  */
 struct acpi_parse_obj_named {
 	ACPI_PARSE_COMMON u8 *path;
 	u8 *data;		/* AML body or bytelist data */
 	u32 length;		/* AML length */
 	u32 name;		/* 4-byte name or zero if no name */
 };
 /* This version is used by the i_aSL compiler only */
 #define ACPI_MAX_PARSEOP_NAME   20
 struct acpi_parse_obj_asl {
 	ACPI_PARSE_COMMON union acpi_parse_object *child;
 	union acpi_parse_object *parent_method;
 	char *filename;
 	char *external_name;
 	char *namepath;
 	char name_seg[4];
 	u32 extra_value;
 	u32 column;
 	u32 line_number;
 	u32 logical_line_number;
 	u32 logical_byte_offset;
 	u32 end_line;
 	u32 end_logical_line;
 	u32 acpi_btype;
 	u32 aml_length;
 	u32 aml_subtree_length;
 	u32 final_aml_length;
 	u32 final_aml_offset;
 	u32 compile_flags;
 	u16 parse_opcode;
 	u8 aml_opcode_length;
 	u8 aml_pkg_len_bytes;
 	u8 extra;
 	char parse_op_name[ACPI_MAX_PARSEOP_NAME];
 };
 union acpi_parse_object {
 	struct acpi_parse_obj_common common;
 	struct acpi_parse_obj_named named;
 	struct acpi_parse_obj_asl asl;
 };
 /*
  * Parse state - one state per parser invocation and each control
  * method.
  */
 struct acpi_parse_state {
 	u8 *aml_start;		/* First AML byte */
 	u8 *aml;		/* Next AML byte */
 	u8 *aml_end;		/* (last + 1) AML byte */
 	u8 *pkg_start;		/* Current package begin */
 	u8 *pkg_end;		/* Current package end */
 	union acpi_parse_object *start_op;	/* Root of parse tree */
 	struct acpi_namespace_node *start_node;
 	union acpi_generic_state *scope;	/* Current scope */
 	union acpi_parse_object *start_scope;
 	u32 aml_size;
 };
 /* Parse object flags */
 #define ACPI_PARSEOP_GENERIC            0x01
 #define ACPI_PARSEOP_NAMED              0x02
 #define ACPI_PARSEOP_DEFERRED           0x04
 #define ACPI_PARSEOP_BYTELIST           0x08
 #define ACPI_PARSEOP_IN_STACK           0x10
 #define ACPI_PARSEOP_TARGET             0x20
 #define ACPI_PARSEOP_IN_CACHE           0x80
 /* Parse object disasm_flags */
 #define ACPI_PARSEOP_IGNORE             0x01
 #define ACPI_PARSEOP_PARAMLIST          0x02
 #define ACPI_PARSEOP_EMPTY_TERMLIST     0x04
 #define ACPI_PARSEOP_SPECIAL            0x10
 /*****************************************************************************
  *
  * Hardware (ACPI registers) and PNP
  *
  ****************************************************************************/
 struct acpi_bit_register_info {
 	u8 parent_register;
 	u8 bit_position;
 	u16 access_bit_mask;
 };
 /*
  * Some ACPI registers have bits that must be ignored -- meaning that they
  * must be preserved.
  */
 #define ACPI_PM1_STATUS_PRESERVED_BITS          0x0800	/* Bit 11 */
 /* Write-only bits must be zeroed by software */
 #define ACPI_PM1_CONTROL_WRITEONLY_BITS         0x2004	/* Bits 13, 2 */
 /* For control registers, both ignored and reserved bits must be preserved */
 /*
  * For PM1 control, the SCI enable bit (bit 0, SCI_EN) is defined by the
  * ACPI specification to be a "preserved" bit - "OSPM always preserves this
  * bit position", section 4.7.3.2.1. However, on some machines the OS must
  * write a one to this bit after resume for the machine to work properly.
  * To enable this, we no longer attempt to preserve this bit. No machines
  * are known to fail if the bit is not preserved. (May 2009)
  */
 #define ACPI_PM1_CONTROL_IGNORED_BITS           0x0200	/* Bit 9 */
 #define ACPI_PM1_CONTROL_RESERVED_BITS          0xC1F8	/* Bits 14-15, 3-8 */
 #define ACPI_PM1_CONTROL_PRESERVED_BITS \
 	       (ACPI_PM1_CONTROL_IGNORED_BITS | ACPI_PM1_CONTROL_RESERVED_BITS)
 #define ACPI_PM2_CONTROL_PRESERVED_BITS         0xFFFFFFFE	/* All except bit 0 */
 /*
  * Register IDs
  * These are the full ACPI registers
  */
 #define ACPI_REGISTER_PM1_STATUS                0x01
 #define ACPI_REGISTER_PM1_ENABLE                0x02
 #define ACPI_REGISTER_PM1_CONTROL               0x03
 #define ACPI_REGISTER_PM2_CONTROL               0x04
 #define ACPI_REGISTER_PM_TIMER                  0x05
 #define ACPI_REGISTER_PROCESSOR_BLOCK           0x06
 #define ACPI_REGISTER_SMI_COMMAND_BLOCK         0x07
 /* Masks used to access the bit_registers */
 #define ACPI_BITMASK_TIMER_STATUS               0x0001
 #define ACPI_BITMASK_BUS_MASTER_STATUS          0x0010
 #define ACPI_BITMASK_GLOBAL_LOCK_STATUS         0x0020
 #define ACPI_BITMASK_POWER_BUTTON_STATUS        0x0100
 #define ACPI_BITMASK_SLEEP_BUTTON_STATUS        0x0200
 #define ACPI_BITMASK_RT_CLOCK_STATUS            0x0400
 #define ACPI_BITMASK_PCIEXP_WAKE_STATUS         0x4000	/* ACPI 3.0 */
 #define ACPI_BITMASK_WAKE_STATUS                0x8000
 #define ACPI_BITMASK_ALL_FIXED_STATUS           (\
 	ACPI_BITMASK_TIMER_STATUS          | \
 	ACPI_BITMASK_BUS_MASTER_STATUS     | \
 	ACPI_BITMASK_GLOBAL_LOCK_STATUS    | \
 	ACPI_BITMASK_POWER_BUTTON_STATUS   | \
 	ACPI_BITMASK_SLEEP_BUTTON_STATUS   | \
 	ACPI_BITMASK_RT_CLOCK_STATUS       | \
 	ACPI_BITMASK_WAKE_STATUS)
 #define ACPI_BITMASK_TIMER_ENABLE               0x0001
 #define ACPI_BITMASK_GLOBAL_LOCK_ENABLE         0x0020
 #define ACPI_BITMASK_POWER_BUTTON_ENABLE        0x0100
 #define ACPI_BITMASK_SLEEP_BUTTON_ENABLE        0x0200
 #define ACPI_BITMASK_RT_CLOCK_ENABLE            0x0400
 #define ACPI_BITMASK_PCIEXP_WAKE_DISABLE        0x4000	/* ACPI 3.0 */
 #define ACPI_BITMASK_SCI_ENABLE                 0x0001
 #define ACPI_BITMASK_BUS_MASTER_RLD             0x0002
 #define ACPI_BITMASK_GLOBAL_LOCK_RELEASE        0x0004
 #define ACPI_BITMASK_SLEEP_TYPE                 0x1C00
 #define ACPI_BITMASK_SLEEP_ENABLE               0x2000
 #define ACPI_BITMASK_ARB_DISABLE                0x0001
 /* Raw bit position of each bit_register */
 #define ACPI_BITPOSITION_TIMER_STATUS           0x00
 #define ACPI_BITPOSITION_BUS_MASTER_STATUS      0x04
 #define ACPI_BITPOSITION_GLOBAL_LOCK_STATUS     0x05
 #define ACPI_BITPOSITION_POWER_BUTTON_STATUS    0x08
 #define ACPI_BITPOSITION_SLEEP_BUTTON_STATUS    0x09
 #define ACPI_BITPOSITION_RT_CLOCK_STATUS        0x0A
 #define ACPI_BITPOSITION_PCIEXP_WAKE_STATUS     0x0E	/* ACPI 3.0 */
 #define ACPI_BITPOSITION_WAKE_STATUS            0x0F
 #define ACPI_BITPOSITION_TIMER_ENABLE           0x00
 #define ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE     0x05
 #define ACPI_BITPOSITION_POWER_BUTTON_ENABLE    0x08
 #define ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE    0x09
 #define ACPI_BITPOSITION_RT_CLOCK_ENABLE        0x0A
 #define ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE    0x0E	/* ACPI 3.0 */
 #define ACPI_BITPOSITION_SCI_ENABLE             0x00
 #define ACPI_BITPOSITION_BUS_MASTER_RLD         0x01
 #define ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE    0x02
 #define ACPI_BITPOSITION_SLEEP_TYPE             0x0A
 #define ACPI_BITPOSITION_SLEEP_ENABLE           0x0D
 #define ACPI_BITPOSITION_ARB_DISABLE            0x00
 /* Structs and definitions for _OSI support and I/O port validation */
 #define ACPI_OSI_WIN_2000               0x01
 #define ACPI_OSI_WIN_XP                 0x02
 #define ACPI_OSI_WIN_XP_SP1             0x03
 #define ACPI_OSI_WINSRV_2003            0x04
 #define ACPI_OSI_WIN_XP_SP2             0x05
 #define ACPI_OSI_WINSRV_2003_SP1        0x06
 #define ACPI_OSI_WIN_VISTA              0x07
 #define ACPI_OSI_WINSRV_2008            0x08
 #define ACPI_OSI_WIN_VISTA_SP1          0x09
 #define ACPI_OSI_WIN_7                  0x0A
 #define ACPI_ALWAYS_ILLEGAL             0x00
 struct acpi_interface_info {
 	char *name;
 	u8 value;
 };
 struct acpi_port_info {
 	char *name;
 	u16 start;
 	u16 end;
 	u8 osi_dependency;
 };
 /*****************************************************************************
  *
  * Resource descriptors
  *
  ****************************************************************************/
 /* resource_type values */
 #define ACPI_ADDRESS_TYPE_MEMORY_RANGE          0
 #define ACPI_ADDRESS_TYPE_IO_RANGE              1
 #define ACPI_ADDRESS_TYPE_BUS_NUMBER_RANGE      2
 /* Resource descriptor types and masks */
 #define ACPI_RESOURCE_NAME_LARGE                0x80
 #define ACPI_RESOURCE_NAME_SMALL                0x00
 #define ACPI_RESOURCE_NAME_SMALL_MASK           0x78	/* Bits 6:3 contain the type */
 #define ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK    0x07	/* Bits 2:0 contain the length */
 #define ACPI_RESOURCE_NAME_LARGE_MASK           0x7F	/* Bits 6:0 contain the type */
 /*
  * Small resource descriptor "names" as defined by the ACPI specification.
  * Note: Bits 2:0 are used for the descriptor length
  */
 #define ACPI_RESOURCE_NAME_IRQ                  0x20
 #define ACPI_RESOURCE_NAME_DMA                  0x28
 #define ACPI_RESOURCE_NAME_START_DEPENDENT      0x30
 #define ACPI_RESOURCE_NAME_END_DEPENDENT        0x38
 #define ACPI_RESOURCE_NAME_IO                   0x40
 #define ACPI_RESOURCE_NAME_FIXED_IO             0x48
 #define ACPI_RESOURCE_NAME_RESERVED_S1          0x50
 #define ACPI_RESOURCE_NAME_RESERVED_S2          0x58
 #define ACPI_RESOURCE_NAME_RESERVED_S3          0x60
 #define ACPI_RESOURCE_NAME_RESERVED_S4          0x68
 #define ACPI_RESOURCE_NAME_VENDOR_SMALL         0x70
 #define ACPI_RESOURCE_NAME_END_TAG              0x78
 /*
  * Large resource descriptor "names" as defined by the ACPI specification.
  * Note: includes the Large Descriptor bit in bit[7]
  */
 #define ACPI_RESOURCE_NAME_MEMORY24             0x81
 #define ACPI_RESOURCE_NAME_GENERIC_REGISTER     0x82
 #define ACPI_RESOURCE_NAME_RESERVED_L1          0x83
 #define ACPI_RESOURCE_NAME_VENDOR_LARGE         0x84
 #define ACPI_RESOURCE_NAME_MEMORY32             0x85
 #define ACPI_RESOURCE_NAME_FIXED_MEMORY32       0x86
 #define ACPI_RESOURCE_NAME_ADDRESS32            0x87
 #define ACPI_RESOURCE_NAME_ADDRESS16            0x88
 #define ACPI_RESOURCE_NAME_EXTENDED_IRQ         0x89
 #define ACPI_RESOURCE_NAME_ADDRESS64            0x8A
 #define ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64   0x8B
 #define ACPI_RESOURCE_NAME_LARGE_MAX            0x8B
 /*****************************************************************************
  *
  * Miscellaneous
  *
  ****************************************************************************/
 #define ACPI_ASCII_ZERO                 0x30
 /*****************************************************************************
  *
  * Debugger
  *
  ****************************************************************************/
 struct acpi_db_method_info {
 	acpi_handle main_thread_gate;
 	acpi_handle thread_complete_gate;
 	u32 *threads;
 	u32 num_threads;
 	u32 num_created;
 	u32 num_completed;
 	char *name;
 	u32 flags;
 	u32 num_loops;
 	char pathname[128];
 	char **args;
 	/*
 	 * Arguments to be passed to method for the command
 	 * Threads -
 	 *   the Number of threads, ID of current thread and
 	 *   Index of current thread inside all them created.
 	 */
 	char init_args;
 	char *arguments[4];
 	char num_threads_str[11];
 	char id_of_thread_str[11];
 	char index_of_thread_str[11];
 };
 struct acpi_integrity_info {
 	u32 nodes;
 	u32 objects;
 };
 #define ACPI_DB_REDIRECTABLE_OUTPUT     0x01
 #define ACPI_DB_CONSOLE_OUTPUT          0x02
 #define ACPI_DB_DUPLICATE_OUTPUT        0x03
 /*****************************************************************************
  *
  * Debug
  *
  ****************************************************************************/
 /* Entry for a memory allocation (debug only) */
 #define ACPI_MEM_MALLOC                 0
 #define ACPI_MEM_CALLOC                 1
 #define ACPI_MAX_MODULE_NAME            16
 #define ACPI_COMMON_DEBUG_MEM_HEADER \
 	struct acpi_debug_mem_block     *previous; \
 	struct acpi_debug_mem_block     *next; \
 	u32                             size; \
 	u32                             component; \
 	u32                             line; \
 	char                            module[ACPI_MAX_MODULE_NAME]; \
 	u8                              alloc_type;
 struct acpi_debug_mem_header {
 ACPI_COMMON_DEBUG_MEM_HEADER};
 struct acpi_debug_mem_block {
 	ACPI_COMMON_DEBUG_MEM_HEADER u64 user_space;
 };
 #define ACPI_MEM_LIST_GLOBAL            0
 #define ACPI_MEM_LIST_NSNODE            1
 #define ACPI_MEM_LIST_MAX               1
 #define ACPI_NUM_MEM_LISTS              2
 #endif				/* __ACLOCAL_H__ */

drivers/acpi/acpica/acnamesp.h

Diff comments View file @ 091f4d7

 /******************************************************************************
  *
  * Name: acnamesp.h - Namespace subcomponent prototypes and defines
  *
  *****************************************************************************/
 /*
  * Copyright (C) 2000 - 2010, Intel Corp.
  * 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 __ACNAMESP_H__
 #define __ACNAMESP_H__
 /* To search the entire name space, pass this as search_base */
 #define ACPI_NS_ALL                 ((acpi_handle)0)
 /*
  * Elements of acpi_ns_properties are bit significant
  * and should be one-to-one with values of acpi_object_type
  */
 #define ACPI_NS_NORMAL              0
 #define ACPI_NS_NEWSCOPE            1	/* a definition of this type opens a name scope */
 #define ACPI_NS_LOCAL               2	/* suppress search of enclosing scopes */
 /* Flags for acpi_ns_lookup, acpi_ns_search_and_enter */
 #define ACPI_NS_NO_UPSEARCH         0
 #define ACPI_NS_SEARCH_PARENT       0x01
 #define ACPI_NS_DONT_OPEN_SCOPE     0x02
 #define ACPI_NS_NO_PEER_SEARCH      0x04
 #define ACPI_NS_ERROR_IF_FOUND      0x08
 #define ACPI_NS_PREFIX_IS_SCOPE     0x10
 #define ACPI_NS_EXTERNAL            0x20
 #define ACPI_NS_TEMPORARY           0x40
 /* Flags for acpi_ns_walk_namespace */
 #define ACPI_NS_WALK_NO_UNLOCK      0
 #define ACPI_NS_WALK_UNLOCK         0x01
 #define ACPI_NS_WALK_TEMP_NODES     0x02
 /* Object is not a package element */
 #define ACPI_NOT_PACKAGE_ELEMENT    ACPI_UINT32_MAX
 /* Always emit warning message, not dependent on node flags */
 #define ACPI_WARN_ALWAYS            0
 /*
  * nsinit - Namespace initialization
  */
 acpi_status acpi_ns_initialize_objects(void);
 acpi_status acpi_ns_initialize_devices(void);
 /*
  * nsload -  Namespace loading
  */
 acpi_status acpi_ns_load_namespace(void);
 acpi_status
 acpi_ns_load_table(u32 table_index, struct acpi_namespace_node *node);
 /*
  * nswalk - walk the namespace
  */
 acpi_status
 acpi_ns_walk_namespace(acpi_object_type type,
 		       acpi_handle start_object,
 		       u32 max_depth,
 		       u32 flags,
 		       acpi_walk_callback pre_order_visit,
 		       acpi_walk_callback post_order_visit,
 		       void *context, void **return_value);
 struct acpi_namespace_node *acpi_ns_get_next_node(struct acpi_namespace_node
 						  *parent,
 						  struct acpi_namespace_node
 						  *child);
 struct acpi_namespace_node *acpi_ns_get_next_node_typed(acpi_object_type type,
 							struct
 							acpi_namespace_node
 							*parent,
 							struct
 							acpi_namespace_node
 							*child);
 /*
  * nsparse - table parsing
  */
 acpi_status
 acpi_ns_parse_table(u32 table_index, struct acpi_namespace_node *start_node);
 acpi_status
 acpi_ns_one_complete_parse(u32 pass_number,
 			   u32 table_index,
 			   struct acpi_namespace_node *start_node);
 /*
  * nsaccess - Top-level namespace access
  */
 acpi_status acpi_ns_root_initialize(void);
 acpi_status
 acpi_ns_lookup(union acpi_generic_state *scope_info,
 	       char *name,
 	       acpi_object_type type,
 	       acpi_interpreter_mode interpreter_mode,
 	       u32 flags,
 	       struct acpi_walk_state *walk_state,
 	       struct acpi_namespace_node **ret_node);
 /*
  * nsalloc - Named object allocation/deallocation
  */
 struct acpi_namespace_node *acpi_ns_create_node(u32 name);
 void acpi_ns_delete_node(struct acpi_namespace_node *node);
 void acpi_ns_remove_node(struct acpi_namespace_node *node);
 void
 acpi_ns_delete_namespace_subtree(struct acpi_namespace_node *parent_handle);
 void acpi_ns_delete_namespace_by_owner(acpi_owner_id owner_id);
 void acpi_ns_detach_object(struct acpi_namespace_node *node);
 void acpi_ns_delete_children(struct acpi_namespace_node *parent);
 int acpi_ns_compare_names(char *name1, char *name2);
 /*
  * nsdump - Namespace dump/print utilities
  */
 #ifdef	ACPI_FUTURE_USAGE
 void acpi_ns_dump_tables(acpi_handle search_base, u32 max_depth);
 #endif				/* ACPI_FUTURE_USAGE */
 void acpi_ns_dump_entry(acpi_handle handle, u32 debug_level);
 void
 acpi_ns_dump_pathname(acpi_handle handle, char *msg, u32 level, u32 component);
 void acpi_ns_print_pathname(u32 num_segments, char *pathname);
 acpi_status
 acpi_ns_dump_one_object(acpi_handle obj_handle,
 			u32 level, void *context, void **return_value);
 #ifdef	ACPI_FUTURE_USAGE
 void
 acpi_ns_dump_objects(acpi_object_type type,
 		     u8 display_type,
 		     u32 max_depth,
 		     acpi_owner_id owner_id, acpi_handle start_handle);
 #endif				/* ACPI_FUTURE_USAGE */
 /*
  * nseval - Namespace evaluation functions
  */
 acpi_status acpi_ns_evaluate(struct acpi_evaluate_info *info);
 void acpi_ns_exec_module_code_list(void);
 /*
  * nspredef - Support for predefined/reserved names
  */
 acpi_status
 acpi_ns_check_predefined_names(struct acpi_namespace_node *node,
 			       u32 user_param_count,
 			       acpi_status return_status,
 			       union acpi_operand_object **return_object);
 const union acpi_predefined_info *acpi_ns_check_for_predefined_name(struct
 								    acpi_namespace_node
 								    *node);
 void
 acpi_ns_check_parameter_count(char *pathname,
 			      struct acpi_namespace_node *node,
 			      u32 user_param_count,
 			      const union acpi_predefined_info *info);
 /*
  * nsnames - Name and Scope manipulation
  */
 u32 acpi_ns_opens_scope(acpi_object_type type);
 acpi_status
 acpi_ns_build_external_path(struct acpi_namespace_node *node,
 			    acpi_size size, char *name_buffer);
 char *acpi_ns_get_external_pathname(struct acpi_namespace_node *node);
 char *acpi_ns_name_of_current_scope(struct acpi_walk_state *walk_state);
 acpi_status
 acpi_ns_handle_to_pathname(acpi_handle target_handle,
 			   struct acpi_buffer *buffer);
 u8
 acpi_ns_pattern_match(struct acpi_namespace_node *obj_node, char *search_for);
 acpi_status
 acpi_ns_get_node(struct acpi_namespace_node *prefix_node,
 		 const char *external_pathname,
 		 u32 flags, struct acpi_namespace_node **out_node);
 acpi_size acpi_ns_get_pathname_length(struct acpi_namespace_node *node);
 /*
  * nsobject - Object management for namespace nodes
  */
 acpi_status
 acpi_ns_attach_object(struct acpi_namespace_node *node,
 		      union acpi_operand_object *object, acpi_object_type type);
 union acpi_operand_object *acpi_ns_get_attached_object(struct
 						       acpi_namespace_node
 						       *node);
 union acpi_operand_object *acpi_ns_get_secondary_object(union
 							acpi_operand_object
 							*obj_desc);
 acpi_status
 acpi_ns_attach_data(struct acpi_namespace_node *node,
 		    acpi_object_handler handler, void *data);
 acpi_status
 acpi_ns_detach_data(struct acpi_namespace_node *node,
 		    acpi_object_handler handler);
 acpi_status
 acpi_ns_get_attached_data(struct acpi_namespace_node *node,
 			  acpi_object_handler handler, void **data);
 /*
  * nsrepair - General return object repair for all
  * predefined methods/objects
  */
 acpi_status
 acpi_ns_repair_object(struct acpi_predefined_data *data,
 		      u32 expected_btypes,
 		      u32 package_index,
 		      union acpi_operand_object **return_object_ptr);
 acpi_status
 acpi_ns_repair_package_list(struct acpi_predefined_data *data,
 			    union acpi_operand_object **obj_desc_ptr);
+acpi_status
+acpi_ns_repair_null_element(struct acpi_predefined_data *data,
+			    u32 expected_btypes,
+			    u32 package_index,
+			    union acpi_operand_object **return_object_ptr);
+void
+acpi_ns_remove_null_elements(struct acpi_predefined_data *data,
+			     u8 package_type,
+			     union acpi_operand_object *obj_desc);
 /*
  * nsrepair2 - Return object repair for specific
  * predefined methods/objects
  */
 acpi_status
 acpi_ns_complex_repairs(struct acpi_predefined_data *data,
 			struct acpi_namespace_node *node,
 			acpi_status validate_status,
 			union acpi_operand_object **return_object_ptr);
-void
-acpi_ns_remove_null_elements(struct acpi_predefined_data *data,
-			     u8 package_type,
-			     union acpi_operand_object *obj_desc);
 /*
  * nssearch - Namespace searching and entry
  */
 acpi_status
 acpi_ns_search_and_enter(u32 entry_name,
 			 struct acpi_walk_state *walk_state,
 			 struct acpi_namespace_node *node,
 			 acpi_interpreter_mode interpreter_mode,
 			 acpi_object_type type,
 			 u32 flags, struct acpi_namespace_node **ret_node);
 acpi_status
 acpi_ns_search_one_scope(u32 entry_name,
 			 struct acpi_namespace_node *node,
 			 acpi_object_type type,
 			 struct acpi_namespace_node **ret_node);
 void
 acpi_ns_install_node(struct acpi_walk_state *walk_state,
 		     struct acpi_namespace_node *parent_node,
 		     struct acpi_namespace_node *node, acpi_object_type type);
 /*
  * nsutils - Utility functions
  */
 u8 acpi_ns_valid_root_prefix(char prefix);
 acpi_object_type acpi_ns_get_type(struct acpi_namespace_node *node);
 u32 acpi_ns_local(acpi_object_type type);
 void
 acpi_ns_report_error(const char *module_name,
 		     u32 line_number,
 		     const char *internal_name, acpi_status lookup_status);
 void
 acpi_ns_report_method_error(const char *module_name,
 			    u32 line_number,
 			    const char *message,
 			    struct acpi_namespace_node *node,
 			    const char *path, acpi_status lookup_status);
 void
 acpi_ns_print_node_pathname(struct acpi_namespace_node *node, const char *msg);
 acpi_status acpi_ns_build_internal_name(struct acpi_namestring_info *info);
 void acpi_ns_get_internal_name_length(struct acpi_namestring_info *info);
 acpi_status
 acpi_ns_internalize_name(const char *dotted_name, char **converted_name);
 acpi_status
 acpi_ns_externalize_name(u32 internal_name_length,
 			 const char *internal_name,
 			 u32 * converted_name_length, char **converted_name);
 struct acpi_namespace_node *acpi_ns_validate_handle(acpi_handle handle);
 void acpi_ns_terminate(void);
 struct acpi_namespace_node *acpi_ns_get_parent_node(struct acpi_namespace_node
 						    *node);
 struct acpi_namespace_node *acpi_ns_get_next_valid_node(struct

drivers/acpi/acpica/nspredef.c

Diff comments View file @ 091f4d7

 /******************************************************************************
  *
  * Module Name: nspredef - Validation of ACPI predefined methods and objects
  *              $Revision: 1.1 $
  *
  *****************************************************************************/
 /*
  * Copyright (C) 2000 - 2010, Intel Corp.
  * 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.
  */
 #define ACPI_CREATE_PREDEFINED_TABLE
 #include <acpi/acpi.h>
 #include "accommon.h"
 #include "acnamesp.h"
 #include "acpredef.h"
 #define _COMPONENT          ACPI_NAMESPACE
 ACPI_MODULE_NAME("nspredef")
 /*******************************************************************************
  *
  * This module validates predefined ACPI objects that appear in the namespace,
  * at the time they are evaluated (via acpi_evaluate_object). The purpose of this
  * validation is to detect problems with BIOS-exposed predefined ACPI objects
  * before the results are returned to the ACPI-related drivers.
  *
  * There are several areas that are validated:
  *
  *  1) The number of input arguments as defined by the method/object in the
  *      ASL is validated against the ACPI specification.
  *  2) The type of the return object (if any) is validated against the ACPI
  *      specification.
  *  3) For returned package objects, the count of package elements is
  *      validated, as well as the type of each package element. Nested
  *      packages are supported.
  *
  * For any problems found, a warning message is issued.
  *
  ******************************************************************************/
 /* Local prototypes */
 static acpi_status
 acpi_ns_check_package(struct acpi_predefined_data *data,
 		      union acpi_operand_object **return_object_ptr);
 static acpi_status
 acpi_ns_check_package_list(struct acpi_predefined_data *data,
 			   const union acpi_predefined_info *package,
 			   union acpi_operand_object **elements, u32 count);
 static acpi_status
 acpi_ns_check_package_elements(struct acpi_predefined_data *data,
 			       union acpi_operand_object **elements,
 			       u8 type1,
 			       u32 count1,
 			       u8 type2, u32 count2, u32 start_index);
 static acpi_status
 acpi_ns_check_object_type(struct acpi_predefined_data *data,
 			  union acpi_operand_object **return_object_ptr,
 			  u32 expected_btypes, u32 package_index);
 static acpi_status
 acpi_ns_check_reference(struct acpi_predefined_data *data,
 			union acpi_operand_object *return_object);
 static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes);
 /*
  * Names for the types that can be returned by the predefined objects.
  * Used for warning messages. Must be in the same order as the ACPI_RTYPEs
  */
 static const char *acpi_rtype_names[] = {
 	"/Integer",
 	"/String",
 	"/Buffer",
 	"/Package",
 	"/Reference",
 };
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_predefined_names
  *
  * PARAMETERS:  Node            - Namespace node for the method/object
  *              user_param_count - Number of parameters actually passed
  *              return_status   - Status from the object evaluation
  *              return_object_ptr - Pointer to the object returned from the
  *                                evaluation of a method or object
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Check an ACPI name for a match in the predefined name list.
  *
  ******************************************************************************/
 acpi_status
 acpi_ns_check_predefined_names(struct acpi_namespace_node *node,
 			       u32 user_param_count,
 			       acpi_status return_status,
 			       union acpi_operand_object **return_object_ptr)
 {
 	union acpi_operand_object *return_object = *return_object_ptr;
 	acpi_status status = AE_OK;
 	const union acpi_predefined_info *predefined;
 	char *pathname;
 	struct acpi_predefined_data *data;
 	/* Match the name for this method/object against the predefined list */
 	predefined = acpi_ns_check_for_predefined_name(node);
 	/* Get the full pathname to the object, for use in warning messages */
 	pathname = acpi_ns_get_external_pathname(node);
 	if (!pathname) {
 		return AE_OK;	/* Could not get pathname, ignore */
 	}
 	/*
 	 * Check that the parameter count for this method matches the ASL
 	 * definition. For predefined names, ensure that both the caller and
 	 * the method itself are in accordance with the ACPI specification.
 	 */
 	acpi_ns_check_parameter_count(pathname, node, user_param_count,
 				      predefined);
 	/* If not a predefined name, we cannot validate the return object */
 	if (!predefined) {
 		goto cleanup;
 	}
 	/*
 	 * If the method failed or did not actually return an object, we cannot
 	 * validate the return object
 	 */
 	if ((return_status != AE_OK) && (return_status != AE_CTRL_RETURN_VALUE)) {
 		goto cleanup;
 	}
 	/*
 	 * If there is no return value, check if we require a return value for
 	 * this predefined name. Either one return value is expected, or none,
 	 * for both methods and other objects.
 	 *
 	 * Exit now if there is no return object. Warning if one was expected.
 	 */
 	if (!return_object) {
 		if ((predefined->info.expected_btypes) &&
 		    (!(predefined->info.expected_btypes & ACPI_RTYPE_NONE))) {
 			ACPI_WARN_PREDEFINED((AE_INFO, pathname,
 					      ACPI_WARN_ALWAYS,
 					      "Missing expected return value"));
 			status = AE_AML_NO_RETURN_VALUE;
 		}
 		goto cleanup;
 	}
 	/*
 	 * 1) We have a return value, but if one wasn't expected, just exit, this is
 	 * not a problem. For example, if the "Implicit Return" feature is
 	 * enabled, methods will always return a value.
 	 *
 	 * 2) If the return value can be of any type, then we cannot perform any
 	 * validation, exit.
 	 */
 	if ((!predefined->info.expected_btypes) ||
 	    (predefined->info.expected_btypes == ACPI_RTYPE_ALL)) {
 		goto cleanup;
 	}
 	/* Create the parameter data block for object validation */
 	data = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_predefined_data));
 	if (!data) {
 		goto cleanup;
 	}
 	data->predefined = predefined;
 	data->node_flags = node->flags;
 	data->pathname = pathname;
 	/*
 	 * Check that the type of the main return object is what is expected
 	 * for this predefined name
 	 */
 	status = acpi_ns_check_object_type(data, return_object_ptr,
 					   predefined->info.expected_btypes,
 					   ACPI_NOT_PACKAGE_ELEMENT);
 	if (ACPI_FAILURE(status)) {
 		goto exit;
 	}
 	/*
 	 * For returned Package objects, check the type of all sub-objects.
 	 * Note: Package may have been newly created by call above.
 	 */
 	if ((*return_object_ptr)->common.type == ACPI_TYPE_PACKAGE) {
+		data->parent_package = *return_object_ptr;
 		status = acpi_ns_check_package(data, return_object_ptr);
 		if (ACPI_FAILURE(status)) {
 			goto exit;
 		}
 	}
 	/*
 	 * The return object was OK, or it was successfully repaired above.
 	 * Now make some additional checks such as verifying that package
 	 * objects are sorted correctly (if required) or buffer objects have
 	 * the correct data width (bytes vs. dwords). These repairs are
 	 * performed on a per-name basis, i.e., the code is specific to
 	 * particular predefined names.
 	 */
 	status = acpi_ns_complex_repairs(data, node, status, return_object_ptr);
 exit:
 	/*
 	 * If the object validation failed or if we successfully repaired one
 	 * or more objects, mark the parent node to suppress further warning
 	 * messages during the next evaluation of the same method/object.
 	 */
 	if (ACPI_FAILURE(status) || (data->flags & ACPI_OBJECT_REPAIRED)) {
 		node->flags |= ANOBJ_EVALUATED;
 	}
 	ACPI_FREE(data);
 cleanup:
 	ACPI_FREE(pathname);
 	return (status);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_parameter_count
  *
  * PARAMETERS:  Pathname        - Full pathname to the node (for error msgs)
  *              Node            - Namespace node for the method/object
  *              user_param_count - Number of args passed in by the caller
  *              Predefined      - Pointer to entry in predefined name table
  *
  * RETURN:      None
  *
  * DESCRIPTION: Check that the declared (in ASL/AML) parameter count for a
  *              predefined name is what is expected (i.e., what is defined in
  *              the ACPI specification for this predefined name.)
  *
  ******************************************************************************/
 void
 acpi_ns_check_parameter_count(char *pathname,
 			      struct acpi_namespace_node *node,
 			      u32 user_param_count,
 			      const union acpi_predefined_info *predefined)
 {
 	u32 param_count;
 	u32 required_params_current;
 	u32 required_params_old;
 	/* Methods have 0-7 parameters. All other types have zero. */
 	param_count = 0;
 	if (node->type == ACPI_TYPE_METHOD) {
 		param_count = node->object->method.param_count;
 	}
 	if (!predefined) {
 		/*
 		 * Check the parameter count for non-predefined methods/objects.
 		 *
 		 * Warning if too few or too many arguments have been passed by the
 		 * caller. An incorrect number of arguments may not cause the method
 		 * to fail. However, the method will fail if there are too few
 		 * arguments and the method attempts to use one of the missing ones.
 		 */
 		if (user_param_count < param_count) {
 			ACPI_WARN_PREDEFINED((AE_INFO, pathname,
 					      ACPI_WARN_ALWAYS,
 					      "Insufficient arguments - needs %u, found %u",
 					      param_count, user_param_count));
 		} else if (user_param_count > param_count) {
 			ACPI_WARN_PREDEFINED((AE_INFO, pathname,
 					      ACPI_WARN_ALWAYS,
 					      "Excess arguments - needs %u, found %u",
 					      param_count, user_param_count));
 		}
 		return;
 	}
 	/*
 	 * Validate the user-supplied parameter count.
 	 * Allow two different legal argument counts (_SCP, etc.)
 	 */
 	required_params_current = predefined->info.param_count & 0x0F;
 	required_params_old = predefined->info.param_count >> 4;
 	if (user_param_count != ACPI_UINT32_MAX) {
 		if ((user_param_count != required_params_current) &&
 		    (user_param_count != required_params_old)) {
 			ACPI_WARN_PREDEFINED((AE_INFO, pathname,
 					      ACPI_WARN_ALWAYS,
 					      "Parameter count mismatch - "
 					      "caller passed %u, ACPI requires %u",
 					      user_param_count,
 					      required_params_current));
 		}
 	}
 	/*
 	 * Check that the ASL-defined parameter count is what is expected for
 	 * this predefined name (parameter count as defined by the ACPI
 	 * specification)
 	 */
 	if ((param_count != required_params_current) &&
 	    (param_count != required_params_old)) {
 		ACPI_WARN_PREDEFINED((AE_INFO, pathname, node->flags,
 				      "Parameter count mismatch - ASL declared %u, ACPI requires %u",
 				      param_count, required_params_current));
 	}
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_for_predefined_name
  *
  * PARAMETERS:  Node            - Namespace node for the method/object
  *
  * RETURN:      Pointer to entry in predefined table. NULL indicates not found.
  *
  * DESCRIPTION: Check an object name against the predefined object list.
  *
  ******************************************************************************/
 const union acpi_predefined_info *acpi_ns_check_for_predefined_name(struct
 								    acpi_namespace_node
 								    *node)
 {
 	const union acpi_predefined_info *this_name;
 	/* Quick check for a predefined name, first character must be underscore */
 	if (node->name.ascii[0] != '_') {
 		return (NULL);
 	}
 	/* Search info table for a predefined method/object name */
 	this_name = predefined_names;
 	while (this_name->info.name[0]) {
 		if (ACPI_COMPARE_NAME(node->name.ascii, this_name->info.name)) {
 			return (this_name);
 		}
 		/*
 		 * Skip next entry in the table if this name returns a Package
 		 * (next entry contains the package info)
 		 */
 		if (this_name->info.expected_btypes & ACPI_RTYPE_PACKAGE) {
 			this_name++;
 		}
 		this_name++;
 	}
 	return (NULL);		/* Not found */
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_package
  *
  * PARAMETERS:  Data            - Pointer to validation data structure
  *              return_object_ptr - Pointer to the object returned from the
  *                                evaluation of a method or object
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Check a returned package object for the correct count and
  *              correct type of all sub-objects.
  *
  ******************************************************************************/
 static acpi_status
 acpi_ns_check_package(struct acpi_predefined_data *data,
 		      union acpi_operand_object **return_object_ptr)
 {
 	union acpi_operand_object *return_object = *return_object_ptr;
 	const union acpi_predefined_info *package;
 	union acpi_operand_object **elements;
 	acpi_status status = AE_OK;
 	u32 expected_count;
 	u32 count;
 	u32 i;
 	ACPI_FUNCTION_NAME(ns_check_package);
 	/* The package info for this name is in the next table entry */
 	package = data->predefined + 1;
 	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
 			  "%s Validating return Package of Type %X, Count %X\n",
 			  data->pathname, package->ret_info.type,
 			  return_object->package.count));
 	/*
 	 * For variable-length Packages, we can safely remove all embedded
 	 * and trailing NULL package elements
 	 */
 	acpi_ns_remove_null_elements(data, package->ret_info.type,
 				     return_object);
 	/* Extract package count and elements array */
 	elements = return_object->package.elements;
 	count = return_object->package.count;
 	/* The package must have at least one element, else invalid */
 	if (!count) {
 		ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 				      "Return Package has no elements (empty)"));
 		return (AE_AML_OPERAND_VALUE);
 	}
 	/*
 	 * Decode the type of the expected package contents
 	 *
 	 * PTYPE1 packages contain no subpackages
 	 * PTYPE2 packages contain sub-packages
 	 */
 	switch (package->ret_info.type) {
 	case ACPI_PTYPE1_FIXED:
 		/*
 		 * The package count is fixed and there are no sub-packages
 		 *
 		 * If package is too small, exit.
 		 * If package is larger than expected, issue warning but continue
 		 */
 		expected_count =
 		    package->ret_info.count1 + package->ret_info.count2;
 		if (count < expected_count) {
 			goto package_too_small;
 		} else if (count > expected_count) {
 			ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 					  "%s: Return Package is larger than needed - "
 					  "found %u, expected %u\n",
 					  data->pathname, count,
 					  expected_count));
 		}
 		/* Validate all elements of the returned package */
 		status = acpi_ns_check_package_elements(data, elements,
 							package->ret_info.
 							object_type1,
 							package->ret_info.
 							count1,
 							package->ret_info.
 							object_type2,
 							package->ret_info.
 							count2, 0);
 		break;
 	case ACPI_PTYPE1_VAR:
 		/*
 		 * The package count is variable, there are no sub-packages, and all
 		 * elements must be of the same type
 		 */
 		for (i = 0; i < count; i++) {
 			status = acpi_ns_check_object_type(data, elements,
 							   package->ret_info.
 							   object_type1, i);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 			elements++;
 		}
 		break;
 	case ACPI_PTYPE1_OPTION:
 		/*
 		 * The package count is variable, there are no sub-packages. There are
 		 * a fixed number of required elements, and a variable number of
 		 * optional elements.
 		 *
 		 * Check if package is at least as large as the minimum required
 		 */
 		expected_count = package->ret_info3.count;
 		if (count < expected_count) {
 			goto package_too_small;
 		}
 		/* Variable number of sub-objects */
 		for (i = 0; i < count; i++) {
 			if (i < package->ret_info3.count) {
 				/* These are the required package elements (0, 1, or 2) */
 				status =
 				    acpi_ns_check_object_type(data, elements,
 							      package->
 							      ret_info3.
 							      object_type[i],
 							      i);
 				if (ACPI_FAILURE(status)) {
 					return (status);
 				}
 			} else {
 				/* These are the optional package elements */
 				status =
 				    acpi_ns_check_object_type(data, elements,
 							      package->
 							      ret_info3.
 							      tail_object_type,
 							      i);
 				if (ACPI_FAILURE(status)) {
 					return (status);
 				}
 			}
 			elements++;
 		}
 		break;
 	case ACPI_PTYPE2_REV_FIXED:
 		/* First element is the (Integer) revision */
 		status = acpi_ns_check_object_type(data, elements,
 						   ACPI_RTYPE_INTEGER, 0);
 		if (ACPI_FAILURE(status)) {
 			return (status);
 		}
 		elements++;
 		count--;
 		/* Examine the sub-packages */
 		status =
 		    acpi_ns_check_package_list(data, package, elements, count);
 		break;
 	case ACPI_PTYPE2_PKG_COUNT:
 		/* First element is the (Integer) count of sub-packages to follow */
 		status = acpi_ns_check_object_type(data, elements,
 						   ACPI_RTYPE_INTEGER, 0);
 		if (ACPI_FAILURE(status)) {
 			return (status);
 		}
 		/*
 		 * Count cannot be larger than the parent package length, but allow it
 		 * to be smaller. The >= accounts for the Integer above.
 		 */
 		expected_count = (u32) (*elements)->integer.value;
 		if (expected_count >= count) {
 			goto package_too_small;
 		}
 		count = expected_count;
 		elements++;
 		/* Examine the sub-packages */
 		status =
 		    acpi_ns_check_package_list(data, package, elements, count);
 		break;
 	case ACPI_PTYPE2:
 	case ACPI_PTYPE2_FIXED:
 	case ACPI_PTYPE2_MIN:
 	case ACPI_PTYPE2_COUNT:
 		/*
 		 * These types all return a single Package that consists of a
 		 * variable number of sub-Packages.
 		 *
 		 * First, ensure that the first element is a sub-Package. If not,
 		 * the BIOS may have incorrectly returned the object as a single
 		 * package instead of a Package of Packages (a common error if
 		 * there is only one entry). We may be able to repair this by
 		 * wrapping the returned Package with a new outer Package.
 		 */
 		if (*elements
 		    && ((*elements)->common.type != ACPI_TYPE_PACKAGE)) {
 			/* Create the new outer package and populate it */
 			status =
 			    acpi_ns_repair_package_list(data,
 							return_object_ptr);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 			/* Update locals to point to the new package (of 1 element) */
 			return_object = *return_object_ptr;
 			elements = return_object->package.elements;
 			count = 1;
 		}
 		/* Examine the sub-packages */
 		status =
 		    acpi_ns_check_package_list(data, package, elements, count);
 		break;
 	default:
 		/* Should not get here if predefined info table is correct */
 		ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 				      "Invalid internal return type in table entry: %X",
 				      package->ret_info.type));
 		return (AE_AML_INTERNAL);
 	}
 	return (status);
 package_too_small:
 	/* Error exit for the case with an incorrect package count */
 	ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 			      "Return Package is too small - found %u elements, expected %u",
 			      count, expected_count));
 	return (AE_AML_OPERAND_VALUE);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_package_list
  *
  * PARAMETERS:  Data            - Pointer to validation data structure
  *              Package         - Pointer to package-specific info for method
  *              Elements        - Element list of parent package. All elements
  *                                of this list should be of type Package.
  *              Count           - Count of subpackages
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Examine a list of subpackages
  *
  ******************************************************************************/
 static acpi_status
 acpi_ns_check_package_list(struct acpi_predefined_data *data,
 			   const union acpi_predefined_info *package,
 			   union acpi_operand_object **elements, u32 count)
 {
 	union acpi_operand_object *sub_package;
 	union acpi_operand_object **sub_elements;
 	acpi_status status;
 	u32 expected_count;
 	u32 i;
 	u32 j;
 	/*
 	 * Validate each sub-Package in the parent Package
 	 *
 	 * NOTE: assumes list of sub-packages contains no NULL elements.
 	 * Any NULL elements should have been removed by earlier call
 	 * to acpi_ns_remove_null_elements.
 	 */
 	for (i = 0; i < count; i++) {
 		sub_package = *elements;
 		sub_elements = sub_package->package.elements;
+		data->parent_package = sub_package;
 		/* Each sub-object must be of type Package */
 		status = acpi_ns_check_object_type(data, &sub_package,
 						   ACPI_RTYPE_PACKAGE, i);
 		if (ACPI_FAILURE(status)) {
 			return (status);
 		}
 		/* Examine the different types of expected sub-packages */
+		data->parent_package = sub_package;
 		switch (package->ret_info.type) {
 		case ACPI_PTYPE2:
 		case ACPI_PTYPE2_PKG_COUNT:
 		case ACPI_PTYPE2_REV_FIXED:
 			/* Each subpackage has a fixed number of elements */
 			expected_count =
 			    package->ret_info.count1 + package->ret_info.count2;
 			if (sub_package->package.count < expected_count) {
 				goto package_too_small;
 			}
 			status =
 			    acpi_ns_check_package_elements(data, sub_elements,
 							   package->ret_info.
 							   object_type1,
 							   package->ret_info.
 							   count1,
 							   package->ret_info.
 							   object_type2,
 							   package->ret_info.
 							   count2, 0);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 			break;
 		case ACPI_PTYPE2_FIXED:
 			/* Each sub-package has a fixed length */
 			expected_count = package->ret_info2.count;
 			if (sub_package->package.count < expected_count) {
 				goto package_too_small;
 			}
 			/* Check the type of each sub-package element */
 			for (j = 0; j < expected_count; j++) {
 				status =
 				    acpi_ns_check_object_type(data,
 							      &sub_elements[j],
 							      package->
 							      ret_info2.
 							      object_type[j],
 							      j);
 				if (ACPI_FAILURE(status)) {
 					return (status);
 				}
 			}
 			break;
 		case ACPI_PTYPE2_MIN:
 			/* Each sub-package has a variable but minimum length */
 			expected_count = package->ret_info.count1;
 			if (sub_package->package.count < expected_count) {
 				goto package_too_small;
 			}
 			/* Check the type of each sub-package element */
 			status =
 			    acpi_ns_check_package_elements(data, sub_elements,
 							   package->ret_info.
 							   object_type1,
 							   sub_package->package.
 							   count, 0, 0, 0);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 			break;
 		case ACPI_PTYPE2_COUNT:
 			/*
 			 * First element is the (Integer) count of elements, including
-			 * the count field.
+			 * the count field (the ACPI name is num_elements)
 			 */
 			status = acpi_ns_check_object_type(data, sub_elements,
 							   ACPI_RTYPE_INTEGER,
 							   0);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 			/*
 			 * Make sure package is large enough for the Count and is
 			 * is as large as the minimum size
 			 */
 			expected_count = (u32)(*sub_elements)->integer.value;
 			if (sub_package->package.count < expected_count) {
 				goto package_too_small;
 			}
 			if (sub_package->package.count <
 			    package->ret_info.count1) {
 				expected_count = package->ret_info.count1;
 				goto package_too_small;
 			}
+			if (expected_count == 0) {
+				/*
+				 * Either the num_entries element was originally zero or it was
+				 * a NULL element and repaired to an Integer of value zero.
+				 * In either case, repair it by setting num_entries to be the
+				 * actual size of the subpackage.
+				 */
+				expected_count = sub_package->package.count;
+				(*sub_elements)->integer.value = expected_count;
+			}
 			/* Check the type of each sub-package element */
 			status =
 			    acpi_ns_check_package_elements(data,
 							   (sub_elements + 1),
 							   package->ret_info.
 							   object_type1,
 							   (expected_count - 1),
 							   0, 0, 1);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 			break;
 		default:	/* Should not get here, type was validated by caller */
 			return (AE_AML_INTERNAL);
 		}
 		elements++;
 	}
 	return (AE_OK);
 package_too_small:
 	/* The sub-package count was smaller than required */
 	ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 			      "Return Sub-Package[%u] is too small - found %u elements, expected %u",
 			      i, sub_package->package.count, expected_count));
 	return (AE_AML_OPERAND_VALUE);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_package_elements
  *
  * PARAMETERS:  Data            - Pointer to validation data structure
  *              Elements        - Pointer to the package elements array
  *              Type1           - Object type for first group
  *              Count1          - Count for first group
  *              Type2           - Object type for second group
  *              Count2          - Count for second group
  *              start_index     - Start of the first group of elements
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Check that all elements of a package are of the correct object
  *              type. Supports up to two groups of different object types.
  *
  ******************************************************************************/
 static acpi_status
 acpi_ns_check_package_elements(struct acpi_predefined_data *data,
 			       union acpi_operand_object **elements,
 			       u8 type1,
 			       u32 count1,
 			       u8 type2, u32 count2, u32 start_index)
 {
 	union acpi_operand_object **this_element = elements;
 	acpi_status status;
 	u32 i;
 	/*
 	 * Up to two groups of package elements are supported by the data
 	 * structure. All elements in each group must be of the same type.
 	 * The second group can have a count of zero.
 	 */
 	for (i = 0; i < count1; i++) {
 		status = acpi_ns_check_object_type(data, this_element,
 						   type1, i + start_index);
 		if (ACPI_FAILURE(status)) {
 			return (status);
 		}
 		this_element++;
 	}
 	for (i = 0; i < count2; i++) {
 		status = acpi_ns_check_object_type(data, this_element,
 						   type2,
 						   (i + count1 + start_index));
 		if (ACPI_FAILURE(status)) {
 			return (status);
 		}
 		this_element++;
 	}
 	return (AE_OK);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_object_type
  *
  * PARAMETERS:  Data            - Pointer to validation data structure
  *              return_object_ptr - Pointer to the object returned from the
  *                                evaluation of a method or object
  *              expected_btypes - Bitmap of expected return type(s)
  *              package_index   - Index of object within parent package (if
  *                                applicable - ACPI_NOT_PACKAGE_ELEMENT
  *                                otherwise)
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Check the type of the return object against the expected object
  *              type(s). Use of Btype allows multiple expected object types.
  *
  ******************************************************************************/
 static acpi_status
 acpi_ns_check_object_type(struct acpi_predefined_data *data,
 			  union acpi_operand_object **return_object_ptr,
 			  u32 expected_btypes, u32 package_index)
 {
 	union acpi_operand_object *return_object = *return_object_ptr;
 	acpi_status status = AE_OK;
 	u32 return_btype;
 	char type_buffer[48];	/* Room for 5 types */
 	/*
-	 * If we get a NULL return_object here, it is a NULL package element,
+	 * If we get a NULL return_object here, it is a NULL package element.
-	 * and this is always an error.
+	 * Since all extraneous NULL package elements were removed earlier by a
+	 * call to acpi_ns_remove_null_elements, this is an unexpected NULL element.
+	 * We will attempt to repair it.
 	 */
 	if (!return_object) {
+		status = acpi_ns_repair_null_element(data, expected_btypes,
+						     package_index,
+						     return_object_ptr);
+		if (ACPI_SUCCESS(status)) {
+			return (AE_OK);	/* Repair was successful */
+		}
 		goto type_error_exit;
 	}
 	/* A Namespace node should not get here, but make sure */
 	if (ACPI_GET_DESCRIPTOR_TYPE(return_object) == ACPI_DESC_TYPE_NAMED) {
 		ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 				      "Invalid return type - Found a Namespace node [%4.4s] type %s",
 				      return_object->node.name.ascii,
 				      acpi_ut_get_type_name(return_object->node.
 							    type)));
 		return (AE_AML_OPERAND_TYPE);
 	}
 	/*
 	 * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type.
 	 * The bitmapped type allows multiple possible return types.
 	 *
 	 * Note, the cases below must handle all of the possible types returned
 	 * from all of the predefined names (including elements of returned
 	 * packages)
 	 */
 	switch (return_object->common.type) {
 	case ACPI_TYPE_INTEGER:
 		return_btype = ACPI_RTYPE_INTEGER;
 		break;
 	case ACPI_TYPE_BUFFER:
 		return_btype = ACPI_RTYPE_BUFFER;
 		break;
 	case ACPI_TYPE_STRING:
 		return_btype = ACPI_RTYPE_STRING;
 		break;
 	case ACPI_TYPE_PACKAGE:
 		return_btype = ACPI_RTYPE_PACKAGE;
 		break;
 	case ACPI_TYPE_LOCAL_REFERENCE:
 		return_btype = ACPI_RTYPE_REFERENCE;
 		break;
 	default:
 		/* Not one of the supported objects, must be incorrect */
 		goto type_error_exit;
 	}
 	/* Is the object one of the expected types? */
 	if (return_btype & expected_btypes) {
 		/* For reference objects, check that the reference type is correct */
 		if (return_object->common.type == ACPI_TYPE_LOCAL_REFERENCE) {
 			status = acpi_ns_check_reference(data, return_object);
 		}
 		return (status);
 	}
 	/* Type mismatch -- attempt repair of the returned object */
 	status = acpi_ns_repair_object(data, expected_btypes,
 				       package_index, return_object_ptr);
 	if (ACPI_SUCCESS(status)) {
 		return (AE_OK);	/* Repair was successful */
 	}
       type_error_exit:
 	/* Create a string with all expected types for this predefined object */
 	acpi_ns_get_expected_types(type_buffer, expected_btypes);
 	if (package_index == ACPI_NOT_PACKAGE_ELEMENT) {
 		ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 				      "Return type mismatch - found %s, expected %s",
 				      acpi_ut_get_object_type_name
 				      (return_object), type_buffer));
 	} else {
 		ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 				      "Return Package type mismatch at index %u - "
 				      "found %s, expected %s", package_index,
 				      acpi_ut_get_object_type_name
 				      (return_object), type_buffer));
 	}
 	return (AE_AML_OPERAND_TYPE);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_reference
  *
  * PARAMETERS:  Data            - Pointer to validation data structure
  *              return_object   - Object returned from the evaluation of a
  *                                method or object
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Check a returned reference object for the correct reference
  *              type. The only reference type that can be returned from a
  *              predefined method is a named reference. All others are invalid.
  *
  ******************************************************************************/
 static acpi_status
 acpi_ns_check_reference(struct acpi_predefined_data *data,
 			union acpi_operand_object *return_object)
 {
 	/*
 	 * Check the reference object for the correct reference type (opcode).
 	 * The only type of reference that can be converted to an union acpi_object is
 	 * a reference to a named object (reference class: NAME)
 	 */
 	if (return_object->reference.class == ACPI_REFCLASS_NAME) {
 		return (AE_OK);
 	}
 	ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 			      "Return type mismatch - unexpected reference object type [%s] %2.2X",
 			      acpi_ut_get_reference_name(return_object),
 			      return_object->reference.class));
 	return (AE_AML_OPERAND_TYPE);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_get_expected_types
  *
  * PARAMETERS:  Buffer          - Pointer to where the string is returned
  *              expected_btypes - Bitmap of expected return type(s)
  *
  * RETURN:      Buffer is populated with type names.
  *
  * DESCRIPTION: Translate the expected types bitmap into a string of ascii
  *              names of expected types, for use in warning messages.
  *
  ******************************************************************************/
 static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes)
 {
 	u32 this_rtype;
 	u32 i;
 	u32 j;
 	j = 1;
 	buffer[0] = 0;
 	this_rtype = ACPI_RTYPE_INTEGER;
 	for (i = 0; i < ACPI_NUM_RTYPES; i++) {
 		/* If one of the expected types, concatenate the name of this type */
 		if (expected_btypes & this_rtype) {
 			ACPI_STRCAT(buffer, &acpi_rtype_names[i][j]);
 			j = 0;	/* Use name separator from now on */
 		}
 		this_rtype <<= 1;	/* Next Rtype */
 	}
 }

drivers/acpi/acpica/nsrepair.c

Diff comments View file @ 091f4d7

 /******************************************************************************
  *
  * Module Name: nsrepair - Repair for objects returned by predefined methods
  *
  *****************************************************************************/
 /*
  * Copyright (C) 2000 - 2010, Intel Corp.
  * 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.
  */
 #include <acpi/acpi.h>
 #include "accommon.h"
 #include "acnamesp.h"
 #include "acinterp.h"
+#include "acpredef.h"
 #define _COMPONENT          ACPI_NAMESPACE
 ACPI_MODULE_NAME("nsrepair")
 /*******************************************************************************
  *
  * This module attempts to repair or convert objects returned by the
  * predefined methods to an object type that is expected, as per the ACPI
  * specification. The need for this code is dictated by the many machines that
  * return incorrect types for the standard predefined methods. Performing these
  * conversions here, in one place, eliminates the need for individual ACPI
  * device drivers to do the same. Note: Most of these conversions are different
  * than the internal object conversion routines used for implicit object
  * conversion.
  *
  * The following conversions can be performed as necessary:
  *
  * Integer -> String
  * Integer -> Buffer
  * String  -> Integer
  * String  -> Buffer
  * Buffer  -> Integer
  * Buffer  -> String
  * Buffer  -> Package of Integers
  * Package -> Package of one Package
  *
+ * Additional possible repairs:
+ *
+ * Optional/unnecessary NULL package elements removed
+ * Required package elements that are NULL replaced by Integer/String/Buffer
+ * Incorrect standalone package wrapped with required outer package
+ *
  ******************************************************************************/
 /* Local prototypes */
 static acpi_status
 acpi_ns_convert_to_integer(union acpi_operand_object *original_object,
 			   union acpi_operand_object **return_object);
 static acpi_status
 acpi_ns_convert_to_string(union acpi_operand_object *original_object,
 			  union acpi_operand_object **return_object);
 static acpi_status
 acpi_ns_convert_to_buffer(union acpi_operand_object *original_object,
 			  union acpi_operand_object **return_object);
 static acpi_status
 acpi_ns_convert_to_package(union acpi_operand_object *original_object,
 			   union acpi_operand_object **return_object);
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_repair_object
  *
  * PARAMETERS:  Data                - Pointer to validation data structure
  *              expected_btypes     - Object types expected
  *              package_index       - Index of object within parent package (if
  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
  *                                    otherwise)
  *              return_object_ptr   - Pointer to the object returned from the
  *                                    evaluation of a method or object
  *
  * RETURN:      Status. AE_OK if repair was successful.
  *
  * DESCRIPTION: Attempt to repair/convert a return object of a type that was
  *              not expected.
  *
  ******************************************************************************/
 acpi_status
 acpi_ns_repair_object(struct acpi_predefined_data *data,
 		      u32 expected_btypes,
 		      u32 package_index,
 		      union acpi_operand_object **return_object_ptr)
 {
 	union acpi_operand_object *return_object = *return_object_ptr;
 	union acpi_operand_object *new_object;
 	acpi_status status;
 	ACPI_FUNCTION_NAME(ns_repair_object);
 	/*
 	 * At this point, we know that the type of the returned object was not
 	 * one of the expected types for this predefined name. Attempt to
 	 * repair the object by converting it to one of the expected object
 	 * types for this predefined name.
 	 */
 	if (expected_btypes & ACPI_RTYPE_INTEGER) {
 		status = acpi_ns_convert_to_integer(return_object, &new_object);
 		if (ACPI_SUCCESS(status)) {
 			goto object_repaired;
 		}
 	}
 	if (expected_btypes & ACPI_RTYPE_STRING) {
 		status = acpi_ns_convert_to_string(return_object, &new_object);
 		if (ACPI_SUCCESS(status)) {
 			goto object_repaired;
 		}
 	}
 	if (expected_btypes & ACPI_RTYPE_BUFFER) {
 		status = acpi_ns_convert_to_buffer(return_object, &new_object);
 		if (ACPI_SUCCESS(status)) {
 			goto object_repaired;
 		}
 	}
 	if (expected_btypes & ACPI_RTYPE_PACKAGE) {
 		status = acpi_ns_convert_to_package(return_object, &new_object);
 		if (ACPI_SUCCESS(status)) {
 			goto object_repaired;
 		}
 	}
 	/* We cannot repair this object */
 	return (AE_AML_OPERAND_TYPE);
       object_repaired:
 	/* Object was successfully repaired */
 	/*
 	 * If the original object is a package element, we need to:
 	 * 1. Set the reference count of the new object to match the
 	 *    reference count of the old object.
 	 * 2. Decrement the reference count of the original object.
 	 */
 	if (package_index != ACPI_NOT_PACKAGE_ELEMENT) {
 		new_object->common.reference_count =
 		    return_object->common.reference_count;
 		if (return_object->common.reference_count > 1) {
 			return_object->common.reference_count--;
 		}
 		ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 				  "%s: Converted %s to expected %s at index %u\n",
 				  data->pathname,
 				  acpi_ut_get_object_type_name(return_object),
 				  acpi_ut_get_object_type_name(new_object),
 				  package_index));
 	} else {
 		ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 				  "%s: Converted %s to expected %s\n",
 				  data->pathname,
 				  acpi_ut_get_object_type_name(return_object),
 				  acpi_ut_get_object_type_name(new_object)));
 	}
 	/* Delete old object, install the new return object */
 	acpi_ut_remove_reference(return_object);
 	*return_object_ptr = new_object;
 	data->flags |= ACPI_OBJECT_REPAIRED;
 	return (AE_OK);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_convert_to_integer
  *
  * PARAMETERS:  original_object     - Object to be converted
  *              return_object       - Where the new converted object is returned
  *
  * RETURN:      Status. AE_OK if conversion was successful.
  *
  * DESCRIPTION: Attempt to convert a String/Buffer object to an Integer.
  *
  ******************************************************************************/
 static acpi_status
 acpi_ns_convert_to_integer(union acpi_operand_object *original_object,
 			   union acpi_operand_object **return_object)
 {
 	union acpi_operand_object *new_object;
 	acpi_status status;
 	u64 value = 0;
 	u32 i;
 	switch (original_object->common.type) {
 	case ACPI_TYPE_STRING:
 		/* String-to-Integer conversion */
 		status = acpi_ut_strtoul64(original_object->string.pointer,
 					   ACPI_ANY_BASE, &value);
 		if (ACPI_FAILURE(status)) {
 			return (status);
 		}
 		break;
 	case ACPI_TYPE_BUFFER:
 		/* Buffer-to-Integer conversion. Max buffer size is 64 bits. */
 		if (original_object->buffer.length > 8) {
 			return (AE_AML_OPERAND_TYPE);
 		}
 		/* Extract each buffer byte to create the integer */
 		for (i = 0; i < original_object->buffer.length; i++) {
 			value |=
 			    ((u64) original_object->buffer.
 			     pointer[i] << (i * 8));
 		}
 		break;
 	default:
 		return (AE_AML_OPERAND_TYPE);
 	}
 	new_object = acpi_ut_create_integer_object(value);
 	if (!new_object) {
 		return (AE_NO_MEMORY);
 	}
 	*return_object = new_object;
 	return (AE_OK);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_convert_to_string
  *
  * PARAMETERS:  original_object     - Object to be converted
  *              return_object       - Where the new converted object is returned
  *
  * RETURN:      Status. AE_OK if conversion was successful.
  *
  * DESCRIPTION: Attempt to convert a Integer/Buffer object to a String.
  *
  ******************************************************************************/
 static acpi_status
 acpi_ns_convert_to_string(union acpi_operand_object *original_object,
 			  union acpi_operand_object **return_object)
 {
 	union acpi_operand_object *new_object;
 	acpi_size length;
 	acpi_status status;
 	switch (original_object->common.type) {
 	case ACPI_TYPE_INTEGER:
 		/*
 		 * Integer-to-String conversion. Commonly, convert
 		 * an integer of value 0 to a NULL string. The last element of
 		 * _BIF and _BIX packages occasionally need this fix.
 		 */
 		if (original_object->integer.value == 0) {
 			/* Allocate a new NULL string object */
 			new_object = acpi_ut_create_string_object(0);
 			if (!new_object) {
 				return (AE_NO_MEMORY);
 			}
 		} else {
 			status =
 			    acpi_ex_convert_to_string(original_object,
 						      &new_object,
 						      ACPI_IMPLICIT_CONVERT_HEX);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 		}
 		break;
 	case ACPI_TYPE_BUFFER:
 		/*
 		 * Buffer-to-String conversion. Use a to_string
 		 * conversion, no transform performed on the buffer data. The best
 		 * example of this is the _BIF method, where the string data from
 		 * the battery is often (incorrectly) returned as buffer object(s).
 		 */
 		length = 0;
 		while ((length < original_object->buffer.length) &&
 		       (original_object->buffer.pointer[length])) {
 			length++;
 		}
 		/* Allocate a new string object */
 		new_object = acpi_ut_create_string_object(length);
 		if (!new_object) {
 			return (AE_NO_MEMORY);
 		}
 		/*
 		 * Copy the raw buffer data with no transform. String is already NULL
 		 * terminated at Length+1.
 		 */
 		ACPI_MEMCPY(new_object->string.pointer,
 			    original_object->buffer.pointer, length);
 		break;
 	default:
 		return (AE_AML_OPERAND_TYPE);
 	}
 	*return_object = new_object;
 	return (AE_OK);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_convert_to_buffer
  *
  * PARAMETERS:  original_object     - Object to be converted
  *              return_object       - Where the new converted object is returned
  *
  * RETURN:      Status. AE_OK if conversion was successful.
  *
  * DESCRIPTION: Attempt to convert a Integer/String/Package object to a Buffer.
  *
  ******************************************************************************/
 static acpi_status
 acpi_ns_convert_to_buffer(union acpi_operand_object *original_object,
 			  union acpi_operand_object **return_object)
 {
 	union acpi_operand_object *new_object;
 	acpi_status status;
 	union acpi_operand_object **elements;
 	u32 *dword_buffer;
 	u32 count;
 	u32 i;
 	switch (original_object->common.type) {
 	case ACPI_TYPE_INTEGER:
 		/*
 		 * Integer-to-Buffer conversion.
 		 * Convert the Integer to a packed-byte buffer. _MAT and other
 		 * objects need this sometimes, if a read has been performed on a
 		 * Field object that is less than or equal to the global integer
 		 * size (32 or 64 bits).
 		 */
 		status =
 		    acpi_ex_convert_to_buffer(original_object, &new_object);
 		if (ACPI_FAILURE(status)) {
 			return (status);
 		}
 		break;
 	case ACPI_TYPE_STRING:
 		/* String-to-Buffer conversion. Simple data copy */
 		new_object =
 		    acpi_ut_create_buffer_object(original_object->string.
 						 length);
 		if (!new_object) {
 			return (AE_NO_MEMORY);
 		}
 		ACPI_MEMCPY(new_object->buffer.pointer,
 			    original_object->string.pointer,
 			    original_object->string.length);
 		break;
 	case ACPI_TYPE_PACKAGE:
 		/*
 		 * This case is often seen for predefined names that must return a
 		 * Buffer object with multiple DWORD integers within. For example,
 		 * _FDE and _GTM. The Package can be converted to a Buffer.
 		 */
 		/* All elements of the Package must be integers */
 		elements = original_object->package.elements;
 		count = original_object->package.count;
 		for (i = 0; i < count; i++) {
 			if ((!*elements) ||
 			    ((*elements)->common.type != ACPI_TYPE_INTEGER)) {
 				return (AE_AML_OPERAND_TYPE);
 			}
 			elements++;
 		}
 		/* Create the new buffer object to replace the Package */
 		new_object = acpi_ut_create_buffer_object(ACPI_MUL_4(count));
 		if (!new_object) {
 			return (AE_NO_MEMORY);
 		}
 		/* Copy the package elements (integers) to the buffer as DWORDs */
 		elements = original_object->package.elements;
 		dword_buffer = ACPI_CAST_PTR(u32, new_object->buffer.pointer);
 		for (i = 0; i < count; i++) {
 			*dword_buffer = (u32) (*elements)->integer.value;
 			dword_buffer++;
 			elements++;
 		}
 		break;
 	default:
 		return (AE_AML_OPERAND_TYPE);
 	}
 	*return_object = new_object;
 	return (AE_OK);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_convert_to_package
  *
  * PARAMETERS:  original_object     - Object to be converted
  *              return_object       - Where the new converted object is returned
  *
  * RETURN:      Status. AE_OK if conversion was successful.
  *
  * DESCRIPTION: Attempt to convert a Buffer object to a Package. Each byte of
  *              the buffer is converted to a single integer package element.
  *
  ******************************************************************************/
 static acpi_status
 acpi_ns_convert_to_package(union acpi_operand_object *original_object,
 			   union acpi_operand_object **return_object)
 {
 	union acpi_operand_object *new_object;
 	union acpi_operand_object **elements;
 	u32 length;
 	u8 *buffer;
 	switch (original_object->common.type) {
 	case ACPI_TYPE_BUFFER:
 		/* Buffer-to-Package conversion */
 		length = original_object->buffer.length;
 		new_object = acpi_ut_create_package_object(length);
 		if (!new_object) {
 			return (AE_NO_MEMORY);
 		}
 		/* Convert each buffer byte to an integer package element */
 		elements = new_object->package.elements;
 		buffer = original_object->buffer.pointer;
 		while (length--) {
 			*elements =
 			    acpi_ut_create_integer_object((u64) *buffer);
 			if (!*elements) {
 				acpi_ut_remove_reference(new_object);
 				return (AE_NO_MEMORY);
 			}
 			elements++;
 			buffer++;
 		}
 		break;
 	default:
 		return (AE_AML_OPERAND_TYPE);
 	}
 	*return_object = new_object;
 	return (AE_OK);
+}
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ns_repair_null_element
+ *
+ * PARAMETERS:  Data                - Pointer to validation data structure
+ *              expected_btypes     - Object types expected
+ *              package_index       - Index of object within parent package (if
+ *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
+ *                                    otherwise)
+ *              return_object_ptr   - Pointer to the object returned from the
+ *                                    evaluation of a method or object
+ *
+ * RETURN:      Status. AE_OK if repair was successful.
+ *
+ * DESCRIPTION: Attempt to repair a NULL element of a returned Package object.
+ *
+ ******************************************************************************/
+acpi_status
+acpi_ns_repair_null_element(struct acpi_predefined_data *data,
+			    u32 expected_btypes,
+			    u32 package_index,
+			    union acpi_operand_object **return_object_ptr)
+{
+	union acpi_operand_object *return_object = *return_object_ptr;
+	union acpi_operand_object *new_object;
+	ACPI_FUNCTION_NAME(ns_repair_null_element);
+	/* No repair needed if return object is non-NULL */
+	if (return_object) {
+		return (AE_OK);
+	}
+	/*
+	 * Attempt to repair a NULL element of a Package object. This applies to
+	 * predefined names that return a fixed-length package and each element
+	 * is required. It does not apply to variable-length packages where NULL
+	 * elements are allowed, especially at the end of the package.
+	 */
+	if (expected_btypes & ACPI_RTYPE_INTEGER) {
+		/* Need an Integer - create a zero-value integer */
+		new_object = acpi_ut_create_integer_object(0);
+	} else if (expected_btypes & ACPI_RTYPE_STRING) {
+		/* Need a String - create a NULL string */
+		new_object = acpi_ut_create_string_object(0);
+	} else if (expected_btypes & ACPI_RTYPE_BUFFER) {
+		/* Need a Buffer - create a zero-length buffer */
+		new_object = acpi_ut_create_buffer_object(0);
+	} else {
+		/* Error for all other expected types */
+		return (AE_AML_OPERAND_TYPE);
+	}
+	if (!new_object) {
+		return (AE_NO_MEMORY);
+	}
+	/* Set the reference count according to the parent Package object */
+	new_object->common.reference_count =
+	    data->parent_package->common.reference_count;
+	ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
+			  "%s: Converted NULL package element to expected %s at index %u\n",
+			  data->pathname,
+			  acpi_ut_get_object_type_name(new_object),
+			  package_index));
+	*return_object_ptr = new_object;
+	data->flags |= ACPI_OBJECT_REPAIRED;
+	return (AE_OK);
+}
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_ns_remove_null_elements
+ *
+ * PARAMETERS:  Data                - Pointer to validation data structure
+ *              package_type        - An acpi_return_package_types value
+ *              obj_desc            - A Package object
+ *
+ * RETURN:      None.
+ *
+ * DESCRIPTION: Remove all NULL package elements from packages that contain
+ *              a variable number of sub-packages. For these types of
+ *              packages, NULL elements can be safely removed.
+ *
+ *****************************************************************************/
+void
+acpi_ns_remove_null_elements(struct acpi_predefined_data *data,
+			     u8 package_type,
+			     union acpi_operand_object *obj_desc)
+{
+	union acpi_operand_object **source;
+	union acpi_operand_object **dest;
+	u32 count;
+	u32 new_count;
+	u32 i;
+	ACPI_FUNCTION_NAME(ns_remove_null_elements);
+	/*
+	 * PTYPE1 packages contain no subpackages.
+	 * PTYPE2 packages contain a variable number of sub-packages. We can
+	 * safely remove all NULL elements from the PTYPE2 packages.
+	 */
+	switch (package_type) {
+	case ACPI_PTYPE1_FIXED:
+	case ACPI_PTYPE1_VAR:
+	case ACPI_PTYPE1_OPTION:
+		return;
+	case ACPI_PTYPE2:
+	case ACPI_PTYPE2_COUNT:
+	case ACPI_PTYPE2_PKG_COUNT:
+	case ACPI_PTYPE2_FIXED:
+	case ACPI_PTYPE2_MIN:
+	case ACPI_PTYPE2_REV_FIXED:
+		break;
+	default:
+		return;
+	}
+	count = obj_desc->package.count;
+	new_count = count;
+	source = obj_desc->package.elements;
+	dest = source;
+	/* Examine all elements of the package object, remove nulls */
+	for (i = 0; i < count; i++) {
+		if (!*source) {
+			new_count--;
+		} else {
+			*dest = *source;
+			dest++;
+		}
+		source++;
+	}
+	/* Update parent package if any null elements were removed */
+	if (new_count < count) {
+		ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
+				  "%s: Found and removed %u NULL elements\n",
+				  data->pathname, (count - new_count)));
+		/* NULL terminate list and update the package count */
+		*dest = NULL;
+		obj_desc->package.count = new_count;
+	}
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_repair_package_list
  *
  * PARAMETERS:  Data                - Pointer to validation data structure
  *              obj_desc_ptr        - Pointer to the object to repair. The new
  *                                    package object is returned here,
  *                                    overwriting the old object.
  *
  * RETURN:      Status, new object in *obj_desc_ptr
  *
  * DESCRIPTION: Repair a common problem with objects that are defined to return
  *              a variable-length Package of Packages. If the variable-length
  *              is one, some BIOS code mistakenly simply declares a single
  *              Package instead of a Package with one sub-Package. This
  *              function attempts to repair this error by wrapping a Package
  *              object around the original Package, creating the correct
  *              Package with one sub-Package.
  *
  *              Names that can be repaired in this manner include:
  *              _ALR, _CSD, _HPX, _MLS, _PRT, _PSS, _TRT, TSS
  *
  ******************************************************************************/
 acpi_status
 acpi_ns_repair_package_list(struct acpi_predefined_data *data,
 			    union acpi_operand_object **obj_desc_ptr)
 {
 	union acpi_operand_object *pkg_obj_desc;
 	ACPI_FUNCTION_NAME(ns_repair_package_list);
 	/*
 	 * Create the new outer package and populate it. The new package will
 	 * have a single element, the lone subpackage.
 	 */
 	pkg_obj_desc = acpi_ut_create_package_object(1);
 	if (!pkg_obj_desc) {
 		return (AE_NO_MEMORY);
 	}
 	pkg_obj_desc->package.elements[0] = *obj_desc_ptr;
 	/* Return the new object in the object pointer */
 	*obj_desc_ptr = pkg_obj_desc;
 	data->flags |= ACPI_OBJECT_REPAIRED;
 	ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 			  "%s: Repaired incorrectly formed Package\n",
 			  data->pathname));
 	return (AE_OK);
 }

drivers/acpi/acpica/nsrepair2.c

Diff comments View file @ 091f4d7

 /******************************************************************************
  *
  * Module Name: nsrepair2 - Repair for objects returned by specific
  *                          predefined methods
  *
  *****************************************************************************/
 /*
  * Copyright (C) 2000 - 2010, Intel Corp.
  * 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.
  */
 #include <acpi/acpi.h>
 #include "accommon.h"
 #include "acnamesp.h"
-#include "acpredef.h"
 #define _COMPONENT          ACPI_NAMESPACE
 ACPI_MODULE_NAME("nsrepair2")
 /*
  * Information structure and handler for ACPI predefined names that can
  * be repaired on a per-name basis.
  */
 typedef
 acpi_status(*acpi_repair_function) (struct acpi_predefined_data *data,
 				    union acpi_operand_object **return_object_ptr);
 typedef struct acpi_repair_info {
 	char name[ACPI_NAME_SIZE];
 	acpi_repair_function repair_function;
 } acpi_repair_info;
 /* Local prototypes */
 static const struct acpi_repair_info *acpi_ns_match_repairable_name(struct
 								    acpi_namespace_node
 								    *node);
 static acpi_status
 acpi_ns_repair_ALR(struct acpi_predefined_data *data,
 		   union acpi_operand_object **return_object_ptr);
 static acpi_status
 acpi_ns_repair_FDE(struct acpi_predefined_data *data,
 		   union acpi_operand_object **return_object_ptr);
 static acpi_status
 acpi_ns_repair_PSS(struct acpi_predefined_data *data,
 		   union acpi_operand_object **return_object_ptr);
 static acpi_status
 acpi_ns_repair_TSS(struct acpi_predefined_data *data,
 		   union acpi_operand_object **return_object_ptr);
 static acpi_status
 acpi_ns_check_sorted_list(struct acpi_predefined_data *data,
 			  union acpi_operand_object *return_object,
 			  u32 expected_count,
 			  u32 sort_index,
 			  u8 sort_direction, char *sort_key_name);
 static void
 acpi_ns_sort_list(union acpi_operand_object **elements,
 		  u32 count, u32 index, u8 sort_direction);
 /* Values for sort_direction above */
 #define ACPI_SORT_ASCENDING     0
 #define ACPI_SORT_DESCENDING    1
 /*
  * This table contains the names of the predefined methods for which we can
  * perform more complex repairs.
  *
  * As necessary:
  *
  * _ALR: Sort the list ascending by ambient_illuminance
  * _FDE: Convert Buffer of BYTEs to a Buffer of DWORDs
  * _GTM: Convert Buffer of BYTEs to a Buffer of DWORDs
  * _PSS: Sort the list descending by Power
  * _TSS: Sort the list descending by Power
  */
 static const struct acpi_repair_info acpi_ns_repairable_names[] = {
 	{"_ALR", acpi_ns_repair_ALR},
 	{"_FDE", acpi_ns_repair_FDE},
 	{"_GTM", acpi_ns_repair_FDE},	/* _GTM has same repair as _FDE */
 	{"_PSS", acpi_ns_repair_PSS},
 	{"_TSS", acpi_ns_repair_TSS},
 	{{0, 0, 0, 0}, NULL}	/* Table terminator */
 };
 #define ACPI_FDE_FIELD_COUNT        5
 #define ACPI_FDE_BYTE_BUFFER_SIZE   5
 #define ACPI_FDE_DWORD_BUFFER_SIZE  (ACPI_FDE_FIELD_COUNT * sizeof (u32))
 /******************************************************************************
  *
  * FUNCTION:    acpi_ns_complex_repairs
  *
  * PARAMETERS:  Data                - Pointer to validation data structure
  *              Node                - Namespace node for the method/object
  *              validate_status     - Original status of earlier validation
  *              return_object_ptr   - Pointer to the object returned from the
  *                                    evaluation of a method or object
  *
  * RETURN:      Status. AE_OK if repair was successful. If name is not
  *              matched, validate_status is returned.
  *
  * DESCRIPTION: Attempt to repair/convert a return object of a type that was
  *              not expected.
  *
  *****************************************************************************/
 acpi_status
 acpi_ns_complex_repairs(struct acpi_predefined_data *data,
 			struct acpi_namespace_node *node,
 			acpi_status validate_status,
 			union acpi_operand_object **return_object_ptr)
 {
 	const struct acpi_repair_info *predefined;
 	acpi_status status;
 	/* Check if this name is in the list of repairable names */
 	predefined = acpi_ns_match_repairable_name(node);
 	if (!predefined) {
 		return (validate_status);
 	}
 	status = predefined->repair_function(data, return_object_ptr);
 	return (status);
 }
 /******************************************************************************
  *
  * FUNCTION:    acpi_ns_match_repairable_name
  *
  * PARAMETERS:  Node                - Namespace node for the method/object
  *
  * RETURN:      Pointer to entry in repair table. NULL indicates not found.
  *
  * DESCRIPTION: Check an object name against the repairable object list.
  *
  *****************************************************************************/
 static const struct acpi_repair_info *acpi_ns_match_repairable_name(struct
 								    acpi_namespace_node
 								    *node)
 {
 	const struct acpi_repair_info *this_name;
 	/* Search info table for a repairable predefined method/object name */
 	this_name = acpi_ns_repairable_names;
 	while (this_name->repair_function) {
 		if (ACPI_COMPARE_NAME(node->name.ascii, this_name->name)) {
 			return (this_name);
 		}
 		this_name++;
 	}
 	return (NULL);		/* Not found */
 }
 /******************************************************************************
  *
  * FUNCTION:    acpi_ns_repair_ALR
  *
  * PARAMETERS:  Data                - Pointer to validation data structure
  *              return_object_ptr   - Pointer to the object returned from the
  *                                    evaluation of a method or object
  *
  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
  *
  * DESCRIPTION: Repair for the _ALR object. If necessary, sort the object list
  *              ascending by the ambient illuminance values.
  *
  *****************************************************************************/
 static acpi_status
 acpi_ns_repair_ALR(struct acpi_predefined_data *data,
 		   union acpi_operand_object **return_object_ptr)
 {
 	union acpi_operand_object *return_object = *return_object_ptr;
 	acpi_status status;
 	status = acpi_ns_check_sorted_list(data, return_object, 2, 1,
 					   ACPI_SORT_ASCENDING,
 					   "AmbientIlluminance");
 	return (status);
 }
 /******************************************************************************
  *
  * FUNCTION:    acpi_ns_repair_FDE
  *
  * PARAMETERS:  Data                - Pointer to validation data structure
  *              return_object_ptr   - Pointer to the object returned from the
  *                                    evaluation of a method or object
  *
  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
  *
  * DESCRIPTION: Repair for the _FDE and _GTM objects. The expected return
  *              value is a Buffer of 5 DWORDs. This function repairs a common
  *              problem where the return value is a Buffer of BYTEs, not
  *              DWORDs.
  *
  *****************************************************************************/
 static acpi_status
 acpi_ns_repair_FDE(struct acpi_predefined_data *data,
 		   union acpi_operand_object **return_object_ptr)
 {
 	union acpi_operand_object *return_object = *return_object_ptr;
 	union acpi_operand_object *buffer_object;
 	u8 *byte_buffer;
 	u32 *dword_buffer;
 	u32 i;
 	ACPI_FUNCTION_NAME(ns_repair_FDE);
 	switch (return_object->common.type) {
 	case ACPI_TYPE_BUFFER:
 		/* This is the expected type. Length should be (at least) 5 DWORDs */
 		if (return_object->buffer.length >= ACPI_FDE_DWORD_BUFFER_SIZE) {
 			return (AE_OK);
 		}
 		/* We can only repair if we have exactly 5 BYTEs */
 		if (return_object->buffer.length != ACPI_FDE_BYTE_BUFFER_SIZE) {
 			ACPI_WARN_PREDEFINED((AE_INFO, data->pathname,
 					      data->node_flags,
 					      "Incorrect return buffer length %u, expected %u",
 					      return_object->buffer.length,
 					      ACPI_FDE_DWORD_BUFFER_SIZE));
 			return (AE_AML_OPERAND_TYPE);
 		}
 		/* Create the new (larger) buffer object */
 		buffer_object =
 		    acpi_ut_create_buffer_object(ACPI_FDE_DWORD_BUFFER_SIZE);
 		if (!buffer_object) {
 			return (AE_NO_MEMORY);
 		}
 		/* Expand each byte to a DWORD */
 		byte_buffer = return_object->buffer.pointer;
 		dword_buffer =
 		    ACPI_CAST_PTR(u32, buffer_object->buffer.pointer);
 		for (i = 0; i < ACPI_FDE_FIELD_COUNT; i++) {
 			*dword_buffer = (u32) *byte_buffer;
 			dword_buffer++;
 			byte_buffer++;
 		}
 		ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 				  "%s Expanded Byte Buffer to expected DWord Buffer\n",
 				  data->pathname));
 		break;
 	default:
 		return (AE_AML_OPERAND_TYPE);
 	}
 	/* Delete the original return object, return the new buffer object */
 	acpi_ut_remove_reference(return_object);
 	*return_object_ptr = buffer_object;
 	data->flags |= ACPI_OBJECT_REPAIRED;
 	return (AE_OK);
 }
 /******************************************************************************
  *
  * FUNCTION:    acpi_ns_repair_TSS
  *
  * PARAMETERS:  Data                - Pointer to validation data structure
  *              return_object_ptr   - Pointer to the object returned from the
  *                                    evaluation of a method or object
  *
  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
  *
  * DESCRIPTION: Repair for the _TSS object. If necessary, sort the object list
  *              descending by the power dissipation values.
  *
  *****************************************************************************/
 static acpi_status
 acpi_ns_repair_TSS(struct acpi_predefined_data *data,
 		   union acpi_operand_object **return_object_ptr)
 {
 	union acpi_operand_object *return_object = *return_object_ptr;
 	acpi_status status;
 	status = acpi_ns_check_sorted_list(data, return_object, 5, 1,
 					   ACPI_SORT_DESCENDING,
 					   "PowerDissipation");
 	return (status);
 }
 /******************************************************************************
  *
  * FUNCTION:    acpi_ns_repair_PSS
  *
  * PARAMETERS:  Data                - Pointer to validation data structure
  *              return_object_ptr   - Pointer to the object returned from the
  *                                    evaluation of a method or object
  *
  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
  *
  * DESCRIPTION: Repair for the _PSS object. If necessary, sort the object list
  *              by the CPU frequencies. Check that the power dissipation values
  *              are all proportional to CPU frequency (i.e., sorting by
  *              frequency should be the same as sorting by power.)
  *
  *****************************************************************************/
 static acpi_status
 acpi_ns_repair_PSS(struct acpi_predefined_data *data,
 		   union acpi_operand_object **return_object_ptr)
 {
 	union acpi_operand_object *return_object = *return_object_ptr;
 	union acpi_operand_object **outer_elements;
 	u32 outer_element_count;
 	union acpi_operand_object **elements;
 	union acpi_operand_object *obj_desc;
 	u32 previous_value;
 	acpi_status status;
 	u32 i;
 	/*
 	 * Entries (sub-packages) in the _PSS Package must be sorted by power
 	 * dissipation, in descending order. If it appears that the list is
 	 * incorrectly sorted, sort it. We sort by cpu_frequency, since this
 	 * should be proportional to the power.
 	 */
 	status = acpi_ns_check_sorted_list(data, return_object, 6, 0,
 					   ACPI_SORT_DESCENDING,
 					   "CpuFrequency");
 	if (ACPI_FAILURE(status)) {
 		return (status);
 	}
 	/*
 	 * We now know the list is correctly sorted by CPU frequency. Check if
 	 * the power dissipation values are proportional.
 	 */
 	previous_value = ACPI_UINT32_MAX;
 	outer_elements = return_object->package.elements;
 	outer_element_count = return_object->package.count;
 	for (i = 0; i < outer_element_count; i++) {
 		elements = (*outer_elements)->package.elements;
 		obj_desc = elements[1];	/* Index1 = power_dissipation */
 		if ((u32) obj_desc->integer.value > previous_value) {
 			ACPI_WARN_PREDEFINED((AE_INFO, data->pathname,
 					      data->node_flags,
 					      "SubPackage[%u,%u] - suspicious power dissipation values",
 					      i - 1, i));
 		}
 		previous_value = (u32) obj_desc->integer.value;
 		outer_elements++;
 	}
 	return (AE_OK);
 }
 /******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_sorted_list
  *
  * PARAMETERS:  Data                - Pointer to validation data structure
  *              return_object       - Pointer to the top-level returned object
  *              expected_count      - Minimum length of each sub-package
  *              sort_index          - Sub-package entry to sort on
  *              sort_direction      - Ascending or descending
  *              sort_key_name       - Name of the sort_index field
  *
  * RETURN:      Status. AE_OK if the list is valid and is sorted correctly or
  *              has been repaired by sorting the list.
  *
  * DESCRIPTION: Check if the package list is valid and sorted correctly by the
  *              sort_index. If not, then sort the list.
  *
  *****************************************************************************/
 static acpi_status
 acpi_ns_check_sorted_list(struct acpi_predefined_data *data,
 			  union acpi_operand_object *return_object,
 			  u32 expected_count,
 			  u32 sort_index,
 			  u8 sort_direction, char *sort_key_name)
 {
 	u32 outer_element_count;
 	union acpi_operand_object **outer_elements;
 	union acpi_operand_object **elements;
 	union acpi_operand_object *obj_desc;
 	u32 i;
 	u32 previous_value;
 	ACPI_FUNCTION_NAME(ns_check_sorted_list);
 	/* The top-level object must be a package */
 	if (return_object->common.type != ACPI_TYPE_PACKAGE) {
 		return (AE_AML_OPERAND_TYPE);
 	}
 	/*
 	 * NOTE: assumes list of sub-packages contains no NULL elements.
 	 * Any NULL elements should have been removed by earlier call
 	 * to acpi_ns_remove_null_elements.
 	 */
 	outer_elements = return_object->package.elements;
 	outer_element_count = return_object->package.count;
 	if (!outer_element_count) {
 		return (AE_AML_PACKAGE_LIMIT);
 	}
 	previous_value = 0;
 	if (sort_direction == ACPI_SORT_DESCENDING) {
 		previous_value = ACPI_UINT32_MAX;
 	}
 	/* Examine each subpackage */
 	for (i = 0; i < outer_element_count; i++) {
 		/* Each element of the top-level package must also be a package */
 		if ((*outer_elements)->common.type != ACPI_TYPE_PACKAGE) {
 			return (AE_AML_OPERAND_TYPE);
 		}
 		/* Each sub-package must have the minimum length */
 		if ((*outer_elements)->package.count < expected_count) {
 			return (AE_AML_PACKAGE_LIMIT);
 		}
 		elements = (*outer_elements)->package.elements;
 		obj_desc = elements[sort_index];
 		if (obj_desc->common.type != ACPI_TYPE_INTEGER) {
 			return (AE_AML_OPERAND_TYPE);
 		}
 		/*
 		 * The list must be sorted in the specified order. If we detect a
 		 * discrepancy, sort the entire list.
 		 */
 		if (((sort_direction == ACPI_SORT_ASCENDING) &&
 		     (obj_desc->integer.value < previous_value)) ||
 		    ((sort_direction == ACPI_SORT_DESCENDING) &&
 		     (obj_desc->integer.value > previous_value))) {
 			acpi_ns_sort_list(return_object->package.elements,
 					  outer_element_count, sort_index,
 					  sort_direction);
 			data->flags |= ACPI_OBJECT_REPAIRED;
 			ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 					  "%s: Repaired unsorted list - now sorted by %s\n",
 					  data->pathname, sort_key_name));
 			return (AE_OK);
 		}
 		previous_value = (u32) obj_desc->integer.value;
 		outer_elements++;
 	}
 	return (AE_OK);
-}
-/******************************************************************************
- *
- * FUNCTION:    acpi_ns_remove_null_elements
- *
- * PARAMETERS:  Data                - Pointer to validation data structure
- *              package_type        - An acpi_return_package_types value
- *              obj_desc            - A Package object
- *
- * RETURN:      None.
- *
- * DESCRIPTION: Remove all NULL package elements from packages that contain
- *              a variable number of sub-packages.
- *
- *****************************************************************************/
-void
-acpi_ns_remove_null_elements(struct acpi_predefined_data *data,
-			     u8 package_type,
-			     union acpi_operand_object *obj_desc)
-{
-	union acpi_operand_object **source;
-	union acpi_operand_object **dest;
-	u32 count;
-	u32 new_count;
-	u32 i;
-	ACPI_FUNCTION_NAME(ns_remove_null_elements);
-	/*
-	 * PTYPE1 packages contain no subpackages.
-	 * PTYPE2 packages contain a variable number of sub-packages. We can
-	 * safely remove all NULL elements from the PTYPE2 packages.
-	 */
-	switch (package_type) {
-	case ACPI_PTYPE1_FIXED:
-	case ACPI_PTYPE1_VAR:
-	case ACPI_PTYPE1_OPTION:
-		return;
-	case ACPI_PTYPE2:
-	case ACPI_PTYPE2_COUNT:
-	case ACPI_PTYPE2_PKG_COUNT:
-	case ACPI_PTYPE2_FIXED:
-	case ACPI_PTYPE2_MIN:
-	case ACPI_PTYPE2_REV_FIXED:
-		break;
-	default:
-		return;
-	}
-	count = obj_desc->package.count;
-	new_count = count;
-	source = obj_desc->package.elements;
-	dest = source;
-	/* Examine all elements of the package object, remove nulls */
-	for (i = 0; i < count; i++) {
-		if (!*source) {
-			new_count--;
-		} else {
-			*dest = *source;
-			dest++;
-		}
-		source++;
-	}
-	/* Update parent package if any null elements were removed */
-	if (new_count < count) {
-		ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
-				  "%s: Found and removed %u NULL elements\n",
-				  data->pathname, (count - new_count)));
-		/* NULL terminate list and update the package count */
-		*dest = NULL;
-		obj_desc->package.count = new_count;
-	}
 }
 /******************************************************************************
  *
  * FUNCTION:    acpi_ns_sort_list
  *
  * PARAMETERS:  Elements            - Package object element list
  *              Count               - Element count for above
  *              Index               - Sort by which package element
  *              sort_direction      - Ascending or Descending sort
  *
  * RETURN:      None
  *
  * DESCRIPTION: Sort the objects that are in a package element list.
  *
  * NOTE: Assumes that all NULL elements have been removed from the package,
  *       and that all elements have been verified to be of type Integer.
  *
  *****************************************************************************/
 static void
 acpi_ns_sort_list(union acpi_operand_object **elements,
 		  u32 count, u32 index, u8 sort_direction)
 {
 	union acpi_operand_object *obj_desc1;
 	union acpi_operand_object *obj_desc2;
 	union acpi_operand_object *temp_obj;
 	u32 i;
 	u32 j;
 	/* Simple bubble sort */
 	for (i = 1; i < count; i++) {
 		for (j = (count - 1); j >= i; j--) {
 			obj_desc1 = elements[j - 1]->package.elements[index];
 			obj_desc2 = elements[j]->package.elements[index];
 			if (((sort_direction == ACPI_SORT_ASCENDING) &&
 			     (obj_desc1->integer.value >
 			      obj_desc2->integer.value))
 			    || ((sort_direction == ACPI_SORT_DESCENDING)
 				&& (obj_desc1->integer.value <
 				    obj_desc2->integer.value))) {
 				temp_obj = elements[j - 1];
 				elements[j - 1] = elements[j];
 				elements[j] = temp_obj;
 			}
 		}
 	}
 }