arch/all-pc/acpica/source/components/executer/exresop.c

   1 /******************************************************************************
   2  *
   3  * Module Name: exresop - AML Interpreter operand/object resolution
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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 #define __EXRESOP_C__
  45
  46 #include "acpi.h"
  47 #include "accommon.h"
  48 #include "amlcode.h"
  49 #include "acparser.h"
  50 #include "acinterp.h"
  51 #include "acnamesp.h"
  52
  53
  54 #define _COMPONENT          ACPI_EXECUTER
  55         ACPI_MODULE_NAME    ("exresop")
  56
  57 /* Local prototypes */
  58
  59 static ACPI_STATUS
  60 AcpiExCheckObjectType (
  61     ACPI_OBJECT_TYPE        TypeNeeded,
  62     ACPI_OBJECT_TYPE        ThisType,
  63     void                    *Object);
  64
  65
  66 /*******************************************************************************
  67  *
  68  * FUNCTION:    AcpiExCheckObjectType
  69  *
  70  * PARAMETERS:  TypeNeeded          Object type needed
  71  *              ThisType            Actual object type
  72  *              Object              Object pointer
  73  *
  74  * RETURN:      Status
  75  *
  76  * DESCRIPTION: Check required type against actual type
  77  *
  78  ******************************************************************************/
  79
  80 static ACPI_STATUS
  81 AcpiExCheckObjectType (
  82     ACPI_OBJECT_TYPE        TypeNeeded,
  83     ACPI_OBJECT_TYPE        ThisType,
  84     void                    *Object)
  85 {
  86     ACPI_FUNCTION_ENTRY ();
  87
  88
  89     if (TypeNeeded == ACPI_TYPE_ANY)
  90     {
  91         /* All types OK, so we don't perform any typechecks */
  92
  93         return (AE_OK);
  94     }
  95
  96     if (TypeNeeded == ACPI_TYPE_LOCAL_REFERENCE)
  97     {
  98         /*
  99          * Allow the AML "Constant" opcodes (Zero, One, etc.) to be reference
 100          * objects and thus allow them to be targets. (As per the ACPI
 101          * specification, a store to a constant is a noop.)
 102          */
 103         if ((ThisType == ACPI_TYPE_INTEGER) &&
 104             (((ACPI_OPERAND_OBJECT *) Object)->Common.Flags & AOPOBJ_AML_CONSTANT))
 105         {
 106             return (AE_OK);
 107         }
 108     }
 109
 110     if (TypeNeeded != ThisType)
 111     {
 112         ACPI_ERROR ((AE_INFO,
 113             "Needed type [%s], found [%s] %p",
 114             AcpiUtGetTypeName (TypeNeeded),
 115             AcpiUtGetTypeName (ThisType), Object));
 116
 117         return (AE_AML_OPERAND_TYPE);
 118     }
 119
 120     return (AE_OK);
 121 }
 122
 123
 124 /*******************************************************************************
 125  *
 126  * FUNCTION:    AcpiExResolveOperands
 127  *
 128  * PARAMETERS:  Opcode              - Opcode being interpreted
 129  *              StackPtr            - Pointer to the operand stack to be
 130  *                                    resolved
 131  *              WalkState           - Current state
 132  *
 133  * RETURN:      Status
 134  *
 135  * DESCRIPTION: Convert multiple input operands to the types required by the
 136  *              target operator.
 137  *
 138  *      Each 5-bit group in ArgTypes represents one required
 139  *      operand and indicates the required Type. The corresponding operand
 140  *      will be converted to the required type if possible, otherwise we
 141  *      abort with an exception.
 142  *
 143  ******************************************************************************/
 144
 145 ACPI_STATUS
 146 AcpiExResolveOperands (
 147     UINT16                  Opcode,
 148     ACPI_OPERAND_OBJECT     **StackPtr,
 149     ACPI_WALK_STATE         *WalkState)
 150 {
 151     ACPI_OPERAND_OBJECT     *ObjDesc;
 152     ACPI_STATUS             Status = AE_OK;
 153     UINT8                   ObjectType;
 154     UINT32                  ArgTypes;
 155     const ACPI_OPCODE_INFO  *OpInfo;
 156     UINT32                  ThisArgType;
 157     ACPI_OBJECT_TYPE        TypeNeeded;
 158     UINT16                  TargetOp = 0;
 159
 160
 161     ACPI_FUNCTION_TRACE_U32 (ExResolveOperands, Opcode);
 162
 163
 164     OpInfo = AcpiPsGetOpcodeInfo (Opcode);
 165     if (OpInfo->Class == AML_CLASS_UNKNOWN)
 166     {
 167         return_ACPI_STATUS (AE_AML_BAD_OPCODE);
 168     }
 169
 170     ArgTypes = OpInfo->RuntimeArgs;
 171     if (ArgTypes == ARGI_INVALID_OPCODE)
 172     {
 173         ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
 174             Opcode));
 175
 176         return_ACPI_STATUS (AE_AML_INTERNAL);
 177     }
 178
 179     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 180         "Opcode %X [%s] RequiredOperandTypes=%8.8X\n",
 181         Opcode, OpInfo->Name, ArgTypes));
 182
 183     /*
 184      * Normal exit is with (ArgTypes == 0) at end of argument list.
 185      * Function will return an exception from within the loop upon
 186      * finding an entry which is not (or cannot be converted
 187      * to) the required type; if stack underflows; or upon
 188      * finding a NULL stack entry (which should not happen).
 189      */
 190     while (GET_CURRENT_ARG_TYPE (ArgTypes))
 191     {
 192         if (!StackPtr || !*StackPtr)
 193         {
 194             ACPI_ERROR ((AE_INFO, "Null stack entry at %p",
 195                 StackPtr));
 196
 197             return_ACPI_STATUS (AE_AML_INTERNAL);
 198         }
 199
 200         /* Extract useful items */
 201
 202         ObjDesc = *StackPtr;
 203
 204         /* Decode the descriptor type */
 205
 206         switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc))
 207         {
 208         case ACPI_DESC_TYPE_NAMED:
 209
 210             /* Namespace Node */
 211
 212             ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type;
 213
 214             /*
 215              * Resolve an alias object. The construction of these objects
 216              * guarantees that there is only one level of alias indirection;
 217              * thus, the attached object is always the aliased namespace node
 218              */
 219             if (ObjectType == ACPI_TYPE_LOCAL_ALIAS)
 220             {
 221                 ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) ObjDesc);
 222                 *StackPtr = ObjDesc;
 223                 ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type;
 224             }
 225             break;
 226
 227         case ACPI_DESC_TYPE_OPERAND:
 228
 229             /* ACPI internal object */
 230
 231             ObjectType = ObjDesc->Common.Type;
 232
 233             /* Check for bad ACPI_OBJECT_TYPE */
 234
 235             if (!AcpiUtValidObjectType (ObjectType))
 236             {
 237                 ACPI_ERROR ((AE_INFO,
 238                     "Bad operand object type [0x%X]", ObjectType));
 239
 240                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 241             }
 242
 243             if (ObjectType == (UINT8) ACPI_TYPE_LOCAL_REFERENCE)
 244             {
 245                 /* Validate the Reference */
 246
 247                 switch (ObjDesc->Reference.Class)
 248                 {
 249                 case ACPI_REFCLASS_DEBUG:
 250
 251                     TargetOp = AML_DEBUG_OP;
 252
 253                     /*lint -fallthrough */
 254
 255                 case ACPI_REFCLASS_ARG:
 256                 case ACPI_REFCLASS_LOCAL:
 257                 case ACPI_REFCLASS_INDEX:
 258                 case ACPI_REFCLASS_REFOF:
 259                 case ACPI_REFCLASS_TABLE:    /* DdbHandle from LOAD_OP or LOAD_TABLE_OP */
 260                 case ACPI_REFCLASS_NAME:     /* Reference to a named object */
 261
 262                     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 263                         "Operand is a Reference, Class [%s] %2.2X\n",
 264                         AcpiUtGetReferenceName (ObjDesc),
 265                         ObjDesc->Reference.Class));
 266                     break;
 267
 268                 default:
 269
 270                     ACPI_ERROR ((AE_INFO,
 271                         "Unknown Reference Class 0x%2.2X in %p",
 272                         ObjDesc->Reference.Class, ObjDesc));
 273
 274                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 275                 }
 276             }
 277             break;
 278
 279         default:
 280
 281             /* Invalid descriptor */
 282
 283             ACPI_ERROR ((AE_INFO, "Invalid descriptor %p [%s]",
 284                 ObjDesc, AcpiUtGetDescriptorName (ObjDesc)));
 285
 286             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 287         }
 288
 289         /* Get one argument type, point to the next */
 290
 291         ThisArgType = GET_CURRENT_ARG_TYPE (ArgTypes);
 292         INCREMENT_ARG_LIST (ArgTypes);
 293
 294         /*
 295          * Handle cases where the object does not need to be
 296          * resolved to a value
 297          */
 298         switch (ThisArgType)
 299         {
 300         case ARGI_REF_OR_STRING:        /* Can be a String or Reference */
 301
 302             if ((ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND) &&
 303                 (ObjDesc->Common.Type == ACPI_TYPE_STRING))
 304             {
 305                 /*
 306                  * String found - the string references a named object and
 307                  * must be resolved to a node
 308                  */
 309                 goto NextOperand;
 310             }
 311
 312             /*
 313              * Else not a string - fall through to the normal Reference
 314              * case below
 315              */
 316             /*lint -fallthrough */
 317
 318         case ARGI_REFERENCE:            /* References: */
 319         case ARGI_INTEGER_REF:
 320         case ARGI_OBJECT_REF:
 321         case ARGI_DEVICE_REF:
 322         case ARGI_TARGETREF:     /* Allows implicit conversion rules before store */
 323         case ARGI_FIXED_TARGET:  /* No implicit conversion before store to target */
 324         case ARGI_SIMPLE_TARGET: /* Name, Local, or Arg - no implicit conversion  */
 325             /*
 326              * Need an operand of type ACPI_TYPE_LOCAL_REFERENCE
 327              * A Namespace Node is OK as-is
 328              */
 329             if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED)
 330             {
 331                 goto NextOperand;
 332             }
 333
 334             Status = AcpiExCheckObjectType (ACPI_TYPE_LOCAL_REFERENCE,
 335                             ObjectType, ObjDesc);
 336             if (ACPI_FAILURE (Status))
 337             {
 338                 return_ACPI_STATUS (Status);
 339             }
 340             goto NextOperand;
 341
 342         case ARGI_DATAREFOBJ:  /* Store operator only */
 343             /*
 344              * We don't want to resolve IndexOp reference objects during
 345              * a store because this would be an implicit DeRefOf operation.
 346              * Instead, we just want to store the reference object.
 347              * -- All others must be resolved below.
 348              */
 349             if ((Opcode == AML_STORE_OP) &&
 350                 ((*StackPtr)->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) &&
 351                 ((*StackPtr)->Reference.Class == ACPI_REFCLASS_INDEX))
 352             {
 353                 goto NextOperand;
 354             }
 355             break;
 356
 357         default:
 358
 359             /* All cases covered above */
 360
 361             break;
 362         }
 363
 364         /*
 365          * Resolve this object to a value
 366          */
 367         Status = AcpiExResolveToValue (StackPtr, WalkState);
 368         if (ACPI_FAILURE (Status))
 369         {
 370             return_ACPI_STATUS (Status);
 371         }
 372
 373         /* Get the resolved object */
 374
 375         ObjDesc = *StackPtr;
 376
 377         /*
 378          * Check the resulting object (value) type
 379          */
 380         switch (ThisArgType)
 381         {
 382         /*
 383          * For the simple cases, only one type of resolved object
 384          * is allowed
 385          */
 386         case ARGI_MUTEX:
 387
 388             /* Need an operand of type ACPI_TYPE_MUTEX */
 389
 390             TypeNeeded = ACPI_TYPE_MUTEX;
 391             break;
 392
 393         case ARGI_EVENT:
 394
 395             /* Need an operand of type ACPI_TYPE_EVENT */
 396
 397             TypeNeeded = ACPI_TYPE_EVENT;
 398             break;
 399
 400         case ARGI_PACKAGE:   /* Package */
 401
 402             /* Need an operand of type ACPI_TYPE_PACKAGE */
 403
 404             TypeNeeded = ACPI_TYPE_PACKAGE;
 405             break;
 406
 407         case ARGI_ANYTYPE:
 408
 409             /* Any operand type will do */
 410
 411             TypeNeeded = ACPI_TYPE_ANY;
 412             break;
 413
 414         case ARGI_DDBHANDLE:
 415
 416             /* Need an operand of type ACPI_TYPE_DDB_HANDLE */
 417
 418             TypeNeeded = ACPI_TYPE_LOCAL_REFERENCE;
 419             break;
 420
 421
 422         /*
 423          * The more complex cases allow multiple resolved object types
 424          */
 425         case ARGI_INTEGER:
 426
 427             /*
 428              * Need an operand of type ACPI_TYPE_INTEGER,
 429              * But we can implicitly convert from a STRING or BUFFER
 430              * Aka - "Implicit Source Operand Conversion"
 431              */
 432             Status = AcpiExConvertToInteger (ObjDesc, StackPtr, 16);
 433             if (ACPI_FAILURE (Status))
 434             {
 435                 if (Status == AE_TYPE)
 436                 {
 437                     ACPI_ERROR ((AE_INFO,
 438                         "Needed [Integer/String/Buffer], found [%s] %p",
 439                         AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 440
 441                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 442                 }
 443
 444                 return_ACPI_STATUS (Status);
 445             }
 446
 447             if (ObjDesc != *StackPtr)
 448             {
 449                 AcpiUtRemoveReference (ObjDesc);
 450             }
 451             goto NextOperand;
 452
 453         case ARGI_BUFFER:
 454             /*
 455              * Need an operand of type ACPI_TYPE_BUFFER,
 456              * But we can implicitly convert from a STRING or INTEGER
 457              * Aka - "Implicit Source Operand Conversion"
 458              */
 459             Status = AcpiExConvertToBuffer (ObjDesc, StackPtr);
 460             if (ACPI_FAILURE (Status))
 461             {
 462                 if (Status == AE_TYPE)
 463                 {
 464                     ACPI_ERROR ((AE_INFO,
 465                         "Needed [Integer/String/Buffer], found [%s] %p",
 466                         AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 467
 468                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 469                 }
 470
 471                 return_ACPI_STATUS (Status);
 472             }
 473
 474             if (ObjDesc != *StackPtr)
 475             {
 476                 AcpiUtRemoveReference (ObjDesc);
 477             }
 478             goto NextOperand;
 479
 480         case ARGI_STRING:
 481             /*
 482              * Need an operand of type ACPI_TYPE_STRING,
 483              * But we can implicitly convert from a BUFFER or INTEGER
 484              * Aka - "Implicit Source Operand Conversion"
 485              */
 486             Status = AcpiExConvertToString (ObjDesc, StackPtr,
 487                         ACPI_IMPLICIT_CONVERT_HEX);
 488             if (ACPI_FAILURE (Status))
 489             {
 490                 if (Status == AE_TYPE)
 491                 {
 492                     ACPI_ERROR ((AE_INFO,
 493                         "Needed [Integer/String/Buffer], found [%s] %p",
 494                         AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 495
 496                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 497                 }
 498
 499                 return_ACPI_STATUS (Status);
 500             }
 501
 502             if (ObjDesc != *StackPtr)
 503             {
 504                 AcpiUtRemoveReference (ObjDesc);
 505             }
 506             goto NextOperand;
 507
 508         case ARGI_COMPUTEDATA:
 509
 510             /* Need an operand of type INTEGER, STRING or BUFFER */
 511
 512             switch (ObjDesc->Common.Type)
 513             {
 514             case ACPI_TYPE_INTEGER:
 515             case ACPI_TYPE_STRING:
 516             case ACPI_TYPE_BUFFER:
 517
 518                 /* Valid operand */
 519                break;
 520
 521             default:
 522                 ACPI_ERROR ((AE_INFO,
 523                     "Needed [Integer/String/Buffer], found [%s] %p",
 524                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 525
 526                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 527             }
 528             goto NextOperand;
 529
 530         case ARGI_BUFFER_OR_STRING:
 531
 532             /* Need an operand of type STRING or BUFFER */
 533
 534             switch (ObjDesc->Common.Type)
 535             {
 536             case ACPI_TYPE_STRING:
 537             case ACPI_TYPE_BUFFER:
 538
 539                 /* Valid operand */
 540                break;
 541
 542             case ACPI_TYPE_INTEGER:
 543
 544                 /* Highest priority conversion is to type Buffer */
 545
 546                 Status = AcpiExConvertToBuffer (ObjDesc, StackPtr);
 547                 if (ACPI_FAILURE (Status))
 548                 {
 549                     return_ACPI_STATUS (Status);
 550                 }
 551
 552                 if (ObjDesc != *StackPtr)
 553                 {
 554                     AcpiUtRemoveReference (ObjDesc);
 555                 }
 556                 break;
 557
 558             default:
 559                 ACPI_ERROR ((AE_INFO,
 560                     "Needed [Integer/String/Buffer], found [%s] %p",
 561                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 562
 563                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 564             }
 565             goto NextOperand;
 566
 567         case ARGI_DATAOBJECT:
 568             /*
 569              * ARGI_DATAOBJECT is only used by the SizeOf operator.
 570              * Need a buffer, string, package, or RefOf reference.
 571              *
 572              * The only reference allowed here is a direct reference to
 573              * a namespace node.
 574              */
 575             switch (ObjDesc->Common.Type)
 576             {
 577             case ACPI_TYPE_PACKAGE:
 578             case ACPI_TYPE_STRING:
 579             case ACPI_TYPE_BUFFER:
 580             case ACPI_TYPE_LOCAL_REFERENCE:
 581
 582                 /* Valid operand */
 583                 break;
 584
 585             default:
 586
 587                 ACPI_ERROR ((AE_INFO,
 588                     "Needed [Buffer/String/Package/Reference], found [%s] %p",
 589                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 590
 591                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 592             }
 593             goto NextOperand;
 594
 595         case ARGI_COMPLEXOBJ:
 596
 597             /* Need a buffer or package or (ACPI 2.0) String */
 598
 599             switch (ObjDesc->Common.Type)
 600             {
 601             case ACPI_TYPE_PACKAGE:
 602             case ACPI_TYPE_STRING:
 603             case ACPI_TYPE_BUFFER:
 604
 605                 /* Valid operand */
 606                 break;
 607
 608             default:
 609
 610                 ACPI_ERROR ((AE_INFO,
 611                     "Needed [Buffer/String/Package], found [%s] %p",
 612                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 613
 614                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 615             }
 616             goto NextOperand;
 617
 618         case ARGI_REGION_OR_BUFFER: /* Used by Load() only */
 619
 620             /* Need an operand of type REGION or a BUFFER (which could be a resolved region field) */
 621
 622             switch (ObjDesc->Common.Type)
 623             {
 624             case ACPI_TYPE_BUFFER:
 625             case ACPI_TYPE_REGION:
 626
 627                 /* Valid operand */
 628                 break;
 629
 630             default:
 631
 632                 ACPI_ERROR ((AE_INFO,
 633                     "Needed [Region/Buffer], found [%s] %p",
 634                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 635
 636                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 637             }
 638             goto NextOperand;
 639
 640         case ARGI_DATAREFOBJ:
 641
 642             /* Used by the Store() operator only */
 643
 644             switch (ObjDesc->Common.Type)
 645             {
 646             case ACPI_TYPE_INTEGER:
 647             case ACPI_TYPE_PACKAGE:
 648             case ACPI_TYPE_STRING:
 649             case ACPI_TYPE_BUFFER:
 650             case ACPI_TYPE_BUFFER_FIELD:
 651             case ACPI_TYPE_LOCAL_REFERENCE:
 652             case ACPI_TYPE_LOCAL_REGION_FIELD:
 653             case ACPI_TYPE_LOCAL_BANK_FIELD:
 654             case ACPI_TYPE_LOCAL_INDEX_FIELD:
 655             case ACPI_TYPE_DDB_HANDLE:
 656
 657                 /* Valid operand */
 658                 break;
 659
 660             default:
 661
 662                 if (AcpiGbl_EnableInterpreterSlack)
 663                 {
 664                     /*
 665                      * Enable original behavior of Store(), allowing any and all
 666                      * objects as the source operand. The ACPI spec does not
 667                      * allow this, however.
 668                      */
 669                     break;
 670                 }
 671
 672                 if (TargetOp == AML_DEBUG_OP)
 673                 {
 674                     /* Allow store of any object to the Debug object */
 675
 676                     break;
 677                 }
 678
 679                 ACPI_ERROR ((AE_INFO,
 680                     "Needed Integer/Buffer/String/Package/Ref/Ddb], found [%s] %p",
 681                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 682
 683                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 684             }
 685             goto NextOperand;
 686
 687         default:
 688
 689             /* Unknown type */
 690
 691             ACPI_ERROR ((AE_INFO,
 692                 "Internal - Unknown ARGI (required operand) type 0x%X",
 693                 ThisArgType));
 694
 695             return_ACPI_STATUS (AE_BAD_PARAMETER);
 696         }
 697
 698         /*
 699          * Make sure that the original object was resolved to the
 700          * required object type (Simple cases only).
 701          */
 702         Status = AcpiExCheckObjectType (TypeNeeded,
 703                         (*StackPtr)->Common.Type, *StackPtr);
 704         if (ACPI_FAILURE (Status))
 705         {
 706             return_ACPI_STATUS (Status);
 707         }
 708
 709 NextOperand:
 710         /*
 711          * If more operands needed, decrement StackPtr to point
 712          * to next operand on stack
 713          */
 714         if (GET_CURRENT_ARG_TYPE (ArgTypes))
 715         {
 716             StackPtr--;
 717         }
 718     }
 719
 720     ACPI_DUMP_OPERANDS (WalkState->Operands,
 721         AcpiPsGetOpcodeName (Opcode), WalkState->NumOperands);
 722
 723     return_ACPI_STATUS (Status);
 724 }