drivers/bus/acpi/acpica/executer/exprep.c

   1 /******************************************************************************
   2  *
   3  * Module Name: exprep - ACPI AML field prep utilities
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2017, 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 "acinterp.h"
  47 #include "amlcode.h"
  48 #include "acnamesp.h"
  49 #include "acdispat.h"
  50
  51
  52 #define _COMPONENT          ACPI_EXECUTER
  53         ACPI_MODULE_NAME    ("exprep")
  54
  55 /* Local prototypes */
  56
  57 static UINT32
  58 AcpiExDecodeFieldAccess (
  59     ACPI_OPERAND_OBJECT     *ObjDesc,
  60     UINT8                   FieldFlags,
  61     UINT32                  *ReturnByteAlignment);
  62
  63
  64 #ifdef ACPI_UNDER_DEVELOPMENT
  65
  66 static UINT32
  67 AcpiExGenerateAccess (
  68     UINT32                  FieldBitOffset,
  69     UINT32                  FieldBitLength,
  70     UINT32                  RegionLength);
  71
  72
  73 /*******************************************************************************
  74  *
  75  * FUNCTION:    AcpiExGenerateAccess
  76  *
  77  * PARAMETERS:  FieldBitOffset      - Start of field within parent region/buffer
  78  *              FieldBitLength      - Length of field in bits
  79  *              RegionLength        - Length of parent in bytes
  80  *
  81  * RETURN:      Field granularity (8, 16, 32 or 64) and
  82  *              ByteAlignment (1, 2, 3, or 4)
  83  *
  84  * DESCRIPTION: Generate an optimal access width for fields defined with the
  85  *              AnyAcc keyword.
  86  *
  87  * NOTE: Need to have the RegionLength in order to check for boundary
  88  *       conditions (end-of-region). However, the RegionLength is a deferred
  89  *       operation. Therefore, to complete this implementation, the generation
  90  *       of this access width must be deferred until the region length has
  91  *       been evaluated.
  92  *
  93  ******************************************************************************/
  94
  95 static UINT32
  96 AcpiExGenerateAccess (
  97     UINT32                  FieldBitOffset,
  98     UINT32                  FieldBitLength,
  99     UINT32                  RegionLength)
 100 {
 101     UINT32                  FieldByteLength;
 102     UINT32                  FieldByteOffset;
 103     UINT32                  FieldByteEndOffset;
 104     UINT32                  AccessByteWidth;
 105     UINT32                  FieldStartOffset;
 106     UINT32                  FieldEndOffset;
 107     UINT32                  MinimumAccessWidth = 0xFFFFFFFF;
 108     UINT32                  MinimumAccesses = 0xFFFFFFFF;
 109     UINT32                  Accesses;
 110
 111
 112     ACPI_FUNCTION_TRACE (ExGenerateAccess);
 113
 114
 115     /* Round Field start offset and length to "minimal" byte boundaries */
 116
 117     FieldByteOffset = ACPI_DIV_8 (
 118         ACPI_ROUND_DOWN (FieldBitOffset, 8));
 119
 120     FieldByteEndOffset = ACPI_DIV_8 (
 121         ACPI_ROUND_UP (FieldBitLength + FieldBitOffset, 8));
 122
 123     FieldByteLength = FieldByteEndOffset - FieldByteOffset;
 124
 125     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 126         "Bit length %u, Bit offset %u\n",
 127         FieldBitLength, FieldBitOffset));
 128
 129     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 130         "Byte Length %u, Byte Offset %u, End Offset %u\n",
 131         FieldByteLength, FieldByteOffset, FieldByteEndOffset));
 132
 133     /*
 134      * Iterative search for the maximum access width that is both aligned
 135      * and does not go beyond the end of the region
 136      *
 137      * Start at ByteAcc and work upwards to QwordAcc max. (1,2,4,8 bytes)
 138      */
 139     for (AccessByteWidth = 1; AccessByteWidth <= 8; AccessByteWidth <<= 1)
 140     {
 141         /*
 142          * 1) Round end offset up to next access boundary and make sure that
 143          *    this does not go beyond the end of the parent region.
 144          * 2) When the Access width is greater than the FieldByteLength, we
 145          *    are done. (This does not optimize for the perfectly aligned
 146          *    case yet).
 147          */
 148         if (ACPI_ROUND_UP (FieldByteEndOffset, AccessByteWidth) <=
 149             RegionLength)
 150         {
 151             FieldStartOffset =
 152                 ACPI_ROUND_DOWN (FieldByteOffset, AccessByteWidth) /
 153                 AccessByteWidth;
 154
 155             FieldEndOffset =
 156                 ACPI_ROUND_UP ((FieldByteLength + FieldByteOffset),
 157                     AccessByteWidth) / AccessByteWidth;
 158
 159             Accesses = FieldEndOffset - FieldStartOffset;
 160
 161             ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 162                 "AccessWidth %u end is within region\n", AccessByteWidth));
 163
 164             ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 165                 "Field Start %u, Field End %u -- requires %u accesses\n",
 166                 FieldStartOffset, FieldEndOffset, Accesses));
 167
 168             /* Single access is optimal */
 169
 170             if (Accesses <= 1)
 171             {
 172                 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 173                     "Entire field can be accessed "
 174                     "with one operation of size %u\n",
 175                     AccessByteWidth));
 176                 return_VALUE (AccessByteWidth);
 177             }
 178
 179             /*
 180              * Fits in the region, but requires more than one read/write.
 181              * try the next wider access on next iteration
 182              */
 183             if (Accesses < MinimumAccesses)
 184             {
 185                 MinimumAccesses = Accesses;
 186                 MinimumAccessWidth = AccessByteWidth;
 187             }
 188         }
 189         else
 190         {
 191             ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 192                 "AccessWidth %u end is NOT within region\n",
 193                 AccessByteWidth));
 194             if (AccessByteWidth == 1)
 195             {
 196                 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 197                     "Field goes beyond end-of-region!\n"));
 198
 199                 /* Field does not fit in the region at all */
 200
 201                 return_VALUE (0);
 202             }
 203
 204             /*
 205              * This width goes beyond the end-of-region, back off to
 206              * previous access
 207              */
 208             ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 209                 "Backing off to previous optimal access width of %u\n",
 210                 MinimumAccessWidth));
 211             return_VALUE (MinimumAccessWidth);
 212         }
 213     }
 214
 215     /*
 216      * Could not read/write field with one operation,
 217      * just use max access width
 218      */
 219     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 220         "Cannot access field in one operation, using width 8\n"));
 221
 222     return_VALUE (8);
 223 }
 224 #endif /* ACPI_UNDER_DEVELOPMENT */
 225
 226
 227 /*******************************************************************************
 228  *
 229  * FUNCTION:    AcpiExDecodeFieldAccess
 230  *
 231  * PARAMETERS:  ObjDesc             - Field object
 232  *              FieldFlags          - Encoded fieldflags (contains access bits)
 233  *              ReturnByteAlignment - Where the byte alignment is returned
 234  *
 235  * RETURN:      Field granularity (8, 16, 32 or 64) and
 236  *              ByteAlignment (1, 2, 3, or 4)
 237  *
 238  * DESCRIPTION: Decode the AccessType bits of a field definition.
 239  *
 240  ******************************************************************************/
 241
 242 static UINT32
 243 AcpiExDecodeFieldAccess (
 244     ACPI_OPERAND_OBJECT     *ObjDesc,
 245     UINT8                   FieldFlags,
 246     UINT32                  *ReturnByteAlignment)
 247 {
 248     UINT32                  Access;
 249     UINT32                  ByteAlignment;
 250     UINT32                  BitLength;
 251
 252
 253     ACPI_FUNCTION_TRACE (ExDecodeFieldAccess);
 254
 255
 256     Access = (FieldFlags & AML_FIELD_ACCESS_TYPE_MASK);
 257
 258     switch (Access)
 259     {
 260     case AML_FIELD_ACCESS_ANY:
 261
 262 #ifdef ACPI_UNDER_DEVELOPMENT
 263         ByteAlignment =
 264             AcpiExGenerateAccess (ObjDesc->CommonField.StartFieldBitOffset,
 265                 ObjDesc->CommonField.BitLength,
 266                 0xFFFFFFFF /* Temp until we pass RegionLength as parameter */);
 267         BitLength = ByteAlignment * 8;
 268 #endif
 269
 270         ByteAlignment = 1;
 271         BitLength = 8;
 272         break;
 273
 274     case AML_FIELD_ACCESS_BYTE:
 275     case AML_FIELD_ACCESS_BUFFER:   /* ACPI 2.0 (SMBus Buffer) */
 276
 277         ByteAlignment = 1;
 278         BitLength     = 8;
 279         break;
 280
 281     case AML_FIELD_ACCESS_WORD:
 282
 283         ByteAlignment = 2;
 284         BitLength     = 16;
 285         break;
 286
 287     case AML_FIELD_ACCESS_DWORD:
 288
 289         ByteAlignment = 4;
 290         BitLength     = 32;
 291         break;
 292
 293     case AML_FIELD_ACCESS_QWORD:    /* ACPI 2.0 */
 294
 295         ByteAlignment = 8;
 296         BitLength     = 64;
 297         break;
 298
 299     default:
 300
 301         /* Invalid field access type */
 302
 303         ACPI_ERROR ((AE_INFO,
 304             "Unknown field access type 0x%X",
 305             Access));
 306
 307         return_UINT32 (0);
 308     }
 309
 310     if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
 311     {
 312         /*
 313          * BufferField access can be on any byte boundary, so the
 314          * ByteAlignment is always 1 byte -- regardless of any ByteAlignment
 315          * implied by the field access type.
 316          */
 317         ByteAlignment = 1;
 318     }
 319
 320     *ReturnByteAlignment = ByteAlignment;
 321     return_UINT32 (BitLength);
 322 }
 323
 324
 325 /*******************************************************************************
 326  *
 327  * FUNCTION:    AcpiExPrepCommonFieldObject
 328  *
 329  * PARAMETERS:  ObjDesc             - The field object
 330  *              FieldFlags          - Access, LockRule, and UpdateRule.
 331  *                                    The format of a FieldFlag is described
 332  *                                    in the ACPI specification
 333  *              FieldAttribute      - Special attributes (not used)
 334  *              FieldBitPosition    - Field start position
 335  *              FieldBitLength      - Field length in number of bits
 336  *
 337  * RETURN:      Status
 338  *
 339  * DESCRIPTION: Initialize the areas of the field object that are common
 340  *              to the various types of fields. Note: This is very "sensitive"
 341  *              code because we are solving the general case for field
 342  *              alignment.
 343  *
 344  ******************************************************************************/
 345
 346 ACPI_STATUS
 347 AcpiExPrepCommonFieldObject (
 348     ACPI_OPERAND_OBJECT     *ObjDesc,
 349     UINT8                   FieldFlags,
 350     UINT8                   FieldAttribute,
 351     UINT32                  FieldBitPosition,
 352     UINT32                  FieldBitLength)
 353 {
 354     UINT32                  AccessBitWidth;
 355     UINT32                  ByteAlignment;
 356     UINT32                  NearestByteAddress;
 357
 358
 359     ACPI_FUNCTION_TRACE (ExPrepCommonFieldObject);
 360
 361
 362     /*
 363      * Note: the structure being initialized is the
 364      * ACPI_COMMON_FIELD_INFO;  No structure fields outside of the common
 365      * area are initialized by this procedure.
 366      */
 367     ObjDesc->CommonField.FieldFlags = FieldFlags;
 368     ObjDesc->CommonField.Attribute  = FieldAttribute;
 369     ObjDesc->CommonField.BitLength  = FieldBitLength;
 370
 371     /*
 372      * Decode the access type so we can compute offsets. The access type gives
 373      * two pieces of information - the width of each field access and the
 374      * necessary ByteAlignment (address granularity) of the access.
 375      *
 376      * For AnyAcc, the AccessBitWidth is the largest width that is both
 377      * necessary and possible in an attempt to access the whole field in one
 378      * I/O operation. However, for AnyAcc, the ByteAlignment is always one
 379      * byte.
 380      *
 381      * For all Buffer Fields, the ByteAlignment is always one byte.
 382      *
 383      * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is
 384      * the same (equivalent) as the ByteAlignment.
 385      */
 386     AccessBitWidth = AcpiExDecodeFieldAccess (
 387         ObjDesc, FieldFlags, &ByteAlignment);
 388     if (!AccessBitWidth)
 389     {
 390         return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
 391     }
 392
 393     /* Setup width (access granularity) fields (values are: 1, 2, 4, 8) */
 394
 395     ObjDesc->CommonField.AccessByteWidth = (UINT8)
 396         ACPI_DIV_8 (AccessBitWidth);
 397
 398     /*
 399      * BaseByteOffset is the address of the start of the field within the
 400      * region. It is the byte address of the first *datum* (field-width data
 401      * unit) of the field. (i.e., the first datum that contains at least the
 402      * first *bit* of the field.)
 403      *
 404      * Note: ByteAlignment is always either equal to the AccessBitWidth or 8
 405      * (Byte access), and it defines the addressing granularity of the parent
 406      * region or buffer.
 407      */
 408     NearestByteAddress =
 409         ACPI_ROUND_BITS_DOWN_TO_BYTES (FieldBitPosition);
 410     ObjDesc->CommonField.BaseByteOffset = (UINT32)
 411         ACPI_ROUND_DOWN (NearestByteAddress, ByteAlignment);
 412
 413     /*
 414      * StartFieldBitOffset is the offset of the first bit of the field within
 415      * a field datum.
 416      */
 417     ObjDesc->CommonField.StartFieldBitOffset = (UINT8)
 418         (FieldBitPosition - ACPI_MUL_8 (ObjDesc->CommonField.BaseByteOffset));
 419
 420     return_ACPI_STATUS (AE_OK);
 421 }
 422
 423
 424 /*******************************************************************************
 425  *
 426  * FUNCTION:    AcpiExPrepFieldValue
 427  *
 428  * PARAMETERS:  Info    - Contains all field creation info
 429  *
 430  * RETURN:      Status
 431  *
 432  * DESCRIPTION: Construct an object of type ACPI_OPERAND_OBJECT with a
 433  *              subtype of DefField and connect it to the parent Node.
 434  *
 435  ******************************************************************************/
 436
 437 ACPI_STATUS
 438 AcpiExPrepFieldValue (
 439     ACPI_CREATE_FIELD_INFO  *Info)
 440 {
 441     ACPI_OPERAND_OBJECT     *ObjDesc;
 442     ACPI_OPERAND_OBJECT     *SecondDesc = NULL;
 443     ACPI_STATUS             Status;
 444     UINT32                  AccessByteWidth;
 445     UINT32                  Type;
 446
 447
 448     ACPI_FUNCTION_TRACE (ExPrepFieldValue);
 449
 450
 451     /* Parameter validation */
 452
 453     if (Info->FieldType != ACPI_TYPE_LOCAL_INDEX_FIELD)
 454     {
 455         if (!Info->RegionNode)
 456         {
 457             ACPI_ERROR ((AE_INFO, "Null RegionNode"));
 458             return_ACPI_STATUS (AE_AML_NO_OPERAND);
 459         }
 460
 461         Type = AcpiNsGetType (Info->RegionNode);
 462         if (Type != ACPI_TYPE_REGION)
 463         {
 464             ACPI_ERROR ((AE_INFO, "Needed Region, found type 0x%X (%s)",
 465                 Type, AcpiUtGetTypeName (Type)));
 466
 467             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 468         }
 469     }
 470
 471     /* Allocate a new field object */
 472
 473     ObjDesc = AcpiUtCreateInternalObject (Info->FieldType);
 474     if (!ObjDesc)
 475     {
 476         return_ACPI_STATUS (AE_NO_MEMORY);
 477     }
 478
 479     /* Initialize areas of the object that are common to all fields */
 480
 481     ObjDesc->CommonField.Node = Info->FieldNode;
 482     Status = AcpiExPrepCommonFieldObject (ObjDesc,
 483         Info->FieldFlags, Info->Attribute,
 484         Info->FieldBitPosition, Info->FieldBitLength);
 485     if (ACPI_FAILURE (Status))
 486     {
 487         AcpiUtDeleteObjectDesc (ObjDesc);
 488         return_ACPI_STATUS (Status);
 489     }
 490
 491     /* Initialize areas of the object that are specific to the field type */
 492
 493     switch (Info->FieldType)
 494     {
 495     case ACPI_TYPE_LOCAL_REGION_FIELD:
 496
 497         ObjDesc->Field.RegionObj = AcpiNsGetAttachedObject (Info->RegionNode);
 498
 499         /* Fields specific to GenericSerialBus fields */
 500
 501         ObjDesc->Field.AccessLength = Info->AccessLength;
 502
 503         if (Info->ConnectionNode)
 504         {
 505             SecondDesc = Info->ConnectionNode->Object;
 506             if (!(SecondDesc->Common.Flags & AOPOBJ_DATA_VALID))
 507             {
 508                 Status = AcpiDsGetBufferArguments (SecondDesc);
 509                 if (ACPI_FAILURE (Status))
 510                 {
 511                     AcpiUtDeleteObjectDesc (ObjDesc);
 512                     return_ACPI_STATUS (Status);
 513                 }
 514             }
 515
 516             ObjDesc->Field.ResourceBuffer =
 517                 SecondDesc->Buffer.Pointer;
 518             ObjDesc->Field.ResourceLength =
 519                 (UINT16) SecondDesc->Buffer.Length;
 520         }
 521         else if (Info->ResourceBuffer)
 522         {
 523             ObjDesc->Field.ResourceBuffer = Info->ResourceBuffer;
 524             ObjDesc->Field.ResourceLength = Info->ResourceLength;
 525         }
 526
 527         ObjDesc->Field.PinNumberIndex = Info->PinNumberIndex;
 528
 529         /* Allow full data read from EC address space */
 530
 531         if ((ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_EC) &&
 532             (ObjDesc->CommonField.BitLength > 8))
 533         {
 534             AccessByteWidth = ACPI_ROUND_BITS_UP_TO_BYTES (
 535                 ObjDesc->CommonField.BitLength);
 536
 537             /* Maximum byte width supported is 255 */
 538
 539             if (AccessByteWidth < 256)
 540             {
 541                 ObjDesc->CommonField.AccessByteWidth =
 542                     (UINT8) AccessByteWidth;
 543             }
 544         }
 545
 546         /* An additional reference for the container */
 547
 548         AcpiUtAddReference (ObjDesc->Field.RegionObj);
 549
 550         ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 551             "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n",
 552             ObjDesc->Field.StartFieldBitOffset,
 553             ObjDesc->Field.BaseByteOffset,
 554             ObjDesc->Field.AccessByteWidth,
 555             ObjDesc->Field.RegionObj));
 556         break;
 557
 558     case ACPI_TYPE_LOCAL_BANK_FIELD:
 559
 560         ObjDesc->BankField.Value = Info->BankValue;
 561         ObjDesc->BankField.RegionObj =
 562             AcpiNsGetAttachedObject (Info->RegionNode);
 563         ObjDesc->BankField.BankObj =
 564             AcpiNsGetAttachedObject (Info->RegisterNode);
 565
 566         /* An additional reference for the attached objects */
 567
 568         AcpiUtAddReference (ObjDesc->BankField.RegionObj);
 569         AcpiUtAddReference (ObjDesc->BankField.BankObj);
 570
 571         ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 572             "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n",
 573             ObjDesc->BankField.StartFieldBitOffset,
 574             ObjDesc->BankField.BaseByteOffset,
 575             ObjDesc->Field.AccessByteWidth,
 576             ObjDesc->BankField.RegionObj,
 577             ObjDesc->BankField.BankObj));
 578
 579         /*
 580          * Remember location in AML stream of the field unit
 581          * opcode and operands -- since the BankValue
 582          * operands must be evaluated.
 583          */
 584         SecondDesc = ObjDesc->Common.NextObject;
 585         SecondDesc->Extra.AmlStart = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
 586             Info->DataRegisterNode)->Named.Data;
 587         SecondDesc->Extra.AmlLength = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
 588             Info->DataRegisterNode)->Named.Length;
 589
 590         break;
 591
 592     case ACPI_TYPE_LOCAL_INDEX_FIELD:
 593
 594         /* Get the Index and Data registers */
 595
 596         ObjDesc->IndexField.IndexObj =
 597             AcpiNsGetAttachedObject (Info->RegisterNode);
 598         ObjDesc->IndexField.DataObj =
 599             AcpiNsGetAttachedObject (Info->DataRegisterNode);
 600
 601         if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj)
 602         {
 603             ACPI_ERROR ((AE_INFO, "Null Index Object during field prep"));
 604             AcpiUtDeleteObjectDesc (ObjDesc);
 605             return_ACPI_STATUS (AE_AML_INTERNAL);
 606         }
 607
 608         /* An additional reference for the attached objects */
 609
 610         AcpiUtAddReference (ObjDesc->IndexField.DataObj);
 611         AcpiUtAddReference (ObjDesc->IndexField.IndexObj);
 612
 613         /*
 614          * April 2006: Changed to match MS behavior
 615          *
 616          * The value written to the Index register is the byte offset of the
 617          * target field in units of the granularity of the IndexField
 618          *
 619          * Previously, the value was calculated as an index in terms of the
 620          * width of the Data register, as below:
 621          *
 622          *      ObjDesc->IndexField.Value = (UINT32)
 623          *          (Info->FieldBitPosition / ACPI_MUL_8 (
 624          *              ObjDesc->Field.AccessByteWidth));
 625          *
 626          * February 2006: Tried value as a byte offset:
 627          *      ObjDesc->IndexField.Value = (UINT32)
 628          *          ACPI_DIV_8 (Info->FieldBitPosition);
 629          */
 630         ObjDesc->IndexField.Value = (UINT32) ACPI_ROUND_DOWN (
 631             ACPI_DIV_8 (Info->FieldBitPosition),
 632             ObjDesc->IndexField.AccessByteWidth);
 633
 634         ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 635             "IndexField: BitOff %X, Off %X, Value %X, "
 636             "Gran %X, Index %p, Data %p\n",
 637             ObjDesc->IndexField.StartFieldBitOffset,
 638             ObjDesc->IndexField.BaseByteOffset,
 639             ObjDesc->IndexField.Value,
 640             ObjDesc->Field.AccessByteWidth,
 641             ObjDesc->IndexField.IndexObj,
 642             ObjDesc->IndexField.DataObj));
 643         break;
 644
 645     default:
 646
 647         /* No other types should get here */
 648
 649         break;
 650     }
 651
 652     /*
 653      * Store the constructed descriptor (ObjDesc) into the parent Node,
 654      * preserving the current type of that NamedObj.
 655      */
 656     Status = AcpiNsAttachObject (
 657         Info->FieldNode, ObjDesc, AcpiNsGetType (Info->FieldNode));
 658
 659     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 660         "Set NamedObj %p [%4.4s], ObjDesc %p\n",
 661         Info->FieldNode, AcpiUtGetNodeName (Info->FieldNode), ObjDesc));
 662
 663     /* Remove local reference to the object */
 664
 665     AcpiUtRemoveReference (ObjDesc);
 666     return_ACPI_STATUS (Status);
 667 }