/****************************************************************************** * * Module Name: dsopcode - Dispatcher Op Region support and handling of * "control" opcodes * $Revision: 56 $ * *****************************************************************************/ /* * 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" #include "acevents.h" #include "actables.h" #define _COMPONENT ACPI_DISPATCHER MODULE_NAME ("dsopcode") /***************************************************************************** * * FUNCTION: Acpi_ds_get_buffer_field_arguments * * PARAMETERS: Obj_desc - A valid Buffer_field object * * RETURN: Status. * * DESCRIPTION: Get Buffer_field Buffer and Index. This implements the late * evaluation of these field attributes. * ****************************************************************************/ acpi_status acpi_ds_get_buffer_field_arguments ( acpi_operand_object *obj_desc) { acpi_operand_object *extra_desc; acpi_namespace_node *node; acpi_parse_object *op; acpi_parse_object *field_op; acpi_status status; acpi_table_desc *table_desc; acpi_walk_state *walk_state; FUNCTION_TRACE_PTR ("Ds_get_buffer_field_arguments", obj_desc); if (obj_desc->common.flags & AOPOBJ_DATA_VALID) { return_ACPI_STATUS (AE_OK); } /* Get the AML pointer (method object) and Buffer_field node */ extra_desc = obj_desc->buffer_field.extra; node = obj_desc->buffer_field.node; DEBUG_EXEC(acpi_ut_display_init_pathname (node, " [Field]")); ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s] Buffer_field JIT Init\n", (char*)&node->name)); /* * Allocate a new parser op to be the root of the parsed * Op_region tree */ op = acpi_ps_alloc_op (AML_SCOPE_OP); if (!op) { return (AE_NO_MEMORY); } /* Save the Node for use in Acpi_ps_parse_aml */ op->node = acpi_ns_get_parent_object (node); /* Get a handle to the parent ACPI table */ status = acpi_tb_handle_to_object (node->owner_id, &table_desc); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } /* Create and initialize a new parser state */ walk_state = acpi_ds_create_walk_state (TABLE_ID_DSDT, NULL, NULL, NULL); if (!walk_state) { return_ACPI_STATUS (AE_NO_MEMORY); } status = acpi_ds_init_aml_walk (walk_state, op, NULL, extra_desc->extra.aml_start, extra_desc->extra.aml_length, NULL, NULL, 1); if (ACPI_FAILURE (status)) { /* TBD: delete walk state */ return_ACPI_STATUS (status); } /* TBD: No Walk flags?? */ walk_state->parse_flags = 0; /* Pass1: Parse the entire Buffer_field declaration */ status = acpi_ps_parse_aml (walk_state); if (ACPI_FAILURE (status)) { acpi_ps_delete_parse_tree (op); return_ACPI_STATUS (status); } /* Get and init the actual Field_unit Op created above */ field_op = op->value.arg; op->node = node; field_op = op->value.arg; field_op->node = node; acpi_ps_delete_parse_tree (op); /* Evaluate the address and length arguments for the Op_region */ op = acpi_ps_alloc_op (AML_SCOPE_OP); if (!op) { return (AE_NO_MEMORY); } op->node = acpi_ns_get_parent_object (node); /* Create and initialize a new parser state */ walk_state = acpi_ds_create_walk_state (TABLE_ID_DSDT, NULL, NULL, NULL); if (!walk_state) { return_ACPI_STATUS (AE_NO_MEMORY); } status = acpi_ds_init_aml_walk (walk_state, op, NULL, extra_desc->extra.aml_start, extra_desc->extra.aml_length, NULL, NULL, 3); if (ACPI_FAILURE (status)) { /* TBD: delete walk state */ return_ACPI_STATUS (status); } status = acpi_ps_parse_aml (walk_state); acpi_ps_delete_parse_tree (op); /* * The pseudo-method object is no longer needed since the region is * now initialized */ acpi_ut_remove_reference (obj_desc->buffer_field.extra); obj_desc->buffer_field.extra = NULL; return_ACPI_STATUS (status); } /***************************************************************************** * * FUNCTION: Acpi_ds_get_region_arguments * * PARAMETERS: Obj_desc - A valid region object * * RETURN: Status. * * DESCRIPTION: Get region address and length. This implements the late * evaluation of these region attributes. * ****************************************************************************/ acpi_status acpi_ds_get_region_arguments ( acpi_operand_object *obj_desc) { acpi_operand_object *extra_desc = NULL; acpi_namespace_node *node; acpi_parse_object *op; acpi_parse_object *region_op; acpi_status status; acpi_table_desc *table_desc; acpi_walk_state *walk_state; FUNCTION_TRACE_PTR ("Ds_get_region_arguments", obj_desc); if (obj_desc->region.flags & AOPOBJ_DATA_VALID) { return_ACPI_STATUS (AE_OK); } /* Get the AML pointer (method object) and region node */ extra_desc = obj_desc->region.extra; node = obj_desc->region.node; DEBUG_EXEC(acpi_ut_display_init_pathname (node, " [Operation Region]")); ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s] Op_region Init at AML %p\n", (char*)&node->name, extra_desc->extra.aml_start)); /* * Allocate a new parser op to be the root of the parsed * Op_region tree */ op = acpi_ps_alloc_op (AML_SCOPE_OP); if (!op) { return (AE_NO_MEMORY); } /* Save the Node for use in Acpi_ps_parse_aml */ op->node = acpi_ns_get_parent_object (node); /* Get a handle to the parent ACPI table */ status = acpi_tb_handle_to_object (node->owner_id, &table_desc); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } /* Create and initialize a new parser state */ walk_state = acpi_ds_create_walk_state (TABLE_ID_DSDT, op, NULL, NULL); if (!walk_state) { return_ACPI_STATUS (AE_NO_MEMORY); } status = acpi_ds_init_aml_walk (walk_state, op, NULL, extra_desc->extra.aml_start, extra_desc->extra.aml_length, NULL, NULL, 1); if (ACPI_FAILURE (status)) { /* TBD: delete walk state */ return_ACPI_STATUS (status); } /* TBD: No Walk flags?? */ walk_state->parse_flags = 0; /* Parse the entire Op_region declaration, creating a parse tree */ status = acpi_ps_parse_aml (walk_state); if (ACPI_FAILURE (status)) { acpi_ps_delete_parse_tree (op); return_ACPI_STATUS (status); } /* Get and init the actual Region_op created above */ region_op = op->value.arg; op->node = node; region_op = op->value.arg; region_op->node = node; acpi_ps_delete_parse_tree (op); /* Evaluate the address and length arguments for the Op_region */ op = acpi_ps_alloc_op (AML_SCOPE_OP); if (!op) { return (AE_NO_MEMORY); } op->node = acpi_ns_get_parent_object (node); /* Create and initialize a new parser state */ walk_state = acpi_ds_create_walk_state (TABLE_ID_DSDT, op, NULL, NULL); if (!walk_state) { return_ACPI_STATUS (AE_NO_MEMORY); } status = acpi_ds_init_aml_walk (walk_state, op, NULL, extra_desc->extra.aml_start, extra_desc->extra.aml_length, NULL, NULL, 3); if (ACPI_FAILURE (status)) { /* TBD: delete walk state */ return_ACPI_STATUS (status); } status = acpi_ps_parse_aml (walk_state); acpi_ps_delete_parse_tree (op); return_ACPI_STATUS (status); } /***************************************************************************** * * FUNCTION: Acpi_ds_initialize_region * * PARAMETERS: Op - A valid region Op object * * RETURN: Status * * DESCRIPTION: * ****************************************************************************/ acpi_status acpi_ds_initialize_region ( acpi_handle obj_handle) { acpi_operand_object *obj_desc; acpi_status status; obj_desc = acpi_ns_get_attached_object (obj_handle); /* Namespace is NOT locked */ status = acpi_ev_initialize_region (obj_desc, FALSE); return (status); } /***************************************************************************** * * FUNCTION: Acpi_ds_eval_buffer_field_operands * * PARAMETERS: Op - A valid Buffer_field Op object * * RETURN: Status * * DESCRIPTION: Get Buffer_field Buffer and Index * Called from Acpi_ds_exec_end_op during Buffer_field parse tree walk * * ACPI SPECIFICATION REFERENCES: * Each of the Buffer Field opcodes is defined as specified in in-line * comments below. For each one, use the following definitions. * * Def_bit_field := Bit_field_op Src_buf Bit_idx Destination * Def_byte_field := Byte_field_op Src_buf Byte_idx Destination * Def_create_field := Create_field_op Src_buf Bit_idx Num_bits Name_string * Def_dWord_field := DWord_field_op Src_buf Byte_idx Destination * Def_word_field := Word_field_op Src_buf Byte_idx Destination * Bit_index := Term_arg=>Integer * Byte_index := Term_arg=>Integer * Destination := Name_string * Num_bits := Term_arg=>Integer * Source_buf := Term_arg=>Buffer * ****************************************************************************/ acpi_status acpi_ds_eval_buffer_field_operands ( acpi_walk_state *walk_state, acpi_parse_object *op) { acpi_status status; acpi_operand_object *obj_desc; acpi_namespace_node *node; acpi_parse_object *next_op; u32 offset; u32 bit_offset; u32 bit_count; u8 field_flags; acpi_operand_object *res_desc = NULL; acpi_operand_object *cnt_desc = NULL; acpi_operand_object *off_desc = NULL; acpi_operand_object *src_desc = NULL; FUNCTION_TRACE_PTR ("Ds_eval_buffer_field_operands", op); /* * This is where we evaluate the address and length fields of the * Create_xxx_field declaration */ node = op->node; /* Next_op points to the op that holds the Buffer */ next_op = op->value.arg; /* Acpi_evaluate/create the address and length operands */ status = acpi_ds_create_operands (walk_state, next_op); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } obj_desc = acpi_ns_get_attached_object (node); if (!obj_desc) { return_ACPI_STATUS (AE_NOT_EXIST); } /* Resolve the operands */ status = acpi_ex_resolve_operands (op->opcode, WALK_OPERANDS, walk_state); DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, acpi_ps_get_opcode_name (op->opcode), walk_state->num_operands, "after Acpi_ex_resolve_operands"); if (ACPI_FAILURE (status)) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(%s) bad operand(s) (%X)\n", acpi_ps_get_opcode_name (op->opcode), status)); goto cleanup; } /* Get the operands */ if (AML_CREATE_FIELD_OP == op->opcode) { res_desc = walk_state->operands[3]; cnt_desc = walk_state->operands[2]; } else { res_desc = walk_state->operands[2]; } off_desc = walk_state->operands[1]; src_desc = walk_state->operands[0]; offset = (u32) off_desc->integer.value; /* * If Res_desc is a Name, it will be a direct name pointer after * Acpi_ex_resolve_operands() */ if (!VALID_DESCRIPTOR_TYPE (res_desc, ACPI_DESC_TYPE_NAMED)) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(%s) destination must be a Node\n", acpi_ps_get_opcode_name (op->opcode))); status = AE_AML_OPERAND_TYPE; goto cleanup; } /* * Setup the Bit offsets and counts, according to the opcode */ switch (op->opcode) { /* Def_create_field */ case AML_CREATE_FIELD_OP: /* Offset is in bits, count is in bits */ bit_offset = offset; bit_count = (u32) cnt_desc->integer.value; field_flags = ACCESS_BYTE_ACC; break; /* Def_create_bit_field */ case AML_CREATE_BIT_FIELD_OP: /* Offset is in bits, Field is one bit */ bit_offset = offset; bit_count = 1; field_flags = ACCESS_BYTE_ACC; break; /* Def_create_byte_field */ case AML_CREATE_BYTE_FIELD_OP: /* Offset is in bytes, field is one byte */ bit_offset = 8 * offset; bit_count = 8; field_flags = ACCESS_BYTE_ACC; break; /* Def_create_word_field */ case AML_CREATE_WORD_FIELD_OP: /* Offset is in bytes, field is one word */ bit_offset = 8 * offset; bit_count = 16; field_flags = ACCESS_WORD_ACC; break; /* Def_create_dWord_field */ case AML_CREATE_DWORD_FIELD_OP: /* Offset is in bytes, field is one dword */ bit_offset = 8 * offset; bit_count = 32; field_flags = ACCESS_DWORD_ACC; break; /* Def_create_qWord_field */ case AML_CREATE_QWORD_FIELD_OP: /* Offset is in bytes, field is one qword */ bit_offset = 8 * offset; bit_count = 64; field_flags = ACCESS_QWORD_ACC; break; default: ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal error - unknown field creation opcode %02x\n", op->opcode)); status = AE_AML_BAD_OPCODE; goto cleanup; } /* * Setup field according to the object type */ switch (src_desc->common.type) { /* Source_buff := Term_arg=>Buffer */ case ACPI_TYPE_BUFFER: if ((bit_offset + bit_count) > (8 * (u32) src_desc->buffer.length)) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Field size %d exceeds Buffer size %d (bits)\n", bit_offset + bit_count, 8 * (u32) src_desc->buffer.length)); status = AE_AML_BUFFER_LIMIT; goto cleanup; } /* * Initialize areas of the field object that are common to all fields * For Field_flags, use LOCK_RULE = 0 (NO_LOCK), UPDATE_RULE = 0 (UPDATE_PRESERVE) */ status = acpi_ex_prep_common_field_object (obj_desc, field_flags, bit_offset, bit_count); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } obj_desc->buffer_field.buffer_obj = src_desc; /* Reference count for Src_desc inherits Obj_desc count */ src_desc->common.reference_count = (u16) (src_desc->common.reference_count + obj_desc->common.reference_count); break; /* Improper object type */ default: if ((src_desc->common.type > (u8) INTERNAL_TYPE_REFERENCE) || !acpi_ut_valid_object_type (src_desc->common.type)) /* TBD: This line MUST be a single line until Acpi_src can handle it (block deletion) */ { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Tried to create field in invalid object type %X\n", src_desc->common.type)); } else { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Tried to create field in improper object type - %s\n", acpi_ut_get_type_name (src_desc->common.type))); } status = AE_AML_OPERAND_TYPE; goto cleanup; } if (AML_CREATE_FIELD_OP == op->opcode) { /* Delete object descriptor unique to Create_field */ acpi_ut_remove_reference (cnt_desc); cnt_desc = NULL; } cleanup: /* Always delete the operands */ acpi_ut_remove_reference (off_desc); acpi_ut_remove_reference (src_desc); if (AML_CREATE_FIELD_OP == op->opcode) { acpi_ut_remove_reference (cnt_desc); } /* On failure, delete the result descriptor */ if (ACPI_FAILURE (status)) { acpi_ut_remove_reference (res_desc); /* Result descriptor */ } else { /* Now the address and length are valid for this Buffer_field */ obj_desc->buffer_field.flags |= AOPOBJ_DATA_VALID; } return_ACPI_STATUS (status); } /***************************************************************************** * * FUNCTION: Acpi_ds_eval_region_operands * * PARAMETERS: Op - A valid region Op object * * RETURN: Status * * DESCRIPTION: Get region address and length * Called from Acpi_ds_exec_end_op during Op_region parse tree walk * ****************************************************************************/ acpi_status acpi_ds_eval_region_operands ( acpi_walk_state *walk_state, acpi_parse_object *op) { acpi_status status; acpi_operand_object *obj_desc; acpi_operand_object *operand_desc; acpi_namespace_node *node; acpi_parse_object *next_op; FUNCTION_TRACE_PTR ("Ds_eval_region_operands", op); /* * This is where we evaluate the address and length fields of the Op_region declaration */ node = op->node; /* Next_op points to the op that holds the Space_iD */ next_op = op->value.arg; /* Next_op points to address op */ next_op = next_op->next; /* Acpi_evaluate/create the address and length operands */ status = acpi_ds_create_operands (walk_state, next_op); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } /* Resolve the length and address operands to numbers */ status = acpi_ex_resolve_operands (op->opcode, WALK_OPERANDS, walk_state); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } DUMP_OPERANDS (WALK_OPERANDS, IMODE_EXECUTE, acpi_ps_get_opcode_name (op->opcode), 1, "after Acpi_ex_resolve_operands"); obj_desc = acpi_ns_get_attached_object (node); if (!obj_desc) { return_ACPI_STATUS (AE_NOT_EXIST); } /* * Get the length operand and save it * (at Top of stack) */ operand_desc = walk_state->operands[walk_state->num_operands - 1]; obj_desc->region.length = (u32) operand_desc->integer.value; acpi_ut_remove_reference (operand_desc); /* * Get the address and save it * (at top of stack - 1) */ operand_desc = walk_state->operands[walk_state->num_operands - 2]; obj_desc->region.address = (ACPI_PHYSICAL_ADDRESS) operand_desc->integer.value; acpi_ut_remove_reference (operand_desc); ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Rgn_obj %p Addr %8.8X%8.8X Len %X\n", obj_desc, HIDWORD(obj_desc->region.address), LODWORD(obj_desc->region.address), obj_desc->region.length)); /* Now the address and length are valid for this opregion */ obj_desc->region.flags |= AOPOBJ_DATA_VALID; return_ACPI_STATUS (status); } /******************************************************************************* * * FUNCTION: Acpi_ds_exec_begin_control_op * * PARAMETERS: Walk_list - The list that owns the walk stack * Op - The control Op * * RETURN: Status * * DESCRIPTION: Handles all control ops encountered during control method * execution. * ******************************************************************************/ acpi_status acpi_ds_exec_begin_control_op ( acpi_walk_state *walk_state, acpi_parse_object *op) { acpi_status status = AE_OK; acpi_generic_state *control_state; PROC_NAME ("Ds_exec_begin_control_op"); ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p Opcode=%2.2X State=%p\n", op, op->opcode, walk_state)); switch (op->opcode) { case AML_IF_OP: case AML_WHILE_OP: /* * IF/WHILE: Create a new control state to manage these * constructs. We need to manage these as a stack, in order * to handle nesting. */ control_state = acpi_ut_create_control_state (); if (!control_state) { status = AE_NO_MEMORY; break; } acpi_ut_push_generic_state (&walk_state->control_state, control_state); /* * Save a pointer to the predicate for multiple executions * of a loop */ walk_state->control_state->control.aml_predicate_start = walk_state->parser_state.aml - 1; /* TBD: can this be removed? */ /*Acpi_ps_pkg_length_encoding_size (GET8 (Walk_state->Parser_state->Aml));*/ break; case AML_ELSE_OP: /* Predicate is in the state object */ /* If predicate is true, the IF was executed, ignore ELSE part */ if (walk_state->last_predicate) { status = AE_CTRL_TRUE; } break; case AML_RETURN_OP: break; default: break; } return (status); } /******************************************************************************* * * FUNCTION: Acpi_ds_exec_end_control_op * * PARAMETERS: Walk_list - The list that owns the walk stack * Op - The control Op * * RETURN: Status * * DESCRIPTION: Handles all control ops encountered during control method * execution. * * ******************************************************************************/ acpi_status acpi_ds_exec_end_control_op ( acpi_walk_state *walk_state, acpi_parse_object *op) { acpi_status status = AE_OK; acpi_generic_state *control_state; PROC_NAME ("Ds_exec_end_control_op"); switch (op->opcode) { case AML_IF_OP: ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[IF_OP] Op=%p\n", op)); /* * Save the result of the predicate in case there is an * ELSE to come */ walk_state->last_predicate = (u8) walk_state->control_state->common.value; /* * Pop the control state that was created at the start * of the IF and free it */ control_state = acpi_ut_pop_generic_state (&walk_state->control_state); acpi_ut_delete_generic_state (control_state); break; case AML_ELSE_OP: break; case AML_WHILE_OP: ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[WHILE_OP] Op=%p\n", op)); if (walk_state->control_state->common.value) { /* Predicate was true, go back and evaluate it again! */ status = AE_CTRL_PENDING; } ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[WHILE_OP] termination! Op=%p\n", op)); /* Pop this control state and free it */ control_state = acpi_ut_pop_generic_state (&walk_state->control_state); walk_state->aml_last_while = control_state->control.aml_predicate_start; acpi_ut_delete_generic_state (control_state); break; case AML_RETURN_OP: ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[RETURN_OP] Op=%p Arg=%p\n",op, op->value.arg)); /* * One optional operand -- the return value * It can be either an immediate operand or a result that * has been bubbled up the tree */ if (op->value.arg) { /* Return statement has an immediate operand */ status = acpi_ds_create_operands (walk_state, op->value.arg); if (ACPI_FAILURE (status)) { return (status); } /* * If value being returned is a Reference (such as * an arg or local), resolve it now because it may * cease to exist at the end of the method. */ status = acpi_ex_resolve_to_value (&walk_state->operands [0], walk_state); if (ACPI_FAILURE (status)) { return (status); } /* * Get the return value and save as the last result * value. This is the only place where Walk_state->Return_desc * is set to anything other than zero! */ walk_state->return_desc = walk_state->operands[0]; } else if ((walk_state->results) && (walk_state->results->results.num_results > 0)) { /* * The return value has come from a previous calculation. * * If value being returned is a Reference (such as * an arg or local), resolve it now because it may * cease to exist at the end of the method. * * Allow references created by the Index operator to return unchanged. */ if (VALID_DESCRIPTOR_TYPE (walk_state->results->results.obj_desc [0], ACPI_DESC_TYPE_INTERNAL) && ((walk_state->results->results.obj_desc [0])->common.type == INTERNAL_TYPE_REFERENCE) && ((walk_state->results->results.obj_desc [0])->reference.opcode != AML_INDEX_OP)) { status = acpi_ex_resolve_to_value (&walk_state->results->results.obj_desc [0], walk_state); if (ACPI_FAILURE (status)) { return (status); } } walk_state->return_desc = walk_state->results->results.obj_desc [0]; } else { /* No return operand */ if (walk_state->num_operands) { acpi_ut_remove_reference (walk_state->operands [0]); } walk_state->operands [0] = NULL; walk_state->num_operands = 0; walk_state->return_desc = NULL; } ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Completed RETURN_OP State=%p, Ret_val=%p\n", walk_state, walk_state->return_desc)); /* End the control method execution right now */ status = AE_CTRL_TERMINATE; break; case AML_NOOP_OP: /* Just do nothing! */ break; case AML_BREAK_POINT_OP: /* Call up to the OS service layer to handle this */ acpi_os_signal (ACPI_SIGNAL_BREAKPOINT, "Executed AML Breakpoint opcode"); /* If and when it returns, all done. */ break; case AML_BREAK_OP: ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Break to end of current package, Op=%p\n", op)); /* TBD: update behavior for ACPI 2.0 */ /* * As per the ACPI specification: * "The break operation causes the current package * execution to complete" * "Break -- Stop executing the current code package * at this point" * * Returning AE_FALSE here will cause termination of * the current package, and execution will continue one * level up, starting with the completion of the parent Op. */ status = AE_CTRL_FALSE; break; case AML_CONTINUE_OP: /* ACPI 2.0 */ status = AE_NOT_IMPLEMENTED; break; default: ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown control opcode=%X Op=%p\n", op->opcode, op)); status = AE_AML_BAD_OPCODE; break; } return (status); }