1 /******************************************************************************
3 * Module Name: utcopy - Internal to external object translation utilities
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2011, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
46 #include <contrib/dev/acpica/include/acpi.h>
47 #include <contrib/dev/acpica/include/accommon.h>
48 #include <contrib/dev/acpica/include/acnamesp.h>
51 #define _COMPONENT ACPI_UTILITIES
52 ACPI_MODULE_NAME ("utcopy")
54 /* Local prototypes */
57 AcpiUtCopyIsimpleToEsimple (
58 ACPI_OPERAND_OBJECT *InternalObject,
59 ACPI_OBJECT *ExternalObject,
61 ACPI_SIZE *BufferSpaceUsed);
64 AcpiUtCopyIelementToIelement (
66 ACPI_OPERAND_OBJECT *SourceObject,
67 ACPI_GENERIC_STATE *State,
71 AcpiUtCopyIpackageToEpackage (
72 ACPI_OPERAND_OBJECT *InternalObject,
74 ACPI_SIZE *SpaceUsed);
77 AcpiUtCopyEsimpleToIsimple(
79 ACPI_OPERAND_OBJECT **ReturnObj);
82 AcpiUtCopyEpackageToIpackage (
83 ACPI_OBJECT *ExternalObject,
84 ACPI_OPERAND_OBJECT **InternalObject);
87 AcpiUtCopySimpleObject (
88 ACPI_OPERAND_OBJECT *SourceDesc,
89 ACPI_OPERAND_OBJECT *DestDesc);
92 AcpiUtCopyIelementToEelement (
94 ACPI_OPERAND_OBJECT *SourceObject,
95 ACPI_GENERIC_STATE *State,
99 AcpiUtCopyIpackageToIpackage (
100 ACPI_OPERAND_OBJECT *SourceObj,
101 ACPI_OPERAND_OBJECT *DestObj,
102 ACPI_WALK_STATE *WalkState);
105 /*******************************************************************************
107 * FUNCTION: AcpiUtCopyIsimpleToEsimple
109 * PARAMETERS: InternalObject - Source object to be copied
110 * ExternalObject - Where to return the copied object
111 * DataSpace - Where object data is returned (such as
112 * buffer and string data)
113 * BufferSpaceUsed - Length of DataSpace that was used
117 * DESCRIPTION: This function is called to copy a simple internal object to
118 * an external object.
120 * The DataSpace buffer is assumed to have sufficient space for
123 ******************************************************************************/
126 AcpiUtCopyIsimpleToEsimple (
127 ACPI_OPERAND_OBJECT *InternalObject,
128 ACPI_OBJECT *ExternalObject,
130 ACPI_SIZE *BufferSpaceUsed)
132 ACPI_STATUS Status = AE_OK;
135 ACPI_FUNCTION_TRACE (UtCopyIsimpleToEsimple);
138 *BufferSpaceUsed = 0;
141 * Check for NULL object case (could be an uninitialized
146 return_ACPI_STATUS (AE_OK);
149 /* Always clear the external object */
151 ACPI_MEMSET (ExternalObject, 0, sizeof (ACPI_OBJECT));
154 * In general, the external object will be the same type as
155 * the internal object
157 ExternalObject->Type = InternalObject->Common.Type;
159 /* However, only a limited number of external types are supported */
161 switch (InternalObject->Common.Type)
163 case ACPI_TYPE_STRING:
165 ExternalObject->String.Pointer = (char *) DataSpace;
166 ExternalObject->String.Length = InternalObject->String.Length;
167 *BufferSpaceUsed = ACPI_ROUND_UP_TO_NATIVE_WORD (
168 (ACPI_SIZE) InternalObject->String.Length + 1);
170 ACPI_MEMCPY ((void *) DataSpace,
171 (void *) InternalObject->String.Pointer,
172 (ACPI_SIZE) InternalObject->String.Length + 1);
176 case ACPI_TYPE_BUFFER:
178 ExternalObject->Buffer.Pointer = DataSpace;
179 ExternalObject->Buffer.Length = InternalObject->Buffer.Length;
180 *BufferSpaceUsed = ACPI_ROUND_UP_TO_NATIVE_WORD (
181 InternalObject->String.Length);
183 ACPI_MEMCPY ((void *) DataSpace,
184 (void *) InternalObject->Buffer.Pointer,
185 InternalObject->Buffer.Length);
189 case ACPI_TYPE_INTEGER:
191 ExternalObject->Integer.Value = InternalObject->Integer.Value;
195 case ACPI_TYPE_LOCAL_REFERENCE:
197 /* This is an object reference. */
199 switch (InternalObject->Reference.Class)
201 case ACPI_REFCLASS_NAME:
204 * For namepath, return the object handle ("reference")
205 * We are referring to the namespace node
207 ExternalObject->Reference.Handle =
208 InternalObject->Reference.Node;
209 ExternalObject->Reference.ActualType =
210 AcpiNsGetType (InternalObject->Reference.Node);
215 /* All other reference types are unsupported */
217 return_ACPI_STATUS (AE_TYPE);
222 case ACPI_TYPE_PROCESSOR:
224 ExternalObject->Processor.ProcId =
225 InternalObject->Processor.ProcId;
226 ExternalObject->Processor.PblkAddress =
227 InternalObject->Processor.Address;
228 ExternalObject->Processor.PblkLength =
229 InternalObject->Processor.Length;
233 case ACPI_TYPE_POWER:
235 ExternalObject->PowerResource.SystemLevel =
236 InternalObject->PowerResource.SystemLevel;
238 ExternalObject->PowerResource.ResourceOrder =
239 InternalObject->PowerResource.ResourceOrder;
245 * There is no corresponding external object type
247 ACPI_ERROR ((AE_INFO,
248 "Unsupported object type, cannot convert to external object: %s",
249 AcpiUtGetTypeName (InternalObject->Common.Type)));
251 return_ACPI_STATUS (AE_SUPPORT);
254 return_ACPI_STATUS (Status);
258 /*******************************************************************************
260 * FUNCTION: AcpiUtCopyIelementToEelement
262 * PARAMETERS: ACPI_PKG_CALLBACK
266 * DESCRIPTION: Copy one package element to another package element
268 ******************************************************************************/
271 AcpiUtCopyIelementToEelement (
273 ACPI_OPERAND_OBJECT *SourceObject,
274 ACPI_GENERIC_STATE *State,
277 ACPI_STATUS Status = AE_OK;
278 ACPI_PKG_INFO *Info = (ACPI_PKG_INFO *) Context;
279 ACPI_SIZE ObjectSpace;
281 ACPI_OBJECT *TargetObject;
284 ACPI_FUNCTION_ENTRY ();
287 ThisIndex = State->Pkg.Index;
288 TargetObject = (ACPI_OBJECT *)
289 &((ACPI_OBJECT *)(State->Pkg.DestObject))->Package.Elements[ThisIndex];
293 case ACPI_COPY_TYPE_SIMPLE:
296 * This is a simple or null object
298 Status = AcpiUtCopyIsimpleToEsimple (SourceObject,
299 TargetObject, Info->FreeSpace, &ObjectSpace);
300 if (ACPI_FAILURE (Status))
307 case ACPI_COPY_TYPE_PACKAGE:
310 * Build the package object
312 TargetObject->Type = ACPI_TYPE_PACKAGE;
313 TargetObject->Package.Count = SourceObject->Package.Count;
314 TargetObject->Package.Elements =
315 ACPI_CAST_PTR (ACPI_OBJECT, Info->FreeSpace);
318 * Pass the new package object back to the package walk routine
320 State->Pkg.ThisTargetObj = TargetObject;
323 * Save space for the array of objects (Package elements)
324 * update the buffer length counter
326 ObjectSpace = ACPI_ROUND_UP_TO_NATIVE_WORD (
327 (ACPI_SIZE) TargetObject->Package.Count *
328 sizeof (ACPI_OBJECT));
333 return (AE_BAD_PARAMETER);
336 Info->FreeSpace += ObjectSpace;
337 Info->Length += ObjectSpace;
342 /*******************************************************************************
344 * FUNCTION: AcpiUtCopyIpackageToEpackage
346 * PARAMETERS: InternalObject - Pointer to the object we are returning
347 * Buffer - Where the object is returned
348 * SpaceUsed - Where the object length is returned
352 * DESCRIPTION: This function is called to place a package object in a user
353 * buffer. A package object by definition contains other objects.
355 * The buffer is assumed to have sufficient space for the object.
356 * The caller must have verified the buffer length needed using
357 * the AcpiUtGetObjectSize function before calling this function.
359 ******************************************************************************/
362 AcpiUtCopyIpackageToEpackage (
363 ACPI_OPERAND_OBJECT *InternalObject,
365 ACPI_SIZE *SpaceUsed)
367 ACPI_OBJECT *ExternalObject;
372 ACPI_FUNCTION_TRACE (UtCopyIpackageToEpackage);
376 * First package at head of the buffer
378 ExternalObject = ACPI_CAST_PTR (ACPI_OBJECT, Buffer);
381 * Free space begins right after the first package
383 Info.Length = ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
384 Info.FreeSpace = Buffer + ACPI_ROUND_UP_TO_NATIVE_WORD (
385 sizeof (ACPI_OBJECT));
386 Info.ObjectSpace = 0;
387 Info.NumPackages = 1;
389 ExternalObject->Type = InternalObject->Common.Type;
390 ExternalObject->Package.Count = InternalObject->Package.Count;
391 ExternalObject->Package.Elements = ACPI_CAST_PTR (ACPI_OBJECT,
395 * Leave room for an array of ACPI_OBJECTS in the buffer
396 * and move the free space past it
398 Info.Length += (ACPI_SIZE) ExternalObject->Package.Count *
399 ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
400 Info.FreeSpace += ExternalObject->Package.Count *
401 ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
403 Status = AcpiUtWalkPackageTree (InternalObject, ExternalObject,
404 AcpiUtCopyIelementToEelement, &Info);
406 *SpaceUsed = Info.Length;
407 return_ACPI_STATUS (Status);
411 /*******************************************************************************
413 * FUNCTION: AcpiUtCopyIobjectToEobject
415 * PARAMETERS: InternalObject - The internal object to be converted
416 * RetBuffer - Where the object is returned
420 * DESCRIPTION: This function is called to build an API object to be returned
423 ******************************************************************************/
426 AcpiUtCopyIobjectToEobject (
427 ACPI_OPERAND_OBJECT *InternalObject,
428 ACPI_BUFFER *RetBuffer)
433 ACPI_FUNCTION_TRACE (UtCopyIobjectToEobject);
436 if (InternalObject->Common.Type == ACPI_TYPE_PACKAGE)
439 * Package object: Copy all subobjects (including
442 Status = AcpiUtCopyIpackageToEpackage (InternalObject,
443 RetBuffer->Pointer, &RetBuffer->Length);
448 * Build a simple object (no nested objects)
450 Status = AcpiUtCopyIsimpleToEsimple (InternalObject,
451 ACPI_CAST_PTR (ACPI_OBJECT, RetBuffer->Pointer),
452 ACPI_ADD_PTR (UINT8, RetBuffer->Pointer,
453 ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT))),
456 * build simple does not include the object size in the length
457 * so we add it in here
459 RetBuffer->Length += sizeof (ACPI_OBJECT);
462 return_ACPI_STATUS (Status);
466 /*******************************************************************************
468 * FUNCTION: AcpiUtCopyEsimpleToIsimple
470 * PARAMETERS: ExternalObject - The external object to be converted
471 * RetInternalObject - Where the internal object is returned
475 * DESCRIPTION: This function copies an external object to an internal one.
476 * NOTE: Pointers can be copied, we don't need to copy data.
477 * (The pointers have to be valid in our address space no matter
478 * what we do with them!)
480 ******************************************************************************/
483 AcpiUtCopyEsimpleToIsimple (
484 ACPI_OBJECT *ExternalObject,
485 ACPI_OPERAND_OBJECT **RetInternalObject)
487 ACPI_OPERAND_OBJECT *InternalObject;
490 ACPI_FUNCTION_TRACE (UtCopyEsimpleToIsimple);
494 * Simple types supported are: String, Buffer, Integer
496 switch (ExternalObject->Type)
498 case ACPI_TYPE_STRING:
499 case ACPI_TYPE_BUFFER:
500 case ACPI_TYPE_INTEGER:
501 case ACPI_TYPE_LOCAL_REFERENCE:
503 InternalObject = AcpiUtCreateInternalObject (
504 (UINT8) ExternalObject->Type);
507 return_ACPI_STATUS (AE_NO_MEMORY);
511 case ACPI_TYPE_ANY: /* This is the case for a NULL object */
513 *RetInternalObject = NULL;
514 return_ACPI_STATUS (AE_OK);
517 /* All other types are not supported */
519 ACPI_ERROR ((AE_INFO,
520 "Unsupported object type, cannot convert to internal object: %s",
521 AcpiUtGetTypeName (ExternalObject->Type)));
523 return_ACPI_STATUS (AE_SUPPORT);
527 /* Must COPY string and buffer contents */
529 switch (ExternalObject->Type)
531 case ACPI_TYPE_STRING:
533 InternalObject->String.Pointer =
534 ACPI_ALLOCATE_ZEROED ((ACPI_SIZE)
535 ExternalObject->String.Length + 1);
537 if (!InternalObject->String.Pointer)
542 ACPI_MEMCPY (InternalObject->String.Pointer,
543 ExternalObject->String.Pointer,
544 ExternalObject->String.Length);
546 InternalObject->String.Length = ExternalObject->String.Length;
550 case ACPI_TYPE_BUFFER:
552 InternalObject->Buffer.Pointer =
553 ACPI_ALLOCATE_ZEROED (ExternalObject->Buffer.Length);
554 if (!InternalObject->Buffer.Pointer)
559 ACPI_MEMCPY (InternalObject->Buffer.Pointer,
560 ExternalObject->Buffer.Pointer,
561 ExternalObject->Buffer.Length);
563 InternalObject->Buffer.Length = ExternalObject->Buffer.Length;
565 /* Mark buffer data valid */
567 InternalObject->Buffer.Flags |= AOPOBJ_DATA_VALID;
571 case ACPI_TYPE_INTEGER:
573 InternalObject->Integer.Value = ExternalObject->Integer.Value;
576 case ACPI_TYPE_LOCAL_REFERENCE:
578 /* TBD: should validate incoming handle */
580 InternalObject->Reference.Class = ACPI_REFCLASS_NAME;
581 InternalObject->Reference.Node = ExternalObject->Reference.Handle;
585 /* Other types can't get here */
589 *RetInternalObject = InternalObject;
590 return_ACPI_STATUS (AE_OK);
594 AcpiUtRemoveReference (InternalObject);
595 return_ACPI_STATUS (AE_NO_MEMORY);
599 /*******************************************************************************
601 * FUNCTION: AcpiUtCopyEpackageToIpackage
603 * PARAMETERS: ExternalObject - The external object to be converted
604 * InternalObject - Where the internal object is returned
608 * DESCRIPTION: Copy an external package object to an internal package.
609 * Handles nested packages.
611 ******************************************************************************/
614 AcpiUtCopyEpackageToIpackage (
615 ACPI_OBJECT *ExternalObject,
616 ACPI_OPERAND_OBJECT **InternalObject)
618 ACPI_STATUS Status = AE_OK;
619 ACPI_OPERAND_OBJECT *PackageObject;
620 ACPI_OPERAND_OBJECT **PackageElements;
624 ACPI_FUNCTION_TRACE (UtCopyEpackageToIpackage);
627 /* Create the package object */
629 PackageObject = AcpiUtCreatePackageObject (ExternalObject->Package.Count);
632 return_ACPI_STATUS (AE_NO_MEMORY);
635 PackageElements = PackageObject->Package.Elements;
638 * Recursive implementation. Probably ok, since nested external packages
639 * as parameters should be very rare.
641 for (i = 0; i < ExternalObject->Package.Count; i++)
643 Status = AcpiUtCopyEobjectToIobject (
644 &ExternalObject->Package.Elements[i],
645 &PackageElements[i]);
646 if (ACPI_FAILURE (Status))
648 /* Truncate package and delete it */
650 PackageObject->Package.Count = i;
651 PackageElements[i] = NULL;
652 AcpiUtRemoveReference (PackageObject);
653 return_ACPI_STATUS (Status);
657 /* Mark package data valid */
659 PackageObject->Package.Flags |= AOPOBJ_DATA_VALID;
661 *InternalObject = PackageObject;
662 return_ACPI_STATUS (Status);
666 /*******************************************************************************
668 * FUNCTION: AcpiUtCopyEobjectToIobject
670 * PARAMETERS: ExternalObject - The external object to be converted
671 * InternalObject - Where the internal object is returned
675 * DESCRIPTION: Converts an external object to an internal object.
677 ******************************************************************************/
680 AcpiUtCopyEobjectToIobject (
681 ACPI_OBJECT *ExternalObject,
682 ACPI_OPERAND_OBJECT **InternalObject)
687 ACPI_FUNCTION_TRACE (UtCopyEobjectToIobject);
690 if (ExternalObject->Type == ACPI_TYPE_PACKAGE)
692 Status = AcpiUtCopyEpackageToIpackage (ExternalObject, InternalObject);
697 * Build a simple object (no nested objects)
699 Status = AcpiUtCopyEsimpleToIsimple (ExternalObject, InternalObject);
702 return_ACPI_STATUS (Status);
706 /*******************************************************************************
708 * FUNCTION: AcpiUtCopySimpleObject
710 * PARAMETERS: SourceDesc - The internal object to be copied
711 * DestDesc - New target object
715 * DESCRIPTION: Simple copy of one internal object to another. Reference count
716 * of the destination object is preserved.
718 ******************************************************************************/
721 AcpiUtCopySimpleObject (
722 ACPI_OPERAND_OBJECT *SourceDesc,
723 ACPI_OPERAND_OBJECT *DestDesc)
725 UINT16 ReferenceCount;
726 ACPI_OPERAND_OBJECT *NextObject;
731 /* Save fields from destination that we don't want to overwrite */
733 ReferenceCount = DestDesc->Common.ReferenceCount;
734 NextObject = DestDesc->Common.NextObject;
737 * Copy the entire source object over the destination object.
738 * Note: Source can be either an operand object or namespace node.
740 CopySize = sizeof (ACPI_OPERAND_OBJECT);
741 if (ACPI_GET_DESCRIPTOR_TYPE (SourceDesc) == ACPI_DESC_TYPE_NAMED)
743 CopySize = sizeof (ACPI_NAMESPACE_NODE);
746 ACPI_MEMCPY (ACPI_CAST_PTR (char, DestDesc),
747 ACPI_CAST_PTR (char, SourceDesc), CopySize);
749 /* Restore the saved fields */
751 DestDesc->Common.ReferenceCount = ReferenceCount;
752 DestDesc->Common.NextObject = NextObject;
754 /* New object is not static, regardless of source */
756 DestDesc->Common.Flags &= ~AOPOBJ_STATIC_POINTER;
758 /* Handle the objects with extra data */
760 switch (DestDesc->Common.Type)
762 case ACPI_TYPE_BUFFER:
764 * Allocate and copy the actual buffer if and only if:
765 * 1) There is a valid buffer pointer
766 * 2) The buffer has a length > 0
768 if ((SourceDesc->Buffer.Pointer) &&
769 (SourceDesc->Buffer.Length))
771 DestDesc->Buffer.Pointer =
772 ACPI_ALLOCATE (SourceDesc->Buffer.Length);
773 if (!DestDesc->Buffer.Pointer)
775 return (AE_NO_MEMORY);
778 /* Copy the actual buffer data */
780 ACPI_MEMCPY (DestDesc->Buffer.Pointer,
781 SourceDesc->Buffer.Pointer, SourceDesc->Buffer.Length);
785 case ACPI_TYPE_STRING:
787 * Allocate and copy the actual string if and only if:
788 * 1) There is a valid string pointer
789 * (Pointer to a NULL string is allowed)
791 if (SourceDesc->String.Pointer)
793 DestDesc->String.Pointer =
794 ACPI_ALLOCATE ((ACPI_SIZE) SourceDesc->String.Length + 1);
795 if (!DestDesc->String.Pointer)
797 return (AE_NO_MEMORY);
800 /* Copy the actual string data */
802 ACPI_MEMCPY (DestDesc->String.Pointer, SourceDesc->String.Pointer,
803 (ACPI_SIZE) SourceDesc->String.Length + 1);
807 case ACPI_TYPE_LOCAL_REFERENCE:
809 * We copied the reference object, so we now must add a reference
810 * to the object pointed to by the reference
812 * DDBHandle reference (from Load/LoadTable) is a special reference,
813 * it does not have a Reference.Object, so does not need to
814 * increase the reference count
816 if (SourceDesc->Reference.Class == ACPI_REFCLASS_TABLE)
821 AcpiUtAddReference (SourceDesc->Reference.Object);
824 case ACPI_TYPE_REGION:
826 * We copied the Region Handler, so we now must add a reference
828 if (DestDesc->Region.Handler)
830 AcpiUtAddReference (DestDesc->Region.Handler);
835 * For Mutex and Event objects, we cannot simply copy the underlying
836 * OS object. We must create a new one.
838 case ACPI_TYPE_MUTEX:
840 Status = AcpiOsCreateMutex (&DestDesc->Mutex.OsMutex);
841 if (ACPI_FAILURE (Status))
847 case ACPI_TYPE_EVENT:
849 Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 0,
850 &DestDesc->Event.OsSemaphore);
851 if (ACPI_FAILURE (Status))
858 /* Nothing to do for other simple objects */
866 /*******************************************************************************
868 * FUNCTION: AcpiUtCopyIelementToIelement
870 * PARAMETERS: ACPI_PKG_CALLBACK
874 * DESCRIPTION: Copy one package element to another package element
876 ******************************************************************************/
879 AcpiUtCopyIelementToIelement (
881 ACPI_OPERAND_OBJECT *SourceObject,
882 ACPI_GENERIC_STATE *State,
885 ACPI_STATUS Status = AE_OK;
887 ACPI_OPERAND_OBJECT **ThisTargetPtr;
888 ACPI_OPERAND_OBJECT *TargetObject;
891 ACPI_FUNCTION_ENTRY ();
894 ThisIndex = State->Pkg.Index;
895 ThisTargetPtr = (ACPI_OPERAND_OBJECT **)
896 &State->Pkg.DestObject->Package.Elements[ThisIndex];
900 case ACPI_COPY_TYPE_SIMPLE:
902 /* A null source object indicates a (legal) null package element */
907 * This is a simple object, just copy it
909 TargetObject = AcpiUtCreateInternalObject (
910 SourceObject->Common.Type);
913 return (AE_NO_MEMORY);
916 Status = AcpiUtCopySimpleObject (SourceObject, TargetObject);
917 if (ACPI_FAILURE (Status))
922 *ThisTargetPtr = TargetObject;
926 /* Pass through a null element */
928 *ThisTargetPtr = NULL;
933 case ACPI_COPY_TYPE_PACKAGE:
936 * This object is a package - go down another nesting level
937 * Create and build the package object
939 TargetObject = AcpiUtCreatePackageObject (SourceObject->Package.Count);
942 return (AE_NO_MEMORY);
945 TargetObject->Common.Flags = SourceObject->Common.Flags;
947 /* Pass the new package object back to the package walk routine */
949 State->Pkg.ThisTargetObj = TargetObject;
951 /* Store the object pointer in the parent package object */
953 *ThisTargetPtr = TargetObject;
958 return (AE_BAD_PARAMETER);
964 AcpiUtRemoveReference (TargetObject);
969 /*******************************************************************************
971 * FUNCTION: AcpiUtCopyIpackageToIpackage
973 * PARAMETERS: SourceObj - Pointer to the source package object
974 * DestObj - Where the internal object is returned
975 * WalkState - Current Walk state descriptor
979 * DESCRIPTION: This function is called to copy an internal package object
980 * into another internal package object.
982 ******************************************************************************/
985 AcpiUtCopyIpackageToIpackage (
986 ACPI_OPERAND_OBJECT *SourceObj,
987 ACPI_OPERAND_OBJECT *DestObj,
988 ACPI_WALK_STATE *WalkState)
990 ACPI_STATUS Status = AE_OK;
993 ACPI_FUNCTION_TRACE (UtCopyIpackageToIpackage);
996 DestObj->Common.Type = SourceObj->Common.Type;
997 DestObj->Common.Flags = SourceObj->Common.Flags;
998 DestObj->Package.Count = SourceObj->Package.Count;
1001 * Create the object array and walk the source package tree
1003 DestObj->Package.Elements = ACPI_ALLOCATE_ZEROED (
1004 ((ACPI_SIZE) SourceObj->Package.Count + 1) *
1006 if (!DestObj->Package.Elements)
1008 ACPI_ERROR ((AE_INFO, "Package allocation failure"));
1009 return_ACPI_STATUS (AE_NO_MEMORY);
1013 * Copy the package element-by-element by walking the package "tree".
1014 * This handles nested packages of arbitrary depth.
1016 Status = AcpiUtWalkPackageTree (SourceObj, DestObj,
1017 AcpiUtCopyIelementToIelement, WalkState);
1018 if (ACPI_FAILURE (Status))
1020 /* On failure, delete the destination package object */
1022 AcpiUtRemoveReference (DestObj);
1025 return_ACPI_STATUS (Status);
1029 /*******************************************************************************
1031 * FUNCTION: AcpiUtCopyIobjectToIobject
1033 * PARAMETERS: SourceDesc - The internal object to be copied
1034 * DestDesc - Where the copied object is returned
1035 * WalkState - Current walk state
1039 * DESCRIPTION: Copy an internal object to a new internal object
1041 ******************************************************************************/
1044 AcpiUtCopyIobjectToIobject (
1045 ACPI_OPERAND_OBJECT *SourceDesc,
1046 ACPI_OPERAND_OBJECT **DestDesc,
1047 ACPI_WALK_STATE *WalkState)
1049 ACPI_STATUS Status = AE_OK;
1052 ACPI_FUNCTION_TRACE (UtCopyIobjectToIobject);
1055 /* Create the top level object */
1057 *DestDesc = AcpiUtCreateInternalObject (SourceDesc->Common.Type);
1060 return_ACPI_STATUS (AE_NO_MEMORY);
1063 /* Copy the object and possible subobjects */
1065 if (SourceDesc->Common.Type == ACPI_TYPE_PACKAGE)
1067 Status = AcpiUtCopyIpackageToIpackage (SourceDesc, *DestDesc,
1072 Status = AcpiUtCopySimpleObject (SourceDesc, *DestDesc);
1075 return_ACPI_STATUS (Status);