ACPICA: Lindent
[linux-2.6.git] / drivers / acpi / utilities / utcopy.c
1 /******************************************************************************
2  *
3  * Module Name: utcopy - Internal to external object translation utilities
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2007, R. Byron Moore
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
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.
25  *
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.
29  *
30  * NO WARRANTY
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.
42  */
43
44 #include <acpi/acpi.h>
45 #include <acpi/amlcode.h>
46
47 #define _COMPONENT          ACPI_UTILITIES
48 ACPI_MODULE_NAME("utcopy")
49
50 /* Local prototypes */
51 static acpi_status
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);
55
56 static acpi_status
57 acpi_ut_copy_ielement_to_ielement(u8 object_type,
58                                   union acpi_operand_object *source_object,
59                                   union acpi_generic_state *state,
60                                   void *context);
61
62 static acpi_status
63 acpi_ut_copy_ipackage_to_epackage(union acpi_operand_object *internal_object,
64                                   u8 * buffer, acpi_size * space_used);
65
66 static acpi_status
67 acpi_ut_copy_esimple_to_isimple(union acpi_object *user_obj,
68                                 union acpi_operand_object **return_obj);
69
70 static acpi_status
71 acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
72                            union acpi_operand_object *dest_desc);
73
74 static acpi_status
75 acpi_ut_copy_ielement_to_eelement(u8 object_type,
76                                   union acpi_operand_object *source_object,
77                                   union acpi_generic_state *state,
78                                   void *context);
79
80 static acpi_status
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);
84
85 /*******************************************************************************
86  *
87  * FUNCTION:    acpi_ut_copy_isimple_to_esimple
88  *
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
94  *
95  * RETURN:      Status
96  *
97  * DESCRIPTION: This function is called to copy a simple internal object to
98  *              an external object.
99  *
100  *              The data_space buffer is assumed to have sufficient space for
101  *              the object.
102  *
103  ******************************************************************************/
104
105 static acpi_status
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)
109 {
110         acpi_status status = AE_OK;
111
112         ACPI_FUNCTION_TRACE(ut_copy_isimple_to_esimple);
113
114         *buffer_space_used = 0;
115
116         /*
117          * Check for NULL object case (could be an uninitialized
118          * package element)
119          */
120         if (!internal_object) {
121                 return_ACPI_STATUS(AE_OK);
122         }
123
124         /* Always clear the external object */
125
126         ACPI_MEMSET(external_object, 0, sizeof(union acpi_object));
127
128         /*
129          * In general, the external object will be the same type as
130          * the internal object
131          */
132         external_object->type = ACPI_GET_OBJECT_TYPE(internal_object);
133
134         /* However, only a limited number of external types are supported */
135
136         switch (ACPI_GET_OBJECT_TYPE(internal_object)) {
137         case ACPI_TYPE_STRING:
138
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)
142                                                                   internal_object->
143                                                                   string.
144                                                                   length + 1);
145
146                 ACPI_MEMCPY((void *)data_space,
147                             (void *)internal_object->string.pointer,
148                             (acpi_size) internal_object->string.length + 1);
149                 break;
150
151         case ACPI_TYPE_BUFFER:
152
153                 external_object->buffer.pointer = data_space;
154                 external_object->buffer.length = internal_object->buffer.length;
155                 *buffer_space_used =
156                     ACPI_ROUND_UP_TO_NATIVE_WORD(internal_object->string.
157                                                  length);
158
159                 ACPI_MEMCPY((void *)data_space,
160                             (void *)internal_object->buffer.pointer,
161                             internal_object->buffer.length);
162                 break;
163
164         case ACPI_TYPE_INTEGER:
165
166                 external_object->integer.value = internal_object->integer.value;
167                 break;
168
169         case ACPI_TYPE_LOCAL_REFERENCE:
170
171                 /*
172                  * This is an object reference.  Attempt to dereference it.
173                  */
174                 switch (internal_object->reference.opcode) {
175                 case AML_INT_NAMEPATH_OP:
176
177                         /* For namepath, return the object handle ("reference") */
178
179                 default:
180                         /*
181                          * Use the object type of "Any" to indicate a reference
182                          * to object containing a handle to an ACPI named object.
183                          */
184                         external_object->type = ACPI_TYPE_ANY;
185                         external_object->reference.handle =
186                             internal_object->reference.node;
187                         break;
188                 }
189                 break;
190
191         case ACPI_TYPE_PROCESSOR:
192
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;
199                 break;
200
201         case ACPI_TYPE_POWER:
202
203                 external_object->power_resource.system_level =
204                     internal_object->power_resource.system_level;
205
206                 external_object->power_resource.resource_order =
207                     internal_object->power_resource.resource_order;
208                 break;
209
210         default:
211                 /*
212                  * There is no corresponding external object type
213                  */
214                 return_ACPI_STATUS(AE_SUPPORT);
215         }
216
217         return_ACPI_STATUS(status);
218 }
219
220 /*******************************************************************************
221  *
222  * FUNCTION:    acpi_ut_copy_ielement_to_eelement
223  *
224  * PARAMETERS:  acpi_pkg_callback
225  *
226  * RETURN:      Status
227  *
228  * DESCRIPTION: Copy one package element to another package element
229  *
230  ******************************************************************************/
231
232 static acpi_status
233 acpi_ut_copy_ielement_to_eelement(u8 object_type,
234                                   union acpi_operand_object *source_object,
235                                   union acpi_generic_state *state,
236                                   void *context)
237 {
238         acpi_status status = AE_OK;
239         struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
240         acpi_size object_space;
241         u32 this_index;
242         union acpi_object *target_object;
243
244         ACPI_FUNCTION_ENTRY();
245
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];
250
251         switch (object_type) {
252         case ACPI_COPY_TYPE_SIMPLE:
253
254                 /*
255                  * This is a simple or null object
256                  */
257                 status = acpi_ut_copy_isimple_to_esimple(source_object,
258                                                          target_object,
259                                                          info->free_space,
260                                                          &object_space);
261                 if (ACPI_FAILURE(status)) {
262                         return (status);
263                 }
264                 break;
265
266         case ACPI_COPY_TYPE_PACKAGE:
267
268                 /*
269                  * Build the package object
270                  */
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);
275
276                 /*
277                  * Pass the new package object back to the package walk routine
278                  */
279                 state->pkg.this_target_obj = target_object;
280
281                 /*
282                  * Save space for the array of objects (Package elements)
283                  * update the buffer length counter
284                  */
285                 object_space = ACPI_ROUND_UP_TO_NATIVE_WORD((acpi_size)
286                                                             target_object->
287                                                             package.count *
288                                                             sizeof(union
289                                                                    acpi_object));
290                 break;
291
292         default:
293                 return (AE_BAD_PARAMETER);
294         }
295
296         info->free_space += object_space;
297         info->length += object_space;
298         return (status);
299 }
300
301 /*******************************************************************************
302  *
303  * FUNCTION:    acpi_ut_copy_ipackage_to_epackage
304  *
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
308  *
309  * RETURN:      Status
310  *
311  * DESCRIPTION: This function is called to place a package object in a user
312  *              buffer.  A package object by definition contains other objects.
313  *
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.
317  *
318  ******************************************************************************/
319
320 static acpi_status
321 acpi_ut_copy_ipackage_to_epackage(union acpi_operand_object *internal_object,
322                                   u8 * buffer, acpi_size * space_used)
323 {
324         union acpi_object *external_object;
325         acpi_status status;
326         struct acpi_pkg_info info;
327
328         ACPI_FUNCTION_TRACE(ut_copy_ipackage_to_epackage);
329
330         /*
331          * First package at head of the buffer
332          */
333         external_object = ACPI_CAST_PTR(union acpi_object, buffer);
334
335         /*
336          * Free space begins right after the first package
337          */
338         info.length = ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
339         info.free_space =
340             buffer + ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
341         info.object_space = 0;
342         info.num_packages = 1;
343
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,
347                                                           info.free_space);
348
349         /*
350          * Leave room for an array of ACPI_OBJECTS in the buffer
351          * and move the free space past it
352          */
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));
357
358         status = acpi_ut_walk_package_tree(internal_object, external_object,
359                                            acpi_ut_copy_ielement_to_eelement,
360                                            &info);
361
362         *space_used = info.length;
363         return_ACPI_STATUS(status);
364 }
365
366 /*******************************************************************************
367  *
368  * FUNCTION:    acpi_ut_copy_iobject_to_eobject
369  *
370  * PARAMETERS:  internal_object     - The internal object to be converted
371  *              buffer_ptr          - Where the object is returned
372  *
373  * RETURN:      Status
374  *
375  * DESCRIPTION: This function is called to build an API object to be returned to
376  *              the caller.
377  *
378  ******************************************************************************/
379
380 acpi_status
381 acpi_ut_copy_iobject_to_eobject(union acpi_operand_object *internal_object,
382                                 struct acpi_buffer *ret_buffer)
383 {
384         acpi_status status;
385
386         ACPI_FUNCTION_TRACE(ut_copy_iobject_to_eobject);
387
388         if (ACPI_GET_OBJECT_TYPE(internal_object) == ACPI_TYPE_PACKAGE) {
389                 /*
390                  * Package object:  Copy all subobjects (including
391                  * nested packages)
392                  */
393                 status = acpi_ut_copy_ipackage_to_epackage(internal_object,
394                                                            ret_buffer->pointer,
395                                                            &ret_buffer->length);
396         } else {
397                 /*
398                  * Build a simple object (no nested objects)
399                  */
400                 status = acpi_ut_copy_isimple_to_esimple(internal_object,
401                                                          ACPI_CAST_PTR(union
402                                                                        acpi_object,
403                                                                        ret_buffer->
404                                                                        pointer),
405                                                          ACPI_ADD_PTR(u8,
406                                                                       ret_buffer->
407                                                                       pointer,
408                                                                       ACPI_ROUND_UP_TO_NATIVE_WORD
409                                                                       (sizeof
410                                                                        (union
411                                                                         acpi_object))),
412                                                          &ret_buffer->length);
413                 /*
414                  * build simple does not include the object size in the length
415                  * so we add it in here
416                  */
417                 ret_buffer->length += sizeof(union acpi_object);
418         }
419
420         return_ACPI_STATUS(status);
421 }
422
423 /*******************************************************************************
424  *
425  * FUNCTION:    acpi_ut_copy_esimple_to_isimple
426  *
427  * PARAMETERS:  external_object     - The external object to be converted
428  *              ret_internal_object - Where the internal object is returned
429  *
430  * RETURN:      Status
431  *
432  * DESCRIPTION: This function copies an external object to an internal one.
433  *              NOTE: Pointers can be copied, we don't need to copy data.
434  *              (The pointers have to be valid in our address space no matter
435  *              what we do with them!)
436  *
437  ******************************************************************************/
438
439 static acpi_status
440 acpi_ut_copy_esimple_to_isimple(union acpi_object *external_object,
441                                 union acpi_operand_object **ret_internal_object)
442 {
443         union acpi_operand_object *internal_object;
444
445         ACPI_FUNCTION_TRACE(ut_copy_esimple_to_isimple);
446
447         /*
448          * Simple types supported are: String, Buffer, Integer
449          */
450         switch (external_object->type) {
451         case ACPI_TYPE_STRING:
452         case ACPI_TYPE_BUFFER:
453         case ACPI_TYPE_INTEGER:
454
455                 internal_object = acpi_ut_create_internal_object((u8)
456                                                                  external_object->
457                                                                  type);
458                 if (!internal_object) {
459                         return_ACPI_STATUS(AE_NO_MEMORY);
460                 }
461                 break;
462
463         default:
464                 /* All other types are not supported */
465
466                 return_ACPI_STATUS(AE_SUPPORT);
467         }
468
469         /* Must COPY string and buffer contents */
470
471         switch (external_object->type) {
472         case ACPI_TYPE_STRING:
473
474                 internal_object->string.pointer =
475                     ACPI_ALLOCATE_ZEROED((acpi_size) external_object->string.
476                                          length + 1);
477                 if (!internal_object->string.pointer) {
478                         goto error_exit;
479                 }
480
481                 ACPI_MEMCPY(internal_object->string.pointer,
482                             external_object->string.pointer,
483                             external_object->string.length);
484
485                 internal_object->string.length = external_object->string.length;
486                 break;
487
488         case ACPI_TYPE_BUFFER:
489
490                 internal_object->buffer.pointer =
491                     ACPI_ALLOCATE_ZEROED(external_object->buffer.length);
492                 if (!internal_object->buffer.pointer) {
493                         goto error_exit;
494                 }
495
496                 ACPI_MEMCPY(internal_object->buffer.pointer,
497                             external_object->buffer.pointer,
498                             external_object->buffer.length);
499
500                 internal_object->buffer.length = external_object->buffer.length;
501                 break;
502
503         case ACPI_TYPE_INTEGER:
504
505                 internal_object->integer.value = external_object->integer.value;
506                 break;
507
508         default:
509                 /* Other types can't get here */
510                 break;
511         }
512
513         *ret_internal_object = internal_object;
514         return_ACPI_STATUS(AE_OK);
515
516       error_exit:
517         acpi_ut_remove_reference(internal_object);
518         return_ACPI_STATUS(AE_NO_MEMORY);
519 }
520
521 #ifdef ACPI_FUTURE_IMPLEMENTATION
522 /* Code to convert packages that are parameters to control methods */
523
524 /*******************************************************************************
525  *
526  * FUNCTION:    acpi_ut_copy_epackage_to_ipackage
527  *
528  * PARAMETERS:  *internal_object   - Pointer to the object we are returning
529  *              *Buffer            - Where the object is returned
530  *              *space_used        - Where the length of the object is returned
531  *
532  * RETURN:      Status
533  *
534  * DESCRIPTION: This function is called to place a package object in a user
535  *              buffer.  A package object by definition contains other objects.
536  *
537  *              The buffer is assumed to have sufficient space for the object.
538  *              The caller must have verified the buffer length needed using the
539  *              acpi_ut_get_object_size function before calling this function.
540  *
541  ******************************************************************************/
542
543 static acpi_status
544 acpi_ut_copy_epackage_to_ipackage(union acpi_operand_object *internal_object,
545                                   u8 * buffer, u32 * space_used)
546 {
547         u8 *free_space;
548         union acpi_object *external_object;
549         u32 length = 0;
550         u32 this_index;
551         u32 object_space = 0;
552         union acpi_operand_object *this_internal_obj;
553         union acpi_object *this_external_obj;
554
555         ACPI_FUNCTION_TRACE(ut_copy_epackage_to_ipackage);
556
557         /*
558          * First package at head of the buffer
559          */
560         external_object = (union acpi_object *)buffer;
561
562         /*
563          * Free space begins right after the first package
564          */
565         free_space = buffer + sizeof(union acpi_object);
566
567         external_object->type = ACPI_GET_OBJECT_TYPE(internal_object);
568         external_object->package.count = internal_object->package.count;
569         external_object->package.elements = (union acpi_object *)free_space;
570
571         /*
572          * Build an array of ACPI_OBJECTS in the buffer
573          * and move the free space past it
574          */
575         free_space +=
576             external_object->package.count * sizeof(union acpi_object);
577
578         /* Call walk_package */
579
580 }
581
582 #endif                          /* Future implementation */
583
584 /*******************************************************************************
585  *
586  * FUNCTION:    acpi_ut_copy_eobject_to_iobject
587  *
588  * PARAMETERS:  *internal_object   - The external object to be converted
589  *              *buffer_ptr     - Where the internal object is returned
590  *
591  * RETURN:      Status          - the status of the call
592  *
593  * DESCRIPTION: Converts an external object to an internal object.
594  *
595  ******************************************************************************/
596
597 acpi_status
598 acpi_ut_copy_eobject_to_iobject(union acpi_object *external_object,
599                                 union acpi_operand_object **internal_object)
600 {
601         acpi_status status;
602
603         ACPI_FUNCTION_TRACE(ut_copy_eobject_to_iobject);
604
605         if (external_object->type == ACPI_TYPE_PACKAGE) {
606                 /*
607                  * Packages as external input to control methods are not supported,
608                  */
609                 ACPI_ERROR((AE_INFO,
610                             "Packages as parameters not implemented!"));
611
612                 return_ACPI_STATUS(AE_NOT_IMPLEMENTED);
613         }
614
615         else {
616                 /*
617                  * Build a simple object (no nested objects)
618                  */
619                 status =
620                     acpi_ut_copy_esimple_to_isimple(external_object,
621                                                     internal_object);
622         }
623
624         return_ACPI_STATUS(status);
625 }
626
627 /*******************************************************************************
628  *
629  * FUNCTION:    acpi_ut_copy_simple_object
630  *
631  * PARAMETERS:  source_desc         - The internal object to be copied
632  *              dest_desc           - New target object
633  *
634  * RETURN:      Status
635  *
636  * DESCRIPTION: Simple copy of one internal object to another.  Reference count
637  *              of the destination object is preserved.
638  *
639  ******************************************************************************/
640
641 static acpi_status
642 acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
643                            union acpi_operand_object *dest_desc)
644 {
645         u16 reference_count;
646         union acpi_operand_object *next_object;
647
648         /* Save fields from destination that we don't want to overwrite */
649
650         reference_count = dest_desc->common.reference_count;
651         next_object = dest_desc->common.next_object;
652
653         /* Copy the entire source object over the destination object */
654
655         ACPI_MEMCPY((char *)dest_desc, (char *)source_desc,
656                     sizeof(union acpi_operand_object));
657
658         /* Restore the saved fields */
659
660         dest_desc->common.reference_count = reference_count;
661         dest_desc->common.next_object = next_object;
662
663         /* New object is not static, regardless of source */
664
665         dest_desc->common.flags &= ~AOPOBJ_STATIC_POINTER;
666
667         /* Handle the objects with extra data */
668
669         switch (ACPI_GET_OBJECT_TYPE(dest_desc)) {
670         case ACPI_TYPE_BUFFER:
671                 /*
672                  * Allocate and copy the actual buffer if and only if:
673                  * 1) There is a valid buffer pointer
674                  * 2) The buffer has a length > 0
675                  */
676                 if ((source_desc->buffer.pointer) &&
677                     (source_desc->buffer.length)) {
678                         dest_desc->buffer.pointer =
679                             ACPI_ALLOCATE(source_desc->buffer.length);
680                         if (!dest_desc->buffer.pointer) {
681                                 return (AE_NO_MEMORY);
682                         }
683
684                         /* Copy the actual buffer data */
685
686                         ACPI_MEMCPY(dest_desc->buffer.pointer,
687                                     source_desc->buffer.pointer,
688                                     source_desc->buffer.length);
689                 }
690                 break;
691
692         case ACPI_TYPE_STRING:
693                 /*
694                  * Allocate and copy the actual string if and only if:
695                  * 1) There is a valid string pointer
696                  * (Pointer to a NULL string is allowed)
697                  */
698                 if (source_desc->string.pointer) {
699                         dest_desc->string.pointer =
700                             ACPI_ALLOCATE((acpi_size) source_desc->string.
701                                           length + 1);
702                         if (!dest_desc->string.pointer) {
703                                 return (AE_NO_MEMORY);
704                         }
705
706                         /* Copy the actual string data */
707
708                         ACPI_MEMCPY(dest_desc->string.pointer,
709                                     source_desc->string.pointer,
710                                     (acpi_size) source_desc->string.length + 1);
711                 }
712                 break;
713
714         case ACPI_TYPE_LOCAL_REFERENCE:
715                 /*
716                  * We copied the reference object, so we now must add a reference
717                  * to the object pointed to by the reference
718                  */
719                 acpi_ut_add_reference(source_desc->reference.object);
720                 break;
721
722         case ACPI_TYPE_REGION:
723                 /*
724                  * We copied the Region Handler, so we now must add a reference
725                  */
726                 if (dest_desc->region.handler) {
727                         acpi_ut_add_reference(dest_desc->region.handler);
728                 }
729                 break;
730
731         default:
732                 /* Nothing to do for other simple objects */
733                 break;
734         }
735
736         return (AE_OK);
737 }
738
739 /*******************************************************************************
740  *
741  * FUNCTION:    acpi_ut_copy_ielement_to_ielement
742  *
743  * PARAMETERS:  acpi_pkg_callback
744  *
745  * RETURN:      Status
746  *
747  * DESCRIPTION: Copy one package element to another package element
748  *
749  ******************************************************************************/
750
751 static acpi_status
752 acpi_ut_copy_ielement_to_ielement(u8 object_type,
753                                   union acpi_operand_object *source_object,
754                                   union acpi_generic_state *state,
755                                   void *context)
756 {
757         acpi_status status = AE_OK;
758         u32 this_index;
759         union acpi_operand_object **this_target_ptr;
760         union acpi_operand_object *target_object;
761
762         ACPI_FUNCTION_ENTRY();
763
764         this_index = state->pkg.index;
765         this_target_ptr = (union acpi_operand_object **)
766             &state->pkg.dest_object->package.elements[this_index];
767
768         switch (object_type) {
769         case ACPI_COPY_TYPE_SIMPLE:
770
771                 /* A null source object indicates a (legal) null package element */
772
773                 if (source_object) {
774                         /*
775                          * This is a simple object, just copy it
776                          */
777                         target_object =
778                             acpi_ut_create_internal_object(ACPI_GET_OBJECT_TYPE
779                                                            (source_object));
780                         if (!target_object) {
781                                 return (AE_NO_MEMORY);
782                         }
783
784                         status =
785                             acpi_ut_copy_simple_object(source_object,
786                                                        target_object);
787                         if (ACPI_FAILURE(status)) {
788                                 goto error_exit;
789                         }
790
791                         *this_target_ptr = target_object;
792                 } else {
793                         /* Pass through a null element */
794
795                         *this_target_ptr = NULL;
796                 }
797                 break;
798
799         case ACPI_COPY_TYPE_PACKAGE:
800
801                 /*
802                  * This object is a package - go down another nesting level
803                  * Create and build the package object
804                  */
805                 target_object =
806                     acpi_ut_create_internal_object(ACPI_TYPE_PACKAGE);
807                 if (!target_object) {
808                         return (AE_NO_MEMORY);
809                 }
810
811                 target_object->package.count = source_object->package.count;
812                 target_object->common.flags = source_object->common.flags;
813
814                 /*
815                  * Create the object array
816                  */
817                 target_object->package.elements =
818                     ACPI_ALLOCATE_ZEROED(((acpi_size) source_object->package.
819                                           count + 1) * sizeof(void *));
820                 if (!target_object->package.elements) {
821                         status = AE_NO_MEMORY;
822                         goto error_exit;
823                 }
824
825                 /*
826                  * Pass the new package object back to the package walk routine
827                  */
828                 state->pkg.this_target_obj = target_object;
829
830                 /*
831                  * Store the object pointer in the parent package object
832                  */
833                 *this_target_ptr = target_object;
834                 break;
835
836         default:
837                 return (AE_BAD_PARAMETER);
838         }
839
840         return (status);
841
842       error_exit:
843         acpi_ut_remove_reference(target_object);
844         return (status);
845 }
846
847 /*******************************************************************************
848  *
849  * FUNCTION:    acpi_ut_copy_ipackage_to_ipackage
850  *
851  * PARAMETERS:  *source_obj     - Pointer to the source package object
852  *              *dest_obj       - Where the internal object is returned
853  *
854  * RETURN:      Status          - the status of the call
855  *
856  * DESCRIPTION: This function is called to copy an internal package object
857  *              into another internal package object.
858  *
859  ******************************************************************************/
860
861 static acpi_status
862 acpi_ut_copy_ipackage_to_ipackage(union acpi_operand_object *source_obj,
863                                   union acpi_operand_object *dest_obj,
864                                   struct acpi_walk_state *walk_state)
865 {
866         acpi_status status = AE_OK;
867
868         ACPI_FUNCTION_TRACE(ut_copy_ipackage_to_ipackage);
869
870         dest_obj->common.type = ACPI_GET_OBJECT_TYPE(source_obj);
871         dest_obj->common.flags = source_obj->common.flags;
872         dest_obj->package.count = source_obj->package.count;
873
874         /*
875          * Create the object array and walk the source package tree
876          */
877         dest_obj->package.elements = ACPI_ALLOCATE_ZEROED(((acpi_size)
878                                                            source_obj->package.
879                                                            count +
880                                                            1) * sizeof(void *));
881         if (!dest_obj->package.elements) {
882                 ACPI_ERROR((AE_INFO, "Package allocation failure"));
883                 return_ACPI_STATUS(AE_NO_MEMORY);
884         }
885
886         /*
887          * Copy the package element-by-element by walking the package "tree".
888          * This handles nested packages of arbitrary depth.
889          */
890         status = acpi_ut_walk_package_tree(source_obj, dest_obj,
891                                            acpi_ut_copy_ielement_to_ielement,
892                                            walk_state);
893         if (ACPI_FAILURE(status)) {
894
895                 /* On failure, delete the destination package object */
896
897                 acpi_ut_remove_reference(dest_obj);
898         }
899
900         return_ACPI_STATUS(status);
901 }
902
903 /*******************************************************************************
904  *
905  * FUNCTION:    acpi_ut_copy_iobject_to_iobject
906  *
907  * PARAMETERS:  walk_state          - Current walk state
908  *              source_desc         - The internal object to be copied
909  *              dest_desc           - Where the copied object is returned
910  *
911  * RETURN:      Status
912  *
913  * DESCRIPTION: Copy an internal object to a new internal object
914  *
915  ******************************************************************************/
916
917 acpi_status
918 acpi_ut_copy_iobject_to_iobject(union acpi_operand_object *source_desc,
919                                 union acpi_operand_object **dest_desc,
920                                 struct acpi_walk_state *walk_state)
921 {
922         acpi_status status = AE_OK;
923
924         ACPI_FUNCTION_TRACE(ut_copy_iobject_to_iobject);
925
926         /* Create the top level object */
927
928         *dest_desc =
929             acpi_ut_create_internal_object(ACPI_GET_OBJECT_TYPE(source_desc));
930         if (!*dest_desc) {
931                 return_ACPI_STATUS(AE_NO_MEMORY);
932         }
933
934         /* Copy the object and possible subobjects */
935
936         if (ACPI_GET_OBJECT_TYPE(source_desc) == ACPI_TYPE_PACKAGE) {
937                 status =
938                     acpi_ut_copy_ipackage_to_ipackage(source_desc, *dest_desc,
939                                                       walk_state);
940         } else {
941                 status = acpi_ut_copy_simple_object(source_desc, *dest_desc);
942         }
943
944         return_ACPI_STATUS(status);
945 }