2 /******************************************************************************
4 * Module Name: exutils - interpreter/scanner utilities
6 *****************************************************************************/
9 * Copyright (C) 2000 - 2006, R. Byron Moore
10 * All rights reserved.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
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.
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.
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.
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
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
59 #define DEFINE_AML_GLOBALS
61 #include <acpi/acpi.h>
62 #include <acpi/acinterp.h>
63 #include <acpi/amlcode.h>
64 #include <acpi/acevents.h>
66 #define _COMPONENT ACPI_EXECUTER
67 ACPI_MODULE_NAME("exutils")
69 /* Local prototypes */
70 static u32
acpi_ex_digits_needed(acpi_integer value
, u32 base
);
72 #ifndef ACPI_NO_METHOD_EXECUTION
73 /*******************************************************************************
75 * FUNCTION: acpi_ex_enter_interpreter
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.
85 ******************************************************************************/
87 void acpi_ex_enter_interpreter(void)
91 ACPI_FUNCTION_TRACE(ex_reacquire_interpreter
);
93 status
= acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER
);
94 if (ACPI_FAILURE(status
)) {
96 "Could not acquire AML Interpreter mutex"));
102 /*******************************************************************************
104 * FUNCTION: acpi_ex_reacquire_interpreter
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
115 ******************************************************************************/
117 void acpi_ex_reacquire_interpreter(void)
120 ACPI_FUNCTION_TRACE(ex_reacquire_interpreter
);
123 * If the global serialized flag is set, do not release the interpreter,
124 * since it was not actually released by acpi_ex_relinquish_interpreter.
125 * This forces the interpreter to be single threaded.
127 if (!acpi_gbl_all_methods_serialized
) {
128 acpi_ex_enter_interpreter();
134 /*******************************************************************************
136 * FUNCTION: acpi_ex_exit_interpreter
142 * DESCRIPTION: Exit the interpreter execution region. This is the top level
143 * routine used to exit the interpreter when all processing has
146 ******************************************************************************/
148 void acpi_ex_exit_interpreter(void)
152 ACPI_FUNCTION_TRACE(ex_exit_interpreter
);
154 status
= acpi_ut_release_mutex(ACPI_MTX_INTERPRETER
);
155 if (ACPI_FAILURE(status
)) {
157 "Could not release AML Interpreter mutex"));
163 /*******************************************************************************
165 * FUNCTION: acpi_ex_relinquish_interpreter
171 * DESCRIPTION: Exit the interpreter execution region, from within the
172 * interpreter - before attempting an operation that will possibly
173 * block the running thread.
175 * Cases where the interpreter is unlocked internally
176 * 1) Method to be blocked on a Sleep() AML opcode
177 * 2) Method to be blocked on an Acquire() AML opcode
178 * 3) Method to be blocked on a Wait() AML opcode
179 * 4) Method to be blocked to acquire the global lock
180 * 5) Method to be blocked waiting to execute a serialized control method
181 * that is currently executing
182 * 6) About to invoke a user-installed opregion handler
184 ******************************************************************************/
186 void acpi_ex_relinquish_interpreter(void)
189 ACPI_FUNCTION_TRACE(ex_relinquish_interpreter
);
192 * If the global serialized flag is set, do not release the interpreter.
193 * This forces the interpreter to be single threaded.
195 if (!acpi_gbl_all_methods_serialized
) {
196 acpi_ex_exit_interpreter();
202 /*******************************************************************************
204 * FUNCTION: acpi_ex_truncate_for32bit_table
206 * PARAMETERS: obj_desc - Object to be truncated
210 * DESCRIPTION: Truncate an ACPI Integer to 32 bits if the execution mode is
211 * 32-bit, as determined by the revision of the DSDT.
213 ******************************************************************************/
215 void acpi_ex_truncate_for32bit_table(union acpi_operand_object
*obj_desc
)
218 ACPI_FUNCTION_ENTRY();
221 * Object must be a valid number and we must be executing
225 (ACPI_GET_OBJECT_TYPE(obj_desc
) != ACPI_TYPE_INTEGER
)) {
229 if (acpi_gbl_integer_byte_width
== 4) {
231 * We are running a method that exists in a 32-bit ACPI table.
232 * Truncate the value to 32 bits by zeroing out the upper 32-bit field
234 obj_desc
->integer
.value
&= (acpi_integer
) ACPI_UINT32_MAX
;
238 /*******************************************************************************
240 * FUNCTION: acpi_ex_acquire_global_lock
242 * PARAMETERS: field_flags - Flags with Lock rule:
243 * always_lock or never_lock
245 * RETURN: TRUE/FALSE indicating whether the lock was actually acquired
247 * DESCRIPTION: Obtain the global lock and keep track of this fact via two
248 * methods. A global variable keeps the state of the lock, and
249 * the state is returned to the caller.
251 ******************************************************************************/
253 u8
acpi_ex_acquire_global_lock(u32 field_flags
)
258 ACPI_FUNCTION_TRACE(ex_acquire_global_lock
);
260 /* Only attempt lock if the always_lock bit is set */
262 if (field_flags
& AML_FIELD_LOCK_RULE_MASK
) {
264 /* We should attempt to get the lock, wait forever */
266 status
= acpi_ev_acquire_global_lock(ACPI_WAIT_FOREVER
);
267 if (ACPI_SUCCESS(status
)) {
270 ACPI_EXCEPTION((AE_INFO
, status
,
271 "Could not acquire Global Lock"));
275 return_UINT8(locked
);
278 /*******************************************************************************
280 * FUNCTION: acpi_ex_release_global_lock
282 * PARAMETERS: locked_by_me - Return value from corresponding call to
283 * acquire_global_lock.
287 * DESCRIPTION: Release the global lock if it is locked.
289 ******************************************************************************/
291 void acpi_ex_release_global_lock(u8 locked_by_me
)
295 ACPI_FUNCTION_TRACE(ex_release_global_lock
);
297 /* Only attempt unlock if the caller locked it */
301 /* OK, now release the lock */
303 status
= acpi_ev_release_global_lock();
304 if (ACPI_FAILURE(status
)) {
306 /* Report the error, but there isn't much else we can do */
308 ACPI_EXCEPTION((AE_INFO
, status
,
309 "Could not release ACPI Global Lock"));
316 /*******************************************************************************
318 * FUNCTION: acpi_ex_digits_needed
320 * PARAMETERS: Value - Value to be represented
321 * Base - Base of representation
323 * RETURN: The number of digits.
325 * DESCRIPTION: Calculate the number of digits needed to represent the Value
326 * in the given Base (Radix)
328 ******************************************************************************/
330 static u32
acpi_ex_digits_needed(acpi_integer value
, u32 base
)
333 acpi_integer current_value
;
335 ACPI_FUNCTION_TRACE(ex_digits_needed
);
337 /* acpi_integer is unsigned, so we don't worry about a '-' prefix */
343 current_value
= value
;
346 /* Count the digits in the requested base */
348 while (current_value
) {
349 (void)acpi_ut_short_divide(current_value
, base
, ¤t_value
,
354 return_UINT32(num_digits
);
357 /*******************************************************************************
359 * FUNCTION: acpi_ex_eisa_id_to_string
361 * PARAMETERS: numeric_id - EISA ID to be converted
362 * out_string - Where to put the converted string (8 bytes)
366 * DESCRIPTION: Convert a numeric EISA ID to string representation
368 ******************************************************************************/
370 void acpi_ex_eisa_id_to_string(u32 numeric_id
, char *out_string
)
374 ACPI_FUNCTION_ENTRY();
376 /* Swap ID to big-endian to get contiguous bits */
378 eisa_id
= acpi_ut_dword_byte_swap(numeric_id
);
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);
390 /*******************************************************************************
392 * FUNCTION: acpi_ex_unsigned_integer_to_string
394 * PARAMETERS: Value - Value to be converted
395 * out_string - Where to put the converted string (8 bytes)
397 * RETURN: None, string
399 * DESCRIPTION: Convert a number to string representation. Assumes string
400 * buffer is large enough to hold the string.
402 ******************************************************************************/
404 void acpi_ex_unsigned_integer_to_string(acpi_integer value
, char *out_string
)
410 ACPI_FUNCTION_ENTRY();
412 digits_needed
= acpi_ex_digits_needed(value
, 10);
413 out_string
[digits_needed
] = 0;
415 for (count
= digits_needed
; count
> 0; count
--) {
416 (void)acpi_ut_short_divide(value
, 10, &value
, &remainder
);
417 out_string
[count
- 1] = (char)('0' + remainder
);