xref: /titanic_41/usr/src/uts/intel/io/acpica/executer/exutils.c (revision de5d74c22760a6d2cefd94d0e7f0fd87214fb71f)
1 /******************************************************************************
2  *
3  * Module Name: exutils - interpreter/scanner utilities
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2016, Intel Corp.
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 /*
45  * DEFINE_AML_GLOBALS is tested in amlcode.h
46  * to determine whether certain global names should be "defined" or only
47  * "declared" in the current compilation. This enhances maintainability
48  * by enabling a single header file to embody all knowledge of the names
49  * in question.
50  *
51  * Exactly one module of any executable should #define DEFINE_GLOBALS
52  * before #including the header files which use this convention. The
53  * names in question will be defined and initialized in that module,
54  * and declared as extern in all other modules which #include those
55  * header files.
56  */
57 
58 #define DEFINE_AML_GLOBALS
59 
60 #include "acpi.h"
61 #include "accommon.h"
62 #include "acinterp.h"
63 #include "amlcode.h"
64 
65 #define _COMPONENT          ACPI_EXECUTER
66         ACPI_MODULE_NAME    ("exutils")
67 
68 /* Local prototypes */
69 
70 static UINT32
71 AcpiExDigitsNeeded (
72     UINT64                  Value,
73     UINT32                  Base);
74 
75 
76 #ifndef ACPI_NO_METHOD_EXECUTION
77 /*******************************************************************************
78  *
79  * FUNCTION:    AcpiExEnterInterpreter
80  *
81  * PARAMETERS:  None
82  *
83  * RETURN:      None
84  *
85  * DESCRIPTION: Enter the interpreter execution region. Failure to enter
86  *              the interpreter region is a fatal system error. Used in
87  *              conjunction with ExitInterpreter.
88  *
89  ******************************************************************************/
90 
91 void
AcpiExEnterInterpreter(void)92 AcpiExEnterInterpreter (
93     void)
94 {
95     ACPI_STATUS             Status;
96 
97 
98     ACPI_FUNCTION_TRACE (ExEnterInterpreter);
99 
100 
101     Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER);
102     if (ACPI_FAILURE (Status))
103     {
104         ACPI_ERROR ((AE_INFO, "Could not acquire AML Interpreter mutex"));
105     }
106 
107     return_VOID;
108 }
109 
110 
111 /*******************************************************************************
112  *
113  * FUNCTION:    AcpiExExitInterpreter
114  *
115  * PARAMETERS:  None
116  *
117  * RETURN:      None
118  *
119  * DESCRIPTION: Exit the interpreter execution region. This is the top level
120  *              routine used to exit the interpreter when all processing has
121  *              been completed, or when the method blocks.
122  *
123  * Cases where the interpreter is unlocked internally:
124  *      1) Method will be blocked on a Sleep() AML opcode
125  *      2) Method will be blocked on an Acquire() AML opcode
126  *      3) Method will be blocked on a Wait() AML opcode
127  *      4) Method will be blocked to acquire the global lock
128  *      5) Method will be blocked waiting to execute a serialized control
129  *          method that is currently executing
130  *      6) About to invoke a user-installed opregion handler
131  *
132  ******************************************************************************/
133 
134 void
AcpiExExitInterpreter(void)135 AcpiExExitInterpreter (
136     void)
137 {
138     ACPI_STATUS             Status;
139 
140 
141     ACPI_FUNCTION_TRACE (ExExitInterpreter);
142 
143 
144     Status = AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
145     if (ACPI_FAILURE (Status))
146     {
147         ACPI_ERROR ((AE_INFO, "Could not release AML Interpreter mutex"));
148     }
149 
150     return_VOID;
151 }
152 
153 
154 /*******************************************************************************
155  *
156  * FUNCTION:    AcpiExTruncateFor32bitTable
157  *
158  * PARAMETERS:  ObjDesc         - Object to be truncated
159  *
160  * RETURN:      TRUE if a truncation was performed, FALSE otherwise.
161  *
162  * DESCRIPTION: Truncate an ACPI Integer to 32 bits if the execution mode is
163  *              32-bit, as determined by the revision of the DSDT.
164  *
165  ******************************************************************************/
166 
167 BOOLEAN
AcpiExTruncateFor32bitTable(ACPI_OPERAND_OBJECT * ObjDesc)168 AcpiExTruncateFor32bitTable (
169     ACPI_OPERAND_OBJECT     *ObjDesc)
170 {
171 
172     ACPI_FUNCTION_ENTRY ();
173 
174 
175     /*
176      * Object must be a valid number and we must be executing
177      * a control method. Object could be NS node for AML_INT_NAMEPATH_OP.
178      */
179     if ((!ObjDesc) ||
180         (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND) ||
181         (ObjDesc->Common.Type != ACPI_TYPE_INTEGER))
182     {
183         return (FALSE);
184     }
185 
186     if ((AcpiGbl_IntegerByteWidth == 4) &&
187         (ObjDesc->Integer.Value > (UINT64) ACPI_UINT32_MAX))
188     {
189         /*
190          * We are executing in a 32-bit ACPI table. Truncate
191          * the value to 32 bits by zeroing out the upper 32-bit field
192          */
193         ObjDesc->Integer.Value &= (UINT64) ACPI_UINT32_MAX;
194         return (TRUE);
195     }
196 
197     return (FALSE);
198 }
199 
200 
201 /*******************************************************************************
202  *
203  * FUNCTION:    AcpiExAcquireGlobalLock
204  *
205  * PARAMETERS:  FieldFlags            - Flags with Lock rule:
206  *                                      AlwaysLock or NeverLock
207  *
208  * RETURN:      None
209  *
210  * DESCRIPTION: Obtain the ACPI hardware Global Lock, only if the field
211  *              flags specifiy that it is to be obtained before field access.
212  *
213  ******************************************************************************/
214 
215 void
AcpiExAcquireGlobalLock(UINT32 FieldFlags)216 AcpiExAcquireGlobalLock (
217     UINT32                  FieldFlags)
218 {
219     ACPI_STATUS             Status;
220 
221 
222     ACPI_FUNCTION_TRACE (ExAcquireGlobalLock);
223 
224 
225     /* Only use the lock if the AlwaysLock bit is set */
226 
227     if (!(FieldFlags & AML_FIELD_LOCK_RULE_MASK))
228     {
229         return_VOID;
230     }
231 
232     /* Attempt to get the global lock, wait forever */
233 
234     Status = AcpiExAcquireMutexObject (ACPI_WAIT_FOREVER,
235         AcpiGbl_GlobalLockMutex, AcpiOsGetThreadId ());
236 
237     if (ACPI_FAILURE (Status))
238     {
239         ACPI_EXCEPTION ((AE_INFO, Status,
240             "Could not acquire Global Lock"));
241     }
242 
243     return_VOID;
244 }
245 
246 
247 /*******************************************************************************
248  *
249  * FUNCTION:    AcpiExReleaseGlobalLock
250  *
251  * PARAMETERS:  FieldFlags            - Flags with Lock rule:
252  *                                      AlwaysLock or NeverLock
253  *
254  * RETURN:      None
255  *
256  * DESCRIPTION: Release the ACPI hardware Global Lock
257  *
258  ******************************************************************************/
259 
260 void
AcpiExReleaseGlobalLock(UINT32 FieldFlags)261 AcpiExReleaseGlobalLock (
262     UINT32                  FieldFlags)
263 {
264     ACPI_STATUS             Status;
265 
266 
267     ACPI_FUNCTION_TRACE (ExReleaseGlobalLock);
268 
269 
270     /* Only use the lock if the AlwaysLock bit is set */
271 
272     if (!(FieldFlags & AML_FIELD_LOCK_RULE_MASK))
273     {
274         return_VOID;
275     }
276 
277     /* Release the global lock */
278 
279     Status = AcpiExReleaseMutexObject (AcpiGbl_GlobalLockMutex);
280     if (ACPI_FAILURE (Status))
281     {
282         /* Report the error, but there isn't much else we can do */
283 
284         ACPI_EXCEPTION ((AE_INFO, Status,
285             "Could not release Global Lock"));
286     }
287 
288     return_VOID;
289 }
290 
291 
292 /*******************************************************************************
293  *
294  * FUNCTION:    AcpiExDigitsNeeded
295  *
296  * PARAMETERS:  Value           - Value to be represented
297  *              Base            - Base of representation
298  *
299  * RETURN:      The number of digits.
300  *
301  * DESCRIPTION: Calculate the number of digits needed to represent the Value
302  *              in the given Base (Radix)
303  *
304  ******************************************************************************/
305 
306 static UINT32
AcpiExDigitsNeeded(UINT64 Value,UINT32 Base)307 AcpiExDigitsNeeded (
308     UINT64                  Value,
309     UINT32                  Base)
310 {
311     UINT32                  NumDigits;
312     UINT64                  CurrentValue;
313 
314 
315     ACPI_FUNCTION_TRACE (ExDigitsNeeded);
316 
317 
318     /* UINT64 is unsigned, so we don't worry about a '-' prefix */
319 
320     if (Value == 0)
321     {
322         return_UINT32 (1);
323     }
324 
325     CurrentValue = Value;
326     NumDigits = 0;
327 
328     /* Count the digits in the requested base */
329 
330     while (CurrentValue)
331     {
332         (void) AcpiUtShortDivide (CurrentValue, Base, &CurrentValue, NULL);
333         NumDigits++;
334     }
335 
336     return_UINT32 (NumDigits);
337 }
338 
339 
340 /*******************************************************************************
341  *
342  * FUNCTION:    AcpiExEisaIdToString
343  *
344  * PARAMETERS:  OutString       - Where to put the converted string (8 bytes)
345  *              CompressedId    - EISAID to be converted
346  *
347  * RETURN:      None
348  *
349  * DESCRIPTION: Convert a numeric EISAID to string representation. Return
350  *              buffer must be large enough to hold the string. The string
351  *              returned is always exactly of length ACPI_EISAID_STRING_SIZE
352  *              (includes null terminator). The EISAID is always 32 bits.
353  *
354  ******************************************************************************/
355 
356 void
AcpiExEisaIdToString(char * OutString,UINT64 CompressedId)357 AcpiExEisaIdToString (
358     char                    *OutString,
359     UINT64                  CompressedId)
360 {
361     UINT32                  SwappedId;
362 
363 
364     ACPI_FUNCTION_ENTRY ();
365 
366 
367     /* The EISAID should be a 32-bit integer */
368 
369     if (CompressedId > ACPI_UINT32_MAX)
370     {
371         ACPI_WARNING ((AE_INFO,
372             "Expected EISAID is larger than 32 bits: "
373             "0x%8.8X%8.8X, truncating",
374             ACPI_FORMAT_UINT64 (CompressedId)));
375     }
376 
377     /* Swap ID to big-endian to get contiguous bits */
378 
379     SwappedId = AcpiUtDwordByteSwap ((UINT32) CompressedId);
380 
381     /* First 3 bytes are uppercase letters. Next 4 bytes are hexadecimal */
382 
383     OutString[0] = (char) (0x40 + (((unsigned long) SwappedId >> 26) & 0x1F));
384     OutString[1] = (char) (0x40 + ((SwappedId >> 21) & 0x1F));
385     OutString[2] = (char) (0x40 + ((SwappedId >> 16) & 0x1F));
386     OutString[3] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 12);
387     OutString[4] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 8);
388     OutString[5] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 4);
389     OutString[6] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 0);
390     OutString[7] = 0;
391 }
392 
393 
394 /*******************************************************************************
395  *
396  * FUNCTION:    AcpiExIntegerToString
397  *
398  * PARAMETERS:  OutString       - Where to put the converted string. At least
399  *                                21 bytes are needed to hold the largest
400  *                                possible 64-bit integer.
401  *              Value           - Value to be converted
402  *
403  * RETURN:      Converted string in OutString
404  *
405  * DESCRIPTION: Convert a 64-bit integer to decimal string representation.
406  *              Assumes string buffer is large enough to hold the string. The
407  *              largest string is (ACPI_MAX64_DECIMAL_DIGITS + 1).
408  *
409  ******************************************************************************/
410 
411 void
AcpiExIntegerToString(char * OutString,UINT64 Value)412 AcpiExIntegerToString (
413     char                    *OutString,
414     UINT64                  Value)
415 {
416     UINT32                  Count;
417     UINT32                  DigitsNeeded;
418     UINT32                  Remainder;
419 
420 
421     ACPI_FUNCTION_ENTRY ();
422 
423 
424     DigitsNeeded = AcpiExDigitsNeeded (Value, 10);
425     OutString[DigitsNeeded] = 0;
426 
427     for (Count = DigitsNeeded; Count > 0; Count--)
428     {
429         (void) AcpiUtShortDivide (Value, 10, &Value, &Remainder);
430         OutString[Count-1] = (char) ('0' + Remainder);\
431     }
432 }
433 
434 
435 /*******************************************************************************
436  *
437  * FUNCTION:    AcpiExPciClsToString
438  *
439  * PARAMETERS:  OutString       - Where to put the converted string (7 bytes)
440  *              ClassCode       - PCI class code to be converted (3 bytes)
441  *
442  * RETURN:      Converted string in OutString
443  *
444  * DESCRIPTION: Convert 3-bytes PCI class code to string representation.
445  *              Return buffer must be large enough to hold the string. The
446  *              string returned is always exactly of length
447  *              ACPI_PCICLS_STRING_SIZE (includes null terminator).
448  *
449  ******************************************************************************/
450 
451 void
AcpiExPciClsToString(char * OutString,UINT8 ClassCode[3])452 AcpiExPciClsToString (
453     char                    *OutString,
454     UINT8                   ClassCode[3])
455 {
456 
457     ACPI_FUNCTION_ENTRY ();
458 
459 
460     /* All 3 bytes are hexadecimal */
461 
462     OutString[0] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[0], 4);
463     OutString[1] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[0], 0);
464     OutString[2] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[1], 4);
465     OutString[3] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[1], 0);
466     OutString[4] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[2], 4);
467     OutString[5] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[2], 0);
468     OutString[6] = 0;
469 }
470 
471 
472 /*******************************************************************************
473  *
474  * FUNCTION:    AcpiIsValidSpaceId
475  *
476  * PARAMETERS:  SpaceId             - ID to be validated
477  *
478  * RETURN:      TRUE if SpaceId is a valid/supported ID.
479  *
480  * DESCRIPTION: Validate an operation region SpaceID.
481  *
482  ******************************************************************************/
483 
484 BOOLEAN
AcpiIsValidSpaceId(UINT8 SpaceId)485 AcpiIsValidSpaceId (
486     UINT8                   SpaceId)
487 {
488 
489     if ((SpaceId >= ACPI_NUM_PREDEFINED_REGIONS) &&
490         (SpaceId < ACPI_USER_REGION_BEGIN) &&
491         (SpaceId != ACPI_ADR_SPACE_DATA_TABLE) &&
492         (SpaceId != ACPI_ADR_SPACE_FIXED_HARDWARE))
493     {
494         return (FALSE);
495     }
496 
497     return (TRUE);
498 }
499 
500 #endif
501