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