]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - drivers/acpi/utilities/utmisc.c
ACPI: ACPICA 20060331
[mirror_ubuntu-zesty-kernel.git] / drivers / acpi / utilities / utmisc.c
1 /*******************************************************************************
2 *
3 * Module Name: utmisc - common utility procedures
4 *
5 ******************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2006, 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/acnamesp.h>
46
47 #define _COMPONENT ACPI_UTILITIES
48 ACPI_MODULE_NAME("utmisc")
49
50 /*******************************************************************************
51 *
52 * FUNCTION: acpi_ut_is_aml_table
53 *
54 * PARAMETERS: Table - An ACPI table
55 *
56 * RETURN: TRUE if table contains executable AML; FALSE otherwise
57 *
58 * DESCRIPTION: Check ACPI Signature for a table that contains AML code.
59 * Currently, these are DSDT,SSDT,PSDT. All other table types are
60 * data tables that do not contain AML code.
61 *
62 ******************************************************************************/
63 u8 acpi_ut_is_aml_table(struct acpi_table_header *table)
64 {
65
66 /* Ignore tables that contain AML */
67
68 if (ACPI_COMPARE_NAME(table->signature, DSDT_SIG) ||
69 ACPI_COMPARE_NAME(table->signature, PSDT_SIG) ||
70 ACPI_COMPARE_NAME(table->signature, SSDT_SIG)) {
71 return (TRUE);
72 }
73
74 return (FALSE);
75 }
76
77 /*******************************************************************************
78 *
79 * FUNCTION: acpi_ut_allocate_owner_id
80 *
81 * PARAMETERS: owner_id - Where the new owner ID is returned
82 *
83 * RETURN: Status
84 *
85 * DESCRIPTION: Allocate a table or method owner ID. The owner ID is used to
86 * track objects created by the table or method, to be deleted
87 * when the method exits or the table is unloaded.
88 *
89 ******************************************************************************/
90
91 acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id)
92 {
93 acpi_native_uint i;
94 acpi_native_uint j;
95 acpi_native_uint k;
96 acpi_status status;
97
98 ACPI_FUNCTION_TRACE("ut_allocate_owner_id");
99
100 /* Guard against multiple allocations of ID to the same location */
101
102 if (*owner_id) {
103 ACPI_ERROR((AE_INFO, "Owner ID [%2.2X] already exists",
104 *owner_id));
105 return_ACPI_STATUS(AE_ALREADY_EXISTS);
106 }
107
108 /* Mutex for the global ID mask */
109
110 status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES);
111 if (ACPI_FAILURE(status)) {
112 return_ACPI_STATUS(status);
113 }
114
115 /*
116 * Find a free owner ID, cycle through all possible IDs on repeated
117 * allocations. (ACPI_NUM_OWNERID_MASKS + 1) because first index may have
118 * to be scanned twice.
119 */
120 for (i = 0, j = acpi_gbl_last_owner_id_index;
121 i < (ACPI_NUM_OWNERID_MASKS + 1); i++, j++) {
122 if (j >= ACPI_NUM_OWNERID_MASKS) {
123 j = 0; /* Wraparound to start of mask array */
124 }
125
126 for (k = acpi_gbl_next_owner_id_offset; k < 32; k++) {
127 if (acpi_gbl_owner_id_mask[j] == ACPI_UINT32_MAX) {
128
129 /* There are no free IDs in this mask */
130
131 break;
132 }
133
134 if (!(acpi_gbl_owner_id_mask[j] & (1 << k))) {
135 /*
136 * Found a free ID. The actual ID is the bit index plus one,
137 * making zero an invalid Owner ID. Save this as the last ID
138 * allocated and update the global ID mask.
139 */
140 acpi_gbl_owner_id_mask[j] |= (1 << k);
141
142 acpi_gbl_last_owner_id_index = (u8) j;
143 acpi_gbl_next_owner_id_offset = (u8) (k + 1);
144
145 /*
146 * Construct encoded ID from the index and bit position
147 *
148 * Note: Last [j].k (bit 255) is never used and is marked
149 * permanently allocated (prevents +1 overflow)
150 */
151 *owner_id =
152 (acpi_owner_id) ((k + 1) + ACPI_MUL_32(j));
153
154 ACPI_DEBUG_PRINT((ACPI_DB_VALUES,
155 "Allocated owner_id: %2.2X\n",
156 (unsigned int)*owner_id));
157 goto exit;
158 }
159 }
160
161 acpi_gbl_next_owner_id_offset = 0;
162 }
163
164 /*
165 * All owner_ids have been allocated. This typically should
166 * not happen since the IDs are reused after deallocation. The IDs are
167 * allocated upon table load (one per table) and method execution, and
168 * they are released when a table is unloaded or a method completes
169 * execution.
170 *
171 * If this error happens, there may be very deep nesting of invoked control
172 * methods, or there may be a bug where the IDs are not released.
173 */
174 status = AE_OWNER_ID_LIMIT;
175 ACPI_ERROR((AE_INFO,
176 "Could not allocate new owner_id (255 max), AE_OWNER_ID_LIMIT"));
177
178 exit:
179 (void)acpi_ut_release_mutex(ACPI_MTX_CACHES);
180 return_ACPI_STATUS(status);
181 }
182
183 /*******************************************************************************
184 *
185 * FUNCTION: acpi_ut_release_owner_id
186 *
187 * PARAMETERS: owner_id_ptr - Pointer to a previously allocated owner_iD
188 *
189 * RETURN: None. No error is returned because we are either exiting a
190 * control method or unloading a table. Either way, we would
191 * ignore any error anyway.
192 *
193 * DESCRIPTION: Release a table or method owner ID. Valid IDs are 1 - 255
194 *
195 ******************************************************************************/
196
197 void acpi_ut_release_owner_id(acpi_owner_id * owner_id_ptr)
198 {
199 acpi_owner_id owner_id = *owner_id_ptr;
200 acpi_status status;
201 acpi_native_uint index;
202 u32 bit;
203
204 ACPI_FUNCTION_TRACE_U32("ut_release_owner_id", owner_id);
205
206 /* Always clear the input owner_id (zero is an invalid ID) */
207
208 *owner_id_ptr = 0;
209
210 /* Zero is not a valid owner_iD */
211
212 if (owner_id == 0) {
213 ACPI_ERROR((AE_INFO, "Invalid owner_id: %2.2X", owner_id));
214 return_VOID;
215 }
216
217 /* Mutex for the global ID mask */
218
219 status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES);
220 if (ACPI_FAILURE(status)) {
221 return_VOID;
222 }
223
224 /* Normalize the ID to zero */
225
226 owner_id--;
227
228 /* Decode ID to index/offset pair */
229
230 index = ACPI_DIV_32(owner_id);
231 bit = 1 << ACPI_MOD_32(owner_id);
232
233 /* Free the owner ID only if it is valid */
234
235 if (acpi_gbl_owner_id_mask[index] & bit) {
236 acpi_gbl_owner_id_mask[index] ^= bit;
237 } else {
238 ACPI_ERROR((AE_INFO,
239 "Release of non-allocated owner_id: %2.2X",
240 owner_id + 1));
241 }
242
243 (void)acpi_ut_release_mutex(ACPI_MTX_CACHES);
244 return_VOID;
245 }
246
247 /*******************************************************************************
248 *
249 * FUNCTION: acpi_ut_strupr (strupr)
250 *
251 * PARAMETERS: src_string - The source string to convert
252 *
253 * RETURN: None
254 *
255 * DESCRIPTION: Convert string to uppercase
256 *
257 * NOTE: This is not a POSIX function, so it appears here, not in utclib.c
258 *
259 ******************************************************************************/
260
261 void acpi_ut_strupr(char *src_string)
262 {
263 char *string;
264
265 ACPI_FUNCTION_ENTRY();
266
267 if (!src_string) {
268 return;
269 }
270
271 /* Walk entire string, uppercasing the letters */
272
273 for (string = src_string; *string; string++) {
274 *string = (char)ACPI_TOUPPER(*string);
275 }
276
277 return;
278 }
279
280 /*******************************************************************************
281 *
282 * FUNCTION: acpi_ut_print_string
283 *
284 * PARAMETERS: String - Null terminated ASCII string
285 * max_length - Maximum output length
286 *
287 * RETURN: None
288 *
289 * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape
290 * sequences.
291 *
292 ******************************************************************************/
293
294 void acpi_ut_print_string(char *string, u8 max_length)
295 {
296 u32 i;
297
298 if (!string) {
299 acpi_os_printf("<\"NULL STRING PTR\">");
300 return;
301 }
302
303 acpi_os_printf("\"");
304 for (i = 0; string[i] && (i < max_length); i++) {
305
306 /* Escape sequences */
307
308 switch (string[i]) {
309 case 0x07:
310 acpi_os_printf("\\a"); /* BELL */
311 break;
312
313 case 0x08:
314 acpi_os_printf("\\b"); /* BACKSPACE */
315 break;
316
317 case 0x0C:
318 acpi_os_printf("\\f"); /* FORMFEED */
319 break;
320
321 case 0x0A:
322 acpi_os_printf("\\n"); /* LINEFEED */
323 break;
324
325 case 0x0D:
326 acpi_os_printf("\\r"); /* CARRIAGE RETURN */
327 break;
328
329 case 0x09:
330 acpi_os_printf("\\t"); /* HORIZONTAL TAB */
331 break;
332
333 case 0x0B:
334 acpi_os_printf("\\v"); /* VERTICAL TAB */
335 break;
336
337 case '\'': /* Single Quote */
338 case '\"': /* Double Quote */
339 case '\\': /* Backslash */
340 acpi_os_printf("\\%c", (int)string[i]);
341 break;
342
343 default:
344
345 /* Check for printable character or hex escape */
346
347 if (ACPI_IS_PRINT(string[i])) {
348 /* This is a normal character */
349
350 acpi_os_printf("%c", (int)string[i]);
351 } else {
352 /* All others will be Hex escapes */
353
354 acpi_os_printf("\\x%2.2X", (s32) string[i]);
355 }
356 break;
357 }
358 }
359 acpi_os_printf("\"");
360
361 if (i == max_length && string[i]) {
362 acpi_os_printf("...");
363 }
364 }
365
366 /*******************************************************************************
367 *
368 * FUNCTION: acpi_ut_dword_byte_swap
369 *
370 * PARAMETERS: Value - Value to be converted
371 *
372 * RETURN: u32 integer with bytes swapped
373 *
374 * DESCRIPTION: Convert a 32-bit value to big-endian (swap the bytes)
375 *
376 ******************************************************************************/
377
378 u32 acpi_ut_dword_byte_swap(u32 value)
379 {
380 union {
381 u32 value;
382 u8 bytes[4];
383 } out;
384 union {
385 u32 value;
386 u8 bytes[4];
387 } in;
388
389 ACPI_FUNCTION_ENTRY();
390
391 in.value = value;
392
393 out.bytes[0] = in.bytes[3];
394 out.bytes[1] = in.bytes[2];
395 out.bytes[2] = in.bytes[1];
396 out.bytes[3] = in.bytes[0];
397
398 return (out.value);
399 }
400
401 /*******************************************************************************
402 *
403 * FUNCTION: acpi_ut_set_integer_width
404 *
405 * PARAMETERS: Revision From DSDT header
406 *
407 * RETURN: None
408 *
409 * DESCRIPTION: Set the global integer bit width based upon the revision
410 * of the DSDT. For Revision 1 and 0, Integers are 32 bits.
411 * For Revision 2 and above, Integers are 64 bits. Yes, this
412 * makes a difference.
413 *
414 ******************************************************************************/
415
416 void acpi_ut_set_integer_width(u8 revision)
417 {
418
419 if (revision <= 1) {
420 acpi_gbl_integer_bit_width = 32;
421 acpi_gbl_integer_nybble_width = 8;
422 acpi_gbl_integer_byte_width = 4;
423 } else {
424 acpi_gbl_integer_bit_width = 64;
425 acpi_gbl_integer_nybble_width = 16;
426 acpi_gbl_integer_byte_width = 8;
427 }
428 }
429
430 #ifdef ACPI_DEBUG_OUTPUT
431 /*******************************************************************************
432 *
433 * FUNCTION: acpi_ut_display_init_pathname
434 *
435 * PARAMETERS: Type - Object type of the node
436 * obj_handle - Handle whose pathname will be displayed
437 * Path - Additional path string to be appended.
438 * (NULL if no extra path)
439 *
440 * RETURN: acpi_status
441 *
442 * DESCRIPTION: Display full pathname of an object, DEBUG ONLY
443 *
444 ******************************************************************************/
445
446 void
447 acpi_ut_display_init_pathname(u8 type,
448 struct acpi_namespace_node *obj_handle,
449 char *path)
450 {
451 acpi_status status;
452 struct acpi_buffer buffer;
453
454 ACPI_FUNCTION_ENTRY();
455
456 /* Only print the path if the appropriate debug level is enabled */
457
458 if (!(acpi_dbg_level & ACPI_LV_INIT_NAMES)) {
459 return;
460 }
461
462 /* Get the full pathname to the node */
463
464 buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
465 status = acpi_ns_handle_to_pathname(obj_handle, &buffer);
466 if (ACPI_FAILURE(status)) {
467 return;
468 }
469
470 /* Print what we're doing */
471
472 switch (type) {
473 case ACPI_TYPE_METHOD:
474 acpi_os_printf("Executing ");
475 break;
476
477 default:
478 acpi_os_printf("Initializing ");
479 break;
480 }
481
482 /* Print the object type and pathname */
483
484 acpi_os_printf("%-12s %s",
485 acpi_ut_get_type_name(type), (char *)buffer.pointer);
486
487 /* Extra path is used to append names like _STA, _INI, etc. */
488
489 if (path) {
490 acpi_os_printf(".%s", path);
491 }
492 acpi_os_printf("\n");
493
494 ACPI_FREE(buffer.pointer);
495 }
496 #endif
497
498 /*******************************************************************************
499 *
500 * FUNCTION: acpi_ut_valid_acpi_char
501 *
502 * PARAMETERS: Char - The character to be examined
503 *
504 * RETURN: TRUE if the character is valid, FALSE otherwise
505 *
506 * DESCRIPTION: Check for a valid ACPI character. Must be one of:
507 * 1) Upper case alpha
508 * 2) numeric
509 * 3) underscore
510 *
511 * We allow a '!' as the last character because of the ASF! table
512 *
513 ******************************************************************************/
514
515 u8 acpi_ut_valid_acpi_char(char character, acpi_native_uint position)
516 {
517
518 if (!((character >= 'A' && character <= 'Z') ||
519 (character >= '0' && character <= '9') || (character == '_'))) {
520
521 /* Allow a '!' in the last position */
522
523 if (character == '!' && position == 3) {
524 return (TRUE);
525 }
526
527 return (FALSE);
528 }
529
530 return (TRUE);
531 }
532
533 /*******************************************************************************
534 *
535 * FUNCTION: acpi_ut_valid_acpi_name
536 *
537 * PARAMETERS: Name - The name to be examined
538 *
539 * RETURN: TRUE if the name is valid, FALSE otherwise
540 *
541 * DESCRIPTION: Check for a valid ACPI name. Each character must be one of:
542 * 1) Upper case alpha
543 * 2) numeric
544 * 3) underscore
545 *
546 ******************************************************************************/
547
548 u8 acpi_ut_valid_acpi_name(u32 name)
549 {
550 acpi_native_uint i;
551
552 ACPI_FUNCTION_ENTRY();
553
554 for (i = 0; i < ACPI_NAME_SIZE; i++) {
555 if (!acpi_ut_valid_acpi_char
556 ((ACPI_CAST_PTR(char, &name))[i], i)) {
557 return (FALSE);
558 }
559 }
560
561 return (TRUE);
562 }
563
564 /*******************************************************************************
565 *
566 * FUNCTION: acpi_ut_repair_name
567 *
568 * PARAMETERS: Name - The ACPI name to be repaired
569 *
570 * RETURN: Repaired version of the name
571 *
572 * DESCRIPTION: Repair an ACPI name: Change invalid characters to '*' and
573 * return the new name.
574 *
575 ******************************************************************************/
576
577 acpi_name acpi_ut_repair_name(acpi_name name)
578 {
579 char *name_ptr = ACPI_CAST_PTR(char, &name);
580 char new_name[ACPI_NAME_SIZE];
581 acpi_native_uint i;
582
583 for (i = 0; i < ACPI_NAME_SIZE; i++) {
584 new_name[i] = name_ptr[i];
585
586 /*
587 * Replace a bad character with something printable, yet technically
588 * still invalid. This prevents any collisions with existing "good"
589 * names in the namespace.
590 */
591 if (!acpi_ut_valid_acpi_char(name_ptr[i], i)) {
592 new_name[i] = '*';
593 }
594 }
595
596 return (*ACPI_CAST_PTR(u32, new_name));
597 }
598
599 /*******************************************************************************
600 *
601 * FUNCTION: acpi_ut_strtoul64
602 *
603 * PARAMETERS: String - Null terminated string
604 * Base - Radix of the string: 10, 16, or ACPI_ANY_BASE
605 * ret_integer - Where the converted integer is returned
606 *
607 * RETURN: Status and Converted value
608 *
609 * DESCRIPTION: Convert a string into an unsigned value.
610 * NOTE: Does not support Octal strings, not needed.
611 *
612 ******************************************************************************/
613
614 acpi_status
615 acpi_ut_strtoul64(char *string, u32 base, acpi_integer * ret_integer)
616 {
617 u32 this_digit = 0;
618 acpi_integer return_value = 0;
619 acpi_integer quotient;
620
621 ACPI_FUNCTION_TRACE("ut_stroul64");
622
623 if ((!string) || !(*string)) {
624 goto error_exit;
625 }
626
627 switch (base) {
628 case ACPI_ANY_BASE:
629 case 10:
630 case 16:
631 break;
632
633 default:
634 /* Invalid Base */
635 return_ACPI_STATUS(AE_BAD_PARAMETER);
636 }
637
638 /* Skip over any white space in the buffer */
639
640 while (ACPI_IS_SPACE(*string) || *string == '\t') {
641 string++;
642 }
643
644 /*
645 * If the input parameter Base is zero, then we need to
646 * determine if it is decimal or hexadecimal:
647 */
648 if (base == 0) {
649 if ((*string == '0') && (ACPI_TOLOWER(*(string + 1)) == 'x')) {
650 base = 16;
651 string += 2;
652 } else {
653 base = 10;
654 }
655 }
656
657 /*
658 * For hexadecimal base, skip over the leading
659 * 0 or 0x, if they are present.
660 */
661 if ((base == 16) &&
662 (*string == '0') && (ACPI_TOLOWER(*(string + 1)) == 'x')) {
663 string += 2;
664 }
665
666 /* Any string left? */
667
668 if (!(*string)) {
669 goto error_exit;
670 }
671
672 /* Main loop: convert the string to a 64-bit integer */
673
674 while (*string) {
675 if (ACPI_IS_DIGIT(*string)) {
676
677 /* Convert ASCII 0-9 to Decimal value */
678
679 this_digit = ((u8) * string) - '0';
680 } else {
681 if (base == 10) {
682
683 /* Digit is out of range */
684
685 goto error_exit;
686 }
687
688 this_digit = (u8) ACPI_TOUPPER(*string);
689 if (ACPI_IS_XDIGIT((char)this_digit)) {
690
691 /* Convert ASCII Hex char to value */
692
693 this_digit = this_digit - 'A' + 10;
694 } else {
695 /*
696 * We allow non-hex chars, just stop now, same as end-of-string.
697 * See ACPI spec, string-to-integer conversion.
698 */
699 break;
700 }
701 }
702
703 /* Divide the digit into the correct position */
704
705 (void)
706 acpi_ut_short_divide((ACPI_INTEGER_MAX -
707 (acpi_integer) this_digit), base,
708 &quotient, NULL);
709 if (return_value > quotient) {
710 goto error_exit;
711 }
712
713 return_value *= base;
714 return_value += this_digit;
715 string++;
716 }
717
718 /* All done, normal exit */
719
720 *ret_integer = return_value;
721 return_ACPI_STATUS(AE_OK);
722
723 error_exit:
724 /* Base was set/validated above */
725
726 if (base == 10) {
727 return_ACPI_STATUS(AE_BAD_DECIMAL_CONSTANT);
728 } else {
729 return_ACPI_STATUS(AE_BAD_HEX_CONSTANT);
730 }
731 }
732
733 /*******************************************************************************
734 *
735 * FUNCTION: acpi_ut_create_update_state_and_push
736 *
737 * PARAMETERS: Object - Object to be added to the new state
738 * Action - Increment/Decrement
739 * state_list - List the state will be added to
740 *
741 * RETURN: Status
742 *
743 * DESCRIPTION: Create a new state and push it
744 *
745 ******************************************************************************/
746
747 acpi_status
748 acpi_ut_create_update_state_and_push(union acpi_operand_object *object,
749 u16 action,
750 union acpi_generic_state **state_list)
751 {
752 union acpi_generic_state *state;
753
754 ACPI_FUNCTION_ENTRY();
755
756 /* Ignore null objects; these are expected */
757
758 if (!object) {
759 return (AE_OK);
760 }
761
762 state = acpi_ut_create_update_state(object, action);
763 if (!state) {
764 return (AE_NO_MEMORY);
765 }
766
767 acpi_ut_push_generic_state(state_list, state);
768 return (AE_OK);
769 }
770
771 /*******************************************************************************
772 *
773 * FUNCTION: acpi_ut_walk_package_tree
774 *
775 * PARAMETERS: source_object - The package to walk
776 * target_object - Target object (if package is being copied)
777 * walk_callback - Called once for each package element
778 * Context - Passed to the callback function
779 *
780 * RETURN: Status
781 *
782 * DESCRIPTION: Walk through a package
783 *
784 ******************************************************************************/
785
786 acpi_status
787 acpi_ut_walk_package_tree(union acpi_operand_object * source_object,
788 void *target_object,
789 acpi_pkg_callback walk_callback, void *context)
790 {
791 acpi_status status = AE_OK;
792 union acpi_generic_state *state_list = NULL;
793 union acpi_generic_state *state;
794 u32 this_index;
795 union acpi_operand_object *this_source_obj;
796
797 ACPI_FUNCTION_TRACE("ut_walk_package_tree");
798
799 state = acpi_ut_create_pkg_state(source_object, target_object, 0);
800 if (!state) {
801 return_ACPI_STATUS(AE_NO_MEMORY);
802 }
803
804 while (state) {
805
806 /* Get one element of the package */
807
808 this_index = state->pkg.index;
809 this_source_obj = (union acpi_operand_object *)
810 state->pkg.source_object->package.elements[this_index];
811
812 /*
813 * Check for:
814 * 1) An uninitialized package element. It is completely
815 * legal to declare a package and leave it uninitialized
816 * 2) Not an internal object - can be a namespace node instead
817 * 3) Any type other than a package. Packages are handled in else
818 * case below.
819 */
820 if ((!this_source_obj) ||
821 (ACPI_GET_DESCRIPTOR_TYPE(this_source_obj) !=
822 ACPI_DESC_TYPE_OPERAND)
823 || (ACPI_GET_OBJECT_TYPE(this_source_obj) !=
824 ACPI_TYPE_PACKAGE)) {
825 status =
826 walk_callback(ACPI_COPY_TYPE_SIMPLE,
827 this_source_obj, state, context);
828 if (ACPI_FAILURE(status)) {
829 return_ACPI_STATUS(status);
830 }
831
832 state->pkg.index++;
833 while (state->pkg.index >=
834 state->pkg.source_object->package.count) {
835 /*
836 * We've handled all of the objects at this level, This means
837 * that we have just completed a package. That package may
838 * have contained one or more packages itself.
839 *
840 * Delete this state and pop the previous state (package).
841 */
842 acpi_ut_delete_generic_state(state);
843 state = acpi_ut_pop_generic_state(&state_list);
844
845 /* Finished when there are no more states */
846
847 if (!state) {
848 /*
849 * We have handled all of the objects in the top level
850 * package just add the length of the package objects
851 * and exit
852 */
853 return_ACPI_STATUS(AE_OK);
854 }
855
856 /*
857 * Go back up a level and move the index past the just
858 * completed package object.
859 */
860 state->pkg.index++;
861 }
862 } else {
863 /* This is a subobject of type package */
864
865 status =
866 walk_callback(ACPI_COPY_TYPE_PACKAGE,
867 this_source_obj, state, context);
868 if (ACPI_FAILURE(status)) {
869 return_ACPI_STATUS(status);
870 }
871
872 /*
873 * Push the current state and create a new one
874 * The callback above returned a new target package object.
875 */
876 acpi_ut_push_generic_state(&state_list, state);
877 state = acpi_ut_create_pkg_state(this_source_obj,
878 state->pkg.
879 this_target_obj, 0);
880 if (!state) {
881 return_ACPI_STATUS(AE_NO_MEMORY);
882 }
883 }
884 }
885
886 /* We should never get here */
887
888 return_ACPI_STATUS(AE_AML_INTERNAL);
889 }
890
891 /*******************************************************************************
892 *
893 * FUNCTION: acpi_ut_error, acpi_ut_warning, acpi_ut_info
894 *
895 * PARAMETERS: module_name - Caller's module name (for error output)
896 * line_number - Caller's line number (for error output)
897 * Format - Printf format string + additional args
898 *
899 * RETURN: None
900 *
901 * DESCRIPTION: Print message with module/line/version info
902 *
903 ******************************************************************************/
904
905 void ACPI_INTERNAL_VAR_XFACE
906 acpi_ut_error(char *module_name, u32 line_number, char *format, ...)
907 {
908 va_list args;
909
910 acpi_os_printf("ACPI Error (%s-%04d): ", module_name, line_number);
911
912 va_start(args, format);
913 acpi_os_vprintf(format, args);
914 acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
915 }
916
917 void ACPI_INTERNAL_VAR_XFACE
918 acpi_ut_exception(char *module_name,
919 u32 line_number, acpi_status status, char *format, ...)
920 {
921 va_list args;
922
923 acpi_os_printf("ACPI Exception (%s-%04d): %s, ", module_name,
924 line_number, acpi_format_exception(status));
925
926 va_start(args, format);
927 acpi_os_vprintf(format, args);
928 acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
929 }
930
931 void ACPI_INTERNAL_VAR_XFACE
932 acpi_ut_warning(char *module_name, u32 line_number, char *format, ...)
933 {
934 va_list args;
935
936 acpi_os_printf("ACPI Warning (%s-%04d): ", module_name, line_number);
937
938 va_start(args, format);
939 acpi_os_vprintf(format, args);
940 acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
941 }
942
943 void ACPI_INTERNAL_VAR_XFACE
944 acpi_ut_info(char *module_name, u32 line_number, char *format, ...)
945 {
946 va_list args;
947
948 acpi_os_printf("ACPI (%s-%04d): ", module_name, line_number);
949
950 va_start(args, format);
951 acpi_os_vprintf(format, args);
952 acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
953 }