sys/contrib/dev/acpica-unix/executer/exprep.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117 #define __EXPREP_C__
 118
 119 #include "acpi.h"
 120 #include "accommon.h"
 121 #include "acinterp.h"
 122 #include "amlcode.h"
 123 #include "acnamesp.h"
 124
 125
 126 #define _COMPONENT          ACPI_EXECUTER
 127         ACPI_MODULE_NAME    ("exprep")
 128
 129 /* Local prototypes */
 130
 131 static UINT32
 132 AcpiExDecodeFieldAccess (
 133     ACPI_OPERAND_OBJECT     *ObjDesc,
 134     UINT8                   FieldFlags,
 135     UINT32                  *ReturnByteAlignment);
 136
 137
 138 #ifdef ACPI_UNDER_DEVELOPMENT
 139
 140 static UINT32
 141 AcpiExGenerateAccess (
 142     UINT32                  FieldBitOffset,
 143     UINT32                  FieldBitLength,
 144     UINT32                  RegionLength);
 145
 146 /*******************************************************************************
 147  *
 148  * FUNCTION:    AcpiExGenerateAccess
 149  *
 150  * PARAMETERS:  FieldBitOffset      - Start of field within parent region/buffer
 151  *              FieldBitLength      - Length of field in bits
 152  *              RegionLength        - Length of parent in bytes
 153  *
 154  * RETURN:      Field granularity (8, 16, 32 or 64) and
 155  *              ByteAlignment (1, 2, 3, or 4)
 156  *
 157  * DESCRIPTION: Generate an optimal access width for fields defined with the
 158  *              AnyAcc keyword.
 159  *
 160  * NOTE: Need to have the RegionLength in order to check for boundary
 161  *       conditions (end-of-region).  However, the RegionLength is a deferred
 162  *       operation.  Therefore, to complete this implementation, the generation
 163  *       of this access width must be deferred until the region length has
 164  *       been evaluated.
 165  *
 166  ******************************************************************************/
 167
 168 static UINT32
 169 AcpiExGenerateAccess (
 170     UINT32                  FieldBitOffset,
 171     UINT32                  FieldBitLength,
 172     UINT32                  RegionLength)
 173 {
 174     UINT32                  FieldByteLength;
 175     UINT32                  FieldByteOffset;
 176     UINT32                  FieldByteEndOffset;
 177     UINT32                  AccessByteWidth;
 178     UINT32                  FieldStartOffset;
 179     UINT32                  FieldEndOffset;
 180     UINT32                  MinimumAccessWidth = 0xFFFFFFFF;
 181     UINT32                  MinimumAccesses = 0xFFFFFFFF;
 182     UINT32                  Accesses;
 183
 184
 185     ACPI_FUNCTION_TRACE (ExGenerateAccess);
 186
 187
 188     /* Round Field start offset and length to "minimal" byte boundaries */
 189
 190     FieldByteOffset    = ACPI_DIV_8 (ACPI_ROUND_DOWN (FieldBitOffset, 8));
 191     FieldByteEndOffset = ACPI_DIV_8 (ACPI_ROUND_UP   (FieldBitLength +
 192                                                       FieldBitOffset, 8));
 193     FieldByteLength    = FieldByteEndOffset - FieldByteOffset;
 194
 195     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 196         "Bit length %u, Bit offset %u\n",
 197         FieldBitLength, FieldBitOffset));
 198
 199     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 200         "Byte Length %u, Byte Offset %u, End Offset %u\n",
 201         FieldByteLength, FieldByteOffset, FieldByteEndOffset));
 202
 203     /*
 204      * Iterative search for the maximum access width that is both aligned
 205      * and does not go beyond the end of the region
 206      *
 207      * Start at ByteAcc and work upwards to QwordAcc max. (1,2,4,8 bytes)
 208      */
 209     for (AccessByteWidth = 1; AccessByteWidth <= 8; AccessByteWidth <<= 1)
 210     {
 211         /*
 212          * 1) Round end offset up to next access boundary and make sure that
 213          *    this does not go beyond the end of the parent region.
 214          * 2) When the Access width is greater than the FieldByteLength, we
 215          *    are done. (This does not optimize for the perfectly aligned
 216          *    case yet).
 217          */
 218         if (ACPI_ROUND_UP (FieldByteEndOffset, AccessByteWidth) <= RegionLength)
 219         {
 220             FieldStartOffset =
 221                 ACPI_ROUND_DOWN (FieldByteOffset, AccessByteWidth) /
 222                 AccessByteWidth;
 223
 224             FieldEndOffset =
 225                 ACPI_ROUND_UP ((FieldByteLength + FieldByteOffset),
 226                     AccessByteWidth) / AccessByteWidth;
 227
 228             Accesses = FieldEndOffset - FieldStartOffset;
 229
 230             ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 231                 "AccessWidth %u end is within region\n", AccessByteWidth));
 232
 233             ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 234                 "Field Start %u, Field End %u -- requires %u accesses\n",
 235                 FieldStartOffset, FieldEndOffset, Accesses));
 236
 237             /* Single access is optimal */
 238
 239             if (Accesses <= 1)
 240             {
 241                 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 242                     "Entire field can be accessed with one operation of size %u\n",
 243                     AccessByteWidth));
 244                 return_VALUE (AccessByteWidth);
 245             }
 246
 247             /*
 248              * Fits in the region, but requires more than one read/write.
 249              * try the next wider access on next iteration
 250              */
 251             if (Accesses < MinimumAccesses)
 252             {
 253                 MinimumAccesses    = Accesses;
 254                 MinimumAccessWidth = AccessByteWidth;
 255             }
 256         }
 257         else
 258         {
 259             ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 260                 "AccessWidth %u end is NOT within region\n", AccessByteWidth));
 261             if (AccessByteWidth == 1)
 262             {
 263                 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 264                     "Field goes beyond end-of-region!\n"));
 265
 266                 /* Field does not fit in the region at all */
 267
 268                 return_VALUE (0);
 269             }
 270
 271             /*
 272              * This width goes beyond the end-of-region, back off to
 273              * previous access
 274              */
 275             ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 276                 "Backing off to previous optimal access width of %u\n",
 277                 MinimumAccessWidth));
 278             return_VALUE (MinimumAccessWidth);
 279         }
 280     }
 281
 282     /*
 283      * Could not read/write field with one operation,
 284      * just use max access width
 285      */
 286     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 287         "Cannot access field in one operation, using width 8\n"));
 288     return_VALUE (8);
 289 }
 290 #endif /* ACPI_UNDER_DEVELOPMENT */
 291
 292
 293 /*******************************************************************************
 294  *
 295  * FUNCTION:    AcpiExDecodeFieldAccess
 296  *
 297  * PARAMETERS:  ObjDesc             - Field object
 298  *              FieldFlags          - Encoded fieldflags (contains access bits)
 299  *              ReturnByteAlignment - Where the byte alignment is returned
 300  *
 301  * RETURN:      Field granularity (8, 16, 32 or 64) and
 302  *              ByteAlignment (1, 2, 3, or 4)
 303  *
 304  * DESCRIPTION: Decode the AccessType bits of a field definition.
 305  *
 306  ******************************************************************************/
 307
 308 static UINT32
 309 AcpiExDecodeFieldAccess (
 310     ACPI_OPERAND_OBJECT     *ObjDesc,
 311     UINT8                   FieldFlags,
 312     UINT32                  *ReturnByteAlignment)
 313 {
 314     UINT32                  Access;
 315     UINT32                  ByteAlignment;
 316     UINT32                  BitLength;
 317
 318
 319     ACPI_FUNCTION_TRACE (ExDecodeFieldAccess);
 320
 321
 322     Access = (FieldFlags & AML_FIELD_ACCESS_TYPE_MASK);
 323
 324     switch (Access)
 325     {
 326     case AML_FIELD_ACCESS_ANY:
 327
 328 #ifdef ACPI_UNDER_DEVELOPMENT
 329         ByteAlignment =
 330             AcpiExGenerateAccess (ObjDesc->CommonField.StartFieldBitOffset,
 331                 ObjDesc->CommonField.BitLength,
 332                 0xFFFFFFFF /* Temp until we pass RegionLength as parameter */);
 333         BitLength = ByteAlignment * 8;
 334 #endif
 335
 336         ByteAlignment = 1;
 337         BitLength = 8;
 338         break;
 339
 340     case AML_FIELD_ACCESS_BYTE:
 341     case AML_FIELD_ACCESS_BUFFER:   /* ACPI 2.0 (SMBus Buffer) */
 342         ByteAlignment = 1;
 343         BitLength     = 8;
 344         break;
 345
 346     case AML_FIELD_ACCESS_WORD:
 347         ByteAlignment = 2;
 348         BitLength     = 16;
 349         break;
 350
 351     case AML_FIELD_ACCESS_DWORD:
 352         ByteAlignment = 4;
 353         BitLength     = 32;
 354         break;
 355
 356     case AML_FIELD_ACCESS_QWORD:    /* ACPI 2.0 */
 357         ByteAlignment = 8;
 358         BitLength     = 64;
 359         break;
 360
 361     default:
 362         /* Invalid field access type */
 363
 364         ACPI_ERROR ((AE_INFO,
 365             "Unknown field access type 0x%X",
 366             Access));
 367         return_UINT32 (0);
 368     }
 369
 370     if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
 371     {
 372         /*
 373          * BufferField access can be on any byte boundary, so the
 374          * ByteAlignment is always 1 byte -- regardless of any ByteAlignment
 375          * implied by the field access type.
 376          */
 377         ByteAlignment = 1;
 378     }
 379
 380     *ReturnByteAlignment = ByteAlignment;
 381     return_UINT32 (BitLength);
 382 }
 383
 384
 385 /*******************************************************************************
 386  *
 387  * FUNCTION:    AcpiExPrepCommonFieldObject
 388  *
 389  * PARAMETERS:  ObjDesc             - The field object
 390  *              FieldFlags          - Access, LockRule, and UpdateRule.
 391  *                                    The format of a FieldFlag is described
 392  *                                    in the ACPI specification
 393  *              FieldAttribute      - Special attributes (not used)
 394  *              FieldBitPosition    - Field start position
 395  *              FieldBitLength      - Field length in number of bits
 396  *
 397  * RETURN:      Status
 398  *
 399  * DESCRIPTION: Initialize the areas of the field object that are common
 400  *              to the various types of fields.  Note: This is very "sensitive"
 401  *              code because we are solving the general case for field
 402  *              alignment.
 403  *
 404  ******************************************************************************/
 405
 406 ACPI_STATUS
 407 AcpiExPrepCommonFieldObject (
 408     ACPI_OPERAND_OBJECT     *ObjDesc,
 409     UINT8                   FieldFlags,
 410     UINT8                   FieldAttribute,
 411     UINT32                  FieldBitPosition,
 412     UINT32                  FieldBitLength)
 413 {
 414     UINT32                  AccessBitWidth;
 415     UINT32                  ByteAlignment;
 416     UINT32                  NearestByteAddress;
 417
 418
 419     ACPI_FUNCTION_TRACE (ExPrepCommonFieldObject);
 420
 421
 422     /*
 423      * Note: the structure being initialized is the
 424      * ACPI_COMMON_FIELD_INFO;  No structure fields outside of the common
 425      * area are initialized by this procedure.
 426      */
 427     ObjDesc->CommonField.FieldFlags = FieldFlags;
 428     ObjDesc->CommonField.Attribute  = FieldAttribute;
 429     ObjDesc->CommonField.BitLength  = FieldBitLength;
 430
 431     /*
 432      * Decode the access type so we can compute offsets.  The access type gives
 433      * two pieces of information - the width of each field access and the
 434      * necessary ByteAlignment (address granularity) of the access.
 435      *
 436      * For AnyAcc, the AccessBitWidth is the largest width that is both
 437      * necessary and possible in an attempt to access the whole field in one
 438      * I/O operation.  However, for AnyAcc, the ByteAlignment is always one
 439      * byte.
 440      *
 441      * For all Buffer Fields, the ByteAlignment is always one byte.
 442      *
 443      * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is
 444      * the same (equivalent) as the ByteAlignment.
 445      */
 446     AccessBitWidth = AcpiExDecodeFieldAccess (ObjDesc, FieldFlags,
 447                         &ByteAlignment);
 448     if (!AccessBitWidth)
 449     {
 450         return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
 451     }
 452
 453     /* Setup width (access granularity) fields (values are: 1, 2, 4, 8) */
 454
 455     ObjDesc->CommonField.AccessByteWidth = (UINT8)
 456         ACPI_DIV_8 (AccessBitWidth);
 457
 458     /*
 459      * BaseByteOffset is the address of the start of the field within the
 460      * region.  It is the byte address of the first *datum* (field-width data
 461      * unit) of the field. (i.e., the first datum that contains at least the
 462      * first *bit* of the field.)
 463      *
 464      * Note: ByteAlignment is always either equal to the AccessBitWidth or 8
 465      * (Byte access), and it defines the addressing granularity of the parent
 466      * region or buffer.
 467      */
 468     NearestByteAddress =
 469         ACPI_ROUND_BITS_DOWN_TO_BYTES (FieldBitPosition);
 470     ObjDesc->CommonField.BaseByteOffset = (UINT32)
 471         ACPI_ROUND_DOWN (NearestByteAddress, ByteAlignment);
 472
 473     /*
 474      * StartFieldBitOffset is the offset of the first bit of the field within
 475      * a field datum.
 476      */
 477     ObjDesc->CommonField.StartFieldBitOffset = (UINT8)
 478         (FieldBitPosition - ACPI_MUL_8 (ObjDesc->CommonField.BaseByteOffset));
 479
 480     return_ACPI_STATUS (AE_OK);
 481 }
 482
 483
 484 /*******************************************************************************
 485  *
 486  * FUNCTION:    AcpiExPrepFieldValue
 487  *
 488  * PARAMETERS:  Info    - Contains all field creation info
 489  *
 490  * RETURN:      Status
 491  *
 492  * DESCRIPTION: Construct an ACPI_OPERAND_OBJECT of type DefField and
 493  *              connect it to the parent Node.
 494  *
 495  ******************************************************************************/
 496
 497 ACPI_STATUS
 498 AcpiExPrepFieldValue (
 499     ACPI_CREATE_FIELD_INFO  *Info)
 500 {
 501     ACPI_OPERAND_OBJECT     *ObjDesc;
 502     ACPI_OPERAND_OBJECT     *SecondDesc = NULL;
 503     ACPI_STATUS             Status;
 504     UINT32                  AccessByteWidth;
 505     UINT32                  Type;
 506
 507
 508     ACPI_FUNCTION_TRACE (ExPrepFieldValue);
 509
 510
 511     /* Parameter validation */
 512
 513     if (Info->FieldType != ACPI_TYPE_LOCAL_INDEX_FIELD)
 514     {
 515         if (!Info->RegionNode)
 516         {
 517             ACPI_ERROR ((AE_INFO, "Null RegionNode"));
 518             return_ACPI_STATUS (AE_AML_NO_OPERAND);
 519         }
 520
 521         Type = AcpiNsGetType (Info->RegionNode);
 522         if (Type != ACPI_TYPE_REGION)
 523         {
 524             ACPI_ERROR ((AE_INFO, "Needed Region, found type 0x%X (%s)",
 525                 Type, AcpiUtGetTypeName (Type)));
 526
 527             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 528         }
 529     }
 530
 531     /* Allocate a new field object */
 532
 533     ObjDesc = AcpiUtCreateInternalObject (Info->FieldType);
 534     if (!ObjDesc)
 535     {
 536         return_ACPI_STATUS (AE_NO_MEMORY);
 537     }
 538
 539     /* Initialize areas of the object that are common to all fields */
 540
 541     ObjDesc->CommonField.Node = Info->FieldNode;
 542     Status = AcpiExPrepCommonFieldObject (ObjDesc,
 543                 Info->FieldFlags, Info->Attribute,
 544                 Info->FieldBitPosition, Info->FieldBitLength);
 545     if (ACPI_FAILURE (Status))
 546     {
 547         AcpiUtDeleteObjectDesc (ObjDesc);
 548         return_ACPI_STATUS (Status);
 549     }
 550
 551     /* Initialize areas of the object that are specific to the field type */
 552
 553     switch (Info->FieldType)
 554     {
 555     case ACPI_TYPE_LOCAL_REGION_FIELD:
 556
 557         ObjDesc->Field.RegionObj = AcpiNsGetAttachedObject (Info->RegionNode);
 558
 559         /* Allow full data read from EC address space */
 560
 561         if ((ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_EC) &&
 562             (ObjDesc->CommonField.BitLength > 8))
 563         {
 564             AccessByteWidth = ACPI_ROUND_BITS_UP_TO_BYTES (
 565                 ObjDesc->CommonField.BitLength);
 566
 567             /* Maximum byte width supported is 255 */
 568
 569             if (AccessByteWidth < 256)
 570             {
 571                 ObjDesc->CommonField.AccessByteWidth = (UINT8) AccessByteWidth;
 572             }
 573         }
 574
 575         /* An additional reference for the container */
 576
 577         AcpiUtAddReference (ObjDesc->Field.RegionObj);
 578
 579         ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 580             "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n",
 581             ObjDesc->Field.StartFieldBitOffset, ObjDesc->Field.BaseByteOffset,
 582             ObjDesc->Field.AccessByteWidth, ObjDesc->Field.RegionObj));
 583         break;
 584
 585
 586     case ACPI_TYPE_LOCAL_BANK_FIELD:
 587
 588         ObjDesc->BankField.Value = Info->BankValue;
 589         ObjDesc->BankField.RegionObj =
 590             AcpiNsGetAttachedObject (Info->RegionNode);
 591         ObjDesc->BankField.BankObj =
 592             AcpiNsGetAttachedObject (Info->RegisterNode);
 593
 594         /* An additional reference for the attached objects */
 595
 596         AcpiUtAddReference (ObjDesc->BankField.RegionObj);
 597         AcpiUtAddReference (ObjDesc->BankField.BankObj);
 598
 599         ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 600             "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n",
 601             ObjDesc->BankField.StartFieldBitOffset,
 602             ObjDesc->BankField.BaseByteOffset,
 603             ObjDesc->Field.AccessByteWidth,
 604             ObjDesc->BankField.RegionObj,
 605             ObjDesc->BankField.BankObj));
 606
 607         /*
 608          * Remember location in AML stream of the field unit
 609          * opcode and operands -- since the BankValue
 610          * operands must be evaluated.
 611          */
 612         SecondDesc = ObjDesc->Common.NextObject;
 613         SecondDesc->Extra.AmlStart = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
 614             Info->DataRegisterNode)->Named.Data;
 615         SecondDesc->Extra.AmlLength = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
 616             Info->DataRegisterNode)->Named.Length;
 617
 618         break;
 619
 620
 621     case ACPI_TYPE_LOCAL_INDEX_FIELD:
 622
 623         /* Get the Index and Data registers */
 624
 625         ObjDesc->IndexField.IndexObj =
 626             AcpiNsGetAttachedObject (Info->RegisterNode);
 627         ObjDesc->IndexField.DataObj =
 628             AcpiNsGetAttachedObject (Info->DataRegisterNode);
 629
 630         if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj)
 631         {
 632             ACPI_ERROR ((AE_INFO, "Null Index Object during field prep"));
 633             AcpiUtDeleteObjectDesc (ObjDesc);
 634             return_ACPI_STATUS (AE_AML_INTERNAL);
 635         }
 636
 637         /* An additional reference for the attached objects */
 638
 639         AcpiUtAddReference (ObjDesc->IndexField.DataObj);
 640         AcpiUtAddReference (ObjDesc->IndexField.IndexObj);
 641
 642         /*
 643          * April 2006: Changed to match MS behavior
 644          *
 645          * The value written to the Index register is the byte offset of the
 646          * target field in units of the granularity of the IndexField
 647          *
 648          * Previously, the value was calculated as an index in terms of the
 649          * width of the Data register, as below:
 650          *
 651          *      ObjDesc->IndexField.Value = (UINT32)
 652          *          (Info->FieldBitPosition / ACPI_MUL_8 (
 653          *              ObjDesc->Field.AccessByteWidth));
 654          *
 655          * February 2006: Tried value as a byte offset:
 656          *      ObjDesc->IndexField.Value = (UINT32)
 657          *          ACPI_DIV_8 (Info->FieldBitPosition);
 658          */
 659         ObjDesc->IndexField.Value = (UINT32) ACPI_ROUND_DOWN (
 660             ACPI_DIV_8 (Info->FieldBitPosition),
 661             ObjDesc->IndexField.AccessByteWidth);
 662
 663         ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 664             "IndexField: BitOff %X, Off %X, Value %X, Gran %X, Index %p, Data %p\n",
 665             ObjDesc->IndexField.StartFieldBitOffset,
 666             ObjDesc->IndexField.BaseByteOffset,
 667             ObjDesc->IndexField.Value,
 668             ObjDesc->Field.AccessByteWidth,
 669             ObjDesc->IndexField.IndexObj,
 670             ObjDesc->IndexField.DataObj));
 671         break;
 672
 673     default:
 674         /* No other types should get here */
 675         break;
 676     }
 677
 678     /*
 679      * Store the constructed descriptor (ObjDesc) into the parent Node,
 680      * preserving the current type of that NamedObj.
 681      */
 682     Status = AcpiNsAttachObject (Info->FieldNode, ObjDesc,
 683                 AcpiNsGetType (Info->FieldNode));
 684
 685     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Set NamedObj %p [%4.4s], ObjDesc %p\n",
 686         Info->FieldNode, AcpiUtGetNodeName (Info->FieldNode), ObjDesc));
 687
 688     /* Remove local reference to the object */
 689
 690     AcpiUtRemoveReference (ObjDesc);
 691     return_ACPI_STATUS (Status);
 692 }
 693