arch/all-pc/acpica/source/components/dispatcher/dsfield.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dsfield - Dispatcher field routines
   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 __DSFIELD_C__
  45
  46 #include "acpi.h"
  47 #include "accommon.h"
  48 #include "amlcode.h"
  49 #include "acdispat.h"
  50 #include "acinterp.h"
  51 #include "acnamesp.h"
  52 #include "acparser.h"
  53
  54
  55 #define _COMPONENT          ACPI_DISPATCHER
  56         ACPI_MODULE_NAME    ("dsfield")
  57
  58 /* Local prototypes */
  59
  60 #ifdef ACPI_ASL_COMPILER
  61 #include "acdisasm.h"
  62
  63 static ACPI_STATUS
  64 AcpiDsCreateExternalRegion (
  65     ACPI_STATUS             LookupStatus,
  66     ACPI_PARSE_OBJECT       *Op,
  67     char                    *Path,
  68     ACPI_WALK_STATE         *WalkState,
  69     ACPI_NAMESPACE_NODE     **Node);
  70 #endif
  71
  72 static ACPI_STATUS
  73 AcpiDsGetFieldNames (
  74     ACPI_CREATE_FIELD_INFO  *Info,
  75     ACPI_WALK_STATE         *WalkState,
  76     ACPI_PARSE_OBJECT       *Arg);
  77
  78
  79 #ifdef ACPI_ASL_COMPILER
  80 /*******************************************************************************
  81  *
  82  * FUNCTION:    AcpiDsCreateExternalRegion (iASL Disassembler only)
  83  *
  84  * PARAMETERS:  LookupStatus    - Status from NsLookup operation
  85  *              Op              - Op containing the Field definition and args
  86  *              Path            - Pathname of the region
  87  *  `           WalkState       - Current method state
  88  *              Node            - Where the new region node is returned
  89  *
  90  * RETURN:      Status
  91  *
  92  * DESCRIPTION: Add region to the external list if NOT_FOUND. Create a new
  93  *              region node/object.
  94  *
  95  ******************************************************************************/
  96
  97 static ACPI_STATUS
  98 AcpiDsCreateExternalRegion (
  99     ACPI_STATUS             LookupStatus,
 100     ACPI_PARSE_OBJECT       *Op,
 101     char                    *Path,
 102     ACPI_WALK_STATE         *WalkState,
 103     ACPI_NAMESPACE_NODE     **Node)
 104 {
 105     ACPI_STATUS             Status;
 106     ACPI_OPERAND_OBJECT     *ObjDesc;
 107
 108
 109     if (LookupStatus != AE_NOT_FOUND)
 110     {
 111         return (LookupStatus);
 112     }
 113
 114     /*
 115      * Table disassembly:
 116      * OperationRegion not found. Generate an External for it, and
 117      * insert the name into the namespace.
 118      */
 119     AcpiDmAddToExternalList (Op, Path, ACPI_TYPE_REGION, 0);
 120     Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ACPI_TYPE_REGION,
 121        ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT, WalkState, Node);
 122     if (ACPI_FAILURE (Status))
 123     {
 124         return (Status);
 125     }
 126
 127     /* Must create and install a region object for the new node */
 128
 129     ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_REGION);
 130     if (!ObjDesc)
 131     {
 132         return (AE_NO_MEMORY);
 133     }
 134
 135     ObjDesc->Region.Node = *Node;
 136     Status = AcpiNsAttachObject (*Node, ObjDesc, ACPI_TYPE_REGION);
 137     return (Status);
 138 }
 139 #endif
 140
 141
 142 /*******************************************************************************
 143  *
 144  * FUNCTION:    AcpiDsCreateBufferField
 145  *
 146  * PARAMETERS:  Op                  - Current parse op (CreateXXField)
 147  *              WalkState           - Current state
 148  *
 149  * RETURN:      Status
 150  *
 151  * DESCRIPTION: Execute the CreateField operators:
 152  *              CreateBitFieldOp,
 153  *              CreateByteFieldOp,
 154  *              CreateWordFieldOp,
 155  *              CreateDwordFieldOp,
 156  *              CreateQwordFieldOp,
 157  *              CreateFieldOp       (all of which define a field in a buffer)
 158  *
 159  ******************************************************************************/
 160
 161 ACPI_STATUS
 162 AcpiDsCreateBufferField (
 163     ACPI_PARSE_OBJECT       *Op,
 164     ACPI_WALK_STATE         *WalkState)
 165 {
 166     ACPI_PARSE_OBJECT       *Arg;
 167     ACPI_NAMESPACE_NODE     *Node;
 168     ACPI_STATUS             Status;
 169     ACPI_OPERAND_OBJECT     *ObjDesc;
 170     ACPI_OPERAND_OBJECT     *SecondDesc = NULL;
 171     UINT32                  Flags;
 172
 173
 174     ACPI_FUNCTION_TRACE (DsCreateBufferField);
 175
 176
 177     /*
 178      * Get the NameString argument (name of the new BufferField)
 179      */
 180     if (Op->Common.AmlOpcode == AML_CREATE_FIELD_OP)
 181     {
 182         /* For CreateField, name is the 4th argument */
 183
 184         Arg = AcpiPsGetArg (Op, 3);
 185     }
 186     else
 187     {
 188         /* For all other CreateXXXField operators, name is the 3rd argument */
 189
 190         Arg = AcpiPsGetArg (Op, 2);
 191     }
 192
 193     if (!Arg)
 194     {
 195         return_ACPI_STATUS (AE_AML_NO_OPERAND);
 196     }
 197
 198     if (WalkState->DeferredNode)
 199     {
 200         Node = WalkState->DeferredNode;
 201         Status = AE_OK;
 202     }
 203     else
 204     {
 205         /* Execute flag should always be set when this function is entered */
 206
 207         if (!(WalkState->ParseFlags & ACPI_PARSE_EXECUTE))
 208         {
 209             return_ACPI_STATUS (AE_AML_INTERNAL);
 210         }
 211
 212         /* Creating new namespace node, should not already exist */
 213
 214         Flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
 215                 ACPI_NS_ERROR_IF_FOUND;
 216
 217         /*
 218          * Mark node temporary if we are executing a normal control
 219          * method. (Don't mark if this is a module-level code method)
 220          */
 221         if (WalkState->MethodNode &&
 222             !(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL))
 223         {
 224             Flags |= ACPI_NS_TEMPORARY;
 225         }
 226
 227         /* Enter the NameString into the namespace */
 228
 229         Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String,
 230                     ACPI_TYPE_ANY, ACPI_IMODE_LOAD_PASS1,
 231                     Flags, WalkState, &Node);
 232         if (ACPI_FAILURE (Status))
 233         {
 234             ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status);
 235             return_ACPI_STATUS (Status);
 236         }
 237     }
 238
 239     /*
 240      * We could put the returned object (Node) on the object stack for later,
 241      * but for now, we will put it in the "op" object that the parser uses,
 242      * so we can get it again at the end of this scope.
 243      */
 244     Op->Common.Node = Node;
 245
 246     /*
 247      * If there is no object attached to the node, this node was just created
 248      * and we need to create the field object. Otherwise, this was a lookup
 249      * of an existing node and we don't want to create the field object again.
 250      */
 251     ObjDesc = AcpiNsGetAttachedObject (Node);
 252     if (ObjDesc)
 253     {
 254         return_ACPI_STATUS (AE_OK);
 255     }
 256
 257     /*
 258      * The Field definition is not fully parsed at this time.
 259      * (We must save the address of the AML for the buffer and index operands)
 260      */
 261
 262     /* Create the buffer field object */
 263
 264     ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER_FIELD);
 265     if (!ObjDesc)
 266     {
 267         Status = AE_NO_MEMORY;
 268         goto Cleanup;
 269     }
 270
 271     /*
 272      * Remember location in AML stream of the field unit opcode and operands --
 273      * since the buffer and index operands must be evaluated.
 274      */
 275     SecondDesc                  = ObjDesc->Common.NextObject;
 276     SecondDesc->Extra.AmlStart  = Op->Named.Data;
 277     SecondDesc->Extra.AmlLength = Op->Named.Length;
 278     ObjDesc->BufferField.Node   = Node;
 279
 280     /* Attach constructed field descriptors to parent node */
 281
 282     Status = AcpiNsAttachObject (Node, ObjDesc, ACPI_TYPE_BUFFER_FIELD);
 283     if (ACPI_FAILURE (Status))
 284     {
 285         goto Cleanup;
 286     }
 287
 288
 289 Cleanup:
 290
 291     /* Remove local reference to the object */
 292
 293     AcpiUtRemoveReference (ObjDesc);
 294     return_ACPI_STATUS (Status);
 295 }
 296
 297
 298 /*******************************************************************************
 299  *
 300  * FUNCTION:    AcpiDsGetFieldNames
 301  *
 302  * PARAMETERS:  Info            - CreateField info structure
 303  *  `           WalkState       - Current method state
 304  *              Arg             - First parser arg for the field name list
 305  *
 306  * RETURN:      Status
 307  *
 308  * DESCRIPTION: Process all named fields in a field declaration. Names are
 309  *              entered into the namespace.
 310  *
 311  ******************************************************************************/
 312
 313 static ACPI_STATUS
 314 AcpiDsGetFieldNames (
 315     ACPI_CREATE_FIELD_INFO  *Info,
 316     ACPI_WALK_STATE         *WalkState,
 317     ACPI_PARSE_OBJECT       *Arg)
 318 {
 319     ACPI_STATUS             Status;
 320     UINT64                  Position;
 321     ACPI_PARSE_OBJECT       *Child;
 322
 323
 324     ACPI_FUNCTION_TRACE_PTR (DsGetFieldNames, Info);
 325
 326
 327     /* First field starts at bit zero */
 328
 329     Info->FieldBitPosition = 0;
 330
 331     /* Process all elements in the field list (of parse nodes) */
 332
 333     while (Arg)
 334     {
 335         /*
 336          * Four types of field elements are handled:
 337          * 1) Name - Enters a new named field into the namespace
 338          * 2) Offset - specifies a bit offset
 339          * 3) AccessAs - changes the access mode/attributes
 340          * 4) Connection - Associate a resource template with the field
 341          */
 342         switch (Arg->Common.AmlOpcode)
 343         {
 344         case AML_INT_RESERVEDFIELD_OP:
 345
 346             Position = (UINT64) Info->FieldBitPosition
 347                         + (UINT64) Arg->Common.Value.Size;
 348
 349             if (Position > ACPI_UINT32_MAX)
 350             {
 351                 ACPI_ERROR ((AE_INFO,
 352                     "Bit offset within field too large (> 0xFFFFFFFF)"));
 353                 return_ACPI_STATUS (AE_SUPPORT);
 354             }
 355
 356             Info->FieldBitPosition = (UINT32) Position;
 357             break;
 358
 359         case AML_INT_ACCESSFIELD_OP:
 360         case AML_INT_EXTACCESSFIELD_OP:
 361             /*
 362              * Get new AccessType, AccessAttribute, and AccessLength fields
 363              * -- to be used for all field units that follow, until the
 364              * end-of-field or another AccessAs keyword is encountered.
 365              * NOTE. These three bytes are encoded in the integer value
 366              * of the parseop for convenience.
 367              *
 368              * In FieldFlags, preserve the flag bits other than the
 369              * ACCESS_TYPE bits.
 370              */
 371
 372             /* AccessType (ByteAcc, WordAcc, etc.) */
 373
 374             Info->FieldFlags = (UINT8)
 375                 ((Info->FieldFlags & ~(AML_FIELD_ACCESS_TYPE_MASK)) |
 376                 ((UINT8) ((UINT32) (Arg->Common.Value.Integer & 0x07))));
 377
 378             /* AccessAttribute (AttribQuick, AttribByte, etc.) */
 379
 380             Info->Attribute = (UINT8) ((Arg->Common.Value.Integer >> 8) & 0xFF);
 381
 382             /* AccessLength (for serial/buffer protocols) */
 383
 384             Info->AccessLength = (UINT8) ((Arg->Common.Value.Integer >> 16) & 0xFF);
 385             break;
 386
 387         case AML_INT_CONNECTION_OP:
 388             /*
 389              * Clear any previous connection. New connection is used for all
 390              * fields that follow, similar to AccessAs
 391              */
 392             Info->ResourceBuffer = NULL;
 393             Info->ConnectionNode = NULL;
 394
 395             /*
 396              * A Connection() is either an actual resource descriptor (buffer)
 397              * or a named reference to a resource template
 398              */
 399             Child = Arg->Common.Value.Arg;
 400             if (Child->Common.AmlOpcode == AML_INT_BYTELIST_OP)
 401             {
 402                 Info->ResourceBuffer = Child->Named.Data;
 403                 Info->ResourceLength = (UINT16) Child->Named.Value.Integer;
 404             }
 405             else
 406             {
 407                 /* Lookup the Connection() namepath, it should already exist */
 408
 409                 Status = AcpiNsLookup (WalkState->ScopeInfo,
 410                             Child->Common.Value.Name, ACPI_TYPE_ANY,
 411                             ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE,
 412                             WalkState, &Info->ConnectionNode);
 413                 if (ACPI_FAILURE (Status))
 414                 {
 415                     ACPI_ERROR_NAMESPACE (Child->Common.Value.Name, Status);
 416                     return_ACPI_STATUS (Status);
 417                 }
 418             }
 419             break;
 420
 421         case AML_INT_NAMEDFIELD_OP:
 422
 423             /* Lookup the name, it should already exist */
 424
 425             Status = AcpiNsLookup (WalkState->ScopeInfo,
 426                         (char *) &Arg->Named.Name, Info->FieldType,
 427                         ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE,
 428                         WalkState, &Info->FieldNode);
 429             if (ACPI_FAILURE (Status))
 430             {
 431                 ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status);
 432                 return_ACPI_STATUS (Status);
 433             }
 434             else
 435             {
 436                 Arg->Common.Node = Info->FieldNode;
 437                 Info->FieldBitLength = Arg->Common.Value.Size;
 438
 439                 /*
 440                  * If there is no object attached to the node, this node was
 441                  * just created and we need to create the field object.
 442                  * Otherwise, this was a lookup of an existing node and we
 443                  * don't want to create the field object again.
 444                  */
 445                 if (!AcpiNsGetAttachedObject (Info->FieldNode))
 446                 {
 447                     Status = AcpiExPrepFieldValue (Info);
 448                     if (ACPI_FAILURE (Status))
 449                     {
 450                         return_ACPI_STATUS (Status);
 451                     }
 452                 }
 453             }
 454
 455             /* Keep track of bit position for the next field */
 456
 457             Position = (UINT64) Info->FieldBitPosition
 458                         + (UINT64) Arg->Common.Value.Size;
 459
 460             if (Position > ACPI_UINT32_MAX)
 461             {
 462                 ACPI_ERROR ((AE_INFO,
 463                     "Field [%4.4s] bit offset too large (> 0xFFFFFFFF)",
 464                     ACPI_CAST_PTR (char, &Info->FieldNode->Name)));
 465                 return_ACPI_STATUS (AE_SUPPORT);
 466             }
 467
 468             Info->FieldBitPosition += Info->FieldBitLength;
 469             break;
 470
 471         default:
 472
 473             ACPI_ERROR ((AE_INFO,
 474                 "Invalid opcode in field list: 0x%X", Arg->Common.AmlOpcode));
 475             return_ACPI_STATUS (AE_AML_BAD_OPCODE);
 476         }
 477
 478         Arg = Arg->Common.Next;
 479     }
 480
 481     return_ACPI_STATUS (AE_OK);
 482 }
 483
 484
 485 /*******************************************************************************
 486  *
 487  * FUNCTION:    AcpiDsCreateField
 488  *
 489  * PARAMETERS:  Op              - Op containing the Field definition and args
 490  *              RegionNode      - Object for the containing Operation Region
 491  *  `           WalkState       - Current method state
 492  *
 493  * RETURN:      Status
 494  *
 495  * DESCRIPTION: Create a new field in the specified operation region
 496  *
 497  ******************************************************************************/
 498
 499 ACPI_STATUS
 500 AcpiDsCreateField (
 501     ACPI_PARSE_OBJECT       *Op,
 502     ACPI_NAMESPACE_NODE     *RegionNode,
 503     ACPI_WALK_STATE         *WalkState)
 504 {
 505     ACPI_STATUS             Status;
 506     ACPI_PARSE_OBJECT       *Arg;
 507     ACPI_CREATE_FIELD_INFO  Info;
 508
 509
 510     ACPI_FUNCTION_TRACE_PTR (DsCreateField, Op);
 511
 512
 513     /* First arg is the name of the parent OpRegion (must already exist) */
 514
 515     Arg = Op->Common.Value.Arg;
 516
 517     if (!RegionNode)
 518     {
 519         Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.Name,
 520                         ACPI_TYPE_REGION, ACPI_IMODE_EXECUTE,
 521                         ACPI_NS_SEARCH_PARENT, WalkState, &RegionNode);
 522 #ifdef ACPI_ASL_COMPILER
 523         Status = AcpiDsCreateExternalRegion (Status, Arg,
 524             Arg->Common.Value.Name, WalkState, &RegionNode);
 525 #endif
 526         if (ACPI_FAILURE (Status))
 527         {
 528             ACPI_ERROR_NAMESPACE (Arg->Common.Value.Name, Status);
 529             return_ACPI_STATUS (Status);
 530         }
 531     }
 532
 533     ACPI_MEMSET (&Info, 0, sizeof (ACPI_CREATE_FIELD_INFO));
 534
 535     /* Second arg is the field flags */
 536
 537     Arg = Arg->Common.Next;
 538     Info.FieldFlags = (UINT8) Arg->Common.Value.Integer;
 539     Info.Attribute = 0;
 540
 541     /* Each remaining arg is a Named Field */
 542
 543     Info.FieldType = ACPI_TYPE_LOCAL_REGION_FIELD;
 544     Info.RegionNode = RegionNode;
 545
 546     Status = AcpiDsGetFieldNames (&Info, WalkState, Arg->Common.Next);
 547     return_ACPI_STATUS (Status);
 548 }
 549
 550
 551 /*******************************************************************************
 552  *
 553  * FUNCTION:    AcpiDsInitFieldObjects
 554  *
 555  * PARAMETERS:  Op              - Op containing the Field definition and args
 556  *  `           WalkState       - Current method state
 557  *
 558  * RETURN:      Status
 559  *
 560  * DESCRIPTION: For each "Field Unit" name in the argument list that is
 561  *              part of the field declaration, enter the name into the
 562  *              namespace.
 563  *
 564  ******************************************************************************/
 565
 566 ACPI_STATUS
 567 AcpiDsInitFieldObjects (
 568     ACPI_PARSE_OBJECT       *Op,
 569     ACPI_WALK_STATE         *WalkState)
 570 {
 571     ACPI_STATUS             Status;
 572     ACPI_PARSE_OBJECT       *Arg = NULL;
 573     ACPI_NAMESPACE_NODE     *Node;
 574     UINT8                   Type = 0;
 575     UINT32                  Flags;
 576
 577
 578     ACPI_FUNCTION_TRACE_PTR (DsInitFieldObjects, Op);
 579
 580
 581     /* Execute flag should always be set when this function is entered */
 582
 583     if (!(WalkState->ParseFlags & ACPI_PARSE_EXECUTE))
 584     {
 585         if (WalkState->ParseFlags & ACPI_PARSE_DEFERRED_OP)
 586         {
 587             /* BankField Op is deferred, just return OK */
 588
 589             return_ACPI_STATUS (AE_OK);
 590         }
 591
 592         return_ACPI_STATUS (AE_AML_INTERNAL);
 593     }
 594
 595     /*
 596      * Get the FieldList argument for this opcode. This is the start of the
 597      * list of field elements.
 598      */
 599     switch (WalkState->Opcode)
 600     {
 601     case AML_FIELD_OP:
 602
 603         Arg = AcpiPsGetArg (Op, 2);
 604         Type = ACPI_TYPE_LOCAL_REGION_FIELD;
 605         break;
 606
 607     case AML_BANK_FIELD_OP:
 608
 609         Arg = AcpiPsGetArg (Op, 4);
 610         Type = ACPI_TYPE_LOCAL_BANK_FIELD;
 611         break;
 612
 613     case AML_INDEX_FIELD_OP:
 614
 615         Arg = AcpiPsGetArg (Op, 3);
 616         Type = ACPI_TYPE_LOCAL_INDEX_FIELD;
 617         break;
 618
 619     default:
 620
 621         return_ACPI_STATUS (AE_BAD_PARAMETER);
 622     }
 623
 624     /* Creating new namespace node(s), should not already exist */
 625
 626     Flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
 627             ACPI_NS_ERROR_IF_FOUND;
 628
 629     /*
 630      * Mark node(s) temporary if we are executing a normal control
 631      * method. (Don't mark if this is a module-level code method)
 632      */
 633     if (WalkState->MethodNode &&
 634         !(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL))
 635     {
 636         Flags |= ACPI_NS_TEMPORARY;
 637     }
 638
 639     /*
 640      * Walk the list of entries in the FieldList
 641      * Note: FieldList can be of zero length. In this case, Arg will be NULL.
 642      */
 643     while (Arg)
 644     {
 645         /*
 646          * Ignore OFFSET/ACCESSAS/CONNECTION terms here; we are only interested
 647          * in the field names in order to enter them into the namespace.
 648          */
 649         if (Arg->Common.AmlOpcode == AML_INT_NAMEDFIELD_OP)
 650         {
 651             Status = AcpiNsLookup (WalkState->ScopeInfo,
 652                         (char *) &Arg->Named.Name, Type, ACPI_IMODE_LOAD_PASS1,
 653                         Flags, WalkState, &Node);
 654             if (ACPI_FAILURE (Status))
 655             {
 656                 ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status);
 657                 if (Status != AE_ALREADY_EXISTS)
 658                 {
 659                     return_ACPI_STATUS (Status);
 660                 }
 661
 662                 /* Name already exists, just ignore this error */
 663
 664                 Status = AE_OK;
 665             }
 666
 667             Arg->Common.Node = Node;
 668         }
 669
 670         /* Get the next field element in the list */
 671
 672         Arg = Arg->Common.Next;
 673     }
 674
 675     return_ACPI_STATUS (AE_OK);
 676 }
 677
 678
 679 /*******************************************************************************
 680  *
 681  * FUNCTION:    AcpiDsCreateBankField
 682  *
 683  * PARAMETERS:  Op              - Op containing the Field definition and args
 684  *              RegionNode      - Object for the containing Operation Region
 685  *              WalkState       - Current method state
 686  *
 687  * RETURN:      Status
 688  *
 689  * DESCRIPTION: Create a new bank field in the specified operation region
 690  *
 691  ******************************************************************************/
 692
 693 ACPI_STATUS
 694 AcpiDsCreateBankField (
 695     ACPI_PARSE_OBJECT       *Op,
 696     ACPI_NAMESPACE_NODE     *RegionNode,
 697     ACPI_WALK_STATE         *WalkState)
 698 {
 699     ACPI_STATUS             Status;
 700     ACPI_PARSE_OBJECT       *Arg;
 701     ACPI_CREATE_FIELD_INFO  Info;
 702
 703
 704     ACPI_FUNCTION_TRACE_PTR (DsCreateBankField, Op);
 705
 706
 707     /* First arg is the name of the parent OpRegion (must already exist) */
 708
 709     Arg = Op->Common.Value.Arg;
 710     if (!RegionNode)
 711     {
 712         Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.Name,
 713                         ACPI_TYPE_REGION, ACPI_IMODE_EXECUTE,
 714                         ACPI_NS_SEARCH_PARENT, WalkState, &RegionNode);
 715 #ifdef ACPI_ASL_COMPILER
 716         Status = AcpiDsCreateExternalRegion (Status, Arg,
 717             Arg->Common.Value.Name, WalkState, &RegionNode);
 718 #endif
 719         if (ACPI_FAILURE (Status))
 720         {
 721             ACPI_ERROR_NAMESPACE (Arg->Common.Value.Name, Status);
 722             return_ACPI_STATUS (Status);
 723         }
 724     }
 725
 726     /* Second arg is the Bank Register (Field) (must already exist) */
 727
 728     Arg = Arg->Common.Next;
 729     Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String,
 730                     ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 731                     ACPI_NS_SEARCH_PARENT, WalkState, &Info.RegisterNode);
 732     if (ACPI_FAILURE (Status))
 733     {
 734         ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status);
 735         return_ACPI_STATUS (Status);
 736     }
 737
 738     /*
 739      * Third arg is the BankValue
 740      * This arg is a TermArg, not a constant
 741      * It will be evaluated later, by AcpiDsEvalBankFieldOperands
 742      */
 743     Arg = Arg->Common.Next;
 744
 745     /* Fourth arg is the field flags */
 746
 747     Arg = Arg->Common.Next;
 748     Info.FieldFlags = (UINT8) Arg->Common.Value.Integer;
 749
 750     /* Each remaining arg is a Named Field */
 751
 752     Info.FieldType = ACPI_TYPE_LOCAL_BANK_FIELD;
 753     Info.RegionNode = RegionNode;
 754
 755     /*
 756      * Use Info.DataRegisterNode to store BankField Op
 757      * It's safe because DataRegisterNode will never be used when create bank field
 758      * We store AmlStart and AmlLength in the BankField Op for late evaluation
 759      * Used in AcpiExPrepFieldValue(Info)
 760      *
 761      * TBD: Or, should we add a field in ACPI_CREATE_FIELD_INFO, like "void *ParentOp"?
 762      */
 763     Info.DataRegisterNode = (ACPI_NAMESPACE_NODE*) Op;
 764
 765     Status = AcpiDsGetFieldNames (&Info, WalkState, Arg->Common.Next);
 766     return_ACPI_STATUS (Status);
 767 }
 768
 769
 770 /*******************************************************************************
 771  *
 772  * FUNCTION:    AcpiDsCreateIndexField
 773  *
 774  * PARAMETERS:  Op              - Op containing the Field definition and args
 775  *              RegionNode      - Object for the containing Operation Region
 776  *  `           WalkState       - Current method state
 777  *
 778  * RETURN:      Status
 779  *
 780  * DESCRIPTION: Create a new index field in the specified operation region
 781  *
 782  ******************************************************************************/
 783
 784 ACPI_STATUS
 785 AcpiDsCreateIndexField (
 786     ACPI_PARSE_OBJECT       *Op,
 787     ACPI_NAMESPACE_NODE     *RegionNode,
 788     ACPI_WALK_STATE         *WalkState)
 789 {
 790     ACPI_STATUS             Status;
 791     ACPI_PARSE_OBJECT       *Arg;
 792     ACPI_CREATE_FIELD_INFO  Info;
 793
 794
 795     ACPI_FUNCTION_TRACE_PTR (DsCreateIndexField, Op);
 796
 797
 798     /* First arg is the name of the Index register (must already exist) */
 799
 800     Arg = Op->Common.Value.Arg;
 801     Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String,
 802                     ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 803                     ACPI_NS_SEARCH_PARENT, WalkState, &Info.RegisterNode);
 804     if (ACPI_FAILURE (Status))
 805     {
 806         ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status);
 807         return_ACPI_STATUS (Status);
 808     }
 809
 810     /* Second arg is the data register (must already exist) */
 811
 812     Arg = Arg->Common.Next;
 813     Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String,
 814                     ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 815                     ACPI_NS_SEARCH_PARENT, WalkState, &Info.DataRegisterNode);
 816     if (ACPI_FAILURE (Status))
 817     {
 818         ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status);
 819         return_ACPI_STATUS (Status);
 820     }
 821
 822     /* Next arg is the field flags */
 823
 824     Arg = Arg->Common.Next;
 825     Info.FieldFlags = (UINT8) Arg->Common.Value.Integer;
 826
 827     /* Each remaining arg is a Named Field */
 828
 829     Info.FieldType = ACPI_TYPE_LOCAL_INDEX_FIELD;
 830     Info.RegionNode = RegionNode;
 831
 832     Status = AcpiDsGetFieldNames (&Info, WalkState, Arg->Common.Next);
 833     return_ACPI_STATUS (Status);
 834 }