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