drivers/bus/acpi/acpica/executer/exoparg2.c

   1 /******************************************************************************
   2  *
   3  * Module Name: exoparg2 - AML execution - opcodes with 2 arguments
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2018, 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.h"
  45 #include "accommon.h"
  46 #include "acparser.h"
  47 #include "acinterp.h"
  48 #include "acevents.h"
  49 #include "amlcode.h"
  50
  51
  52 #define _COMPONENT          ACPI_EXECUTER
  53         ACPI_MODULE_NAME    ("exoparg2")
  54
  55
  56 /*!
  57  * Naming convention for AML interpreter execution routines.
  58  *
  59  * The routines that begin execution of AML opcodes are named with a common
  60  * convention based upon the number of arguments, the number of target operands,
  61  * and whether or not a value is returned:
  62  *
  63  *      AcpiExOpcode_xA_yT_zR
  64  *
  65  * Where:
  66  *
  67  * xA - ARGUMENTS:    The number of arguments (input operands) that are
  68  *                    required for this opcode type (1 through 6 args).
  69  * yT - TARGETS:      The number of targets (output operands) that are required
  70  *                    for this opcode type (0, 1, or 2 targets).
  71  * zR - RETURN VALUE: Indicates whether this opcode type returns a value
  72  *                    as the function return (0 or 1).
  73  *
  74  * The AcpiExOpcode* functions are called via the Dispatcher component with
  75  * fully resolved operands.
  76 !*/
  77
  78
  79 /*******************************************************************************
  80  *
  81  * FUNCTION:    AcpiExOpcode_2A_0T_0R
  82  *
  83  * PARAMETERS:  WalkState           - Current walk state
  84  *
  85  * RETURN:      Status
  86  *
  87  * DESCRIPTION: Execute opcode with two arguments, no target, and no return
  88  *              value.
  89  *
  90  * ALLOCATION:  Deletes both operands
  91  *
  92  ******************************************************************************/
  93
  94 ACPI_STATUS
  95 AcpiExOpcode_2A_0T_0R (
  96     ACPI_WALK_STATE         *WalkState)
  97 {
  98     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
  99     ACPI_NAMESPACE_NODE     *Node;
 100     UINT32                  Value;
 101     ACPI_STATUS             Status = AE_OK;
 102
 103
 104     ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_0R,
 105             AcpiPsGetOpcodeName (WalkState->Opcode));
 106
 107
 108     /* Examine the opcode */
 109
 110     switch (WalkState->Opcode)
 111     {
 112     case AML_NOTIFY_OP:         /* Notify (NotifyObject, NotifyValue) */
 113
 114         /* The first operand is a namespace node */
 115
 116         Node = (ACPI_NAMESPACE_NODE *) Operand[0];
 117
 118         /* Second value is the notify value */
 119
 120         Value = (UINT32) Operand[1]->Integer.Value;
 121
 122         /* Are notifies allowed on this object? */
 123
 124         if (!AcpiEvIsNotifyObject (Node))
 125         {
 126             ACPI_ERROR ((AE_INFO,
 127                 "Unexpected notify object type [%s]",
 128                 AcpiUtGetTypeName (Node->Type)));
 129
 130             Status = AE_AML_OPERAND_TYPE;
 131             break;
 132         }
 133
 134         /*
 135          * Dispatch the notify to the appropriate handler
 136          * NOTE: the request is queued for execution after this method
 137          * completes. The notify handlers are NOT invoked synchronously
 138          * from this thread -- because handlers may in turn run other
 139          * control methods.
 140          */
 141         Status = AcpiEvQueueNotifyRequest (Node, Value);
 142         break;
 143
 144     default:
 145
 146         ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
 147             WalkState->Opcode));
 148         Status = AE_AML_BAD_OPCODE;
 149     }
 150
 151     return_ACPI_STATUS (Status);
 152 }
 153
 154
 155 /*******************************************************************************
 156  *
 157  * FUNCTION:    AcpiExOpcode_2A_2T_1R
 158  *
 159  * PARAMETERS:  WalkState           - Current walk state
 160  *
 161  * RETURN:      Status
 162  *
 163  * DESCRIPTION: Execute a dyadic operator (2 operands) with 2 output targets
 164  *              and one implicit return value.
 165  *
 166  ******************************************************************************/
 167
 168 ACPI_STATUS
 169 AcpiExOpcode_2A_2T_1R (
 170     ACPI_WALK_STATE         *WalkState)
 171 {
 172     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
 173     ACPI_OPERAND_OBJECT     *ReturnDesc1 = NULL;
 174     ACPI_OPERAND_OBJECT     *ReturnDesc2 = NULL;
 175     ACPI_STATUS             Status;
 176
 177
 178     ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_2T_1R,
 179         AcpiPsGetOpcodeName (WalkState->Opcode));
 180
 181
 182     /* Execute the opcode */
 183
 184     switch (WalkState->Opcode)
 185     {
 186     case AML_DIVIDE_OP:
 187
 188         /* Divide (Dividend, Divisor, RemainderResult QuotientResult) */
 189
 190         ReturnDesc1 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
 191         if (!ReturnDesc1)
 192         {
 193             Status = AE_NO_MEMORY;
 194             goto Cleanup;
 195         }
 196
 197         ReturnDesc2 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
 198         if (!ReturnDesc2)
 199         {
 200             Status = AE_NO_MEMORY;
 201             goto Cleanup;
 202         }
 203
 204         /* Quotient to ReturnDesc1, remainder to ReturnDesc2 */
 205
 206         Status = AcpiUtDivide (
 207             Operand[0]->Integer.Value,
 208             Operand[1]->Integer.Value,
 209             &ReturnDesc1->Integer.Value,
 210             &ReturnDesc2->Integer.Value);
 211         if (ACPI_FAILURE (Status))
 212         {
 213             goto Cleanup;
 214         }
 215         break;
 216
 217     default:
 218
 219         ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
 220             WalkState->Opcode));
 221
 222         Status = AE_AML_BAD_OPCODE;
 223         goto Cleanup;
 224     }
 225
 226     /* Store the results to the target reference operands */
 227
 228     Status = AcpiExStore (ReturnDesc2, Operand[2], WalkState);
 229     if (ACPI_FAILURE (Status))
 230     {
 231         goto Cleanup;
 232     }
 233
 234     Status = AcpiExStore (ReturnDesc1, Operand[3], WalkState);
 235     if (ACPI_FAILURE (Status))
 236     {
 237         goto Cleanup;
 238     }
 239
 240 Cleanup:
 241     /*
 242      * Since the remainder is not returned indirectly, remove a reference to
 243      * it. Only the quotient is returned indirectly.
 244      */
 245     AcpiUtRemoveReference (ReturnDesc2);
 246
 247     if (ACPI_FAILURE (Status))
 248     {
 249         /* Delete the return object */
 250
 251         AcpiUtRemoveReference (ReturnDesc1);
 252     }
 253
 254     /* Save return object (the remainder) on success */
 255
 256     else
 257     {
 258         WalkState->ResultObj = ReturnDesc1;
 259     }
 260
 261     return_ACPI_STATUS (Status);
 262 }
 263
 264
 265 /*******************************************************************************
 266  *
 267  * FUNCTION:    AcpiExOpcode_2A_1T_1R
 268  *
 269  * PARAMETERS:  WalkState           - 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
 278 ACPI_STATUS
 279 AcpiExOpcode_2A_1T_1R (
 280     ACPI_WALK_STATE         *WalkState)
 281 {
 282     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
 283     ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
 284     UINT64                  Index;
 285     ACPI_STATUS             Status = AE_OK;
 286     ACPI_SIZE               Length = 0;
 287
 288
 289     ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_1T_1R,
 290         AcpiPsGetOpcodeName (WalkState->Opcode));
 291
 292
 293     /* Execute the opcode */
 294
 295     if (WalkState->OpInfo->Flags & AML_MATH)
 296     {
 297         /* All simple math opcodes (add, etc.) */
 298
 299         ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
 300         if (!ReturnDesc)
 301         {
 302             Status = AE_NO_MEMORY;
 303             goto Cleanup;
 304         }
 305
 306         ReturnDesc->Integer.Value = AcpiExDoMathOp (
 307             WalkState->Opcode,
 308             Operand[0]->Integer.Value,
 309             Operand[1]->Integer.Value);
 310         goto StoreResultToTarget;
 311     }
 312
 313     switch (WalkState->Opcode)
 314     {
 315     case AML_MOD_OP: /* Mod (Dividend, Divisor, RemainderResult (ACPI 2.0) */
 316
 317         ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
 318         if (!ReturnDesc)
 319         {
 320             Status = AE_NO_MEMORY;
 321             goto Cleanup;
 322         }
 323
 324         /* ReturnDesc will contain the remainder */
 325
 326         Status = AcpiUtDivide (
 327             Operand[0]->Integer.Value,
 328             Operand[1]->Integer.Value,
 329             NULL,
 330             &ReturnDesc->Integer.Value);
 331         break;
 332
 333     case AML_CONCATENATE_OP: /* Concatenate (Data1, Data2, Result) */
 334
 335         Status = AcpiExDoConcatenate (
 336             Operand[0], Operand[1], &ReturnDesc, WalkState);
 337         break;
 338
 339     case AML_TO_STRING_OP: /* ToString (Buffer, Length, Result) (ACPI 2.0) */
 340         /*
 341          * Input object is guaranteed to be a buffer at this point (it may have
 342          * been converted.)  Copy the raw buffer data to a new object of
 343          * type String.
 344          */
 345
 346         /*
 347          * Get the length of the new string. It is the smallest of:
 348          * 1) Length of the input buffer
 349          * 2) Max length as specified in the ToString operator
 350          * 3) Length of input buffer up to a zero byte (null terminator)
 351          *
 352          * NOTE: A length of zero is ok, and will create a zero-length, null
 353          *       terminated string.
 354          */
 355         while ((Length < Operand[0]->Buffer.Length) &&
 356                (Length < Operand[1]->Integer.Value) &&
 357                (Operand[0]->Buffer.Pointer[Length]))
 358         {
 359             Length++;
 360         }
 361
 362         /* Allocate a new string object */
 363
 364         ReturnDesc = AcpiUtCreateStringObject (Length);
 365         if (!ReturnDesc)
 366         {
 367             Status = AE_NO_MEMORY;
 368             goto Cleanup;
 369         }
 370
 371         /*
 372          * Copy the raw buffer data with no transform.
 373          * (NULL terminated already)
 374          */
 375         memcpy (ReturnDesc->String.Pointer,
 376             Operand[0]->Buffer.Pointer, Length);
 377         break;
 378
 379     case AML_CONCATENATE_TEMPLATE_OP:
 380
 381         /* ConcatenateResTemplate (Buffer, Buffer, Result) (ACPI 2.0) */
 382
 383         Status = AcpiExConcatTemplate (
 384             Operand[0], Operand[1], &ReturnDesc, WalkState);
 385         break;
 386
 387     case AML_INDEX_OP:              /* Index (Source Index Result) */
 388
 389         /* Create the internal return object */
 390
 391         ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_REFERENCE);
 392         if (!ReturnDesc)
 393         {
 394             Status = AE_NO_MEMORY;
 395             goto Cleanup;
 396         }
 397
 398         /* Initialize the Index reference object */
 399
 400         Index = Operand[1]->Integer.Value;
 401         ReturnDesc->Reference.Value = (UINT32) Index;
 402         ReturnDesc->Reference.Class = ACPI_REFCLASS_INDEX;
 403
 404         /*
 405          * At this point, the Source operand is a String, Buffer, or Package.
 406          * Verify that the index is within range.
 407          */
 408         switch ((Operand[0])->Common.Type)
 409         {
 410         case ACPI_TYPE_STRING:
 411
 412             if (Index >= Operand[0]->String.Length)
 413             {
 414                 Length = Operand[0]->String.Length;
 415                 Status = AE_AML_STRING_LIMIT;
 416             }
 417
 418             ReturnDesc->Reference.TargetType = ACPI_TYPE_BUFFER_FIELD;
 419             ReturnDesc->Reference.IndexPointer =
 420                 &(Operand[0]->Buffer.Pointer [Index]);
 421             break;
 422
 423         case ACPI_TYPE_BUFFER:
 424
 425             if (Index >= Operand[0]->Buffer.Length)
 426             {
 427                 Length = Operand[0]->Buffer.Length;
 428                 Status = AE_AML_BUFFER_LIMIT;
 429             }
 430
 431             ReturnDesc->Reference.TargetType = ACPI_TYPE_BUFFER_FIELD;
 432             ReturnDesc->Reference.IndexPointer =
 433                 &(Operand[0]->Buffer.Pointer [Index]);
 434             break;
 435
 436         case ACPI_TYPE_PACKAGE:
 437
 438             if (Index >= Operand[0]->Package.Count)
 439             {
 440                 Length = Operand[0]->Package.Count;
 441                 Status = AE_AML_PACKAGE_LIMIT;
 442             }
 443
 444             ReturnDesc->Reference.TargetType = ACPI_TYPE_PACKAGE;
 445             ReturnDesc->Reference.Where =
 446                 &Operand[0]->Package.Elements [Index];
 447             break;
 448
 449         default:
 450
 451             ACPI_ERROR ((AE_INFO,
 452                 "Invalid object type: %X", (Operand[0])->Common.Type));
 453             Status = AE_AML_INTERNAL;
 454             goto Cleanup;
 455         }
 456
 457         /* Failure means that the Index was beyond the end of the object */
 458
 459         if (ACPI_FAILURE (Status))
 460         {
 461             ACPI_EXCEPTION ((AE_INFO, Status,
 462                 "Index (0x%X%8.8X) is beyond end of object (length 0x%X)",
 463                 ACPI_FORMAT_UINT64 (Index), (UINT32) Length));
 464             goto Cleanup;
 465         }
 466
 467         /*
 468          * Save the target object and add a reference to it for the life
 469          * of the index
 470          */
 471         ReturnDesc->Reference.Object = Operand[0];
 472         AcpiUtAddReference (Operand[0]);
 473
 474         /* Store the reference to the Target */
 475
 476         Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
 477
 478         /* Return the reference */
 479
 480         WalkState->ResultObj = ReturnDesc;
 481         goto Cleanup;
 482
 483     default:
 484
 485         ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
 486             WalkState->Opcode));
 487         Status = AE_AML_BAD_OPCODE;
 488         break;
 489     }
 490
 491
 492 StoreResultToTarget:
 493
 494     if (ACPI_SUCCESS (Status))
 495     {
 496         /*
 497          * Store the result of the operation (which is now in ReturnDesc) into
 498          * the Target descriptor.
 499          */
 500         Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
 501         if (ACPI_FAILURE (Status))
 502         {
 503             goto Cleanup;
 504         }
 505
 506         if (!WalkState->ResultObj)
 507         {
 508             WalkState->ResultObj = ReturnDesc;
 509         }
 510     }
 511
 512
 513 Cleanup:
 514
 515     /* Delete return object on error */
 516
 517     if (ACPI_FAILURE (Status))
 518     {
 519         AcpiUtRemoveReference (ReturnDesc);
 520         WalkState->ResultObj = NULL;
 521     }
 522
 523     return_ACPI_STATUS (Status);
 524 }
 525
 526
 527 /*******************************************************************************
 528  *
 529  * FUNCTION:    AcpiExOpcode_2A_0T_1R
 530  *
 531  * PARAMETERS:  WalkState           - Current walk state
 532  *
 533  * RETURN:      Status
 534  *
 535  * DESCRIPTION: Execute opcode with 2 arguments, no target, and a return value
 536  *
 537  ******************************************************************************/
 538
 539 ACPI_STATUS
 540 AcpiExOpcode_2A_0T_1R (
 541     ACPI_WALK_STATE         *WalkState)
 542 {
 543     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
 544     ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
 545     ACPI_STATUS             Status = AE_OK;
 546     BOOLEAN                 LogicalResult = FALSE;
 547
 548
 549     ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_1R,
 550         AcpiPsGetOpcodeName (WalkState->Opcode));
 551
 552
 553     /* Create the internal return object */
 554
 555     ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
 556     if (!ReturnDesc)
 557     {
 558         Status = AE_NO_MEMORY;
 559         goto Cleanup;
 560     }
 561
 562     /* Execute the Opcode */
 563
 564     if (WalkState->OpInfo->Flags & AML_LOGICAL_NUMERIC)
 565     {
 566         /* LogicalOp  (Operand0, Operand1) */
 567
 568         Status = AcpiExDoLogicalNumericOp (WalkState->Opcode,
 569             Operand[0]->Integer.Value, Operand[1]->Integer.Value,
 570             &LogicalResult);
 571         goto StoreLogicalResult;
 572     }
 573     else if (WalkState->OpInfo->Flags & AML_LOGICAL)
 574     {
 575         /* LogicalOp  (Operand0, Operand1) */
 576
 577         Status = AcpiExDoLogicalOp (WalkState->Opcode, Operand[0],
 578             Operand[1], &LogicalResult);
 579         goto StoreLogicalResult;
 580     }
 581
 582     switch (WalkState->Opcode)
 583     {
 584     case AML_ACQUIRE_OP:            /* Acquire (MutexObject, Timeout) */
 585
 586         Status = AcpiExAcquireMutex (Operand[1], Operand[0], WalkState);
 587         if (Status == AE_TIME)
 588         {
 589             LogicalResult = TRUE;       /* TRUE = Acquire timed out */
 590             Status = AE_OK;
 591         }
 592         break;
 593
 594
 595     case AML_WAIT_OP:               /* Wait (EventObject, Timeout) */
 596
 597         Status = AcpiExSystemWaitEvent (Operand[1], Operand[0]);
 598         if (Status == AE_TIME)
 599         {
 600             LogicalResult = TRUE;       /* TRUE, Wait timed out */
 601             Status = AE_OK;
 602         }
 603         break;
 604
 605     default:
 606
 607         ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
 608             WalkState->Opcode));
 609
 610         Status = AE_AML_BAD_OPCODE;
 611         goto Cleanup;
 612     }
 613
 614
 615 StoreLogicalResult:
 616     /*
 617      * Set return value to according to LogicalResult. logical TRUE (all ones)
 618      * Default is FALSE (zero)
 619      */
 620     if (LogicalResult)
 621     {
 622         ReturnDesc->Integer.Value = ACPI_UINT64_MAX;
 623     }
 624
 625 Cleanup:
 626
 627     /* Delete return object on error */
 628
 629     if (ACPI_FAILURE (Status))
 630     {
 631         AcpiUtRemoveReference (ReturnDesc);
 632     }
 633
 634     /* Save return object on success */
 635
 636     else
 637     {
 638         WalkState->ResultObj = ReturnDesc;
 639     }
 640
 641     return_ACPI_STATUS (Status);
 642 }