sys/contrib/dev/acpica/components/executer/exprep.c

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