--- old/usr/src/uts/intel/io/acpica/executer/exprep.c	ven. janv. 17 07:30:14 2014
+++ /dev/null	ven. janv. 17 07:30:05 2014
@@ -1,621 +0,0 @@
-
-/******************************************************************************
- *
- * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities
- *
- *****************************************************************************/
-
-/*
- * Copyright (C) 2000 - 2011, Intel Corp.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions, and the following disclaimer,
- *    without modification.
- * 2. Redistributions in binary form must reproduce at minimum a disclaimer
- *    substantially similar to the "NO WARRANTY" disclaimer below
- *    ("Disclaimer") and any redistribution must be conditioned upon
- *    including a substantially similar Disclaimer requirement for further
- *    binary redistribution.
- * 3. Neither the names of the above-listed copyright holders nor the names
- *    of any contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * Alternatively, this software may be distributed under the terms of the
- * GNU General Public License ("GPL") version 2 as published by the Free
- * Software Foundation.
- *
- * NO WARRANTY
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
- * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGES.
- */
-
-#define __EXPREP_C__
-
-#include "acpi.h"
-#include "accommon.h"
-#include "acinterp.h"
-#include "amlcode.h"
-#include "acnamesp.h"
-
-
-#define _COMPONENT          ACPI_EXECUTER
-        ACPI_MODULE_NAME    ("exprep")
-
-/* Local prototypes */
-
-static UINT32
-AcpiExDecodeFieldAccess (
-    ACPI_OPERAND_OBJECT     *ObjDesc,
-    UINT8                   FieldFlags,
-    UINT32                  *ReturnByteAlignment);
-
-
-#ifdef ACPI_UNDER_DEVELOPMENT
-
-static UINT32
-AcpiExGenerateAccess (
-    UINT32                  FieldBitOffset,
-    UINT32                  FieldBitLength,
-    UINT32                  RegionLength);
-
-/*******************************************************************************
- *
- * FUNCTION:    AcpiExGenerateAccess
- *
- * PARAMETERS:  FieldBitOffset      - Start of field within parent region/buffer
- *              FieldBitLength      - Length of field in bits
- *              RegionLength        - Length of parent in bytes
- *
- * RETURN:      Field granularity (8, 16, 32 or 64) and
- *              ByteAlignment (1, 2, 3, or 4)
- *
- * DESCRIPTION: Generate an optimal access width for fields defined with the
- *              AnyAcc keyword.
- *
- * NOTE: Need to have the RegionLength in order to check for boundary
- *       conditions (end-of-region).  However, the RegionLength is a deferred
- *       operation.  Therefore, to complete this implementation, the generation
- *       of this access width must be deferred until the region length has
- *       been evaluated.
- *
- ******************************************************************************/
-
-static UINT32
-AcpiExGenerateAccess (
-    UINT32                  FieldBitOffset,
-    UINT32                  FieldBitLength,
-    UINT32                  RegionLength)
-{
-    UINT32                  FieldByteLength;
-    UINT32                  FieldByteOffset;
-    UINT32                  FieldByteEndOffset;
-    UINT32                  AccessByteWidth;
-    UINT32                  FieldStartOffset;
-    UINT32                  FieldEndOffset;
-    UINT32                  MinimumAccessWidth = 0xFFFFFFFF;
-    UINT32                  MinimumAccesses = 0xFFFFFFFF;
-    UINT32                  Accesses;
-
-
-    ACPI_FUNCTION_TRACE (ExGenerateAccess);
-
-
-    /* Round Field start offset and length to "minimal" byte boundaries */
-
-    FieldByteOffset    = ACPI_DIV_8 (ACPI_ROUND_DOWN (FieldBitOffset, 8));
-    FieldByteEndOffset = ACPI_DIV_8 (ACPI_ROUND_UP   (FieldBitLength +
-                                                      FieldBitOffset, 8));
-    FieldByteLength    = FieldByteEndOffset - FieldByteOffset;
-
-    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-        "Bit length %u, Bit offset %u\n",
-        FieldBitLength, FieldBitOffset));
-
-    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-        "Byte Length %u, Byte Offset %u, End Offset %u\n",
-        FieldByteLength, FieldByteOffset, FieldByteEndOffset));
-
-    /*
-     * Iterative search for the maximum access width that is both aligned
-     * and does not go beyond the end of the region
-     *
-     * Start at ByteAcc and work upwards to QwordAcc max. (1,2,4,8 bytes)
-     */
-    for (AccessByteWidth = 1; AccessByteWidth <= 8; AccessByteWidth <<= 1)
-    {
-        /*
-         * 1) Round end offset up to next access boundary and make sure that
-         *    this does not go beyond the end of the parent region.
-         * 2) When the Access width is greater than the FieldByteLength, we
-         *    are done. (This does not optimize for the perfectly aligned
-         *    case yet).
-         */
-        if (ACPI_ROUND_UP (FieldByteEndOffset, AccessByteWidth) <= RegionLength)
-        {
-            FieldStartOffset =
-                ACPI_ROUND_DOWN (FieldByteOffset, AccessByteWidth) /
-                AccessByteWidth;
-
-            FieldEndOffset =
-                ACPI_ROUND_UP ((FieldByteLength + FieldByteOffset),
-                    AccessByteWidth) / AccessByteWidth;
-
-            Accesses = FieldEndOffset - FieldStartOffset;
-
-            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-                "AccessWidth %u end is within region\n", AccessByteWidth));
-
-            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-                "Field Start %u, Field End %u -- requires %u accesses\n",
-                FieldStartOffset, FieldEndOffset, Accesses));
-
-            /* Single access is optimal */
-
-            if (Accesses <= 1)
-            {
-                ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-                    "Entire field can be accessed with one operation of size %u\n",
-                    AccessByteWidth));
-                return_VALUE (AccessByteWidth);
-            }
-
-            /*
-             * Fits in the region, but requires more than one read/write.
-             * try the next wider access on next iteration
-             */
-            if (Accesses < MinimumAccesses)
-            {
-                MinimumAccesses    = Accesses;
-                MinimumAccessWidth = AccessByteWidth;
-            }
-        }
-        else
-        {
-            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-                "AccessWidth %u end is NOT within region\n", AccessByteWidth));
-            if (AccessByteWidth == 1)
-            {
-                ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-                    "Field goes beyond end-of-region!\n"));
-
-                /* Field does not fit in the region at all */
-
-                return_VALUE (0);
-            }
-
-            /*
-             * This width goes beyond the end-of-region, back off to
-             * previous access
-             */
-            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-                "Backing off to previous optimal access width of %u\n",
-                MinimumAccessWidth));
-            return_VALUE (MinimumAccessWidth);
-        }
-    }
-
-    /*
-     * Could not read/write field with one operation,
-     * just use max access width
-     */
-    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-        "Cannot access field in one operation, using width 8\n"));
-    return_VALUE (8);
-}
-#endif /* ACPI_UNDER_DEVELOPMENT */
-
-
-/*******************************************************************************
- *
- * FUNCTION:    AcpiExDecodeFieldAccess
- *
- * PARAMETERS:  ObjDesc             - Field object
- *              FieldFlags          - Encoded fieldflags (contains access bits)
- *              ReturnByteAlignment - Where the byte alignment is returned
- *
- * RETURN:      Field granularity (8, 16, 32 or 64) and
- *              ByteAlignment (1, 2, 3, or 4)
- *
- * DESCRIPTION: Decode the AccessType bits of a field definition.
- *
- ******************************************************************************/
-
-static UINT32
-AcpiExDecodeFieldAccess (
-    ACPI_OPERAND_OBJECT     *ObjDesc,
-    UINT8                   FieldFlags,
-    UINT32                  *ReturnByteAlignment)
-{
-    UINT32                  Access;
-    UINT32                  ByteAlignment;
-    UINT32                  BitLength;
-
-
-    ACPI_FUNCTION_TRACE (ExDecodeFieldAccess);
-
-
-    Access = (FieldFlags & AML_FIELD_ACCESS_TYPE_MASK);
-
-    switch (Access)
-    {
-    case AML_FIELD_ACCESS_ANY:
-
-#ifdef ACPI_UNDER_DEVELOPMENT
-        ByteAlignment =
-            AcpiExGenerateAccess (ObjDesc->CommonField.StartFieldBitOffset,
-                ObjDesc->CommonField.BitLength,
-                0xFFFFFFFF /* Temp until we pass RegionLength as parameter */);
-        BitLength = ByteAlignment * 8;
-#endif
-
-        ByteAlignment = 1;
-        BitLength = 8;
-        break;
-
-    case AML_FIELD_ACCESS_BYTE:
-    case AML_FIELD_ACCESS_BUFFER:   /* ACPI 2.0 (SMBus Buffer) */
-        ByteAlignment = 1;
-        BitLength     = 8;
-        break;
-
-    case AML_FIELD_ACCESS_WORD:
-        ByteAlignment = 2;
-        BitLength     = 16;
-        break;
-
-    case AML_FIELD_ACCESS_DWORD:
-        ByteAlignment = 4;
-        BitLength     = 32;
-        break;
-
-    case AML_FIELD_ACCESS_QWORD:    /* ACPI 2.0 */
-        ByteAlignment = 8;
-        BitLength     = 64;
-        break;
-
-    default:
-        /* Invalid field access type */
-
-        ACPI_ERROR ((AE_INFO,
-            "Unknown field access type 0x%X",
-            Access));
-        return_UINT32 (0);
-    }
-
-    if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
-    {
-        /*
-         * BufferField access can be on any byte boundary, so the
-         * ByteAlignment is always 1 byte -- regardless of any ByteAlignment
-         * implied by the field access type.
-         */
-        ByteAlignment = 1;
-    }
-
-    *ReturnByteAlignment = ByteAlignment;
-    return_UINT32 (BitLength);
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION:    AcpiExPrepCommonFieldObject
- *
- * PARAMETERS:  ObjDesc             - The field object
- *              FieldFlags          - Access, LockRule, and UpdateRule.
- *                                    The format of a FieldFlag is described
- *                                    in the ACPI specification
- *              FieldAttribute      - Special attributes (not used)
- *              FieldBitPosition    - Field start position
- *              FieldBitLength      - Field length in number of bits
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Initialize the areas of the field object that are common
- *              to the various types of fields.  Note: This is very "sensitive"
- *              code because we are solving the general case for field
- *              alignment.
- *
- ******************************************************************************/
-
-ACPI_STATUS
-AcpiExPrepCommonFieldObject (
-    ACPI_OPERAND_OBJECT     *ObjDesc,
-    UINT8                   FieldFlags,
-    UINT8                   FieldAttribute,
-    UINT32                  FieldBitPosition,
-    UINT32                  FieldBitLength)
-{
-    UINT32                  AccessBitWidth;
-    UINT32                  ByteAlignment;
-    UINT32                  NearestByteAddress;
-
-
-    ACPI_FUNCTION_TRACE (ExPrepCommonFieldObject);
-
-
-    /*
-     * Note: the structure being initialized is the
-     * ACPI_COMMON_FIELD_INFO;  No structure fields outside of the common
-     * area are initialized by this procedure.
-     */
-    ObjDesc->CommonField.FieldFlags = FieldFlags;
-    ObjDesc->CommonField.Attribute  = FieldAttribute;
-    ObjDesc->CommonField.BitLength  = FieldBitLength;
-
-    /*
-     * Decode the access type so we can compute offsets.  The access type gives
-     * two pieces of information - the width of each field access and the
-     * necessary ByteAlignment (address granularity) of the access.
-     *
-     * For AnyAcc, the AccessBitWidth is the largest width that is both
-     * necessary and possible in an attempt to access the whole field in one
-     * I/O operation.  However, for AnyAcc, the ByteAlignment is always one
-     * byte.
-     *
-     * For all Buffer Fields, the ByteAlignment is always one byte.
-     *
-     * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is
-     * the same (equivalent) as the ByteAlignment.
-     */
-    AccessBitWidth = AcpiExDecodeFieldAccess (ObjDesc, FieldFlags,
-                        &ByteAlignment);
-    if (!AccessBitWidth)
-    {
-        return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
-    }
-
-    /* Setup width (access granularity) fields (values are: 1, 2, 4, 8) */
-
-    ObjDesc->CommonField.AccessByteWidth = (UINT8)
-        ACPI_DIV_8 (AccessBitWidth);
-
-    /*
-     * BaseByteOffset is the address of the start of the field within the
-     * region.  It is the byte address of the first *datum* (field-width data
-     * unit) of the field. (i.e., the first datum that contains at least the
-     * first *bit* of the field.)
-     *
-     * Note: ByteAlignment is always either equal to the AccessBitWidth or 8
-     * (Byte access), and it defines the addressing granularity of the parent
-     * region or buffer.
-     */
-    NearestByteAddress =
-        ACPI_ROUND_BITS_DOWN_TO_BYTES (FieldBitPosition);
-    ObjDesc->CommonField.BaseByteOffset = (UINT32)
-        ACPI_ROUND_DOWN (NearestByteAddress, ByteAlignment);
-
-    /*
-     * StartFieldBitOffset is the offset of the first bit of the field within
-     * a field datum.
-     */
-    ObjDesc->CommonField.StartFieldBitOffset = (UINT8)
-        (FieldBitPosition - ACPI_MUL_8 (ObjDesc->CommonField.BaseByteOffset));
-
-    return_ACPI_STATUS (AE_OK);
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION:    AcpiExPrepFieldValue
- *
- * PARAMETERS:  Info    - Contains all field creation info
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Construct an ACPI_OPERAND_OBJECT of type DefField and
- *              connect it to the parent Node.
- *
- ******************************************************************************/
-
-ACPI_STATUS
-AcpiExPrepFieldValue (
-    ACPI_CREATE_FIELD_INFO  *Info)
-{
-    ACPI_OPERAND_OBJECT     *ObjDesc;
-    ACPI_OPERAND_OBJECT     *SecondDesc = NULL;
-    ACPI_STATUS             Status;
-    UINT32                  AccessByteWidth;
-    UINT32                  Type;
-
-
-    ACPI_FUNCTION_TRACE (ExPrepFieldValue);
-
-
-    /* Parameter validation */
-
-    if (Info->FieldType != ACPI_TYPE_LOCAL_INDEX_FIELD)
-    {
-        if (!Info->RegionNode)
-        {
-            ACPI_ERROR ((AE_INFO, "Null RegionNode"));
-            return_ACPI_STATUS (AE_AML_NO_OPERAND);
-        }
-
-        Type = AcpiNsGetType (Info->RegionNode);
-        if (Type != ACPI_TYPE_REGION)
-        {
-            ACPI_ERROR ((AE_INFO, "Needed Region, found type 0x%X (%s)",
-                Type, AcpiUtGetTypeName (Type)));
-
-            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
-        }
-    }
-
-    /* Allocate a new field object */
-
-    ObjDesc = AcpiUtCreateInternalObject (Info->FieldType);
-    if (!ObjDesc)
-    {
-        return_ACPI_STATUS (AE_NO_MEMORY);
-    }
-
-    /* Initialize areas of the object that are common to all fields */
-
-    ObjDesc->CommonField.Node = Info->FieldNode;
-    Status = AcpiExPrepCommonFieldObject (ObjDesc,
-                Info->FieldFlags, Info->Attribute,
-                Info->FieldBitPosition, Info->FieldBitLength);
-    if (ACPI_FAILURE (Status))
-    {
-        AcpiUtDeleteObjectDesc (ObjDesc);
-        return_ACPI_STATUS (Status);
-    }
-
-    /* Initialize areas of the object that are specific to the field type */
-
-    switch (Info->FieldType)
-    {
-    case ACPI_TYPE_LOCAL_REGION_FIELD:
-
-        ObjDesc->Field.RegionObj = AcpiNsGetAttachedObject (Info->RegionNode);
-
-        /* Allow full data read from EC address space */
-
-        if ((ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_EC) &&
-            (ObjDesc->CommonField.BitLength > 8))
-        {
-            AccessByteWidth = ACPI_ROUND_BITS_UP_TO_BYTES (
-                ObjDesc->CommonField.BitLength);
-
-            /* Maximum byte width supported is 255 */
-
-            if (AccessByteWidth < 256)
-            {
-                ObjDesc->CommonField.AccessByteWidth = (UINT8) AccessByteWidth;
-            }
-        }
-
-        /* An additional reference for the container */
-
-        AcpiUtAddReference (ObjDesc->Field.RegionObj);
-
-        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-            "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n",
-            ObjDesc->Field.StartFieldBitOffset, ObjDesc->Field.BaseByteOffset,
-            ObjDesc->Field.AccessByteWidth, ObjDesc->Field.RegionObj));
-        break;
-
-
-    case ACPI_TYPE_LOCAL_BANK_FIELD:
-
-        ObjDesc->BankField.Value = Info->BankValue;
-        ObjDesc->BankField.RegionObj =
-            AcpiNsGetAttachedObject (Info->RegionNode);
-        ObjDesc->BankField.BankObj =
-            AcpiNsGetAttachedObject (Info->RegisterNode);
-
-        /* An additional reference for the attached objects */
-
-        AcpiUtAddReference (ObjDesc->BankField.RegionObj);
-        AcpiUtAddReference (ObjDesc->BankField.BankObj);
-
-        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-            "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n",
-            ObjDesc->BankField.StartFieldBitOffset,
-            ObjDesc->BankField.BaseByteOffset,
-            ObjDesc->Field.AccessByteWidth,
-            ObjDesc->BankField.RegionObj,
-            ObjDesc->BankField.BankObj));
-
-        /*
-         * Remember location in AML stream of the field unit
-         * opcode and operands -- since the BankValue
-         * operands must be evaluated.
-         */
-        SecondDesc = ObjDesc->Common.NextObject;
-        SecondDesc->Extra.AmlStart = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
-            Info->DataRegisterNode)->Named.Data;
-        SecondDesc->Extra.AmlLength = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
-            Info->DataRegisterNode)->Named.Length;
-
-        break;
-
-
-    case ACPI_TYPE_LOCAL_INDEX_FIELD:
-
-        /* Get the Index and Data registers */
-
-        ObjDesc->IndexField.IndexObj =
-            AcpiNsGetAttachedObject (Info->RegisterNode);
-        ObjDesc->IndexField.DataObj =
-            AcpiNsGetAttachedObject (Info->DataRegisterNode);
-
-        if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj)
-        {
-            ACPI_ERROR ((AE_INFO, "Null Index Object during field prep"));
-            AcpiUtDeleteObjectDesc (ObjDesc);
-            return_ACPI_STATUS (AE_AML_INTERNAL);
-        }
-
-        /* An additional reference for the attached objects */
-
-        AcpiUtAddReference (ObjDesc->IndexField.DataObj);
-        AcpiUtAddReference (ObjDesc->IndexField.IndexObj);
-
-        /*
-         * April 2006: Changed to match MS behavior
-         *
-         * The value written to the Index register is the byte offset of the
-         * target field in units of the granularity of the IndexField
-         *
-         * Previously, the value was calculated as an index in terms of the
-         * width of the Data register, as below:
-         *
-         *      ObjDesc->IndexField.Value = (UINT32)
-         *          (Info->FieldBitPosition / ACPI_MUL_8 (
-         *              ObjDesc->Field.AccessByteWidth));
-         *
-         * February 2006: Tried value as a byte offset:
-         *      ObjDesc->IndexField.Value = (UINT32)
-         *          ACPI_DIV_8 (Info->FieldBitPosition);
-         */
-        ObjDesc->IndexField.Value = (UINT32) ACPI_ROUND_DOWN (
-            ACPI_DIV_8 (Info->FieldBitPosition),
-            ObjDesc->IndexField.AccessByteWidth);
-
-        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
-            "IndexField: BitOff %X, Off %X, Value %X, Gran %X, Index %p, Data %p\n",
-            ObjDesc->IndexField.StartFieldBitOffset,
-            ObjDesc->IndexField.BaseByteOffset,
-            ObjDesc->IndexField.Value,
-            ObjDesc->Field.AccessByteWidth,
-            ObjDesc->IndexField.IndexObj,
-            ObjDesc->IndexField.DataObj));
-        break;
-
-    default:
-        /* No other types should get here */
-        break;
-    }
-
-    /*
-     * Store the constructed descriptor (ObjDesc) into the parent Node,
-     * preserving the current type of that NamedObj.
-     */
-    Status = AcpiNsAttachObject (Info->FieldNode, ObjDesc,
-                AcpiNsGetType (Info->FieldNode));
-
-    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Set NamedObj %p [%4.4s], ObjDesc %p\n",
-        Info->FieldNode, AcpiUtGetNodeName (Info->FieldNode), ObjDesc));
-
-    /* Remove local reference to the object */
-
-    AcpiUtRemoveReference (ObjDesc);
-    return_ACPI_STATUS (Status);
-}
-
--- /dev/null	ven. janv. 17 07:30:05 2014
+++ new/usr/src/common/acpica/components/executer/exprep.c	ven. janv. 17 07:30:14 2014
@@ -0,0 +1,651 @@
+/******************************************************************************
+ *
+ * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2014, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#define __EXPREP_C__
+
+#include "acpi.h"
+#include "accommon.h"
+#include "acinterp.h"
+#include "amlcode.h"
+#include "acnamesp.h"
+#include "acdispat.h"
+
+
+#define _COMPONENT          ACPI_EXECUTER
+        ACPI_MODULE_NAME    ("exprep")
+
+/* Local prototypes */
+
+static UINT32
+AcpiExDecodeFieldAccess (
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    UINT8                   FieldFlags,
+    UINT32                  *ReturnByteAlignment);
+
+
+#ifdef ACPI_UNDER_DEVELOPMENT
+
+static UINT32
+AcpiExGenerateAccess (
+    UINT32                  FieldBitOffset,
+    UINT32                  FieldBitLength,
+    UINT32                  RegionLength);
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExGenerateAccess
+ *
+ * PARAMETERS:  FieldBitOffset      - Start of field within parent region/buffer
+ *              FieldBitLength      - Length of field in bits
+ *              RegionLength        - Length of parent in bytes
+ *
+ * RETURN:      Field granularity (8, 16, 32 or 64) and
+ *              ByteAlignment (1, 2, 3, or 4)
+ *
+ * DESCRIPTION: Generate an optimal access width for fields defined with the
+ *              AnyAcc keyword.
+ *
+ * NOTE: Need to have the RegionLength in order to check for boundary
+ *       conditions (end-of-region). However, the RegionLength is a deferred
+ *       operation. Therefore, to complete this implementation, the generation
+ *       of this access width must be deferred until the region length has
+ *       been evaluated.
+ *
+ ******************************************************************************/
+
+static UINT32
+AcpiExGenerateAccess (
+    UINT32                  FieldBitOffset,
+    UINT32                  FieldBitLength,
+    UINT32                  RegionLength)
+{
+    UINT32                  FieldByteLength;
+    UINT32                  FieldByteOffset;
+    UINT32                  FieldByteEndOffset;
+    UINT32                  AccessByteWidth;
+    UINT32                  FieldStartOffset;
+    UINT32                  FieldEndOffset;
+    UINT32                  MinimumAccessWidth = 0xFFFFFFFF;
+    UINT32                  MinimumAccesses = 0xFFFFFFFF;
+    UINT32                  Accesses;
+
+
+    ACPI_FUNCTION_TRACE (ExGenerateAccess);
+
+
+    /* Round Field start offset and length to "minimal" byte boundaries */
+
+    FieldByteOffset    = ACPI_DIV_8 (ACPI_ROUND_DOWN (FieldBitOffset, 8));
+    FieldByteEndOffset = ACPI_DIV_8 (ACPI_ROUND_UP   (FieldBitLength +
+                                                      FieldBitOffset, 8));
+    FieldByteLength    = FieldByteEndOffset - FieldByteOffset;
+
+    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+        "Bit length %u, Bit offset %u\n",
+        FieldBitLength, FieldBitOffset));
+
+    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+        "Byte Length %u, Byte Offset %u, End Offset %u\n",
+        FieldByteLength, FieldByteOffset, FieldByteEndOffset));
+
+    /*
+     * Iterative search for the maximum access width that is both aligned
+     * and does not go beyond the end of the region
+     *
+     * Start at ByteAcc and work upwards to QwordAcc max. (1,2,4,8 bytes)
+     */
+    for (AccessByteWidth = 1; AccessByteWidth <= 8; AccessByteWidth <<= 1)
+    {
+        /*
+         * 1) Round end offset up to next access boundary and make sure that
+         *    this does not go beyond the end of the parent region.
+         * 2) When the Access width is greater than the FieldByteLength, we
+         *    are done. (This does not optimize for the perfectly aligned
+         *    case yet).
+         */
+        if (ACPI_ROUND_UP (FieldByteEndOffset, AccessByteWidth) <= RegionLength)
+        {
+            FieldStartOffset =
+                ACPI_ROUND_DOWN (FieldByteOffset, AccessByteWidth) /
+                AccessByteWidth;
+
+            FieldEndOffset =
+                ACPI_ROUND_UP ((FieldByteLength + FieldByteOffset),
+                    AccessByteWidth) / AccessByteWidth;
+
+            Accesses = FieldEndOffset - FieldStartOffset;
+
+            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+                "AccessWidth %u end is within region\n", AccessByteWidth));
+
+            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+                "Field Start %u, Field End %u -- requires %u accesses\n",
+                FieldStartOffset, FieldEndOffset, Accesses));
+
+            /* Single access is optimal */
+
+            if (Accesses <= 1)
+            {
+                ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+                    "Entire field can be accessed with one operation of size %u\n",
+                    AccessByteWidth));
+                return_VALUE (AccessByteWidth);
+            }
+
+            /*
+             * Fits in the region, but requires more than one read/write.
+             * try the next wider access on next iteration
+             */
+            if (Accesses < MinimumAccesses)
+            {
+                MinimumAccesses    = Accesses;
+                MinimumAccessWidth = AccessByteWidth;
+            }
+        }
+        else
+        {
+            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+                "AccessWidth %u end is NOT within region\n", AccessByteWidth));
+            if (AccessByteWidth == 1)
+            {
+                ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+                    "Field goes beyond end-of-region!\n"));
+
+                /* Field does not fit in the region at all */
+
+                return_VALUE (0);
+            }
+
+            /*
+             * This width goes beyond the end-of-region, back off to
+             * previous access
+             */
+            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+                "Backing off to previous optimal access width of %u\n",
+                MinimumAccessWidth));
+            return_VALUE (MinimumAccessWidth);
+        }
+    }
+
+    /*
+     * Could not read/write field with one operation,
+     * just use max access width
+     */
+    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+        "Cannot access field in one operation, using width 8\n"));
+    return_VALUE (8);
+}
+#endif /* ACPI_UNDER_DEVELOPMENT */
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExDecodeFieldAccess
+ *
+ * PARAMETERS:  ObjDesc             - Field object
+ *              FieldFlags          - Encoded fieldflags (contains access bits)
+ *              ReturnByteAlignment - Where the byte alignment is returned
+ *
+ * RETURN:      Field granularity (8, 16, 32 or 64) and
+ *              ByteAlignment (1, 2, 3, or 4)
+ *
+ * DESCRIPTION: Decode the AccessType bits of a field definition.
+ *
+ ******************************************************************************/
+
+static UINT32
+AcpiExDecodeFieldAccess (
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    UINT8                   FieldFlags,
+    UINT32                  *ReturnByteAlignment)
+{
+    UINT32                  Access;
+    UINT32                  ByteAlignment;
+    UINT32                  BitLength;
+
+
+    ACPI_FUNCTION_TRACE (ExDecodeFieldAccess);
+
+
+    Access = (FieldFlags & AML_FIELD_ACCESS_TYPE_MASK);
+
+    switch (Access)
+    {
+    case AML_FIELD_ACCESS_ANY:
+
+#ifdef ACPI_UNDER_DEVELOPMENT
+        ByteAlignment =
+            AcpiExGenerateAccess (ObjDesc->CommonField.StartFieldBitOffset,
+                ObjDesc->CommonField.BitLength,
+                0xFFFFFFFF /* Temp until we pass RegionLength as parameter */);
+        BitLength = ByteAlignment * 8;
+#endif
+
+        ByteAlignment = 1;
+        BitLength = 8;
+        break;
+
+    case AML_FIELD_ACCESS_BYTE:
+    case AML_FIELD_ACCESS_BUFFER:   /* ACPI 2.0 (SMBus Buffer) */
+
+        ByteAlignment = 1;
+        BitLength     = 8;
+        break;
+
+    case AML_FIELD_ACCESS_WORD:
+
+        ByteAlignment = 2;
+        BitLength     = 16;
+        break;
+
+    case AML_FIELD_ACCESS_DWORD:
+
+        ByteAlignment = 4;
+        BitLength     = 32;
+        break;
+
+    case AML_FIELD_ACCESS_QWORD:    /* ACPI 2.0 */
+
+        ByteAlignment = 8;
+        BitLength     = 64;
+        break;
+
+    default:
+
+        /* Invalid field access type */
+
+        ACPI_ERROR ((AE_INFO,
+            "Unknown field access type 0x%X",
+            Access));
+        return_UINT32 (0);
+    }
+
+    if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
+    {
+        /*
+         * BufferField access can be on any byte boundary, so the
+         * ByteAlignment is always 1 byte -- regardless of any ByteAlignment
+         * implied by the field access type.
+         */
+        ByteAlignment = 1;
+    }
+
+    *ReturnByteAlignment = ByteAlignment;
+    return_UINT32 (BitLength);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExPrepCommonFieldObject
+ *
+ * PARAMETERS:  ObjDesc             - The field object
+ *              FieldFlags          - Access, LockRule, and UpdateRule.
+ *                                    The format of a FieldFlag is described
+ *                                    in the ACPI specification
+ *              FieldAttribute      - Special attributes (not used)
+ *              FieldBitPosition    - Field start position
+ *              FieldBitLength      - Field length in number of bits
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Initialize the areas of the field object that are common
+ *              to the various types of fields. Note: This is very "sensitive"
+ *              code because we are solving the general case for field
+ *              alignment.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExPrepCommonFieldObject (
+    ACPI_OPERAND_OBJECT     *ObjDesc,
+    UINT8                   FieldFlags,
+    UINT8                   FieldAttribute,
+    UINT32                  FieldBitPosition,
+    UINT32                  FieldBitLength)
+{
+    UINT32                  AccessBitWidth;
+    UINT32                  ByteAlignment;
+    UINT32                  NearestByteAddress;
+
+
+    ACPI_FUNCTION_TRACE (ExPrepCommonFieldObject);
+
+
+    /*
+     * Note: the structure being initialized is the
+     * ACPI_COMMON_FIELD_INFO;  No structure fields outside of the common
+     * area are initialized by this procedure.
+     */
+    ObjDesc->CommonField.FieldFlags = FieldFlags;
+    ObjDesc->CommonField.Attribute  = FieldAttribute;
+    ObjDesc->CommonField.BitLength  = FieldBitLength;
+
+    /*
+     * Decode the access type so we can compute offsets. The access type gives
+     * two pieces of information - the width of each field access and the
+     * necessary ByteAlignment (address granularity) of the access.
+     *
+     * For AnyAcc, the AccessBitWidth is the largest width that is both
+     * necessary and possible in an attempt to access the whole field in one
+     * I/O operation. However, for AnyAcc, the ByteAlignment is always one
+     * byte.
+     *
+     * For all Buffer Fields, the ByteAlignment is always one byte.
+     *
+     * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is
+     * the same (equivalent) as the ByteAlignment.
+     */
+    AccessBitWidth = AcpiExDecodeFieldAccess (ObjDesc, FieldFlags,
+                        &ByteAlignment);
+    if (!AccessBitWidth)
+    {
+        return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
+    }
+
+    /* Setup width (access granularity) fields (values are: 1, 2, 4, 8) */
+
+    ObjDesc->CommonField.AccessByteWidth = (UINT8)
+        ACPI_DIV_8 (AccessBitWidth);
+
+    /*
+     * BaseByteOffset is the address of the start of the field within the
+     * region. It is the byte address of the first *datum* (field-width data
+     * unit) of the field. (i.e., the first datum that contains at least the
+     * first *bit* of the field.)
+     *
+     * Note: ByteAlignment is always either equal to the AccessBitWidth or 8
+     * (Byte access), and it defines the addressing granularity of the parent
+     * region or buffer.
+     */
+    NearestByteAddress =
+        ACPI_ROUND_BITS_DOWN_TO_BYTES (FieldBitPosition);
+    ObjDesc->CommonField.BaseByteOffset = (UINT32)
+        ACPI_ROUND_DOWN (NearestByteAddress, ByteAlignment);
+
+    /*
+     * StartFieldBitOffset is the offset of the first bit of the field within
+     * a field datum.
+     */
+    ObjDesc->CommonField.StartFieldBitOffset = (UINT8)
+        (FieldBitPosition - ACPI_MUL_8 (ObjDesc->CommonField.BaseByteOffset));
+
+    return_ACPI_STATUS (AE_OK);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExPrepFieldValue
+ *
+ * PARAMETERS:  Info    - Contains all field creation info
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Construct an object of type ACPI_OPERAND_OBJECT with a
+ *              subtype of DefField and connect it to the parent Node.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExPrepFieldValue (
+    ACPI_CREATE_FIELD_INFO  *Info)
+{
+    ACPI_OPERAND_OBJECT     *ObjDesc;
+    ACPI_OPERAND_OBJECT     *SecondDesc = NULL;
+    ACPI_STATUS             Status;
+    UINT32                  AccessByteWidth;
+    UINT32                  Type;
+
+
+    ACPI_FUNCTION_TRACE (ExPrepFieldValue);
+
+
+    /* Parameter validation */
+
+    if (Info->FieldType != ACPI_TYPE_LOCAL_INDEX_FIELD)
+    {
+        if (!Info->RegionNode)
+        {
+            ACPI_ERROR ((AE_INFO, "Null RegionNode"));
+            return_ACPI_STATUS (AE_AML_NO_OPERAND);
+        }
+
+        Type = AcpiNsGetType (Info->RegionNode);
+        if (Type != ACPI_TYPE_REGION)
+        {
+            ACPI_ERROR ((AE_INFO, "Needed Region, found type 0x%X (%s)",
+                Type, AcpiUtGetTypeName (Type)));
+
+            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
+        }
+    }
+
+    /* Allocate a new field object */
+
+    ObjDesc = AcpiUtCreateInternalObject (Info->FieldType);
+    if (!ObjDesc)
+    {
+        return_ACPI_STATUS (AE_NO_MEMORY);
+    }
+
+    /* Initialize areas of the object that are common to all fields */
+
+    ObjDesc->CommonField.Node = Info->FieldNode;
+    Status = AcpiExPrepCommonFieldObject (ObjDesc,
+                Info->FieldFlags, Info->Attribute,
+                Info->FieldBitPosition, Info->FieldBitLength);
+    if (ACPI_FAILURE (Status))
+    {
+        AcpiUtDeleteObjectDesc (ObjDesc);
+        return_ACPI_STATUS (Status);
+    }
+
+    /* Initialize areas of the object that are specific to the field type */
+
+    switch (Info->FieldType)
+    {
+    case ACPI_TYPE_LOCAL_REGION_FIELD:
+
+        ObjDesc->Field.RegionObj = AcpiNsGetAttachedObject (Info->RegionNode);
+
+        /* Fields specific to GenericSerialBus fields */
+
+        ObjDesc->Field.AccessLength = Info->AccessLength;
+
+        if (Info->ConnectionNode)
+        {
+            SecondDesc = Info->ConnectionNode->Object;
+            if (!(SecondDesc->Common.Flags & AOPOBJ_DATA_VALID))
+            {
+                Status = AcpiDsGetBufferArguments (SecondDesc);
+                if (ACPI_FAILURE (Status))
+                {
+                    AcpiUtDeleteObjectDesc (ObjDesc);
+                    return_ACPI_STATUS (Status);
+                }
+            }
+
+            ObjDesc->Field.ResourceBuffer = SecondDesc->Buffer.Pointer;
+            ObjDesc->Field.ResourceLength = (UINT16) SecondDesc->Buffer.Length;
+        }
+        else if (Info->ResourceBuffer)
+        {
+            ObjDesc->Field.ResourceBuffer = Info->ResourceBuffer;
+            ObjDesc->Field.ResourceLength = Info->ResourceLength;
+        }
+
+        /* Allow full data read from EC address space */
+
+        if ((ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_EC) &&
+            (ObjDesc->CommonField.BitLength > 8))
+        {
+            AccessByteWidth = ACPI_ROUND_BITS_UP_TO_BYTES (
+                ObjDesc->CommonField.BitLength);
+
+            /* Maximum byte width supported is 255 */
+
+            if (AccessByteWidth < 256)
+            {
+                ObjDesc->CommonField.AccessByteWidth = (UINT8) AccessByteWidth;
+            }
+        }
+
+        /* An additional reference for the container */
+
+        AcpiUtAddReference (ObjDesc->Field.RegionObj);
+
+        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+            "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n",
+            ObjDesc->Field.StartFieldBitOffset, ObjDesc->Field.BaseByteOffset,
+            ObjDesc->Field.AccessByteWidth, ObjDesc->Field.RegionObj));
+        break;
+
+    case ACPI_TYPE_LOCAL_BANK_FIELD:
+
+        ObjDesc->BankField.Value = Info->BankValue;
+        ObjDesc->BankField.RegionObj =
+            AcpiNsGetAttachedObject (Info->RegionNode);
+        ObjDesc->BankField.BankObj =
+            AcpiNsGetAttachedObject (Info->RegisterNode);
+
+        /* An additional reference for the attached objects */
+
+        AcpiUtAddReference (ObjDesc->BankField.RegionObj);
+        AcpiUtAddReference (ObjDesc->BankField.BankObj);
+
+        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+            "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n",
+            ObjDesc->BankField.StartFieldBitOffset,
+            ObjDesc->BankField.BaseByteOffset,
+            ObjDesc->Field.AccessByteWidth,
+            ObjDesc->BankField.RegionObj,
+            ObjDesc->BankField.BankObj));
+
+        /*
+         * Remember location in AML stream of the field unit
+         * opcode and operands -- since the BankValue
+         * operands must be evaluated.
+         */
+        SecondDesc = ObjDesc->Common.NextObject;
+        SecondDesc->Extra.AmlStart = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
+            Info->DataRegisterNode)->Named.Data;
+        SecondDesc->Extra.AmlLength = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
+            Info->DataRegisterNode)->Named.Length;
+
+        break;
+
+    case ACPI_TYPE_LOCAL_INDEX_FIELD:
+
+        /* Get the Index and Data registers */
+
+        ObjDesc->IndexField.IndexObj =
+            AcpiNsGetAttachedObject (Info->RegisterNode);
+        ObjDesc->IndexField.DataObj =
+            AcpiNsGetAttachedObject (Info->DataRegisterNode);
+
+        if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj)
+        {
+            ACPI_ERROR ((AE_INFO, "Null Index Object during field prep"));
+            AcpiUtDeleteObjectDesc (ObjDesc);
+            return_ACPI_STATUS (AE_AML_INTERNAL);
+        }
+
+        /* An additional reference for the attached objects */
+
+        AcpiUtAddReference (ObjDesc->IndexField.DataObj);
+        AcpiUtAddReference (ObjDesc->IndexField.IndexObj);
+
+        /*
+         * April 2006: Changed to match MS behavior
+         *
+         * The value written to the Index register is the byte offset of the
+         * target field in units of the granularity of the IndexField
+         *
+         * Previously, the value was calculated as an index in terms of the
+         * width of the Data register, as below:
+         *
+         *      ObjDesc->IndexField.Value = (UINT32)
+         *          (Info->FieldBitPosition / ACPI_MUL_8 (
+         *              ObjDesc->Field.AccessByteWidth));
+         *
+         * February 2006: Tried value as a byte offset:
+         *      ObjDesc->IndexField.Value = (UINT32)
+         *          ACPI_DIV_8 (Info->FieldBitPosition);
+         */
+        ObjDesc->IndexField.Value = (UINT32) ACPI_ROUND_DOWN (
+            ACPI_DIV_8 (Info->FieldBitPosition),
+            ObjDesc->IndexField.AccessByteWidth);
+
+        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
+            "IndexField: BitOff %X, Off %X, Value %X, Gran %X, Index %p, Data %p\n",
+            ObjDesc->IndexField.StartFieldBitOffset,
+            ObjDesc->IndexField.BaseByteOffset,
+            ObjDesc->IndexField.Value,
+            ObjDesc->Field.AccessByteWidth,
+            ObjDesc->IndexField.IndexObj,
+            ObjDesc->IndexField.DataObj));
+        break;
+
+    default:
+
+        /* No other types should get here */
+
+        break;
+    }
+
+    /*
+     * Store the constructed descriptor (ObjDesc) into the parent Node,
+     * preserving the current type of that NamedObj.
+     */
+    Status = AcpiNsAttachObject (Info->FieldNode, ObjDesc,
+                AcpiNsGetType (Info->FieldNode));
+
+    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Set NamedObj %p [%4.4s], ObjDesc %p\n",
+        Info->FieldNode, AcpiUtGetNodeName (Info->FieldNode), ObjDesc));
+
+    /* Remove local reference to the object */
+
+    AcpiUtRemoveReference (ObjDesc);
+    return_ACPI_STATUS (Status);
+}
