1 /****************************************************************************** 2 * 3 * Module Name: exmisc - ACPI AML (p-code) execution - specific opcodes 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2012, Intel Corp. 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 "accommon.h" 46 #include "acinterp.h" 47 #include "amlcode.h" 48 #include "amlresrc.h" 49 50 #define _COMPONENT ACPI_EXECUTER 51 ACPI_MODULE_NAME("exmisc") 52 53 /******************************************************************************* 54 * 55 * FUNCTION: acpi_ex_get_object_reference 56 * 57 * PARAMETERS: obj_desc - Create a reference to this object 58 * return_desc - Where to store the reference 59 * walk_state - Current state 60 * 61 * RETURN: Status 62 * 63 * DESCRIPTION: Obtain and return a "reference" to the target object 64 * Common code for the ref_of_op and the cond_ref_of_op. 65 * 66 ******************************************************************************/ 67 acpi_status 68 acpi_ex_get_object_reference(union acpi_operand_object *obj_desc, 69 union acpi_operand_object **return_desc, 70 struct acpi_walk_state *walk_state) 71 { 72 union acpi_operand_object *reference_obj; 73 union acpi_operand_object *referenced_obj; 74 75 ACPI_FUNCTION_TRACE_PTR(ex_get_object_reference, obj_desc); 76 77 *return_desc = NULL; 78 79 switch (ACPI_GET_DESCRIPTOR_TYPE(obj_desc)) { 80 case ACPI_DESC_TYPE_OPERAND: 81 82 if (obj_desc->common.type != ACPI_TYPE_LOCAL_REFERENCE) { 83 return_ACPI_STATUS(AE_AML_OPERAND_TYPE); 84 } 85 86 /* 87 * Must be a reference to a Local or Arg 88 */ 89 switch (obj_desc->reference.class) { 90 case ACPI_REFCLASS_LOCAL: 91 case ACPI_REFCLASS_ARG: 92 case ACPI_REFCLASS_DEBUG: 93 94 /* The referenced object is the pseudo-node for the local/arg */ 95 96 referenced_obj = obj_desc->reference.object; 97 break; 98 99 default: 100 101 ACPI_ERROR((AE_INFO, "Unknown Reference Class 0x%2.2X", 102 obj_desc->reference.class)); 103 return_ACPI_STATUS(AE_AML_INTERNAL); 104 } 105 break; 106 107 case ACPI_DESC_TYPE_NAMED: 108 109 /* 110 * A named reference that has already been resolved to a Node 111 */ 112 referenced_obj = obj_desc; 113 break; 114 115 default: 116 117 ACPI_ERROR((AE_INFO, "Invalid descriptor type 0x%X", 118 ACPI_GET_DESCRIPTOR_TYPE(obj_desc))); 119 return_ACPI_STATUS(AE_TYPE); 120 } 121 122 /* Create a new reference object */ 123 124 reference_obj = 125 acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_REFERENCE); 126 if (!reference_obj) { 127 return_ACPI_STATUS(AE_NO_MEMORY); 128 } 129 130 reference_obj->reference.class = ACPI_REFCLASS_REFOF; 131 reference_obj->reference.object = referenced_obj; 132 *return_desc = reference_obj; 133 134 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 135 "Object %p Type [%s], returning Reference %p\n", 136 obj_desc, acpi_ut_get_object_type_name(obj_desc), 137 *return_desc)); 138 139 return_ACPI_STATUS(AE_OK); 140 } 141 142 /******************************************************************************* 143 * 144 * FUNCTION: acpi_ex_concat_template 145 * 146 * PARAMETERS: operand0 - First source object 147 * operand1 - Second source object 148 * actual_return_desc - Where to place the return object 149 * walk_state - Current walk state 150 * 151 * RETURN: Status 152 * 153 * DESCRIPTION: Concatenate two resource templates 154 * 155 ******************************************************************************/ 156 157 acpi_status 158 acpi_ex_concat_template(union acpi_operand_object *operand0, 159 union acpi_operand_object *operand1, 160 union acpi_operand_object **actual_return_desc, 161 struct acpi_walk_state *walk_state) 162 { 163 acpi_status status; 164 union acpi_operand_object *return_desc; 165 u8 *new_buf; 166 u8 *end_tag; 167 acpi_size length0; 168 acpi_size length1; 169 acpi_size new_length; 170 171 ACPI_FUNCTION_TRACE(ex_concat_template); 172 173 /* 174 * Find the end_tag descriptor in each resource template. 175 * Note1: returned pointers point TO the end_tag, not past it. 176 * Note2: zero-length buffers are allowed; treated like one end_tag 177 */ 178 179 /* Get the length of the first resource template */ 180 181 status = acpi_ut_get_resource_end_tag(operand0, &end_tag); 182 if (ACPI_FAILURE(status)) { 183 return_ACPI_STATUS(status); 184 } 185 186 length0 = ACPI_PTR_DIFF(end_tag, operand0->buffer.pointer); 187 188 /* Get the length of the second resource template */ 189 190 status = acpi_ut_get_resource_end_tag(operand1, &end_tag); 191 if (ACPI_FAILURE(status)) { 192 return_ACPI_STATUS(status); 193 } 194 195 length1 = ACPI_PTR_DIFF(end_tag, operand1->buffer.pointer); 196 197 /* Combine both lengths, minimum size will be 2 for end_tag */ 198 199 new_length = length0 + length1 + sizeof(struct aml_resource_end_tag); 200 201 /* Create a new buffer object for the result (with one end_tag) */ 202 203 return_desc = acpi_ut_create_buffer_object(new_length); 204 if (!return_desc) { 205 return_ACPI_STATUS(AE_NO_MEMORY); 206 } 207 208 /* 209 * Copy the templates to the new buffer, 0 first, then 1 follows. One 210 * end_tag descriptor is copied from Operand1. 211 */ 212 new_buf = return_desc->buffer.pointer; 213 ACPI_MEMCPY(new_buf, operand0->buffer.pointer, length0); 214 ACPI_MEMCPY(new_buf + length0, operand1->buffer.pointer, length1); 215 216 /* Insert end_tag and set the checksum to zero, means "ignore checksum" */ 217 218 new_buf[new_length - 1] = 0; 219 new_buf[new_length - 2] = ACPI_RESOURCE_NAME_END_TAG | 1; 220 221 /* Return the completed resource template */ 222 223 *actual_return_desc = return_desc; 224 return_ACPI_STATUS(AE_OK); 225 } 226 227 /******************************************************************************* 228 * 229 * FUNCTION: acpi_ex_do_concatenate 230 * 231 * PARAMETERS: operand0 - First source object 232 * operand1 - Second source object 233 * actual_return_desc - Where to place the return object 234 * walk_state - Current walk state 235 * 236 * RETURN: Status 237 * 238 * DESCRIPTION: Concatenate two objects OF THE SAME TYPE. 239 * 240 ******************************************************************************/ 241 242 acpi_status 243 acpi_ex_do_concatenate(union acpi_operand_object *operand0, 244 union acpi_operand_object *operand1, 245 union acpi_operand_object **actual_return_desc, 246 struct acpi_walk_state *walk_state) 247 { 248 union acpi_operand_object *local_operand1 = operand1; 249 union acpi_operand_object *return_desc; 250 char *new_buf; 251 acpi_status status; 252 253 ACPI_FUNCTION_TRACE(ex_do_concatenate); 254 255 /* 256 * Convert the second operand if necessary. The first operand 257 * determines the type of the second operand, (See the Data Types 258 * section of the ACPI specification.) Both object types are 259 * guaranteed to be either Integer/String/Buffer by the operand 260 * resolution mechanism. 261 */ 262 switch (operand0->common.type) { 263 case ACPI_TYPE_INTEGER: 264 status = 265 acpi_ex_convert_to_integer(operand1, &local_operand1, 16); 266 break; 267 268 case ACPI_TYPE_STRING: 269 status = acpi_ex_convert_to_string(operand1, &local_operand1, 270 ACPI_IMPLICIT_CONVERT_HEX); 271 break; 272 273 case ACPI_TYPE_BUFFER: 274 status = acpi_ex_convert_to_buffer(operand1, &local_operand1); 275 break; 276 277 default: 278 ACPI_ERROR((AE_INFO, "Invalid object type: 0x%X", 279 operand0->common.type)); 280 status = AE_AML_INTERNAL; 281 } 282 283 if (ACPI_FAILURE(status)) { 284 goto cleanup; 285 } 286 287 /* 288 * Both operands are now known to be the same object type 289 * (Both are Integer, String, or Buffer), and we can now perform the 290 * concatenation. 291 */ 292 293 /* 294 * There are three cases to handle: 295 * 296 * 1) Two Integers concatenated to produce a new Buffer 297 * 2) Two Strings concatenated to produce a new String 298 * 3) Two Buffers concatenated to produce a new Buffer 299 */ 300 switch (operand0->common.type) { 301 case ACPI_TYPE_INTEGER: 302 303 /* Result of two Integers is a Buffer */ 304 /* Need enough buffer space for two integers */ 305 306 return_desc = acpi_ut_create_buffer_object((acpi_size) 307 ACPI_MUL_2 308 (acpi_gbl_integer_byte_width)); 309 if (!return_desc) { 310 status = AE_NO_MEMORY; 311 goto cleanup; 312 } 313 314 new_buf = (char *)return_desc->buffer.pointer; 315 316 /* Copy the first integer, LSB first */ 317 318 ACPI_MEMCPY(new_buf, &operand0->integer.value, 319 acpi_gbl_integer_byte_width); 320 321 /* Copy the second integer (LSB first) after the first */ 322 323 ACPI_MEMCPY(new_buf + acpi_gbl_integer_byte_width, 324 &local_operand1->integer.value, 325 acpi_gbl_integer_byte_width); 326 break; 327 328 case ACPI_TYPE_STRING: 329 330 /* Result of two Strings is a String */ 331 332 return_desc = acpi_ut_create_string_object(((acpi_size) 333 operand0->string. 334 length + 335 local_operand1-> 336 string.length)); 337 if (!return_desc) { 338 status = AE_NO_MEMORY; 339 goto cleanup; 340 } 341 342 new_buf = return_desc->string.pointer; 343 344 /* Concatenate the strings */ 345 346 ACPI_STRCPY(new_buf, operand0->string.pointer); 347 ACPI_STRCPY(new_buf + operand0->string.length, 348 local_operand1->string.pointer); 349 break; 350 351 case ACPI_TYPE_BUFFER: 352 353 /* Result of two Buffers is a Buffer */ 354 355 return_desc = acpi_ut_create_buffer_object(((acpi_size) 356 operand0->buffer. 357 length + 358 local_operand1-> 359 buffer.length)); 360 if (!return_desc) { 361 status = AE_NO_MEMORY; 362 goto cleanup; 363 } 364 365 new_buf = (char *)return_desc->buffer.pointer; 366 367 /* Concatenate the buffers */ 368 369 ACPI_MEMCPY(new_buf, operand0->buffer.pointer, 370 operand0->buffer.length); 371 ACPI_MEMCPY(new_buf + operand0->buffer.length, 372 local_operand1->buffer.pointer, 373 local_operand1->buffer.length); 374 break; 375 376 default: 377 378 /* Invalid object type, should not happen here */ 379 380 ACPI_ERROR((AE_INFO, "Invalid object type: 0x%X", 381 operand0->common.type)); 382 status = AE_AML_INTERNAL; 383 goto cleanup; 384 } 385 386 *actual_return_desc = return_desc; 387 388 cleanup: 389 if (local_operand1 != operand1) { 390 acpi_ut_remove_reference(local_operand1); 391 } 392 return_ACPI_STATUS(status); 393 } 394 395 /******************************************************************************* 396 * 397 * FUNCTION: acpi_ex_do_math_op 398 * 399 * PARAMETERS: opcode - AML opcode 400 * integer0 - Integer operand #0 401 * integer1 - Integer operand #1 402 * 403 * RETURN: Integer result of the operation 404 * 405 * DESCRIPTION: Execute a math AML opcode. The purpose of having all of the 406 * math functions here is to prevent a lot of pointer dereferencing 407 * to obtain the operands. 408 * 409 ******************************************************************************/ 410 411 u64 acpi_ex_do_math_op(u16 opcode, u64 integer0, u64 integer1) 412 { 413 414 ACPI_FUNCTION_ENTRY(); 415 416 switch (opcode) { 417 case AML_ADD_OP: /* Add (Integer0, Integer1, Result) */ 418 419 return (integer0 + integer1); 420 421 case AML_BIT_AND_OP: /* And (Integer0, Integer1, Result) */ 422 423 return (integer0 & integer1); 424 425 case AML_BIT_NAND_OP: /* NAnd (Integer0, Integer1, Result) */ 426 427 return (~(integer0 & integer1)); 428 429 case AML_BIT_OR_OP: /* Or (Integer0, Integer1, Result) */ 430 431 return (integer0 | integer1); 432 433 case AML_BIT_NOR_OP: /* NOr (Integer0, Integer1, Result) */ 434 435 return (~(integer0 | integer1)); 436 437 case AML_BIT_XOR_OP: /* XOr (Integer0, Integer1, Result) */ 438 439 return (integer0 ^ integer1); 440 441 case AML_MULTIPLY_OP: /* Multiply (Integer0, Integer1, Result) */ 442 443 return (integer0 * integer1); 444 445 case AML_SHIFT_LEFT_OP: /* shift_left (Operand, shift_count, Result) */ 446 447 /* 448 * We need to check if the shiftcount is larger than the integer bit 449 * width since the behavior of this is not well-defined in the C language. 450 */ 451 if (integer1 >= acpi_gbl_integer_bit_width) { 452 return (0); 453 } 454 return (integer0 << integer1); 455 456 case AML_SHIFT_RIGHT_OP: /* shift_right (Operand, shift_count, Result) */ 457 458 /* 459 * We need to check if the shiftcount is larger than the integer bit 460 * width since the behavior of this is not well-defined in the C language. 461 */ 462 if (integer1 >= acpi_gbl_integer_bit_width) { 463 return (0); 464 } 465 return (integer0 >> integer1); 466 467 case AML_SUBTRACT_OP: /* Subtract (Integer0, Integer1, Result) */ 468 469 return (integer0 - integer1); 470 471 default: 472 473 return (0); 474 } 475 } 476 477 /******************************************************************************* 478 * 479 * FUNCTION: acpi_ex_do_logical_numeric_op 480 * 481 * PARAMETERS: opcode - AML opcode 482 * integer0 - Integer operand #0 483 * integer1 - Integer operand #1 484 * logical_result - TRUE/FALSE result of the operation 485 * 486 * RETURN: Status 487 * 488 * DESCRIPTION: Execute a logical "Numeric" AML opcode. For these Numeric 489 * operators (LAnd and LOr), both operands must be integers. 490 * 491 * Note: cleanest machine code seems to be produced by the code 492 * below, rather than using statements of the form: 493 * Result = (Integer0 && Integer1); 494 * 495 ******************************************************************************/ 496 497 acpi_status 498 acpi_ex_do_logical_numeric_op(u16 opcode, 499 u64 integer0, u64 integer1, u8 *logical_result) 500 { 501 acpi_status status = AE_OK; 502 u8 local_result = FALSE; 503 504 ACPI_FUNCTION_TRACE(ex_do_logical_numeric_op); 505 506 switch (opcode) { 507 case AML_LAND_OP: /* LAnd (Integer0, Integer1) */ 508 509 if (integer0 && integer1) { 510 local_result = TRUE; 511 } 512 break; 513 514 case AML_LOR_OP: /* LOr (Integer0, Integer1) */ 515 516 if (integer0 || integer1) { 517 local_result = TRUE; 518 } 519 break; 520 521 default: 522 status = AE_AML_INTERNAL; 523 break; 524 } 525 526 /* Return the logical result and status */ 527 528 *logical_result = local_result; 529 return_ACPI_STATUS(status); 530 } 531 532 /******************************************************************************* 533 * 534 * FUNCTION: acpi_ex_do_logical_op 535 * 536 * PARAMETERS: opcode - AML opcode 537 * operand0 - operand #0 538 * operand1 - operand #1 539 * logical_result - TRUE/FALSE result of the operation 540 * 541 * RETURN: Status 542 * 543 * DESCRIPTION: Execute a logical AML opcode. The purpose of having all of the 544 * functions here is to prevent a lot of pointer dereferencing 545 * to obtain the operands and to simplify the generation of the 546 * logical value. For the Numeric operators (LAnd and LOr), both 547 * operands must be integers. For the other logical operators, 548 * operands can be any combination of Integer/String/Buffer. The 549 * first operand determines the type to which the second operand 550 * will be converted. 551 * 552 * Note: cleanest machine code seems to be produced by the code 553 * below, rather than using statements of the form: 554 * Result = (Operand0 == Operand1); 555 * 556 ******************************************************************************/ 557 558 acpi_status 559 acpi_ex_do_logical_op(u16 opcode, 560 union acpi_operand_object *operand0, 561 union acpi_operand_object *operand1, u8 * logical_result) 562 { 563 union acpi_operand_object *local_operand1 = operand1; 564 u64 integer0; 565 u64 integer1; 566 u32 length0; 567 u32 length1; 568 acpi_status status = AE_OK; 569 u8 local_result = FALSE; 570 int compare; 571 572 ACPI_FUNCTION_TRACE(ex_do_logical_op); 573 574 /* 575 * Convert the second operand if necessary. The first operand 576 * determines the type of the second operand, (See the Data Types 577 * section of the ACPI 3.0+ specification.) Both object types are 578 * guaranteed to be either Integer/String/Buffer by the operand 579 * resolution mechanism. 580 */ 581 switch (operand0->common.type) { 582 case ACPI_TYPE_INTEGER: 583 status = 584 acpi_ex_convert_to_integer(operand1, &local_operand1, 16); 585 break; 586 587 case ACPI_TYPE_STRING: 588 status = acpi_ex_convert_to_string(operand1, &local_operand1, 589 ACPI_IMPLICIT_CONVERT_HEX); 590 break; 591 592 case ACPI_TYPE_BUFFER: 593 status = acpi_ex_convert_to_buffer(operand1, &local_operand1); 594 break; 595 596 default: 597 status = AE_AML_INTERNAL; 598 break; 599 } 600 601 if (ACPI_FAILURE(status)) { 602 goto cleanup; 603 } 604 605 /* 606 * Two cases: 1) Both Integers, 2) Both Strings or Buffers 607 */ 608 if (operand0->common.type == ACPI_TYPE_INTEGER) { 609 /* 610 * 1) Both operands are of type integer 611 * Note: local_operand1 may have changed above 612 */ 613 integer0 = operand0->integer.value; 614 integer1 = local_operand1->integer.value; 615 616 switch (opcode) { 617 case AML_LEQUAL_OP: /* LEqual (Operand0, Operand1) */ 618 619 if (integer0 == integer1) { 620 local_result = TRUE; 621 } 622 break; 623 624 case AML_LGREATER_OP: /* LGreater (Operand0, Operand1) */ 625 626 if (integer0 > integer1) { 627 local_result = TRUE; 628 } 629 break; 630 631 case AML_LLESS_OP: /* LLess (Operand0, Operand1) */ 632 633 if (integer0 < integer1) { 634 local_result = TRUE; 635 } 636 break; 637 638 default: 639 status = AE_AML_INTERNAL; 640 break; 641 } 642 } else { 643 /* 644 * 2) Both operands are Strings or both are Buffers 645 * Note: Code below takes advantage of common Buffer/String 646 * object fields. local_operand1 may have changed above. Use 647 * memcmp to handle nulls in buffers. 648 */ 649 length0 = operand0->buffer.length; 650 length1 = local_operand1->buffer.length; 651 652 /* Lexicographic compare: compare the data bytes */ 653 654 compare = ACPI_MEMCMP(operand0->buffer.pointer, 655 local_operand1->buffer.pointer, 656 (length0 > length1) ? length1 : length0); 657 658 switch (opcode) { 659 case AML_LEQUAL_OP: /* LEqual (Operand0, Operand1) */ 660 661 /* Length and all bytes must be equal */ 662 663 if ((length0 == length1) && (compare == 0)) { 664 665 /* Length and all bytes match ==> TRUE */ 666 667 local_result = TRUE; 668 } 669 break; 670 671 case AML_LGREATER_OP: /* LGreater (Operand0, Operand1) */ 672 673 if (compare > 0) { 674 local_result = TRUE; 675 goto cleanup; /* TRUE */ 676 } 677 if (compare < 0) { 678 goto cleanup; /* FALSE */ 679 } 680 681 /* Bytes match (to shortest length), compare lengths */ 682 683 if (length0 > length1) { 684 local_result = TRUE; 685 } 686 break; 687 688 case AML_LLESS_OP: /* LLess (Operand0, Operand1) */ 689 690 if (compare > 0) { 691 goto cleanup; /* FALSE */ 692 } 693 if (compare < 0) { 694 local_result = TRUE; 695 goto cleanup; /* TRUE */ 696 } 697 698 /* Bytes match (to shortest length), compare lengths */ 699 700 if (length0 < length1) { 701 local_result = TRUE; 702 } 703 break; 704 705 default: 706 status = AE_AML_INTERNAL; 707 break; 708 } 709 } 710 711 cleanup: 712 713 /* New object was created if implicit conversion performed - delete */ 714 715 if (local_operand1 != operand1) { 716 acpi_ut_remove_reference(local_operand1); 717 } 718 719 /* Return the logical result and status */ 720 721 *logical_result = local_result; 722 return_ACPI_STATUS(status); 723 } 724