xref: /titanic_44/usr/src/uts/intel/io/acpica/utilities/utdebug.c (revision f38cb554a534c6df738be3f4d23327e69888e634)
1 /******************************************************************************
2  *
3  * Module Name: utdebug - Debug print routines
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2011, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 #define __UTDEBUG_C__
45 
46 #include "acpi.h"
47 #include "accommon.h"
48 
49 #define _COMPONENT          ACPI_UTILITIES
50         ACPI_MODULE_NAME    ("utdebug")
51 
52 
53 #ifdef ACPI_DEBUG_OUTPUT
54 
55 static ACPI_THREAD_ID       AcpiGbl_PrevThreadId = (ACPI_THREAD_ID) 0xFFFFFFFF;
56 static char                 *AcpiGbl_FnEntryStr = "----Entry";
57 static char                 *AcpiGbl_FnExitStr  = "----Exit-";
58 
59 /* Local prototypes */
60 
61 static const char *
62 AcpiUtTrimFunctionName (
63     const char              *FunctionName);
64 
65 
66 /*******************************************************************************
67  *
68  * FUNCTION:    AcpiUtInitStackPtrTrace
69  *
70  * PARAMETERS:  None
71  *
72  * RETURN:      None
73  *
74  * DESCRIPTION: Save the current CPU stack pointer at subsystem startup
75  *
76  ******************************************************************************/
77 
78 void
79 AcpiUtInitStackPtrTrace (
80     void)
81 {
82     ACPI_SIZE               CurrentSp;
83 
84 
85     AcpiGbl_EntryStackPointer = &CurrentSp;
86 }
87 
88 
89 /*******************************************************************************
90  *
91  * FUNCTION:    AcpiUtTrackStackPtr
92  *
93  * PARAMETERS:  None
94  *
95  * RETURN:      None
96  *
97  * DESCRIPTION: Save the current CPU stack pointer
98  *
99  ******************************************************************************/
100 
101 void
102 AcpiUtTrackStackPtr (
103     void)
104 {
105     ACPI_SIZE               CurrentSp;
106 
107 
108     if (&CurrentSp < AcpiGbl_LowestStackPointer)
109     {
110         AcpiGbl_LowestStackPointer = &CurrentSp;
111     }
112 
113     if (AcpiGbl_NestingLevel > AcpiGbl_DeepestNesting)
114     {
115         AcpiGbl_DeepestNesting = AcpiGbl_NestingLevel;
116     }
117 }
118 
119 
120 /*******************************************************************************
121  *
122  * FUNCTION:    AcpiUtTrimFunctionName
123  *
124  * PARAMETERS:  FunctionName        - Ascii string containing a procedure name
125  *
126  * RETURN:      Updated pointer to the function name
127  *
128  * DESCRIPTION: Remove the "Acpi" prefix from the function name, if present.
129  *              This allows compiler macros such as __FUNCTION__ to be used
130  *              with no change to the debug output.
131  *
132  ******************************************************************************/
133 
134 static const char *
135 AcpiUtTrimFunctionName (
136     const char              *FunctionName)
137 {
138 
139     /* All Function names are longer than 4 chars, check is safe */
140 
141     if (*(ACPI_CAST_PTR (UINT32, FunctionName)) == ACPI_PREFIX_MIXED)
142     {
143         /* This is the case where the original source has not been modified */
144 
145         return (FunctionName + 4);
146     }
147 
148     if (*(ACPI_CAST_PTR (UINT32, FunctionName)) == ACPI_PREFIX_LOWER)
149     {
150         /* This is the case where the source has been 'linuxized' */
151 
152         return (FunctionName + 5);
153     }
154 
155     return (FunctionName);
156 }
157 
158 
159 /*******************************************************************************
160  *
161  * FUNCTION:    AcpiDebugPrint
162  *
163  * PARAMETERS:  RequestedDebugLevel - Requested debug print level
164  *              LineNumber          - Caller's line number (for error output)
165  *              FunctionName        - Caller's procedure name
166  *              ModuleName          - Caller's module name
167  *              ComponentId         - Caller's component ID
168  *              Format              - Printf format field
169  *              ...                 - Optional printf arguments
170  *
171  * RETURN:      None
172  *
173  * DESCRIPTION: Print error message with prefix consisting of the module name,
174  *              line number, and component ID.
175  *
176  ******************************************************************************/
177 
178 void  ACPI_INTERNAL_VAR_XFACE
179 AcpiDebugPrint (
180     UINT32                  RequestedDebugLevel,
181     UINT32                  LineNumber,
182     const char              *FunctionName,
183     const char              *ModuleName,
184     UINT32                  ComponentId,
185     const char              *Format,
186     ...)
187 {
188     ACPI_THREAD_ID          ThreadId;
189     va_list                 args;
190 
191 
192     /*
193      * Stay silent if the debug level or component ID is disabled
194      */
195     if (!(RequestedDebugLevel & AcpiDbgLevel) ||
196         !(ComponentId & AcpiDbgLayer))
197     {
198         return;
199     }
200 
201     /*
202      * Thread tracking and context switch notification
203      */
204     ThreadId = AcpiOsGetThreadId ();
205     if (ThreadId != AcpiGbl_PrevThreadId)
206     {
207         if (ACPI_LV_THREADS & AcpiDbgLevel)
208         {
209             AcpiOsPrintf (
210                 "\n**** Context Switch from TID %u to TID %u ****\n\n",
211                 (UINT32) AcpiGbl_PrevThreadId, (UINT32) ThreadId);
212         }
213 
214         AcpiGbl_PrevThreadId = ThreadId;
215     }
216 
217     /*
218      * Display the module name, current line number, thread ID (if requested),
219      * current procedure nesting level, and the current procedure name
220      */
221     AcpiOsPrintf ("%8s-%04ld ", ModuleName, LineNumber);
222 
223     if (ACPI_LV_THREADS & AcpiDbgLevel)
224     {
225         AcpiOsPrintf ("[%u] ", (UINT32) ThreadId);
226     }
227 
228     AcpiOsPrintf ("[%02ld] %-22.22s: ",
229         AcpiGbl_NestingLevel, AcpiUtTrimFunctionName (FunctionName));
230 
231     va_start (args, Format);
232     AcpiOsVprintf (Format, args);
233     va_end (args);
234 }
235 
236 ACPI_EXPORT_SYMBOL (AcpiDebugPrint)
237 
238 
239 /*******************************************************************************
240  *
241  * FUNCTION:    AcpiDebugPrintRaw
242  *
243  * PARAMETERS:  RequestedDebugLevel - Requested debug print level
244  *              LineNumber          - Caller's line number
245  *              FunctionName        - Caller's procedure name
246  *              ModuleName          - Caller's module name
247  *              ComponentId         - Caller's component ID
248  *              Format              - Printf format field
249  *              ...                 - Optional printf arguments
250  *
251  * RETURN:      None
252  *
253  * DESCRIPTION: Print message with no headers.  Has same interface as
254  *              DebugPrint so that the same macros can be used.
255  *
256  ******************************************************************************/
257 
258 void  ACPI_INTERNAL_VAR_XFACE
259 AcpiDebugPrintRaw (
260     UINT32                  RequestedDebugLevel,
261     UINT32                  LineNumber,
262     const char              *FunctionName,
263     const char              *ModuleName,
264     UINT32                  ComponentId,
265     const char              *Format,
266     ...)
267 {
268     va_list                 args;
269 
270 
271     if (!(RequestedDebugLevel & AcpiDbgLevel) ||
272         !(ComponentId & AcpiDbgLayer))
273     {
274         return;
275     }
276 
277     va_start (args, Format);
278     AcpiOsVprintf (Format, args);
279     va_end (args);
280 }
281 
282 ACPI_EXPORT_SYMBOL (AcpiDebugPrintRaw)
283 
284 
285 /*******************************************************************************
286  *
287  * FUNCTION:    AcpiUtTrace
288  *
289  * PARAMETERS:  LineNumber          - Caller's line number
290  *              FunctionName        - Caller's procedure name
291  *              ModuleName          - Caller's module name
292  *              ComponentId         - Caller's component ID
293  *
294  * RETURN:      None
295  *
296  * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
297  *              set in DebugLevel
298  *
299  ******************************************************************************/
300 
301 void
302 AcpiUtTrace (
303     UINT32                  LineNumber,
304     const char              *FunctionName,
305     const char              *ModuleName,
306     UINT32                  ComponentId)
307 {
308 
309     AcpiGbl_NestingLevel++;
310     AcpiUtTrackStackPtr ();
311 
312     AcpiDebugPrint (ACPI_LV_FUNCTIONS,
313         LineNumber, FunctionName, ModuleName, ComponentId,
314         "%s\n", AcpiGbl_FnEntryStr);
315 }
316 
317 ACPI_EXPORT_SYMBOL (AcpiUtTrace)
318 
319 
320 /*******************************************************************************
321  *
322  * FUNCTION:    AcpiUtTracePtr
323  *
324  * PARAMETERS:  LineNumber          - Caller's line number
325  *              FunctionName        - Caller's procedure name
326  *              ModuleName          - Caller's module name
327  *              ComponentId         - Caller's component ID
328  *              Pointer             - Pointer to display
329  *
330  * RETURN:      None
331  *
332  * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
333  *              set in DebugLevel
334  *
335  ******************************************************************************/
336 
337 void
338 AcpiUtTracePtr (
339     UINT32                  LineNumber,
340     const char              *FunctionName,
341     const char              *ModuleName,
342     UINT32                  ComponentId,
343     void                    *Pointer)
344 {
345     AcpiGbl_NestingLevel++;
346     AcpiUtTrackStackPtr ();
347 
348     AcpiDebugPrint (ACPI_LV_FUNCTIONS,
349         LineNumber, FunctionName, ModuleName, ComponentId,
350         "%s %p\n", AcpiGbl_FnEntryStr, Pointer);
351 }
352 
353 
354 /*******************************************************************************
355  *
356  * FUNCTION:    AcpiUtTraceStr
357  *
358  * PARAMETERS:  LineNumber          - Caller's line number
359  *              FunctionName        - Caller's procedure name
360  *              ModuleName          - Caller's module name
361  *              ComponentId         - Caller's component ID
362  *              String              - Additional string to display
363  *
364  * RETURN:      None
365  *
366  * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
367  *              set in DebugLevel
368  *
369  ******************************************************************************/
370 
371 void
372 AcpiUtTraceStr (
373     UINT32                  LineNumber,
374     const char              *FunctionName,
375     const char              *ModuleName,
376     UINT32                  ComponentId,
377     char                    *String)
378 {
379 
380     AcpiGbl_NestingLevel++;
381     AcpiUtTrackStackPtr ();
382 
383     AcpiDebugPrint (ACPI_LV_FUNCTIONS,
384         LineNumber, FunctionName, ModuleName, ComponentId,
385         "%s %s\n", AcpiGbl_FnEntryStr, String);
386 }
387 
388 
389 /*******************************************************************************
390  *
391  * FUNCTION:    AcpiUtTraceU32
392  *
393  * PARAMETERS:  LineNumber          - Caller's line number
394  *              FunctionName        - Caller's procedure name
395  *              ModuleName          - Caller's module name
396  *              ComponentId         - Caller's component ID
397  *              Integer             - Integer to display
398  *
399  * RETURN:      None
400  *
401  * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
402  *              set in DebugLevel
403  *
404  ******************************************************************************/
405 
406 void
407 AcpiUtTraceU32 (
408     UINT32                  LineNumber,
409     const char              *FunctionName,
410     const char              *ModuleName,
411     UINT32                  ComponentId,
412     UINT32                  Integer)
413 {
414 
415     AcpiGbl_NestingLevel++;
416     AcpiUtTrackStackPtr ();
417 
418     AcpiDebugPrint (ACPI_LV_FUNCTIONS,
419         LineNumber, FunctionName, ModuleName, ComponentId,
420         "%s %08X\n", AcpiGbl_FnEntryStr, Integer);
421 }
422 
423 
424 /*******************************************************************************
425  *
426  * FUNCTION:    AcpiUtExit
427  *
428  * PARAMETERS:  LineNumber          - Caller's line number
429  *              FunctionName        - Caller's procedure name
430  *              ModuleName          - Caller's module name
431  *              ComponentId         - Caller's component ID
432  *
433  * RETURN:      None
434  *
435  * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
436  *              set in DebugLevel
437  *
438  ******************************************************************************/
439 
440 void
441 AcpiUtExit (
442     UINT32                  LineNumber,
443     const char              *FunctionName,
444     const char              *ModuleName,
445     UINT32                  ComponentId)
446 {
447 
448     AcpiDebugPrint (ACPI_LV_FUNCTIONS,
449         LineNumber, FunctionName, ModuleName, ComponentId,
450         "%s\n", AcpiGbl_FnExitStr);
451 
452     AcpiGbl_NestingLevel--;
453 }
454 
455 ACPI_EXPORT_SYMBOL (AcpiUtExit)
456 
457 
458 /*******************************************************************************
459  *
460  * FUNCTION:    AcpiUtStatusExit
461  *
462  * PARAMETERS:  LineNumber          - Caller's line number
463  *              FunctionName        - Caller's procedure name
464  *              ModuleName          - Caller's module name
465  *              ComponentId         - Caller's component ID
466  *              Status              - Exit status code
467  *
468  * RETURN:      None
469  *
470  * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
471  *              set in DebugLevel.  Prints exit status also.
472  *
473  ******************************************************************************/
474 
475 void
476 AcpiUtStatusExit (
477     UINT32                  LineNumber,
478     const char              *FunctionName,
479     const char              *ModuleName,
480     UINT32                  ComponentId,
481     ACPI_STATUS             Status)
482 {
483 
484     if (ACPI_SUCCESS (Status))
485     {
486         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
487             LineNumber, FunctionName, ModuleName, ComponentId,
488             "%s %s\n", AcpiGbl_FnExitStr,
489             AcpiFormatException (Status));
490     }
491     else
492     {
493         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
494             LineNumber, FunctionName, ModuleName, ComponentId,
495             "%s ****Exception****: %s\n", AcpiGbl_FnExitStr,
496             AcpiFormatException (Status));
497     }
498 
499     AcpiGbl_NestingLevel--;
500 }
501 
502 ACPI_EXPORT_SYMBOL (AcpiUtStatusExit)
503 
504 
505 /*******************************************************************************
506  *
507  * FUNCTION:    AcpiUtValueExit
508  *
509  * PARAMETERS:  LineNumber          - Caller's line number
510  *              FunctionName        - Caller's procedure name
511  *              ModuleName          - Caller's module name
512  *              ComponentId         - Caller's component ID
513  *              Value               - Value to be printed with exit msg
514  *
515  * RETURN:      None
516  *
517  * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
518  *              set in DebugLevel.  Prints exit value also.
519  *
520  ******************************************************************************/
521 
522 void
523 AcpiUtValueExit (
524     UINT32                  LineNumber,
525     const char              *FunctionName,
526     const char              *ModuleName,
527     UINT32                  ComponentId,
528     UINT64                  Value)
529 {
530 
531     AcpiDebugPrint (ACPI_LV_FUNCTIONS,
532         LineNumber, FunctionName, ModuleName, ComponentId,
533         "%s %8.8X%8.8X\n", AcpiGbl_FnExitStr,
534         ACPI_FORMAT_UINT64 (Value));
535 
536     AcpiGbl_NestingLevel--;
537 }
538 
539 ACPI_EXPORT_SYMBOL (AcpiUtValueExit)
540 
541 
542 /*******************************************************************************
543  *
544  * FUNCTION:    AcpiUtPtrExit
545  *
546  * PARAMETERS:  LineNumber          - Caller's line number
547  *              FunctionName        - Caller's procedure name
548  *              ModuleName          - Caller's module name
549  *              ComponentId         - Caller's component ID
550  *              Ptr                 - Pointer to display
551  *
552  * RETURN:      None
553  *
554  * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
555  *              set in DebugLevel.  Prints exit value also.
556  *
557  ******************************************************************************/
558 
559 void
560 AcpiUtPtrExit (
561     UINT32                  LineNumber,
562     const char              *FunctionName,
563     const char              *ModuleName,
564     UINT32                  ComponentId,
565     UINT8                   *Ptr)
566 {
567 
568     AcpiDebugPrint (ACPI_LV_FUNCTIONS,
569         LineNumber, FunctionName, ModuleName, ComponentId,
570         "%s %p\n", AcpiGbl_FnExitStr, Ptr);
571 
572     AcpiGbl_NestingLevel--;
573 }
574 
575 #endif
576 
577 
578 /*******************************************************************************
579  *
580  * FUNCTION:    AcpiUtDumpBuffer
581  *
582  * PARAMETERS:  Buffer              - Buffer to dump
583  *              Count               - Amount to dump, in bytes
584  *              Display             - BYTE, WORD, DWORD, or QWORD display
585  *              ComponentID         - Caller's component ID
586  *
587  * RETURN:      None
588  *
589  * DESCRIPTION: Generic dump buffer in both hex and ascii.
590  *
591  ******************************************************************************/
592 
593 void
594 AcpiUtDumpBuffer2 (
595     UINT8                   *Buffer,
596     UINT32                  Count,
597     UINT32                  Display)
598 {
599     UINT32                  i = 0;
600     UINT32                  j;
601     UINT32                  Temp32;
602     UINT8                   BufChar;
603 
604 
605     if (!Buffer)
606     {
607         AcpiOsPrintf ("Null Buffer Pointer in DumpBuffer!\n");
608         return;
609     }
610 
611     if ((Count < 4) || (Count & 0x01))
612     {
613         Display = DB_BYTE_DISPLAY;
614     }
615 
616     /* Nasty little dump buffer routine! */
617 
618     while (i < Count)
619     {
620         /* Print current offset */
621 
622         AcpiOsPrintf ("%6.4X: ", i);
623 
624         /* Print 16 hex chars */
625 
626         for (j = 0; j < 16;)
627         {
628             if (i + j >= Count)
629             {
630                 /* Dump fill spaces */
631 
632                 AcpiOsPrintf ("%*s", ((Display * 2) + 1), " ");
633                 j += Display;
634                 continue;
635             }
636 
637             switch (Display)
638             {
639             case DB_BYTE_DISPLAY:
640             default:    /* Default is BYTE display */
641 
642                 AcpiOsPrintf ("%02X ", Buffer[(ACPI_SIZE) i + j]);
643                 break;
644 
645 
646             case DB_WORD_DISPLAY:
647 
648                 ACPI_MOVE_16_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
649                 AcpiOsPrintf ("%04X ", Temp32);
650                 break;
651 
652 
653             case DB_DWORD_DISPLAY:
654 
655                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
656                 AcpiOsPrintf ("%08X ", Temp32);
657                 break;
658 
659 
660             case DB_QWORD_DISPLAY:
661 
662                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
663                 AcpiOsPrintf ("%08X", Temp32);
664 
665                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j + 4]);
666                 AcpiOsPrintf ("%08X ", Temp32);
667                 break;
668             }
669 
670             j += Display;
671         }
672 
673         /*
674          * Print the ASCII equivalent characters but watch out for the bad
675          * unprintable ones (printable chars are 0x20 through 0x7E)
676          */
677         AcpiOsPrintf (" ");
678         for (j = 0; j < 16; j++)
679         {
680             if (i + j >= Count)
681             {
682                 AcpiOsPrintf ("\n");
683                 return;
684             }
685 
686             BufChar = Buffer[(ACPI_SIZE) i + j];
687             if (ACPI_IS_PRINT (BufChar))
688             {
689                 AcpiOsPrintf ("%c", BufChar);
690             }
691             else
692             {
693                 AcpiOsPrintf (".");
694             }
695         }
696 
697         /* Done with that line. */
698 
699         AcpiOsPrintf ("\n");
700         i += 16;
701     }
702 
703     return;
704 }
705 
706 
707 /*******************************************************************************
708  *
709  * FUNCTION:    AcpiUtDumpBuffer
710  *
711  * PARAMETERS:  Buffer              - Buffer to dump
712  *              Count               - Amount to dump, in bytes
713  *              Display             - BYTE, WORD, DWORD, or QWORD display
714  *              ComponentID         - Caller's component ID
715  *
716  * RETURN:      None
717  *
718  * DESCRIPTION: Generic dump buffer in both hex and ascii.
719  *
720  ******************************************************************************/
721 
722 void
723 AcpiUtDumpBuffer (
724     UINT8                   *Buffer,
725     UINT32                  Count,
726     UINT32                  Display,
727     UINT32                  ComponentId)
728 {
729 
730     /* Only dump the buffer if tracing is enabled */
731 
732     if (!((ACPI_LV_TABLES & AcpiDbgLevel) &&
733         (ComponentId & AcpiDbgLayer)))
734     {
735         return;
736     }
737 
738     AcpiUtDumpBuffer2 (Buffer, Count, Display);
739 }
740 
741 
742