blob: 5e1abb12c74883ebfa14a6bc9bab9ae725b92040 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/******************************************************************************
2 *
3 * Module Name: exoparg2 - AML execution - opcodes with 2 arguments
4 *
5 *****************************************************************************/
6
7/*
Bob Moore4a90c7e2006-01-13 16:22:00 -05008 * Copyright (C) 2000 - 2006, R. Byron Moore
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <acpi/acpi.h>
45#include <acpi/acparser.h>
46#include <acpi/acinterp.h>
47#include <acpi/acevents.h>
48#include <acpi/amlcode.h>
49
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#define _COMPONENT ACPI_EXECUTER
Len Brown4be44fc2005-08-05 00:44:28 -040051ACPI_MODULE_NAME("exoparg2")
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
53/*!
54 * Naming convention for AML interpreter execution routines.
55 *
56 * The routines that begin execution of AML opcodes are named with a common
57 * convention based upon the number of arguments, the number of target operands,
58 * and whether or not a value is returned:
59 *
60 * AcpiExOpcode_xA_yT_zR
61 *
62 * Where:
63 *
64 * xA - ARGUMENTS: The number of arguments (input operands) that are
65 * required for this opcode type (1 through 6 args).
66 * yT - TARGETS: The number of targets (output operands) that are required
67 * for this opcode type (0, 1, or 2 targets).
68 * zR - RETURN VALUE: Indicates whether this opcode type returns a value
69 * as the function return (0 or 1).
70 *
71 * The AcpiExOpcode* functions are called via the Dispatcher component with
72 * fully resolved operands.
73!*/
Linus Torvalds1da177e2005-04-16 15:20:36 -070074/*******************************************************************************
75 *
76 * FUNCTION: acpi_ex_opcode_2A_0T_0R
77 *
78 * PARAMETERS: walk_state - Current walk state
79 *
80 * RETURN: Status
81 *
82 * DESCRIPTION: Execute opcode with two arguments, no target, and no return
83 * value.
84 *
85 * ALLOCATION: Deletes both operands
86 *
87 ******************************************************************************/
Len Brown4be44fc2005-08-05 00:44:28 -040088acpi_status acpi_ex_opcode_2A_0T_0R(struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -070089{
Len Brown4be44fc2005-08-05 00:44:28 -040090 union acpi_operand_object **operand = &walk_state->operands[0];
91 struct acpi_namespace_node *node;
92 u32 value;
93 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Len Brown4be44fc2005-08-05 00:44:28 -040095 ACPI_FUNCTION_TRACE_STR("ex_opcode_2A_0T_0R",
96 acpi_ps_get_opcode_name(walk_state->opcode));
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98 /* Examine the opcode */
99
100 switch (walk_state->opcode) {
Len Brown4be44fc2005-08-05 00:44:28 -0400101 case AML_NOTIFY_OP: /* Notify (notify_object, notify_value) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
103 /* The first operand is a namespace node */
104
Len Brown4be44fc2005-08-05 00:44:28 -0400105 node = (struct acpi_namespace_node *)operand[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
107 /* Second value is the notify value */
108
109 value = (u32) operand[1]->integer.value;
110
Robert Moore44f6c012005-04-18 22:49:35 -0400111 /* Are notifies allowed on this object? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
Len Brown4be44fc2005-08-05 00:44:28 -0400113 if (!acpi_ev_is_notify_object(node)) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500114 ACPI_ERROR((AE_INFO,
115 "Unexpected notify object type [%s]",
116 acpi_ut_get_type_name(node->type)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118 status = AE_AML_OPERAND_TYPE;
119 break;
120 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121#ifdef ACPI_GPE_NOTIFY_CHECK
122 /*
123 * GPE method wake/notify check. Here, we want to ensure that we
124 * don't receive any "device_wake" Notifies from a GPE _Lxx or _Exx
125 * GPE method during system runtime. If we do, the GPE is marked
126 * as "wake-only" and disabled.
127 *
128 * 1) Is the Notify() value == device_wake?
129 * 2) Is this a GPE deferred method? (An _Lxx or _Exx method)
130 * 3) Did the original GPE happen at system runtime?
131 * (versus during wake)
132 *
133 * If all three cases are true, this is a wake-only GPE that should
134 * be disabled at runtime.
135 */
Len Brown4be44fc2005-08-05 00:44:28 -0400136 if (value == 2) { /* device_wake */
137 status =
138 acpi_ev_check_for_wake_only_gpe(walk_state->
139 gpe_event_info);
140 if (ACPI_FAILURE(status)) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 /* AE_WAKE_ONLY_GPE only error, means ignore this notify */
143
Len Brown4be44fc2005-08-05 00:44:28 -0400144 return_ACPI_STATUS(AE_OK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 }
146 }
147#endif
148
149 /*
150 * Dispatch the notify to the appropriate handler
151 * NOTE: the request is queued for execution after this method
152 * completes. The notify handlers are NOT invoked synchronously
153 * from this thread -- because handlers may in turn run other
154 * control methods.
155 */
Len Brown4be44fc2005-08-05 00:44:28 -0400156 status = acpi_ev_queue_notify_request(node, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 break;
158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 default:
160
Bob Mooreb8e4d892006-01-27 16:43:00 -0500161 ACPI_ERROR((AE_INFO, "Unknown AML opcode %X",
162 walk_state->opcode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 status = AE_AML_BAD_OPCODE;
164 }
165
Len Brown4be44fc2005-08-05 00:44:28 -0400166 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167}
168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169/*******************************************************************************
170 *
171 * FUNCTION: acpi_ex_opcode_2A_2T_1R
172 *
173 * PARAMETERS: walk_state - Current walk state
174 *
175 * RETURN: Status
176 *
177 * DESCRIPTION: Execute a dyadic operator (2 operands) with 2 output targets
178 * and one implicit return value.
179 *
180 ******************************************************************************/
181
Len Brown4be44fc2005-08-05 00:44:28 -0400182acpi_status acpi_ex_opcode_2A_2T_1R(struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183{
Len Brown4be44fc2005-08-05 00:44:28 -0400184 union acpi_operand_object **operand = &walk_state->operands[0];
185 union acpi_operand_object *return_desc1 = NULL;
186 union acpi_operand_object *return_desc2 = NULL;
187 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Len Brown4be44fc2005-08-05 00:44:28 -0400189 ACPI_FUNCTION_TRACE_STR("ex_opcode_2A_2T_1R",
190 acpi_ps_get_opcode_name(walk_state->opcode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Robert Moore44f6c012005-04-18 22:49:35 -0400192 /* Execute the opcode */
193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 switch (walk_state->opcode) {
Robert Moore44f6c012005-04-18 22:49:35 -0400195 case AML_DIVIDE_OP:
196
197 /* Divide (Dividend, Divisor, remainder_result quotient_result) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Len Brown4be44fc2005-08-05 00:44:28 -0400199 return_desc1 =
200 acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 if (!return_desc1) {
202 status = AE_NO_MEMORY;
203 goto cleanup;
204 }
205
Len Brown4be44fc2005-08-05 00:44:28 -0400206 return_desc2 =
207 acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 if (!return_desc2) {
209 status = AE_NO_MEMORY;
210 goto cleanup;
211 }
212
213 /* Quotient to return_desc1, remainder to return_desc2 */
214
Len Brown4be44fc2005-08-05 00:44:28 -0400215 status = acpi_ut_divide(operand[0]->integer.value,
216 operand[1]->integer.value,
217 &return_desc1->integer.value,
218 &return_desc2->integer.value);
219 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 goto cleanup;
221 }
222 break;
223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 default:
225
Bob Mooreb8e4d892006-01-27 16:43:00 -0500226 ACPI_ERROR((AE_INFO, "Unknown AML opcode %X",
227 walk_state->opcode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 status = AE_AML_BAD_OPCODE;
229 goto cleanup;
230 }
231
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 /* Store the results to the target reference operands */
233
Len Brown4be44fc2005-08-05 00:44:28 -0400234 status = acpi_ex_store(return_desc2, operand[2], walk_state);
235 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 goto cleanup;
237 }
238
Len Brown4be44fc2005-08-05 00:44:28 -0400239 status = acpi_ex_store(return_desc1, operand[3], walk_state);
240 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 goto cleanup;
242 }
243
244 /* Return the remainder */
245
246 walk_state->result_obj = return_desc1;
247
Len Brown4be44fc2005-08-05 00:44:28 -0400248 cleanup:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 /*
250 * Since the remainder is not returned indirectly, remove a reference to
251 * it. Only the quotient is returned indirectly.
252 */
Len Brown4be44fc2005-08-05 00:44:28 -0400253 acpi_ut_remove_reference(return_desc2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Len Brown4be44fc2005-08-05 00:44:28 -0400255 if (ACPI_FAILURE(status)) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400256
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 /* Delete the return object */
258
Len Brown4be44fc2005-08-05 00:44:28 -0400259 acpi_ut_remove_reference(return_desc1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 }
261
Len Brown4be44fc2005-08-05 00:44:28 -0400262 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263}
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265/*******************************************************************************
266 *
267 * FUNCTION: acpi_ex_opcode_2A_1T_1R
268 *
269 * PARAMETERS: walk_state - Current walk state
270 *
271 * RETURN: Status
272 *
273 * DESCRIPTION: Execute opcode with two arguments, one target, and a return
274 * value.
275 *
276 ******************************************************************************/
277
Len Brown4be44fc2005-08-05 00:44:28 -0400278acpi_status acpi_ex_opcode_2A_1T_1R(struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
Len Brown4be44fc2005-08-05 00:44:28 -0400280 union acpi_operand_object **operand = &walk_state->operands[0];
281 union acpi_operand_object *return_desc = NULL;
282 acpi_integer index;
283 acpi_status status = AE_OK;
284 acpi_size length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
Len Brown4be44fc2005-08-05 00:44:28 -0400286 ACPI_FUNCTION_TRACE_STR("ex_opcode_2A_1T_1R",
287 acpi_ps_get_opcode_name(walk_state->opcode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Robert Moore44f6c012005-04-18 22:49:35 -0400289 /* Execute the opcode */
290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 if (walk_state->op_info->flags & AML_MATH) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 /* All simple math opcodes (add, etc.) */
294
Len Brown4be44fc2005-08-05 00:44:28 -0400295 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 if (!return_desc) {
297 status = AE_NO_MEMORY;
298 goto cleanup;
299 }
300
Len Brown4be44fc2005-08-05 00:44:28 -0400301 return_desc->integer.value =
302 acpi_ex_do_math_op(walk_state->opcode,
303 operand[0]->integer.value,
304 operand[1]->integer.value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 goto store_result_to_target;
306 }
307
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 switch (walk_state->opcode) {
Len Brown4be44fc2005-08-05 00:44:28 -0400309 case AML_MOD_OP: /* Mod (Dividend, Divisor, remainder_result (ACPI 2.0) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
Len Brown4be44fc2005-08-05 00:44:28 -0400311 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 if (!return_desc) {
313 status = AE_NO_MEMORY;
314 goto cleanup;
315 }
316
317 /* return_desc will contain the remainder */
318
Len Brown4be44fc2005-08-05 00:44:28 -0400319 status = acpi_ut_divide(operand[0]->integer.value,
320 operand[1]->integer.value,
321 NULL, &return_desc->integer.value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 break;
323
Len Brown4be44fc2005-08-05 00:44:28 -0400324 case AML_CONCAT_OP: /* Concatenate (Data1, Data2, Result) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
Len Brown4be44fc2005-08-05 00:44:28 -0400326 status = acpi_ex_do_concatenate(operand[0], operand[1],
327 &return_desc, walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 break;
329
Len Brown4be44fc2005-08-05 00:44:28 -0400330 case AML_TO_STRING_OP: /* to_string (Buffer, Length, Result) (ACPI 2.0) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
332 /*
333 * Input object is guaranteed to be a buffer at this point (it may have
Robert Moore44f6c012005-04-18 22:49:35 -0400334 * been converted.) Copy the raw buffer data to a new object of
335 * type String.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 */
337
338 /*
339 * Get the length of the new string. It is the smallest of:
340 * 1) Length of the input buffer
341 * 2) Max length as specified in the to_string operator
342 * 3) Length of input buffer up to a zero byte (null terminator)
343 *
344 * NOTE: A length of zero is ok, and will create a zero-length, null
345 * terminated string.
346 */
347 length = 0;
348 while ((length < operand[0]->buffer.length) &&
Len Brown4be44fc2005-08-05 00:44:28 -0400349 (length < operand[1]->integer.value) &&
350 (operand[0]->buffer.pointer[length])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 length++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 }
353
354 /* Allocate a new string object */
355
Len Brown4be44fc2005-08-05 00:44:28 -0400356 return_desc = acpi_ut_create_string_object(length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 if (!return_desc) {
358 status = AE_NO_MEMORY;
359 goto cleanup;
360 }
361
Bob Moorec51a4de2005-11-17 13:07:00 -0500362 /*
363 * Copy the raw buffer data with no transform.
364 * (NULL terminated already)
365 */
Len Brown4be44fc2005-08-05 00:44:28 -0400366 ACPI_MEMCPY(return_desc->string.pointer,
367 operand[0]->buffer.pointer, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 break;
369
Robert Moore44f6c012005-04-18 22:49:35 -0400370 case AML_CONCAT_RES_OP:
371
372 /* concatenate_res_template (Buffer, Buffer, Result) (ACPI 2.0) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Len Brown4be44fc2005-08-05 00:44:28 -0400374 status = acpi_ex_concat_template(operand[0], operand[1],
375 &return_desc, walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 break;
377
Len Brown4be44fc2005-08-05 00:44:28 -0400378 case AML_INDEX_OP: /* Index (Source Index Result) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380 /* Create the internal return object */
381
Len Brown4be44fc2005-08-05 00:44:28 -0400382 return_desc =
383 acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_REFERENCE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 if (!return_desc) {
385 status = AE_NO_MEMORY;
386 goto cleanup;
387 }
388
Bob Moore52fc0b02006-10-02 00:00:00 -0400389 /* Initialize the Index reference object */
390
Robert Moore44f6c012005-04-18 22:49:35 -0400391 index = operand[1]->integer.value;
Bob Moore52fc0b02006-10-02 00:00:00 -0400392 return_desc->reference.offset = (u32) index;
393 return_desc->reference.opcode = AML_INDEX_OP;
394 return_desc->reference.object = operand[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
Bob Moore52fc0b02006-10-02 00:00:00 -0400396 /*
397 * At this point, the Source operand is a String, Buffer, or Package.
398 * Verify that the index is within range.
399 */
400 switch (ACPI_GET_OBJECT_TYPE(operand[0])) {
401 case ACPI_TYPE_STRING:
Robert Moore44f6c012005-04-18 22:49:35 -0400402
Bob Moore52fc0b02006-10-02 00:00:00 -0400403 if (index >= operand[0]->string.length) {
404 status = AE_AML_STRING_LIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 }
406
Len Brown4be44fc2005-08-05 00:44:28 -0400407 return_desc->reference.target_type =
408 ACPI_TYPE_BUFFER_FIELD;
Bob Moore52fc0b02006-10-02 00:00:00 -0400409 break;
410
411 case ACPI_TYPE_BUFFER:
412
413 if (index >= operand[0]->buffer.length) {
414 status = AE_AML_BUFFER_LIMIT;
415 }
416
417 return_desc->reference.target_type =
418 ACPI_TYPE_BUFFER_FIELD;
419 break;
420
421 case ACPI_TYPE_PACKAGE:
422
423 if (index >= operand[0]->package.count) {
424 status = AE_AML_PACKAGE_LIMIT;
425 }
426
427 return_desc->reference.target_type = ACPI_TYPE_PACKAGE;
428 return_desc->reference.where =
429 &operand[0]->package.elements[index];
430 break;
431
432 default:
433
434 status = AE_AML_INTERNAL;
435 goto cleanup;
436 }
437
438 /* Failure means that the Index was beyond the end of the object */
439
440 if (ACPI_FAILURE(status)) {
441 ACPI_EXCEPTION((AE_INFO, status,
442 "Index (%X%8.8X) is beyond end of object",
443 ACPI_FORMAT_UINT64(index)));
444 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 }
446
447 /*
448 * Add a reference to the target package/buffer/string for the life
Bob Moore52fc0b02006-10-02 00:00:00 -0400449 * of the index
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 */
Len Brown4be44fc2005-08-05 00:44:28 -0400451 acpi_ut_add_reference(operand[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 /* Store the reference to the Target */
454
Len Brown4be44fc2005-08-05 00:44:28 -0400455 status = acpi_ex_store(return_desc, operand[2], walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457 /* Return the reference */
458
459 walk_state->result_obj = return_desc;
460 goto cleanup;
461
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 default:
463
Bob Mooreb8e4d892006-01-27 16:43:00 -0500464 ACPI_ERROR((AE_INFO, "Unknown AML opcode %X",
465 walk_state->opcode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 status = AE_AML_BAD_OPCODE;
467 break;
468 }
469
Len Brown4be44fc2005-08-05 00:44:28 -0400470 store_result_to_target:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
Len Brown4be44fc2005-08-05 00:44:28 -0400472 if (ACPI_SUCCESS(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 /*
474 * Store the result of the operation (which is now in return_desc) into
475 * the Target descriptor.
476 */
Len Brown4be44fc2005-08-05 00:44:28 -0400477 status = acpi_ex_store(return_desc, operand[2], walk_state);
478 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 goto cleanup;
480 }
481
482 if (!walk_state->result_obj) {
483 walk_state->result_obj = return_desc;
484 }
485 }
486
Len Brown4be44fc2005-08-05 00:44:28 -0400487 cleanup:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
489 /* Delete return object on error */
490
Len Brown4be44fc2005-08-05 00:44:28 -0400491 if (ACPI_FAILURE(status)) {
492 acpi_ut_remove_reference(return_desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 }
494
Len Brown4be44fc2005-08-05 00:44:28 -0400495 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496}
497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498/*******************************************************************************
499 *
500 * FUNCTION: acpi_ex_opcode_2A_0T_1R
501 *
502 * PARAMETERS: walk_state - Current walk state
503 *
504 * RETURN: Status
505 *
506 * DESCRIPTION: Execute opcode with 2 arguments, no target, and a return value
507 *
508 ******************************************************************************/
509
Len Brown4be44fc2005-08-05 00:44:28 -0400510acpi_status acpi_ex_opcode_2A_0T_1R(struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
Len Brown4be44fc2005-08-05 00:44:28 -0400512 union acpi_operand_object **operand = &walk_state->operands[0];
513 union acpi_operand_object *return_desc = NULL;
514 acpi_status status = AE_OK;
515 u8 logical_result = FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
Len Brown4be44fc2005-08-05 00:44:28 -0400517 ACPI_FUNCTION_TRACE_STR("ex_opcode_2A_0T_1R",
518 acpi_ps_get_opcode_name(walk_state->opcode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
520 /* Create the internal return object */
521
Len Brown4be44fc2005-08-05 00:44:28 -0400522 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (!return_desc) {
524 status = AE_NO_MEMORY;
525 goto cleanup;
526 }
527
Robert Moore44f6c012005-04-18 22:49:35 -0400528 /* Execute the Opcode */
529
530 if (walk_state->op_info->flags & AML_LOGICAL_NUMERIC) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400531
Robert Moore44f6c012005-04-18 22:49:35 -0400532 /* logical_op (Operand0, Operand1) */
533
Len Brown4be44fc2005-08-05 00:44:28 -0400534 status = acpi_ex_do_logical_numeric_op(walk_state->opcode,
535 operand[0]->integer.
536 value,
537 operand[1]->integer.
538 value, &logical_result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 goto store_logical_result;
Len Brown4be44fc2005-08-05 00:44:28 -0400540 } else if (walk_state->op_info->flags & AML_LOGICAL) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400541
Robert Moore44f6c012005-04-18 22:49:35 -0400542 /* logical_op (Operand0, Operand1) */
543
Len Brown4be44fc2005-08-05 00:44:28 -0400544 status = acpi_ex_do_logical_op(walk_state->opcode, operand[0],
545 operand[1], &logical_result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 goto store_logical_result;
547 }
548
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 switch (walk_state->opcode) {
Len Brown4be44fc2005-08-05 00:44:28 -0400550 case AML_ACQUIRE_OP: /* Acquire (mutex_object, Timeout) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
Len Brown4be44fc2005-08-05 00:44:28 -0400552 status =
553 acpi_ex_acquire_mutex(operand[1], operand[0], walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 if (status == AE_TIME) {
Len Brown4be44fc2005-08-05 00:44:28 -0400555 logical_result = TRUE; /* TRUE = Acquire timed out */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 status = AE_OK;
557 }
558 break;
559
Len Brown4be44fc2005-08-05 00:44:28 -0400560 case AML_WAIT_OP: /* Wait (event_object, Timeout) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Len Brown4be44fc2005-08-05 00:44:28 -0400562 status = acpi_ex_system_wait_event(operand[1], operand[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 if (status == AE_TIME) {
Len Brown4be44fc2005-08-05 00:44:28 -0400564 logical_result = TRUE; /* TRUE, Wait timed out */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 status = AE_OK;
566 }
567 break;
568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 default:
570
Bob Mooreb8e4d892006-01-27 16:43:00 -0500571 ACPI_ERROR((AE_INFO, "Unknown AML opcode %X",
572 walk_state->opcode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 status = AE_AML_BAD_OPCODE;
574 goto cleanup;
575 }
576
Len Brown4be44fc2005-08-05 00:44:28 -0400577 store_logical_result:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 /*
579 * Set return value to according to logical_result. logical TRUE (all ones)
580 * Default is FALSE (zero)
581 */
582 if (logical_result) {
583 return_desc->integer.value = ACPI_INTEGER_MAX;
584 }
585
586 walk_state->result_obj = return_desc;
587
Len Brown4be44fc2005-08-05 00:44:28 -0400588 cleanup:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
590 /* Delete return object on error */
591
Len Brown4be44fc2005-08-05 00:44:28 -0400592 if (ACPI_FAILURE(status)) {
593 acpi_ut_remove_reference(return_desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 }
595
Len Brown4be44fc2005-08-05 00:44:28 -0400596 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597}