1 /******************************************************************************
3 * Module Name: utcopy - Internal to external object translation utilities
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2005, R. Byron Moore
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.
44 #include <acpi/acpi.h>
45 #include <acpi/amlcode.h>
47 #define _COMPONENT ACPI_UTILITIES
48 ACPI_MODULE_NAME("utcopy")
50 /* Local prototypes */
52 acpi_ut_copy_isimple_to_esimple(union acpi_operand_object *internal_object,
53 union acpi_object *external_object,
54 u8 * data_space, acpi_size * buffer_space_used);
57 acpi_ut_copy_ielement_to_ielement(u8 object_type,
58 union acpi_operand_object *source_object,
59 union acpi_generic_state *state,
63 acpi_ut_copy_ipackage_to_epackage(union acpi_operand_object *internal_object,
64 u8 * buffer, acpi_size * space_used);
67 acpi_ut_copy_esimple_to_isimple(union acpi_object *user_obj,
68 union acpi_operand_object **return_obj);
71 acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
72 union acpi_operand_object *dest_desc);
75 acpi_ut_copy_ielement_to_eelement(u8 object_type,
76 union acpi_operand_object *source_object,
77 union acpi_generic_state *state,
81 acpi_ut_copy_ipackage_to_ipackage(union acpi_operand_object *source_obj,
82 union acpi_operand_object *dest_obj,
83 struct acpi_walk_state *walk_state);
85 /*******************************************************************************
87 * FUNCTION: acpi_ut_copy_isimple_to_esimple
89 * PARAMETERS: internal_object - Source object to be copied
90 * external_object - Where to return the copied object
91 * data_space - Where object data is returned (such as
92 * buffer and string data)
93 * buffer_space_used - Length of data_space that was used
97 * DESCRIPTION: This function is called to copy a simple internal object to
100 * The data_space buffer is assumed to have sufficient space for
103 ******************************************************************************/
106 acpi_ut_copy_isimple_to_esimple(union acpi_operand_object *internal_object,
107 union acpi_object *external_object,
108 u8 * data_space, acpi_size * buffer_space_used)
110 acpi_status status = AE_OK;
112 ACPI_FUNCTION_TRACE("ut_copy_isimple_to_esimple");
114 *buffer_space_used = 0;
117 * Check for NULL object case (could be an uninitialized
120 if (!internal_object) {
121 return_ACPI_STATUS(AE_OK);
124 /* Always clear the external object */
126 ACPI_MEMSET(external_object, 0, sizeof(union acpi_object));
129 * In general, the external object will be the same type as
130 * the internal object
132 external_object->type = ACPI_GET_OBJECT_TYPE(internal_object);
134 /* However, only a limited number of external types are supported */
136 switch (ACPI_GET_OBJECT_TYPE(internal_object)) {
137 case ACPI_TYPE_STRING:
139 external_object->string.pointer = (char *)data_space;
140 external_object->string.length = internal_object->string.length;
141 *buffer_space_used = ACPI_ROUND_UP_TO_NATIVE_WORD((acpi_size)
146 ACPI_MEMCPY((void *)data_space,
147 (void *)internal_object->string.pointer,
148 (acpi_size) internal_object->string.length + 1);
151 case ACPI_TYPE_BUFFER:
153 external_object->buffer.pointer = data_space;
154 external_object->buffer.length = internal_object->buffer.length;
156 ACPI_ROUND_UP_TO_NATIVE_WORD(internal_object->string.
159 ACPI_MEMCPY((void *)data_space,
160 (void *)internal_object->buffer.pointer,
161 internal_object->buffer.length);
164 case ACPI_TYPE_INTEGER:
166 external_object->integer.value = internal_object->integer.value;
169 case ACPI_TYPE_LOCAL_REFERENCE:
172 * This is an object reference. Attempt to dereference it.
174 switch (internal_object->reference.opcode) {
175 case AML_INT_NAMEPATH_OP:
177 /* For namepath, return the object handle ("reference") */
181 * Use the object type of "Any" to indicate a reference
182 * to object containing a handle to an ACPI named object.
184 external_object->type = ACPI_TYPE_ANY;
185 external_object->reference.handle =
186 internal_object->reference.node;
191 case ACPI_TYPE_PROCESSOR:
193 external_object->processor.proc_id =
194 internal_object->processor.proc_id;
195 external_object->processor.pblk_address =
196 internal_object->processor.address;
197 external_object->processor.pblk_length =
198 internal_object->processor.length;
201 case ACPI_TYPE_POWER:
203 external_object->power_resource.system_level =
204 internal_object->power_resource.system_level;
206 external_object->power_resource.resource_order =
207 internal_object->power_resource.resource_order;
212 * There is no corresponding external object type
214 return_ACPI_STATUS(AE_SUPPORT);
217 return_ACPI_STATUS(status);
220 /*******************************************************************************
222 * FUNCTION: acpi_ut_copy_ielement_to_eelement
224 * PARAMETERS: acpi_pkg_callback
228 * DESCRIPTION: Copy one package element to another package element
230 ******************************************************************************/
233 acpi_ut_copy_ielement_to_eelement(u8 object_type,
234 union acpi_operand_object *source_object,
235 union acpi_generic_state *state,
238 acpi_status status = AE_OK;
239 struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
240 acpi_size object_space;
242 union acpi_object *target_object;
244 ACPI_FUNCTION_ENTRY();
246 this_index = state->pkg.index;
247 target_object = (union acpi_object *)
248 &((union acpi_object *)(state->pkg.dest_object))->package.
249 elements[this_index];
251 switch (object_type) {
252 case ACPI_COPY_TYPE_SIMPLE:
255 * This is a simple or null object
257 status = acpi_ut_copy_isimple_to_esimple(source_object,
261 if (ACPI_FAILURE(status)) {
266 case ACPI_COPY_TYPE_PACKAGE:
269 * Build the package object
271 target_object->type = ACPI_TYPE_PACKAGE;
272 target_object->package.count = source_object->package.count;
273 target_object->package.elements =
274 ACPI_CAST_PTR(union acpi_object, info->free_space);
277 * Pass the new package object back to the package walk routine
279 state->pkg.this_target_obj = target_object;
282 * Save space for the array of objects (Package elements)
283 * update the buffer length counter
285 object_space = ACPI_ROUND_UP_TO_NATIVE_WORD((acpi_size)
293 return (AE_BAD_PARAMETER);
296 info->free_space += object_space;
297 info->length += object_space;
301 /*******************************************************************************
303 * FUNCTION: acpi_ut_copy_ipackage_to_epackage
305 * PARAMETERS: internal_object - Pointer to the object we are returning
306 * Buffer - Where the object is returned
307 * space_used - Where the object length is returned
311 * DESCRIPTION: This function is called to place a package object in a user
312 * buffer. A package object by definition contains other objects.
314 * The buffer is assumed to have sufficient space for the object.
315 * The caller must have verified the buffer length needed using the
316 * acpi_ut_get_object_size function before calling this function.
318 ******************************************************************************/
321 acpi_ut_copy_ipackage_to_epackage(union acpi_operand_object *internal_object,
322 u8 * buffer, acpi_size * space_used)
324 union acpi_object *external_object;
326 struct acpi_pkg_info info;
328 ACPI_FUNCTION_TRACE("ut_copy_ipackage_to_epackage");
331 * First package at head of the buffer
333 external_object = ACPI_CAST_PTR(union acpi_object, buffer);
336 * Free space begins right after the first package
338 info.length = ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
340 buffer + ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
341 info.object_space = 0;
342 info.num_packages = 1;
344 external_object->type = ACPI_GET_OBJECT_TYPE(internal_object);
345 external_object->package.count = internal_object->package.count;
346 external_object->package.elements = ACPI_CAST_PTR(union acpi_object,
350 * Leave room for an array of ACPI_OBJECTS in the buffer
351 * and move the free space past it
353 info.length += (acpi_size) external_object->package.count *
354 ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
355 info.free_space += external_object->package.count *
356 ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
358 status = acpi_ut_walk_package_tree(internal_object, external_object,
359 acpi_ut_copy_ielement_to_eelement,
362 *space_used = info.length;
363 return_ACPI_STATUS(status);
366 /*******************************************************************************
368 * FUNCTION: acpi_ut_copy_iobject_to_eobject
370 * PARAMETERS: internal_object - The internal object to be converted
371 * buffer_ptr - Where the object is returned
375 * DESCRIPTION: This function is called to build an API object to be returned to
378 ******************************************************************************/
381 acpi_ut_copy_iobject_to_eobject(union acpi_operand_object *internal_object,
382 struct acpi_buffer *ret_buffer)
386 ACPI_FUNCTION_TRACE("ut_copy_iobject_to_eobject");
388 if (ACPI_GET_OBJECT_TYPE(internal_object) == ACPI_TYPE_PACKAGE) {
390 * Package object: Copy all subobjects (including
393 status = acpi_ut_copy_ipackage_to_epackage(internal_object,
395 &ret_buffer->length);
398 * Build a simple object (no nested objects)
400 status = acpi_ut_copy_isimple_to_esimple(internal_object,
401 (union acpi_object *)
405 ACPI_ROUND_UP_TO_NATIVE_WORD
409 &ret_buffer->length);
411 * build simple does not include the object size in the length
412 * so we add it in here
414 ret_buffer->length += sizeof(union acpi_object);
417 return_ACPI_STATUS(status);
420 /*******************************************************************************
422 * FUNCTION: acpi_ut_copy_esimple_to_isimple
424 * PARAMETERS: external_object - The external object to be converted
425 * ret_internal_object - Where the internal object is returned
429 * DESCRIPTION: This function copies an external object to an internal one.
430 * NOTE: Pointers can be copied, we don't need to copy data.
431 * (The pointers have to be valid in our address space no matter
432 * what we do with them!)
434 ******************************************************************************/
437 acpi_ut_copy_esimple_to_isimple(union acpi_object *external_object,
438 union acpi_operand_object **ret_internal_object)
440 union acpi_operand_object *internal_object;
442 ACPI_FUNCTION_TRACE("ut_copy_esimple_to_isimple");
445 * Simple types supported are: String, Buffer, Integer
447 switch (external_object->type) {
448 case ACPI_TYPE_STRING:
449 case ACPI_TYPE_BUFFER:
450 case ACPI_TYPE_INTEGER:
452 internal_object = acpi_ut_create_internal_object((u8)
455 if (!internal_object) {
456 return_ACPI_STATUS(AE_NO_MEMORY);
461 /* All other types are not supported */
463 return_ACPI_STATUS(AE_SUPPORT);
466 /* Must COPY string and buffer contents */
468 switch (external_object->type) {
469 case ACPI_TYPE_STRING:
471 internal_object->string.pointer =
472 ACPI_MEM_CALLOCATE((acpi_size) external_object->string.
474 if (!internal_object->string.pointer) {
478 ACPI_MEMCPY(internal_object->string.pointer,
479 external_object->string.pointer,
480 external_object->string.length);
482 internal_object->string.length = external_object->string.length;
485 case ACPI_TYPE_BUFFER:
487 internal_object->buffer.pointer =
488 ACPI_MEM_CALLOCATE(external_object->buffer.length);
489 if (!internal_object->buffer.pointer) {
493 ACPI_MEMCPY(internal_object->buffer.pointer,
494 external_object->buffer.pointer,
495 external_object->buffer.length);
497 internal_object->buffer.length = external_object->buffer.length;
500 case ACPI_TYPE_INTEGER:
502 internal_object->integer.value = external_object->integer.value;
506 /* Other types can't get here */
510 *ret_internal_object = internal_object;
511 return_ACPI_STATUS(AE_OK);
514 acpi_ut_remove_reference(internal_object);
515 return_ACPI_STATUS(AE_NO_MEMORY);
518 #ifdef ACPI_FUTURE_IMPLEMENTATION
519 /* Code to convert packages that are parameters to control methods */
521 /*******************************************************************************
523 * FUNCTION: acpi_ut_copy_epackage_to_ipackage
525 * PARAMETERS: *internal_object - Pointer to the object we are returning
526 * *Buffer - Where the object is returned
527 * *space_used - Where the length of the object is returned
531 * DESCRIPTION: This function is called to place a package object in a user
532 * buffer. A package object by definition contains other objects.
534 * The buffer is assumed to have sufficient space for the object.
535 * The caller must have verified the buffer length needed using the
536 * acpi_ut_get_object_size function before calling this function.
538 ******************************************************************************/
541 acpi_ut_copy_epackage_to_ipackage(union acpi_operand_object *internal_object,
542 u8 * buffer, u32 * space_used)
545 union acpi_object *external_object;
548 u32 object_space = 0;
549 union acpi_operand_object *this_internal_obj;
550 union acpi_object *this_external_obj;
552 ACPI_FUNCTION_TRACE("ut_copy_epackage_to_ipackage");
555 * First package at head of the buffer
557 external_object = (union acpi_object *)buffer;
560 * Free space begins right after the first package
562 free_space = buffer + sizeof(union acpi_object);
564 external_object->type = ACPI_GET_OBJECT_TYPE(internal_object);
565 external_object->package.count = internal_object->package.count;
566 external_object->package.elements = (union acpi_object *)free_space;
569 * Build an array of ACPI_OBJECTS in the buffer
570 * and move the free space past it
573 external_object->package.count * sizeof(union acpi_object);
575 /* Call walk_package */
579 #endif /* Future implementation */
581 /*******************************************************************************
583 * FUNCTION: acpi_ut_copy_eobject_to_iobject
585 * PARAMETERS: *internal_object - The external object to be converted
586 * *buffer_ptr - Where the internal object is returned
588 * RETURN: Status - the status of the call
590 * DESCRIPTION: Converts an external object to an internal object.
592 ******************************************************************************/
595 acpi_ut_copy_eobject_to_iobject(union acpi_object *external_object,
596 union acpi_operand_object **internal_object)
600 ACPI_FUNCTION_TRACE("ut_copy_eobject_to_iobject");
602 if (external_object->type == ACPI_TYPE_PACKAGE) {
604 * Packages as external input to control methods are not supported,
606 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
607 "Packages as parameters not implemented!\n"));
609 return_ACPI_STATUS(AE_NOT_IMPLEMENTED);
614 * Build a simple object (no nested objects)
617 acpi_ut_copy_esimple_to_isimple(external_object,
621 return_ACPI_STATUS(status);
624 /*******************************************************************************
626 * FUNCTION: acpi_ut_copy_simple_object
628 * PARAMETERS: source_desc - The internal object to be copied
629 * dest_desc - New target object
633 * DESCRIPTION: Simple copy of one internal object to another. Reference count
634 * of the destination object is preserved.
636 ******************************************************************************/
639 acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
640 union acpi_operand_object *dest_desc)
643 union acpi_operand_object *next_object;
645 /* Save fields from destination that we don't want to overwrite */
647 reference_count = dest_desc->common.reference_count;
648 next_object = dest_desc->common.next_object;
650 /* Copy the entire source object over the destination object */
652 ACPI_MEMCPY((char *)dest_desc, (char *)source_desc,
653 sizeof(union acpi_operand_object));
655 /* Restore the saved fields */
657 dest_desc->common.reference_count = reference_count;
658 dest_desc->common.next_object = next_object;
660 /* New object is not static, regardless of source */
662 dest_desc->common.flags &= ~AOPOBJ_STATIC_POINTER;
664 /* Handle the objects with extra data */
666 switch (ACPI_GET_OBJECT_TYPE(dest_desc)) {
667 case ACPI_TYPE_BUFFER:
669 * Allocate and copy the actual buffer if and only if:
670 * 1) There is a valid buffer pointer
671 * 2) The buffer has a length > 0
673 if ((source_desc->buffer.pointer) &&
674 (source_desc->buffer.length)) {
675 dest_desc->buffer.pointer =
676 ACPI_MEM_ALLOCATE(source_desc->buffer.length);
677 if (!dest_desc->buffer.pointer) {
678 return (AE_NO_MEMORY);
681 /* Copy the actual buffer data */
683 ACPI_MEMCPY(dest_desc->buffer.pointer,
684 source_desc->buffer.pointer,
685 source_desc->buffer.length);
689 case ACPI_TYPE_STRING:
691 * Allocate and copy the actual string if and only if:
692 * 1) There is a valid string pointer
693 * (Pointer to a NULL string is allowed)
695 if (source_desc->string.pointer) {
696 dest_desc->string.pointer =
697 ACPI_MEM_ALLOCATE((acpi_size) source_desc->string.
699 if (!dest_desc->string.pointer) {
700 return (AE_NO_MEMORY);
703 /* Copy the actual string data */
705 ACPI_MEMCPY(dest_desc->string.pointer,
706 source_desc->string.pointer,
707 (acpi_size) source_desc->string.length + 1);
711 case ACPI_TYPE_LOCAL_REFERENCE:
713 * We copied the reference object, so we now must add a reference
714 * to the object pointed to by the reference
716 acpi_ut_add_reference(source_desc->reference.object);
720 /* Nothing to do for other simple objects */
727 /*******************************************************************************
729 * FUNCTION: acpi_ut_copy_ielement_to_ielement
731 * PARAMETERS: acpi_pkg_callback
735 * DESCRIPTION: Copy one package element to another package element
737 ******************************************************************************/
740 acpi_ut_copy_ielement_to_ielement(u8 object_type,
741 union acpi_operand_object *source_object,
742 union acpi_generic_state *state,
745 acpi_status status = AE_OK;
747 union acpi_operand_object **this_target_ptr;
748 union acpi_operand_object *target_object;
750 ACPI_FUNCTION_ENTRY();
752 this_index = state->pkg.index;
753 this_target_ptr = (union acpi_operand_object **)
754 &state->pkg.dest_object->package.elements[this_index];
756 switch (object_type) {
757 case ACPI_COPY_TYPE_SIMPLE:
759 /* A null source object indicates a (legal) null package element */
763 * This is a simple object, just copy it
766 acpi_ut_create_internal_object(ACPI_GET_OBJECT_TYPE
768 if (!target_object) {
769 return (AE_NO_MEMORY);
773 acpi_ut_copy_simple_object(source_object,
775 if (ACPI_FAILURE(status)) {
779 *this_target_ptr = target_object;
781 /* Pass through a null element */
783 *this_target_ptr = NULL;
787 case ACPI_COPY_TYPE_PACKAGE:
790 * This object is a package - go down another nesting level
791 * Create and build the package object
794 acpi_ut_create_internal_object(ACPI_TYPE_PACKAGE);
795 if (!target_object) {
796 return (AE_NO_MEMORY);
799 target_object->package.count = source_object->package.count;
800 target_object->common.flags = source_object->common.flags;
803 * Create the object array
805 target_object->package.elements =
806 ACPI_MEM_CALLOCATE(((acpi_size) source_object->package.
807 count + 1) * sizeof(void *));
808 if (!target_object->package.elements) {
809 status = AE_NO_MEMORY;
814 * Pass the new package object back to the package walk routine
816 state->pkg.this_target_obj = target_object;
819 * Store the object pointer in the parent package object
821 *this_target_ptr = target_object;
825 return (AE_BAD_PARAMETER);
831 acpi_ut_remove_reference(target_object);
835 /*******************************************************************************
837 * FUNCTION: acpi_ut_copy_ipackage_to_ipackage
839 * PARAMETERS: *source_obj - Pointer to the source package object
840 * *dest_obj - Where the internal object is returned
842 * RETURN: Status - the status of the call
844 * DESCRIPTION: This function is called to copy an internal package object
845 * into another internal package object.
847 ******************************************************************************/
850 acpi_ut_copy_ipackage_to_ipackage(union acpi_operand_object *source_obj,
851 union acpi_operand_object *dest_obj,
852 struct acpi_walk_state *walk_state)
854 acpi_status status = AE_OK;
856 ACPI_FUNCTION_TRACE("ut_copy_ipackage_to_ipackage");
858 dest_obj->common.type = ACPI_GET_OBJECT_TYPE(source_obj);
859 dest_obj->common.flags = source_obj->common.flags;
860 dest_obj->package.count = source_obj->package.count;
863 * Create the object array and walk the source package tree
865 dest_obj->package.elements = ACPI_MEM_CALLOCATE(((acpi_size)
868 1) * sizeof(void *));
869 if (!dest_obj->package.elements) {
870 ACPI_REPORT_ERROR(("aml_build_copy_internal_package_object: Package allocation failure\n"));
871 return_ACPI_STATUS(AE_NO_MEMORY);
875 * Copy the package element-by-element by walking the package "tree".
876 * This handles nested packages of arbitrary depth.
878 status = acpi_ut_walk_package_tree(source_obj, dest_obj,
879 acpi_ut_copy_ielement_to_ielement,
881 if (ACPI_FAILURE(status)) {
882 /* On failure, delete the destination package object */
884 acpi_ut_remove_reference(dest_obj);
887 return_ACPI_STATUS(status);
890 /*******************************************************************************
892 * FUNCTION: acpi_ut_copy_iobject_to_iobject
894 * PARAMETERS: walk_state - Current walk state
895 * source_desc - The internal object to be copied
896 * dest_desc - Where the copied object is returned
900 * DESCRIPTION: Copy an internal object to a new internal object
902 ******************************************************************************/
905 acpi_ut_copy_iobject_to_iobject(union acpi_operand_object *source_desc,
906 union acpi_operand_object **dest_desc,
907 struct acpi_walk_state *walk_state)
909 acpi_status status = AE_OK;
911 ACPI_FUNCTION_TRACE("ut_copy_iobject_to_iobject");
913 /* Create the top level object */
916 acpi_ut_create_internal_object(ACPI_GET_OBJECT_TYPE(source_desc));
918 return_ACPI_STATUS(AE_NO_MEMORY);
921 /* Copy the object and possible subobjects */
923 if (ACPI_GET_OBJECT_TYPE(source_desc) == ACPI_TYPE_PACKAGE) {
925 acpi_ut_copy_ipackage_to_ipackage(source_desc, *dest_desc,
928 status = acpi_ut_copy_simple_object(source_desc, *dest_desc);
931 return_ACPI_STATUS(status);