[net-next-2.6.git] / drivers / acpi / acpica / exutils.c


/******************************************************************************
 *
 * Module Name: exutils - interpreter/scanner utilities
 *
 *****************************************************************************/

/*
 * Copyright (C) 2000 - 2008, Intel Corp.
 * 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.
 */

/*
 * DEFINE_AML_GLOBALS is tested in amlcode.h
 * to determine whether certain global names should be "defined" or only
 * "declared" in the current compilation.  This enhances maintainability
 * by enabling a single header file to embody all knowledge of the names
 * in question.
 *
 * Exactly one module of any executable should #define DEFINE_GLOBALS
 * before #including the header files which use this convention.  The
 * names in question will be defined and initialized in that module,
 * and declared as extern in all other modules which #include those
 * header files.
 */

#define DEFINE_AML_GLOBALS

#include <acpi/acpi.h>
#include "accommon.h"
#include "acinterp.h"
#include "amlcode.h"

#define _COMPONENT          ACPI_EXECUTER
ACPI_MODULE_NAME("exutils")

/* Local prototypes */
static u32 acpi_ex_digits_needed(acpi_integer value, u32 base);

#ifndef ACPI_NO_METHOD_EXECUTION
/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_enter_interpreter
 *
 * PARAMETERS:  None
 *
 * RETURN:      None
 *
 * DESCRIPTION: Enter the interpreter execution region. Failure to enter
 *              the interpreter region is a fatal system error. Used in
 *              conjunction with exit_interpreter.
 *
 ******************************************************************************/

void acpi_ex_enter_interpreter(void)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(ex_enter_interpreter);

	status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
	if (ACPI_FAILURE(status)) {
		ACPI_ERROR((AE_INFO,
			    "Could not acquire AML Interpreter mutex"));
	}

	return_VOID;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_reacquire_interpreter
 *
 * PARAMETERS:  None
 *
 * RETURN:      None
 *
 * DESCRIPTION: Reacquire the interpreter execution region from within the
 *              interpreter code. Failure to enter the interpreter region is a
 *              fatal system error. Used in  conjuction with
 *              relinquish_interpreter
 *
 ******************************************************************************/

void acpi_ex_reacquire_interpreter(void)
{
	ACPI_FUNCTION_TRACE(ex_reacquire_interpreter);

	/*
	 * If the global serialized flag is set, do not release the interpreter,
	 * since it was not actually released by acpi_ex_relinquish_interpreter.
	 * This forces the interpreter to be single threaded.
	 */
	if (!acpi_gbl_all_methods_serialized) {
		acpi_ex_enter_interpreter();
	}

	return_VOID;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_exit_interpreter
 *
 * PARAMETERS:  None
 *
 * RETURN:      None
 *
 * DESCRIPTION: Exit the interpreter execution region. This is the top level
 *              routine used to exit the interpreter when all processing has
 *              been completed.
 *
 ******************************************************************************/

void acpi_ex_exit_interpreter(void)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(ex_exit_interpreter);

	status = acpi_ut_release_mutex(ACPI_MTX_INTERPRETER);
	if (ACPI_FAILURE(status)) {
		ACPI_ERROR((AE_INFO,
			    "Could not release AML Interpreter mutex"));
	}

	return_VOID;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_relinquish_interpreter
 *
 * PARAMETERS:  None
 *
 * RETURN:      None
 *
 * DESCRIPTION: Exit the interpreter execution region, from within the
 *              interpreter - before attempting an operation that will possibly
 *              block the running thread.
 *
 * Cases where the interpreter is unlocked internally
 *      1) Method to be blocked on a Sleep() AML opcode
 *      2) Method to be blocked on an Acquire() AML opcode
 *      3) Method to be blocked on a Wait() AML opcode
 *      4) Method to be blocked to acquire the global lock
 *      5) Method to be blocked waiting to execute a serialized control method
 *          that is currently executing
 *      6) About to invoke a user-installed opregion handler
 *
 ******************************************************************************/

void acpi_ex_relinquish_interpreter(void)
{
	ACPI_FUNCTION_TRACE(ex_relinquish_interpreter);

	/*
	 * If the global serialized flag is set, do not release the interpreter.
	 * This forces the interpreter to be single threaded.
	 */
	if (!acpi_gbl_all_methods_serialized) {
		acpi_ex_exit_interpreter();
	}

	return_VOID;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_truncate_for32bit_table
 *
 * PARAMETERS:  obj_desc        - Object to be truncated
 *
 * RETURN:      none
 *
 * DESCRIPTION: Truncate an ACPI Integer to 32 bits if the execution mode is
 *              32-bit, as determined by the revision of the DSDT.
 *
 ******************************************************************************/

void acpi_ex_truncate_for32bit_table(union acpi_operand_object *obj_desc)
{

	ACPI_FUNCTION_ENTRY();

	/*
	 * Object must be a valid number and we must be executing
	 * a control method. NS node could be there for AML_INT_NAMEPATH_OP.
	 */
	if ((!obj_desc) ||
	    (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_OPERAND) ||
	    (obj_desc->common.type != ACPI_TYPE_INTEGER)) {
		return;
	}

	if (acpi_gbl_integer_byte_width == 4) {
		/*
		 * We are running a method that exists in a 32-bit ACPI table.
		 * Truncate the value to 32 bits by zeroing out the upper 32-bit field
		 */
		obj_desc->integer.value &= (acpi_integer) ACPI_UINT32_MAX;
	}
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_acquire_global_lock
 *
 * PARAMETERS:  field_flags           - Flags with Lock rule:
 *                                      always_lock or never_lock
 *
 * RETURN:      None
 *
 * DESCRIPTION: Obtain the ACPI hardware Global Lock, only if the field
 *              flags specifiy that it is to be obtained before field access.
 *
 ******************************************************************************/

void acpi_ex_acquire_global_lock(u32 field_flags)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(ex_acquire_global_lock);

	/* Only use the lock if the always_lock bit is set */

	if (!(field_flags & AML_FIELD_LOCK_RULE_MASK)) {
		return_VOID;
	}

	/* Attempt to get the global lock, wait forever */

	status = acpi_ex_acquire_mutex_object(ACPI_WAIT_FOREVER,
					      acpi_gbl_global_lock_mutex,
					      acpi_os_get_thread_id());

	if (ACPI_FAILURE(status)) {
		ACPI_EXCEPTION((AE_INFO, status,
				"Could not acquire Global Lock"));
	}

	return_VOID;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_release_global_lock
 *
 * PARAMETERS:  field_flags           - Flags with Lock rule:
 *                                      always_lock or never_lock
 *
 * RETURN:      None
 *
 * DESCRIPTION: Release the ACPI hardware Global Lock
 *
 ******************************************************************************/

void acpi_ex_release_global_lock(u32 field_flags)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(ex_release_global_lock);

	/* Only use the lock if the always_lock bit is set */

	if (!(field_flags & AML_FIELD_LOCK_RULE_MASK)) {
		return_VOID;
	}

	/* Release the global lock */

	status = acpi_ex_release_mutex_object(acpi_gbl_global_lock_mutex);
	if (ACPI_FAILURE(status)) {

		/* Report the error, but there isn't much else we can do */

		ACPI_EXCEPTION((AE_INFO, status,
				"Could not release Global Lock"));
	}

	return_VOID;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_digits_needed
 *
 * PARAMETERS:  Value           - Value to be represented
 *              Base            - Base of representation
 *
 * RETURN:      The number of digits.
 *
 * DESCRIPTION: Calculate the number of digits needed to represent the Value
 *              in the given Base (Radix)
 *
 ******************************************************************************/

static u32 acpi_ex_digits_needed(acpi_integer value, u32 base)
{
	u32 num_digits;
	acpi_integer current_value;

	ACPI_FUNCTION_TRACE(ex_digits_needed);

	/* acpi_integer is unsigned, so we don't worry about a '-' prefix */

	if (value == 0) {
		return_UINT32(1);
	}

	current_value = value;
	num_digits = 0;

	/* Count the digits in the requested base */

	while (current_value) {
		(void)acpi_ut_short_divide(current_value, base, &current_value,
					   NULL);
		num_digits++;
	}

	return_UINT32(num_digits);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_eisa_id_to_string
 *
 * PARAMETERS:  numeric_id      - EISA ID to be converted
 *              out_string      - Where to put the converted string (8 bytes)
 *
 * RETURN:      None
 *
 * DESCRIPTION: Convert a numeric EISA ID to string representation
 *
 ******************************************************************************/

void acpi_ex_eisa_id_to_string(u32 numeric_id, char *out_string)
{
	u32 eisa_id;

	ACPI_FUNCTION_ENTRY();

	/* Swap ID to big-endian to get contiguous bits */

	eisa_id = acpi_ut_dword_byte_swap(numeric_id);

	out_string[0] = (char)('@' + (((unsigned long)eisa_id >> 26) & 0x1f));
	out_string[1] = (char)('@' + ((eisa_id >> 21) & 0x1f));
	out_string[2] = (char)('@' + ((eisa_id >> 16) & 0x1f));
	out_string[3] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 12);
	out_string[4] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 8);
	out_string[5] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 4);
	out_string[6] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 0);
	out_string[7] = 0;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_unsigned_integer_to_string
 *
 * PARAMETERS:  Value           - Value to be converted
 *              out_string      - Where to put the converted string (8 bytes)
 *
 * RETURN:      None, string
 *
 * DESCRIPTION: Convert a number to string representation. Assumes string
 *              buffer is large enough to hold the string.
 *
 ******************************************************************************/

void acpi_ex_unsigned_integer_to_string(acpi_integer value, char *out_string)
{
	u32 count;
	u32 digits_needed;
	u32 remainder;

	ACPI_FUNCTION_ENTRY();

	digits_needed = acpi_ex_digits_needed(value, 10);
	out_string[digits_needed] = 0;

	for (count = digits_needed; count > 0; count--) {
		(void)acpi_ut_short_divide(value, 10, &value, &remainder);
		out_string[count - 1] = (char)('0' + remainder);
	}
}

#endif
Commit	Line	Data
1da177e4 LT	1
	2	/******************************************************************************
	3	*
	4	* Module Name: exutils - interpreter/scanner utilities
	5	*
	6	*****************************************************************************/
	7
	8	/*
75a44ce0	9	* Copyright (C) 2000 - 2008, Intel Corp.
1da177e4 LT	10	* All rights reserved.
	11	*
	12	* Redistribution and use in source and binary forms, with or without
	13	* modification, are permitted provided that the following conditions
	14	* are met:
	15	* 1. Redistributions of source code must retain the above copyright
	16	* notice, this list of conditions, and the following disclaimer,
	17	* without modification.
	18	* 2. Redistributions in binary form must reproduce at minimum a disclaimer
	19	* substantially similar to the "NO WARRANTY" disclaimer below
	20	* ("Disclaimer") and any redistribution must be conditioned upon
	21	* including a substantially similar Disclaimer requirement for further
	22	* binary redistribution.
	23	* 3. Neither the names of the above-listed copyright holders nor the names
	24	* of any contributors may be used to endorse or promote products derived
	25	* from this software without specific prior written permission.
	26	*
	27	* Alternatively, this software may be distributed under the terms of the
	28	* GNU General Public License ("GPL") version 2 as published by the Free
	29	* Software Foundation.
	30	*
	31	* NO WARRANTY
	32	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	33	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	34	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
	35	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	36	* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	37	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	38	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	39	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	40	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	41	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	42	* POSSIBILITY OF SUCH DAMAGES.
	43	*/
	44
1da177e4 LT	45	/*
	46	* DEFINE_AML_GLOBALS is tested in amlcode.h
	47	* to determine whether certain global names should be "defined" or only
	48	* "declared" in the current compilation. This enhances maintainability
	49	* by enabling a single header file to embody all knowledge of the names
	50	* in question.
	51	*
	52	* Exactly one module of any executable should #define DEFINE_GLOBALS
	53	* before #including the header files which use this convention. The
	54	* names in question will be defined and initialized in that module,
	55	* and declared as extern in all other modules which #include those
	56	* header files.
	57	*/
	58
	59	#define DEFINE_AML_GLOBALS
	60
	61	#include <acpi/acpi.h>
e2f7a777 LB	62	#include "accommon.h"
	63	#include "acinterp.h"
	64	#include "amlcode.h"
1da177e4 LT	65
1da177e4 LT	66	#define _COMPONENT ACPI_EXECUTER
4be44fcd	67	ACPI_MODULE_NAME("exutils")
1da177e4	68
44f6c012	69	/* Local prototypes */
4be44fcd	70	static u32 acpi_ex_digits_needed(acpi_integer value, u32 base);
44f6c012 RM	71
44f6c012 RM	72	#ifndef ACPI_NO_METHOD_EXECUTION
1da177e4 LT	73	/*******************************************************************************
	74	*
	75	* FUNCTION: acpi_ex_enter_interpreter
	76	*
	77	* PARAMETERS: None
	78	*
4d2acd9e	79	* RETURN: None
44f6c012	80	*
4d2acd9e LB	81	* DESCRIPTION: Enter the interpreter execution region. Failure to enter
	82	* the interpreter region is a fatal system error. Used in
	83	* conjunction with exit_interpreter.
1da177e4 LT	84	*
	85	******************************************************************************/
	86
4d2acd9e	87	void acpi_ex_enter_interpreter(void)
1da177e4	88	{
4be44fcd	89	acpi_status status;
1da177e4	90
977a6226	91	ACPI_FUNCTION_TRACE(ex_enter_interpreter);
1da177e4	92
4c90ece2	93	status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
4be44fcd	94	if (ACPI_FAILURE(status)) {
4d2acd9e LB	95	ACPI_ERROR((AE_INFO,
4d2acd9e LB	96	"Could not acquire AML Interpreter mutex"));
1da177e4 LT	97	}
1da177e4 LT	98
4d2acd9e	99	return_VOID;
1ba753ac BM	100	}
	101
	102	/*******************************************************************************
	103	*
4d2acd9e	104	* FUNCTION: acpi_ex_reacquire_interpreter
1ba753ac BM	105	*
	106	* PARAMETERS: None
	107	*
	108	* RETURN: None
1da177e4	109	*
4d2acd9e LB	110	* DESCRIPTION: Reacquire the interpreter execution region from within the
	111	* interpreter code. Failure to enter the interpreter region is a
	112	* fatal system error. Used in conjuction with
	113	* relinquish_interpreter
	114	*
	115	******************************************************************************/
	116
	117	void acpi_ex_reacquire_interpreter(void)
	118	{
	119	ACPI_FUNCTION_TRACE(ex_reacquire_interpreter);
	120
	121	/*
	122	* If the global serialized flag is set, do not release the interpreter,
	123	* since it was not actually released by acpi_ex_relinquish_interpreter.
	124	* This forces the interpreter to be single threaded.
	125	*/
	126	if (!acpi_gbl_all_methods_serialized) {
	127	acpi_ex_enter_interpreter();
	128	}
	129
	130	return_VOID;
	131	}
	132
	133	/*******************************************************************************
	134	*
	135	* FUNCTION: acpi_ex_exit_interpreter
	136	*
	137	* PARAMETERS: None
	138	*
	139	* RETURN: None
a8f4af6d	140	*
4d2acd9e LB	141	* DESCRIPTION: Exit the interpreter execution region. This is the top level
	142	* routine used to exit the interpreter when all processing has
	143	* been completed.
1da177e4 LT	144	*
	145	******************************************************************************/
	146
4be44fcd	147	void acpi_ex_exit_interpreter(void)
1da177e4	148	{
4be44fcd	149	acpi_status status;
1da177e4	150
b229cf92	151	ACPI_FUNCTION_TRACE(ex_exit_interpreter);
1da177e4	152
4c90ece2	153	status = acpi_ut_release_mutex(ACPI_MTX_INTERPRETER);
4be44fcd	154	if (ACPI_FAILURE(status)) {
4d2acd9e LB	155	ACPI_ERROR((AE_INFO,
	156	"Could not release AML Interpreter mutex"));
	157	}
	158
	159	return_VOID;
	160	}
	161
	162	/*******************************************************************************
	163	*
	164	* FUNCTION: acpi_ex_relinquish_interpreter
	165	*
	166	* PARAMETERS: None
	167	*
	168	* RETURN: None
	169	*
	170	* DESCRIPTION: Exit the interpreter execution region, from within the
	171	* interpreter - before attempting an operation that will possibly
	172	* block the running thread.
	173	*
	174	* Cases where the interpreter is unlocked internally
	175	* 1) Method to be blocked on a Sleep() AML opcode
	176	* 2) Method to be blocked on an Acquire() AML opcode
	177	* 3) Method to be blocked on a Wait() AML opcode
	178	* 4) Method to be blocked to acquire the global lock
	179	* 5) Method to be blocked waiting to execute a serialized control method
	180	* that is currently executing
	181	* 6) About to invoke a user-installed opregion handler
	182	*
	183	******************************************************************************/
	184
	185	void acpi_ex_relinquish_interpreter(void)
	186	{
	187	ACPI_FUNCTION_TRACE(ex_relinquish_interpreter);
	188
	189	/*
	190	* If the global serialized flag is set, do not release the interpreter.
	191	* This forces the interpreter to be single threaded.
	192	*/
	193	if (!acpi_gbl_all_methods_serialized) {
	194	acpi_ex_exit_interpreter();
1da177e4 LT	195	}
	196
	197	return_VOID;
	198	}
	199
1da177e4 LT	200	/*******************************************************************************
	201	*
	202	* FUNCTION: acpi_ex_truncate_for32bit_table
	203	*
	204	* PARAMETERS: obj_desc - Object to be truncated
	205	*
	206	* RETURN: none
	207	*
4d2acd9e LB	208	* DESCRIPTION: Truncate an ACPI Integer to 32 bits if the execution mode is
4d2acd9e LB	209	* 32-bit, as determined by the revision of the DSDT.
1da177e4 LT	210	*
	211	******************************************************************************/
	212
4be44fcd	213	void acpi_ex_truncate_for32bit_table(union acpi_operand_object *obj_desc)
1da177e4 LT	214	{
1da177e4 LT	215
4be44fcd	216	ACPI_FUNCTION_ENTRY();
1da177e4 LT	217
	218	/*
	219	* Object must be a valid number and we must be executing
4e3156b1	220	* a control method. NS node could be there for AML_INT_NAMEPATH_OP.
1da177e4 LT	221	*/
1da177e4 LT	222	if ((!obj_desc) \|\|
4e3156b1	223	(ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_OPERAND) \|\|
3371c19c	224	(obj_desc->common.type != ACPI_TYPE_INTEGER)) {
1da177e4 LT	225	return;
	226	}
	227
	228	if (acpi_gbl_integer_byte_width == 4) {
	229	/*
	230	* We are running a method that exists in a 32-bit ACPI table.
	231	* Truncate the value to 32 bits by zeroing out the upper 32-bit field
	232	*/
	233	obj_desc->integer.value &= (acpi_integer) ACPI_UINT32_MAX;
	234	}
	235	}
	236
1da177e4 LT	237	/*******************************************************************************
	238	*
	239	* FUNCTION: acpi_ex_acquire_global_lock
	240	*
	241	* PARAMETERS: field_flags - Flags with Lock rule:
	242	* always_lock or never_lock
	243	*
ba886cd4	244	* RETURN: None
1da177e4	245	*
ba886cd4 BM	246	* DESCRIPTION: Obtain the ACPI hardware Global Lock, only if the field
ba886cd4 BM	247	* flags specifiy that it is to be obtained before field access.
1da177e4 LT	248	*
	249	******************************************************************************/
	250
ba886cd4	251	void acpi_ex_acquire_global_lock(u32 field_flags)
1da177e4	252	{
4be44fcd	253	acpi_status status;
1da177e4	254
b229cf92	255	ACPI_FUNCTION_TRACE(ex_acquire_global_lock);
1da177e4	256
ba886cd4 BM	257	/* Only use the lock if the always_lock bit is set */
	258
	259	if (!(field_flags & AML_FIELD_LOCK_RULE_MASK)) {
	260	return_VOID;
	261	}
1da177e4	262
ba886cd4	263	/* Attempt to get the global lock, wait forever */
52fc0b02	264
ba886cd4 BM	265	status = acpi_ex_acquire_mutex_object(ACPI_WAIT_FOREVER,
	266	acpi_gbl_global_lock_mutex,
	267	acpi_os_get_thread_id());
1da177e4	268
ba886cd4 BM	269	if (ACPI_FAILURE(status)) {
	270	ACPI_EXCEPTION((AE_INFO, status,
	271	"Could not acquire Global Lock"));
1da177e4 LT	272	}
1da177e4 LT	273
ba886cd4	274	return_VOID;
1da177e4 LT	275	}
1da177e4 LT	276
1da177e4 LT	277	/*******************************************************************************
	278	*
	279	* FUNCTION: acpi_ex_release_global_lock
	280	*
f02e9fa1 BM	281	* PARAMETERS: field_flags - Flags with Lock rule:
f02e9fa1 BM	282	* always_lock or never_lock
1da177e4	283	*
44f6c012	284	* RETURN: None
1da177e4	285	*
ba886cd4	286	* DESCRIPTION: Release the ACPI hardware Global Lock
1da177e4 LT	287	*
	288	******************************************************************************/
	289
f02e9fa1	290	void acpi_ex_release_global_lock(u32 field_flags)
1da177e4	291	{
4be44fcd	292	acpi_status status;
1da177e4	293
b229cf92	294	ACPI_FUNCTION_TRACE(ex_release_global_lock);
1da177e4	295
f02e9fa1 BM	296	/* Only use the lock if the always_lock bit is set */
	297
	298	if (!(field_flags & AML_FIELD_LOCK_RULE_MASK)) {
	299	return_VOID;
	300	}
	301
ba886cd4	302	/* Release the global lock */
52fc0b02	303
ba886cd4 BM	304	status = acpi_ex_release_mutex_object(acpi_gbl_global_lock_mutex);
ba886cd4 BM	305	if (ACPI_FAILURE(status)) {
52fc0b02	306
ba886cd4	307	/* Report the error, but there isn't much else we can do */
1da177e4	308
ba886cd4 BM	309	ACPI_EXCEPTION((AE_INFO, status,
ba886cd4 BM	310	"Could not release Global Lock"));
1da177e4 LT	311	}
	312
	313	return_VOID;
	314	}
	315
1da177e4 LT	316	/*******************************************************************************
	317	*
	318	* FUNCTION: acpi_ex_digits_needed
	319	*
	320	* PARAMETERS: Value - Value to be represented
	321	* Base - Base of representation
	322	*
44f6c012 RM	323	* RETURN: The number of digits.
	324	*
	325	* DESCRIPTION: Calculate the number of digits needed to represent the Value
	326	* in the given Base (Radix)
1da177e4 LT	327	*
	328	******************************************************************************/
	329
4be44fcd	330	static u32 acpi_ex_digits_needed(acpi_integer value, u32 base)
1da177e4	331	{
4be44fcd LB	332	u32 num_digits;
4be44fcd LB	333	acpi_integer current_value;
1da177e4	334
b229cf92	335	ACPI_FUNCTION_TRACE(ex_digits_needed);
1da177e4 LT	336
	337	/* acpi_integer is unsigned, so we don't worry about a '-' prefix */
	338
	339	if (value == 0) {
50eca3eb	340	return_UINT32(1);
1da177e4 LT	341	}
	342
	343	current_value = value;
	344	num_digits = 0;
	345
	346	/* Count the digits in the requested base */
	347
	348	while (current_value) {
4be44fcd LB	349	(void)acpi_ut_short_divide(current_value, base, &current_value,
4be44fcd LB	350	NULL);
1da177e4 LT	351	num_digits++;
	352	}
	353
50eca3eb	354	return_UINT32(num_digits);
1da177e4 LT	355	}
1da177e4 LT	356
1da177e4 LT	357	/*******************************************************************************
	358	*
	359	* FUNCTION: acpi_ex_eisa_id_to_string
	360	*
	361	* PARAMETERS: numeric_id - EISA ID to be converted
	362	* out_string - Where to put the converted string (8 bytes)
	363	*
44f6c012 RM	364	* RETURN: None
44f6c012 RM	365	*
1da177e4 LT	366	* DESCRIPTION: Convert a numeric EISA ID to string representation
	367	*
	368	******************************************************************************/
	369
4be44fcd	370	void acpi_ex_eisa_id_to_string(u32 numeric_id, char *out_string)
1da177e4	371	{
4be44fcd	372	u32 eisa_id;
1da177e4	373
4be44fcd	374	ACPI_FUNCTION_ENTRY();
1da177e4 LT	375
	376	/* Swap ID to big-endian to get contiguous bits */
	377
4be44fcd	378	eisa_id = acpi_ut_dword_byte_swap(numeric_id);
1da177e4	379
4be44fcd LB	380	out_string[0] = (char)('@' + (((unsigned long)eisa_id >> 26) & 0x1f));
	381	out_string[1] = (char)('@' + ((eisa_id >> 21) & 0x1f));
	382	out_string[2] = (char)('@' + ((eisa_id >> 16) & 0x1f));
	383	out_string[3] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 12);
	384	out_string[4] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 8);
	385	out_string[5] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 4);
	386	out_string[6] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 0);
1da177e4 LT	387	out_string[7] = 0;
	388	}
	389
1da177e4 LT	390	/*******************************************************************************
	391	*
	392	* FUNCTION: acpi_ex_unsigned_integer_to_string
	393	*
	394	* PARAMETERS: Value - Value to be converted
	395	* out_string - Where to put the converted string (8 bytes)
	396	*
44f6c012 RM	397	* RETURN: None, string
44f6c012 RM	398	*
73459f73	399	* DESCRIPTION: Convert a number to string representation. Assumes string
44f6c012	400	* buffer is large enough to hold the string.
1da177e4 LT	401	*
	402	******************************************************************************/
	403
4be44fcd	404	void acpi_ex_unsigned_integer_to_string(acpi_integer value, char *out_string)
1da177e4	405	{
4be44fcd LB	406	u32 count;
	407	u32 digits_needed;
	408	u32 remainder;
1da177e4	409
4be44fcd	410	ACPI_FUNCTION_ENTRY();
1da177e4	411
4be44fcd	412	digits_needed = acpi_ex_digits_needed(value, 10);
1da177e4 LT	413	out_string[digits_needed] = 0;
	414
	415	for (count = digits_needed; count > 0; count--) {
4be44fcd LB	416	(void)acpi_ut_short_divide(value, 10, &value, &remainder);
4be44fcd LB	417	out_string[count - 1] = (char)('0' + remainder);
1da177e4 LT	418	}
	419	}
	420
	421	#endif