10d02842fSSascha Wildner /******************************************************************************
20d02842fSSascha Wildner *
30d02842fSSascha Wildner * Module Name: utcopy - Internal to external object translation utilities
40d02842fSSascha Wildner *
50d02842fSSascha Wildner *****************************************************************************/
60d02842fSSascha Wildner
7b4315fc7SSascha Wildner /******************************************************************************
8b4315fc7SSascha Wildner *
9b4315fc7SSascha Wildner * 1. Copyright Notice
10b4315fc7SSascha Wildner *
11*383048acSSascha Wildner * Some or all of this work - Copyright (c) 1999 - 2021, Intel Corp.
120d02842fSSascha Wildner * All rights reserved.
130d02842fSSascha Wildner *
14b4315fc7SSascha Wildner * 2. License
15b4315fc7SSascha Wildner *
16b4315fc7SSascha Wildner * 2.1. This is your license from Intel Corp. under its intellectual property
17b4315fc7SSascha Wildner * rights. You may have additional license terms from the party that provided
18b4315fc7SSascha Wildner * you this software, covering your right to use that party's intellectual
19b4315fc7SSascha Wildner * property rights.
20b4315fc7SSascha Wildner *
21b4315fc7SSascha Wildner * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22b4315fc7SSascha Wildner * copy of the source code appearing in this file ("Covered Code") an
23b4315fc7SSascha Wildner * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24b4315fc7SSascha Wildner * base code distributed originally by Intel ("Original Intel Code") to copy,
25b4315fc7SSascha Wildner * make derivatives, distribute, use and display any portion of the Covered
26b4315fc7SSascha Wildner * Code in any form, with the right to sublicense such rights; and
27b4315fc7SSascha Wildner *
28b4315fc7SSascha Wildner * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29b4315fc7SSascha Wildner * license (with the right to sublicense), under only those claims of Intel
30b4315fc7SSascha Wildner * patents that are infringed by the Original Intel Code, to make, use, sell,
31b4315fc7SSascha Wildner * offer to sell, and import the Covered Code and derivative works thereof
32b4315fc7SSascha Wildner * solely to the minimum extent necessary to exercise the above copyright
33b4315fc7SSascha Wildner * license, and in no event shall the patent license extend to any additions
34b4315fc7SSascha Wildner * to or modifications of the Original Intel Code. No other license or right
35b4315fc7SSascha Wildner * is granted directly or by implication, estoppel or otherwise;
36b4315fc7SSascha Wildner *
37b4315fc7SSascha Wildner * The above copyright and patent license is granted only if the following
38b4315fc7SSascha Wildner * conditions are met:
39b4315fc7SSascha Wildner *
40b4315fc7SSascha Wildner * 3. Conditions
41b4315fc7SSascha Wildner *
42b4315fc7SSascha Wildner * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43b4315fc7SSascha Wildner * Redistribution of source code of any substantial portion of the Covered
44b4315fc7SSascha Wildner * Code or modification with rights to further distribute source must include
45b4315fc7SSascha Wildner * the above Copyright Notice, the above License, this list of Conditions,
46b4315fc7SSascha Wildner * and the following Disclaimer and Export Compliance provision. In addition,
47b4315fc7SSascha Wildner * Licensee must cause all Covered Code to which Licensee contributes to
48b4315fc7SSascha Wildner * contain a file documenting the changes Licensee made to create that Covered
49b4315fc7SSascha Wildner * Code and the date of any change. Licensee must include in that file the
50b4315fc7SSascha Wildner * documentation of any changes made by any predecessor Licensee. Licensee
51b4315fc7SSascha Wildner * must include a prominent statement that the modification is derived,
52b4315fc7SSascha Wildner * directly or indirectly, from Original Intel Code.
53b4315fc7SSascha Wildner *
54b4315fc7SSascha Wildner * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55b4315fc7SSascha Wildner * Redistribution of source code of any substantial portion of the Covered
56b4315fc7SSascha Wildner * Code or modification without rights to further distribute source must
57b4315fc7SSascha Wildner * include the following Disclaimer and Export Compliance provision in the
58b4315fc7SSascha Wildner * documentation and/or other materials provided with distribution. In
59b4315fc7SSascha Wildner * addition, Licensee may not authorize further sublicense of source of any
60b4315fc7SSascha Wildner * portion of the Covered Code, and must include terms to the effect that the
61b4315fc7SSascha Wildner * license from Licensee to its licensee is limited to the intellectual
62b4315fc7SSascha Wildner * property embodied in the software Licensee provides to its licensee, and
63b4315fc7SSascha Wildner * not to intellectual property embodied in modifications its licensee may
64b4315fc7SSascha Wildner * make.
65b4315fc7SSascha Wildner *
66b4315fc7SSascha Wildner * 3.3. Redistribution of Executable. Redistribution in executable form of any
67b4315fc7SSascha Wildner * substantial portion of the Covered Code or modification must reproduce the
68b4315fc7SSascha Wildner * above Copyright Notice, and the following Disclaimer and Export Compliance
69b4315fc7SSascha Wildner * provision in the documentation and/or other materials provided with the
70b4315fc7SSascha Wildner * distribution.
71b4315fc7SSascha Wildner *
72b4315fc7SSascha Wildner * 3.4. Intel retains all right, title, and interest in and to the Original
73b4315fc7SSascha Wildner * Intel Code.
74b4315fc7SSascha Wildner *
75b4315fc7SSascha Wildner * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76b4315fc7SSascha Wildner * Intel shall be used in advertising or otherwise to promote the sale, use or
77b4315fc7SSascha Wildner * other dealings in products derived from or relating to the Covered Code
78b4315fc7SSascha Wildner * without prior written authorization from Intel.
79b4315fc7SSascha Wildner *
80b4315fc7SSascha Wildner * 4. Disclaimer and Export Compliance
81b4315fc7SSascha Wildner *
82b4315fc7SSascha Wildner * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83b4315fc7SSascha Wildner * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84b4315fc7SSascha Wildner * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85b4315fc7SSascha Wildner * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86b4315fc7SSascha Wildner * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87b4315fc7SSascha Wildner * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88b4315fc7SSascha Wildner * PARTICULAR PURPOSE.
89b4315fc7SSascha Wildner *
90b4315fc7SSascha Wildner * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91b4315fc7SSascha Wildner * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92b4315fc7SSascha Wildner * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93b4315fc7SSascha Wildner * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94b4315fc7SSascha Wildner * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95b4315fc7SSascha Wildner * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96b4315fc7SSascha Wildner * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97b4315fc7SSascha Wildner * LIMITED REMEDY.
98b4315fc7SSascha Wildner *
99b4315fc7SSascha Wildner * 4.3. Licensee shall not export, either directly or indirectly, any of this
100b4315fc7SSascha Wildner * software or system incorporating such software without first obtaining any
101b4315fc7SSascha Wildner * required license or other approval from the U. S. Department of Commerce or
102b4315fc7SSascha Wildner * any other agency or department of the United States Government. In the
103b4315fc7SSascha Wildner * event Licensee exports any such software from the United States or
104b4315fc7SSascha Wildner * re-exports any such software from a foreign destination, Licensee shall
105b4315fc7SSascha Wildner * ensure that the distribution and export/re-export of the software is in
106b4315fc7SSascha Wildner * compliance with all laws, regulations, orders, or other restrictions of the
107b4315fc7SSascha Wildner * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108b4315fc7SSascha Wildner * any of its subsidiaries will export/re-export any technical data, process,
109b4315fc7SSascha Wildner * software, or service, directly or indirectly, to any country for which the
110b4315fc7SSascha Wildner * United States government or any agency thereof requires an export license,
111b4315fc7SSascha Wildner * other governmental approval, or letter of assurance, without first obtaining
112b4315fc7SSascha Wildner * such license, approval or letter.
113b4315fc7SSascha Wildner *
114b4315fc7SSascha Wildner *****************************************************************************
115b4315fc7SSascha Wildner *
116b4315fc7SSascha Wildner * Alternatively, you may choose to be licensed under the terms of the
117b4315fc7SSascha Wildner * following license:
118b4315fc7SSascha Wildner *
1190d02842fSSascha Wildner * Redistribution and use in source and binary forms, with or without
1200d02842fSSascha Wildner * modification, are permitted provided that the following conditions
1210d02842fSSascha Wildner * are met:
1220d02842fSSascha Wildner * 1. Redistributions of source code must retain the above copyright
1230d02842fSSascha Wildner * notice, this list of conditions, and the following disclaimer,
1240d02842fSSascha Wildner * without modification.
1250d02842fSSascha Wildner * 2. Redistributions in binary form must reproduce at minimum a disclaimer
1260d02842fSSascha Wildner * substantially similar to the "NO WARRANTY" disclaimer below
1270d02842fSSascha Wildner * ("Disclaimer") and any redistribution must be conditioned upon
1280d02842fSSascha Wildner * including a substantially similar Disclaimer requirement for further
1290d02842fSSascha Wildner * binary redistribution.
1300d02842fSSascha Wildner * 3. Neither the names of the above-listed copyright holders nor the names
1310d02842fSSascha Wildner * of any contributors may be used to endorse or promote products derived
1320d02842fSSascha Wildner * from this software without specific prior written permission.
1330d02842fSSascha Wildner *
134b4315fc7SSascha Wildner * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135b4315fc7SSascha Wildner * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136b4315fc7SSascha Wildner * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137b4315fc7SSascha Wildner * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138b4315fc7SSascha Wildner * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139b4315fc7SSascha Wildner * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140b4315fc7SSascha Wildner * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141b4315fc7SSascha Wildner * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142b4315fc7SSascha Wildner * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143b4315fc7SSascha Wildner * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144b4315fc7SSascha Wildner * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145b4315fc7SSascha Wildner *
146b4315fc7SSascha Wildner * Alternatively, you may choose to be licensed under the terms of the
1470d02842fSSascha Wildner * GNU General Public License ("GPL") version 2 as published by the Free
1480d02842fSSascha Wildner * Software Foundation.
1490d02842fSSascha Wildner *
150b4315fc7SSascha Wildner *****************************************************************************/
1510d02842fSSascha Wildner
1520d02842fSSascha Wildner #include "acpi.h"
1530d02842fSSascha Wildner #include "accommon.h"
1540d02842fSSascha Wildner #include "acnamesp.h"
1550d02842fSSascha Wildner
1560d02842fSSascha Wildner
1570d02842fSSascha Wildner #define _COMPONENT ACPI_UTILITIES
1580d02842fSSascha Wildner ACPI_MODULE_NAME ("utcopy")
1590d02842fSSascha Wildner
1600d02842fSSascha Wildner /* Local prototypes */
1610d02842fSSascha Wildner
1620d02842fSSascha Wildner static ACPI_STATUS
1630d02842fSSascha Wildner AcpiUtCopyIsimpleToEsimple (
1640d02842fSSascha Wildner ACPI_OPERAND_OBJECT *InternalObject,
1650d02842fSSascha Wildner ACPI_OBJECT *ExternalObject,
1660d02842fSSascha Wildner UINT8 *DataSpace,
1670d02842fSSascha Wildner ACPI_SIZE *BufferSpaceUsed);
1680d02842fSSascha Wildner
1690d02842fSSascha Wildner static ACPI_STATUS
1700d02842fSSascha Wildner AcpiUtCopyIelementToIelement (
1710d02842fSSascha Wildner UINT8 ObjectType,
1720d02842fSSascha Wildner ACPI_OPERAND_OBJECT *SourceObject,
1730d02842fSSascha Wildner ACPI_GENERIC_STATE *State,
1740d02842fSSascha Wildner void *Context);
1750d02842fSSascha Wildner
1760d02842fSSascha Wildner static ACPI_STATUS
1770d02842fSSascha Wildner AcpiUtCopyIpackageToEpackage (
1780d02842fSSascha Wildner ACPI_OPERAND_OBJECT *InternalObject,
1790d02842fSSascha Wildner UINT8 *Buffer,
1800d02842fSSascha Wildner ACPI_SIZE *SpaceUsed);
1810d02842fSSascha Wildner
1820d02842fSSascha Wildner static ACPI_STATUS
1830d02842fSSascha Wildner AcpiUtCopyEsimpleToIsimple(
1840d02842fSSascha Wildner ACPI_OBJECT *UserObj,
1850d02842fSSascha Wildner ACPI_OPERAND_OBJECT **ReturnObj);
1860d02842fSSascha Wildner
1870d02842fSSascha Wildner static ACPI_STATUS
1880d02842fSSascha Wildner AcpiUtCopyEpackageToIpackage (
1890d02842fSSascha Wildner ACPI_OBJECT *ExternalObject,
1900d02842fSSascha Wildner ACPI_OPERAND_OBJECT **InternalObject);
1910d02842fSSascha Wildner
1920d02842fSSascha Wildner static ACPI_STATUS
1930d02842fSSascha Wildner AcpiUtCopySimpleObject (
1940d02842fSSascha Wildner ACPI_OPERAND_OBJECT *SourceDesc,
1950d02842fSSascha Wildner ACPI_OPERAND_OBJECT *DestDesc);
1960d02842fSSascha Wildner
1970d02842fSSascha Wildner static ACPI_STATUS
1980d02842fSSascha Wildner AcpiUtCopyIelementToEelement (
1990d02842fSSascha Wildner UINT8 ObjectType,
2000d02842fSSascha Wildner ACPI_OPERAND_OBJECT *SourceObject,
2010d02842fSSascha Wildner ACPI_GENERIC_STATE *State,
2020d02842fSSascha Wildner void *Context);
2030d02842fSSascha Wildner
2040d02842fSSascha Wildner static ACPI_STATUS
2050d02842fSSascha Wildner AcpiUtCopyIpackageToIpackage (
2060d02842fSSascha Wildner ACPI_OPERAND_OBJECT *SourceObj,
2070d02842fSSascha Wildner ACPI_OPERAND_OBJECT *DestObj,
2080d02842fSSascha Wildner ACPI_WALK_STATE *WalkState);
2090d02842fSSascha Wildner
2100d02842fSSascha Wildner
2110d02842fSSascha Wildner /*******************************************************************************
2120d02842fSSascha Wildner *
2130d02842fSSascha Wildner * FUNCTION: AcpiUtCopyIsimpleToEsimple
2140d02842fSSascha Wildner *
2150d02842fSSascha Wildner * PARAMETERS: InternalObject - Source object to be copied
2160d02842fSSascha Wildner * ExternalObject - Where to return the copied object
2170d02842fSSascha Wildner * DataSpace - Where object data is returned (such as
2180d02842fSSascha Wildner * buffer and string data)
2190d02842fSSascha Wildner * BufferSpaceUsed - Length of DataSpace that was used
2200d02842fSSascha Wildner *
2210d02842fSSascha Wildner * RETURN: Status
2220d02842fSSascha Wildner *
2230d02842fSSascha Wildner * DESCRIPTION: This function is called to copy a simple internal object to
2240d02842fSSascha Wildner * an external object.
2250d02842fSSascha Wildner *
2260d02842fSSascha Wildner * The DataSpace buffer is assumed to have sufficient space for
2270d02842fSSascha Wildner * the object.
2280d02842fSSascha Wildner *
2290d02842fSSascha Wildner ******************************************************************************/
2300d02842fSSascha Wildner
2310d02842fSSascha Wildner static ACPI_STATUS
AcpiUtCopyIsimpleToEsimple(ACPI_OPERAND_OBJECT * InternalObject,ACPI_OBJECT * ExternalObject,UINT8 * DataSpace,ACPI_SIZE * BufferSpaceUsed)2320d02842fSSascha Wildner AcpiUtCopyIsimpleToEsimple (
2330d02842fSSascha Wildner ACPI_OPERAND_OBJECT *InternalObject,
2340d02842fSSascha Wildner ACPI_OBJECT *ExternalObject,
2350d02842fSSascha Wildner UINT8 *DataSpace,
2360d02842fSSascha Wildner ACPI_SIZE *BufferSpaceUsed)
2370d02842fSSascha Wildner {
2380d02842fSSascha Wildner ACPI_STATUS Status = AE_OK;
2390d02842fSSascha Wildner
2400d02842fSSascha Wildner
2410d02842fSSascha Wildner ACPI_FUNCTION_TRACE (UtCopyIsimpleToEsimple);
2420d02842fSSascha Wildner
2430d02842fSSascha Wildner
2440d02842fSSascha Wildner *BufferSpaceUsed = 0;
2450d02842fSSascha Wildner
2460d02842fSSascha Wildner /*
2470d02842fSSascha Wildner * Check for NULL object case (could be an uninitialized
2480d02842fSSascha Wildner * package element)
2490d02842fSSascha Wildner */
2500d02842fSSascha Wildner if (!InternalObject)
2510d02842fSSascha Wildner {
2520d02842fSSascha Wildner return_ACPI_STATUS (AE_OK);
2530d02842fSSascha Wildner }
2540d02842fSSascha Wildner
2550d02842fSSascha Wildner /* Always clear the external object */
2560d02842fSSascha Wildner
25725ca8c79SSascha Wildner memset (ExternalObject, 0, sizeof (ACPI_OBJECT));
2580d02842fSSascha Wildner
2590d02842fSSascha Wildner /*
2600d02842fSSascha Wildner * In general, the external object will be the same type as
2610d02842fSSascha Wildner * the internal object
2620d02842fSSascha Wildner */
2630d02842fSSascha Wildner ExternalObject->Type = InternalObject->Common.Type;
2640d02842fSSascha Wildner
2650d02842fSSascha Wildner /* However, only a limited number of external types are supported */
2660d02842fSSascha Wildner
2670d02842fSSascha Wildner switch (InternalObject->Common.Type)
2680d02842fSSascha Wildner {
2690d02842fSSascha Wildner case ACPI_TYPE_STRING:
2700d02842fSSascha Wildner
2710d02842fSSascha Wildner ExternalObject->String.Pointer = (char *) DataSpace;
2720d02842fSSascha Wildner ExternalObject->String.Length = InternalObject->String.Length;
2730d02842fSSascha Wildner *BufferSpaceUsed = ACPI_ROUND_UP_TO_NATIVE_WORD (
2740d02842fSSascha Wildner (ACPI_SIZE) InternalObject->String.Length + 1);
2750d02842fSSascha Wildner
27625ca8c79SSascha Wildner memcpy ((void *) DataSpace,
2770d02842fSSascha Wildner (void *) InternalObject->String.Pointer,
2780d02842fSSascha Wildner (ACPI_SIZE) InternalObject->String.Length + 1);
2790d02842fSSascha Wildner break;
2800d02842fSSascha Wildner
2810d02842fSSascha Wildner case ACPI_TYPE_BUFFER:
2820d02842fSSascha Wildner
2830d02842fSSascha Wildner ExternalObject->Buffer.Pointer = DataSpace;
2840d02842fSSascha Wildner ExternalObject->Buffer.Length = InternalObject->Buffer.Length;
2850d02842fSSascha Wildner *BufferSpaceUsed = ACPI_ROUND_UP_TO_NATIVE_WORD (
2860d02842fSSascha Wildner InternalObject->String.Length);
2870d02842fSSascha Wildner
28825ca8c79SSascha Wildner memcpy ((void *) DataSpace,
2890d02842fSSascha Wildner (void *) InternalObject->Buffer.Pointer,
2900d02842fSSascha Wildner InternalObject->Buffer.Length);
2910d02842fSSascha Wildner break;
2920d02842fSSascha Wildner
2930d02842fSSascha Wildner case ACPI_TYPE_INTEGER:
2940d02842fSSascha Wildner
2950d02842fSSascha Wildner ExternalObject->Integer.Value = InternalObject->Integer.Value;
2960d02842fSSascha Wildner break;
2970d02842fSSascha Wildner
2980d02842fSSascha Wildner case ACPI_TYPE_LOCAL_REFERENCE:
2990d02842fSSascha Wildner
3000d02842fSSascha Wildner /* This is an object reference. */
3010d02842fSSascha Wildner
3020d02842fSSascha Wildner switch (InternalObject->Reference.Class)
3030d02842fSSascha Wildner {
3040d02842fSSascha Wildner case ACPI_REFCLASS_NAME:
3050d02842fSSascha Wildner /*
3060d02842fSSascha Wildner * For namepath, return the object handle ("reference")
3070d02842fSSascha Wildner * We are referring to the namespace node
3080d02842fSSascha Wildner */
3090d02842fSSascha Wildner ExternalObject->Reference.Handle =
3100d02842fSSascha Wildner InternalObject->Reference.Node;
3110d02842fSSascha Wildner ExternalObject->Reference.ActualType =
3120d02842fSSascha Wildner AcpiNsGetType (InternalObject->Reference.Node);
3130d02842fSSascha Wildner break;
3140d02842fSSascha Wildner
3150d02842fSSascha Wildner default:
3160d02842fSSascha Wildner
3170d02842fSSascha Wildner /* All other reference types are unsupported */
3180d02842fSSascha Wildner
3190d02842fSSascha Wildner return_ACPI_STATUS (AE_TYPE);
3200d02842fSSascha Wildner }
3210d02842fSSascha Wildner break;
3220d02842fSSascha Wildner
3230d02842fSSascha Wildner case ACPI_TYPE_PROCESSOR:
3240d02842fSSascha Wildner
3250d02842fSSascha Wildner ExternalObject->Processor.ProcId =
3260d02842fSSascha Wildner InternalObject->Processor.ProcId;
3270d02842fSSascha Wildner ExternalObject->Processor.PblkAddress =
3280d02842fSSascha Wildner InternalObject->Processor.Address;
3290d02842fSSascha Wildner ExternalObject->Processor.PblkLength =
3300d02842fSSascha Wildner InternalObject->Processor.Length;
3310d02842fSSascha Wildner break;
3320d02842fSSascha Wildner
3330d02842fSSascha Wildner case ACPI_TYPE_POWER:
3340d02842fSSascha Wildner
3350d02842fSSascha Wildner ExternalObject->PowerResource.SystemLevel =
3360d02842fSSascha Wildner InternalObject->PowerResource.SystemLevel;
3370d02842fSSascha Wildner
3380d02842fSSascha Wildner ExternalObject->PowerResource.ResourceOrder =
3390d02842fSSascha Wildner InternalObject->PowerResource.ResourceOrder;
3400d02842fSSascha Wildner break;
3410d02842fSSascha Wildner
3420d02842fSSascha Wildner default:
3430d02842fSSascha Wildner /*
3440d02842fSSascha Wildner * There is no corresponding external object type
3450d02842fSSascha Wildner */
3460d02842fSSascha Wildner ACPI_ERROR ((AE_INFO,
3470d02842fSSascha Wildner "Unsupported object type, cannot convert to external object: %s",
3480d02842fSSascha Wildner AcpiUtGetTypeName (InternalObject->Common.Type)));
3490d02842fSSascha Wildner
3500d02842fSSascha Wildner return_ACPI_STATUS (AE_SUPPORT);
3510d02842fSSascha Wildner }
3520d02842fSSascha Wildner
3530d02842fSSascha Wildner return_ACPI_STATUS (Status);
3540d02842fSSascha Wildner }
3550d02842fSSascha Wildner
3560d02842fSSascha Wildner
3570d02842fSSascha Wildner /*******************************************************************************
3580d02842fSSascha Wildner *
3590d02842fSSascha Wildner * FUNCTION: AcpiUtCopyIelementToEelement
3600d02842fSSascha Wildner *
3610d02842fSSascha Wildner * PARAMETERS: ACPI_PKG_CALLBACK
3620d02842fSSascha Wildner *
3630d02842fSSascha Wildner * RETURN: Status
3640d02842fSSascha Wildner *
3650d02842fSSascha Wildner * DESCRIPTION: Copy one package element to another package element
3660d02842fSSascha Wildner *
3670d02842fSSascha Wildner ******************************************************************************/
3680d02842fSSascha Wildner
3690d02842fSSascha Wildner static ACPI_STATUS
AcpiUtCopyIelementToEelement(UINT8 ObjectType,ACPI_OPERAND_OBJECT * SourceObject,ACPI_GENERIC_STATE * State,void * Context)3700d02842fSSascha Wildner AcpiUtCopyIelementToEelement (
3710d02842fSSascha Wildner UINT8 ObjectType,
3720d02842fSSascha Wildner ACPI_OPERAND_OBJECT *SourceObject,
3730d02842fSSascha Wildner ACPI_GENERIC_STATE *State,
3740d02842fSSascha Wildner void *Context)
3750d02842fSSascha Wildner {
3760d02842fSSascha Wildner ACPI_STATUS Status = AE_OK;
3770d02842fSSascha Wildner ACPI_PKG_INFO *Info = (ACPI_PKG_INFO *) Context;
3780d02842fSSascha Wildner ACPI_SIZE ObjectSpace;
3790d02842fSSascha Wildner UINT32 ThisIndex;
3800d02842fSSascha Wildner ACPI_OBJECT *TargetObject;
3810d02842fSSascha Wildner
3820d02842fSSascha Wildner
3830d02842fSSascha Wildner ACPI_FUNCTION_ENTRY ();
3840d02842fSSascha Wildner
3850d02842fSSascha Wildner
3860d02842fSSascha Wildner ThisIndex = State->Pkg.Index;
387820c5b08SSascha Wildner TargetObject = (ACPI_OBJECT *) &((ACPI_OBJECT *)
388820c5b08SSascha Wildner (State->Pkg.DestObject))->Package.Elements[ThisIndex];
3890d02842fSSascha Wildner
3900d02842fSSascha Wildner switch (ObjectType)
3910d02842fSSascha Wildner {
3920d02842fSSascha Wildner case ACPI_COPY_TYPE_SIMPLE:
3930d02842fSSascha Wildner /*
3940d02842fSSascha Wildner * This is a simple or null object
3950d02842fSSascha Wildner */
3960d02842fSSascha Wildner Status = AcpiUtCopyIsimpleToEsimple (SourceObject,
3970d02842fSSascha Wildner TargetObject, Info->FreeSpace, &ObjectSpace);
3980d02842fSSascha Wildner if (ACPI_FAILURE (Status))
3990d02842fSSascha Wildner {
4000d02842fSSascha Wildner return (Status);
4010d02842fSSascha Wildner }
4020d02842fSSascha Wildner break;
4030d02842fSSascha Wildner
4040d02842fSSascha Wildner case ACPI_COPY_TYPE_PACKAGE:
4050d02842fSSascha Wildner /*
4060d02842fSSascha Wildner * Build the package object
4070d02842fSSascha Wildner */
4080d02842fSSascha Wildner TargetObject->Type = ACPI_TYPE_PACKAGE;
4090d02842fSSascha Wildner TargetObject->Package.Count = SourceObject->Package.Count;
4100d02842fSSascha Wildner TargetObject->Package.Elements =
4110d02842fSSascha Wildner ACPI_CAST_PTR (ACPI_OBJECT, Info->FreeSpace);
4120d02842fSSascha Wildner
4130d02842fSSascha Wildner /*
4140d02842fSSascha Wildner * Pass the new package object back to the package walk routine
4150d02842fSSascha Wildner */
4160d02842fSSascha Wildner State->Pkg.ThisTargetObj = TargetObject;
4170d02842fSSascha Wildner
4180d02842fSSascha Wildner /*
4190d02842fSSascha Wildner * Save space for the array of objects (Package elements)
4200d02842fSSascha Wildner * update the buffer length counter
4210d02842fSSascha Wildner */
4220d02842fSSascha Wildner ObjectSpace = ACPI_ROUND_UP_TO_NATIVE_WORD (
4230d02842fSSascha Wildner (ACPI_SIZE) TargetObject->Package.Count *
4240d02842fSSascha Wildner sizeof (ACPI_OBJECT));
4250d02842fSSascha Wildner break;
4260d02842fSSascha Wildner
4270d02842fSSascha Wildner default:
4280d02842fSSascha Wildner
4290d02842fSSascha Wildner return (AE_BAD_PARAMETER);
4300d02842fSSascha Wildner }
4310d02842fSSascha Wildner
4320d02842fSSascha Wildner Info->FreeSpace += ObjectSpace;
4330d02842fSSascha Wildner Info->Length += ObjectSpace;
4340d02842fSSascha Wildner return (Status);
4350d02842fSSascha Wildner }
4360d02842fSSascha Wildner
4370d02842fSSascha Wildner
4380d02842fSSascha Wildner /*******************************************************************************
4390d02842fSSascha Wildner *
4400d02842fSSascha Wildner * FUNCTION: AcpiUtCopyIpackageToEpackage
4410d02842fSSascha Wildner *
4420d02842fSSascha Wildner * PARAMETERS: InternalObject - Pointer to the object we are returning
4430d02842fSSascha Wildner * Buffer - Where the object is returned
4440d02842fSSascha Wildner * SpaceUsed - Where the object length is returned
4450d02842fSSascha Wildner *
4460d02842fSSascha Wildner * RETURN: Status
4470d02842fSSascha Wildner *
4480d02842fSSascha Wildner * DESCRIPTION: This function is called to place a package object in a user
4490d02842fSSascha Wildner * buffer. A package object by definition contains other objects.
4500d02842fSSascha Wildner *
4510d02842fSSascha Wildner * The buffer is assumed to have sufficient space for the object.
4520d02842fSSascha Wildner * The caller must have verified the buffer length needed using
4530d02842fSSascha Wildner * the AcpiUtGetObjectSize function before calling this function.
4540d02842fSSascha Wildner *
4550d02842fSSascha Wildner ******************************************************************************/
4560d02842fSSascha Wildner
4570d02842fSSascha Wildner static ACPI_STATUS
AcpiUtCopyIpackageToEpackage(ACPI_OPERAND_OBJECT * InternalObject,UINT8 * Buffer,ACPI_SIZE * SpaceUsed)4580d02842fSSascha Wildner AcpiUtCopyIpackageToEpackage (
4590d02842fSSascha Wildner ACPI_OPERAND_OBJECT *InternalObject,
4600d02842fSSascha Wildner UINT8 *Buffer,
4610d02842fSSascha Wildner ACPI_SIZE *SpaceUsed)
4620d02842fSSascha Wildner {
4630d02842fSSascha Wildner ACPI_OBJECT *ExternalObject;
4640d02842fSSascha Wildner ACPI_STATUS Status;
4650d02842fSSascha Wildner ACPI_PKG_INFO Info;
4660d02842fSSascha Wildner
4670d02842fSSascha Wildner
4680d02842fSSascha Wildner ACPI_FUNCTION_TRACE (UtCopyIpackageToEpackage);
4690d02842fSSascha Wildner
4700d02842fSSascha Wildner
4710d02842fSSascha Wildner /*
4720d02842fSSascha Wildner * First package at head of the buffer
4730d02842fSSascha Wildner */
4740d02842fSSascha Wildner ExternalObject = ACPI_CAST_PTR (ACPI_OBJECT, Buffer);
4750d02842fSSascha Wildner
4760d02842fSSascha Wildner /*
4770d02842fSSascha Wildner * Free space begins right after the first package
4780d02842fSSascha Wildner */
4790d02842fSSascha Wildner Info.Length = ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
480820c5b08SSascha Wildner Info.FreeSpace = Buffer +
481820c5b08SSascha Wildner ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
4820d02842fSSascha Wildner Info.ObjectSpace = 0;
4830d02842fSSascha Wildner Info.NumPackages = 1;
4840d02842fSSascha Wildner
4850d02842fSSascha Wildner ExternalObject->Type = InternalObject->Common.Type;
4860d02842fSSascha Wildner ExternalObject->Package.Count = InternalObject->Package.Count;
487820c5b08SSascha Wildner ExternalObject->Package.Elements =
488820c5b08SSascha Wildner ACPI_CAST_PTR (ACPI_OBJECT, Info.FreeSpace);
4890d02842fSSascha Wildner
4900d02842fSSascha Wildner /*
4910d02842fSSascha Wildner * Leave room for an array of ACPI_OBJECTS in the buffer
4920d02842fSSascha Wildner * and move the free space past it
4930d02842fSSascha Wildner */
4940d02842fSSascha Wildner Info.Length += (ACPI_SIZE) ExternalObject->Package.Count *
4950d02842fSSascha Wildner ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
4960d02842fSSascha Wildner Info.FreeSpace += ExternalObject->Package.Count *
4970d02842fSSascha Wildner ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
4980d02842fSSascha Wildner
4990d02842fSSascha Wildner Status = AcpiUtWalkPackageTree (InternalObject, ExternalObject,
5000d02842fSSascha Wildner AcpiUtCopyIelementToEelement, &Info);
5010d02842fSSascha Wildner
5020d02842fSSascha Wildner *SpaceUsed = Info.Length;
5030d02842fSSascha Wildner return_ACPI_STATUS (Status);
5040d02842fSSascha Wildner }
5050d02842fSSascha Wildner
5060d02842fSSascha Wildner
5070d02842fSSascha Wildner /*******************************************************************************
5080d02842fSSascha Wildner *
5090d02842fSSascha Wildner * FUNCTION: AcpiUtCopyIobjectToEobject
5100d02842fSSascha Wildner *
5110d02842fSSascha Wildner * PARAMETERS: InternalObject - The internal object to be converted
5120d02842fSSascha Wildner * RetBuffer - Where the object is returned
5130d02842fSSascha Wildner *
5140d02842fSSascha Wildner * RETURN: Status
5150d02842fSSascha Wildner *
5160d02842fSSascha Wildner * DESCRIPTION: This function is called to build an API object to be returned
5170d02842fSSascha Wildner * to the caller.
5180d02842fSSascha Wildner *
5190d02842fSSascha Wildner ******************************************************************************/
5200d02842fSSascha Wildner
5210d02842fSSascha Wildner ACPI_STATUS
AcpiUtCopyIobjectToEobject(ACPI_OPERAND_OBJECT * InternalObject,ACPI_BUFFER * RetBuffer)5220d02842fSSascha Wildner AcpiUtCopyIobjectToEobject (
5230d02842fSSascha Wildner ACPI_OPERAND_OBJECT *InternalObject,
5240d02842fSSascha Wildner ACPI_BUFFER *RetBuffer)
5250d02842fSSascha Wildner {
5260d02842fSSascha Wildner ACPI_STATUS Status;
5270d02842fSSascha Wildner
5280d02842fSSascha Wildner
5290d02842fSSascha Wildner ACPI_FUNCTION_TRACE (UtCopyIobjectToEobject);
5300d02842fSSascha Wildner
5310d02842fSSascha Wildner
5320d02842fSSascha Wildner if (InternalObject->Common.Type == ACPI_TYPE_PACKAGE)
5330d02842fSSascha Wildner {
5340d02842fSSascha Wildner /*
5350d02842fSSascha Wildner * Package object: Copy all subobjects (including
5360d02842fSSascha Wildner * nested packages)
5370d02842fSSascha Wildner */
5380d02842fSSascha Wildner Status = AcpiUtCopyIpackageToEpackage (InternalObject,
5390d02842fSSascha Wildner RetBuffer->Pointer, &RetBuffer->Length);
5400d02842fSSascha Wildner }
5410d02842fSSascha Wildner else
5420d02842fSSascha Wildner {
5430d02842fSSascha Wildner /*
5440d02842fSSascha Wildner * Build a simple object (no nested objects)
5450d02842fSSascha Wildner */
5460d02842fSSascha Wildner Status = AcpiUtCopyIsimpleToEsimple (InternalObject,
5470d02842fSSascha Wildner ACPI_CAST_PTR (ACPI_OBJECT, RetBuffer->Pointer),
5480d02842fSSascha Wildner ACPI_ADD_PTR (UINT8, RetBuffer->Pointer,
5490d02842fSSascha Wildner ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT))),
5500d02842fSSascha Wildner &RetBuffer->Length);
5510d02842fSSascha Wildner /*
5520d02842fSSascha Wildner * build simple does not include the object size in the length
5530d02842fSSascha Wildner * so we add it in here
5540d02842fSSascha Wildner */
5550d02842fSSascha Wildner RetBuffer->Length += sizeof (ACPI_OBJECT);
5560d02842fSSascha Wildner }
5570d02842fSSascha Wildner
5580d02842fSSascha Wildner return_ACPI_STATUS (Status);
5590d02842fSSascha Wildner }
5600d02842fSSascha Wildner
5610d02842fSSascha Wildner
5620d02842fSSascha Wildner /*******************************************************************************
5630d02842fSSascha Wildner *
5640d02842fSSascha Wildner * FUNCTION: AcpiUtCopyEsimpleToIsimple
5650d02842fSSascha Wildner *
5660d02842fSSascha Wildner * PARAMETERS: ExternalObject - The external object to be converted
5670d02842fSSascha Wildner * RetInternalObject - Where the internal object is returned
5680d02842fSSascha Wildner *
5690d02842fSSascha Wildner * RETURN: Status
5700d02842fSSascha Wildner *
5710d02842fSSascha Wildner * DESCRIPTION: This function copies an external object to an internal one.
5720d02842fSSascha Wildner * NOTE: Pointers can be copied, we don't need to copy data.
5730d02842fSSascha Wildner * (The pointers have to be valid in our address space no matter
5740d02842fSSascha Wildner * what we do with them!)
5750d02842fSSascha Wildner *
5760d02842fSSascha Wildner ******************************************************************************/
5770d02842fSSascha Wildner
5780d02842fSSascha Wildner static ACPI_STATUS
AcpiUtCopyEsimpleToIsimple(ACPI_OBJECT * ExternalObject,ACPI_OPERAND_OBJECT ** RetInternalObject)5790d02842fSSascha Wildner AcpiUtCopyEsimpleToIsimple (
5800d02842fSSascha Wildner ACPI_OBJECT *ExternalObject,
5810d02842fSSascha Wildner ACPI_OPERAND_OBJECT **RetInternalObject)
5820d02842fSSascha Wildner {
5830d02842fSSascha Wildner ACPI_OPERAND_OBJECT *InternalObject;
5840d02842fSSascha Wildner
5850d02842fSSascha Wildner
5860d02842fSSascha Wildner ACPI_FUNCTION_TRACE (UtCopyEsimpleToIsimple);
5870d02842fSSascha Wildner
5880d02842fSSascha Wildner
5890d02842fSSascha Wildner /*
5900d02842fSSascha Wildner * Simple types supported are: String, Buffer, Integer
5910d02842fSSascha Wildner */
5920d02842fSSascha Wildner switch (ExternalObject->Type)
5930d02842fSSascha Wildner {
5940d02842fSSascha Wildner case ACPI_TYPE_STRING:
5950d02842fSSascha Wildner case ACPI_TYPE_BUFFER:
5960d02842fSSascha Wildner case ACPI_TYPE_INTEGER:
5970d02842fSSascha Wildner case ACPI_TYPE_LOCAL_REFERENCE:
5980d02842fSSascha Wildner
5990d02842fSSascha Wildner InternalObject = AcpiUtCreateInternalObject (
6000d02842fSSascha Wildner (UINT8) ExternalObject->Type);
6010d02842fSSascha Wildner if (!InternalObject)
6020d02842fSSascha Wildner {
6030d02842fSSascha Wildner return_ACPI_STATUS (AE_NO_MEMORY);
6040d02842fSSascha Wildner }
6050d02842fSSascha Wildner break;
6060d02842fSSascha Wildner
6070d02842fSSascha Wildner case ACPI_TYPE_ANY: /* This is the case for a NULL object */
6080d02842fSSascha Wildner
6090d02842fSSascha Wildner *RetInternalObject = NULL;
6100d02842fSSascha Wildner return_ACPI_STATUS (AE_OK);
6110d02842fSSascha Wildner
6120d02842fSSascha Wildner default:
6130d02842fSSascha Wildner
6140d02842fSSascha Wildner /* All other types are not supported */
6150d02842fSSascha Wildner
6160d02842fSSascha Wildner ACPI_ERROR ((AE_INFO,
6170d02842fSSascha Wildner "Unsupported object type, cannot convert to internal object: %s",
6180d02842fSSascha Wildner AcpiUtGetTypeName (ExternalObject->Type)));
6190d02842fSSascha Wildner
6200d02842fSSascha Wildner return_ACPI_STATUS (AE_SUPPORT);
6210d02842fSSascha Wildner }
6220d02842fSSascha Wildner
6230d02842fSSascha Wildner
6240d02842fSSascha Wildner /* Must COPY string and buffer contents */
6250d02842fSSascha Wildner
6260d02842fSSascha Wildner switch (ExternalObject->Type)
6270d02842fSSascha Wildner {
6280d02842fSSascha Wildner case ACPI_TYPE_STRING:
6290d02842fSSascha Wildner
6300d02842fSSascha Wildner InternalObject->String.Pointer =
6310d02842fSSascha Wildner ACPI_ALLOCATE_ZEROED ((ACPI_SIZE)
6320d02842fSSascha Wildner ExternalObject->String.Length + 1);
6330d02842fSSascha Wildner
6340d02842fSSascha Wildner if (!InternalObject->String.Pointer)
6350d02842fSSascha Wildner {
6360d02842fSSascha Wildner goto ErrorExit;
6370d02842fSSascha Wildner }
6380d02842fSSascha Wildner
63925ca8c79SSascha Wildner memcpy (InternalObject->String.Pointer,
6400d02842fSSascha Wildner ExternalObject->String.Pointer,
6410d02842fSSascha Wildner ExternalObject->String.Length);
6420d02842fSSascha Wildner
6430d02842fSSascha Wildner InternalObject->String.Length = ExternalObject->String.Length;
6440d02842fSSascha Wildner break;
6450d02842fSSascha Wildner
6460d02842fSSascha Wildner case ACPI_TYPE_BUFFER:
6470d02842fSSascha Wildner
6480d02842fSSascha Wildner InternalObject->Buffer.Pointer =
6490d02842fSSascha Wildner ACPI_ALLOCATE_ZEROED (ExternalObject->Buffer.Length);
6500d02842fSSascha Wildner if (!InternalObject->Buffer.Pointer)
6510d02842fSSascha Wildner {
6520d02842fSSascha Wildner goto ErrorExit;
6530d02842fSSascha Wildner }
6540d02842fSSascha Wildner
65525ca8c79SSascha Wildner memcpy (InternalObject->Buffer.Pointer,
6560d02842fSSascha Wildner ExternalObject->Buffer.Pointer,
6570d02842fSSascha Wildner ExternalObject->Buffer.Length);
6580d02842fSSascha Wildner
6590d02842fSSascha Wildner InternalObject->Buffer.Length = ExternalObject->Buffer.Length;
6600d02842fSSascha Wildner
6610d02842fSSascha Wildner /* Mark buffer data valid */
6620d02842fSSascha Wildner
6630d02842fSSascha Wildner InternalObject->Buffer.Flags |= AOPOBJ_DATA_VALID;
6640d02842fSSascha Wildner break;
6650d02842fSSascha Wildner
6660d02842fSSascha Wildner case ACPI_TYPE_INTEGER:
6670d02842fSSascha Wildner
6680d02842fSSascha Wildner InternalObject->Integer.Value = ExternalObject->Integer.Value;
6690d02842fSSascha Wildner break;
6700d02842fSSascha Wildner
6710d02842fSSascha Wildner case ACPI_TYPE_LOCAL_REFERENCE:
6720d02842fSSascha Wildner
67320294b7eSSascha Wildner /* An incoming reference is defined to be a namespace node */
6740d02842fSSascha Wildner
67520294b7eSSascha Wildner InternalObject->Reference.Class = ACPI_REFCLASS_REFOF;
67620294b7eSSascha Wildner InternalObject->Reference.Object = ExternalObject->Reference.Handle;
6770d02842fSSascha Wildner break;
6780d02842fSSascha Wildner
6790d02842fSSascha Wildner default:
6800d02842fSSascha Wildner
6810d02842fSSascha Wildner /* Other types can't get here */
6820d02842fSSascha Wildner
6830d02842fSSascha Wildner break;
6840d02842fSSascha Wildner }
6850d02842fSSascha Wildner
6860d02842fSSascha Wildner *RetInternalObject = InternalObject;
6870d02842fSSascha Wildner return_ACPI_STATUS (AE_OK);
6880d02842fSSascha Wildner
6890d02842fSSascha Wildner
6900d02842fSSascha Wildner ErrorExit:
6910d02842fSSascha Wildner AcpiUtRemoveReference (InternalObject);
6920d02842fSSascha Wildner return_ACPI_STATUS (AE_NO_MEMORY);
6930d02842fSSascha Wildner }
6940d02842fSSascha Wildner
6950d02842fSSascha Wildner
6960d02842fSSascha Wildner /*******************************************************************************
6970d02842fSSascha Wildner *
6980d02842fSSascha Wildner * FUNCTION: AcpiUtCopyEpackageToIpackage
6990d02842fSSascha Wildner *
7000d02842fSSascha Wildner * PARAMETERS: ExternalObject - The external object to be converted
7010d02842fSSascha Wildner * InternalObject - Where the internal object is returned
7020d02842fSSascha Wildner *
7030d02842fSSascha Wildner * RETURN: Status
7040d02842fSSascha Wildner *
7050d02842fSSascha Wildner * DESCRIPTION: Copy an external package object to an internal package.
7060d02842fSSascha Wildner * Handles nested packages.
7070d02842fSSascha Wildner *
7080d02842fSSascha Wildner ******************************************************************************/
7090d02842fSSascha Wildner
7100d02842fSSascha Wildner static ACPI_STATUS
AcpiUtCopyEpackageToIpackage(ACPI_OBJECT * ExternalObject,ACPI_OPERAND_OBJECT ** InternalObject)7110d02842fSSascha Wildner AcpiUtCopyEpackageToIpackage (
7120d02842fSSascha Wildner ACPI_OBJECT *ExternalObject,
7130d02842fSSascha Wildner ACPI_OPERAND_OBJECT **InternalObject)
7140d02842fSSascha Wildner {
7150d02842fSSascha Wildner ACPI_STATUS Status = AE_OK;
7160d02842fSSascha Wildner ACPI_OPERAND_OBJECT *PackageObject;
7170d02842fSSascha Wildner ACPI_OPERAND_OBJECT **PackageElements;
7180d02842fSSascha Wildner UINT32 i;
7190d02842fSSascha Wildner
7200d02842fSSascha Wildner
7210d02842fSSascha Wildner ACPI_FUNCTION_TRACE (UtCopyEpackageToIpackage);
7220d02842fSSascha Wildner
7230d02842fSSascha Wildner
7240d02842fSSascha Wildner /* Create the package object */
7250d02842fSSascha Wildner
726820c5b08SSascha Wildner PackageObject = AcpiUtCreatePackageObject (
727820c5b08SSascha Wildner ExternalObject->Package.Count);
7280d02842fSSascha Wildner if (!PackageObject)
7290d02842fSSascha Wildner {
7300d02842fSSascha Wildner return_ACPI_STATUS (AE_NO_MEMORY);
7310d02842fSSascha Wildner }
7320d02842fSSascha Wildner
7330d02842fSSascha Wildner PackageElements = PackageObject->Package.Elements;
7340d02842fSSascha Wildner
7350d02842fSSascha Wildner /*
736820c5b08SSascha Wildner * Recursive implementation. Probably ok, since nested external
737820c5b08SSascha Wildner * packages as parameters should be very rare.
7380d02842fSSascha Wildner */
7390d02842fSSascha Wildner for (i = 0; i < ExternalObject->Package.Count; i++)
7400d02842fSSascha Wildner {
7410d02842fSSascha Wildner Status = AcpiUtCopyEobjectToIobject (
7420d02842fSSascha Wildner &ExternalObject->Package.Elements[i],
7430d02842fSSascha Wildner &PackageElements[i]);
7440d02842fSSascha Wildner if (ACPI_FAILURE (Status))
7450d02842fSSascha Wildner {
7460d02842fSSascha Wildner /* Truncate package and delete it */
7470d02842fSSascha Wildner
7480d02842fSSascha Wildner PackageObject->Package.Count = i;
7490d02842fSSascha Wildner PackageElements[i] = NULL;
7500d02842fSSascha Wildner AcpiUtRemoveReference (PackageObject);
7510d02842fSSascha Wildner return_ACPI_STATUS (Status);
7520d02842fSSascha Wildner }
7530d02842fSSascha Wildner }
7540d02842fSSascha Wildner
7550d02842fSSascha Wildner /* Mark package data valid */
7560d02842fSSascha Wildner
7570d02842fSSascha Wildner PackageObject->Package.Flags |= AOPOBJ_DATA_VALID;
7580d02842fSSascha Wildner
7590d02842fSSascha Wildner *InternalObject = PackageObject;
7600d02842fSSascha Wildner return_ACPI_STATUS (Status);
7610d02842fSSascha Wildner }
7620d02842fSSascha Wildner
7630d02842fSSascha Wildner
7640d02842fSSascha Wildner /*******************************************************************************
7650d02842fSSascha Wildner *
7660d02842fSSascha Wildner * FUNCTION: AcpiUtCopyEobjectToIobject
7670d02842fSSascha Wildner *
7680d02842fSSascha Wildner * PARAMETERS: ExternalObject - The external object to be converted
7690d02842fSSascha Wildner * InternalObject - Where the internal object is returned
7700d02842fSSascha Wildner *
7710d02842fSSascha Wildner * RETURN: Status
7720d02842fSSascha Wildner *
7730d02842fSSascha Wildner * DESCRIPTION: Converts an external object to an internal object.
7740d02842fSSascha Wildner *
7750d02842fSSascha Wildner ******************************************************************************/
7760d02842fSSascha Wildner
7770d02842fSSascha Wildner ACPI_STATUS
AcpiUtCopyEobjectToIobject(ACPI_OBJECT * ExternalObject,ACPI_OPERAND_OBJECT ** InternalObject)7780d02842fSSascha Wildner AcpiUtCopyEobjectToIobject (
7790d02842fSSascha Wildner ACPI_OBJECT *ExternalObject,
7800d02842fSSascha Wildner ACPI_OPERAND_OBJECT **InternalObject)
7810d02842fSSascha Wildner {
7820d02842fSSascha Wildner ACPI_STATUS Status;
7830d02842fSSascha Wildner
7840d02842fSSascha Wildner
7850d02842fSSascha Wildner ACPI_FUNCTION_TRACE (UtCopyEobjectToIobject);
7860d02842fSSascha Wildner
7870d02842fSSascha Wildner
7880d02842fSSascha Wildner if (ExternalObject->Type == ACPI_TYPE_PACKAGE)
7890d02842fSSascha Wildner {
790820c5b08SSascha Wildner Status = AcpiUtCopyEpackageToIpackage (
791820c5b08SSascha Wildner ExternalObject, InternalObject);
7920d02842fSSascha Wildner }
7930d02842fSSascha Wildner else
7940d02842fSSascha Wildner {
7950d02842fSSascha Wildner /*
7960d02842fSSascha Wildner * Build a simple object (no nested objects)
7970d02842fSSascha Wildner */
798820c5b08SSascha Wildner Status = AcpiUtCopyEsimpleToIsimple (ExternalObject,
799820c5b08SSascha Wildner InternalObject);
8000d02842fSSascha Wildner }
8010d02842fSSascha Wildner
8020d02842fSSascha Wildner return_ACPI_STATUS (Status);
8030d02842fSSascha Wildner }
8040d02842fSSascha Wildner
8050d02842fSSascha Wildner
8060d02842fSSascha Wildner /*******************************************************************************
8070d02842fSSascha Wildner *
8080d02842fSSascha Wildner * FUNCTION: AcpiUtCopySimpleObject
8090d02842fSSascha Wildner *
8100d02842fSSascha Wildner * PARAMETERS: SourceDesc - The internal object to be copied
8110d02842fSSascha Wildner * DestDesc - New target object
8120d02842fSSascha Wildner *
8130d02842fSSascha Wildner * RETURN: Status
8140d02842fSSascha Wildner *
8150d02842fSSascha Wildner * DESCRIPTION: Simple copy of one internal object to another. Reference count
8160d02842fSSascha Wildner * of the destination object is preserved.
8170d02842fSSascha Wildner *
8180d02842fSSascha Wildner ******************************************************************************/
8190d02842fSSascha Wildner
8200d02842fSSascha Wildner static ACPI_STATUS
AcpiUtCopySimpleObject(ACPI_OPERAND_OBJECT * SourceDesc,ACPI_OPERAND_OBJECT * DestDesc)8210d02842fSSascha Wildner AcpiUtCopySimpleObject (
8220d02842fSSascha Wildner ACPI_OPERAND_OBJECT *SourceDesc,
8230d02842fSSascha Wildner ACPI_OPERAND_OBJECT *DestDesc)
8240d02842fSSascha Wildner {
8250d02842fSSascha Wildner UINT16 ReferenceCount;
8260d02842fSSascha Wildner ACPI_OPERAND_OBJECT *NextObject;
8270d02842fSSascha Wildner ACPI_STATUS Status;
8280d02842fSSascha Wildner ACPI_SIZE CopySize;
8290d02842fSSascha Wildner
8300d02842fSSascha Wildner
8310d02842fSSascha Wildner /* Save fields from destination that we don't want to overwrite */
8320d02842fSSascha Wildner
8330d02842fSSascha Wildner ReferenceCount = DestDesc->Common.ReferenceCount;
8340d02842fSSascha Wildner NextObject = DestDesc->Common.NextObject;
8350d02842fSSascha Wildner
8360d02842fSSascha Wildner /*
8370d02842fSSascha Wildner * Copy the entire source object over the destination object.
8380d02842fSSascha Wildner * Note: Source can be either an operand object or namespace node.
8390d02842fSSascha Wildner */
8400d02842fSSascha Wildner CopySize = sizeof (ACPI_OPERAND_OBJECT);
8410d02842fSSascha Wildner if (ACPI_GET_DESCRIPTOR_TYPE (SourceDesc) == ACPI_DESC_TYPE_NAMED)
8420d02842fSSascha Wildner {
8430d02842fSSascha Wildner CopySize = sizeof (ACPI_NAMESPACE_NODE);
8440d02842fSSascha Wildner }
8450d02842fSSascha Wildner
84625ca8c79SSascha Wildner memcpy (ACPI_CAST_PTR (char, DestDesc),
8470d02842fSSascha Wildner ACPI_CAST_PTR (char, SourceDesc), CopySize);
8480d02842fSSascha Wildner
8490d02842fSSascha Wildner /* Restore the saved fields */
8500d02842fSSascha Wildner
8510d02842fSSascha Wildner DestDesc->Common.ReferenceCount = ReferenceCount;
8520d02842fSSascha Wildner DestDesc->Common.NextObject = NextObject;
8530d02842fSSascha Wildner
8540d02842fSSascha Wildner /* New object is not static, regardless of source */
8550d02842fSSascha Wildner
8560d02842fSSascha Wildner DestDesc->Common.Flags &= ~AOPOBJ_STATIC_POINTER;
8570d02842fSSascha Wildner
8580d02842fSSascha Wildner /* Handle the objects with extra data */
8590d02842fSSascha Wildner
8600d02842fSSascha Wildner switch (DestDesc->Common.Type)
8610d02842fSSascha Wildner {
8620d02842fSSascha Wildner case ACPI_TYPE_BUFFER:
8630d02842fSSascha Wildner /*
8640d02842fSSascha Wildner * Allocate and copy the actual buffer if and only if:
8650d02842fSSascha Wildner * 1) There is a valid buffer pointer
8660d02842fSSascha Wildner * 2) The buffer has a length > 0
8670d02842fSSascha Wildner */
8680d02842fSSascha Wildner if ((SourceDesc->Buffer.Pointer) &&
8690d02842fSSascha Wildner (SourceDesc->Buffer.Length))
8700d02842fSSascha Wildner {
8710d02842fSSascha Wildner DestDesc->Buffer.Pointer =
8720d02842fSSascha Wildner ACPI_ALLOCATE (SourceDesc->Buffer.Length);
8730d02842fSSascha Wildner if (!DestDesc->Buffer.Pointer)
8740d02842fSSascha Wildner {
8750d02842fSSascha Wildner return (AE_NO_MEMORY);
8760d02842fSSascha Wildner }
8770d02842fSSascha Wildner
8780d02842fSSascha Wildner /* Copy the actual buffer data */
8790d02842fSSascha Wildner
88025ca8c79SSascha Wildner memcpy (DestDesc->Buffer.Pointer,
8810d02842fSSascha Wildner SourceDesc->Buffer.Pointer, SourceDesc->Buffer.Length);
8820d02842fSSascha Wildner }
8830d02842fSSascha Wildner break;
8840d02842fSSascha Wildner
8850d02842fSSascha Wildner case ACPI_TYPE_STRING:
8860d02842fSSascha Wildner /*
8870d02842fSSascha Wildner * Allocate and copy the actual string if and only if:
8880d02842fSSascha Wildner * 1) There is a valid string pointer
8890d02842fSSascha Wildner * (Pointer to a NULL string is allowed)
8900d02842fSSascha Wildner */
8910d02842fSSascha Wildner if (SourceDesc->String.Pointer)
8920d02842fSSascha Wildner {
8930d02842fSSascha Wildner DestDesc->String.Pointer =
8940d02842fSSascha Wildner ACPI_ALLOCATE ((ACPI_SIZE) SourceDesc->String.Length + 1);
8950d02842fSSascha Wildner if (!DestDesc->String.Pointer)
8960d02842fSSascha Wildner {
8970d02842fSSascha Wildner return (AE_NO_MEMORY);
8980d02842fSSascha Wildner }
8990d02842fSSascha Wildner
9000d02842fSSascha Wildner /* Copy the actual string data */
9010d02842fSSascha Wildner
90225ca8c79SSascha Wildner memcpy (DestDesc->String.Pointer, SourceDesc->String.Pointer,
9030d02842fSSascha Wildner (ACPI_SIZE) SourceDesc->String.Length + 1);
9040d02842fSSascha Wildner }
9050d02842fSSascha Wildner break;
9060d02842fSSascha Wildner
9070d02842fSSascha Wildner case ACPI_TYPE_LOCAL_REFERENCE:
9080d02842fSSascha Wildner /*
9090d02842fSSascha Wildner * We copied the reference object, so we now must add a reference
9100d02842fSSascha Wildner * to the object pointed to by the reference
9110d02842fSSascha Wildner *
9120d02842fSSascha Wildner * DDBHandle reference (from Load/LoadTable) is a special reference,
9130d02842fSSascha Wildner * it does not have a Reference.Object, so does not need to
9140d02842fSSascha Wildner * increase the reference count
9150d02842fSSascha Wildner */
9160d02842fSSascha Wildner if (SourceDesc->Reference.Class == ACPI_REFCLASS_TABLE)
9170d02842fSSascha Wildner {
9180d02842fSSascha Wildner break;
9190d02842fSSascha Wildner }
9200d02842fSSascha Wildner
9210d02842fSSascha Wildner AcpiUtAddReference (SourceDesc->Reference.Object);
9220d02842fSSascha Wildner break;
9230d02842fSSascha Wildner
9240d02842fSSascha Wildner case ACPI_TYPE_REGION:
9250d02842fSSascha Wildner /*
9260d02842fSSascha Wildner * We copied the Region Handler, so we now must add a reference
9270d02842fSSascha Wildner */
9280d02842fSSascha Wildner if (DestDesc->Region.Handler)
9290d02842fSSascha Wildner {
9300d02842fSSascha Wildner AcpiUtAddReference (DestDesc->Region.Handler);
9310d02842fSSascha Wildner }
9320d02842fSSascha Wildner break;
9330d02842fSSascha Wildner
9340d02842fSSascha Wildner /*
9350d02842fSSascha Wildner * For Mutex and Event objects, we cannot simply copy the underlying
9360d02842fSSascha Wildner * OS object. We must create a new one.
9370d02842fSSascha Wildner */
9380d02842fSSascha Wildner case ACPI_TYPE_MUTEX:
9390d02842fSSascha Wildner
9400d02842fSSascha Wildner Status = AcpiOsCreateMutex (&DestDesc->Mutex.OsMutex);
9410d02842fSSascha Wildner if (ACPI_FAILURE (Status))
9420d02842fSSascha Wildner {
9430d02842fSSascha Wildner return (Status);
9440d02842fSSascha Wildner }
9450d02842fSSascha Wildner break;
9460d02842fSSascha Wildner
9470d02842fSSascha Wildner case ACPI_TYPE_EVENT:
9480d02842fSSascha Wildner
9490d02842fSSascha Wildner Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 0,
9500d02842fSSascha Wildner &DestDesc->Event.OsSemaphore);
9510d02842fSSascha Wildner if (ACPI_FAILURE (Status))
9520d02842fSSascha Wildner {
9530d02842fSSascha Wildner return (Status);
9540d02842fSSascha Wildner }
9550d02842fSSascha Wildner break;
9560d02842fSSascha Wildner
9570d02842fSSascha Wildner default:
9580d02842fSSascha Wildner
9590d02842fSSascha Wildner /* Nothing to do for other simple objects */
9600d02842fSSascha Wildner
9610d02842fSSascha Wildner break;
9620d02842fSSascha Wildner }
9630d02842fSSascha Wildner
9640d02842fSSascha Wildner return (AE_OK);
9650d02842fSSascha Wildner }
9660d02842fSSascha Wildner
9670d02842fSSascha Wildner
9680d02842fSSascha Wildner /*******************************************************************************
9690d02842fSSascha Wildner *
9700d02842fSSascha Wildner * FUNCTION: AcpiUtCopyIelementToIelement
9710d02842fSSascha Wildner *
9720d02842fSSascha Wildner * PARAMETERS: ACPI_PKG_CALLBACK
9730d02842fSSascha Wildner *
9740d02842fSSascha Wildner * RETURN: Status
9750d02842fSSascha Wildner *
9760d02842fSSascha Wildner * DESCRIPTION: Copy one package element to another package element
9770d02842fSSascha Wildner *
9780d02842fSSascha Wildner ******************************************************************************/
9790d02842fSSascha Wildner
9800d02842fSSascha Wildner static ACPI_STATUS
AcpiUtCopyIelementToIelement(UINT8 ObjectType,ACPI_OPERAND_OBJECT * SourceObject,ACPI_GENERIC_STATE * State,void * Context)9810d02842fSSascha Wildner AcpiUtCopyIelementToIelement (
9820d02842fSSascha Wildner UINT8 ObjectType,
9830d02842fSSascha Wildner ACPI_OPERAND_OBJECT *SourceObject,
9840d02842fSSascha Wildner ACPI_GENERIC_STATE *State,
9850d02842fSSascha Wildner void *Context)
9860d02842fSSascha Wildner {
9870d02842fSSascha Wildner ACPI_STATUS Status = AE_OK;
9880d02842fSSascha Wildner UINT32 ThisIndex;
9890d02842fSSascha Wildner ACPI_OPERAND_OBJECT **ThisTargetPtr;
9900d02842fSSascha Wildner ACPI_OPERAND_OBJECT *TargetObject;
9910d02842fSSascha Wildner
9920d02842fSSascha Wildner
9930d02842fSSascha Wildner ACPI_FUNCTION_ENTRY ();
9940d02842fSSascha Wildner
9950d02842fSSascha Wildner
9960d02842fSSascha Wildner ThisIndex = State->Pkg.Index;
9970d02842fSSascha Wildner ThisTargetPtr = (ACPI_OPERAND_OBJECT **)
9980d02842fSSascha Wildner &State->Pkg.DestObject->Package.Elements[ThisIndex];
9990d02842fSSascha Wildner
10000d02842fSSascha Wildner switch (ObjectType)
10010d02842fSSascha Wildner {
10020d02842fSSascha Wildner case ACPI_COPY_TYPE_SIMPLE:
10030d02842fSSascha Wildner
10040d02842fSSascha Wildner /* A null source object indicates a (legal) null package element */
10050d02842fSSascha Wildner
10060d02842fSSascha Wildner if (SourceObject)
10070d02842fSSascha Wildner {
10080d02842fSSascha Wildner /*
10090d02842fSSascha Wildner * This is a simple object, just copy it
10100d02842fSSascha Wildner */
10110d02842fSSascha Wildner TargetObject = AcpiUtCreateInternalObject (
10120d02842fSSascha Wildner SourceObject->Common.Type);
10130d02842fSSascha Wildner if (!TargetObject)
10140d02842fSSascha Wildner {
10150d02842fSSascha Wildner return (AE_NO_MEMORY);
10160d02842fSSascha Wildner }
10170d02842fSSascha Wildner
10180d02842fSSascha Wildner Status = AcpiUtCopySimpleObject (SourceObject, TargetObject);
10190d02842fSSascha Wildner if (ACPI_FAILURE (Status))
10200d02842fSSascha Wildner {
10210d02842fSSascha Wildner goto ErrorExit;
10220d02842fSSascha Wildner }
10230d02842fSSascha Wildner
10240d02842fSSascha Wildner *ThisTargetPtr = TargetObject;
10250d02842fSSascha Wildner }
10260d02842fSSascha Wildner else
10270d02842fSSascha Wildner {
10280d02842fSSascha Wildner /* Pass through a null element */
10290d02842fSSascha Wildner
10300d02842fSSascha Wildner *ThisTargetPtr = NULL;
10310d02842fSSascha Wildner }
10320d02842fSSascha Wildner break;
10330d02842fSSascha Wildner
10340d02842fSSascha Wildner case ACPI_COPY_TYPE_PACKAGE:
10350d02842fSSascha Wildner /*
10360d02842fSSascha Wildner * This object is a package - go down another nesting level
10370d02842fSSascha Wildner * Create and build the package object
10380d02842fSSascha Wildner */
1039820c5b08SSascha Wildner TargetObject = AcpiUtCreatePackageObject (
1040820c5b08SSascha Wildner SourceObject->Package.Count);
10410d02842fSSascha Wildner if (!TargetObject)
10420d02842fSSascha Wildner {
10430d02842fSSascha Wildner return (AE_NO_MEMORY);
10440d02842fSSascha Wildner }
10450d02842fSSascha Wildner
10460d02842fSSascha Wildner TargetObject->Common.Flags = SourceObject->Common.Flags;
10470d02842fSSascha Wildner
10480d02842fSSascha Wildner /* Pass the new package object back to the package walk routine */
10490d02842fSSascha Wildner
10500d02842fSSascha Wildner State->Pkg.ThisTargetObj = TargetObject;
10510d02842fSSascha Wildner
10520d02842fSSascha Wildner /* Store the object pointer in the parent package object */
10530d02842fSSascha Wildner
10540d02842fSSascha Wildner *ThisTargetPtr = TargetObject;
10550d02842fSSascha Wildner break;
10560d02842fSSascha Wildner
10570d02842fSSascha Wildner default:
10580d02842fSSascha Wildner
10590d02842fSSascha Wildner return (AE_BAD_PARAMETER);
10600d02842fSSascha Wildner }
10610d02842fSSascha Wildner
10620d02842fSSascha Wildner return (Status);
10630d02842fSSascha Wildner
10640d02842fSSascha Wildner ErrorExit:
10650d02842fSSascha Wildner AcpiUtRemoveReference (TargetObject);
10660d02842fSSascha Wildner return (Status);
10670d02842fSSascha Wildner }
10680d02842fSSascha Wildner
10690d02842fSSascha Wildner
10700d02842fSSascha Wildner /*******************************************************************************
10710d02842fSSascha Wildner *
10720d02842fSSascha Wildner * FUNCTION: AcpiUtCopyIpackageToIpackage
10730d02842fSSascha Wildner *
10740d02842fSSascha Wildner * PARAMETERS: SourceObj - Pointer to the source package object
10750d02842fSSascha Wildner * DestObj - Where the internal object is returned
10760d02842fSSascha Wildner * WalkState - Current Walk state descriptor
10770d02842fSSascha Wildner *
10780d02842fSSascha Wildner * RETURN: Status
10790d02842fSSascha Wildner *
10800d02842fSSascha Wildner * DESCRIPTION: This function is called to copy an internal package object
10810d02842fSSascha Wildner * into another internal package object.
10820d02842fSSascha Wildner *
10830d02842fSSascha Wildner ******************************************************************************/
10840d02842fSSascha Wildner
10850d02842fSSascha Wildner static ACPI_STATUS
AcpiUtCopyIpackageToIpackage(ACPI_OPERAND_OBJECT * SourceObj,ACPI_OPERAND_OBJECT * DestObj,ACPI_WALK_STATE * WalkState)10860d02842fSSascha Wildner AcpiUtCopyIpackageToIpackage (
10870d02842fSSascha Wildner ACPI_OPERAND_OBJECT *SourceObj,
10880d02842fSSascha Wildner ACPI_OPERAND_OBJECT *DestObj,
10890d02842fSSascha Wildner ACPI_WALK_STATE *WalkState)
10900d02842fSSascha Wildner {
10910d02842fSSascha Wildner ACPI_STATUS Status = AE_OK;
10920d02842fSSascha Wildner
10930d02842fSSascha Wildner
10940d02842fSSascha Wildner ACPI_FUNCTION_TRACE (UtCopyIpackageToIpackage);
10950d02842fSSascha Wildner
10960d02842fSSascha Wildner
10970d02842fSSascha Wildner DestObj->Common.Type = SourceObj->Common.Type;
10980d02842fSSascha Wildner DestObj->Common.Flags = SourceObj->Common.Flags;
10990d02842fSSascha Wildner DestObj->Package.Count = SourceObj->Package.Count;
11000d02842fSSascha Wildner
11010d02842fSSascha Wildner /*
11020d02842fSSascha Wildner * Create the object array and walk the source package tree
11030d02842fSSascha Wildner */
11040d02842fSSascha Wildner DestObj->Package.Elements = ACPI_ALLOCATE_ZEROED (
11050d02842fSSascha Wildner ((ACPI_SIZE) SourceObj->Package.Count + 1) *
11060d02842fSSascha Wildner sizeof (void *));
11070d02842fSSascha Wildner if (!DestObj->Package.Elements)
11080d02842fSSascha Wildner {
11090d02842fSSascha Wildner ACPI_ERROR ((AE_INFO, "Package allocation failure"));
11100d02842fSSascha Wildner return_ACPI_STATUS (AE_NO_MEMORY);
11110d02842fSSascha Wildner }
11120d02842fSSascha Wildner
11130d02842fSSascha Wildner /*
11140d02842fSSascha Wildner * Copy the package element-by-element by walking the package "tree".
11150d02842fSSascha Wildner * This handles nested packages of arbitrary depth.
11160d02842fSSascha Wildner */
11170d02842fSSascha Wildner Status = AcpiUtWalkPackageTree (SourceObj, DestObj,
11180d02842fSSascha Wildner AcpiUtCopyIelementToIelement, WalkState);
11190d02842fSSascha Wildner if (ACPI_FAILURE (Status))
11200d02842fSSascha Wildner {
11210d02842fSSascha Wildner /* On failure, delete the destination package object */
11220d02842fSSascha Wildner
11230d02842fSSascha Wildner AcpiUtRemoveReference (DestObj);
11240d02842fSSascha Wildner }
11250d02842fSSascha Wildner
11260d02842fSSascha Wildner return_ACPI_STATUS (Status);
11270d02842fSSascha Wildner }
11280d02842fSSascha Wildner
11290d02842fSSascha Wildner
11300d02842fSSascha Wildner /*******************************************************************************
11310d02842fSSascha Wildner *
11320d02842fSSascha Wildner * FUNCTION: AcpiUtCopyIobjectToIobject
11330d02842fSSascha Wildner *
11340d02842fSSascha Wildner * PARAMETERS: SourceDesc - The internal object to be copied
11350d02842fSSascha Wildner * DestDesc - Where the copied object is returned
11360d02842fSSascha Wildner * WalkState - Current walk state
11370d02842fSSascha Wildner *
11380d02842fSSascha Wildner * RETURN: Status
11390d02842fSSascha Wildner *
11400d02842fSSascha Wildner * DESCRIPTION: Copy an internal object to a new internal object
11410d02842fSSascha Wildner *
11420d02842fSSascha Wildner ******************************************************************************/
11430d02842fSSascha Wildner
11440d02842fSSascha Wildner ACPI_STATUS
AcpiUtCopyIobjectToIobject(ACPI_OPERAND_OBJECT * SourceDesc,ACPI_OPERAND_OBJECT ** DestDesc,ACPI_WALK_STATE * WalkState)11450d02842fSSascha Wildner AcpiUtCopyIobjectToIobject (
11460d02842fSSascha Wildner ACPI_OPERAND_OBJECT *SourceDesc,
11470d02842fSSascha Wildner ACPI_OPERAND_OBJECT **DestDesc,
11480d02842fSSascha Wildner ACPI_WALK_STATE *WalkState)
11490d02842fSSascha Wildner {
11500d02842fSSascha Wildner ACPI_STATUS Status = AE_OK;
11510d02842fSSascha Wildner
11520d02842fSSascha Wildner
11530d02842fSSascha Wildner ACPI_FUNCTION_TRACE (UtCopyIobjectToIobject);
11540d02842fSSascha Wildner
11550d02842fSSascha Wildner
11560d02842fSSascha Wildner /* Create the top level object */
11570d02842fSSascha Wildner
11580d02842fSSascha Wildner *DestDesc = AcpiUtCreateInternalObject (SourceDesc->Common.Type);
11590d02842fSSascha Wildner if (!*DestDesc)
11600d02842fSSascha Wildner {
11610d02842fSSascha Wildner return_ACPI_STATUS (AE_NO_MEMORY);
11620d02842fSSascha Wildner }
11630d02842fSSascha Wildner
11640d02842fSSascha Wildner /* Copy the object and possible subobjects */
11650d02842fSSascha Wildner
11660d02842fSSascha Wildner if (SourceDesc->Common.Type == ACPI_TYPE_PACKAGE)
11670d02842fSSascha Wildner {
1168820c5b08SSascha Wildner Status = AcpiUtCopyIpackageToIpackage (
1169820c5b08SSascha Wildner SourceDesc, *DestDesc, WalkState);
11700d02842fSSascha Wildner }
11710d02842fSSascha Wildner else
11720d02842fSSascha Wildner {
11730d02842fSSascha Wildner Status = AcpiUtCopySimpleObject (SourceDesc, *DestDesc);
11740d02842fSSascha Wildner }
11750d02842fSSascha Wildner
11765f39c7e7SSascha Wildner /* Delete the allocated object if copy failed */
11775f39c7e7SSascha Wildner
11785f39c7e7SSascha Wildner if (ACPI_FAILURE (Status))
11795f39c7e7SSascha Wildner {
11805f39c7e7SSascha Wildner AcpiUtRemoveReference (*DestDesc);
11815f39c7e7SSascha Wildner }
11825f39c7e7SSascha Wildner
11830d02842fSSascha Wildner return_ACPI_STATUS (Status);
11840d02842fSSascha Wildner }
1185