ACPICA: Re-implement interpreters' "serialized mode"
[sfrench/cifs-2.6.git] / drivers / acpi / executer / exutils.c
1
2 /******************************************************************************
3  *
4  * Module Name: exutils - interpreter/scanner utilities
5  *
6  *****************************************************************************/
7
8 /*
9  * Copyright (C) 2000 - 2006, R. Byron Moore
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
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>
64 #include <acpi/acevents.h>
65
66 #define _COMPONENT          ACPI_EXECUTER
67 ACPI_MODULE_NAME("exutils")
68
69 /* Local prototypes */
70 static u32 acpi_ex_digits_needed(acpi_integer value, u32 base);
71
72 #ifndef ACPI_NO_METHOD_EXECUTION
73 /*******************************************************************************
74  *
75  * FUNCTION:    acpi_ex_enter_interpreter
76  *
77  * PARAMETERS:  None
78  *
79  * RETURN:      None
80  *
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.
84  *
85  ******************************************************************************/
86
87 void acpi_ex_enter_interpreter(void)
88 {
89         acpi_status status;
90
91         ACPI_FUNCTION_TRACE(ex_reacquire_interpreter);
92
93         status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
94         if (ACPI_FAILURE(status)) {
95                 ACPI_ERROR((AE_INFO,
96                             "Could not acquire AML Interpreter mutex"));
97         }
98
99         return_VOID;
100 }
101
102 /*******************************************************************************
103  *
104  * FUNCTION:    acpi_ex_reacquire_interpreter
105  *
106  * PARAMETERS:  None
107  *
108  * RETURN:      None
109  *
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
120         ACPI_FUNCTION_TRACE(ex_reacquire_interpreter);
121
122         /*
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.
126          */
127         if (!acpi_gbl_all_methods_serialized) {
128                 acpi_ex_enter_interpreter();
129         }
130
131         return_VOID;
132 }
133
134 /*******************************************************************************
135  *
136  * FUNCTION:    acpi_ex_exit_interpreter
137  *
138  * PARAMETERS:  None
139  *
140  * RETURN:      None
141  *
142  * DESCRIPTION: Exit the interpreter execution region. This is the top level
143  *              routine used to exit the interpreter when all processing has
144  *              been completed.
145  *
146  ******************************************************************************/
147
148 void acpi_ex_exit_interpreter(void)
149 {
150         acpi_status status;
151
152         ACPI_FUNCTION_TRACE(ex_exit_interpreter);
153
154         status = acpi_ut_release_mutex(ACPI_MTX_INTERPRETER);
155         if (ACPI_FAILURE(status)) {
156                 ACPI_ERROR((AE_INFO,
157                             "Could not release AML Interpreter mutex"));
158         }
159
160         return_VOID;
161 }
162
163 /*******************************************************************************
164  *
165  * FUNCTION:    acpi_ex_relinquish_interpreter
166  *
167  * PARAMETERS:  None
168  *
169  * RETURN:      None
170  *
171  * DESCRIPTION: Exit the interpreter execution region, from within the
172  *              interpreter - before attempting an operation that will possibly
173  *              block the running thread.
174  *
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
183  *
184  ******************************************************************************/
185
186 void acpi_ex_relinquish_interpreter(void)
187 {
188
189         ACPI_FUNCTION_TRACE(ex_relinquish_interpreter);
190
191         /*
192          * If the global serialized flag is set, do not release the interpreter.
193          * This forces the interpreter to be single threaded.
194          */
195         if (!acpi_gbl_all_methods_serialized) {
196                 acpi_ex_exit_interpreter();
197         }
198
199         return_VOID;
200 }
201
202 /*******************************************************************************
203  *
204  * FUNCTION:    acpi_ex_truncate_for32bit_table
205  *
206  * PARAMETERS:  obj_desc        - Object to be truncated
207  *
208  * RETURN:      none
209  *
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.
212  *
213  ******************************************************************************/
214
215 void acpi_ex_truncate_for32bit_table(union acpi_operand_object *obj_desc)
216 {
217
218         ACPI_FUNCTION_ENTRY();
219
220         /*
221          * Object must be a valid number and we must be executing
222          * a control method
223          */
224         if ((!obj_desc) ||
225             (ACPI_GET_OBJECT_TYPE(obj_desc) != ACPI_TYPE_INTEGER)) {
226                 return;
227         }
228
229         if (acpi_gbl_integer_byte_width == 4) {
230                 /*
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
233                  */
234                 obj_desc->integer.value &= (acpi_integer) ACPI_UINT32_MAX;
235         }
236 }
237
238 /*******************************************************************************
239  *
240  * FUNCTION:    acpi_ex_acquire_global_lock
241  *
242  * PARAMETERS:  field_flags           - Flags with Lock rule:
243  *                                      always_lock or never_lock
244  *
245  * RETURN:      TRUE/FALSE indicating whether the lock was actually acquired
246  *
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.
250  *
251  ******************************************************************************/
252
253 u8 acpi_ex_acquire_global_lock(u32 field_flags)
254 {
255         u8 locked = FALSE;
256         acpi_status status;
257
258         ACPI_FUNCTION_TRACE(ex_acquire_global_lock);
259
260         /* Only attempt lock if the always_lock bit is set */
261
262         if (field_flags & AML_FIELD_LOCK_RULE_MASK) {
263
264                 /* We should attempt to get the lock, wait forever */
265
266                 status = acpi_ev_acquire_global_lock(ACPI_WAIT_FOREVER);
267                 if (ACPI_SUCCESS(status)) {
268                         locked = TRUE;
269                 } else {
270                         ACPI_EXCEPTION((AE_INFO, status,
271                                         "Could not acquire Global Lock"));
272                 }
273         }
274
275         return_UINT8(locked);
276 }
277
278 /*******************************************************************************
279  *
280  * FUNCTION:    acpi_ex_release_global_lock
281  *
282  * PARAMETERS:  locked_by_me    - Return value from corresponding call to
283  *                                acquire_global_lock.
284  *
285  * RETURN:      None
286  *
287  * DESCRIPTION: Release the global lock if it is locked.
288  *
289  ******************************************************************************/
290
291 void acpi_ex_release_global_lock(u8 locked_by_me)
292 {
293         acpi_status status;
294
295         ACPI_FUNCTION_TRACE(ex_release_global_lock);
296
297         /* Only attempt unlock if the caller locked it */
298
299         if (locked_by_me) {
300
301                 /* OK, now release the lock */
302
303                 status = acpi_ev_release_global_lock();
304                 if (ACPI_FAILURE(status)) {
305
306                         /* Report the error, but there isn't much else we can do */
307
308                         ACPI_EXCEPTION((AE_INFO, status,
309                                         "Could not release ACPI Global Lock"));
310                 }
311         }
312
313         return_VOID;
314 }
315
316 /*******************************************************************************
317  *
318  * FUNCTION:    acpi_ex_digits_needed
319  *
320  * PARAMETERS:  Value           - Value to be represented
321  *              Base            - Base of representation
322  *
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)
327  *
328  ******************************************************************************/
329
330 static u32 acpi_ex_digits_needed(acpi_integer value, u32 base)
331 {
332         u32 num_digits;
333         acpi_integer current_value;
334
335         ACPI_FUNCTION_TRACE(ex_digits_needed);
336
337         /* acpi_integer is unsigned, so we don't worry about a '-' prefix */
338
339         if (value == 0) {
340                 return_UINT32(1);
341         }
342
343         current_value = value;
344         num_digits = 0;
345
346         /* Count the digits in the requested base */
347
348         while (current_value) {
349                 (void)acpi_ut_short_divide(current_value, base, &current_value,
350                                            NULL);
351                 num_digits++;
352         }
353
354         return_UINT32(num_digits);
355 }
356
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  *
364  * RETURN:      None
365  *
366  * DESCRIPTION: Convert a numeric EISA ID to string representation
367  *
368  ******************************************************************************/
369
370 void acpi_ex_eisa_id_to_string(u32 numeric_id, char *out_string)
371 {
372         u32 eisa_id;
373
374         ACPI_FUNCTION_ENTRY();
375
376         /* Swap ID to big-endian to get contiguous bits */
377
378         eisa_id = acpi_ut_dword_byte_swap(numeric_id);
379
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);
387         out_string[7] = 0;
388 }
389
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  *
397  * RETURN:      None, string
398  *
399  * DESCRIPTION: Convert a number to string representation. Assumes string
400  *              buffer is large enough to hold the string.
401  *
402  ******************************************************************************/
403
404 void acpi_ex_unsigned_integer_to_string(acpi_integer value, char *out_string)
405 {
406         u32 count;
407         u32 digits_needed;
408         u32 remainder;
409
410         ACPI_FUNCTION_ENTRY();
411
412         digits_needed = acpi_ex_digits_needed(value, 10);
413         out_string[digits_needed] = 0;
414
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);
418         }
419 }
420
421 #endif