sys/contrib/dev/acpica/exresop.c

   1 /* $DragonFly: src/sys/contrib/dev/acpica/Attic/exresop.c,v 1.1 2003/09/24 03:32:16 drhodus Exp $                                                               */
   2 /******************************************************************************
   3  *
   4  * Module Name: exresop - AML Interpreter operand/object resolution
   5  *              $Revision: 62 $
   6  *
   7  *****************************************************************************/
   8
   9 /******************************************************************************
  10  *
  11  * 1. Copyright Notice
  12  *
  13  * Some or all of this work - Copyright (c) 1999 - 2003, Intel Corp.
  14  * All rights reserved.
  15  *
  16  * 2. License
  17  *
  18  * 2.1. This is your license from Intel Corp. under its intellectual property
  19  * rights.  You may have additional license terms from the party that provided
  20  * you this software, covering your right to use that party's intellectual
  21  * property rights.
  22  *
  23  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  24  * copy of the source code appearing in this file ("Covered Code") an
  25  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  26  * base code distributed originally by Intel ("Original Intel Code") to copy,
  27  * make derivatives, distribute, use and display any portion of the Covered
  28  * Code in any form, with the right to sublicense such rights; and
  29  *
  30  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  31  * license (with the right to sublicense), under only those claims of Intel
  32  * patents that are infringed by the Original Intel Code, to make, use, sell,
  33  * offer to sell, and import the Covered Code and derivative works thereof
  34  * solely to the minimum extent necessary to exercise the above copyright
  35  * license, and in no event shall the patent license extend to any additions
  36  * to or modifications of the Original Intel Code.  No other license or right
  37  * is granted directly or by implication, estoppel or otherwise;
  38  *
  39  * The above copyright and patent license is granted only if the following
  40  * conditions are met:
  41  *
  42  * 3. Conditions
  43  *
  44  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  45  * Redistribution of source code of any substantial portion of the Covered
  46  * Code or modification with rights to further distribute source must include
  47  * the above Copyright Notice, the above License, this list of Conditions,
  48  * and the following Disclaimer and Export Compliance provision.  In addition,
  49  * Licensee must cause all Covered Code to which Licensee contributes to
  50  * contain a file documenting the changes Licensee made to create that Covered
  51  * Code and the date of any change.  Licensee must include in that file the
  52  * documentation of any changes made by any predecessor Licensee.  Licensee
  53  * must include a prominent statement that the modification is derived,
  54  * directly or indirectly, from Original Intel Code.
  55  *
  56  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  57  * Redistribution of source code of any substantial portion of the Covered
  58  * Code or modification without rights to further distribute source must
  59  * include the following Disclaimer and Export Compliance provision in the
  60  * documentation and/or other materials provided with distribution.  In
  61  * addition, Licensee may not authorize further sublicense of source of any
  62  * portion of the Covered Code, and must include terms to the effect that the
  63  * license from Licensee to its licensee is limited to the intellectual
  64  * property embodied in the software Licensee provides to its licensee, and
  65  * not to intellectual property embodied in modifications its licensee may
  66  * make.
  67  *
  68  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  69  * substantial portion of the Covered Code or modification must reproduce the
  70  * above Copyright Notice, and the following Disclaimer and Export Compliance
  71  * provision in the documentation and/or other materials provided with the
  72  * distribution.
  73  *
  74  * 3.4. Intel retains all right, title, and interest in and to the Original
  75  * Intel Code.
  76  *
  77  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  78  * Intel shall be used in advertising or otherwise to promote the sale, use or
  79  * other dealings in products derived from or relating to the Covered Code
  80  * without prior written authorization from Intel.
  81  *
  82  * 4. Disclaimer and Export Compliance
  83  *
  84  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  85  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  86  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  87  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  90  * PARTICULAR PURPOSE.
  91  *
  92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  99  * LIMITED REMEDY.
 100  *
 101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 102  * software or system incorporating such software without first obtaining any
 103  * required license or other approval from the U. S. Department of Commerce or
 104  * any other agency or department of the United States Government.  In the
 105  * event Licensee exports any such software from the United States or
 106  * re-exports any such software from a foreign destination, Licensee shall
 107  * ensure that the distribution and export/re-export of the software is in
 108  * compliance with all laws, regulations, orders, or other restrictions of the
 109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 110  * any of its subsidiaries will export/re-export any technical data, process,
 111  * software, or service, directly or indirectly, to any country for which the
 112  * United States government or any agency thereof requires an export license,
 113  * other governmental approval, or letter of assurance, without first obtaining
 114  * such license, approval or letter.
 115  *
 116  *****************************************************************************/
 117
 118 #define __EXRESOP_C__
 119
 120 #include "acpi.h"
 121 #include "amlcode.h"
 122 #include "acparser.h"
 123 #include "acinterp.h"
 124
 125
 126 #define _COMPONENT          ACPI_EXECUTER
 127         ACPI_MODULE_NAME    ("exresop")
 128
 129
 130 /*******************************************************************************
 131  *
 132  * FUNCTION:    AcpiExCheckObjectType
 133  *
 134  * PARAMETERS:  TypeNeeded          Object type needed
 135  *              ThisType            Actual object type
 136  *              Object              Object pointer
 137  *
 138  * RETURN:      Status
 139  *
 140  * DESCRIPTION: Check required type against actual type
 141  *
 142  ******************************************************************************/
 143
 144 ACPI_STATUS
 145 AcpiExCheckObjectType (
 146     ACPI_OBJECT_TYPE        TypeNeeded,
 147     ACPI_OBJECT_TYPE        ThisType,
 148     void                    *Object)
 149 {
 150     ACPI_FUNCTION_NAME ("ExCheckObjectType");
 151
 152
 153     if (TypeNeeded == ACPI_TYPE_ANY)
 154     {
 155         /* All types OK, so we don't perform any typechecks */
 156
 157         return (AE_OK);
 158     }
 159
 160     if (TypeNeeded == ACPI_TYPE_LOCAL_REFERENCE)
 161     {
 162         /*
 163          * Allow the AML "Constant" opcodes (Zero, One, etc.) to be reference
 164          * objects and thus allow them to be targets.  (As per the ACPI
 165          * specification, a store to a constant is a noop.)
 166          */
 167         if ((ThisType == ACPI_TYPE_INTEGER) &&
 168             (((ACPI_OPERAND_OBJECT *) Object)->Common.Flags & AOPOBJ_AML_CONSTANT))
 169         {
 170             return (AE_OK);
 171         }
 172     }
 173
 174     if (TypeNeeded != ThisType)
 175     {
 176         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 177             "Needed [%s], found [%s] %p\n",
 178             AcpiUtGetTypeName (TypeNeeded),
 179             AcpiUtGetTypeName (ThisType), Object));
 180
 181         return (AE_AML_OPERAND_TYPE);
 182     }
 183
 184     return (AE_OK);
 185 }
 186
 187
 188 /*******************************************************************************
 189  *
 190  * FUNCTION:    AcpiExResolveOperands
 191  *
 192  * PARAMETERS:  Opcode              - Opcode being interpreted
 193  *              StackPtr            - Pointer to the operand stack to be
 194  *                                    resolved
 195  *              WalkState           - Current state
 196  *
 197  * RETURN:      Status
 198  *
 199  * DESCRIPTION: Convert multiple input operands to the types required by the
 200  *              target operator.
 201  *
 202  *      Each 5-bit group in ArgTypes represents one required
 203  *      operand and indicates the required Type. The corresponding operand
 204  *      will be converted to the required type if possible, otherwise we
 205  *      abort with an exception.
 206  *
 207  ******************************************************************************/
 208
 209 ACPI_STATUS
 210 AcpiExResolveOperands (
 211     UINT16                  Opcode,
 212     ACPI_OPERAND_OBJECT     **StackPtr,
 213     ACPI_WALK_STATE         *WalkState)
 214 {
 215     ACPI_OPERAND_OBJECT     *ObjDesc;
 216     ACPI_STATUS             Status = AE_OK;
 217     UINT8                   ObjectType;
 218     void                    *TempNode;
 219     UINT32                  ArgTypes;
 220     const ACPI_OPCODE_INFO  *OpInfo;
 221     UINT32                  ThisArgType;
 222     ACPI_OBJECT_TYPE        TypeNeeded;
 223
 224
 225     ACPI_FUNCTION_TRACE_U32 ("ExResolveOperands", Opcode);
 226
 227
 228     OpInfo = AcpiPsGetOpcodeInfo (Opcode);
 229     if (OpInfo->Class == AML_CLASS_UNKNOWN)
 230     {
 231         return_ACPI_STATUS (AE_AML_BAD_OPCODE);
 232     }
 233
 234     ArgTypes = OpInfo->RuntimeArgs;
 235     if (ArgTypes == ARGI_INVALID_OPCODE)
 236     {
 237         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - %X is not a valid AML opcode\n",
 238             Opcode));
 239
 240         return_ACPI_STATUS (AE_AML_INTERNAL);
 241     }
 242
 243     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Opcode %X [%s] OperandTypes=%X \n",
 244         Opcode, OpInfo->Name, ArgTypes));
 245
 246     /*
 247      * Normal exit is with (ArgTypes == 0) at end of argument list.
 248      * Function will return an exception from within the loop upon
 249      * finding an entry which is not (or cannot be converted
 250      * to) the required type; if stack underflows; or upon
 251      * finding a NULL stack entry (which should not happen).
 252      */
 253     while (GET_CURRENT_ARG_TYPE (ArgTypes))
 254     {
 255         if (!StackPtr || !*StackPtr)
 256         {
 257             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - null stack entry at %p\n",
 258                 StackPtr));
 259
 260             return_ACPI_STATUS (AE_AML_INTERNAL);
 261         }
 262
 263         /* Extract useful items */
 264
 265         ObjDesc = *StackPtr;
 266
 267         /* Decode the descriptor type */
 268
 269         switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc))
 270         {
 271         case ACPI_DESC_TYPE_NAMED:
 272
 273             /* Node */
 274
 275             ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type;
 276             break;
 277
 278
 279         case ACPI_DESC_TYPE_OPERAND:
 280
 281             /* ACPI internal object */
 282
 283             ObjectType = ACPI_GET_OBJECT_TYPE (ObjDesc);
 284
 285             /* Check for bad ACPI_OBJECT_TYPE */
 286
 287             if (!AcpiUtValidObjectType (ObjectType))
 288             {
 289                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Bad operand object type [%X]\n",
 290                     ObjectType));
 291
 292                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 293             }
 294
 295             if (ObjectType == (UINT8) ACPI_TYPE_LOCAL_REFERENCE)
 296             {
 297                 /*
 298                  * Decode the Reference
 299                  */
 300                 OpInfo = AcpiPsGetOpcodeInfo (Opcode);
 301                 if (OpInfo->Class == AML_CLASS_UNKNOWN)
 302                 {
 303                     return_ACPI_STATUS (AE_AML_BAD_OPCODE);
 304                 }
 305
 306                 switch (ObjDesc->Reference.Opcode)
 307                 {
 308                 case AML_DEBUG_OP:
 309                 case AML_NAME_OP:
 310                 case AML_INDEX_OP:
 311                 case AML_REF_OF_OP:
 312                 case AML_ARG_OP:
 313                 case AML_LOCAL_OP:
 314
 315                     ACPI_DEBUG_ONLY_MEMBERS (ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 316                         "Reference Opcode: %s\n", OpInfo->Name)));
 317                     break;
 318
 319                 default:
 320                     ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 321                         "Unknown Reference Opcode %X\n",
 322                         ObjDesc->Reference.Opcode));
 323
 324                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 325                 }
 326             }
 327             break;
 328
 329
 330         default:
 331
 332             /* Invalid descriptor */
 333
 334             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 335                 "Bad descriptor type %X in Obj %p\n",
 336                 ACPI_GET_DESCRIPTOR_TYPE (ObjDesc), ObjDesc));
 337
 338             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 339         }
 340
 341
 342         /*
 343          * Get one argument type, point to the next
 344          */
 345         ThisArgType = GET_CURRENT_ARG_TYPE (ArgTypes);
 346         INCREMENT_ARG_LIST (ArgTypes);
 347
 348         /*
 349          * Handle cases where the object does not need to be
 350          * resolved to a value
 351          */
 352         switch (ThisArgType)
 353         {
 354         case ARGI_REF_OR_STRING:        /* Can be a String or Reference */
 355
 356             if ((ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND) &&
 357                 (ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_STRING))
 358             {
 359                 /*
 360                  * String found - the string references a named object and must be
 361                  * resolved to a node
 362                  */
 363                 goto NextOperand;
 364             }
 365
 366             /* Else not a string - fall through to the normal Reference case below */
 367             /*lint -fallthrough */
 368
 369         case ARGI_REFERENCE:            /* References: */
 370         case ARGI_INTEGER_REF:
 371         case ARGI_OBJECT_REF:
 372         case ARGI_DEVICE_REF:
 373         case ARGI_TARGETREF:            /* Allows implicit conversion rules before store */
 374         case ARGI_FIXED_TARGET:         /* No implicit conversion before store to target */
 375         case ARGI_SIMPLE_TARGET:        /* Name, Local, or Arg - no implicit conversion  */
 376
 377             /* Need an operand of type ACPI_TYPE_LOCAL_REFERENCE */
 378
 379             if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED) /* Node (name) ptr OK as-is */
 380             {
 381                 goto NextOperand;
 382             }
 383
 384             Status = AcpiExCheckObjectType (ACPI_TYPE_LOCAL_REFERENCE,
 385                             ObjectType, ObjDesc);
 386             if (ACPI_FAILURE (Status))
 387             {
 388                 return_ACPI_STATUS (Status);
 389             }
 390
 391             if (AML_NAME_OP == ObjDesc->Reference.Opcode)
 392             {
 393                 /*
 394                  * Convert an indirect name ptr to direct name ptr and put
 395                  * it on the stack
 396                  */
 397                 TempNode = ObjDesc->Reference.Object;
 398                 AcpiUtRemoveReference (ObjDesc);
 399                 (*StackPtr) = TempNode;
 400             }
 401             goto NextOperand;
 402
 403
 404         case ARGI_ANYTYPE:
 405
 406             /*
 407              * We don't want to resolve IndexOp reference objects during
 408              * a store because this would be an implicit DeRefOf operation.
 409              * Instead, we just want to store the reference object.
 410              * -- All others must be resolved below.
 411              */
 412             if ((Opcode == AML_STORE_OP) &&
 413                 (ACPI_GET_OBJECT_TYPE (*StackPtr) == ACPI_TYPE_LOCAL_REFERENCE) &&
 414                 ((*StackPtr)->Reference.Opcode == AML_INDEX_OP))
 415             {
 416                 goto NextOperand;
 417             }
 418             break;
 419
 420         default:
 421             /* All cases covered above */
 422             break;
 423         }
 424
 425
 426         /*
 427          * Resolve this object to a value
 428          */
 429         Status = AcpiExResolveToValue (StackPtr, WalkState);
 430         if (ACPI_FAILURE (Status))
 431         {
 432             return_ACPI_STATUS (Status);
 433         }
 434
 435         /* Get the resolved object */
 436
 437         ObjDesc = *StackPtr;
 438
 439         /*
 440          * Check the resulting object (value) type
 441          */
 442         switch (ThisArgType)
 443         {
 444         /*
 445          * For the simple cases, only one type of resolved object
 446          * is allowed
 447          */
 448         case ARGI_MUTEX:
 449
 450             /* Need an operand of type ACPI_TYPE_MUTEX */
 451
 452             TypeNeeded = ACPI_TYPE_MUTEX;
 453             break;
 454
 455         case ARGI_EVENT:
 456
 457             /* Need an operand of type ACPI_TYPE_EVENT */
 458
 459             TypeNeeded = ACPI_TYPE_EVENT;
 460             break;
 461
 462         case ARGI_PACKAGE:   /* Package */
 463
 464             /* Need an operand of type ACPI_TYPE_PACKAGE */
 465
 466             TypeNeeded = ACPI_TYPE_PACKAGE;
 467             break;
 468
 469         case ARGI_ANYTYPE:
 470
 471             /* Any operand type will do */
 472
 473             TypeNeeded = ACPI_TYPE_ANY;
 474             break;
 475
 476
 477         /*
 478          * The more complex cases allow multiple resolved object types
 479          */
 480         case ARGI_INTEGER:   /* Number */
 481
 482             /*
 483              * Need an operand of type ACPI_TYPE_INTEGER,
 484              * But we can implicitly convert from a STRING or BUFFER
 485              * Aka - "Implicit Source Operand Conversion"
 486              */
 487             Status = AcpiExConvertToInteger (ObjDesc, StackPtr, WalkState);
 488             if (ACPI_FAILURE (Status))
 489             {
 490                 if (Status == AE_TYPE)
 491                 {
 492                     ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 493                         "Needed [Integer/String/Buffer], found [%s] %p\n",
 494                         AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 495
 496                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 497                 }
 498
 499                 return_ACPI_STATUS (Status);
 500             }
 501             goto NextOperand;
 502
 503
 504         case ARGI_BUFFER:
 505
 506             /*
 507              * Need an operand of type ACPI_TYPE_BUFFER,
 508              * But we can implicitly convert from a STRING or INTEGER
 509              * Aka - "Implicit Source Operand Conversion"
 510              */
 511             Status = AcpiExConvertToBuffer (ObjDesc, StackPtr, WalkState);
 512             if (ACPI_FAILURE (Status))
 513             {
 514                 if (Status == AE_TYPE)
 515                 {
 516                     ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 517                         "Needed [Integer/String/Buffer], found [%s] %p\n",
 518                         AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 519
 520                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 521                 }
 522
 523                 return_ACPI_STATUS (Status);
 524             }
 525             goto NextOperand;
 526
 527
 528         case ARGI_STRING:
 529
 530             /*
 531              * Need an operand of type ACPI_TYPE_STRING,
 532              * But we can implicitly convert from a BUFFER or INTEGER
 533              * Aka - "Implicit Source Operand Conversion"
 534              */
 535             Status = AcpiExConvertToString (ObjDesc, StackPtr, 16, ACPI_UINT32_MAX, WalkState);
 536             if (ACPI_FAILURE (Status))
 537             {
 538                 if (Status == AE_TYPE)
 539                 {
 540                     ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 541                         "Needed [Integer/String/Buffer], found [%s] %p\n",
 542                         AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 543
 544                     return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 545                 }
 546
 547                 return_ACPI_STATUS (Status);
 548             }
 549             goto NextOperand;
 550
 551
 552         case ARGI_COMPUTEDATA:
 553
 554             /* Need an operand of type INTEGER, STRING or BUFFER */
 555
 556             switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
 557             {
 558             case ACPI_TYPE_INTEGER:
 559             case ACPI_TYPE_STRING:
 560             case ACPI_TYPE_BUFFER:
 561
 562                 /* Valid operand */
 563                break;
 564
 565             default:
 566                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 567                     "Needed [Integer/String/Buffer], found [%s] %p\n",
 568                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 569
 570                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 571             }
 572             goto NextOperand;
 573
 574
 575         case ARGI_BUFFER_OR_STRING:
 576
 577             /* Need an operand of type STRING or BUFFER */
 578
 579             switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
 580             {
 581             case ACPI_TYPE_STRING:
 582             case ACPI_TYPE_BUFFER:
 583
 584                 /* Valid operand */
 585                break;
 586
 587             case ACPI_TYPE_INTEGER:
 588
 589                 /* Highest priority conversion is to type Buffer */
 590
 591                 Status = AcpiExConvertToBuffer (ObjDesc, StackPtr, WalkState);
 592                 if (ACPI_FAILURE (Status))
 593                 {
 594                     return_ACPI_STATUS (Status);
 595                 }
 596                 break;
 597
 598             default:
 599                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 600                     "Needed [Integer/String/Buffer], found [%s] %p\n",
 601                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 602
 603                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 604             }
 605             goto NextOperand;
 606
 607
 608         case ARGI_DATAOBJECT:
 609             /*
 610              * ARGI_DATAOBJECT is only used by the SizeOf operator.
 611              * Need a buffer, string, package, or RefOf reference.
 612              *
 613              * The only reference allowed here is a direct reference to
 614              * a namespace node.
 615              */
 616             switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
 617             {
 618             case ACPI_TYPE_PACKAGE:
 619             case ACPI_TYPE_STRING:
 620             case ACPI_TYPE_BUFFER:
 621             case ACPI_TYPE_LOCAL_REFERENCE:
 622
 623                 /* Valid operand */
 624                 break;
 625
 626             default:
 627                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 628                     "Needed [Buffer/String/Package/Reference], found [%s] %p\n",
 629                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 630
 631                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 632             }
 633             goto NextOperand;
 634
 635
 636         case ARGI_COMPLEXOBJ:
 637
 638             /* Need a buffer or package or (ACPI 2.0) String */
 639
 640             switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
 641             {
 642             case ACPI_TYPE_PACKAGE:
 643             case ACPI_TYPE_STRING:
 644             case ACPI_TYPE_BUFFER:
 645
 646                 /* Valid operand */
 647                 break;
 648
 649             default:
 650                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 651                     "Needed [Buffer/String/Package], found [%s] %p\n",
 652                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 653
 654                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 655             }
 656             goto NextOperand;
 657
 658
 659         case ARGI_REGION_OR_FIELD:
 660
 661             /* Need an operand of type ACPI_TYPE_REGION or a FIELD in a region */
 662
 663             switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
 664             {
 665             case ACPI_TYPE_REGION:
 666             case ACPI_TYPE_LOCAL_REGION_FIELD:
 667             case ACPI_TYPE_LOCAL_BANK_FIELD:
 668             case ACPI_TYPE_LOCAL_INDEX_FIELD:
 669
 670                 /* Valid operand */
 671                 break;
 672
 673             default:
 674                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 675                     "Needed [Region/RegionField], found [%s] %p\n",
 676                     AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 677
 678                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 679             }
 680             goto NextOperand;
 681
 682
 683         default:
 684
 685             /* Unknown type */
 686
 687             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 688                 "Internal - Unknown ARGI (required operand) type %X\n",
 689                 ThisArgType));
 690
 691             return_ACPI_STATUS (AE_BAD_PARAMETER);
 692         }
 693
 694         /*
 695          * Make sure that the original object was resolved to the
 696          * required object type (Simple cases only).
 697          */
 698         Status = AcpiExCheckObjectType (TypeNeeded,
 699                         ACPI_GET_OBJECT_TYPE (*StackPtr), *StackPtr);
 700         if (ACPI_FAILURE (Status))
 701         {
 702             return_ACPI_STATUS (Status);
 703         }
 704
 705 NextOperand:
 706         /*
 707          * If more operands needed, decrement StackPtr to point
 708          * to next operand on stack
 709          */
 710         if (GET_CURRENT_ARG_TYPE (ArgTypes))
 711         {
 712             StackPtr--;
 713         }
 714
 715     }   /* while (*Types) */
 716
 717     return_ACPI_STATUS (Status);
 718 }
 719
 720