Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
47ACPI_MODULE_NAME("utdebug")
48
49#ifdef ACPI_DEBUG_OUTPUT
50static acpi_thread_id acpi_gbl_prev_thread_id;
51static char *acpi_gbl_fn_entry_str = "----Entry";
52static char *acpi_gbl_fn_exit_str = "----Exit-";
53
54/* Local prototypes */
55
56static 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
70void acpi_ut_init_stack_ptr_trace(void)
71{
72 u32 current_sp;
73
74 acpi_gbl_entry_stack_pointer = ACPI_PTR_DIFF(¤t_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
89void acpi_ut_track_stack_ptr(void)
90{
91 acpi_size current_sp;
92
93 current_sp = ACPI_PTR_DIFF(¤t_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
118static 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
159void ACPI_INTERNAL_VAR_XFACE
160acpi_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
209ACPI_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 ******************************************************************************/
229void ACPI_INTERNAL_VAR_XFACE
230acpi_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
246ACPI_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 ******************************************************************************/
263void
264acpi_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
276ACPI_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 ******************************************************************************/
294void
295acpi_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
325void
326acpi_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
357void
358acpi_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
388void
389acpi_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
400ACPI_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 ******************************************************************************/
418void
419acpi_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
441ACPI_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 ******************************************************************************/
459void
460acpi_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
473ACPI_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 ******************************************************************************/
491void
492acpi_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
521void 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
627void 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}