Update to the 20010125 ACPI CA snapshot.

1 files changed, 388 insertions, 154 deletions

diff --git a/sys/contrib/dev/acpica/exstore.c b/sys/contrib/dev/acpica/exstore.c
index 51f1bb65e988..71d1dfb82aa5 100644
--- a/sys/contrib/dev/acpica/exstore.c
+++ b/sys/contrib/dev/acpica/exstore.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: amstore - AML Interpreter object store support
- *              $Revision: 118 $
+ *              $Revision: 121 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,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
@@ -130,6 +130,10 @@
         MODULE_NAME         ("amstore")
 
 
+
+
+
+
 /*******************************************************************************
  *
  * FUNCTION:    AcpiAmlExecStore
@@ -156,18 +160,10 @@ AcpiAmlExecStore (
     ACPI_WALK_STATE         *WalkState)
 {
     ACPI_STATUS             Status = AE_OK;
-    ACPI_OPERAND_OBJECT     *DeleteDestDesc = NULL;
-    ACPI_OPERAND_OBJECT     *TmpDesc;
-    ACPI_NAMESPACE_NODE     *Node = NULL;
-    UINT8                   Value = 0;
-    UINT32                  Length;
-    UINT32                  i;
-
+    ACPI_OPERAND_OBJECT     *RefDesc = DestDesc;
 
-    FUNCTION_TRACE ("AmlExecStore");
 
-    DEBUG_PRINT (ACPI_INFO, ("entered AcpiAmlExecStore: Val=%p, Dest=%p\n",
-                    ValDesc, DestDesc));
+    FUNCTION_TRACE_PTR ("AmlExecStore", DestDesc);
 
 
     /* Validate parameters */
@@ -179,80 +175,185 @@ AcpiAmlExecStore (
         return_ACPI_STATUS (AE_AML_NO_OPERAND);
     }
 
-    /* Examine the datatype of the DestDesc */
+    /* DestDesc can be either a namespace node or an ACPI object */
 
     if (VALID_DESCRIPTOR_TYPE (DestDesc, ACPI_DESC_TYPE_NAMED))
     {
-        /* Dest is an ACPI_HANDLE, create a new object */
-
-        Node = (ACPI_NAMESPACE_NODE *) DestDesc;
-        DestDesc = AcpiCmCreateInternalObject (INTERNAL_TYPE_REFERENCE);
-        if (!DestDesc)
-        {
-            /* Allocation failure  */
-
-            return_ACPI_STATUS (AE_NO_MEMORY);
-        }
+        /* 
+         * Dest is a namespace node,
+         * Storing an object into a Name "container" 
+         */
+        Status = AcpiAmlStoreObjectToNode (ValDesc, 
+                    (ACPI_NAMESPACE_NODE *) DestDesc, WalkState);
 
-        /* Build a new Reference wrapper around the handle */
+        /* All done, that's it */
 
-        DestDesc->Reference.OpCode = AML_NAME_OP;
-        DestDesc->Reference.Object = Node;
+        return_ACPI_STATUS (Status);
     }
 
-    else
-    {
-        DEBUG_PRINT (ACPI_INFO,
-            ("AmlExecStore: Dest is object (not handle) - may be deleted!\n"));
-    }
 
-    /* Destination object must be of type Reference */
+    /* Destination object must be an object of type Reference */
 
     if (DestDesc->Common.Type != INTERNAL_TYPE_REFERENCE)
     {
         /* Destination is not an Reference */
 
         DEBUG_PRINT (ACPI_ERROR,
-            ("AmlExecStore: Destination is not an Reference [%p]\n", DestDesc));
+            ("AmlExecStore: Destination is not a ReferenceObj [%p]\n", DestDesc));
 
         DUMP_STACK_ENTRY (ValDesc);
         DUMP_STACK_ENTRY (DestDesc);
         DUMP_OPERANDS (&DestDesc, IMODE_EXECUTE, "AmlExecStore",
-                        2, "target not Reference");
+                        2, "Target is not a ReferenceObj");
 
         return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
     }
 
-    /* Examine the Reference opcode */
 
-    switch (DestDesc->Reference.OpCode)
+    /* 
+     * Examine the Reference opcode.  These cases are handled:
+     *
+     * 1) Store to Name (Change the object associated with a name)
+     * 2) Store to an indexed area of a Buffer or Package
+     * 3) Store to a Method Local or Arg
+     * 4) Store to the debug object
+     * 5) Store to a constant -- a noop
+     */
+
+    switch (RefDesc->Reference.OpCode)
     {
 
     case AML_NAME_OP:
 
-        /*
-         *  Storing into a Name
-         */
-        DeleteDestDesc = DestDesc;
-        Status = AcpiAmlStoreObjectToNode (ValDesc, DestDesc->Reference.Object,
-                        WalkState);
+        /* Storing an object into a Name "container" */
 
-        break;  /* Case NameOp */
+        Status = AcpiAmlStoreObjectToNode (ValDesc, RefDesc->Reference.Object,
+                        WalkState);
+        break;
 
 
     case AML_INDEX_OP:
 
-        DeleteDestDesc = DestDesc;
+        /* Storing to an Index (pointer into a packager or buffer) */
+
+        Status = AcpiAmlStoreObjectToIndex (ValDesc, RefDesc, WalkState);
+        break;
+
+
+    case AML_LOCAL_OP:
+
+        Status = AcpiDsMethodDataSetValue (MTH_TYPE_LOCAL,
+                        (RefDesc->Reference.Offset), ValDesc, WalkState);
+        break;
+
+
+    case AML_ARG_OP:
+
+        Status = AcpiDsMethodDataSetValue (MTH_TYPE_ARG,
+                        (RefDesc->Reference.Offset), ValDesc, WalkState);
+        break;
+
+
+    case AML_DEBUG_OP:
 
         /*
-         * Valid source value and destination reference pointer.
+         * Storing to the Debug object causes the value stored to be
+         * displayed and otherwise has no effect -- see ACPI Specification
          *
-         * ACPI Specification 1.0B section 15.2.3.4.2.13:
-         * Destination should point to either a buffer or a package
+         * TBD: print known object types "prettier".
          */
+        DEBUG_PRINT (ACPI_INFO, ("**** Write to Debug Object: ****: \n"));
+        
+        if (ValDesc->Common.Type == ACPI_TYPE_STRING)
+        {
+            DEBUG_PRINT (ACPI_INFO, ("%s\n", ValDesc->String.Pointer));
+        }
+        else
+        {
+            DUMP_STACK_ENTRY (ValDesc);
+        }
+
+        break;
+
+
+    case AML_ZERO_OP:
+    case AML_ONE_OP:
+    case AML_ONES_OP:
 
         /*
-         * Actually, storing to a package is not so simple.  The source must be
+         * Storing to a constant is a no-op -- see ACPI Specification
+         * Delete the reference descriptor, however
+         */
+        break;
+
+
+    default:
+
+        DEBUG_PRINT (ACPI_ERROR,
+            ("AmlExecStore: Internal error - Unknown Reference subtype %02x\n",
+            RefDesc->Reference.OpCode));
+
+        /* TBD: [Restructure] use object dump routine !! */
+
+        DUMP_BUFFER (RefDesc, sizeof (ACPI_OPERAND_OBJECT));
+
+        Status = AE_AML_INTERNAL;
+        break;
+
+    }   /* switch (RefDesc->Reference.OpCode) */
+
+
+
+    /* Always delete the reference descriptor object */
+
+    if (RefDesc)
+    {
+        AcpiCmRemoveReference (RefDesc);
+    }
+
+    return_ACPI_STATUS (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiAmlStoreObjectToIndex
+ *
+ * PARAMETERS:  *ValDesc            - Value to be stored
+ *              *Node           - Named object to recieve the value
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Store the object to the named object.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiAmlStoreObjectToIndex (
+    ACPI_OPERAND_OBJECT     *ValDesc,
+    ACPI_OPERAND_OBJECT     *DestDesc,
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_STATUS             Status = AE_OK;
+    ACPI_OPERAND_OBJECT     *ObjDesc;
+    UINT32                  Length;
+    UINT32                  i;
+    UINT8                   Value = 0;
+
+
+    FUNCTION_TRACE ("AcpiAmlStoreObjectToIndex");
+
+
+    /*
+     * Destination must be a reference pointer, and
+     * must point to either a buffer or a package
+     */
+
+    switch (DestDesc->Reference.TargetType)
+    {
+    case ACPI_TYPE_PACKAGE:
+        /*
+         * Storing to a package element is not simple.  The source must be
          * evaluated and converted to the type of the destination and then the
          * source is copied into the destination - we can't just point to the
          * source object.
@@ -263,8 +364,8 @@ AcpiAmlExecStore (
              * The object at *(DestDesc->Reference.Where) is the
              *  element within the package that is to be modified.
              */
-            TmpDesc = *(DestDesc->Reference.Where);
-            if (TmpDesc)
+            ObjDesc = *(DestDesc->Reference.Where);
+            if (ObjDesc)
             {
                 /*
                  * If the Destination element is a package, we will delete
@@ -274,46 +375,44 @@ AcpiAmlExecStore (
                  *      to be packages?
                  *       && (ValDesc->Common.Type == ACPI_TYPE_PACKAGE)
                  */
-                if (TmpDesc->Common.Type == ACPI_TYPE_PACKAGE)
+                if (ObjDesc->Common.Type == ACPI_TYPE_PACKAGE)
                 {
                     /*
                      * Take away the reference for being part of a package and
                      * delete
                      */
-                    AcpiCmRemoveReference (TmpDesc);
-                    AcpiCmRemoveReference (TmpDesc);
+                    AcpiCmRemoveReference (ObjDesc);
+                    AcpiCmRemoveReference (ObjDesc);
 
-                    TmpDesc = NULL;
+                    ObjDesc = NULL;
                 }
             }
 
-            if (!TmpDesc)
+            if (!ObjDesc)
             {
                 /*
-                 * If the TmpDesc is NULL, that means an uninitialized package
-                 * has been used as a destination, therefore, we must create
-                 * the destination element to match the type of the source
-                 * element NOTE: ValDesc can be of any type.
+                 * If the ObjDesc is NULL, it means that an uninitialized package
+                 * element has been used as a destination (this is OK), therefore, 
+                 * we must create the destination element to match the type of the 
+                 * source element NOTE: ValDesc can be of any type.
                  */
-                TmpDesc = AcpiCmCreateInternalObject (ValDesc->Common.Type);
-                if (!TmpDesc)
+                ObjDesc = AcpiCmCreateInternalObject (ValDesc->Common.Type);
+                if (!ObjDesc)
                 {
-                    Status = AE_NO_MEMORY;
-                    goto Cleanup;
+                    return_ACPI_STATUS (AE_NO_MEMORY);
                 }
 
                 /*
                  * If the source is a package, copy the source to the new dest
                  */
-                if (ACPI_TYPE_PACKAGE == TmpDesc->Common.Type)
+                if (ACPI_TYPE_PACKAGE == ObjDesc->Common.Type)
                 {
                     Status = AcpiAmlBuildCopyInternalPackageObject (
-                                ValDesc, TmpDesc, WalkState);
+                                ValDesc, ObjDesc, WalkState);
                     if (ACPI_FAILURE (Status))
                     {
-                        AcpiCmRemoveReference (TmpDesc);
-                        TmpDesc = NULL;
-                        goto Cleanup;
+                        AcpiCmRemoveReference (ObjDesc);
+                        return_ACPI_STATUS (Status);
                     }
                 }
 
@@ -323,18 +422,18 @@ AcpiAmlExecStore (
                  * part of the parent package
                  */
 
-                *(DestDesc->Reference.Where) = TmpDesc;
-                AcpiCmAddReference (TmpDesc);
+                *(DestDesc->Reference.Where) = ObjDesc;
+                AcpiCmAddReference (ObjDesc);
             }
 
-            if (ACPI_TYPE_PACKAGE != TmpDesc->Common.Type)
+            if (ACPI_TYPE_PACKAGE != ObjDesc->Common.Type)
             {
                 /*
                  * The destination element is not a package, so we need to
                  * convert the contents of the source (ValDesc) and copy into
-                 * the destination (TmpDesc)
+                 * the destination (ObjDesc)
                  */
-                Status = AcpiAmlStoreObjectToObject (ValDesc, TmpDesc,
+                Status = AcpiAmlStoreObjectToObject (ValDesc, ObjDesc,
                                                         WalkState);
                 if (ACPI_FAILURE (Status))
                 {
@@ -344,22 +443,14 @@ AcpiAmlExecStore (
                      */
                     DEBUG_PRINT (ACPI_ERROR,
                         ("AmlExecStore/Index: Unable to copy the internal object\n"));
-                    Status = AE_AML_OPERAND_TYPE;
+                    return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
                 }
             }
-
-            break;
         }
+        break;
 
-        /*
-         * Check that the destination is a Buffer Field type
-         */
-        if (DestDesc->Reference.TargetType != ACPI_TYPE_BUFFER_FIELD)
-        {
-            Status = AE_AML_OPERAND_TYPE;
-            break;
-        }
 
+    case ACPI_TYPE_BUFFER_FIELD:
         /*
          * Storing into a buffer at a location defined by an Index.
          *
@@ -368,14 +459,12 @@ AcpiAmlExecStore (
          */
 
         /*
-         * Set the TmpDesc to the destination object and type check.
+         * Set the ObjDesc to the destination object and type check.
          */
-        TmpDesc = DestDesc->Reference.Object;
-
-        if (TmpDesc->Common.Type != ACPI_TYPE_BUFFER)
+        ObjDesc = DestDesc->Reference.Object;
+        if (ObjDesc->Common.Type != ACPI_TYPE_BUFFER)
         {
-            Status = AE_AML_OPERAND_TYPE;
-            break;
+            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
         }
 
         /*
@@ -386,16 +475,16 @@ AcpiAmlExecStore (
         switch (ValDesc->Common.Type)
         {
         /*
-         * If the type is Integer, the Length is 4.
+         * If the type is Integer, assign bytewise
          * This loop to assign each of the elements is somewhat
-         *  backward because of the Big Endian-ness of IA-64
+         * backward because of the Big Endian-ness of IA-64
          */
-        case ACPI_TYPE_NUMBER:
-            Length = 4;
+        case ACPI_TYPE_INTEGER:
+            Length = sizeof (ACPI_INTEGER);
             for (i = Length; i != 0; i--)
             {
-                Value = (UINT8)(ValDesc->Number.Value >> (MUL_8 (i - 1)));
-                TmpDesc->Buffer.Pointer[DestDesc->Reference.Offset] = Value;
+                Value = (UINT8)(ValDesc->Integer.Value >> (MUL_8 (i - 1)));
+                ObjDesc->Buffer.Pointer[DestDesc->Reference.Offset] = Value;
             }
             break;
 
@@ -408,7 +497,7 @@ AcpiAmlExecStore (
             for (i = 0; i < Length; i++)
             {
                 Value = *(ValDesc->Buffer.Pointer + i);
-                TmpDesc->Buffer.Pointer[DestDesc->Reference.Offset] = Value;
+                ObjDesc->Buffer.Pointer[DestDesc->Reference.Offset] = Value;
             }
             break;
 
@@ -421,7 +510,7 @@ AcpiAmlExecStore (
             for (i = 0; i < Length; i++)
             {
                 Value = *(ValDesc->String.Pointer + i);
-                TmpDesc->Buffer.Pointer[DestDesc->Reference.Offset] = Value;
+                ObjDesc->Buffer.Pointer[DestDesc->Reference.Offset] = Value;
             }
             break;
 
@@ -435,97 +524,242 @@ AcpiAmlExecStore (
             Status = AE_AML_OPERAND_TYPE;
             break;
         }
+        break;
 
-        /*
-         * If we had an error, break out of this case statement.
-         */
-        if (ACPI_FAILURE (Status))
-        {
-            break;
-        }
-
-        /*
-         * Set the return pointer
-         */
-        DestDesc = TmpDesc;
 
+    default:
+        DEBUG_PRINT (ACPI_ERROR,
+            ("AmlExecStoreIndex: Target is not a Package or BufferField\n"));
+        Status = AE_AML_OPERAND_TYPE;
         break;
+    }
 
-    case AML_ZERO_OP:
-    case AML_ONE_OP:
-    case AML_ONES_OP:
 
-        /*
-         * Storing to a constant is a no-op -- see ACPI Specification
-         * Delete the result descriptor.
-         */
+    return_ACPI_STATUS (Status);
+}
 
-        DeleteDestDesc = DestDesc;
-        break;
 
 
-    case AML_LOCAL_OP:
 
-        Status = AcpiDsMethodDataSetValue (MTH_TYPE_LOCAL,
-                        (DestDesc->Reference.Offset), ValDesc, WalkState);
-        DeleteDestDesc = DestDesc;
-        break;
 
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiAmlStoreObjectToNode
+ *
+ * PARAMETERS:  *SourceDesc            - Value to be stored
+ *              *Node               - Named object to recieve the value
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Store the object to the named object.
+ *
+ *              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.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiAmlStoreObjectToNode (
+    ACPI_OPERAND_OBJECT     *SourceDesc,
+    ACPI_NAMESPACE_NODE     *Node,
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_STATUS             Status = AE_OK;
+    ACPI_OPERAND_OBJECT     *TargetDesc;
+    OBJECT_TYPE_INTERNAL    TargetType = ACPI_TYPE_ANY;
 
-    case AML_ARG_OP:
 
-        Status = AcpiDsMethodDataSetValue (MTH_TYPE_ARG,
-                        (DestDesc->Reference.Offset), ValDesc, WalkState);
-        DeleteDestDesc = DestDesc;
+    FUNCTION_TRACE ("AmlStoreObjectToNode");
+
+    /*
+     * Assuming the parameters were already validated
+     */
+    ACPI_ASSERT((Node) && (SourceDesc));
+
+
+    /*
+     * Get current type of the node, and object attached to Node
+     */
+    TargetType = AcpiNsGetType (Node);
+    TargetDesc = AcpiNsGetAttachedObject (Node);
+
+    DEBUG_PRINT (ACPI_INFO, ("AmlStoreObjectToNode: Storing %p(%s) into node %p(%s)\n",
+        Node, AcpiCmGetTypeName (SourceDesc->Common.Type),
+        SourceDesc, AcpiCmGetTypeName (TargetType)));
+
+
+    /*
+     * Resolve the source object to an actual value
+     * (If it is a reference object) 
+     */
+    Status = AcpiAmlResolveObject (&SourceDesc, TargetType, WalkState);
+    if (ACPI_FAILURE (Status))
+    {
+        return_ACPI_STATUS (Status);
+    }
+
+
+    /*
+     * Do the actual store operation 
+     */
+    switch (TargetType)
+    {
+    case INTERNAL_TYPE_DEF_FIELD:
+
+        /* Raw data copy for target types Integer/String/Buffer */
+
+        Status = AcpiAmlCopyDataToNamedField (SourceDesc, Node);
         break;
 
 
-    case AML_DEBUG_OP:
+    case ACPI_TYPE_INTEGER:
+    case ACPI_TYPE_STRING:
+    case ACPI_TYPE_BUFFER:
+    case INTERNAL_TYPE_BANK_FIELD:
+    case INTERNAL_TYPE_INDEX_FIELD:
+    case ACPI_TYPE_FIELD_UNIT:
 
-        /*
-         * Storing to the Debug object causes the value stored to be
-         * displayed and otherwise has no effect -- see ACPI Specification
+        /* 
+         * These target types are all of type Integer/String/Buffer, and
+         * therefore support implicit conversion before the store.
+         * 
+         * Copy and/or convert the source object to a new target object 
          */
-        DEBUG_PRINT (ACPI_INFO, ("**** Write to Debug Object: ****: \n"));
-        if (ValDesc->Common.Type == ACPI_TYPE_STRING)
-        {
-            DEBUG_PRINT (ACPI_INFO, ("%s\n", ValDesc->String.Pointer));
-        }
-        else
+        Status = AcpiAmlStoreObject (SourceDesc, TargetType, &TargetDesc, WalkState);
+        if (ACPI_FAILURE (Status))
         {
-            DUMP_STACK_ENTRY (ValDesc);
+            return_ACPI_STATUS (Status);
         }
 
-        DeleteDestDesc = DestDesc;
+        /*
+         * Store the new TargetDesc as the new value of the Name, and set
+         * the Name's type to that of the value being stored in it.
+         * SourceDesc reference count is incremented by AttachObject.
+         */
+        Status = AcpiNsAttachObject (Node, TargetDesc, TargetType);
+        DEBUG_PRINT (ACPI_INFO,
+            ("AmlStoreObjectToNode: Store %s into %s via Convert/Attach\n",
+            AcpiCmGetTypeName (TargetDesc->Common.Type),
+            AcpiCmGetTypeName (TargetType)));
         break;
-
+    
 
     default:
 
-        DEBUG_PRINT (ACPI_ERROR,
-            ("AmlExecStore: Internal error - Unknown Reference subtype %02x\n",
-            DestDesc->Reference.OpCode));
+        /* No conversions for all other types.  Just attach the source object */
 
-        /* TBD: [Restructure] use object dump routine !! */
+        Status = AcpiNsAttachObject (Node, SourceDesc, SourceDesc->Common.Type);
+        
+        DEBUG_PRINT (ACPI_INFO,
+            ("AmlStoreObjectToNode: Store %s into %s via Attach only\n",
+            AcpiCmGetTypeName (SourceDesc->Common.Type),
+            AcpiCmGetTypeName (SourceDesc->Common.Type)));
+        break;
+    }
 
-        DUMP_BUFFER (DestDesc, sizeof (ACPI_OPERAND_OBJECT));
 
-        DeleteDestDesc = DestDesc;
-        Status = AE_AML_INTERNAL;
+    return_ACPI_STATUS (Status);
+}
 
-    }   /* switch(DestDesc->Reference.OpCode) */
 
 
-Cleanup:
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiAmlStoreObjectToObject
+ *
+ * PARAMETERS:  *SourceDesc            - Value to be stored
+ *              *DestDesc           - Object to receive the value
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Store an object to another object.
+ *
+ *              The Assignment of an object to another (not 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.
+ *
+ *              This module allows destination types of Number, String,
+ *              and Buffer.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiAmlStoreObjectToObject (
+    ACPI_OPERAND_OBJECT     *SourceDesc,
+    ACPI_OPERAND_OBJECT     *DestDesc,
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_STATUS             Status = AE_OK;
+    OBJECT_TYPE_INTERNAL    DestinationType = DestDesc->Common.Type;
+
+
+    FUNCTION_TRACE ("AmlStoreObjectToObject");
+
+
+    /*
+     *  Assuming the parameters are valid!
+     */
+    ACPI_ASSERT((DestDesc) && (SourceDesc));
 
-    /* Cleanup and exit*/
+    DEBUG_PRINT (ACPI_INFO, ("AmlStoreObjectToObject: Storing %p(%s) to (%p)%s\n",
+                    SourceDesc, AcpiCmGetTypeName (SourceDesc->Common.Type),
+                    DestDesc, AcpiCmGetTypeName (DestDesc->Common.Type)));
 
-    if (DeleteDestDesc)
+
+    /*
+     * From this interface, we only support Integers/Strings/Buffers
+     */
+    switch (DestinationType)
+    {
+    case ACPI_TYPE_INTEGER:
+    case ACPI_TYPE_STRING:
+    case ACPI_TYPE_BUFFER:
+        break;
+
+    default:
+        DEBUG_PRINT (ACPI_WARN,
+            ("AmlStoreObjectToObject: Store into %s not implemented\n",
+            AcpiCmGetTypeName (DestDesc->Common.Type)));
+
+        return_ACPI_STATUS (AE_NOT_IMPLEMENTED);
+    }
+
+
+
+    /*
+     * Resolve the source object to an actual value
+     * (If it is a reference object) 
+     */
+    Status = AcpiAmlResolveObject (&SourceDesc, DestinationType, WalkState);
+    if (ACPI_FAILURE (Status))
     {
-        AcpiCmRemoveReference (DeleteDestDesc);
+        return_ACPI_STATUS (Status);
     }
 
+
+    /*
+     * Copy and/or convert the source object to the destination object 
+     */
+    Status = AcpiAmlStoreObject (SourceDesc, DestinationType, &DestDesc, WalkState);
+
+
     return_ACPI_STATUS (Status);
 }
 
-