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