Update to the 20010125 ACPI CA snapshot.

1 files changed, 122 insertions, 464 deletions

diff --git a/sys/contrib/dev/acpica/exstoren.c b/sys/contrib/dev/acpica/exstoren.c
index 57e02ff..b6bd010 100644
--- a/sys/contrib/dev/acpica/exstoren.c
+++ b/sys/contrib/dev/acpica/exstoren.c
@@ -2,8 +2,8 @@
 /******************************************************************************
  *
  * Module Name: amstoren - AML Interpreter object store support,
- *                         Store to Node (namespace object)
- *              $Revision: 25 $
+ *                        Store to Node (namespace object)
+ *              $Revision: 28 $
  *
  *****************************************************************************/
 
@@ -11,7 +11,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999, 2000, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -131,557 +131,226 @@
         MODULE_NAME         ("amstoren")
 
 
+
+
 /*******************************************************************************
  *
- * FUNCTION:    AcpiAmlStoreObjectToNode
+ * FUNCTION:    AcpiAmlResolveObject
  *
- * PARAMETERS:  *ValDesc            - Value to be stored
- *              *Node           - Named object to recieve the value
- *
- * RETURN:      Status
+ * PARAMETERS:  SourceDescPtr       - Pointer to the source object
+ *              TargetType          - Current type of the target
+ *              WalkState           - Current walk state
  *
- * DESCRIPTION: Store the object to the named object.
+ * RETURN:      Status, resolved object in SourceDescPtr.
  *
- *              The Assignment of an object to a named object is handled here
- *              The val passed in will replace the current value (if any)
- *              with the input value.
- *
- *              When storing into an object the data is converted to the
- *              target object type then stored in the object.  This means
- *              that the target object type (for an initialized target) will
- *              not be changed by a store operation.
- *
- *              NOTE: the global lock is acquired early.  This will result
- *              in the global lock being held a bit longer.  Also, if the
- *              function fails during set up we may get the lock when we
- *              don't really need it.  I don't think we care.
+ * DESCRIPTION: Resolve an object.  If the object is a reference, dereference 
+ *              it and return the actual object in the SourceDescPtr.
  *
  ******************************************************************************/
 
 ACPI_STATUS
-AcpiAmlStoreObjectToNode (
-    ACPI_OPERAND_OBJECT     *ValDesc,
-    ACPI_NAMESPACE_NODE     *Node,
+AcpiAmlResolveObject (
+    ACPI_OPERAND_OBJECT     **SourceDescPtr,
+    OBJECT_TYPE_INTERNAL    TargetType,
     ACPI_WALK_STATE         *WalkState)
 {
+    ACPI_OPERAND_OBJECT     *SourceDesc = *SourceDescPtr;
     ACPI_STATUS             Status = AE_OK;
-    UINT8                   *Buffer = NULL;
-    UINT32                  Length = 0;
-    UINT32                  Mask;
-    UINT32                  NewValue;
-    BOOLEAN                 Locked = FALSE;
-    UINT8                   *Location=NULL;
-    ACPI_OPERAND_OBJECT     *DestDesc;
-    OBJECT_TYPE_INTERNAL    DestinationType = ACPI_TYPE_ANY;
 
 
-    FUNCTION_TRACE ("AmlStoreObjectToNte");
+    FUNCTION_TRACE ("AmlResolveObject");
 
-    DEBUG_PRINT (ACPI_INFO,
-        ("entered AcpiAmlStoreObjectToNode: NamedObj=%p, Obj=%p\n",
-        Node, ValDesc));
 
     /*
-     *  Assuming the parameters are valid!!!
+     * Ensure we have a Source that can be stored in the target
      */
-    ACPI_ASSERT((Node) && (ValDesc));
-
-    DestinationType = AcpiNsGetType (Node);
+    switch (TargetType)
+    {
 
-    DEBUG_PRINT (ACPI_INFO, ("AmlStoreObjectToNte: Storing %s into %s\n",
-        AcpiCmGetTypeName (ValDesc->Common.Type),
-        AcpiCmGetTypeName (DestinationType)));
+    /* This case handles the "interchangeable" types Integer, String, and Buffer. */
 
     /*
-     *  First ensure we have a value that can be stored in the target
+     * These cases all require only Integers or values that
+     * can be converted to Integers (Strings or Buffers)
      */
-    switch (DestinationType)
-    {
-        /* Type of Name's existing value */
-
-    case INTERNAL_TYPE_ALIAS:
-
-        /*
-         *  Aliases are resolved by AcpiAmlPrepOperands
-         */
-
-        DEBUG_PRINT (ACPI_WARN,
-            ("AmlStoreObjectToNte: Store into Alias - should never happen\n"));
-        Status = AE_AML_INTERNAL;
-        break;
-
-
+    case ACPI_TYPE_INTEGER:
+    case ACPI_TYPE_FIELD_UNIT:
     case INTERNAL_TYPE_BANK_FIELD:
     case INTERNAL_TYPE_INDEX_FIELD:
-    case ACPI_TYPE_FIELD_UNIT:
-    case ACPI_TYPE_NUMBER:
-
-        /*
-         *  These cases all require only number values or values that
-         *  can be converted to numbers.
-         *
-         *  If value is not a Number, try to resolve it to one.
-         */
-
-        if (ValDesc->Common.Type != ACPI_TYPE_NUMBER)
-        {
-            /*
-             *  Initially not a number, convert
-             */
-            Status = AcpiAmlResolveToValue (&ValDesc, WalkState);
-            if (ACPI_SUCCESS (Status) &&
-                (ValDesc->Common.Type != ACPI_TYPE_NUMBER))
-            {
-                /*
-                 *  Conversion successful but still not a number
-                 */
-                DEBUG_PRINT (ACPI_ERROR,
-                    ("AmlStoreObjectToNte: Value assigned to %s must be Number, not %s\n",
-                    AcpiCmGetTypeName (DestinationType),
-                    AcpiCmGetTypeName (ValDesc->Common.Type)));
-                Status = AE_AML_OPERAND_TYPE;
-            }
-        }
-
-        break;
 
+    /*
+     * Stores into a Field/Region or into a Buffer/String 
+     * are all essentially the same.
+     */
     case ACPI_TYPE_STRING:
     case ACPI_TYPE_BUFFER:
     case INTERNAL_TYPE_DEF_FIELD:
 
         /*
-         *  Storing into a Field in a region or into a buffer or into
-         *  a string all is essentially the same.
-         *
-         *  If value is not a valid type, try to resolve it to one.
+         * If SourceDesc is not a valid type, try to resolve it to one.
          */
-
-        if ((ValDesc->Common.Type != ACPI_TYPE_NUMBER) &&
-            (ValDesc->Common.Type != ACPI_TYPE_BUFFER) &&
-            (ValDesc->Common.Type != ACPI_TYPE_STRING))
+        if ((SourceDesc->Common.Type != ACPI_TYPE_INTEGER)     &&
+            (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)      &&
+            (SourceDesc->Common.Type != ACPI_TYPE_STRING))
         {
             /*
-             *  Initially not a valid type, convert
+             * Initially not a valid type, convert
              */
-            Status = AcpiAmlResolveToValue (&ValDesc, WalkState);
+            Status = AcpiAmlResolveToValue (SourceDescPtr, WalkState);
             if (ACPI_SUCCESS (Status) &&
-                (ValDesc->Common.Type != ACPI_TYPE_NUMBER) &&
-                (ValDesc->Common.Type != ACPI_TYPE_BUFFER) &&
-                (ValDesc->Common.Type != ACPI_TYPE_STRING))
+                (SourceDesc->Common.Type != ACPI_TYPE_INTEGER)     &&
+                (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)      &&
+                (SourceDesc->Common.Type != ACPI_TYPE_STRING))
             {
                 /*
-                 *  Conversion successful but still not a valid type
+                 * Conversion successful but still not a valid type
                  */
                 DEBUG_PRINT (ACPI_ERROR,
-                    ("AmlStoreObjectToNte: Assign wrong type %s to %s (must be type Num/Str/Buf)\n",
-                    AcpiCmGetTypeName (ValDesc->Common.Type),
-                    AcpiCmGetTypeName (DestinationType)));
+                    ("AmlResolveObject: Cannot assign type %s to %s (must be type Int/Str/Buf)\n",
+                    AcpiCmGetTypeName ((*SourceDescPtr)->Common.Type),
+                    AcpiCmGetTypeName (TargetType)));
                 Status = AE_AML_OPERAND_TYPE;
             }
         }
         break;
 
 
-    case ACPI_TYPE_PACKAGE:
+    case INTERNAL_TYPE_ALIAS:
 
         /*
-         *  TBD: [Unhandled] Not real sure what to do here
+         * Aliases are resolved by AcpiAmlPrepOperands
          */
-        Status = AE_NOT_IMPLEMENTED;
+        DEBUG_PRINT (ACPI_WARN,
+            ("AmlResolveObject: Store into Alias - should never happen\n"));
+
+        Status = AE_AML_INTERNAL;
         break;
 
 
+    case ACPI_TYPE_PACKAGE:
     default:
 
         /*
-         * All other types than Alias and the various Fields come here.
-         * Store ValDesc as the new value of the Name, and set
-         * the Name's type to that of the value being stored in it.
-         * ValDesc reference count is incremented by AttachObject.
+         * All other types than Alias and the various Fields come here,
+         * including the untyped case - ACPI_TYPE_ANY.
          */
+        break;
+    }
 
-        Status = AcpiNsAttachObject (Node, ValDesc, ValDesc->Common.Type);
+    return_ACPI_STATUS (Status);
+}
 
-        DEBUG_PRINT (ACPI_INFO,
-            ("AmlStoreObjectToNte: Store %s into %s via Attach\n",
-            AcpiCmGetTypeName (ValDesc->Common.Type),
-            AcpiCmGetTypeName (DestinationType)));
 
-        goto CleanUpAndBailOut;
-        break;
-    }
 
-    /* Exit now if failure above */
 
-    if (ACPI_FAILURE (Status))
-    {
-        goto CleanUpAndBailOut;
-    }
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiAmlStoreObject
+ *
+ * PARAMETERS:  SourceDesc          - Object to store
+ *              TargetType          - Current type of the target
+ *              TargetDescPtr       - Pointer to the target
+ *              WalkState           - Current walk state
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: "Store" an object to another object.  This may include 
+ *              converting the source type to the target type (implicit
+ *              conversion), and a copy of the value of the source to
+ *              the target.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiAmlStoreObject (
+    ACPI_OPERAND_OBJECT     *SourceDesc,
+    OBJECT_TYPE_INTERNAL    TargetType,
+    ACPI_OPERAND_OBJECT     **TargetDescPtr,
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_OPERAND_OBJECT     *TargetDesc = *TargetDescPtr;
+    ACPI_STATUS             Status;
+
+
+    FUNCTION_TRACE ("AmlStoreObject");
 
-    /*
-     *  Get descriptor for object attached to Node
-     */
-    DestDesc = AcpiNsGetAttachedObject (Node);
-    if (!DestDesc)
-    {
-        /*
-         *  There is no existing object attached to this Node
-         */
-        DEBUG_PRINT (ACPI_ERROR,
-            ("AmlStoreObjectToNte: Internal error - no destination object for %4.4s type %X\n",
-            &Node->Name, DestinationType));
-        Status = AE_AML_INTERNAL;
-        goto CleanUpAndBailOut;
-    }
 
     /*
-     *  Make sure the destination Object is the same as the Node
+     * Perform the "implicit conversion" of the source to the current type
+     * of the target - As per the ACPI specification.
+     *
+     * If no conversion performed, SourceDesc is left alone, otherwise it
+     * is updated with a new object.
      */
-    if (DestDesc->Common.Type != (UINT8) DestinationType)
+    Status = AcpiAmlConvertToTargetType (TargetType, &SourceDesc, WalkState);
+    if (ACPI_FAILURE (Status))
     {
-        DEBUG_PRINT (ACPI_ERROR,
-            ("AmlStoreObjectToNte: Internal error - Name %4.4s type %X does not match value-type %X at %p\n",
-            &Node->Name, AcpiNsGetType (Node),
-            DestDesc->Common.Type, DestDesc));
-        Status = AE_AML_INTERNAL;
-        goto CleanUpAndBailOut;
+        return_ACPI_STATUS (Status);
     }
 
+
     /*
-     * AcpiEverything is ready to execute now,  We have
-     * a value we can handle, just perform the update
+     * We now have two objects of identical types, and we can perform a
+     * copy of the *value* of the source object.
      */
-
-    switch (DestinationType)
+    switch (TargetType)
     {
-        /* Type of Name's existing value */
-
-    case INTERNAL_TYPE_BANK_FIELD:
-
-        /*
-         * Get the global lock if needed
-         */
-        Locked = AcpiAmlAcquireGlobalLock (DestDesc->BankField.LockRule);
-
-        /*
-         *  Set Bank value to select proper Bank
-         *  Perform the update (Set Bank Select)
+    case ACPI_TYPE_ANY:
+    case INTERNAL_TYPE_DEF_ANY:
+        
+        /* 
+         * The target namespace node is uninitialized (has no target object),
+         * and will take on the type of the source object
          */
 
-        Status = AcpiAmlAccessNamedField (ACPI_WRITE,
-                                DestDesc->BankField.BankSelect,
-                                &DestDesc->BankField.Value,
-                                sizeof (DestDesc->BankField.Value));
-        if (ACPI_SUCCESS (Status))
-        {
-            /* Set bank select successful, set data value  */
-
-            Status = AcpiAmlAccessNamedField (ACPI_WRITE,
-                                DestDesc->BankField.BankSelect,
-                                &ValDesc->BankField.Value,
-                                sizeof (ValDesc->BankField.Value));
-        }
-
+        *TargetDescPtr = SourceDesc;
         break;
 
 
-    case INTERNAL_TYPE_DEF_FIELD:
-
-        /*
-         * Get the global lock if needed
-         */
-        Locked = AcpiAmlAcquireGlobalLock (ValDesc->Field.LockRule);
-
-        /*
-         *  Perform the update
-         */
-
-        switch (ValDesc->Common.Type)
-        {
-        case ACPI_TYPE_NUMBER:
-            Buffer = (UINT8 *) &ValDesc->Number.Value;
-            Length = sizeof (ValDesc->Number.Value);
-            break;
-
-        case ACPI_TYPE_BUFFER:
-            Buffer = (UINT8 *) ValDesc->Buffer.Pointer;
-            Length = ValDesc->Buffer.Length;
-            break;
-
-        case ACPI_TYPE_STRING:
-            Buffer = (UINT8 *) ValDesc->String.Pointer;
-            Length = ValDesc->String.Length;
-            break;
-        }
-
-        Status = AcpiAmlAccessNamedField (ACPI_WRITE,
-                                    Node, Buffer, Length);
+    case ACPI_TYPE_INTEGER:
 
-        break;      /* Global Lock released below   */
+        TargetDesc->Integer.Value = SourceDesc->Integer.Value;
 
+        /* Truncate value if we are executing from a 32-bit ACPI table */
 
-    case ACPI_TYPE_STRING:
-
-        /*
-         *  Perform the update
-         */
-
-        switch (ValDesc->Common.Type)
-        {
-        case ACPI_TYPE_NUMBER:
-            Buffer = (UINT8 *) &ValDesc->Number.Value;
-            Length = sizeof (ValDesc->Number.Value);
-            break;
-
-        case ACPI_TYPE_BUFFER:
-            Buffer = (UINT8 *) ValDesc->Buffer.Pointer;
-            Length = ValDesc->Buffer.Length;
-            break;
-
-        case ACPI_TYPE_STRING:
-            Buffer = (UINT8 *) ValDesc->String.Pointer;
-            Length = ValDesc->String.Length;
-            break;
-        }
-
-        /*
-         *  Setting a string value replaces the old string
-         */
-
-        if (Length < DestDesc->String.Length)
-        {
-            /*
-             *  Zero fill, not willing to do pointer arithmetic for
-             *  archetecture independance.  Just clear the whole thing
-             */
-            MEMSET(DestDesc->String.Pointer, 0, DestDesc->String.Length);
-            MEMCPY(DestDesc->String.Pointer, Buffer, Length);
-        }
-        else
-        {
-            /*
-             *  Free the current buffer, then allocate a buffer
-             *  large enough to hold the value
-             */
-            if ( DestDesc->String.Pointer &&
-                !AcpiTbSystemTablePointer (DestDesc->String.Pointer))
-            {
-                /*
-                 *  Only free if not a pointer into the DSDT
-                 */
-
-                AcpiCmFree(DestDesc->String.Pointer);
-            }
+        AcpiAmlTruncateFor32bitTable (TargetDesc, WalkState);
+        break;
 
-            DestDesc->String.Pointer = AcpiCmAllocate (Length + 1);
-            DestDesc->String.Length = Length;
 
-            if (!DestDesc->String.Pointer)
-            {
-                Status = AE_NO_MEMORY;
-                goto CleanUpAndBailOut;
-            }
+    case ACPI_TYPE_FIELD_UNIT:
 
-            MEMCPY(DestDesc->String.Pointer, Buffer, Length);
-        }
+        Status = AcpiAmlCopyIntegerToFieldUnit (SourceDesc, TargetDesc);
         break;
 
 
-    case ACPI_TYPE_BUFFER:
-
-        /*
-         *  Perform the update to the buffer
-         */
-
-        switch (ValDesc->Common.Type)
-        {
-        case ACPI_TYPE_NUMBER:
-            Buffer = (UINT8 *) &ValDesc->Number.Value;
-            Length = sizeof (ValDesc->Number.Value);
-            break;
-
-        case ACPI_TYPE_BUFFER:
-            Buffer = (UINT8 *) ValDesc->Buffer.Pointer;
-            Length = ValDesc->Buffer.Length;
-            break;
-
-        case ACPI_TYPE_STRING:
-            Buffer = (UINT8 *) ValDesc->String.Pointer;
-            Length = ValDesc->String.Length;
-            break;
-        }
+    case INTERNAL_TYPE_BANK_FIELD:
 
-        /*
-         *  Buffer is a static allocation,
-         *  only place what will fit in the buffer.
-         */
-        if (Length <= DestDesc->Buffer.Length)
-        {
-            /*
-             *  Zero fill first, not willing to do pointer arithmetic for
-             *  archetecture independence.  Just clear the whole thing
-             */
-            MEMSET(DestDesc->Buffer.Pointer, 0, DestDesc->Buffer.Length);
-            MEMCPY(DestDesc->Buffer.Pointer, Buffer, Length);
-        }
-        else
-        {
-            /*
-             *  truncate, copy only what will fit
-             */
-            MEMCPY(DestDesc->Buffer.Pointer, Buffer, DestDesc->Buffer.Length);
-            DEBUG_PRINT (ACPI_INFO,
-                ("AmlStoreObjectToNte: Truncating src buffer from %X to %X\n",
-                Length, DestDesc->Buffer.Length));
-        }
+        Status = AcpiAmlCopyIntegerToBankField (SourceDesc, TargetDesc);
         break;
 
 
     case INTERNAL_TYPE_INDEX_FIELD:
 
-        /*
-         * Get the global lock if needed
-         */
-        Locked = AcpiAmlAcquireGlobalLock (DestDesc->IndexField.LockRule);
-
-        /*
-         *  Set Index value to select proper Data register
-         *  perform the update (Set index)
-         */
-
-        Status = AcpiAmlAccessNamedField (ACPI_WRITE,
-                                DestDesc->IndexField.Index,
-                                &DestDesc->IndexField.Value,
-                                sizeof (DestDesc->IndexField.Value));
-
-        DEBUG_PRINT (ACPI_INFO,
-            ("AmlStoreObjectToNte: IndexField: set index returned %s\n",
-            AcpiCmFormatException (Status)));
-
-        if (ACPI_SUCCESS (Status))
-        {
-            /* set index successful, next set Data value */
-
-            Status = AcpiAmlAccessNamedField (ACPI_WRITE,
-                                DestDesc->IndexField.Data,
-                                &ValDesc->Number.Value,
-                                sizeof (ValDesc->Number.Value));
-            DEBUG_PRINT (ACPI_INFO,
-                ("AmlStoreObjectToNte: IndexField: set data returned %s\n",
-                AcpiCmFormatException (Status)));
-        }
+        Status = AcpiAmlCopyIntegerToIndexField (SourceDesc, TargetDesc);
         break;
 
 
-    case ACPI_TYPE_FIELD_UNIT:
-
-
-        /*
-         * If the Field Buffer and Index have not been previously evaluated,
-         * evaluate them and save the results.
-         */
-        if (!(DestDesc->Common.Flags & AOPOBJ_DATA_VALID))
-        {
-            Status = AcpiDsGetFieldUnitArguments (DestDesc);
-            if (ACPI_FAILURE (Status))
-            {
-                return_ACPI_STATUS (Status);
-            }
-        }
-
-        if ((!DestDesc->FieldUnit.Container ||
-            ACPI_TYPE_BUFFER != DestDesc->FieldUnit.Container->Common.Type))
-        {
-            DUMP_PATHNAME (Node,
-                "AmlStoreObjectToNte: FieldUnit: Bad container in ",
-                ACPI_ERROR, _COMPONENT);
-            DUMP_ENTRY (Node, ACPI_ERROR);
-            DEBUG_PRINT (ACPI_ERROR,
-                ("Container: %p", DestDesc->FieldUnit.Container));
-
-            if (DestDesc->FieldUnit.Container)
-            {
-                DEBUG_PRINT_RAW (ACPI_ERROR, (" Type %X",
-                    DestDesc->FieldUnit.Container->Common.Type));
-            }
-            DEBUG_PRINT_RAW (ACPI_ERROR, ("\n"));
-
-            Status = AE_AML_INTERNAL;
-            goto CleanUpAndBailOut;
-        }
-
-        /*
-         *  Get the global lock if needed
-         */
-        Locked = AcpiAmlAcquireGlobalLock (DestDesc->FieldUnit.LockRule);
-
-        /*
-         * TBD: [Unhandled] REMOVE this limitation
-         * Make sure the operation is within the limits of our implementation
-         * this is not a Spec limitation!!
-         */
-        if (DestDesc->FieldUnit.Length + DestDesc->FieldUnit.BitOffset > 32)
-        {
-            DEBUG_PRINT (ACPI_ERROR,
-                ("AmlStoreObjectToNte: FieldUnit: Implementation limitation - Field exceeds UINT32\n"));
-            Status = AE_NOT_IMPLEMENTED;
-            goto CleanUpAndBailOut;
-        }
-
-        /* Field location is (base of buffer) + (byte offset) */
-
-        Location = DestDesc->FieldUnit.Container->Buffer.Pointer
-                        + DestDesc->FieldUnit.Offset;
-
-        /*
-         * Construct Mask with 1 bits where the field is,
-         * 0 bits elsewhere
-         */
-        Mask = ((UINT32) 1 << DestDesc->FieldUnit.Length) - ((UINT32)1
-                            << DestDesc->FieldUnit.BitOffset);
-
-        DEBUG_PRINT (TRACE_EXEC,
-            ("** Store %lx in buffer %p byte %ld bit %X width %d addr %p mask %08lx\n",
-            ValDesc->Number.Value,
-            DestDesc->FieldUnit.Container->Buffer.Pointer,
-            DestDesc->FieldUnit.Offset, DestDesc->FieldUnit.BitOffset,
-            DestDesc->FieldUnit.Length,Location, Mask));
-
-        /* Zero out the field in the buffer */
-
-        MOVE_UNALIGNED32_TO_32 (&NewValue, Location);
-        NewValue &= ~Mask;
-
-        /*
-         * Shift and mask the new value into position,
-         * and or it into the buffer.
-         */
-        NewValue |= (ValDesc->Number.Value << DestDesc->FieldUnit.BitOffset) &
-                    Mask;
-
-        /* Store back the value */
-
-        MOVE_UNALIGNED32_TO_32 (Location, &NewValue);
+    case ACPI_TYPE_STRING:
 
-        DEBUG_PRINT (TRACE_EXEC, ("New Field value %08lx\n", NewValue));
+        Status = AcpiAmlCopyStringToString (SourceDesc, TargetDesc);
         break;
 
 
-    case ACPI_TYPE_NUMBER:
-
-
-        DestDesc->Number.Value = ValDesc->Number.Value;
-
-        /* Truncate value if we are executing from a 32-bit ACPI table */
+    case ACPI_TYPE_BUFFER:
 
-        AcpiAmlTruncateFor32bitTable (DestDesc, WalkState);
+        Status = AcpiAmlCopyBufferToBuffer (SourceDesc, TargetDesc);
         break;
 
 
     case ACPI_TYPE_PACKAGE:
 
         /*
-         *  TBD: [Unhandled] Not real sure what to do here
+         * TBD: [Unhandled] Not real sure what to do here
          */
         Status = AE_NOT_IMPLEMENTED;
         break;
@@ -690,28 +359,17 @@ AcpiAmlStoreObjectToNode (
     default:
 
         /*
-         * All other types than Alias and the various Fields come here.
-         * Store ValDesc as the new value of the Name, and set
-         * the Name's type to that of the value being stored in it.
-         * ValDesc reference count is incremented by AttachObject.
+         * All other types come here.
          */
-
         DEBUG_PRINT (ACPI_WARN,
-            ("AmlStoreObjectToNte: Store into %s not implemented\n",
-            AcpiCmGetTypeName (AcpiNsGetType (Node))));
+            ("AmlStoreObject: Store into type %s not implemented\n",
+            AcpiCmGetTypeName (TargetType)));
 
         Status = AE_NOT_IMPLEMENTED;
         break;
     }
 
 
-CleanUpAndBailOut:
-
-    /*
-     * Release global lock if we acquired it earlier
-     */
-    AcpiAmlReleaseGlobalLock (Locked);
-
     return_ACPI_STATUS (Status);
 }