1/****************************************************************************** 2 * 3 * Module Name: exoparg1 - AML execution - opcodes with 1 argument 4 * 5 *****************************************************************************/ 6 7/****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2023, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 ***************************************************************************** 115 * 116 * Alternatively, you may choose to be licensed under the terms of the 117 * following license: 118 * 119 * Redistribution and use in source and binary forms, with or without 120 * modification, are permitted provided that the following conditions 121 * are met: 122 * 1. Redistributions of source code must retain the above copyright 123 * notice, this list of conditions, and the following disclaimer, 124 * without modification. 125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 126 * substantially similar to the "NO WARRANTY" disclaimer below 127 * ("Disclaimer") and any redistribution must be conditioned upon 128 * including a substantially similar Disclaimer requirement for further 129 * binary redistribution. 130 * 3. Neither the names of the above-listed copyright holders nor the names 131 * of any contributors may be used to endorse or promote products derived 132 * from this software without specific prior written permission. 133 * 134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 145 * 146 * Alternatively, you may choose to be licensed under the terms of the 147 * GNU General Public License ("GPL") version 2 as published by the Free 148 * Software Foundation. 149 * 150 *****************************************************************************/ 151 152#include "acpi.h" 153#include "accommon.h" 154#include "acparser.h" 155#include "acdispat.h" 156#include "acinterp.h" 157#include "amlcode.h" 158#include "acnamesp.h" 159 160 161#define _COMPONENT ACPI_EXECUTER 162 ACPI_MODULE_NAME ("exoparg1") 163 164 165/*! 166 * Naming convention for AML interpreter execution routines. 167 * 168 * The routines that begin execution of AML opcodes are named with a common 169 * convention based upon the number of arguments, the number of target operands, 170 * and whether or not a value is returned: 171 * 172 * AcpiExOpcode_xA_yT_zR 173 * 174 * Where: 175 * 176 * xA - ARGUMENTS: The number of arguments (input operands) that are 177 * required for this opcode type (0 through 6 args). 178 * yT - TARGETS: The number of targets (output operands) that are required 179 * for this opcode type (0, 1, or 2 targets). 180 * zR - RETURN VALUE: Indicates whether this opcode type returns a value 181 * as the function return (0 or 1). 182 * 183 * The AcpiExOpcode* functions are called via the Dispatcher component with 184 * fully resolved operands. 185!*/ 186 187/******************************************************************************* 188 * 189 * FUNCTION: AcpiExOpcode_0A_0T_1R 190 * 191 * PARAMETERS: WalkState - Current state (contains AML opcode) 192 * 193 * RETURN: Status 194 * 195 * DESCRIPTION: Execute operator with no operands, one return value 196 * 197 ******************************************************************************/ 198 199ACPI_STATUS 200AcpiExOpcode_0A_0T_1R ( 201 ACPI_WALK_STATE *WalkState) 202{ 203 ACPI_STATUS Status = AE_OK; 204 ACPI_OPERAND_OBJECT *ReturnDesc = NULL; 205 206 207 ACPI_FUNCTION_TRACE_STR (ExOpcode_0A_0T_1R, 208 AcpiPsGetOpcodeName (WalkState->Opcode)); 209 210 211 /* Examine the AML opcode */ 212 213 switch (WalkState->Opcode) 214 { 215 case AML_TIMER_OP: /* Timer () */ 216 217 /* Create a return object of type Integer */ 218 219 ReturnDesc = AcpiUtCreateIntegerObject (AcpiOsGetTimer ()); 220 if (!ReturnDesc) 221 { 222 Status = AE_NO_MEMORY; 223 goto Cleanup; 224 } 225 break; 226 227 default: /* Unknown opcode */ 228 229 ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X", 230 WalkState->Opcode)); 231 Status = AE_AML_BAD_OPCODE; 232 break; 233 } 234 235Cleanup: 236 237 /* Delete return object on error */ 238 239 if ((ACPI_FAILURE (Status)) || WalkState->ResultObj) 240 { 241 AcpiUtRemoveReference (ReturnDesc); 242 WalkState->ResultObj = NULL; 243 } 244 else 245 { 246 /* Save the return value */ 247 248 WalkState->ResultObj = ReturnDesc; 249 } 250 251 return_ACPI_STATUS (Status); 252} 253 254 255/******************************************************************************* 256 * 257 * FUNCTION: AcpiExOpcode_1A_0T_0R 258 * 259 * PARAMETERS: WalkState - Current state (contains AML opcode) 260 * 261 * RETURN: Status 262 * 263 * DESCRIPTION: Execute Type 1 monadic operator with numeric operand on 264 * object stack 265 * 266 ******************************************************************************/ 267 268ACPI_STATUS 269AcpiExOpcode_1A_0T_0R ( 270 ACPI_WALK_STATE *WalkState) 271{ 272 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0]; 273 ACPI_STATUS Status = AE_OK; 274 275 276 ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_0T_0R, 277 AcpiPsGetOpcodeName (WalkState->Opcode)); 278 279 280 /* Examine the AML opcode */ 281 282 switch (WalkState->Opcode) 283 { 284 case AML_RELEASE_OP: /* Release (MutexObject) */ 285 286 Status = AcpiExReleaseMutex (Operand[0], WalkState); 287 break; 288 289 case AML_RESET_OP: /* Reset (EventObject) */ 290 291 Status = AcpiExSystemResetEvent (Operand[0]); 292 break; 293 294 case AML_SIGNAL_OP: /* Signal (EventObject) */ 295 296 Status = AcpiExSystemSignalEvent (Operand[0]); 297 break; 298 299 case AML_SLEEP_OP: /* Sleep (MsecTime) */ 300 301 Status = AcpiExSystemDoSleep (Operand[0]->Integer.Value); 302 break; 303 304 case AML_STALL_OP: /* Stall (UsecTime) */ 305 306 Status = AcpiExSystemDoStall ((UINT32) Operand[0]->Integer.Value); 307 break; 308 309 case AML_UNLOAD_OP: /* Unload (Handle) */ 310 311 Status = AcpiExUnloadTable (Operand[0]); 312 break; 313 314 default: /* Unknown opcode */ 315 316 ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X", 317 WalkState->Opcode)); 318 Status = AE_AML_BAD_OPCODE; 319 break; 320 } 321 322 return_ACPI_STATUS (Status); 323} 324 325 326#ifdef _OBSOLETE_CODE /* Was originally used for Load() operator */ 327/******************************************************************************* 328 * 329 * FUNCTION: AcpiExOpcode_1A_1T_0R 330 * 331 * PARAMETERS: WalkState - Current state (contains AML opcode) 332 * 333 * RETURN: Status 334 * 335 * DESCRIPTION: Execute opcode with one argument, one target, and no 336 * return value. 337 * 338 ******************************************************************************/ 339 340ACPI_STATUS 341AcpiExOpcode_1A_1T_0R ( 342 ACPI_WALK_STATE *WalkState) 343{ 344 ACPI_STATUS Status = AE_OK; 345 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0]; 346 347 348 ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_1T_0R, 349 AcpiPsGetOpcodeName (WalkState->Opcode)); 350 351 352 /* Examine the AML opcode */ 353 354 switch (WalkState->Opcode) 355 { 356#ifdef _OBSOLETE_CODE 357 case AML_LOAD_OP: 358 359 Status = AcpiExLoadOp (Operand[0], Operand[1], WalkState); 360 break; 361#endif 362 363 default: /* Unknown opcode */ 364 365 ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X", 366 WalkState->Opcode)); 367 Status = AE_AML_BAD_OPCODE; 368 goto Cleanup; 369 } 370 371 372Cleanup: 373 374 return_ACPI_STATUS (Status); 375} 376#endif 377 378/******************************************************************************* 379 * 380 * FUNCTION: AcpiExOpcode_1A_1T_1R 381 * 382 * PARAMETERS: WalkState - Current state (contains AML opcode) 383 * 384 * RETURN: Status 385 * 386 * DESCRIPTION: Execute opcode with one argument, one target, and a 387 * return value. 388 * January 2022: Added Load operator, with new ACPI 6.4 389 * semantics. 390 * 391 ******************************************************************************/ 392 393ACPI_STATUS 394AcpiExOpcode_1A_1T_1R ( 395 ACPI_WALK_STATE *WalkState) 396{ 397 ACPI_STATUS Status = AE_OK; 398 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0]; 399 ACPI_OPERAND_OBJECT *ReturnDesc = NULL; 400 ACPI_OPERAND_OBJECT *ReturnDesc2 = NULL; 401 UINT32 Temp32; 402 UINT32 i; 403 UINT64 PowerOfTen; 404 UINT64 Digit; 405 406 407 ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_1T_1R, 408 AcpiPsGetOpcodeName (WalkState->Opcode)); 409 410 411 /* Examine the AML opcode */ 412 413 switch (WalkState->Opcode) 414 { 415 case AML_BIT_NOT_OP: 416 case AML_FIND_SET_LEFT_BIT_OP: 417 case AML_FIND_SET_RIGHT_BIT_OP: 418 case AML_FROM_BCD_OP: 419 case AML_LOAD_OP: 420 case AML_TO_BCD_OP: 421 case AML_CONDITIONAL_REF_OF_OP: 422 423 /* Create a return object of type Integer for these opcodes */ 424 425 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); 426 if (!ReturnDesc) 427 { 428 Status = AE_NO_MEMORY; 429 goto Cleanup; 430 } 431 432 switch (WalkState->Opcode) 433 { 434 case AML_BIT_NOT_OP: /* Not (Operand, Result) */ 435 436 ReturnDesc->Integer.Value = ~Operand[0]->Integer.Value; 437 break; 438 439 case AML_FIND_SET_LEFT_BIT_OP: /* FindSetLeftBit (Operand, Result) */ 440 441 ReturnDesc->Integer.Value = Operand[0]->Integer.Value; 442 443 /* 444 * Acpi specification describes Integer type as a little 445 * endian unsigned value, so this boundary condition is valid. 446 */ 447 for (Temp32 = 0; ReturnDesc->Integer.Value && 448 Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32) 449 { 450 ReturnDesc->Integer.Value >>= 1; 451 } 452 453 ReturnDesc->Integer.Value = Temp32; 454 break; 455 456 case AML_FIND_SET_RIGHT_BIT_OP: /* FindSetRightBit (Operand, Result) */ 457 458 ReturnDesc->Integer.Value = Operand[0]->Integer.Value; 459 460 /* 461 * The Acpi specification describes Integer type as a little 462 * endian unsigned value, so this boundary condition is valid. 463 */ 464 for (Temp32 = 0; ReturnDesc->Integer.Value && 465 Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32) 466 { 467 ReturnDesc->Integer.Value <<= 1; 468 } 469 470 /* Since the bit position is one-based, subtract from 33 (65) */ 471 472 ReturnDesc->Integer.Value = 473 Temp32 == 0 ? 0 : (ACPI_INTEGER_BIT_SIZE + 1) - Temp32; 474 break; 475 476 case AML_FROM_BCD_OP: /* FromBcd (BCDValue, Result) */ 477 /* 478 * The 64-bit ACPI integer can hold 16 4-bit BCD characters 479 * (if table is 32-bit, integer can hold 8 BCD characters) 480 * Convert each 4-bit BCD value 481 */ 482 PowerOfTen = 1; 483 ReturnDesc->Integer.Value = 0; 484 Digit = Operand[0]->Integer.Value; 485 486 /* Convert each BCD digit (each is one nybble wide) */ 487 488 for (i = 0; (i < AcpiGbl_IntegerNybbleWidth) && (Digit > 0); i++) 489 { 490 /* Get the least significant 4-bit BCD digit */ 491 492 Temp32 = ((UINT32) Digit) & 0xF; 493 494 /* Check the range of the digit */ 495 496 if (Temp32 > 9) 497 { 498 ACPI_ERROR ((AE_INFO, 499 "BCD digit too large (not decimal): 0x%X", 500 Temp32)); 501 502 Status = AE_AML_NUMERIC_OVERFLOW; 503 goto Cleanup; 504 } 505 506 /* Sum the digit into the result with the current power of 10 */ 507 508 ReturnDesc->Integer.Value += 509 (((UINT64) Temp32) * PowerOfTen); 510 511 /* Shift to next BCD digit */ 512 513 Digit >>= 4; 514 515 /* Next power of 10 */ 516 517 PowerOfTen *= 10; 518 } 519 break; 520 521 case AML_LOAD_OP: /* Result1 = Load (Operand[0], Result1) */ 522 523 ReturnDesc->Integer.Value = 0; 524 Status = AcpiExLoadOp (Operand[0], ReturnDesc, WalkState); 525 if (ACPI_SUCCESS (Status)) 526 { 527 /* Return -1 (non-zero) indicates success */ 528 529 ReturnDesc->Integer.Value = 0xFFFFFFFFFFFFFFFF; 530 } 531 break; 532 533 case AML_TO_BCD_OP: /* ToBcd (Operand, Result) */ 534 535 ReturnDesc->Integer.Value = 0; 536 Digit = Operand[0]->Integer.Value; 537 538 /* Each BCD digit is one nybble wide */ 539 540 for (i = 0; (i < AcpiGbl_IntegerNybbleWidth) && (Digit > 0); i++) 541 { 542 (void) AcpiUtShortDivide (Digit, 10, &Digit, &Temp32); 543 544 /* 545 * Insert the BCD digit that resides in the 546 * remainder from above 547 */ 548 ReturnDesc->Integer.Value |= 549 (((UINT64) Temp32) << ACPI_MUL_4 (i)); 550 } 551 552 /* Overflow if there is any data left in Digit */ 553 554 if (Digit > 0) 555 { 556 ACPI_ERROR ((AE_INFO, 557 "Integer too large to convert to BCD: 0x%8.8X%8.8X", 558 ACPI_FORMAT_UINT64 (Operand[0]->Integer.Value))); 559 Status = AE_AML_NUMERIC_OVERFLOW; 560 goto Cleanup; 561 } 562 break; 563 564 case AML_CONDITIONAL_REF_OF_OP: /* CondRefOf (SourceObject, Result) */ 565 /* 566 * This op is a little strange because the internal return value is 567 * different than the return value stored in the result descriptor 568 * (There are really two return values) 569 */ 570 if ((ACPI_NAMESPACE_NODE *) Operand[0] == AcpiGbl_RootNode) 571 { 572 /* 573 * This means that the object does not exist in the namespace, 574 * return FALSE 575 */ 576 ReturnDesc->Integer.Value = 0; 577 goto Cleanup; 578 } 579 580 /* Get the object reference, store it, and remove our reference */ 581 582 Status = AcpiExGetObjectReference (Operand[0], 583 &ReturnDesc2, WalkState); 584 if (ACPI_FAILURE (Status)) 585 { 586 goto Cleanup; 587 } 588 589 Status = AcpiExStore (ReturnDesc2, Operand[1], WalkState); 590 AcpiUtRemoveReference (ReturnDesc2); 591 592 /* The object exists in the namespace, return TRUE */ 593 594 ReturnDesc->Integer.Value = ACPI_UINT64_MAX; 595 goto Cleanup; 596 597 598 default: 599 600 /* No other opcodes get here */ 601 602 break; 603 } 604 break; 605 606 case AML_STORE_OP: /* Store (Source, Target) */ 607 /* 608 * A store operand is typically a number, string, buffer or lvalue 609 * Be careful about deleting the source object, 610 * since the object itself may have been stored. 611 */ 612 Status = AcpiExStore (Operand[0], Operand[1], WalkState); 613 if (ACPI_FAILURE (Status)) 614 { 615 return_ACPI_STATUS (Status); 616 } 617 618 /* It is possible that the Store already produced a return object */ 619 620 if (!WalkState->ResultObj) 621 { 622 /* 623 * Normally, we would remove a reference on the Operand[0] 624 * parameter; But since it is being used as the internal return 625 * object (meaning we would normally increment it), the two 626 * cancel out, and we simply don't do anything. 627 */ 628 WalkState->ResultObj = Operand[0]; 629 WalkState->Operands[0] = NULL; /* Prevent deletion */ 630 } 631 return_ACPI_STATUS (Status); 632 633 /* 634 * ACPI 2.0 Opcodes 635 */ 636 case AML_COPY_OBJECT_OP: /* CopyObject (Source, Target) */ 637 638 Status = AcpiUtCopyIobjectToIobject ( 639 Operand[0], &ReturnDesc, WalkState); 640 break; 641 642 case AML_TO_DECIMAL_STRING_OP: /* ToDecimalString (Data, Result) */ 643 644 Status = AcpiExConvertToString ( 645 Operand[0], &ReturnDesc, ACPI_EXPLICIT_CONVERT_DECIMAL); 646 if (ReturnDesc == Operand[0]) 647 { 648 /* No conversion performed, add ref to handle return value */ 649 650 AcpiUtAddReference (ReturnDesc); 651 } 652 break; 653 654 case AML_TO_HEX_STRING_OP: /* ToHexString (Data, Result) */ 655 656 Status = AcpiExConvertToString ( 657 Operand[0], &ReturnDesc, ACPI_EXPLICIT_CONVERT_HEX); 658 if (ReturnDesc == Operand[0]) 659 { 660 /* No conversion performed, add ref to handle return value */ 661 662 AcpiUtAddReference (ReturnDesc); 663 } 664 break; 665 666 case AML_TO_BUFFER_OP: /* ToBuffer (Data, Result) */ 667 668 Status = AcpiExConvertToBuffer (Operand[0], &ReturnDesc); 669 if (ReturnDesc == Operand[0]) 670 { 671 /* No conversion performed, add ref to handle return value */ 672 673 AcpiUtAddReference (ReturnDesc); 674 } 675 break; 676 677 case AML_TO_INTEGER_OP: /* ToInteger (Data, Result) */ 678 679 /* Perform "explicit" conversion */ 680 681 Status = AcpiExConvertToInteger (Operand[0], &ReturnDesc, 0); 682 if (ReturnDesc == Operand[0]) 683 { 684 /* No conversion performed, add ref to handle return value */ 685 686 AcpiUtAddReference (ReturnDesc); 687 } 688 break; 689 690 case AML_SHIFT_LEFT_BIT_OP: /* ShiftLeftBit (Source, BitNum) */ 691 case AML_SHIFT_RIGHT_BIT_OP: /* ShiftRightBit (Source, BitNum) */ 692 693 /* These are two obsolete opcodes */ 694 695 ACPI_ERROR ((AE_INFO, 696 "%s is obsolete and not implemented", 697 AcpiPsGetOpcodeName (WalkState->Opcode))); 698 Status = AE_SUPPORT; 699 goto Cleanup; 700 701 default: /* Unknown opcode */ 702 703 ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X", 704 WalkState->Opcode)); 705 Status = AE_AML_BAD_OPCODE; 706 goto Cleanup; 707 } 708 709 if (ACPI_SUCCESS (Status)) 710 { 711 /* Store the return value computed above into the target object */ 712 713 Status = AcpiExStore (ReturnDesc, Operand[1], WalkState); 714 } 715 716 717Cleanup: 718 719 /* Delete return object on error */ 720 721 if (ACPI_FAILURE (Status)) 722 { 723 AcpiUtRemoveReference (ReturnDesc); 724 } 725 726 /* Save return object on success */ 727 728 else if (!WalkState->ResultObj) 729 { 730 WalkState->ResultObj = ReturnDesc; 731 } 732 733 return_ACPI_STATUS (Status); 734} 735 736 737/******************************************************************************* 738 * 739 * FUNCTION: AcpiExOpcode_1A_0T_1R 740 * 741 * PARAMETERS: WalkState - Current state (contains AML opcode) 742 * 743 * RETURN: Status 744 * 745 * DESCRIPTION: Execute opcode with one argument, no target, and a return value 746 * 747 ******************************************************************************/ 748 749ACPI_STATUS 750AcpiExOpcode_1A_0T_1R ( 751 ACPI_WALK_STATE *WalkState) 752{ 753 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0]; 754 ACPI_OPERAND_OBJECT *TempDesc; 755 ACPI_OPERAND_OBJECT *ReturnDesc = NULL; 756 ACPI_STATUS Status = AE_OK; 757 UINT32 Type; 758 UINT64 Value; 759 760 761 ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_0T_1R, 762 AcpiPsGetOpcodeName (WalkState->Opcode)); 763 764 765 /* Examine the AML opcode */ 766 767 switch (WalkState->Opcode) 768 { 769 case AML_LOGICAL_NOT_OP: /* LNot (Operand) */ 770 771 ReturnDesc = AcpiUtCreateIntegerObject ((UINT64) 0); 772 if (!ReturnDesc) 773 { 774 Status = AE_NO_MEMORY; 775 goto Cleanup; 776 } 777 778 /* 779 * Set result to ONES (TRUE) if Value == 0. Note: 780 * ReturnDesc->Integer.Value is initially == 0 (FALSE) from above. 781 */ 782 if (!Operand[0]->Integer.Value) 783 { 784 ReturnDesc->Integer.Value = ACPI_UINT64_MAX; 785 } 786 break; 787 788 case AML_DECREMENT_OP: /* Decrement (Operand) */ 789 case AML_INCREMENT_OP: /* Increment (Operand) */ 790 /* 791 * Create a new integer. Can't just get the base integer and 792 * increment it because it may be an Arg or Field. 793 */ 794 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); 795 if (!ReturnDesc) 796 { 797 Status = AE_NO_MEMORY; 798 goto Cleanup; 799 } 800 801 /* 802 * Since we are expecting a Reference operand, it can be either a 803 * NS Node or an internal object. 804 */ 805 TempDesc = Operand[0]; 806 if (ACPI_GET_DESCRIPTOR_TYPE (TempDesc) == ACPI_DESC_TYPE_OPERAND) 807 { 808 /* Internal reference object - prevent deletion */ 809 810 AcpiUtAddReference (TempDesc); 811 } 812 813 /* 814 * Convert the Reference operand to an Integer (This removes a 815 * reference on the Operand[0] object) 816 * 817 * NOTE: We use LNOT_OP here in order to force resolution of the 818 * reference operand to an actual integer. 819 */ 820 Status = AcpiExResolveOperands (AML_LOGICAL_NOT_OP, 821 &TempDesc, WalkState); 822 if (ACPI_FAILURE (Status)) 823 { 824 ACPI_EXCEPTION ((AE_INFO, Status, 825 "While resolving operands for [%s]", 826 AcpiPsGetOpcodeName (WalkState->Opcode))); 827 828 goto Cleanup; 829 } 830 831 /* 832 * TempDesc is now guaranteed to be an Integer object -- 833 * Perform the actual increment or decrement 834 */ 835 if (WalkState->Opcode == AML_INCREMENT_OP) 836 { 837 ReturnDesc->Integer.Value = TempDesc->Integer.Value + 1; 838 } 839 else 840 { 841 ReturnDesc->Integer.Value = TempDesc->Integer.Value - 1; 842 } 843 844 /* Finished with this Integer object */ 845 846 AcpiUtRemoveReference (TempDesc); 847 848 /* 849 * Store the result back (indirectly) through the original 850 * Reference object 851 */ 852 Status = AcpiExStore (ReturnDesc, Operand[0], WalkState); 853 break; 854 855 case AML_OBJECT_TYPE_OP: /* ObjectType (SourceObject) */ 856 /* 857 * Note: The operand is not resolved at this point because we want to 858 * get the associated object, not its value. For example, we don't 859 * want to resolve a FieldUnit to its value, we want the actual 860 * FieldUnit object. 861 */ 862 863 /* Get the type of the base object */ 864 865 Status = AcpiExResolveMultiple (WalkState, Operand[0], &Type, NULL); 866 if (ACPI_FAILURE (Status)) 867 { 868 goto Cleanup; 869 } 870 871 /* Allocate a descriptor to hold the type. */ 872 873 ReturnDesc = AcpiUtCreateIntegerObject ((UINT64) Type); 874 if (!ReturnDesc) 875 { 876 Status = AE_NO_MEMORY; 877 goto Cleanup; 878 } 879 break; 880 881 case AML_SIZE_OF_OP: /* SizeOf (SourceObject) */ 882 /* 883 * Note: The operand is not resolved at this point because we want to 884 * get the associated object, not its value. 885 */ 886 887 /* Get the base object */ 888 889 Status = AcpiExResolveMultiple ( 890 WalkState, Operand[0], &Type, &TempDesc); 891 if (ACPI_FAILURE (Status)) 892 { 893 goto Cleanup; 894 } 895 896 /* 897 * The type of the base object must be integer, buffer, string, or 898 * package. All others are not supported. 899 * 900 * NOTE: Integer is not specifically supported by the ACPI spec, 901 * but is supported implicitly via implicit operand conversion. 902 * rather than bother with conversion, we just use the byte width 903 * global (4 or 8 bytes). 904 */ 905 switch (Type) 906 { 907 case ACPI_TYPE_INTEGER: 908 909 Value = AcpiGbl_IntegerByteWidth; 910 break; 911 912 case ACPI_TYPE_STRING: 913 914 Value = TempDesc->String.Length; 915 break; 916 917 case ACPI_TYPE_BUFFER: 918 919 /* Buffer arguments may not be evaluated at this point */ 920 921 Status = AcpiDsGetBufferArguments (TempDesc); 922 Value = TempDesc->Buffer.Length; 923 break; 924 925 case ACPI_TYPE_PACKAGE: 926 927 /* Package arguments may not be evaluated at this point */ 928 929 Status = AcpiDsGetPackageArguments (TempDesc); 930 Value = TempDesc->Package.Count; 931 break; 932 933 default: 934 935 ACPI_ERROR ((AE_INFO, 936 "Operand must be Buffer/Integer/String/Package" 937 " - found type %s", 938 AcpiUtGetTypeName (Type))); 939 940 Status = AE_AML_OPERAND_TYPE; 941 goto Cleanup; 942 } 943 944 if (ACPI_FAILURE (Status)) 945 { 946 goto Cleanup; 947 } 948 949 /* 950 * Now that we have the size of the object, create a result 951 * object to hold the value 952 */ 953 ReturnDesc = AcpiUtCreateIntegerObject (Value); 954 if (!ReturnDesc) 955 { 956 Status = AE_NO_MEMORY; 957 goto Cleanup; 958 } 959 break; 960 961 962 case AML_REF_OF_OP: /* RefOf (SourceObject) */ 963 964 Status = AcpiExGetObjectReference ( 965 Operand[0], &ReturnDesc, WalkState); 966 if (ACPI_FAILURE (Status)) 967 { 968 goto Cleanup; 969 } 970 break; 971 972 973 case AML_DEREF_OF_OP: /* DerefOf (ObjReference | String) */ 974 975 /* Check for a method local or argument, or standalone String */ 976 977 if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) == ACPI_DESC_TYPE_NAMED) 978 { 979 TempDesc = AcpiNsGetAttachedObject ( 980 (ACPI_NAMESPACE_NODE *) Operand[0]); 981 if (TempDesc && 982 ((TempDesc->Common.Type == ACPI_TYPE_STRING) || 983 (TempDesc->Common.Type == ACPI_TYPE_LOCAL_REFERENCE))) 984 { 985 Operand[0] = TempDesc; 986 AcpiUtAddReference (TempDesc); 987 } 988 else 989 { 990 Status = AE_AML_OPERAND_TYPE; 991 goto Cleanup; 992 } 993 } 994 else 995 { 996 switch ((Operand[0])->Common.Type) 997 { 998 case ACPI_TYPE_LOCAL_REFERENCE: 999 /* 1000 * This is a DerefOf (LocalX | ArgX) 1001 * 1002 * Must resolve/dereference the local/arg reference first 1003 */ 1004 switch (Operand[0]->Reference.Class) 1005 { 1006 case ACPI_REFCLASS_LOCAL: 1007 case ACPI_REFCLASS_ARG: 1008 1009 /* Set Operand[0] to the value of the local/arg */ 1010 1011 Status = AcpiDsMethodDataGetValue ( 1012 Operand[0]->Reference.Class, 1013 Operand[0]->Reference.Value, 1014 WalkState, &TempDesc); 1015 if (ACPI_FAILURE (Status)) 1016 { 1017 goto Cleanup; 1018 } 1019 1020 /* 1021 * Delete our reference to the input object and 1022 * point to the object just retrieved 1023 */ 1024 AcpiUtRemoveReference (Operand[0]); 1025 Operand[0] = TempDesc; 1026 break; 1027 1028 case ACPI_REFCLASS_REFOF: 1029 1030 /* Get the object to which the reference refers */ 1031 1032 TempDesc = Operand[0]->Reference.Object; 1033 AcpiUtRemoveReference (Operand[0]); 1034 Operand[0] = TempDesc; 1035 break; 1036 1037 default: 1038 1039 /* Must be an Index op - handled below */ 1040 break; 1041 } 1042 break; 1043 1044 case ACPI_TYPE_STRING: 1045 1046 break; 1047 1048 default: 1049 1050 Status = AE_AML_OPERAND_TYPE; 1051 goto Cleanup; 1052 } 1053 } 1054 1055 if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) != ACPI_DESC_TYPE_NAMED) 1056 { 1057 if ((Operand[0])->Common.Type == ACPI_TYPE_STRING) 1058 { 1059 /* 1060 * This is a DerefOf (String). The string is a reference 1061 * to a named ACPI object. 1062 * 1063 * 1) Find the owning Node 1064 * 2) Dereference the node to an actual object. Could be a 1065 * Field, so we need to resolve the node to a value. 1066 */ 1067 Status = AcpiNsGetNodeUnlocked (WalkState->ScopeInfo->Scope.Node, 1068 Operand[0]->String.Pointer, 1069 ACPI_NS_SEARCH_PARENT, 1070 ACPI_CAST_INDIRECT_PTR ( 1071 ACPI_NAMESPACE_NODE, &ReturnDesc)); 1072 if (ACPI_FAILURE (Status)) 1073 { 1074 goto Cleanup; 1075 } 1076 1077 Status = AcpiExResolveNodeToValue ( 1078 ACPI_CAST_INDIRECT_PTR ( 1079 ACPI_NAMESPACE_NODE, &ReturnDesc), 1080 WalkState); 1081 goto Cleanup; 1082 } 1083 } 1084 1085 /* Operand[0] may have changed from the code above */ 1086 1087 if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) == ACPI_DESC_TYPE_NAMED) 1088 { 1089 /* 1090 * This is a DerefOf (ObjectReference) 1091 * Get the actual object from the Node (This is the dereference). 1092 * This case may only happen when a LocalX or ArgX is 1093 * dereferenced above, or for references to device and 1094 * thermal objects. 1095 */ 1096 switch (((ACPI_NAMESPACE_NODE *) Operand[0])->Type) 1097 { 1098 case ACPI_TYPE_DEVICE: 1099 case ACPI_TYPE_THERMAL: 1100 1101 /* These types have no node subobject, return the NS node */ 1102 1103 ReturnDesc = Operand[0]; 1104 break; 1105 1106 default: 1107 /* For most types, get the object attached to the node */ 1108 1109 ReturnDesc = AcpiNsGetAttachedObject ( 1110 (ACPI_NAMESPACE_NODE *) Operand[0]); 1111 AcpiUtAddReference (ReturnDesc); 1112 break; 1113 } 1114 } 1115 else 1116 { 1117 /* 1118 * This must be a reference object produced by either the 1119 * Index() or RefOf() operator 1120 */ 1121 switch (Operand[0]->Reference.Class) 1122 { 1123 case ACPI_REFCLASS_INDEX: 1124 /* 1125 * The target type for the Index operator must be 1126 * either a Buffer or a Package 1127 */ 1128 switch (Operand[0]->Reference.TargetType) 1129 { 1130 case ACPI_TYPE_BUFFER_FIELD: 1131 1132 TempDesc = Operand[0]->Reference.Object; 1133 1134 /* 1135 * Create a new object that contains one element of the 1136 * buffer -- the element pointed to by the index. 1137 * 1138 * NOTE: index into a buffer is NOT a pointer to a 1139 * sub-buffer of the main buffer, it is only a pointer to a 1140 * single element (byte) of the buffer! 1141 * 1142 * Since we are returning the value of the buffer at the 1143 * indexed location, we don't need to add an additional 1144 * reference to the buffer itself. 1145 */ 1146 ReturnDesc = AcpiUtCreateIntegerObject ((UINT64) 1147 TempDesc->Buffer.Pointer[Operand[0]->Reference.Value]); 1148 if (!ReturnDesc) 1149 { 1150 Status = AE_NO_MEMORY; 1151 goto Cleanup; 1152 } 1153 break; 1154 1155 case ACPI_TYPE_PACKAGE: 1156 /* 1157 * Return the referenced element of the package. We must 1158 * add another reference to the referenced object, however. 1159 */ 1160 ReturnDesc = *(Operand[0]->Reference.Where); 1161 if (!ReturnDesc) 1162 { 1163 /* 1164 * Element is NULL, do not allow the dereference. 1165 * This provides compatibility with other ACPI 1166 * implementations. 1167 */ 1168 return_ACPI_STATUS (AE_AML_UNINITIALIZED_ELEMENT); 1169 } 1170 1171 AcpiUtAddReference (ReturnDesc); 1172 break; 1173 1174 default: 1175 1176 ACPI_ERROR ((AE_INFO, 1177 "Unknown Index TargetType 0x%X in reference object %p", 1178 Operand[0]->Reference.TargetType, Operand[0])); 1179 1180 Status = AE_AML_OPERAND_TYPE; 1181 goto Cleanup; 1182 } 1183 break; 1184 1185 case ACPI_REFCLASS_REFOF: 1186 1187 ReturnDesc = Operand[0]->Reference.Object; 1188 1189 if (ACPI_GET_DESCRIPTOR_TYPE (ReturnDesc) == 1190 ACPI_DESC_TYPE_NAMED) 1191 { 1192 ReturnDesc = AcpiNsGetAttachedObject ( 1193 (ACPI_NAMESPACE_NODE *) ReturnDesc); 1194 if (!ReturnDesc) 1195 { 1196 break; 1197 } 1198 1199 /* 1200 * June 2013: 1201 * BufferFields/FieldUnits require additional resolution 1202 */ 1203 switch (ReturnDesc->Common.Type) 1204 { 1205 case ACPI_TYPE_BUFFER_FIELD: 1206 case ACPI_TYPE_LOCAL_REGION_FIELD: 1207 case ACPI_TYPE_LOCAL_BANK_FIELD: 1208 case ACPI_TYPE_LOCAL_INDEX_FIELD: 1209 1210 Status = AcpiExReadDataFromField ( 1211 WalkState, ReturnDesc, &TempDesc); 1212 if (ACPI_FAILURE (Status)) 1213 { 1214 return_ACPI_STATUS (Status); 1215 } 1216 1217 ReturnDesc = TempDesc; 1218 break; 1219 1220 default: 1221 1222 /* Add another reference to the object */ 1223 1224 AcpiUtAddReference (ReturnDesc); 1225 break; 1226 } 1227 } 1228 break; 1229 1230 default: 1231 1232 ACPI_ERROR ((AE_INFO, 1233 "Unknown class in reference(%p) - 0x%2.2X", 1234 Operand[0], Operand[0]->Reference.Class)); 1235 1236 Status = AE_TYPE; 1237 goto Cleanup; 1238 } 1239 } 1240 break; 1241 1242 default: 1243 1244 ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X", 1245 WalkState->Opcode)); 1246 1247 Status = AE_AML_BAD_OPCODE; 1248 goto Cleanup; 1249 } 1250 1251 1252Cleanup: 1253 1254 /* Delete return object on error */ 1255 1256 if (ACPI_FAILURE (Status)) 1257 { 1258 AcpiUtRemoveReference (ReturnDesc); 1259 } 1260 1261 /* Save return object on success */ 1262 1263 else 1264 { 1265 WalkState->ResultObj = ReturnDesc; 1266 } 1267 1268 return_ACPI_STATUS (Status); 1269} 1270