[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)
 *              dbg_info            - Contains:
 *                  proc_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,
	struct acpi_debug_print_info    *dbg_info,
	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) ||
		!(dbg_info->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 ", dbg_info->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, dbg_info->proc_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
 *              dbg_info            - Contains:
 *                  proc_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,
	struct acpi_debug_print_info    *dbg_info,
	char                            *format,
	...)
{
	va_list                 args;


	if (!(requested_debug_level & acpi_dbg_level) ||
		!(dbg_info->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
 *              dbg_info            - Contains:
 *                  proc_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,
	struct acpi_debug_print_info    *dbg_info)
{

	acpi_gbl_nesting_level++;
	acpi_ut_track_stack_ptr ();

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


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_trace_ptr
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              dbg_info            - Contains:
 *                  proc_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,
	struct acpi_debug_print_info    *dbg_info,
	void                            *pointer)
{
	acpi_gbl_nesting_level++;
	acpi_ut_track_stack_ptr ();

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


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_trace_str
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              dbg_info            - Contains:
 *                  proc_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,
	struct acpi_debug_print_info    *dbg_info,
	char                            *string)
{

	acpi_gbl_nesting_level++;
	acpi_ut_track_stack_ptr ();

	acpi_ut_debug_print (ACPI_LV_FUNCTIONS, line_number, dbg_info,
			"%s %s\n", acpi_gbl_fn_entry_str, string);
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_trace_u32
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              dbg_info            - Contains:
 *                  proc_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,
	struct acpi_debug_print_info    *dbg_info,
	u32                             integer)
{

	acpi_gbl_nesting_level++;
	acpi_ut_track_stack_ptr ();

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


/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_exit
 *
 * PARAMETERS:  line_number         - Caller's line number
 *              dbg_info            - Contains:
 *                  proc_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,
	struct acpi_debug_print_info    *dbg_info)
{

	acpi_ut_debug_print (ACPI_LV_FUNCTIONS, line_number, dbg_info,
			"%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
 *              dbg_info            - Contains:
 *                  proc_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,
	struct acpi_debug_print_info    *dbg_info,
	acpi_status                     status)
{

	if (ACPI_SUCCESS (status)) {
		acpi_ut_debug_print (ACPI_LV_FUNCTIONS, line_number, dbg_info,
				"%s %s\n", acpi_gbl_fn_exit_str,
				acpi_format_exception (status));
	}
	else {
		acpi_ut_debug_print (ACPI_LV_FUNCTIONS, line_number, dbg_info,
				"%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
 *              dbg_info            - Contains:
 *                  proc_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,
	struct acpi_debug_print_info    *dbg_info,
	acpi_integer                    value)
{

	acpi_ut_debug_print (ACPI_LV_FUNCTIONS, line_number, dbg_info,
			"%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
 *              dbg_info            - Contains:
 *                  proc_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,
	struct acpi_debug_print_info    *dbg_info,
	u8                              *ptr)
{

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