sys/contrib/dev/acpica/components/dispatcher/dsfield.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dsfield - Dispatcher field routines
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2014, 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 <contrib/dev/acpica/include/acpi.h>
  47 #include <contrib/dev/acpica/include/accommon.h>
  48 #include <contrib/dev/acpica/include/amlcode.h>
  49 #include <contrib/dev/acpica/include/acdispat.h>
  50 #include <contrib/dev/acpica/include/acinterp.h>
  51 #include <contrib/dev/acpica/include/acnamesp.h>
  52 #include <contrib/dev/acpica/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 <contrib/dev/acpica/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     AcpiDmAddOpToExternalList (Op, Path, ACPI_TYPE_REGION, 0, 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             Info->PinNumberIndex = 0;
 395
 396             /*
 397              * A Connection() is either an actual resource descriptor (buffer)
 398              * or a named reference to a resource template
 399              */
 400             Child = Arg->Common.Value.Arg;
 401             if (Child->Common.AmlOpcode == AML_INT_BYTELIST_OP)
 402             {
 403                 Info->ResourceBuffer = Child->Named.Data;
 404                 Info->ResourceLength = (UINT16) Child->Named.Value.Integer;
 405             }
 406             else
 407             {
 408                 /* Lookup the Connection() namepath, it should already exist */
 409
 410                 Status = AcpiNsLookup (WalkState->ScopeInfo,
 411                             Child->Common.Value.Name, ACPI_TYPE_ANY,
 412                             ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE,
 413                             WalkState, &Info->ConnectionNode);
 414                 if (ACPI_FAILURE (Status))
 415                 {
 416                     ACPI_ERROR_NAMESPACE (Child->Common.Value.Name, Status);
 417                     return_ACPI_STATUS (Status);
 418                 }
 419             }
 420             break;
 421
 422         case AML_INT_NAMEDFIELD_OP:
 423
 424             /* Lookup the name, it should already exist */
 425
 426             Status = AcpiNsLookup (WalkState->ScopeInfo,
 427                         (char *) &Arg->Named.Name, Info->FieldType,
 428                         ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE,
 429                         WalkState, &Info->FieldNode);
 430             if (ACPI_FAILURE (Status))
 431             {
 432                 ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status);
 433                 return_ACPI_STATUS (Status);
 434             }
 435             else
 436             {
 437                 Arg->Common.Node = Info->FieldNode;
 438                 Info->FieldBitLength = Arg->Common.Value.Size;
 439
 440                 /*
 441                  * If there is no object attached to the node, this node was
 442                  * just created and we need to create the field object.
 443                  * Otherwise, this was a lookup of an existing node and we
 444                  * don't want to create the field object again.
 445                  */
 446                 if (!AcpiNsGetAttachedObject (Info->FieldNode))
 447                 {
 448                     Status = AcpiExPrepFieldValue (Info);
 449                     if (ACPI_FAILURE (Status))
 450                     {
 451                         return_ACPI_STATUS (Status);
 452                     }
 453                 }
 454             }
 455
 456             /* Keep track of bit position for the next field */
 457
 458             Position = (UINT64) Info->FieldBitPosition
 459                         + (UINT64) Arg->Common.Value.Size;
 460
 461             if (Position > ACPI_UINT32_MAX)
 462             {
 463                 ACPI_ERROR ((AE_INFO,
 464                     "Field [%4.4s] bit offset too large (> 0xFFFFFFFF)",
 465                     ACPI_CAST_PTR (char, &Info->FieldNode->Name)));
 466                 return_ACPI_STATUS (AE_SUPPORT);
 467             }
 468
 469             Info->FieldBitPosition += Info->FieldBitLength;
 470             Info->PinNumberIndex++; /* Index relative to previous Connection() */
 471             break;
 472
 473         default:
 474
 475             ACPI_ERROR ((AE_INFO,
 476                 "Invalid opcode in field list: 0x%X", Arg->Common.AmlOpcode));
 477             return_ACPI_STATUS (AE_AML_BAD_OPCODE);
 478         }
 479
 480         Arg = Arg->Common.Next;
 481     }
 482
 483     return_ACPI_STATUS (AE_OK);
 484 }
 485
 486
 487 /*******************************************************************************
 488  *
 489  * FUNCTION:    AcpiDsCreateField
 490  *
 491  * PARAMETERS:  Op              - Op containing the Field definition and args
 492  *              RegionNode      - Object for the containing Operation Region
 493  *  `           WalkState       - Current method state
 494  *
 495  * RETURN:      Status
 496  *
 497  * DESCRIPTION: Create a new field in the specified operation region
 498  *
 499  ******************************************************************************/
 500
 501 ACPI_STATUS
 502 AcpiDsCreateField (
 503     ACPI_PARSE_OBJECT       *Op,
 504     ACPI_NAMESPACE_NODE     *RegionNode,
 505     ACPI_WALK_STATE         *WalkState)
 506 {
 507     ACPI_STATUS             Status;
 508     ACPI_PARSE_OBJECT       *Arg;
 509     ACPI_CREATE_FIELD_INFO  Info;
 510
 511
 512     ACPI_FUNCTION_TRACE_PTR (DsCreateField, Op);
 513
 514
 515     /* First arg is the name of the parent OpRegion (must already exist) */
 516
 517     Arg = Op->Common.Value.Arg;
 518
 519     if (!RegionNode)
 520     {
 521         Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.Name,
 522                         ACPI_TYPE_REGION, ACPI_IMODE_EXECUTE,
 523                         ACPI_NS_SEARCH_PARENT, WalkState, &RegionNode);
 524 #ifdef ACPI_ASL_COMPILER
 525         Status = AcpiDsCreateExternalRegion (Status, Arg,
 526             Arg->Common.Value.Name, WalkState, &RegionNode);
 527 #endif
 528         if (ACPI_FAILURE (Status))
 529         {
 530             ACPI_ERROR_NAMESPACE (Arg->Common.Value.Name, Status);
 531             return_ACPI_STATUS (Status);
 532         }
 533     }
 534
 535     ACPI_MEMSET (&Info, 0, sizeof (ACPI_CREATE_FIELD_INFO));
 536
 537     /* Second arg is the field flags */
 538
 539     Arg = Arg->Common.Next;
 540     Info.FieldFlags = (UINT8) Arg->Common.Value.Integer;
 541     Info.Attribute = 0;
 542
 543     /* Each remaining arg is a Named Field */
 544
 545     Info.FieldType = ACPI_TYPE_LOCAL_REGION_FIELD;
 546     Info.RegionNode = RegionNode;
 547
 548     Status = AcpiDsGetFieldNames (&Info, WalkState, Arg->Common.Next);
 549     return_ACPI_STATUS (Status);
 550 }
 551
 552
 553 /*******************************************************************************
 554  *
 555  * FUNCTION:    AcpiDsInitFieldObjects
 556  *
 557  * PARAMETERS:  Op              - Op containing the Field definition and args
 558  *  `           WalkState       - Current method state
 559  *
 560  * RETURN:      Status
 561  *
 562  * DESCRIPTION: For each "Field Unit" name in the argument list that is
 563  *              part of the field declaration, enter the name into the
 564  *              namespace.
 565  *
 566  ******************************************************************************/
 567
 568 ACPI_STATUS
 569 AcpiDsInitFieldObjects (
 570     ACPI_PARSE_OBJECT       *Op,
 571     ACPI_WALK_STATE         *WalkState)
 572 {
 573     ACPI_STATUS             Status;
 574     ACPI_PARSE_OBJECT       *Arg = NULL;
 575     ACPI_NAMESPACE_NODE     *Node;
 576     UINT8                   Type = 0;
 577     UINT32                  Flags;
 578
 579
 580     ACPI_FUNCTION_TRACE_PTR (DsInitFieldObjects, Op);
 581
 582
 583     /* Execute flag should always be set when this function is entered */
 584
 585     if (!(WalkState->ParseFlags & ACPI_PARSE_EXECUTE))
 586     {
 587         if (WalkState->ParseFlags & ACPI_PARSE_DEFERRED_OP)
 588         {
 589             /* BankField Op is deferred, just return OK */
 590
 591             return_ACPI_STATUS (AE_OK);
 592         }
 593
 594         return_ACPI_STATUS (AE_AML_INTERNAL);
 595     }
 596
 597     /*
 598      * Get the FieldList argument for this opcode. This is the start of the
 599      * list of field elements.
 600      */
 601     switch (WalkState->Opcode)
 602     {
 603     case AML_FIELD_OP:
 604
 605         Arg = AcpiPsGetArg (Op, 2);
 606         Type = ACPI_TYPE_LOCAL_REGION_FIELD;
 607         break;
 608
 609     case AML_BANK_FIELD_OP:
 610
 611         Arg = AcpiPsGetArg (Op, 4);
 612         Type = ACPI_TYPE_LOCAL_BANK_FIELD;
 613         break;
 614
 615     case AML_INDEX_FIELD_OP:
 616
 617         Arg = AcpiPsGetArg (Op, 3);
 618         Type = ACPI_TYPE_LOCAL_INDEX_FIELD;
 619         break;
 620
 621     default:
 622
 623         return_ACPI_STATUS (AE_BAD_PARAMETER);
 624     }
 625
 626     /* Creating new namespace node(s), should not already exist */
 627
 628     Flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
 629             ACPI_NS_ERROR_IF_FOUND;
 630
 631     /*
 632      * Mark node(s) temporary if we are executing a normal control
 633      * method. (Don't mark if this is a module-level code method)
 634      */
 635     if (WalkState->MethodNode &&
 636         !(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL))
 637     {
 638         Flags |= ACPI_NS_TEMPORARY;
 639     }
 640
 641     /*
 642      * Walk the list of entries in the FieldList
 643      * Note: FieldList can be of zero length. In this case, Arg will be NULL.
 644      */
 645     while (Arg)
 646     {
 647         /*
 648          * Ignore OFFSET/ACCESSAS/CONNECTION terms here; we are only interested
 649          * in the field names in order to enter them into the namespace.
 650          */
 651         if (Arg->Common.AmlOpcode == AML_INT_NAMEDFIELD_OP)
 652         {
 653             Status = AcpiNsLookup (WalkState->ScopeInfo,
 654                         (char *) &Arg->Named.Name, Type, ACPI_IMODE_LOAD_PASS1,
 655                         Flags, WalkState, &Node);
 656             if (ACPI_FAILURE (Status))
 657             {
 658                 ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status);
 659                 if (Status != AE_ALREADY_EXISTS)
 660                 {
 661                     return_ACPI_STATUS (Status);
 662                 }
 663
 664                 /* Name already exists, just ignore this error */
 665
 666                 Status = AE_OK;
 667             }
 668
 669             Arg->Common.Node = Node;
 670         }
 671
 672         /* Get the next field element in the list */
 673
 674         Arg = Arg->Common.Next;
 675     }
 676
 677     return_ACPI_STATUS (AE_OK);
 678 }
 679
 680
 681 /*******************************************************************************
 682  *
 683  * FUNCTION:    AcpiDsCreateBankField
 684  *
 685  * PARAMETERS:  Op              - Op containing the Field definition and args
 686  *              RegionNode      - Object for the containing Operation Region
 687  *              WalkState       - Current method state
 688  *
 689  * RETURN:      Status
 690  *
 691  * DESCRIPTION: Create a new bank field in the specified operation region
 692  *
 693  ******************************************************************************/
 694
 695 ACPI_STATUS
 696 AcpiDsCreateBankField (
 697     ACPI_PARSE_OBJECT       *Op,
 698     ACPI_NAMESPACE_NODE     *RegionNode,
 699     ACPI_WALK_STATE         *WalkState)
 700 {
 701     ACPI_STATUS             Status;
 702     ACPI_PARSE_OBJECT       *Arg;
 703     ACPI_CREATE_FIELD_INFO  Info;
 704
 705
 706     ACPI_FUNCTION_TRACE_PTR (DsCreateBankField, Op);
 707
 708
 709     /* First arg is the name of the parent OpRegion (must already exist) */
 710
 711     Arg = Op->Common.Value.Arg;
 712     if (!RegionNode)
 713     {
 714         Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.Name,
 715                         ACPI_TYPE_REGION, ACPI_IMODE_EXECUTE,
 716                         ACPI_NS_SEARCH_PARENT, WalkState, &RegionNode);
 717 #ifdef ACPI_ASL_COMPILER
 718         Status = AcpiDsCreateExternalRegion (Status, Arg,
 719             Arg->Common.Value.Name, WalkState, &RegionNode);
 720 #endif
 721         if (ACPI_FAILURE (Status))
 722         {
 723             ACPI_ERROR_NAMESPACE (Arg->Common.Value.Name, Status);
 724             return_ACPI_STATUS (Status);
 725         }
 726     }
 727
 728     /* Second arg is the Bank Register (Field) (must already exist) */
 729
 730     Arg = Arg->Common.Next;
 731     Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String,
 732                     ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 733                     ACPI_NS_SEARCH_PARENT, WalkState, &Info.RegisterNode);
 734     if (ACPI_FAILURE (Status))
 735     {
 736         ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status);
 737         return_ACPI_STATUS (Status);
 738     }
 739
 740     /*
 741      * Third arg is the BankValue
 742      * This arg is a TermArg, not a constant
 743      * It will be evaluated later, by AcpiDsEvalBankFieldOperands
 744      */
 745     Arg = Arg->Common.Next;
 746
 747     /* Fourth arg is the field flags */
 748
 749     Arg = Arg->Common.Next;
 750     Info.FieldFlags = (UINT8) Arg->Common.Value.Integer;
 751
 752     /* Each remaining arg is a Named Field */
 753
 754     Info.FieldType = ACPI_TYPE_LOCAL_BANK_FIELD;
 755     Info.RegionNode = RegionNode;
 756
 757     /*
 758      * Use Info.DataRegisterNode to store BankField Op
 759      * It's safe because DataRegisterNode will never be used when create bank field
 760      * We store AmlStart and AmlLength in the BankField Op for late evaluation
 761      * Used in AcpiExPrepFieldValue(Info)
 762      *
 763      * TBD: Or, should we add a field in ACPI_CREATE_FIELD_INFO, like "void *ParentOp"?
 764      */
 765     Info.DataRegisterNode = (ACPI_NAMESPACE_NODE*) Op;
 766
 767     Status = AcpiDsGetFieldNames (&Info, WalkState, Arg->Common.Next);
 768     return_ACPI_STATUS (Status);
 769 }
 770
 771
 772 /*******************************************************************************
 773  *
 774  * FUNCTION:    AcpiDsCreateIndexField
 775  *
 776  * PARAMETERS:  Op              - Op containing the Field definition and args
 777  *              RegionNode      - Object for the containing Operation Region
 778  *  `           WalkState       - Current method state
 779  *
 780  * RETURN:      Status
 781  *
 782  * DESCRIPTION: Create a new index field in the specified operation region
 783  *
 784  ******************************************************************************/
 785
 786 ACPI_STATUS
 787 AcpiDsCreateIndexField (
 788     ACPI_PARSE_OBJECT       *Op,
 789     ACPI_NAMESPACE_NODE     *RegionNode,
 790     ACPI_WALK_STATE         *WalkState)
 791 {
 792     ACPI_STATUS             Status;
 793     ACPI_PARSE_OBJECT       *Arg;
 794     ACPI_CREATE_FIELD_INFO  Info;
 795
 796
 797     ACPI_FUNCTION_TRACE_PTR (DsCreateIndexField, Op);
 798
 799
 800     /* First arg is the name of the Index register (must already exist) */
 801
 802     Arg = Op->Common.Value.Arg;
 803     Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String,
 804                     ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 805                     ACPI_NS_SEARCH_PARENT, WalkState, &Info.RegisterNode);
 806     if (ACPI_FAILURE (Status))
 807     {
 808         ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status);
 809         return_ACPI_STATUS (Status);
 810     }
 811
 812     /* Second arg is the data register (must already exist) */
 813
 814     Arg = Arg->Common.Next;
 815     Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String,
 816                     ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 817                     ACPI_NS_SEARCH_PARENT, WalkState, &Info.DataRegisterNode);
 818     if (ACPI_FAILURE (Status))
 819     {
 820         ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status);
 821         return_ACPI_STATUS (Status);
 822     }
 823
 824     /* Next arg is the field flags */
 825
 826     Arg = Arg->Common.Next;
 827     Info.FieldFlags = (UINT8) Arg->Common.Value.Integer;
 828
 829     /* Each remaining arg is a Named Field */
 830
 831     Info.FieldType = ACPI_TYPE_LOCAL_INDEX_FIELD;
 832     Info.RegionNode = RegionNode;
 833
 834     Status = AcpiDsGetFieldNames (&Info, WalkState, Arg->Common.Next);
 835     return_ACPI_STATUS (Status);
 836 }