[deliverable/linux.git] / drivers / acpi / utilities / utdebug.c

/******************************************************************************
 *
 * Module Name: utdebug - Debug print routines
 *
 *****************************************************************************/

/*
 * Copyright (C) 2000 - 2005, R. Byron Moore
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 * 3. Neither the names of the above-listed copyright holders nor the names
 *    of any contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 */

#include <linux/module.h>

#include <acpi/acpi.h>

#define _COMPONENT          ACPI_UTILITIES
	 ACPI_MODULE_NAME    ("utdebug")


#ifdef ACPI_DEBUG_OUTPUT

static u32   acpi_gbl_prev_thread_id = 0xFFFFFFFF;
static char     *acpi_gbl_fn_entry_str = "----Entry";
static char     *acpi_gbl_fn_exit_str = "----Exit-";


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_init_stack_ptr_trace
 *
 * PARAMETERS:  None
 *
 * RETURN:      None
 *
 * DESCRIPTION: Save the current CPU stack pointer at subsystem startup
 *
 ******************************************************************************/

void
acpi_ut_init_stack_ptr_trace (
	void)
{
	u32                         current_sp;


	acpi_gbl_entry_stack_pointer = ACPI_PTR_DIFF (&current_sp, NULL);
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_track_stack_ptr
 *
 * PARAMETERS:  None
 *
 * RETURN:      None
 *
 * DESCRIPTION: Save the current CPU stack pointer
 *
 ******************************************************************************/

void
acpi_ut_track_stack_ptr (
	void)
{
	acpi_size                   current_sp;


	current_sp = ACPI_PTR_DIFF (&current_sp, NULL);

	if (current_sp < acpi_gbl_lowest_stack_pointer) {
		acpi_gbl_lowest_stack_pointer = current_sp;
	}

	if (acpi_gbl_nesting_level > acpi_gbl_deepest_nesting) {
		acpi_gbl_deepest_nesting = acpi_gbl_nesting_level;
	}
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_debug_print
 *
 * PARAMETERS:  requested_debug_level - Requested debug print level
 *              line_number         - Caller's line number (for error output)
 *              function_name       - Caller's procedure name
 *              module_name         - Caller's module name
 *              component_id        - Caller's component ID
 *              Format              - Printf format field
 *              ...                 - Optional printf arguments
 *
 * RETURN:      None
 *
 * DESCRIPTION: Print error message with prefix consisting of the module name,
 *              line number, and component ID.
 *
 ******************************************************************************/

void  ACPI_INTERNAL_VAR_XFACE
acpi_ut_debug_print (
	u32                             requested_debug_level,
	u32                             line_number,
	char                            *function_name,
	char                            *module_name,
	u32                             component_id,
	char                            *format,
	...)
{
	u32                             thread_id;
	va_list                 args;


	/*
	 * Stay silent if the debug level or component ID is disabled
	 */
	if (!(requested_debug_level & acpi_dbg_level) ||
		!(component_id & acpi_dbg_layer)) {
		return;
	}

	/*
	 * Thread tracking and context switch notification
	 */
	thread_id = acpi_os_get_thread_id ();

	if (thread_id != acpi_gbl_prev_thread_id) {
		if (ACPI_LV_THREADS & acpi_dbg_level) {
			acpi_os_printf (
				"\n**** Context Switch from TID %X to TID %X ****\n\n",
				acpi_gbl_prev_thread_id, thread_id);
		}

		acpi_gbl_prev_thread_id = thread_id;
	}

	/*
	 * Display the module name, current line number, thread ID (if requested),
	 * current procedure nesting level, and the current procedure name
	 */
	acpi_os_printf ("%8s-%04ld ", module_name, line_number);

	if (ACPI_LV_THREADS & acpi_dbg_level) {
		acpi_os_printf ("[%04lX] ", thread_id);
	}

	acpi_os_printf ("[%02ld] %-22.22s: ",
		acpi_gbl_nesting_level, function_name);

	va_start (args, format);
	acpi_os_vprintf (format, args);
}

EXPORT_SYMBOL(acpi_ut_debug_print);

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_debug_print_raw
 *
 * PARAMETERS:  requested_debug_level - Requested debug print level
 *              line_number         - Caller's line number
 *              function_name       - Caller's procedure name
 *              module_name         - Caller's module name
 *              component_id        - Caller's component ID
 *              Format              - Printf format field
 *              ...                 - Optional printf arguments
 *
 * RETURN:      None
 *
 * DESCRIPTION: Print message with no headers.  Has same interface as
 *              debug_print so that the same macros can be used.
 *
 ******************************************************************************/

void  ACPI_INTERNAL_VAR_XFACE
acpi_ut_debug_print_raw (
	u32                             requested_debug_level,
	u32                             line_number,
	char                            *function_name,
	char                            *module_name,
	u32                             component_id,
	char                            *format,
	...)
{
	va_list                 args;


	if (!(requested_debug_level & acpi_dbg_level) ||
		!(component_id & acpi_dbg_layer)) {
		return;
	}

	va_start (args, format);
	acpi_os_vprintf (format, args);
}
EXPORT_SYMBOL(acpi_ut_debug_print_raw);


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_trace
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              function_name       - Caller's procedure name
 *              module_name         - Caller's module name
 *              component_id        - Caller's component ID
 *
 * RETURN:      None
 *
 * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
 *              set in debug_level
 *
 ******************************************************************************/

void
acpi_ut_trace (
	u32                             line_number,
	char                            *function_name,
	char                            *module_name,
	u32                             component_id)
{

	acpi_gbl_nesting_level++;
	acpi_ut_track_stack_ptr ();

	acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
		line_number, function_name, module_name, component_id,
		"%s\n", acpi_gbl_fn_entry_str);
}
EXPORT_SYMBOL(acpi_ut_trace);


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_trace_ptr
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              function_name       - Caller's procedure name
 *              module_name         - Caller's module name
 *              component_id        - Caller's component ID
 *              Pointer             - Pointer to display
 *
 * RETURN:      None
 *
 * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
 *              set in debug_level
 *
 ******************************************************************************/

void
acpi_ut_trace_ptr (
	u32                             line_number,
	char                            *function_name,
	char                            *module_name,
	u32                             component_id,
	void                            *pointer)
{
	acpi_gbl_nesting_level++;
	acpi_ut_track_stack_ptr ();

	acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
		line_number, function_name, module_name, component_id,
		"%s %p\n", acpi_gbl_fn_entry_str, pointer);
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_trace_str
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              function_name       - Caller's procedure name
 *              module_name         - Caller's module name
 *              component_id        - Caller's component ID
 *              String              - Additional string to display
 *
 * RETURN:      None
 *
 * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
 *              set in debug_level
 *
 ******************************************************************************/

void
acpi_ut_trace_str (
	u32                             line_number,
	char                            *function_name,
	char                            *module_name,
	u32                             component_id,
	char                            *string)
{

	acpi_gbl_nesting_level++;
	acpi_ut_track_stack_ptr ();

	acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
		line_number, function_name, module_name, component_id,
		"%s %s\n", acpi_gbl_fn_entry_str, string);
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_trace_u32
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              function_name       - Caller's procedure name
 *              module_name         - Caller's module name
 *              component_id        - Caller's component ID
 *              Integer             - Integer to display
 *
 * RETURN:      None
 *
 * DESCRIPTION: Function entry trace.  Prints only if TRACE_FUNCTIONS bit is
 *              set in debug_level
 *
 ******************************************************************************/

void
acpi_ut_trace_u32 (
	u32                             line_number,
	char                            *function_name,
	char                            *module_name,
	u32                             component_id,
	u32                             integer)
{

	acpi_gbl_nesting_level++;
	acpi_ut_track_stack_ptr ();

	acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
		line_number, function_name, module_name, component_id,
		"%s %08X\n", acpi_gbl_fn_entry_str, integer);
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_exit
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              function_name       - Caller's procedure name
 *              module_name         - Caller's module name
 *              component_id        - Caller's component ID
 *
 * RETURN:      None
 *
 * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
 *              set in debug_level
 *
 ******************************************************************************/

void
acpi_ut_exit (
	u32                             line_number,
	char                            *function_name,
	char                            *module_name,
	u32                             component_id)
{

	acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
		line_number, function_name, module_name, component_id,
		"%s\n", acpi_gbl_fn_exit_str);

	acpi_gbl_nesting_level--;
}
EXPORT_SYMBOL(acpi_ut_exit);


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_status_exit
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              function_name       - Caller's procedure name
 *              module_name         - Caller's module name
 *              component_id        - Caller's component ID
 *              Status              - Exit status code
 *
 * RETURN:      None
 *
 * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
 *              set in debug_level. Prints exit status also.
 *
 ******************************************************************************/

void
acpi_ut_status_exit (
	u32                             line_number,
	char                            *function_name,
	char                            *module_name,
	u32                             component_id,
	acpi_status                     status)
{

	if (ACPI_SUCCESS (status)) {
		acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
			line_number, function_name, module_name, component_id,
			"%s %s\n", acpi_gbl_fn_exit_str,
			acpi_format_exception (status));
	}
	else {
		acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
			line_number, function_name, module_name, component_id,
			"%s ****Exception****: %s\n", acpi_gbl_fn_exit_str,
			acpi_format_exception (status));
	}

	acpi_gbl_nesting_level--;
}
EXPORT_SYMBOL(acpi_ut_status_exit);


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_value_exit
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              function_name       - Caller's procedure name
 *              module_name         - Caller's module name
 *              component_id        - Caller's component ID
 *              Value               - Value to be printed with exit msg
 *
 * RETURN:      None
 *
 * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
 *              set in debug_level. Prints exit value also.
 *
 ******************************************************************************/

void
acpi_ut_value_exit (
	u32                             line_number,
	char                            *function_name,
	char                            *module_name,
	u32                             component_id,
	acpi_integer                    value)
{

	acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
		line_number, function_name, module_name, component_id,
		"%s %8.8X%8.8X\n", acpi_gbl_fn_exit_str,
		ACPI_FORMAT_UINT64 (value));

	acpi_gbl_nesting_level--;
}
EXPORT_SYMBOL(acpi_ut_value_exit);


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_ptr_exit
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              function_name       - Caller's procedure name
 *              module_name         - Caller's module name
 *              component_id        - Caller's component ID
 *              Ptr                 - Pointer to display
 *
 * RETURN:      None
 *
 * DESCRIPTION: Function exit trace.  Prints only if TRACE_FUNCTIONS bit is
 *              set in debug_level. Prints exit value also.
 *
 ******************************************************************************/

void
acpi_ut_ptr_exit (
	u32                             line_number,
	char                            *function_name,
	char                            *module_name,
	u32                             component_id,
	u8                              *ptr)
{

	acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
		line_number, function_name, module_name, component_id,
		"%s %p\n", acpi_gbl_fn_exit_str, ptr);

	acpi_gbl_nesting_level--;
}

#endif


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_dump_buffer
 *
 * PARAMETERS:  Buffer              - Buffer to dump
 *              Count               - Amount to dump, in bytes
 *              Display             - BYTE, WORD, DWORD, or QWORD display
 *              component_iD        - Caller's component ID
 *
 * RETURN:      None
 *
 * DESCRIPTION: Generic dump buffer in both hex and ascii.
 *
 ******************************************************************************/

void
acpi_ut_dump_buffer (
	u8                              *buffer,
	u32                             count,
	u32                             display,
	u32                             component_id)
{
	acpi_native_uint                i = 0;
	acpi_native_uint                j;
	u32                             temp32;
	u8                              buf_char;


	/* Only dump the buffer if tracing is enabled */

	if (!((ACPI_LV_TABLES & acpi_dbg_level) &&
		(component_id & acpi_dbg_layer))) {
		return;
	}

	if ((count < 4) || (count & 0x01)) {
		display = DB_BYTE_DISPLAY;
	}

	/* Nasty little dump buffer routine! */

	while (i < count) {
		/* Print current offset */

		acpi_os_printf ("%6.4X: ", (u32) i);

		/* Print 16 hex chars */

		for (j = 0; j < 16;) {
			if (i + j >= count) {
				/* Dump fill spaces */

				acpi_os_printf ("%*s", ((display * 2) + 1), " ");
				j += (acpi_native_uint) display;
				continue;
			}

			switch (display) {
			default:    /* Default is BYTE display */

				acpi_os_printf ("%02X ", buffer[i + j]);
				break;


			case DB_WORD_DISPLAY:

				ACPI_MOVE_16_TO_32 (&temp32, &buffer[i + j]);
				acpi_os_printf ("%04X ", temp32);
				break;


			case DB_DWORD_DISPLAY:

				ACPI_MOVE_32_TO_32 (&temp32, &buffer[i + j]);
				acpi_os_printf ("%08X ", temp32);
				break;


			case DB_QWORD_DISPLAY:

				ACPI_MOVE_32_TO_32 (&temp32, &buffer[i + j]);
				acpi_os_printf ("%08X", temp32);

				ACPI_MOVE_32_TO_32 (&temp32, &buffer[i + j + 4]);
				acpi_os_printf ("%08X ", temp32);
				break;
			}

			j += (acpi_native_uint) display;
		}

		/*
		 * Print the ASCII equivalent characters
		 * But watch out for the bad unprintable ones...
		 */
		acpi_os_printf (" ");
		for (j = 0; j < 16; j++) {
			if (i + j >= count) {
				acpi_os_printf ("\n");
				return;
			}

			buf_char = buffer[i + j];
			if ((buf_char > 0x1F && buf_char < 0x2E) ||
				(buf_char > 0x2F && buf_char < 0x61) ||
				(buf_char > 0x60 && buf_char < 0x7F)) {
				acpi_os_printf ("%c", buf_char);
			}
			else {
				acpi_os_printf (".");
			}
		}

		/* Done with that line. */

		acpi_os_printf ("\n");
		i += 16;
	}

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