?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
FRV: Use generic show_interrupts()
[cris-mirror.git] / drivers / acpi / acpica / utcopy.c
blobaded299a2fa842210a7ee9c616ff321573f8c5c4
1 /******************************************************************************
2 *
3 * Module Name: utcopy - Internal to external object translation utilities
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2011, 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 }
CRIS linux kernel tree