acpi_status
acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
union acpi_parse_object ** out_op)
{
union acpi_parse_object *op;
struct acpi_namespace_node *node;
acpi_status status;
acpi_object_type object_type;
char *path;
u32 flags;
ACPI_FUNCTION_TRACE(ds_load1_begin_op);
op = walk_state->op;
ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
walk_state));
/* We are only interested in opcodes that have an associated name */
if (op) {
if (!(walk_state->op_info->flags & AML_NAMED)) {
*out_op = op;
return_ACPI_STATUS(AE_OK);
}
/* Check if this object has already been installed in the namespace */
if (op->common.node) {
*out_op = op;
return_ACPI_STATUS(AE_OK);
}
}
path = acpi_ps_get_next_namestring(&walk_state->parser_state);
/* Map the raw opcode into an internal object type */
object_type = walk_state->op_info->object_type;
ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
"State=%p Op=%p [%s]\n", walk_state, op,
acpi_ut_get_type_name(object_type)));
switch (walk_state->opcode) {
case AML_SCOPE_OP:
/*
* The target name of the Scope() operator must exist at this point so
* that we can actually open the scope to enter new names underneath it.
* Allow search-to-root for single namesegs.
*/
status =
acpi_ns_lookup(walk_state->scope_info, path, object_type,
ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
walk_state, &(node));
#ifdef ACPI_ASL_COMPILER
if (status == AE_NOT_FOUND) {
/*
* Table disassembly:
* Target of Scope() not found. Generate an External for it, and
* insert the name into the namespace.
*/
acpi_dm_add_to_external_list(path, ACPI_TYPE_DEVICE, 0);
status =
acpi_ns_lookup(walk_state->scope_info, path,
object_type, ACPI_IMODE_LOAD_PASS1,
ACPI_NS_SEARCH_PARENT, walk_state,
&node);
}
#endif
if (ACPI_FAILURE(status)) {
ACPI_ERROR_NAMESPACE(path, status);
return_ACPI_STATUS(status);
}
/*
* Check to make sure that the target is
* one of the opcodes that actually opens a scope
*/
switch (node->type) {
case ACPI_TYPE_ANY:
case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_POWER:
case ACPI_TYPE_PROCESSOR:
case ACPI_TYPE_THERMAL:
/* These are acceptable types */
break;
case ACPI_TYPE_INTEGER:
case ACPI_TYPE_STRING:
case ACPI_TYPE_BUFFER:
/*
* These types we will allow, but we will change the type. This
* enables some existing code of the form:
*
* Name (DEB, 0)
* Scope (DEB) { ... }
*
* Note: silently change the type here. On the second pass, we will report
* a warning
*/
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
"Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
path,
acpi_ut_get_type_name(node->type)));
node->type = ACPI_TYPE_ANY;
walk_state->scope_info->common.value = ACPI_TYPE_ANY;
break;
default:
/* All other types are an error */
ACPI_ERROR((AE_INFO,
"Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)",
acpi_ut_get_type_name(node->type), path));
return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
}
break;
default:
/*
* For all other named opcodes, we will enter the name into
* the namespace.
*
* Setup the search flags.
* Since we are entering a name into the namespace, we do not want to
* enable the search-to-root upsearch.
*
* There are only two conditions where it is acceptable that the name
* already exists:
* 1) the Scope() operator can reopen a scoping object that was
* previously defined (Scope, Method, Device, etc.)
* 2) Whenever we are parsing a deferred opcode (op_region, Buffer,
* buffer_field, or Package), the name of the object is already
* in the namespace.
*/
if (walk_state->deferred_node) {
/* This name is already in the namespace, get the node */
node = walk_state->deferred_node;
status = AE_OK;
break;
}
/*
* If we are executing a method, do not create any namespace objects
* during the load phase, only during execution.
*/
if (walk_state->method_node) {
node = NULL;
status = AE_OK;
break;
}
flags = ACPI_NS_NO_UPSEARCH;
if ((walk_state->opcode != AML_SCOPE_OP) &&
(!(walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP))) {
flags |= ACPI_NS_ERROR_IF_FOUND;
ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
"[%s] Cannot already exist\n",
acpi_ut_get_type_name(object_type)));
} else {
ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
"[%s] Both Find or Create allowed\n",
acpi_ut_get_type_name(object_type)));
}
/*
* Enter the named type into the internal namespace. We enter the name
* as we go downward in the parse tree. Any necessary subobjects that
* involve arguments to the opcode must be created as we go back up the
* parse tree later.
*/
status =
acpi_ns_lookup(walk_state->scope_info, path, object_type,
ACPI_IMODE_LOAD_PASS1, flags, walk_state,
&node);
if (ACPI_FAILURE(status)) {
if (status == AE_ALREADY_EXISTS) {
/* The name already exists in this scope */
if (node->flags & ANOBJ_IS_EXTERNAL) {
/*
* Allow one create on an object or segment that was
* previously declared External
*/
node->flags &= ~ANOBJ_IS_EXTERNAL;
node->type = (u8) object_type;
/* Just retyped a node, probably will need to open a scope */
if (acpi_ns_opens_scope(object_type)) {
status =
acpi_ds_scope_stack_push
(node, object_type,
walk_state);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS
(status);
}
}
status = AE_OK;
}
}
if (ACPI_FAILURE(status)) {
ACPI_ERROR_NAMESPACE(path, status);
return_ACPI_STATUS(status);
}
}
break;
}
/* Common exit */
if (!op) {
/* Create a new op */
op = acpi_ps_alloc_op(walk_state->opcode);
if (!op) {
return_ACPI_STATUS(AE_NO_MEMORY);
}
}
/* Initialize the op */
#if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
op->named.path = ACPI_CAST_PTR(u8, path);
#endif
if (node) {
/*
* Put the Node in the "op" object that the parser uses, so we
* can get it again quickly when this scope is closed
*/
op->common.node = node;
op->named.name = node->name.integer;
}
acpi_ps_append_arg(acpi_ps_get_parent_scope(&walk_state->parser_state),
op);
*out_op = op;
return_ACPI_STATUS(status);
}
if (!buffer_ptr) {
/* No name, just exit */
return_ACPI_STATUS(AE_OK);
}
} else {
/* Get name from the op */
buffer_ptr = ACPI_CAST_PTR(char, &op->named.name);
}
} else {
/* Get the namestring from the raw AML */
buffer_ptr =
acpi_ps_get_next_namestring(&walk_state->parser_state);
}
/* Map the opcode into an internal object type */
object_type = walk_state->op_info->object_type;
ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
"State=%p Op=%p Type=%X\n", walk_state, op,
object_type));
switch (walk_state->opcode) {
case AML_FIELD_OP:
case AML_BANK_FIELD_OP:
case AML_INDEX_FIELD_OP:
acpi_status
acpi_ps_get_next_namepath(struct acpi_walk_state *walk_state,
struct acpi_parse_state *parser_state,
union acpi_parse_object *arg, u8 method_call)
{
char *path;
union acpi_parse_object *name_op;
acpi_status status = AE_OK;
union acpi_operand_object *method_desc;
struct acpi_namespace_node *node;
union acpi_generic_state scope_info;
ACPI_FUNCTION_TRACE("ps_get_next_namepath");
path = acpi_ps_get_next_namestring(parser_state);
/* Null path case is allowed */
if (path) {
/*
* Lookup the name in the internal namespace
*/
scope_info.scope.node = NULL;
node = parser_state->start_node;
if (node) {
scope_info.scope.node = node;
}
/*
* Lookup object. We don't want to add anything new to the namespace
* here, however. So we use MODE_EXECUTE. Allow searching of the
* parent tree, but don't open a new scope -- we just want to lookup the
* object (MUST BE mode EXECUTE to perform upsearch)
*/
status = acpi_ns_lookup(&scope_info, path, ACPI_TYPE_ANY,
ACPI_IMODE_EXECUTE,
ACPI_NS_SEARCH_PARENT |
ACPI_NS_DONT_OPEN_SCOPE, NULL, &node);
if (ACPI_SUCCESS(status) && method_call) {
if (node->type == ACPI_TYPE_METHOD) {
/* This name is actually a control method invocation */
method_desc = acpi_ns_get_attached_object(node);
ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
"Control Method - %p Desc %p Path=%p\n",
node, method_desc, path));
name_op = acpi_ps_alloc_op(AML_INT_NAMEPATH_OP);
if (!name_op) {
return_ACPI_STATUS(AE_NO_MEMORY);
}
/* Change arg into a METHOD CALL and attach name to it */
acpi_ps_init_op(arg, AML_INT_METHODCALL_OP);
name_op->common.value.name = path;
/* Point METHODCALL/NAME to the METHOD Node */
name_op->common.node = node;
acpi_ps_append_arg(arg, name_op);
if (!method_desc) {
ACPI_REPORT_ERROR(("ps_get_next_namepath: Control Method %p has no attached object\n", node));
return_ACPI_STATUS(AE_AML_INTERNAL);
}
ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
"Control Method - %p Args %X\n",
node,
method_desc->method.
param_count));
/* Get the number of arguments to expect */
walk_state->arg_count =
method_desc->method.param_count;
return_ACPI_STATUS(AE_OK);
}
/*
* Else this is normal named object reference.
* Just init the NAMEPATH object with the pathname.
* (See code below)
*/
}
if (ACPI_FAILURE(status)) {
/*
* 1) Any error other than NOT_FOUND is always severe
* 2) NOT_FOUND is only important if we are executing a method.
* 3) If executing a cond_ref_of opcode, NOT_FOUND is ok.
*/
if ((((walk_state->
parse_flags & ACPI_PARSE_MODE_MASK) ==
ACPI_PARSE_EXECUTE) && (status == AE_NOT_FOUND)
&& (walk_state->op->common.aml_opcode !=
AML_COND_REF_OF_OP))
|| (status != AE_NOT_FOUND)) {
ACPI_REPORT_NSERROR(path, status);
acpi_os_printf
("search_node %p start_node %p return_node %p\n",
scope_info.scope.node,
parser_state->start_node, node);
} else {
/*
* We got a NOT_FOUND during table load or we encountered
* a cond_ref_of(x) where the target does not exist.
* Either case is ok
*/
status = AE_OK;
}
}
}
/*
* Regardless of success/failure above,
* Just initialize the Op with the pathname.
*/
acpi_ps_init_op(arg, AML_INT_NAMEPATH_OP);
arg->common.value.name = path;
return_ACPI_STATUS(status);
}
void
acpi_ps_get_next_simple_arg(struct acpi_parse_state *parser_state,
u32 arg_type, union acpi_parse_object *arg)
{
ACPI_FUNCTION_TRACE_U32("ps_get_next_simple_arg", arg_type);
switch (arg_type) {
case ARGP_BYTEDATA:
acpi_ps_init_op(arg, AML_BYTE_OP);
arg->common.value.integer = (u32) ACPI_GET8(parser_state->aml);
parser_state->aml++;
break;
case ARGP_WORDDATA:
acpi_ps_init_op(arg, AML_WORD_OP);
/* Get 2 bytes from the AML stream */
ACPI_MOVE_16_TO_32(&arg->common.value.integer,
parser_state->aml);
parser_state->aml += 2;
break;
case ARGP_DWORDDATA:
acpi_ps_init_op(arg, AML_DWORD_OP);
/* Get 4 bytes from the AML stream */
ACPI_MOVE_32_TO_32(&arg->common.value.integer,
parser_state->aml);
parser_state->aml += 4;
break;
case ARGP_QWORDDATA:
acpi_ps_init_op(arg, AML_QWORD_OP);
/* Get 8 bytes from the AML stream */
ACPI_MOVE_64_TO_64(&arg->common.value.integer,
parser_state->aml);
parser_state->aml += 8;
break;
case ARGP_CHARLIST:
acpi_ps_init_op(arg, AML_STRING_OP);
arg->common.value.string = (char *)parser_state->aml;
while (ACPI_GET8(parser_state->aml) != '\0') {
parser_state->aml++;
}
parser_state->aml++;
break;
case ARGP_NAME:
case ARGP_NAMESTRING:
acpi_ps_init_op(arg, AML_INT_NAMEPATH_OP);
arg->common.value.name =
acpi_ps_get_next_namestring(parser_state);
break;
default:
ACPI_REPORT_ERROR(("Invalid arg_type %X\n", arg_type));
break;
}
return_VOID;
}
acpi_status
acpi_ds_load2_begin_op (
acpi_walk_state *walk_state,
acpi_parse_object **out_op)
{
acpi_parse_object *op;
acpi_namespace_node *node;
acpi_status status;
acpi_object_type8 data_type;
NATIVE_CHAR *buffer_ptr;
void *original = NULL;
PROC_NAME ("Ds_load2_begin_op");
op = walk_state->op;
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));
if (op) {
/* We only care about Namespace opcodes here */
if (!(walk_state->op_info->flags & AML_NSOPCODE) &&
walk_state->opcode != AML_INT_NAMEPATH_OP) {
return (AE_OK);
}
/* TBD: [Restructure] Temp! same code as in psparse */
if (!(walk_state->op_info->flags & AML_NAMED)) {
return (AE_OK);
}
/*
* Get the name we are going to enter or lookup in the namespace
*/
if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
/* For Namepath op, get the path string */
buffer_ptr = op->value.string;
if (!buffer_ptr) {
/* No name, just exit */
return (AE_OK);
}
}
else {
/* Get name from the op */
buffer_ptr = (NATIVE_CHAR *) &((acpi_parse2_object *)op)->name;
}
}
else {
buffer_ptr = acpi_ps_get_next_namestring (&walk_state->parser_state);
}
/* Map the raw opcode into an internal object type */
data_type = acpi_ds_map_named_opcode_to_data_type (walk_state->opcode);
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"State=%p Op=%p Type=%x\n", walk_state, op, data_type));
if (walk_state->opcode == AML_FIELD_OP ||
walk_state->opcode == AML_BANK_FIELD_OP ||
walk_state->opcode == AML_INDEX_FIELD_OP) {
node = NULL;
status = AE_OK;
}
else if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
/*
* The Name_path is an object reference to an existing object. Don't enter the
* name into the namespace, but look it up for use later
*/
status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, data_type,
IMODE_EXECUTE, NS_SEARCH_PARENT, walk_state, &(node));
}
else {
if (op && op->node) {
original = op->node;
node = op->node;
if (acpi_ns_opens_scope (data_type)) {
status = acpi_ds_scope_stack_push (node, data_type, walk_state);
if (ACPI_FAILURE (status)) {
return (status);
}
}
return (AE_OK);
}
/*
* Enter the named type into the internal namespace. We enter the name
* as we go downward in the parse tree. Any necessary subobjects that involve
* arguments to the opcode must be created as we go back up the parse tree later.
*/
status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, data_type,
IMODE_EXECUTE, NS_NO_UPSEARCH, walk_state, &(node));
}
if (ACPI_SUCCESS (status)) {
if (!op) {
/* Create a new op */
op = acpi_ps_alloc_op (walk_state->opcode);
if (!op) {
return (AE_NO_MEMORY);
}
/* Initialize */
((acpi_parse2_object *)op)->name = node->name;
*out_op = op;
}
/*
* Put the Node in the "op" object that the parser uses, so we
* can get it again quickly when this scope is closed
*/
op->node = node;
if (original) {
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "old %p new %p\n", original, node));
if (original != node) {
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Lookup match error: old %p new %p\n", original, node));
}
}
}
return (status);
}
acpi_status
acpi_ds_load1_begin_op (
acpi_walk_state *walk_state,
acpi_parse_object **out_op)
{
acpi_parse_object *op;
acpi_namespace_node *node;
acpi_status status;
acpi_object_type8 data_type;
NATIVE_CHAR *path;
PROC_NAME ("Ds_load1_begin_op");
op = walk_state->op;
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));
/* We are only interested in opcodes that have an associated name */
if (walk_state->op) {
if (!(walk_state->op_info->flags & AML_NAMED)) {
*out_op = op;
return (AE_OK);
}
/* Check if this object has already been installed in the namespace */
if (op->node) {
*out_op = op;
return (AE_OK);
}
}
path = acpi_ps_get_next_namestring (&walk_state->parser_state);
/* Map the raw opcode into an internal object type */
data_type = acpi_ds_map_named_opcode_to_data_type (walk_state->opcode);
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"State=%p Op=%p Type=%x\n", walk_state, op, data_type));
if (walk_state->opcode == AML_SCOPE_OP) {
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"State=%p Op=%p Type=%x\n", walk_state, op, data_type));
}
/*
* Enter the named type into the internal namespace. We enter the name
* as we go downward in the parse tree. Any necessary subobjects that involve
* arguments to the opcode must be created as we go back up the parse tree later.
*/
status = acpi_ns_lookup (walk_state->scope_info, path, data_type,
IMODE_LOAD_PASS1, NS_NO_UPSEARCH, walk_state, &(node));
if (ACPI_FAILURE (status)) {
return (status);
}
if (!op) {
/* Create a new op */
op = acpi_ps_alloc_op (walk_state->opcode);
if (!op) {
return (AE_NO_MEMORY);
}
}
/* Initialize */
((acpi_parse2_object *)op)->name = node->name;
/*
* Put the Node in the "op" object that the parser uses, so we
* can get it again quickly when this scope is closed
*/
op->node = node;
acpi_ps_append_arg (acpi_ps_get_parent_scope (&walk_state->parser_state), op);
*out_op = op;
return (status);
}
void
acpi_ps_get_next_simple_arg (
ACPI_PARSE_STATE *parser_state,
u32 arg_type,
ACPI_PARSE_OBJECT *arg)
{
switch (arg_type)
{
case ARGP_BYTEDATA:
acpi_ps_init_op (arg, AML_BYTE_OP);
arg->value.integer = (u32) GET8 (parser_state->aml);
parser_state->aml++;
break;
case ARGP_WORDDATA:
acpi_ps_init_op (arg, AML_WORD_OP);
/* Get 2 bytes from the AML stream */
MOVE_UNALIGNED16_TO_32 (&arg->value.integer, parser_state->aml);
parser_state->aml += 2;
break;
case ARGP_DWORDDATA:
acpi_ps_init_op (arg, AML_DWORD_OP);
/* Get 4 bytes from the AML stream */
MOVE_UNALIGNED32_TO_32 (&arg->value.integer, parser_state->aml);
parser_state->aml += 4;
break;
case ARGP_CHARLIST:
acpi_ps_init_op (arg, AML_STRING_OP);
arg->value.string = (char*) parser_state->aml;
while (GET8 (parser_state->aml) != '\0') {
parser_state->aml++;
}
parser_state->aml++;
break;
case ARGP_NAME:
case ARGP_NAMESTRING:
acpi_ps_init_op (arg, AML_NAMEPATH_OP);
arg->value.name = acpi_ps_get_next_namestring (parser_state);
break;
}
return;
}
void
acpi_ps_get_next_namepath (
ACPI_PARSE_STATE *parser_state,
ACPI_PARSE_OBJECT *arg,
u32 *arg_count,
u8 method_call)
{
NATIVE_CHAR *path;
ACPI_PARSE_OBJECT *name_op;
ACPI_STATUS status;
ACPI_NAMESPACE_NODE *method_node = NULL;
ACPI_NAMESPACE_NODE *node;
ACPI_GENERIC_STATE scope_info;
path = acpi_ps_get_next_namestring (parser_state);
if (!path || !method_call) {
/* Null name case, create a null namepath object */
acpi_ps_init_op (arg, AML_NAMEPATH_OP);
arg->value.name = path;
return;
}
if (method_call) {
/*
* Lookup the name in the internal namespace
*/
scope_info.scope.node = NULL;
node = parser_state->start_node;
if (node) {
scope_info.scope.node = node;
}
/*
* Lookup object. We don't want to add anything new to the namespace
* here, however. So we use MODE_EXECUTE. Allow searching of the
* parent tree, but don't open a new scope -- we just want to lookup the
* object (MUST BE mode EXECUTE to perform upsearch)
*/
status = acpi_ns_lookup (&scope_info, path, ACPI_TYPE_ANY, IMODE_EXECUTE,
NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE, NULL,
&node);
if (ACPI_SUCCESS (status)) {
if (node->type == ACPI_TYPE_METHOD) {
method_node = node;
name_op = acpi_ps_alloc_op (AML_NAMEPATH_OP);
if (name_op) {
/* Change arg into a METHOD CALL and attach name to it */
acpi_ps_init_op (arg, AML_METHODCALL_OP);
name_op->value.name = path;
/* Point METHODCALL/NAME to the METHOD Node */
name_op->node = method_node;
acpi_ps_append_arg (arg, name_op);
if (!(ACPI_OPERAND_OBJECT *) method_node->object) {
return;
}
*arg_count = ((ACPI_OPERAND_OBJECT *) method_node->object)->method.param_count;
}
return;
}
/*
* Else this is normal named object reference.
* Just init the NAMEPATH object with the pathname.
* (See code below)
*/
}
}
/*
* Either we didn't find the object in the namespace, or the object is
* something other than a control method. Just initialize the Op with the
* pathname.
*/
acpi_ps_init_op (arg, AML_NAMEPATH_OP);
arg->value.name = path;
return;
}
void
acpi_ps_get_next_namepath (
ACPI_PARSE_STATE *parser_state,
ACPI_PARSE_OBJECT *arg,
u32 *arg_count,
u8 method_call)
{
NATIVE_CHAR *path;
ACPI_PARSE_OBJECT *name_op;
ACPI_PARSE_OBJECT *op;
ACPI_PARSE_OBJECT *count;
path = acpi_ps_get_next_namestring (parser_state);
if (!path || !method_call) {
/* Null name case, create a null namepath object */
acpi_ps_init_op (arg, AML_NAMEPATH_OP);
arg->value.name = path;
return;
}
if (acpi_gbl_parsed_namespace_root) {
/*
* Lookup the name in the parsed namespace
*/
op = NULL;
if (method_call) {
op = acpi_ps_find (acpi_ps_get_parent_scope (parser_state),
path, AML_METHOD_OP, 0);
}
if (op) {
if (op->opcode == AML_METHOD_OP) {
/*
* The name refers to a control method, so this namepath is a
* method invocation. We need to 1) Get the number of arguments
* associated with this method, and 2) Change the NAMEPATH
* object into a METHODCALL object.
*/
count = acpi_ps_get_arg (op, 0);
if (count && count->opcode == AML_BYTE_OP) {
name_op = acpi_ps_alloc_op (AML_NAMEPATH_OP);
if (name_op) {
/* Change arg into a METHOD CALL and attach the name */
acpi_ps_init_op (arg, AML_METHODCALL_OP);
name_op->value.name = path;
/* Point METHODCALL/NAME to the METHOD Node */
name_op->node = (ACPI_NAMESPACE_NODE *) op;
acpi_ps_append_arg (arg, name_op);
*arg_count = count->value.integer &
METHOD_FLAGS_ARG_COUNT;
}
}
return;
}
/*
* Else this is normal named object reference.
* Just init the NAMEPATH object with the pathname.
* (See code below)
*/
}
}
/*
* Either we didn't find the object in the namespace, or the object is
* something other than a control method. Just initialize the Op with the
* pathname
*/
acpi_ps_init_op (arg, AML_NAMEPATH_OP);
arg->value.name = path;
return;
}