sys/contrib/dev/acpica/source/components/dispatcher/dsopcode.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dsopcode - Dispatcher support for regions and fields
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2016, 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 "amlcode.h"
  48 #include "acdispat.h"
  49 #include "acinterp.h"
  50 #include "acnamesp.h"
  51 #include "acevents.h"
  52 #include "actables.h"
  53
  54 #define _COMPONENT          ACPI_DISPATCHER
  55         ACPI_MODULE_NAME    ("dsopcode")
  56
  57 /* Local prototypes */
  58
  59 static ACPI_STATUS
  60 AcpiDsInitBufferField (
  61     UINT16                  AmlOpcode,
  62     ACPI_OPERAND_OBJECT     *ObjDesc,
  63     ACPI_OPERAND_OBJECT     *BufferDesc,
  64     ACPI_OPERAND_OBJECT     *OffsetDesc,
  65     ACPI_OPERAND_OBJECT     *LengthDesc,
  66     ACPI_OPERAND_OBJECT     *ResultDesc);
  67
  68
  69 /*******************************************************************************
  70  *
  71  * FUNCTION:    AcpiDsInitializeRegion
  72  *
  73  * PARAMETERS:  ObjHandle       - Region namespace node
  74  *
  75  * RETURN:      Status
  76  *
  77  * DESCRIPTION: Front end to EvInitializeRegion
  78  *
  79  ******************************************************************************/
  80
  81 ACPI_STATUS
  82 AcpiDsInitializeRegion (
  83     ACPI_HANDLE             ObjHandle)
  84 {
  85     ACPI_OPERAND_OBJECT     *ObjDesc;
  86     ACPI_STATUS             Status;
  87
  88
  89     ObjDesc = AcpiNsGetAttachedObject (ObjHandle);
  90
  91     /* Namespace is NOT locked */
  92
  93     Status = AcpiEvInitializeRegion (ObjDesc);
  94     return (Status);
  95 }
  96
  97
  98 /*******************************************************************************
  99  *
 100  * FUNCTION:    AcpiDsInitBufferField
 101  *
 102  * PARAMETERS:  AmlOpcode       - CreateXxxField
 103  *              ObjDesc         - BufferField object
 104  *              BufferDesc      - Host Buffer
 105  *              OffsetDesc      - Offset into buffer
 106  *              LengthDesc      - Length of field (CREATE_FIELD_OP only)
 107  *              ResultDesc      - Where to store the result
 108  *
 109  * RETURN:      Status
 110  *
 111  * DESCRIPTION: Perform actual initialization of a buffer field
 112  *
 113  ******************************************************************************/
 114
 115 static ACPI_STATUS
 116 AcpiDsInitBufferField (
 117     UINT16                  AmlOpcode,
 118     ACPI_OPERAND_OBJECT     *ObjDesc,
 119     ACPI_OPERAND_OBJECT     *BufferDesc,
 120     ACPI_OPERAND_OBJECT     *OffsetDesc,
 121     ACPI_OPERAND_OBJECT     *LengthDesc,
 122     ACPI_OPERAND_OBJECT     *ResultDesc)
 123 {
 124     UINT32                  Offset;
 125     UINT32                  BitOffset;
 126     UINT32                  BitCount;
 127     UINT8                   FieldFlags;
 128     ACPI_STATUS             Status;
 129
 130
 131     ACPI_FUNCTION_TRACE_PTR (DsInitBufferField, ObjDesc);
 132
 133
 134     /* Host object must be a Buffer */
 135
 136     if (BufferDesc->Common.Type != ACPI_TYPE_BUFFER)
 137     {
 138         ACPI_ERROR ((AE_INFO,
 139             "Target of Create Field is not a Buffer object - %s",
 140             AcpiUtGetObjectTypeName (BufferDesc)));
 141
 142         Status = AE_AML_OPERAND_TYPE;
 143         goto Cleanup;
 144     }
 145
 146     /*
 147      * The last parameter to all of these opcodes (ResultDesc) started
 148      * out as a NameString, and should therefore now be a NS node
 149      * after resolution in AcpiExResolveOperands().
 150      */
 151     if (ACPI_GET_DESCRIPTOR_TYPE (ResultDesc) != ACPI_DESC_TYPE_NAMED)
 152     {
 153         ACPI_ERROR ((AE_INFO,
 154             "(%s) destination not a NS Node [%s]",
 155             AcpiPsGetOpcodeName (AmlOpcode),
 156             AcpiUtGetDescriptorName (ResultDesc)));
 157
 158         Status = AE_AML_OPERAND_TYPE;
 159         goto Cleanup;
 160     }
 161
 162     Offset = (UINT32) OffsetDesc->Integer.Value;
 163
 164     /*
 165      * Setup the Bit offsets and counts, according to the opcode
 166      */
 167     switch (AmlOpcode)
 168     {
 169     case AML_CREATE_FIELD_OP:
 170
 171         /* Offset is in bits, count is in bits */
 172
 173         FieldFlags = AML_FIELD_ACCESS_BYTE;
 174         BitOffset  = Offset;
 175         BitCount   = (UINT32) LengthDesc->Integer.Value;
 176
 177         /* Must have a valid (>0) bit count */
 178
 179         if (BitCount == 0)
 180         {
 181             ACPI_ERROR ((AE_INFO,
 182                 "Attempt to CreateField of length zero"));
 183             Status = AE_AML_OPERAND_VALUE;
 184             goto Cleanup;
 185         }
 186         break;
 187
 188     case AML_CREATE_BIT_FIELD_OP:
 189
 190         /* Offset is in bits, Field is one bit */
 191
 192         BitOffset  = Offset;
 193         BitCount   = 1;
 194         FieldFlags = AML_FIELD_ACCESS_BYTE;
 195         break;
 196
 197     case AML_CREATE_BYTE_FIELD_OP:
 198
 199         /* Offset is in bytes, field is one byte */
 200
 201         BitOffset  = 8 * Offset;
 202         BitCount   = 8;
 203         FieldFlags = AML_FIELD_ACCESS_BYTE;
 204         break;
 205
 206     case AML_CREATE_WORD_FIELD_OP:
 207
 208         /* Offset is in bytes, field is one word */
 209
 210         BitOffset  = 8 * Offset;
 211         BitCount   = 16;
 212         FieldFlags = AML_FIELD_ACCESS_WORD;
 213         break;
 214
 215     case AML_CREATE_DWORD_FIELD_OP:
 216
 217         /* Offset is in bytes, field is one dword */
 218
 219         BitOffset  = 8 * Offset;
 220         BitCount   = 32;
 221         FieldFlags = AML_FIELD_ACCESS_DWORD;
 222         break;
 223
 224     case AML_CREATE_QWORD_FIELD_OP:
 225
 226         /* Offset is in bytes, field is one qword */
 227
 228         BitOffset  = 8 * Offset;
 229         BitCount   = 64;
 230         FieldFlags = AML_FIELD_ACCESS_QWORD;
 231         break;
 232
 233     default:
 234
 235         ACPI_ERROR ((AE_INFO,
 236             "Unknown field creation opcode 0x%02X",
 237             AmlOpcode));
 238         Status = AE_AML_BAD_OPCODE;
 239         goto Cleanup;
 240     }
 241
 242     /* Entire field must fit within the current length of the buffer */
 243
 244     if ((BitOffset + BitCount) >
 245         (8 * (UINT32) BufferDesc->Buffer.Length))
 246     {
 247         ACPI_ERROR ((AE_INFO,
 248             "Field [%4.4s] at %u exceeds Buffer [%4.4s] size %u (bits)",
 249             AcpiUtGetNodeName (ResultDesc),
 250             BitOffset + BitCount,
 251             AcpiUtGetNodeName (BufferDesc->Buffer.Node),
 252             8 * (UINT32) BufferDesc->Buffer.Length));
 253         Status = AE_AML_BUFFER_LIMIT;
 254         goto Cleanup;
 255     }
 256
 257     /*
 258      * Initialize areas of the field object that are common to all fields
 259      * For FieldFlags, use LOCK_RULE = 0 (NO_LOCK),
 260      * UPDATE_RULE = 0 (UPDATE_PRESERVE)
 261      */
 262     Status = AcpiExPrepCommonFieldObject (
 263         ObjDesc, FieldFlags, 0, BitOffset, BitCount);
 264     if (ACPI_FAILURE (Status))
 265     {
 266         goto Cleanup;
 267     }
 268
 269     ObjDesc->BufferField.BufferObj = BufferDesc;
 270
 271     /* Reference count for BufferDesc inherits ObjDesc count */
 272
 273     BufferDesc->Common.ReferenceCount = (UINT16)
 274         (BufferDesc->Common.ReferenceCount + ObjDesc->Common.ReferenceCount);
 275
 276
 277 Cleanup:
 278
 279     /* Always delete the operands */
 280
 281     AcpiUtRemoveReference (OffsetDesc);
 282     AcpiUtRemoveReference (BufferDesc);
 283
 284     if (AmlOpcode == AML_CREATE_FIELD_OP)
 285     {
 286         AcpiUtRemoveReference (LengthDesc);
 287     }
 288
 289     /* On failure, delete the result descriptor */
 290
 291     if (ACPI_FAILURE (Status))
 292     {
 293         AcpiUtRemoveReference (ResultDesc);     /* Result descriptor */
 294     }
 295     else
 296     {
 297         /* Now the address and length are valid for this BufferField */
 298
 299         ObjDesc->BufferField.Flags |= AOPOBJ_DATA_VALID;
 300     }
 301
 302     return_ACPI_STATUS (Status);
 303 }
 304
 305
 306 /*******************************************************************************
 307  *
 308  * FUNCTION:    AcpiDsEvalBufferFieldOperands
 309  *
 310  * PARAMETERS:  WalkState       - Current walk
 311  *              Op              - A valid BufferField Op object
 312  *
 313  * RETURN:      Status
 314  *
 315  * DESCRIPTION: Get BufferField Buffer and Index
 316  *              Called from AcpiDsExecEndOp during BufferField parse tree walk
 317  *
 318  ******************************************************************************/
 319
 320 ACPI_STATUS
 321 AcpiDsEvalBufferFieldOperands (
 322     ACPI_WALK_STATE         *WalkState,
 323     ACPI_PARSE_OBJECT       *Op)
 324 {
 325     ACPI_STATUS             Status;
 326     ACPI_OPERAND_OBJECT     *ObjDesc;
 327     ACPI_NAMESPACE_NODE     *Node;
 328     ACPI_PARSE_OBJECT       *NextOp;
 329
 330
 331     ACPI_FUNCTION_TRACE_PTR (DsEvalBufferFieldOperands, Op);
 332
 333
 334     /*
 335      * This is where we evaluate the address and length fields of the
 336      * CreateXxxField declaration
 337      */
 338     Node =  Op->Common.Node;
 339
 340     /* NextOp points to the op that holds the Buffer */
 341
 342     NextOp = Op->Common.Value.Arg;
 343
 344     /* Evaluate/create the address and length operands */
 345
 346     Status = AcpiDsCreateOperands (WalkState, NextOp);
 347     if (ACPI_FAILURE (Status))
 348     {
 349         return_ACPI_STATUS (Status);
 350     }
 351
 352     ObjDesc = AcpiNsGetAttachedObject (Node);
 353     if (!ObjDesc)
 354     {
 355         return_ACPI_STATUS (AE_NOT_EXIST);
 356     }
 357
 358     /* Resolve the operands */
 359
 360     Status = AcpiExResolveOperands (
 361         Op->Common.AmlOpcode, ACPI_WALK_OPERANDS, WalkState);
 362     if (ACPI_FAILURE (Status))
 363     {
 364         ACPI_ERROR ((AE_INFO, "(%s) bad operand(s), status 0x%X",
 365             AcpiPsGetOpcodeName (Op->Common.AmlOpcode), Status));
 366
 367         return_ACPI_STATUS (Status);
 368     }
 369
 370     /* Initialize the Buffer Field */
 371
 372     if (Op->Common.AmlOpcode == AML_CREATE_FIELD_OP)
 373     {
 374         /* NOTE: Slightly different operands for this opcode */
 375
 376         Status = AcpiDsInitBufferField (Op->Common.AmlOpcode, ObjDesc,
 377             WalkState->Operands[0], WalkState->Operands[1],
 378             WalkState->Operands[2], WalkState->Operands[3]);
 379     }
 380     else
 381     {
 382         /* All other, CreateXxxField opcodes */
 383
 384         Status = AcpiDsInitBufferField (Op->Common.AmlOpcode, ObjDesc,
 385             WalkState->Operands[0], WalkState->Operands[1],
 386             NULL, WalkState->Operands[2]);
 387     }
 388
 389     return_ACPI_STATUS (Status);
 390 }
 391
 392
 393 /*******************************************************************************
 394  *
 395  * FUNCTION:    AcpiDsEvalRegionOperands
 396  *
 397  * PARAMETERS:  WalkState       - Current walk
 398  *              Op              - A valid region Op object
 399  *
 400  * RETURN:      Status
 401  *
 402  * DESCRIPTION: Get region address and length
 403  *              Called from AcpiDsExecEndOp during OpRegion parse tree walk
 404  *
 405  ******************************************************************************/
 406
 407 ACPI_STATUS
 408 AcpiDsEvalRegionOperands (
 409     ACPI_WALK_STATE         *WalkState,
 410     ACPI_PARSE_OBJECT       *Op)
 411 {
 412     ACPI_STATUS             Status;
 413     ACPI_OPERAND_OBJECT     *ObjDesc;
 414     ACPI_OPERAND_OBJECT     *OperandDesc;
 415     ACPI_NAMESPACE_NODE     *Node;
 416     ACPI_PARSE_OBJECT       *NextOp;
 417
 418
 419     ACPI_FUNCTION_TRACE_PTR (DsEvalRegionOperands, Op);
 420
 421
 422     /*
 423      * This is where we evaluate the address and length fields of the
 424      * OpRegion declaration
 425      */
 426     Node =  Op->Common.Node;
 427
 428     /* NextOp points to the op that holds the SpaceID */
 429
 430     NextOp = Op->Common.Value.Arg;
 431
 432     /* NextOp points to address op */
 433
 434     NextOp = NextOp->Common.Next;
 435
 436     /* Evaluate/create the address and length operands */
 437
 438     Status = AcpiDsCreateOperands (WalkState, NextOp);
 439     if (ACPI_FAILURE (Status))
 440     {
 441         return_ACPI_STATUS (Status);
 442     }
 443
 444     /* Resolve the length and address operands to numbers */
 445
 446     Status = AcpiExResolveOperands (
 447         Op->Common.AmlOpcode, ACPI_WALK_OPERANDS, WalkState);
 448     if (ACPI_FAILURE (Status))
 449     {
 450         return_ACPI_STATUS (Status);
 451     }
 452
 453     ObjDesc = AcpiNsGetAttachedObject (Node);
 454     if (!ObjDesc)
 455     {
 456         return_ACPI_STATUS (AE_NOT_EXIST);
 457     }
 458
 459     /*
 460      * Get the length operand and save it
 461      * (at Top of stack)
 462      */
 463     OperandDesc = WalkState->Operands[WalkState->NumOperands - 1];
 464
 465     ObjDesc->Region.Length = (UINT32) OperandDesc->Integer.Value;
 466     AcpiUtRemoveReference (OperandDesc);
 467
 468     /*
 469      * Get the address and save it
 470      * (at top of stack - 1)
 471      */
 472     OperandDesc = WalkState->Operands[WalkState->NumOperands - 2];
 473
 474     ObjDesc->Region.Address = (ACPI_PHYSICAL_ADDRESS)
 475         OperandDesc->Integer.Value;
 476     AcpiUtRemoveReference (OperandDesc);
 477
 478     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "RgnObj %p Addr %8.8X%8.8X Len %X\n",
 479         ObjDesc, ACPI_FORMAT_UINT64 (ObjDesc->Region.Address),
 480         ObjDesc->Region.Length));
 481
 482     /* Now the address and length are valid for this opregion */
 483
 484     ObjDesc->Region.Flags |= AOPOBJ_DATA_VALID;
 485     return_ACPI_STATUS (Status);
 486 }
 487
 488
 489 /*******************************************************************************
 490  *
 491  * FUNCTION:    AcpiDsEvalTableRegionOperands
 492  *
 493  * PARAMETERS:  WalkState       - Current walk
 494  *              Op              - A valid region Op object
 495  *
 496  * RETURN:      Status
 497  *
 498  * DESCRIPTION: Get region address and length.
 499  *              Called from AcpiDsExecEndOp during DataTableRegion parse
 500  *              tree walk.
 501  *
 502  ******************************************************************************/
 503
 504 ACPI_STATUS
 505 AcpiDsEvalTableRegionOperands (
 506     ACPI_WALK_STATE         *WalkState,
 507     ACPI_PARSE_OBJECT       *Op)
 508 {
 509     ACPI_STATUS             Status;
 510     ACPI_OPERAND_OBJECT     *ObjDesc;
 511     ACPI_OPERAND_OBJECT     **Operand;
 512     ACPI_NAMESPACE_NODE     *Node;
 513     ACPI_PARSE_OBJECT       *NextOp;
 514     ACPI_TABLE_HEADER       *Table;
 515     UINT32                  TableIndex;
 516
 517
 518     ACPI_FUNCTION_TRACE_PTR (DsEvalTableRegionOperands, Op);
 519
 520
 521     /*
 522      * This is where we evaluate the Signature string, OemId string,
 523      * and OemTableId string of the Data Table Region declaration
 524      */
 525     Node =  Op->Common.Node;
 526
 527     /* NextOp points to Signature string op */
 528
 529     NextOp = Op->Common.Value.Arg;
 530
 531     /*
 532      * Evaluate/create the Signature string, OemId string,
 533      * and OemTableId string operands
 534      */
 535     Status = AcpiDsCreateOperands (WalkState, NextOp);
 536     if (ACPI_FAILURE (Status))
 537     {
 538         return_ACPI_STATUS (Status);
 539     }
 540
 541     Operand = &WalkState->Operands[0];
 542
 543     /*
 544      * Resolve the Signature string, OemId string,
 545      * and OemTableId string operands
 546      */
 547     Status = AcpiExResolveOperands (
 548         Op->Common.AmlOpcode, ACPI_WALK_OPERANDS, WalkState);
 549     if (ACPI_FAILURE (Status))
 550     {
 551         goto Cleanup;
 552     }
 553
 554     /* Find the ACPI table */
 555
 556     Status = AcpiTbFindTable (
 557         Operand[0]->String.Pointer,
 558         Operand[1]->String.Pointer,
 559         Operand[2]->String.Pointer, &TableIndex);
 560     if (ACPI_FAILURE (Status))
 561     {
 562         if (Status == AE_NOT_FOUND)
 563         {
 564             ACPI_ERROR ((AE_INFO,
 565                 "ACPI Table [%4.4s] OEM:(%s, %s) not found in RSDT/XSDT",
 566                 Operand[0]->String.Pointer,
 567                 Operand[1]->String.Pointer,
 568                 Operand[2]->String.Pointer));
 569         }
 570         goto Cleanup;
 571     }
 572
 573     Status = AcpiGetTableByIndex (TableIndex, &Table);
 574     if (ACPI_FAILURE (Status))
 575     {
 576         goto Cleanup;
 577     }
 578
 579     ObjDesc = AcpiNsGetAttachedObject (Node);
 580     if (!ObjDesc)
 581     {
 582         Status = AE_NOT_EXIST;
 583         goto Cleanup;
 584     }
 585
 586     ObjDesc->Region.Address = ACPI_PTR_TO_PHYSADDR (Table);
 587     ObjDesc->Region.Length = Table->Length;
 588
 589     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "RgnObj %p Addr %8.8X%8.8X Len %X\n",
 590         ObjDesc, ACPI_FORMAT_UINT64 (ObjDesc->Region.Address),
 591         ObjDesc->Region.Length));
 592
 593     /* Now the address and length are valid for this opregion */
 594
 595     ObjDesc->Region.Flags |= AOPOBJ_DATA_VALID;
 596
 597 Cleanup:
 598     AcpiUtRemoveReference (Operand[0]);
 599     AcpiUtRemoveReference (Operand[1]);
 600     AcpiUtRemoveReference (Operand[2]);
 601
 602     return_ACPI_STATUS (Status);
 603 }
 604
 605
 606 /*******************************************************************************
 607  *
 608  * FUNCTION:    AcpiDsEvalDataObjectOperands
 609  *
 610  * PARAMETERS:  WalkState       - Current walk
 611  *              Op              - A valid DataObject Op object
 612  *              ObjDesc         - DataObject
 613  *
 614  * RETURN:      Status
 615  *
 616  * DESCRIPTION: Get the operands and complete the following data object types:
 617  *              Buffer, Package.
 618  *
 619  ******************************************************************************/
 620
 621 ACPI_STATUS
 622 AcpiDsEvalDataObjectOperands (
 623     ACPI_WALK_STATE         *WalkState,
 624     ACPI_PARSE_OBJECT       *Op,
 625     ACPI_OPERAND_OBJECT     *ObjDesc)
 626 {
 627     ACPI_STATUS             Status;
 628     ACPI_OPERAND_OBJECT     *ArgDesc;
 629     UINT32                  Length;
 630
 631
 632     ACPI_FUNCTION_TRACE (DsEvalDataObjectOperands);
 633
 634
 635     /* The first operand (for all of these data objects) is the length */
 636
 637     /*
 638      * Set proper index into operand stack for AcpiDsObjStackPush
 639      * invoked inside AcpiDsCreateOperand.
 640      */
 641     WalkState->OperandIndex = WalkState->NumOperands;
 642
 643     Status = AcpiDsCreateOperand (WalkState, Op->Common.Value.Arg, 1);
 644     if (ACPI_FAILURE (Status))
 645     {
 646         return_ACPI_STATUS (Status);
 647     }
 648
 649     Status = AcpiExResolveOperands (WalkState->Opcode,
 650         &(WalkState->Operands [WalkState->NumOperands -1]),
 651         WalkState);
 652     if (ACPI_FAILURE (Status))
 653     {
 654         return_ACPI_STATUS (Status);
 655     }
 656
 657     /* Extract length operand */
 658
 659     ArgDesc = WalkState->Operands [WalkState->NumOperands - 1];
 660     Length = (UINT32) ArgDesc->Integer.Value;
 661
 662     /* Cleanup for length operand */
 663
 664     Status = AcpiDsObjStackPop (1, WalkState);
 665     if (ACPI_FAILURE (Status))
 666     {
 667         return_ACPI_STATUS (Status);
 668     }
 669
 670     AcpiUtRemoveReference (ArgDesc);
 671
 672     /*
 673      * Create the actual data object
 674      */
 675     switch (Op->Common.AmlOpcode)
 676     {
 677     case AML_BUFFER_OP:
 678
 679         Status = AcpiDsBuildInternalBufferObj (
 680             WalkState, Op, Length, &ObjDesc);
 681         break;
 682
 683     case AML_PACKAGE_OP:
 684     case AML_VAR_PACKAGE_OP:
 685
 686         Status = AcpiDsBuildInternalPackageObj (
 687             WalkState, Op, Length, &ObjDesc);
 688         break;
 689
 690     default:
 691
 692         return_ACPI_STATUS (AE_AML_BAD_OPCODE);
 693     }
 694
 695     if (ACPI_SUCCESS (Status))
 696     {
 697         /*
 698          * Return the object in the WalkState, unless the parent is a package -
 699          * in this case, the return object will be stored in the parse tree
 700          * for the package.
 701          */
 702         if ((!Op->Common.Parent) ||
 703             ((Op->Common.Parent->Common.AmlOpcode != AML_PACKAGE_OP) &&
 704              (Op->Common.Parent->Common.AmlOpcode != AML_VAR_PACKAGE_OP) &&
 705              (Op->Common.Parent->Common.AmlOpcode != AML_NAME_OP)))
 706         {
 707             WalkState->ResultObj = ObjDesc;
 708         }
 709     }
 710
 711     return_ACPI_STATUS (Status);
 712 }
 713
 714
 715 /*******************************************************************************
 716  *
 717  * FUNCTION:    AcpiDsEvalBankFieldOperands
 718  *
 719  * PARAMETERS:  WalkState       - Current walk
 720  *              Op              - A valid BankField Op object
 721  *
 722  * RETURN:      Status
 723  *
 724  * DESCRIPTION: Get BankField BankValue
 725  *              Called from AcpiDsExecEndOp during BankField parse tree walk
 726  *
 727  ******************************************************************************/
 728
 729 ACPI_STATUS
 730 AcpiDsEvalBankFieldOperands (
 731     ACPI_WALK_STATE         *WalkState,
 732     ACPI_PARSE_OBJECT       *Op)
 733 {
 734     ACPI_STATUS             Status;
 735     ACPI_OPERAND_OBJECT     *ObjDesc;
 736     ACPI_OPERAND_OBJECT     *OperandDesc;
 737     ACPI_NAMESPACE_NODE     *Node;
 738     ACPI_PARSE_OBJECT       *NextOp;
 739     ACPI_PARSE_OBJECT       *Arg;
 740
 741
 742     ACPI_FUNCTION_TRACE_PTR (DsEvalBankFieldOperands, Op);
 743
 744
 745     /*
 746      * This is where we evaluate the BankValue field of the
 747      * BankField declaration
 748      */
 749
 750     /* NextOp points to the op that holds the Region */
 751
 752     NextOp = Op->Common.Value.Arg;
 753
 754     /* NextOp points to the op that holds the Bank Register */
 755
 756     NextOp = NextOp->Common.Next;
 757
 758     /* NextOp points to the op that holds the Bank Value */
 759
 760     NextOp = NextOp->Common.Next;
 761
 762     /*
 763      * Set proper index into operand stack for AcpiDsObjStackPush
 764      * invoked inside AcpiDsCreateOperand.
 765      *
 766      * We use WalkState->Operands[0] to store the evaluated BankValue
 767      */
 768     WalkState->OperandIndex = 0;
 769
 770     Status = AcpiDsCreateOperand (WalkState, NextOp, 0);
 771     if (ACPI_FAILURE (Status))
 772     {
 773         return_ACPI_STATUS (Status);
 774     }
 775
 776     Status = AcpiExResolveToValue (&WalkState->Operands[0], WalkState);
 777     if (ACPI_FAILURE (Status))
 778     {
 779         return_ACPI_STATUS (Status);
 780     }
 781
 782     ACPI_DUMP_OPERANDS (ACPI_WALK_OPERANDS,
 783         AcpiPsGetOpcodeName (Op->Common.AmlOpcode), 1);
 784     /*
 785      * Get the BankValue operand and save it
 786      * (at Top of stack)
 787      */
 788     OperandDesc = WalkState->Operands[0];
 789
 790     /* Arg points to the start Bank Field */
 791
 792     Arg = AcpiPsGetArg (Op, 4);
 793     while (Arg)
 794     {
 795         /* Ignore OFFSET and ACCESSAS terms here */
 796
 797         if (Arg->Common.AmlOpcode == AML_INT_NAMEDFIELD_OP)
 798         {
 799             Node = Arg->Common.Node;
 800
 801             ObjDesc = AcpiNsGetAttachedObject (Node);
 802             if (!ObjDesc)
 803             {
 804                 return_ACPI_STATUS (AE_NOT_EXIST);
 805             }
 806
 807             ObjDesc->BankField.Value = (UINT32) OperandDesc->Integer.Value;
 808         }
 809
 810         /* Move to next field in the list */
 811
 812         Arg = Arg->Common.Next;
 813     }
 814
 815     AcpiUtRemoveReference (OperandDesc);
 816     return_ACPI_STATUS (Status);
 817 }