[deliverable/linux.git] / drivers / acpi / executer / 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 <acpi/acinterp.h>
#include <acpi/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) ||
	    (ACPI_GET_OBJECT_TYPE(obj_desc) != 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>
	62	#include <acpi/acinterp.h>
	63	#include <acpi/amlcode.h>
1da177e4 LT	64
1da177e4 LT	65	#define _COMPONENT ACPI_EXECUTER
4be44fcd	66	ACPI_MODULE_NAME("exutils")
1da177e4	67
44f6c012	68	/* Local prototypes */
4be44fcd	69	static u32 acpi_ex_digits_needed(acpi_integer value, u32 base);
44f6c012 RM	70
44f6c012 RM	71	#ifndef ACPI_NO_METHOD_EXECUTION
1da177e4 LT	72	/*******************************************************************************
	73	*
	74	* FUNCTION: acpi_ex_enter_interpreter
	75	*
	76	* PARAMETERS: None
	77	*
4d2acd9e	78	* RETURN: None
44f6c012	79	*
4d2acd9e LB	80	* DESCRIPTION: Enter the interpreter execution region. Failure to enter
	81	* the interpreter region is a fatal system error. Used in
	82	* conjunction with exit_interpreter.
1da177e4 LT	83	*
	84	******************************************************************************/
	85
4d2acd9e	86	void acpi_ex_enter_interpreter(void)
1da177e4	87	{
4be44fcd	88	acpi_status status;
1da177e4	89
977a6226	90	ACPI_FUNCTION_TRACE(ex_enter_interpreter);
1da177e4	91
4c90ece2	92	status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
4be44fcd	93	if (ACPI_FAILURE(status)) {
4d2acd9e LB	94	ACPI_ERROR((AE_INFO,
4d2acd9e LB	95	"Could not acquire AML Interpreter mutex"));
1da177e4 LT	96	}
1da177e4 LT	97
4d2acd9e	98	return_VOID;
1ba753ac BM	99	}
	100
	101	/*******************************************************************************
	102	*
4d2acd9e	103	* FUNCTION: acpi_ex_reacquire_interpreter
1ba753ac BM	104	*
	105	* PARAMETERS: None
	106	*
	107	* RETURN: None
1da177e4	108	*
4d2acd9e LB	109	* DESCRIPTION: Reacquire the interpreter execution region from within the
	110	* interpreter code. Failure to enter the interpreter region is a
	111	* fatal system error. Used in conjuction with
	112	* relinquish_interpreter
	113	*
	114	******************************************************************************/
	115
	116	void acpi_ex_reacquire_interpreter(void)
	117	{
	118	ACPI_FUNCTION_TRACE(ex_reacquire_interpreter);
	119
	120	/*
	121	* If the global serialized flag is set, do not release the interpreter,
	122	* since it was not actually released by acpi_ex_relinquish_interpreter.
	123	* This forces the interpreter to be single threaded.
	124	*/
	125	if (!acpi_gbl_all_methods_serialized) {
	126	acpi_ex_enter_interpreter();
	127	}
	128
	129	return_VOID;
	130	}
	131
	132	/*******************************************************************************
	133	*
	134	* FUNCTION: acpi_ex_exit_interpreter
	135	*
	136	* PARAMETERS: None
	137	*
	138	* RETURN: None
a8f4af6d	139	*
4d2acd9e LB	140	* DESCRIPTION: Exit the interpreter execution region. This is the top level
	141	* routine used to exit the interpreter when all processing has
	142	* been completed.
1da177e4 LT	143	*
	144	******************************************************************************/
	145
4be44fcd	146	void acpi_ex_exit_interpreter(void)
1da177e4	147	{
4be44fcd	148	acpi_status status;
1da177e4	149
b229cf92	150	ACPI_FUNCTION_TRACE(ex_exit_interpreter);
1da177e4	151
4c90ece2	152	status = acpi_ut_release_mutex(ACPI_MTX_INTERPRETER);
4be44fcd	153	if (ACPI_FAILURE(status)) {
4d2acd9e LB	154	ACPI_ERROR((AE_INFO,
	155	"Could not release AML Interpreter mutex"));
	156	}
	157
	158	return_VOID;
	159	}
	160
	161	/*******************************************************************************
	162	*
	163	* FUNCTION: acpi_ex_relinquish_interpreter
	164	*
	165	* PARAMETERS: None
	166	*
	167	* RETURN: None
	168	*
	169	* DESCRIPTION: Exit the interpreter execution region, from within the
	170	* interpreter - before attempting an operation that will possibly
	171	* block the running thread.
	172	*
	173	* Cases where the interpreter is unlocked internally
	174	* 1) Method to be blocked on a Sleep() AML opcode
	175	* 2) Method to be blocked on an Acquire() AML opcode
	176	* 3) Method to be blocked on a Wait() AML opcode
	177	* 4) Method to be blocked to acquire the global lock
	178	* 5) Method to be blocked waiting to execute a serialized control method
	179	* that is currently executing
	180	* 6) About to invoke a user-installed opregion handler
	181	*
	182	******************************************************************************/
	183
	184	void acpi_ex_relinquish_interpreter(void)
	185	{
	186	ACPI_FUNCTION_TRACE(ex_relinquish_interpreter);
	187
	188	/*
	189	* If the global serialized flag is set, do not release the interpreter.
	190	* This forces the interpreter to be single threaded.
	191	*/
	192	if (!acpi_gbl_all_methods_serialized) {
	193	acpi_ex_exit_interpreter();
1da177e4 LT	194	}
	195
	196	return_VOID;
	197	}
	198
1da177e4 LT	199	/*******************************************************************************
	200	*
	201	* FUNCTION: acpi_ex_truncate_for32bit_table
	202	*
	203	* PARAMETERS: obj_desc - Object to be truncated
	204	*
	205	* RETURN: none
	206	*
4d2acd9e LB	207	* DESCRIPTION: Truncate an ACPI Integer to 32 bits if the execution mode is
4d2acd9e LB	208	* 32-bit, as determined by the revision of the DSDT.
1da177e4 LT	209	*
	210	******************************************************************************/
	211
4be44fcd	212	void acpi_ex_truncate_for32bit_table(union acpi_operand_object *obj_desc)
1da177e4 LT	213	{
1da177e4 LT	214
4be44fcd	215	ACPI_FUNCTION_ENTRY();
1da177e4 LT	216
	217	/*
	218	* Object must be a valid number and we must be executing
4e3156b1	219	* a control method. NS node could be there for AML_INT_NAMEPATH_OP.
1da177e4 LT	220	*/
1da177e4 LT	221	if ((!obj_desc) \|\|
4e3156b1	222	(ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_OPERAND) \|\|
4be44fcd	223	(ACPI_GET_OBJECT_TYPE(obj_desc) != ACPI_TYPE_INTEGER)) {
1da177e4 LT	224	return;
	225	}
	226
	227	if (acpi_gbl_integer_byte_width == 4) {
	228	/*
	229	* We are running a method that exists in a 32-bit ACPI table.
	230	* Truncate the value to 32 bits by zeroing out the upper 32-bit field
	231	*/
	232	obj_desc->integer.value &= (acpi_integer) ACPI_UINT32_MAX;
	233	}
	234	}
	235
1da177e4 LT	236	/*******************************************************************************
	237	*
	238	* FUNCTION: acpi_ex_acquire_global_lock
	239	*
	240	* PARAMETERS: field_flags - Flags with Lock rule:
	241	* always_lock or never_lock
	242	*
ba886cd4	243	* RETURN: None
1da177e4	244	*
ba886cd4 BM	245	* DESCRIPTION: Obtain the ACPI hardware Global Lock, only if the field
ba886cd4 BM	246	* flags specifiy that it is to be obtained before field access.
1da177e4 LT	247	*
	248	******************************************************************************/
	249
ba886cd4	250	void acpi_ex_acquire_global_lock(u32 field_flags)
1da177e4	251	{
4be44fcd	252	acpi_status status;
1da177e4	253
b229cf92	254	ACPI_FUNCTION_TRACE(ex_acquire_global_lock);
1da177e4	255
ba886cd4 BM	256	/* Only use the lock if the always_lock bit is set */
	257
	258	if (!(field_flags & AML_FIELD_LOCK_RULE_MASK)) {
	259	return_VOID;
	260	}
1da177e4	261
ba886cd4	262	/* Attempt to get the global lock, wait forever */
52fc0b02	263
ba886cd4 BM	264	status = acpi_ex_acquire_mutex_object(ACPI_WAIT_FOREVER,
	265	acpi_gbl_global_lock_mutex,
	266	acpi_os_get_thread_id());
1da177e4	267
ba886cd4 BM	268	if (ACPI_FAILURE(status)) {
	269	ACPI_EXCEPTION((AE_INFO, status,
	270	"Could not acquire Global Lock"));
1da177e4 LT	271	}
1da177e4 LT	272
ba886cd4	273	return_VOID;
1da177e4 LT	274	}
1da177e4 LT	275
1da177e4 LT	276	/*******************************************************************************
	277	*
	278	* FUNCTION: acpi_ex_release_global_lock
	279	*
f02e9fa1 BM	280	* PARAMETERS: field_flags - Flags with Lock rule:
f02e9fa1 BM	281	* always_lock or never_lock
1da177e4	282	*
44f6c012	283	* RETURN: None
1da177e4	284	*
ba886cd4	285	* DESCRIPTION: Release the ACPI hardware Global Lock
1da177e4 LT	286	*
	287	******************************************************************************/
	288
f02e9fa1	289	void acpi_ex_release_global_lock(u32 field_flags)
1da177e4	290	{
4be44fcd	291	acpi_status status;
1da177e4	292
b229cf92	293	ACPI_FUNCTION_TRACE(ex_release_global_lock);
1da177e4	294
f02e9fa1 BM	295	/* Only use the lock if the always_lock bit is set */
	296
	297	if (!(field_flags & AML_FIELD_LOCK_RULE_MASK)) {
	298	return_VOID;
	299	}
	300
ba886cd4	301	/* Release the global lock */
52fc0b02	302
ba886cd4 BM	303	status = acpi_ex_release_mutex_object(acpi_gbl_global_lock_mutex);
ba886cd4 BM	304	if (ACPI_FAILURE(status)) {
52fc0b02	305
ba886cd4	306	/* Report the error, but there isn't much else we can do */
1da177e4	307
ba886cd4 BM	308	ACPI_EXCEPTION((AE_INFO, status,
ba886cd4 BM	309	"Could not release Global Lock"));
1da177e4 LT	310	}
	311
	312	return_VOID;
	313	}
	314
1da177e4 LT	315	/*******************************************************************************
	316	*
	317	* FUNCTION: acpi_ex_digits_needed
	318	*
	319	* PARAMETERS: Value - Value to be represented
	320	* Base - Base of representation
	321	*
44f6c012 RM	322	* RETURN: The number of digits.
	323	*
	324	* DESCRIPTION: Calculate the number of digits needed to represent the Value
	325	* in the given Base (Radix)
1da177e4 LT	326	*
	327	******************************************************************************/
	328
4be44fcd	329	static u32 acpi_ex_digits_needed(acpi_integer value, u32 base)
1da177e4	330	{
4be44fcd LB	331	u32 num_digits;
4be44fcd LB	332	acpi_integer current_value;
1da177e4	333
b229cf92	334	ACPI_FUNCTION_TRACE(ex_digits_needed);
1da177e4 LT	335
	336	/* acpi_integer is unsigned, so we don't worry about a '-' prefix */
	337
	338	if (value == 0) {
50eca3eb	339	return_UINT32(1);
1da177e4 LT	340	}
	341
	342	current_value = value;
	343	num_digits = 0;
	344
	345	/* Count the digits in the requested base */
	346
	347	while (current_value) {
4be44fcd LB	348	(void)acpi_ut_short_divide(current_value, base, &current_value,
4be44fcd LB	349	NULL);
1da177e4 LT	350	num_digits++;
	351	}
	352
50eca3eb	353	return_UINT32(num_digits);
1da177e4 LT	354	}
1da177e4 LT	355
1da177e4 LT	356	/*******************************************************************************
	357	*
	358	* FUNCTION: acpi_ex_eisa_id_to_string
	359	*
	360	* PARAMETERS: numeric_id - EISA ID to be converted
	361	* out_string - Where to put the converted string (8 bytes)
	362	*
44f6c012 RM	363	* RETURN: None
44f6c012 RM	364	*
1da177e4 LT	365	* DESCRIPTION: Convert a numeric EISA ID to string representation
	366	*
	367	******************************************************************************/
	368
4be44fcd	369	void acpi_ex_eisa_id_to_string(u32 numeric_id, char *out_string)
1da177e4	370	{
4be44fcd	371	u32 eisa_id;
1da177e4	372
4be44fcd	373	ACPI_FUNCTION_ENTRY();
1da177e4 LT	374
	375	/* Swap ID to big-endian to get contiguous bits */
	376
4be44fcd	377	eisa_id = acpi_ut_dword_byte_swap(numeric_id);
1da177e4	378
4be44fcd LB	379	out_string[0] = (char)('@' + (((unsigned long)eisa_id >> 26) & 0x1f));
	380	out_string[1] = (char)('@' + ((eisa_id >> 21) & 0x1f));
	381	out_string[2] = (char)('@' + ((eisa_id >> 16) & 0x1f));
	382	out_string[3] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 12);
	383	out_string[4] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 8);
	384	out_string[5] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 4);
	385	out_string[6] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 0);
1da177e4 LT	386	out_string[7] = 0;
	387	}
	388
1da177e4 LT	389	/*******************************************************************************
	390	*
	391	* FUNCTION: acpi_ex_unsigned_integer_to_string
	392	*
	393	* PARAMETERS: Value - Value to be converted
	394	* out_string - Where to put the converted string (8 bytes)
	395	*
44f6c012 RM	396	* RETURN: None, string
44f6c012 RM	397	*
73459f73	398	* DESCRIPTION: Convert a number to string representation. Assumes string
44f6c012	399	* buffer is large enough to hold the string.
1da177e4 LT	400	*
	401	******************************************************************************/
	402
4be44fcd	403	void acpi_ex_unsigned_integer_to_string(acpi_integer value, char *out_string)
1da177e4	404	{
4be44fcd LB	405	u32 count;
	406	u32 digits_needed;
	407	u32 remainder;
1da177e4	408
4be44fcd	409	ACPI_FUNCTION_ENTRY();
1da177e4	410
4be44fcd	411	digits_needed = acpi_ex_digits_needed(value, 10);
1da177e4 LT	412	out_string[digits_needed] = 0;
	413
	414	for (count = digits_needed; count > 0; count--) {
4be44fcd LB	415	(void)acpi_ut_short_divide(value, 10, &value, &remainder);
4be44fcd LB	416	out_string[count - 1] = (char)('0' + remainder);
1da177e4 LT	417	}
	418	}
	419
	420	#endif