Viewing file:  dsobject.c (17.16 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/******************************************************************************
*
* Module Name: dsobject - Dispatcher object management routines
* $Revision: 81 $
*
*****************************************************************************/
/*
* Copyright (C) 2000, 2001 R. Byron Moore
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "acpi.h"
#include "acparser.h"
#include "amlcode.h"
#include "acdispat.h"
#include "acinterp.h"
#include "acnamesp.h"
#define _COMPONENT ACPI_DISPATCHER
MODULE_NAME ("dsobject")
/*******************************************************************************
*
* FUNCTION: Acpi_ds_init_one_object
*
* PARAMETERS: Obj_handle - Node
* Level - Current nesting level
* Context - Points to a init info struct
* Return_value - Not used
*
* RETURN: Status
*
* DESCRIPTION: Callback from Acpi_walk_namespace. Invoked for every object
* within the namespace.
*
* Currently, the only objects that require initialization are:
* 1) Methods
* 2) Op Regions
*
******************************************************************************/
acpi_status
acpi_ds_init_one_object (
acpi_handle obj_handle,
u32 level,
void *context,
void **return_value)
{
acpi_object_type8 type;
acpi_status status;
acpi_init_walk_info *info = (acpi_init_walk_info *) context;
u8 table_revision;
PROC_NAME ("Ds_init_one_object");
info->object_count++;
table_revision = info->table_desc->pointer->revision;
/*
* We are only interested in objects owned by the table that
* was just loaded
*/
if (((acpi_namespace_node *) obj_handle)->owner_id !=
info->table_desc->table_id) {
return (AE_OK);
}
/* And even then, we are only interested in a few object types */
type = acpi_ns_get_type (obj_handle);
switch (type) {
case ACPI_TYPE_REGION:
acpi_ds_initialize_region (obj_handle);
info->op_region_count++;
break;
case ACPI_TYPE_METHOD:
info->method_count++;
if (!(acpi_dbg_level & ACPI_LV_INIT)) {
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, "."));
}
/*
* Set the execution data width (32 or 64) based upon the
* revision number of the parent ACPI table.
*/
if (table_revision == 1) {
((acpi_namespace_node *)obj_handle)->flags |= ANOBJ_DATA_WIDTH_32;
}
/*
* Always parse methods to detect errors, we may delete
* the parse tree below
*/
status = acpi_ds_parse_method (obj_handle);
if (ACPI_FAILURE (status)) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Method %p [%4.4s] - parse failure, %s\n",
obj_handle, (char*)&((acpi_namespace_node *)obj_handle)->name,
acpi_format_exception (status)));
/* This parse failed, but we will continue parsing more methods */
break;
}
/*
* Delete the parse tree. We simple re-parse the method
* for every execution since there isn't much overhead
*/
acpi_ns_delete_namespace_subtree (obj_handle);
break;
default:
break;
}
/*
* We ignore errors from above, and always return OK, since
* we don't want to abort the walk on a single error.
*/
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: Acpi_ds_initialize_objects
*
* PARAMETERS: None
*
* RETURN: Status
*
* DESCRIPTION: Walk the entire namespace and perform any necessary
* initialization on the objects found therein
*
******************************************************************************/
acpi_status
acpi_ds_initialize_objects (
acpi_table_desc *table_desc,
acpi_namespace_node *start_node)
{
acpi_status status;
acpi_init_walk_info info;
FUNCTION_TRACE ("Ds_initialize_objects");
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"**** Starting initialization of namespace objects ****\n"));
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, "Parsing Methods:"));
info.method_count = 0;
info.op_region_count = 0;
info.object_count = 0;
info.table_desc = table_desc;
/* Walk entire namespace from the supplied root */
status = acpi_walk_namespace (ACPI_TYPE_ANY, start_node, ACPI_UINT32_MAX,
acpi_ds_init_one_object, &info, NULL);
if (ACPI_FAILURE (status)) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Walk_namespace failed! %x\n", status));
}
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
"\n%d Control Methods found and parsed (%d nodes total)\n",
info.method_count, info.object_count));
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"%d Control Methods found\n", info.method_count));
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"%d Op Regions found\n", info.op_region_count));
return_ACPI_STATUS (AE_OK);
}
/*****************************************************************************
*
* FUNCTION: Acpi_ds_init_object_from_op
*
* PARAMETERS: Op - Parser op used to init the internal object
* Opcode - AML opcode associated with the object
* Obj_desc - Namespace object to be initialized
*
* RETURN: Status
*
* DESCRIPTION: Initialize a namespace object from a parser Op and its
* associated arguments. The namespace object is a more compact
* representation of the Op and its arguments.
*
****************************************************************************/
acpi_status
acpi_ds_init_object_from_op (
acpi_walk_state *walk_state,
acpi_parse_object *op,
u16 opcode,
acpi_operand_object **ret_obj_desc)
{
acpi_status status;
acpi_parse_object *arg;
acpi_parse2_object *byte_list;
acpi_operand_object *arg_desc;
const acpi_opcode_info *op_info;
acpi_operand_object *obj_desc;
PROC_NAME ("Ds_init_object_from_op");
obj_desc = *ret_obj_desc;
op_info = acpi_ps_get_opcode_info (opcode);
if (op_info->class == AML_CLASS_UNKNOWN) {
/* Unknown opcode */
return (AE_TYPE);
}
/* Get and prepare the first argument */
switch (obj_desc->common.type) {
case ACPI_TYPE_BUFFER:
/* First arg is a number */
acpi_ds_create_operand (walk_state, op->value.arg, 0);
arg_desc = walk_state->operands [walk_state->num_operands - 1];
acpi_ds_obj_stack_pop (1, walk_state);
/* Resolve the object (could be an arg or local) */
status = acpi_ex_resolve_to_value (&arg_desc, walk_state);
if (ACPI_FAILURE (status)) {
acpi_ut_remove_reference (arg_desc);
return (status);
}
/* We are expecting a number */
if (arg_desc->common.type != ACPI_TYPE_INTEGER) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Expecting number, got obj: %p type %X\n",
arg_desc, arg_desc->common.type));
acpi_ut_remove_reference (arg_desc);
return (AE_TYPE);
}
/* Get the value, delete the internal object */
obj_desc->buffer.length = (u32) arg_desc->integer.value;
acpi_ut_remove_reference (arg_desc);
/* Allocate the buffer */
if (obj_desc->buffer.length == 0) {
obj_desc->buffer.pointer = NULL;
REPORT_WARNING (("Buffer created with zero length in AML\n"));
break;
}
else {
obj_desc->buffer.pointer = ACPI_MEM_CALLOCATE (
obj_desc->buffer.length);
if (!obj_desc->buffer.pointer) {
return (AE_NO_MEMORY);
}
}
/*
* Second arg is the buffer data (optional) Byte_list can be either
* individual bytes or a string initializer.
*/
arg = op->value.arg; /* skip first arg */
byte_list = (acpi_parse2_object *) arg->next;
if (byte_list) {
if (byte_list->opcode != AML_INT_BYTELIST_OP) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Expecting bytelist, got: %p\n",
byte_list));
return (AE_TYPE);
}
MEMCPY (obj_desc->buffer.pointer, byte_list->data,
obj_desc->buffer.length);
}
break;
case ACPI_TYPE_PACKAGE:
/*
* When called, an internal package object has already been built and
* is pointed to by Obj_desc. Acpi_ds_build_internal_object builds another
* internal package object, so remove reference to the original so
* that it is deleted. Error checking is done within the remove
* reference function.
*/
acpi_ut_remove_reference (obj_desc);
status = acpi_ds_build_internal_object (walk_state, op, ret_obj_desc);
break;
case ACPI_TYPE_INTEGER:
obj_desc->integer.value = op->value.integer;
break;
case ACPI_TYPE_STRING:
obj_desc->string.pointer = op->value.string;
obj_desc->string.length = STRLEN (op->value.string);
/*
* The string is contained in the ACPI table, don't ever try
* to delete it
*/
obj_desc->common.flags |= AOPOBJ_STATIC_POINTER;
break;
case ACPI_TYPE_METHOD:
break;
case INTERNAL_TYPE_REFERENCE:
switch (op_info->type) {
case AML_TYPE_LOCAL_VARIABLE:
/* Split the opcode into a base opcode + offset */
obj_desc->reference.opcode = AML_LOCAL_OP;
obj_desc->reference.offset = opcode - AML_LOCAL_OP;
break;
case AML_TYPE_METHOD_ARGUMENT:
/* Split the opcode into a base opcode + offset */
obj_desc->reference.opcode = AML_ARG_OP;
obj_desc->reference.offset = opcode - AML_ARG_OP;
break;
default: /* Constants, Literals, etc.. */
if (op->opcode == AML_INT_NAMEPATH_OP) {
/* Node was saved in Op */
obj_desc->reference.node = op->node;
}
obj_desc->reference.opcode = opcode;
break;
}
break;
default:
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unimplemented data type: %x\n",
obj_desc->common.type));
break;
}
return (AE_OK);
}
/*****************************************************************************
*
* FUNCTION: Acpi_ds_build_internal_simple_obj
*
* PARAMETERS: Op - Parser object to be translated
* Obj_desc_ptr - Where the ACPI internal object is returned
*
* RETURN: Status
*
* DESCRIPTION: Translate a parser Op object to the equivalent namespace object
* Simple objects are any objects other than a package object!
*
****************************************************************************/
static acpi_status
acpi_ds_build_internal_simple_obj (
acpi_walk_state *walk_state,
acpi_parse_object *op,
acpi_operand_object **obj_desc_ptr)
{
acpi_operand_object *obj_desc;
acpi_object_type8 type;
acpi_status status;
u32 length;
char *name;
FUNCTION_TRACE ("Ds_build_internal_simple_obj");
if (op->opcode == AML_INT_NAMEPATH_OP) {
/*
* This is an object reference. If The name was
* previously looked up in the NS, it is stored in this op.
* Otherwise, go ahead and look it up now
*/
if (!op->node) {
status = acpi_ns_lookup (walk_state->scope_info,
op->value.string, ACPI_TYPE_ANY,
IMODE_EXECUTE,
NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE,
NULL,
(acpi_namespace_node **)&(op->node));
if (ACPI_FAILURE (status)) {
if (status == AE_NOT_FOUND) {
name = NULL;
acpi_ns_externalize_name (ACPI_UINT32_MAX, op->value.string, &length, &name);
if (name) {
REPORT_WARNING (("Reference %s at AML %X not found\n",
name, op->aml_offset));
ACPI_MEM_FREE (name);
}
else {
REPORT_WARNING (("Reference %s at AML %X not found\n",
op->value.string, op->aml_offset));
}
*obj_desc_ptr = NULL;
}
else {
return_ACPI_STATUS (status);
}
}
}
/*
* The reference will be a Reference
* TBD: [Restructure] unless we really need a separate
* type of INTERNAL_TYPE_REFERENCE change
* Acpi_ds_map_opcode_to_data_type to handle this case
*/
type = INTERNAL_TYPE_REFERENCE;
}
else {
type = acpi_ds_map_opcode_to_data_type (op->opcode, NULL);
}
/* Create and init the internal ACPI object */
obj_desc = acpi_ut_create_internal_object (type);
if (!obj_desc) {
return_ACPI_STATUS (AE_NO_MEMORY);
}
status = acpi_ds_init_object_from_op (walk_state, op, op->opcode, &obj_desc);
if (ACPI_FAILURE (status)) {
acpi_ut_remove_reference (obj_desc);
return_ACPI_STATUS (status);
}
*obj_desc_ptr = obj_desc;
return_ACPI_STATUS (AE_OK);
}
/*****************************************************************************
*
* FUNCTION: Acpi_ds_build_internal_package_obj
*
* PARAMETERS: Op - Parser object to be translated
* Obj_desc_ptr - Where the ACPI internal object is returned
*
* RETURN: Status
*
* DESCRIPTION: Translate a parser Op package object to the equivalent
* namespace object
*
****************************************************************************/
acpi_status
acpi_ds_build_internal_package_obj (
acpi_walk_state *walk_state,
acpi_parse_object *op,
acpi_operand_object **obj_desc_ptr)
{
acpi_parse_object *arg;
acpi_operand_object *obj_desc;
acpi_status status = AE_OK;
FUNCTION_TRACE ("Ds_build_internal_package_obj");
obj_desc = acpi_ut_create_internal_object (ACPI_TYPE_PACKAGE);
*obj_desc_ptr = obj_desc;
if (!obj_desc) {
return_ACPI_STATUS (AE_NO_MEMORY);
}
if (op->opcode == AML_VAR_PACKAGE_OP) {
/*
* Variable length package parameters are evaluated JIT
*/
return_ACPI_STATUS (AE_OK);
}
/* The first argument must be the package length */
arg = op->value.arg;
obj_desc->package.count = arg->value.integer32;
/*
* Allocate the array of pointers (ptrs to the
* individual objects) Add an extra pointer slot so
* that the list is always null terminated.
*/
obj_desc->package.elements = ACPI_MEM_CALLOCATE (
(obj_desc->package.count + 1) * sizeof (void *));
if (!obj_desc->package.elements) {
acpi_ut_delete_object_desc (obj_desc);
return_ACPI_STATUS (AE_NO_MEMORY);
}
obj_desc->package.next_element = obj_desc->package.elements;
/*
* Now init the elements of the package
*/
arg = arg->next;
while (arg) {
if (arg->opcode == AML_PACKAGE_OP) {
status = acpi_ds_build_internal_package_obj (walk_state, arg,
obj_desc->package.next_element);
}
else {
status = acpi_ds_build_internal_simple_obj (walk_state, arg,
obj_desc->package.next_element);
}
obj_desc->package.next_element++;
arg = arg->next;
}
obj_desc->package.flags |= AOPOBJ_DATA_VALID;
return_ACPI_STATUS (status);
}
/*****************************************************************************
*
* FUNCTION: Acpi_ds_build_internal_object
*
* PARAMETERS: Op - Parser object to be translated
* Obj_desc_ptr - Where the ACPI internal object is returned
*
* RETURN: Status
*
* DESCRIPTION: Translate a parser Op object to the equivalent namespace
* object
*
****************************************************************************/
acpi_status
acpi_ds_build_internal_object (
acpi_walk_state *walk_state,
acpi_parse_object *op,
acpi_operand_object **obj_desc_ptr)
{
acpi_status status;
switch (op->opcode) {
case AML_PACKAGE_OP:
case AML_VAR_PACKAGE_OP:
status = acpi_ds_build_internal_package_obj (walk_state, op, obj_desc_ptr);
break;
default:
status = acpi_ds_build_internal_simple_obj (walk_state, op, obj_desc_ptr);
break;
}
return (status);
}
/*****************************************************************************
*
* FUNCTION: Acpi_ds_create_node
*
* PARAMETERS: Op - Parser object to be translated
* Obj_desc_ptr - Where the ACPI internal object is returned
*
* RETURN: Status
*
* DESCRIPTION:
*
****************************************************************************/
acpi_status
acpi_ds_create_node (
acpi_walk_state *walk_state,
acpi_namespace_node *node,
acpi_parse_object *op)
{
acpi_status status;
acpi_operand_object *obj_desc;
FUNCTION_TRACE_PTR ("Ds_create_node", op);
/*
* Because of the execution pass through the non-control-method
* parts of the table, we can arrive here twice. Only init
* the named object node the first time through
*/
if (node->object) {
return_ACPI_STATUS (AE_OK);
}
if (!op->value.arg) {
/* No arguments, there is nothing to do */
return_ACPI_STATUS (AE_OK);
}
/* Build an internal object for the argument(s) */
status = acpi_ds_build_internal_object (walk_state, op->value.arg, &obj_desc);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
}
/* Re-type the object according to it's argument */
node->type = obj_desc->common.type;
/* Init obj */
status = acpi_ns_attach_object (node, obj_desc, (u8) node->type);
/* Remove local reference to the object */
acpi_ut_remove_reference (obj_desc);
return_ACPI_STATUS (status);
}
|