Pull trivial into test branch
[linux-2.6] / drivers / acpi / utilities / utdebug.c
1 /******************************************************************************
2  *
3  * Module Name: utdebug - Debug print routines
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
46 #define _COMPONENT          ACPI_UTILITIES
47 ACPI_MODULE_NAME("utdebug")
48
49 #ifdef ACPI_DEBUG_OUTPUT
50 static acpi_thread_id acpi_gbl_prev_thread_id;
51 static char *acpi_gbl_fn_entry_str = "----Entry";
52 static char *acpi_gbl_fn_exit_str = "----Exit-";
53
54 /* Local prototypes */
55
56 static const char *acpi_ut_trim_function_name(const char *function_name);
57
58 /*******************************************************************************
59  *
60  * FUNCTION:    acpi_ut_init_stack_ptr_trace
61  *
62  * PARAMETERS:  None
63  *
64  * RETURN:      None
65  *
66  * DESCRIPTION: Save the current CPU stack pointer at subsystem startup
67  *
68  ******************************************************************************/
69
70 void acpi_ut_init_stack_ptr_trace(void)
71 {
72         u32 current_sp;
73
74         acpi_gbl_entry_stack_pointer = ACPI_PTR_DIFF(&current_sp, NULL);
75 }
76
77 /*******************************************************************************
78  *
79  * FUNCTION:    acpi_ut_track_stack_ptr
80  *
81  * PARAMETERS:  None
82  *
83  * RETURN:      None
84  *
85  * DESCRIPTION: Save the current CPU stack pointer
86  *
87  ******************************************************************************/
88
89 void acpi_ut_track_stack_ptr(void)
90 {
91         acpi_size current_sp;
92
93         current_sp = ACPI_PTR_DIFF(&current_sp, NULL);
94
95         if (current_sp < acpi_gbl_lowest_stack_pointer) {
96                 acpi_gbl_lowest_stack_pointer = current_sp;
97         }
98
99         if (acpi_gbl_nesting_level > acpi_gbl_deepest_nesting) {
100                 acpi_gbl_deepest_nesting = acpi_gbl_nesting_level;
101         }
102 }
103
104 /*******************************************************************************
105  *
106  * FUNCTION:    acpi_ut_trim_function_name
107  *
108  * PARAMETERS:  function_name       - Ascii string containing a procedure name
109  *
110  * RETURN:      Updated pointer to the function name
111  *
112  * DESCRIPTION: Remove the "Acpi" prefix from the function name, if present.
113  *              This allows compiler macros such as __FUNCTION__ to be used
114  *              with no change to the debug output.
115  *
116  ******************************************************************************/
117
118 static const char *acpi_ut_trim_function_name(const char *function_name)
119 {
120
121         /* All Function names are longer than 4 chars, check is safe */
122
123         if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_PREFIX_MIXED) {
124
125                 /* This is the case where the original source has not been modified */
126
127                 return (function_name + 4);
128         }
129
130         if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_PREFIX_LOWER) {
131
132                 /* This is the case where the source has been 'linuxized' */
133
134                 return (function_name + 5);
135         }
136
137         return (function_name);
138 }
139
140 /*******************************************************************************
141  *
142  * FUNCTION:    acpi_ut_debug_print
143  *
144  * PARAMETERS:  requested_debug_level - Requested debug print level
145  *              line_number         - Caller's line number (for error output)
146  *              function_name       - Caller's procedure name
147  *              module_name         - Caller's module name
148  *              component_id        - Caller's component ID
149  *              Format              - Printf format field
150  *              ...                 - Optional printf arguments
151  *
152  * RETURN:      None
153  *
154  * DESCRIPTION: Print error message with prefix consisting of the module name,
155  *              line number, and component ID.
156  *
157  ******************************************************************************/
158
159 void ACPI_INTERNAL_VAR_XFACE
160 acpi_ut_debug_print(u32 requested_debug_level,
161                     u32 line_number,
162                     const char *function_name,
163                     char *module_name, u32 component_id, char *format, ...)
164 {
165         acpi_thread_id thread_id;
166         va_list args;
167
168         /*
169          * Stay silent if the debug level or component ID is disabled
170          */
171         if (!(requested_debug_level & acpi_dbg_level) ||
172             !(component_id & acpi_dbg_layer)) {
173                 return;
174         }
175
176         /*
177          * Thread tracking and context switch notification
178          */
179         thread_id = acpi_os_get_thread_id();
180         if (thread_id != acpi_gbl_prev_thread_id) {
181                 if (ACPI_LV_THREADS & acpi_dbg_level) {
182                         acpi_os_printf
183                             ("\n**** Context Switch from TID %lX to TID %lX ****\n\n",
184                              (unsigned long) acpi_gbl_prev_thread_id,
185                              (unsigned long) thread_id);
186                 }
187
188                 acpi_gbl_prev_thread_id = thread_id;
189         }
190
191         /*
192          * Display the module name, current line number, thread ID (if requested),
193          * current procedure nesting level, and the current procedure name
194          */
195         acpi_os_printf("%8s-%04ld ", module_name, line_number);
196
197         if (ACPI_LV_THREADS & acpi_dbg_level) {
198                 acpi_os_printf("[%04lX] ", thread_id);
199         }
200
201         acpi_os_printf("[%02ld] %-22.22s: ",
202                        acpi_gbl_nesting_level,
203                        acpi_ut_trim_function_name(function_name));
204
205         va_start(args, format);
206         acpi_os_vprintf(format, args);
207 }
208
209 ACPI_EXPORT_SYMBOL(acpi_ut_debug_print)
210
211 /*******************************************************************************
212  *
213  * FUNCTION:    acpi_ut_debug_print_raw
214  *
215  * PARAMETERS:  requested_debug_level - Requested debug print level
216  *              line_number         - Caller's line number
217  *              function_name       - Caller's procedure name
218  *              module_name         - Caller's module name
219  *              component_id        - Caller's component ID
220  *              Format              - Printf format field
221  *              ...                 - Optional printf arguments
222  *
223  * RETURN:      None
224  *
225  * DESCRIPTION: Print message with no headers.  Has same interface as
226  *              debug_print so that the same macros can be used.
227  *
228  ******************************************************************************/
229 void ACPI_INTERNAL_VAR_XFACE
230 acpi_ut_debug_print_raw(u32 requested_debug_level,
231                         u32 line_number,
232                         const char *function_name,
233                         char *module_name, u32 component_id, char *format, ...)
234 {
235         va_list args;
236
237         if (!(requested_debug_level & acpi_dbg_level) ||
238             !(component_id & acpi_dbg_layer)) {
239                 return;
240         }
241
242         va_start(args, format);
243         acpi_os_vprintf(format, args);
244 }
245
246 ACPI_EXPORT_SYMBOL(acpi_ut_debug_print_raw)
247
248 /*******************************************************************************
249  *
250  * FUNCTION:    acpi_ut_trace
251  *
252  * PARAMETERS:  line_number         - Caller's line number
253  *              function_name       - Caller's procedure name
254  *              module_name         - Caller's module name
255  *              component_id        - Caller's component ID
256  *
257  * RETURN:      None
258  *
259  * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
260  *              set in debug_level
261  *
262  ******************************************************************************/
263 void
264 acpi_ut_trace(u32 line_number,
265               const char *function_name, char *module_name, u32 component_id)
266 {
267
268         acpi_gbl_nesting_level++;
269         acpi_ut_track_stack_ptr();
270
271         acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
272                             line_number, function_name, module_name,
273                             component_id, "%s\n", acpi_gbl_fn_entry_str);
274 }
275
276 ACPI_EXPORT_SYMBOL(acpi_ut_trace)
277
278 /*******************************************************************************
279  *
280  * FUNCTION:    acpi_ut_trace_ptr
281  *
282  * PARAMETERS:  line_number         - Caller's line number
283  *              function_name       - Caller's procedure name
284  *              module_name         - Caller's module name
285  *              component_id        - Caller's component ID
286  *              Pointer             - Pointer to display
287  *
288  * RETURN:      None
289  *
290  * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
291  *              set in debug_level
292  *
293  ******************************************************************************/
294 void
295 acpi_ut_trace_ptr(u32 line_number,
296                   const char *function_name,
297                   char *module_name, u32 component_id, void *pointer)
298 {
299         acpi_gbl_nesting_level++;
300         acpi_ut_track_stack_ptr();
301
302         acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
303                             line_number, function_name, module_name,
304                             component_id, "%s %p\n", acpi_gbl_fn_entry_str,
305                             pointer);
306 }
307
308 /*******************************************************************************
309  *
310  * FUNCTION:    acpi_ut_trace_str
311  *
312  * PARAMETERS:  line_number         - Caller's line number
313  *              function_name       - Caller's procedure name
314  *              module_name         - Caller's module name
315  *              component_id        - Caller's component ID
316  *              String              - Additional string to display
317  *
318  * RETURN:      None
319  *
320  * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
321  *              set in debug_level
322  *
323  ******************************************************************************/
324
325 void
326 acpi_ut_trace_str(u32 line_number,
327                   const char *function_name,
328                   char *module_name, u32 component_id, char *string)
329 {
330
331         acpi_gbl_nesting_level++;
332         acpi_ut_track_stack_ptr();
333
334         acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
335                             line_number, function_name, module_name,
336                             component_id, "%s %s\n", acpi_gbl_fn_entry_str,
337                             string);
338 }
339
340 /*******************************************************************************
341  *
342  * FUNCTION:    acpi_ut_trace_u32
343  *
344  * PARAMETERS:  line_number         - Caller's line number
345  *              function_name       - Caller's procedure name
346  *              module_name         - Caller's module name
347  *              component_id        - Caller's component ID
348  *              Integer             - Integer to display
349  *
350  * RETURN:      None
351  *
352  * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
353  *              set in debug_level
354  *
355  ******************************************************************************/
356
357 void
358 acpi_ut_trace_u32(u32 line_number,
359                   const char *function_name,
360                   char *module_name, u32 component_id, u32 integer)
361 {
362
363         acpi_gbl_nesting_level++;
364         acpi_ut_track_stack_ptr();
365
366         acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
367                             line_number, function_name, module_name,
368                             component_id, "%s %08X\n", acpi_gbl_fn_entry_str,
369                             integer);
370 }
371
372 /*******************************************************************************
373  *
374  * FUNCTION:    acpi_ut_exit
375  *
376  * PARAMETERS:  line_number         - Caller's line number
377  *              function_name       - Caller's procedure name
378  *              module_name         - Caller's module name
379  *              component_id        - Caller's component ID
380  *
381  * RETURN:      None
382  *
383  * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
384  *              set in debug_level
385  *
386  ******************************************************************************/
387
388 void
389 acpi_ut_exit(u32 line_number,
390              const char *function_name, char *module_name, u32 component_id)
391 {
392
393         acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
394                             line_number, function_name, module_name,
395                             component_id, "%s\n", acpi_gbl_fn_exit_str);
396
397         acpi_gbl_nesting_level--;
398 }
399
400 ACPI_EXPORT_SYMBOL(acpi_ut_exit)
401
402 /*******************************************************************************
403  *
404  * FUNCTION:    acpi_ut_status_exit
405  *
406  * PARAMETERS:  line_number         - Caller's line number
407  *              function_name       - Caller's procedure name
408  *              module_name         - Caller's module name
409  *              component_id        - Caller's component ID
410  *              Status              - Exit status code
411  *
412  * RETURN:      None
413  *
414  * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
415  *              set in debug_level. Prints exit status also.
416  *
417  ******************************************************************************/
418 void
419 acpi_ut_status_exit(u32 line_number,
420                     const char *function_name,
421                     char *module_name, u32 component_id, acpi_status status)
422 {
423
424         if (ACPI_SUCCESS(status)) {
425                 acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
426                                     line_number, function_name, module_name,
427                                     component_id, "%s %s\n",
428                                     acpi_gbl_fn_exit_str,
429                                     acpi_format_exception(status));
430         } else {
431                 acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
432                                     line_number, function_name, module_name,
433                                     component_id, "%s ****Exception****: %s\n",
434                                     acpi_gbl_fn_exit_str,
435                                     acpi_format_exception(status));
436         }
437
438         acpi_gbl_nesting_level--;
439 }
440
441 ACPI_EXPORT_SYMBOL(acpi_ut_status_exit)
442
443 /*******************************************************************************
444  *
445  * FUNCTION:    acpi_ut_value_exit
446  *
447  * PARAMETERS:  line_number         - Caller's line number
448  *              function_name       - Caller's procedure name
449  *              module_name         - Caller's module name
450  *              component_id        - Caller's component ID
451  *              Value               - Value to be printed with exit msg
452  *
453  * RETURN:      None
454  *
455  * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
456  *              set in debug_level. Prints exit value also.
457  *
458  ******************************************************************************/
459 void
460 acpi_ut_value_exit(u32 line_number,
461                    const char *function_name,
462                    char *module_name, u32 component_id, acpi_integer value)
463 {
464
465         acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
466                             line_number, function_name, module_name,
467                             component_id, "%s %8.8X%8.8X\n",
468                             acpi_gbl_fn_exit_str, ACPI_FORMAT_UINT64(value));
469
470         acpi_gbl_nesting_level--;
471 }
472
473 ACPI_EXPORT_SYMBOL(acpi_ut_value_exit)
474
475 /*******************************************************************************
476  *
477  * FUNCTION:    acpi_ut_ptr_exit
478  *
479  * PARAMETERS:  line_number         - Caller's line number
480  *              function_name       - Caller's procedure name
481  *              module_name         - Caller's module name
482  *              component_id        - Caller's component ID
483  *              Ptr                 - Pointer to display
484  *
485  * RETURN:      None
486  *
487  * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
488  *              set in debug_level. Prints exit value also.
489  *
490  ******************************************************************************/
491 void
492 acpi_ut_ptr_exit(u32 line_number,
493                  const char *function_name,
494                  char *module_name, u32 component_id, u8 * ptr)
495 {
496
497         acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
498                             line_number, function_name, module_name,
499                             component_id, "%s %p\n", acpi_gbl_fn_exit_str, ptr);
500
501         acpi_gbl_nesting_level--;
502 }
503
504 #endif
505
506 /*******************************************************************************
507  *
508  * FUNCTION:    acpi_ut_dump_buffer
509  *
510  * PARAMETERS:  Buffer              - Buffer to dump
511  *              Count               - Amount to dump, in bytes
512  *              Display             - BYTE, WORD, DWORD, or QWORD display
513  *              component_iD        - Caller's component ID
514  *
515  * RETURN:      None
516  *
517  * DESCRIPTION: Generic dump buffer in both hex and ascii.
518  *
519  ******************************************************************************/
520
521 void acpi_ut_dump_buffer2(u8 * buffer, u32 count, u32 display)
522 {
523         acpi_native_uint i = 0;
524         acpi_native_uint j;
525         u32 temp32;
526         u8 buf_char;
527
528         if ((count < 4) || (count & 0x01)) {
529                 display = DB_BYTE_DISPLAY;
530         }
531
532         /* Nasty little dump buffer routine! */
533
534         while (i < count) {
535
536                 /* Print current offset */
537
538                 acpi_os_printf("%6.4X: ", (u32) i);
539
540                 /* Print 16 hex chars */
541
542                 for (j = 0; j < 16;) {
543                         if (i + j >= count) {
544
545                                 /* Dump fill spaces */
546
547                                 acpi_os_printf("%*s", ((display * 2) + 1), " ");
548                                 j += (acpi_native_uint) display;
549                                 continue;
550                         }
551
552                         switch (display) {
553                         case DB_BYTE_DISPLAY:
554                         default:        /* Default is BYTE display */
555
556                                 acpi_os_printf("%02X ", buffer[i + j]);
557                                 break;
558
559                         case DB_WORD_DISPLAY:
560
561                                 ACPI_MOVE_16_TO_32(&temp32, &buffer[i + j]);
562                                 acpi_os_printf("%04X ", temp32);
563                                 break;
564
565                         case DB_DWORD_DISPLAY:
566
567                                 ACPI_MOVE_32_TO_32(&temp32, &buffer[i + j]);
568                                 acpi_os_printf("%08X ", temp32);
569                                 break;
570
571                         case DB_QWORD_DISPLAY:
572
573                                 ACPI_MOVE_32_TO_32(&temp32, &buffer[i + j]);
574                                 acpi_os_printf("%08X", temp32);
575
576                                 ACPI_MOVE_32_TO_32(&temp32, &buffer[i + j + 4]);
577                                 acpi_os_printf("%08X ", temp32);
578                                 break;
579                         }
580
581                         j += (acpi_native_uint) display;
582                 }
583
584                 /*
585                  * Print the ASCII equivalent characters but watch out for the bad
586                  * unprintable ones (printable chars are 0x20 through 0x7E)
587                  */
588                 acpi_os_printf(" ");
589                 for (j = 0; j < 16; j++) {
590                         if (i + j >= count) {
591                                 acpi_os_printf("\n");
592                                 return;
593                         }
594
595                         buf_char = buffer[i + j];
596                         if (ACPI_IS_PRINT(buf_char)) {
597                                 acpi_os_printf("%c", buf_char);
598                         } else {
599                                 acpi_os_printf(".");
600                         }
601                 }
602
603                 /* Done with that line. */
604
605                 acpi_os_printf("\n");
606                 i += 16;
607         }
608
609         return;
610 }
611
612 /*******************************************************************************
613  *
614  * FUNCTION:    acpi_ut_dump_buffer
615  *
616  * PARAMETERS:  Buffer              - Buffer to dump
617  *              Count               - Amount to dump, in bytes
618  *              Display             - BYTE, WORD, DWORD, or QWORD display
619  *              component_iD        - Caller's component ID
620  *
621  * RETURN:      None
622  *
623  * DESCRIPTION: Generic dump buffer in both hex and ascii.
624  *
625  ******************************************************************************/
626
627 void acpi_ut_dump_buffer(u8 * buffer, u32 count, u32 display, u32 component_id)
628 {
629
630         /* Only dump the buffer if tracing is enabled */
631
632         if (!((ACPI_LV_TABLES & acpi_dbg_level) &&
633               (component_id & acpi_dbg_layer))) {
634                 return;
635         }
636
637         acpi_ut_dump_buffer2(buffer, count, display);
638 }