1/****************************************************************************** 2 * 3 * Module Name: exoparg2 - AML execution - opcodes with 2 arguments 4 * 5 *****************************************************************************/ 6 7/* 8 * Copyright (C) 2000 - 2007, R. Byron Moore 9 * 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 44#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 50#define _COMPONENT ACPI_EXECUTER 51ACPI_MODULE_NAME("exoparg2") 52 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!*/ 74/******************************************************************************* 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 ******************************************************************************/ 88acpi_status acpi_ex_opcode_2A_0T_0R(struct acpi_walk_state *walk_state) 89{ 90 union acpi_operand_object **operand = &walk_state->operands[0]; 91 struct acpi_namespace_node *node; 92 u32 value; 93 acpi_status status = AE_OK; 94 95 ACPI_FUNCTION_TRACE_STR(ex_opcode_2A_0T_0R, 96 acpi_ps_get_opcode_name(walk_state->opcode)); 97 98 /* Examine the opcode */ 99 100 switch (walk_state->opcode) { 101 case AML_NOTIFY_OP: /* Notify (notify_object, notify_value) */ 102 103 /* The first operand is a namespace node */ 104 105 node = (struct acpi_namespace_node *)operand[0]; 106 107 /* Second value is the notify value */ 108 109 value = (u32) operand[1]->integer.value; 110 111 /* Are notifies allowed on this object? */ 112 113 if (!acpi_ev_is_notify_object(node)) { 114 ACPI_ERROR((AE_INFO, 115 "Unexpected notify object type [%s]", 116 acpi_ut_get_type_name(node->type))); 117 118 status = AE_AML_OPERAND_TYPE; 119 break; 120 } 121#ifdef ACPI_GPE_NOTIFY_CHECK 122 /* 123 * GPE method wake/notify check. Here, we want to ensure that we 124 * don't receive any "DeviceWake" 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 */ 136 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)) { 141 142 /* AE_WAKE_ONLY_GPE only error, means ignore this notify */ 143 144 return_ACPI_STATUS(AE_OK) 145 } 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 */ 156 status = acpi_ev_queue_notify_request(node, value); 157 break; 158 159 default: 160 161 ACPI_ERROR((AE_INFO, "Unknown AML opcode %X", 162 walk_state->opcode)); 163 status = AE_AML_BAD_OPCODE; 164 } 165 166 return_ACPI_STATUS(status); 167} 168 169/******************************************************************************* 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 182acpi_status acpi_ex_opcode_2A_2T_1R(struct acpi_walk_state *walk_state) 183{ 184 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; 188 189 ACPI_FUNCTION_TRACE_STR(ex_opcode_2A_2T_1R, 190 acpi_ps_get_opcode_name(walk_state->opcode)); 191 192 /* Execute the opcode */ 193 194 switch (walk_state->opcode) { 195 case AML_DIVIDE_OP: 196 197 /* Divide (Dividend, Divisor, remainder_result quotient_result) */ 198 199 return_desc1 = 200 acpi_ut_create_internal_object(ACPI_TYPE_INTEGER); 201 if (!return_desc1) { 202 status = AE_NO_MEMORY; 203 goto cleanup; 204 } 205 206 return_desc2 = 207 acpi_ut_create_internal_object(ACPI_TYPE_INTEGER); 208 if (!return_desc2) { 209 status = AE_NO_MEMORY; 210 goto cleanup; 211 } 212 213 /* Quotient to return_desc1, remainder to return_desc2 */ 214 215 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)) { 220 goto cleanup; 221 } 222 break; 223 224 default: 225 226 ACPI_ERROR((AE_INFO, "Unknown AML opcode %X", 227 walk_state->opcode)); 228 status = AE_AML_BAD_OPCODE; 229 goto cleanup; 230 } 231 232 /* Store the results to the target reference operands */ 233 234 status = acpi_ex_store(return_desc2, operand[2], walk_state); 235 if (ACPI_FAILURE(status)) { 236 goto cleanup; 237 } 238 239 status = acpi_ex_store(return_desc1, operand[3], walk_state); 240 if (ACPI_FAILURE(status)) { 241 goto cleanup; 242 } 243 244 /* Return the remainder */ 245 246 walk_state->result_obj = return_desc1; 247 248 cleanup: 249 /* 250 * Since the remainder is not returned indirectly, remove a reference to 251 * it. Only the quotient is returned indirectly. 252 */ 253 acpi_ut_remove_reference(return_desc2); 254 255 if (ACPI_FAILURE(status)) { 256 257 /* Delete the return object */ 258 259 acpi_ut_remove_reference(return_desc1); 260 } 261 262 return_ACPI_STATUS(status); 263} 264 265/******************************************************************************* 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 278acpi_status acpi_ex_opcode_2A_1T_1R(struct acpi_walk_state *walk_state) 279{ 280 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; 285 286 ACPI_FUNCTION_TRACE_STR(ex_opcode_2A_1T_1R, 287 acpi_ps_get_opcode_name(walk_state->opcode)); 288 289 /* Execute the opcode */ 290 291 if (walk_state->op_info->flags & AML_MATH) { 292 293 /* All simple math opcodes (add, etc.) */ 294 295 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER); 296 if (!return_desc) { 297 status = AE_NO_MEMORY; 298 goto cleanup; 299 } 300 301 return_desc->integer.value = 302 acpi_ex_do_math_op(walk_state->opcode, 303 operand[0]->integer.value, 304 operand[1]->integer.value); 305 goto store_result_to_target; 306 } 307 308 switch (walk_state->opcode) { 309 case AML_MOD_OP: /* Mod (Dividend, Divisor, remainder_result (ACPI 2.0) */ 310 311 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER); 312 if (!return_desc) { 313 status = AE_NO_MEMORY; 314 goto cleanup; 315 } 316 317 /* return_desc will contain the remainder */ 318 319 status = acpi_ut_divide(operand[0]->integer.value, 320 operand[1]->integer.value, 321 NULL, &return_desc->integer.value); 322 break; 323 324 case AML_CONCAT_OP: /* Concatenate (Data1, Data2, Result) */ 325 326 status = acpi_ex_do_concatenate(operand[0], operand[1], 327 &return_desc, walk_state); 328 break; 329 330 case AML_TO_STRING_OP: /* to_string (Buffer, Length, Result) (ACPI 2.0) */ 331 332 /* 333 * Input object is guaranteed to be a buffer at this point (it may have 334 * been converted.) Copy the raw buffer data to a new object of 335 * type String. 336 */ 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) && 349 (length < operand[1]->integer.value) && 350 (operand[0]->buffer.pointer[length])) { 351 length++; 352 } 353 354 /* Allocate a new string object */ 355 356 return_desc = acpi_ut_create_string_object(length); 357 if (!return_desc) { 358 status = AE_NO_MEMORY; 359 goto cleanup; 360 } 361 362 /* 363 * Copy the raw buffer data with no transform. 364 * (NULL terminated already) 365 */ 366 ACPI_MEMCPY(return_desc->string.pointer, 367 operand[0]->buffer.pointer, length); 368 break; 369 370 case AML_CONCAT_RES_OP: 371 372 /* concatenate_res_template (Buffer, Buffer, Result) (ACPI 2.0) */ 373 374 status = acpi_ex_concat_template(operand[0], operand[1], 375 &return_desc, walk_state); 376 break; 377 378 case AML_INDEX_OP: /* Index (Source Index Result) */ 379 380 /* Create the internal return object */ 381 382 return_desc = 383 acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_REFERENCE); 384 if (!return_desc) { 385 status = AE_NO_MEMORY; 386 goto cleanup; 387 } 388 389 /* Initialize the Index reference object */ 390 391 index = operand[1]->integer.value; 392 return_desc->reference.offset = (u32) index; 393 return_desc->reference.opcode = AML_INDEX_OP; 394 395 /* 396 * At this point, the Source operand is a String, Buffer, or Package. 397 * Verify that the index is within range. 398 */ 399 switch (ACPI_GET_OBJECT_TYPE(operand[0])) { 400 case ACPI_TYPE_STRING: 401 402 if (index >= operand[0]->string.length) { 403 status = AE_AML_STRING_LIMIT; 404 } 405 406 return_desc->reference.target_type = 407 ACPI_TYPE_BUFFER_FIELD; 408 break; 409 410 case ACPI_TYPE_BUFFER: 411 412 if (index >= operand[0]->buffer.length) { 413 status = AE_AML_BUFFER_LIMIT; 414 } 415 416 return_desc->reference.target_type = 417 ACPI_TYPE_BUFFER_FIELD; 418 break; 419 420 case ACPI_TYPE_PACKAGE: 421 422 if (index >= operand[0]->package.count) { 423 status = AE_AML_PACKAGE_LIMIT; 424 } 425 426 return_desc->reference.target_type = ACPI_TYPE_PACKAGE; 427 return_desc->reference.where = 428 &operand[0]->package.elements[index]; 429 break; 430 431 default: 432 433 status = AE_AML_INTERNAL; 434 goto cleanup; 435 } 436 437 /* Failure means that the Index was beyond the end of the object */ 438 439 if (ACPI_FAILURE(status)) { 440 ACPI_EXCEPTION((AE_INFO, status, 441 "Index (%X%8.8X) is beyond end of object", 442 ACPI_FORMAT_UINT64(index))); 443 goto cleanup; 444 } 445 446 /* 447 * Save the target object and add a reference to it for the life 448 * of the index 449 */ 450 return_desc->reference.object = operand[0]; 451 acpi_ut_add_reference(operand[0]); 452 453 /* Store the reference to the Target */ 454 455 status = acpi_ex_store(return_desc, operand[2], walk_state); 456 457 /* Return the reference */ 458 459 walk_state->result_obj = return_desc; 460 goto cleanup; 461 462 default: 463 464 ACPI_ERROR((AE_INFO, "Unknown AML opcode %X", 465 walk_state->opcode)); 466 status = AE_AML_BAD_OPCODE; 467 break; 468 } 469 470 store_result_to_target: 471 472 if (ACPI_SUCCESS(status)) { 473 /* 474 * Store the result of the operation (which is now in return_desc) into 475 * the Target descriptor. 476 */ 477 status = acpi_ex_store(return_desc, operand[2], walk_state); 478 if (ACPI_FAILURE(status)) { 479 goto cleanup; 480 } 481 482 if (!walk_state->result_obj) { 483 walk_state->result_obj = return_desc; 484 } 485 } 486 487 cleanup: 488 489 /* Delete return object on error */ 490 491 if (ACPI_FAILURE(status)) { 492 acpi_ut_remove_reference(return_desc); 493 } 494 495 return_ACPI_STATUS(status); 496} 497 498/******************************************************************************* 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 510acpi_status acpi_ex_opcode_2A_0T_1R(struct acpi_walk_state *walk_state) 511{ 512 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; 516 517 ACPI_FUNCTION_TRACE_STR(ex_opcode_2A_0T_1R, 518 acpi_ps_get_opcode_name(walk_state->opcode)); 519 520 /* Create the internal return object */ 521 522 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER); 523 if (!return_desc) { 524 status = AE_NO_MEMORY; 525 goto cleanup; 526 } 527 528 /* Execute the Opcode */ 529 530 if (walk_state->op_info->flags & AML_LOGICAL_NUMERIC) { 531 532 /* logical_op (Operand0, Operand1) */ 533 534 status = acpi_ex_do_logical_numeric_op(walk_state->opcode, 535 operand[0]->integer. 536 value, 537 operand[1]->integer. 538 value, &logical_result); 539 goto store_logical_result; 540 } else if (walk_state->op_info->flags & AML_LOGICAL) { 541 542 /* logical_op (Operand0, Operand1) */ 543 544 status = acpi_ex_do_logical_op(walk_state->opcode, operand[0], 545 operand[1], &logical_result); 546 goto store_logical_result; 547 } 548 549 switch (walk_state->opcode) { 550 case AML_ACQUIRE_OP: /* Acquire (mutex_object, Timeout) */ 551 552 status = 553 acpi_ex_acquire_mutex(operand[1], operand[0], walk_state); 554 if (status == AE_TIME) { 555 logical_result = TRUE; /* TRUE = Acquire timed out */ 556 status = AE_OK; 557 } 558 break; 559 560 case AML_WAIT_OP: /* Wait (event_object, Timeout) */ 561 562 status = acpi_ex_system_wait_event(operand[1], operand[0]); 563 if (status == AE_TIME) { 564 logical_result = TRUE; /* TRUE, Wait timed out */ 565 status = AE_OK; 566 } 567 break; 568 569 default: 570 571 ACPI_ERROR((AE_INFO, "Unknown AML opcode %X", 572 walk_state->opcode)); 573 status = AE_AML_BAD_OPCODE; 574 goto cleanup; 575 } 576 577 store_logical_result: 578 /* 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 588 cleanup: 589 590 /* Delete return object on error */ 591 592 if (ACPI_FAILURE(status)) { 593 acpi_ut_remove_reference(return_desc); 594 } 595 596 return_ACPI_STATUS(status); 597} 598