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