1 /******************************************************************************
2 *
3 * Module Name: utglobal - Global variables for the ACPI subsystem
4 *
5 *****************************************************************************/
6
7 /******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************/
115
116 #define __UTGLOBAL_C__
117 #define DEFINE_ACPI_GLOBALS
118
119 #include "acpi.h"
120 #include "accommon.h"
121 #include "acnamesp.h"
122
123 #define _COMPONENT ACPI_UTILITIES
124 ACPI_MODULE_NAME ("utglobal")
125
126
127 /*******************************************************************************
128 *
129 * Static global variable initialization.
130 *
131 ******************************************************************************/
132
133 /*
134 * We want the debug switches statically initialized so they
135 * are already set when the debugger is entered.
136 */
137
138 /* Debug switch - level and trace mask */
139
140 #ifdef ACPI_DEBUG_OUTPUT
141 UINT32 AcpiDbgLevel = ACPI_DEBUG_DEFAULT;
142 #else
143 UINT32 AcpiDbgLevel = ACPI_NORMAL_DEFAULT;
144 #endif
145
146 /* Debug switch - layer (component) mask */
147
148 UINT32 AcpiDbgLayer = ACPI_COMPONENT_DEFAULT;
149 UINT32 AcpiGbl_NestingLevel = 0;
150
151 /* Debugger globals */
152
153 BOOLEAN AcpiGbl_DbTerminateThreads = FALSE;
154 BOOLEAN AcpiGbl_AbortMethod = FALSE;
155 BOOLEAN AcpiGbl_MethodExecuting = FALSE;
156
157 /* System flags */
158
159 UINT32 AcpiGbl_StartupFlags = 0;
160
161 /* System starts uninitialized */
162
163 BOOLEAN AcpiGbl_Shutdown = TRUE;
164
165 const char *AcpiGbl_SleepStateNames[ACPI_S_STATE_COUNT] =
166 {
167 "\\_S0_",
168 "\\_S1_",
169 "\\_S2_",
170 "\\_S3_",
171 "\\_S4_",
172 "\\_S5_"
173 };
174
175 const char *AcpiGbl_LowestDstateNames[ACPI_NUM_SxW_METHODS] =
176 {
177 "_S0W",
178 "_S1W",
179 "_S2W",
180 "_S3W",
181 "_S4W"
182 };
183
184 const char *AcpiGbl_HighestDstateNames[ACPI_NUM_SxD_METHODS] =
185 {
186 "_S1D",
187 "_S2D",
188 "_S3D",
189 "_S4D"
190 };
191
192
193 /*******************************************************************************
194 *
195 * FUNCTION: AcpiFormatException
196 *
197 * PARAMETERS: Status - The ACPI_STATUS code to be formatted
198 *
199 * RETURN: A string containing the exception text. A valid pointer is
200 * always returned.
201 *
202 * DESCRIPTION: This function translates an ACPI exception into an ASCII string
203 * It is here instead of utxface.c so it is always present.
204 *
205 ******************************************************************************/
206
207 const char *
AcpiFormatException(ACPI_STATUS Status)208 AcpiFormatException (
209 ACPI_STATUS Status)
210 {
211 const char *Exception = NULL;
212
213
214 ACPI_FUNCTION_ENTRY ();
215
216
217 Exception = AcpiUtValidateException (Status);
218 if (!Exception)
219 {
220 /* Exception code was not recognized */
221
222 ACPI_ERROR ((AE_INFO,
223 "Unknown exception code: 0x%8.8X", Status));
224
225 Exception = "UNKNOWN_STATUS_CODE";
226 }
227
228 return (ACPI_CAST_PTR (const char, Exception));
229 }
230
231 ACPI_EXPORT_SYMBOL (AcpiFormatException)
232
233
234 /*******************************************************************************
235 *
236 * Namespace globals
237 *
238 ******************************************************************************/
239
240 /*
241 * Predefined ACPI Names (Built-in to the Interpreter)
242 *
243 * NOTES:
244 * 1) _SB_ is defined to be a device to allow \_SB_._INI to be run
245 * during the initialization sequence.
246 * 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to
247 * perform a Notify() operation on it.
248 */
249 const ACPI_PREDEFINED_NAMES AcpiGbl_PreDefinedNames[] =
250 {
251 {"_GPE", ACPI_TYPE_LOCAL_SCOPE, NULL},
252 {"_PR_", ACPI_TYPE_LOCAL_SCOPE, NULL},
253 {"_SB_", ACPI_TYPE_DEVICE, NULL},
254 {"_SI_", ACPI_TYPE_LOCAL_SCOPE, NULL},
255 {"_TZ_", ACPI_TYPE_THERMAL, NULL},
256 {"_REV", ACPI_TYPE_INTEGER, (char *) ACPI_CA_SUPPORT_LEVEL},
257 {"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME},
258 {"_GL_", ACPI_TYPE_MUTEX, (char *) 1},
259
260 #if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)
261 {"_OSI", ACPI_TYPE_METHOD, (char *) 1},
262 #endif
263
264 /* Table terminator */
265
266 {NULL, ACPI_TYPE_ANY, NULL}
267 };
268
269 /*
270 * Properties of the ACPI Object Types, both internal and external.
271 * The table is indexed by values of ACPI_OBJECT_TYPE
272 */
273 const UINT8 AcpiGbl_NsProperties[ACPI_NUM_NS_TYPES] =
274 {
275 ACPI_NS_NORMAL, /* 00 Any */
276 ACPI_NS_NORMAL, /* 01 Number */
277 ACPI_NS_NORMAL, /* 02 String */
278 ACPI_NS_NORMAL, /* 03 Buffer */
279 ACPI_NS_NORMAL, /* 04 Package */
280 ACPI_NS_NORMAL, /* 05 FieldUnit */
281 ACPI_NS_NEWSCOPE, /* 06 Device */
282 ACPI_NS_NORMAL, /* 07 Event */
283 ACPI_NS_NEWSCOPE, /* 08 Method */
284 ACPI_NS_NORMAL, /* 09 Mutex */
285 ACPI_NS_NORMAL, /* 10 Region */
286 ACPI_NS_NEWSCOPE, /* 11 Power */
287 ACPI_NS_NEWSCOPE, /* 12 Processor */
288 ACPI_NS_NEWSCOPE, /* 13 Thermal */
289 ACPI_NS_NORMAL, /* 14 BufferField */
290 ACPI_NS_NORMAL, /* 15 DdbHandle */
291 ACPI_NS_NORMAL, /* 16 Debug Object */
292 ACPI_NS_NORMAL, /* 17 DefField */
293 ACPI_NS_NORMAL, /* 18 BankField */
294 ACPI_NS_NORMAL, /* 19 IndexField */
295 ACPI_NS_NORMAL, /* 20 Reference */
296 ACPI_NS_NORMAL, /* 21 Alias */
297 ACPI_NS_NORMAL, /* 22 MethodAlias */
298 ACPI_NS_NORMAL, /* 23 Notify */
299 ACPI_NS_NORMAL, /* 24 Address Handler */
300 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 25 Resource Desc */
301 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 26 Resource Field */
302 ACPI_NS_NEWSCOPE, /* 27 Scope */
303 ACPI_NS_NORMAL, /* 28 Extra */
304 ACPI_NS_NORMAL, /* 29 Data */
305 ACPI_NS_NORMAL /* 30 Invalid */
306 };
307
308
309 /* Hex to ASCII conversion table */
310
311 static const char AcpiGbl_HexToAscii[] =
312 {
313 '0','1','2','3','4','5','6','7',
314 '8','9','A','B','C','D','E','F'
315 };
316
317
318 /*******************************************************************************
319 *
320 * FUNCTION: AcpiUtHexToAsciiChar
321 *
322 * PARAMETERS: Integer - Contains the hex digit
323 * Position - bit position of the digit within the
324 * integer (multiple of 4)
325 *
326 * RETURN: The converted Ascii character
327 *
328 * DESCRIPTION: Convert a hex digit to an Ascii character
329 *
330 ******************************************************************************/
331
332 char
AcpiUtHexToAsciiChar(ACPI_INTEGER Integer,UINT32 Position)333 AcpiUtHexToAsciiChar (
334 ACPI_INTEGER Integer,
335 UINT32 Position)
336 {
337
338 return (AcpiGbl_HexToAscii[(Integer >> Position) & 0xF]);
339 }
340
341
342 /******************************************************************************
343 *
344 * Event and Hardware globals
345 *
346 ******************************************************************************/
347
348 ACPI_BIT_REGISTER_INFO AcpiGbl_BitRegisterInfo[ACPI_NUM_BITREG] =
349 {
350 /* Name Parent Register Register Bit Position Register Bit Mask */
351
352 /* ACPI_BITREG_TIMER_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_TIMER_STATUS, ACPI_BITMASK_TIMER_STATUS},
353 /* ACPI_BITREG_BUS_MASTER_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_BUS_MASTER_STATUS, ACPI_BITMASK_BUS_MASTER_STATUS},
354 /* ACPI_BITREG_GLOBAL_LOCK_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_GLOBAL_LOCK_STATUS, ACPI_BITMASK_GLOBAL_LOCK_STATUS},
355 /* ACPI_BITREG_POWER_BUTTON_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_POWER_BUTTON_STATUS, ACPI_BITMASK_POWER_BUTTON_STATUS},
356 /* ACPI_BITREG_SLEEP_BUTTON_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_SLEEP_BUTTON_STATUS, ACPI_BITMASK_SLEEP_BUTTON_STATUS},
357 /* ACPI_BITREG_RT_CLOCK_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_RT_CLOCK_STATUS, ACPI_BITMASK_RT_CLOCK_STATUS},
358 /* ACPI_BITREG_WAKE_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_WAKE_STATUS, ACPI_BITMASK_WAKE_STATUS},
359 /* ACPI_BITREG_PCIEXP_WAKE_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_PCIEXP_WAKE_STATUS, ACPI_BITMASK_PCIEXP_WAKE_STATUS},
360
361 /* ACPI_BITREG_TIMER_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_TIMER_ENABLE, ACPI_BITMASK_TIMER_ENABLE},
362 /* ACPI_BITREG_GLOBAL_LOCK_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE, ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
363 /* ACPI_BITREG_POWER_BUTTON_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_ENABLE},
364 /* ACPI_BITREG_SLEEP_BUTTON_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
365 /* ACPI_BITREG_RT_CLOCK_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_RT_CLOCK_ENABLE, ACPI_BITMASK_RT_CLOCK_ENABLE},
366 /* ACPI_BITREG_PCIEXP_WAKE_DISABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE, ACPI_BITMASK_PCIEXP_WAKE_DISABLE},
367
368 /* ACPI_BITREG_SCI_ENABLE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SCI_ENABLE, ACPI_BITMASK_SCI_ENABLE},
369 /* ACPI_BITREG_BUS_MASTER_RLD */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_BUS_MASTER_RLD, ACPI_BITMASK_BUS_MASTER_RLD},
370 /* ACPI_BITREG_GLOBAL_LOCK_RELEASE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE, ACPI_BITMASK_GLOBAL_LOCK_RELEASE},
371 /* ACPI_BITREG_SLEEP_TYPE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SLEEP_TYPE, ACPI_BITMASK_SLEEP_TYPE},
372 /* ACPI_BITREG_SLEEP_ENABLE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SLEEP_ENABLE, ACPI_BITMASK_SLEEP_ENABLE},
373
374 /* ACPI_BITREG_ARB_DIS */ {ACPI_REGISTER_PM2_CONTROL, ACPI_BITPOSITION_ARB_DISABLE, ACPI_BITMASK_ARB_DISABLE}
375 };
376
377
378 ACPI_FIXED_EVENT_INFO AcpiGbl_FixedEventInfo[ACPI_NUM_FIXED_EVENTS] =
379 {
380 /* ACPI_EVENT_PMTIMER */ {ACPI_BITREG_TIMER_STATUS, ACPI_BITREG_TIMER_ENABLE, ACPI_BITMASK_TIMER_STATUS, ACPI_BITMASK_TIMER_ENABLE},
381 /* ACPI_EVENT_GLOBAL */ {ACPI_BITREG_GLOBAL_LOCK_STATUS, ACPI_BITREG_GLOBAL_LOCK_ENABLE, ACPI_BITMASK_GLOBAL_LOCK_STATUS, ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
382 /* ACPI_EVENT_POWER_BUTTON */ {ACPI_BITREG_POWER_BUTTON_STATUS, ACPI_BITREG_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_STATUS, ACPI_BITMASK_POWER_BUTTON_ENABLE},
383 /* ACPI_EVENT_SLEEP_BUTTON */ {ACPI_BITREG_SLEEP_BUTTON_STATUS, ACPI_BITREG_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_STATUS, ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
384 /* ACPI_EVENT_RTC */ {ACPI_BITREG_RT_CLOCK_STATUS, ACPI_BITREG_RT_CLOCK_ENABLE, ACPI_BITMASK_RT_CLOCK_STATUS, ACPI_BITMASK_RT_CLOCK_ENABLE},
385 };
386
387 /*******************************************************************************
388 *
389 * FUNCTION: AcpiUtGetRegionName
390 *
391 * PARAMETERS: None.
392 *
393 * RETURN: Status
394 *
395 * DESCRIPTION: Translate a Space ID into a name string (Debug only)
396 *
397 ******************************************************************************/
398
399 /* Region type decoding */
400
401 const char *AcpiGbl_RegionTypes[ACPI_NUM_PREDEFINED_REGIONS] =
402 {
403 "SystemMemory",
404 "SystemIO",
405 "PCI_Config",
406 "EmbeddedControl",
407 "SMBus",
408 "SystemCMOS",
409 "PCIBARTarget",
410 "IPMI",
411 "DataTable"
412 };
413
414
415 char *
AcpiUtGetRegionName(UINT8 SpaceId)416 AcpiUtGetRegionName (
417 UINT8 SpaceId)
418 {
419
420 if (SpaceId >= ACPI_USER_REGION_BEGIN)
421 {
422 return ("UserDefinedRegion");
423 }
424 else if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS)
425 {
426 return ("InvalidSpaceId");
427 }
428
429 return (ACPI_CAST_PTR (char, AcpiGbl_RegionTypes[SpaceId]));
430 }
431
432
433 /*******************************************************************************
434 *
435 * FUNCTION: AcpiUtGetEventName
436 *
437 * PARAMETERS: None.
438 *
439 * RETURN: Status
440 *
441 * DESCRIPTION: Translate a Event ID into a name string (Debug only)
442 *
443 ******************************************************************************/
444
445 /* Event type decoding */
446
447 static const char *AcpiGbl_EventTypes[ACPI_NUM_FIXED_EVENTS] =
448 {
449 "PM_Timer",
450 "GlobalLock",
451 "PowerButton",
452 "SleepButton",
453 "RealTimeClock",
454 };
455
456
457 char *
AcpiUtGetEventName(UINT32 EventId)458 AcpiUtGetEventName (
459 UINT32 EventId)
460 {
461
462 if (EventId > ACPI_EVENT_MAX)
463 {
464 return ("InvalidEventID");
465 }
466
467 return (ACPI_CAST_PTR (char, AcpiGbl_EventTypes[EventId]));
468 }
469
470
471 /*******************************************************************************
472 *
473 * FUNCTION: AcpiUtGetTypeName
474 *
475 * PARAMETERS: None.
476 *
477 * RETURN: Status
478 *
479 * DESCRIPTION: Translate a Type ID into a name string (Debug only)
480 *
481 ******************************************************************************/
482
483 /*
484 * Elements of AcpiGbl_NsTypeNames below must match
485 * one-to-one with values of ACPI_OBJECT_TYPE
486 *
487 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
488 * when stored in a table it really means that we have thus far seen no
489 * evidence to indicate what type is actually going to be stored for this entry.
490 */
491 static const char AcpiGbl_BadType[] = "UNDEFINED";
492
493 /* Printable names of the ACPI object types */
494
495 static const char *AcpiGbl_NsTypeNames[] =
496 {
497 /* 00 */ "Untyped",
498 /* 01 */ "Integer",
499 /* 02 */ "String",
500 /* 03 */ "Buffer",
501 /* 04 */ "Package",
502 /* 05 */ "FieldUnit",
503 /* 06 */ "Device",
504 /* 07 */ "Event",
505 /* 08 */ "Method",
506 /* 09 */ "Mutex",
507 /* 10 */ "Region",
508 /* 11 */ "Power",
509 /* 12 */ "Processor",
510 /* 13 */ "Thermal",
511 /* 14 */ "BufferField",
512 /* 15 */ "DdbHandle",
513 /* 16 */ "DebugObject",
514 /* 17 */ "RegionField",
515 /* 18 */ "BankField",
516 /* 19 */ "IndexField",
517 /* 20 */ "Reference",
518 /* 21 */ "Alias",
519 /* 22 */ "MethodAlias",
520 /* 23 */ "Notify",
521 /* 24 */ "AddrHandler",
522 /* 25 */ "ResourceDesc",
523 /* 26 */ "ResourceFld",
524 /* 27 */ "Scope",
525 /* 28 */ "Extra",
526 /* 29 */ "Data",
527 /* 30 */ "Invalid"
528 };
529
530
531 char *
AcpiUtGetTypeName(ACPI_OBJECT_TYPE Type)532 AcpiUtGetTypeName (
533 ACPI_OBJECT_TYPE Type)
534 {
535
536 if (Type > ACPI_TYPE_INVALID)
537 {
538 return (ACPI_CAST_PTR (char, AcpiGbl_BadType));
539 }
540
541 return (ACPI_CAST_PTR (char, AcpiGbl_NsTypeNames[Type]));
542 }
543
544
545 char *
AcpiUtGetObjectTypeName(ACPI_OPERAND_OBJECT * ObjDesc)546 AcpiUtGetObjectTypeName (
547 ACPI_OPERAND_OBJECT *ObjDesc)
548 {
549
550 if (!ObjDesc)
551 {
552 return ("[NULL Object Descriptor]");
553 }
554
555 return (AcpiUtGetTypeName (ObjDesc->Common.Type));
556 }
557
558
559 /*******************************************************************************
560 *
561 * FUNCTION: AcpiUtGetNodeName
562 *
563 * PARAMETERS: Object - A namespace node
564 *
565 * RETURN: Pointer to a string
566 *
567 * DESCRIPTION: Validate the node and return the node's ACPI name.
568 *
569 ******************************************************************************/
570
571 char *
AcpiUtGetNodeName(void * Object)572 AcpiUtGetNodeName (
573 void *Object)
574 {
575 ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) Object;
576
577
578 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
579
580 if (!Object)
581 {
582 return ("NULL");
583 }
584
585 /* Check for Root node */
586
587 if ((Object == ACPI_ROOT_OBJECT) ||
588 (Object == AcpiGbl_RootNode))
589 {
590 return ("\"\\\" ");
591 }
592
593 /* Descriptor must be a namespace node */
594
595 if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
596 {
597 return ("####");
598 }
599
600 /*
601 * Ensure name is valid. The name was validated/repaired when the node
602 * was created, but make sure it has not been corrupted.
603 */
604 AcpiUtRepairName (Node->Name.Ascii);
605
606 /* Return the name */
607
608 return (Node->Name.Ascii);
609 }
610
611
612 /*******************************************************************************
613 *
614 * FUNCTION: AcpiUtGetDescriptorName
615 *
616 * PARAMETERS: Object - An ACPI object
617 *
618 * RETURN: Pointer to a string
619 *
620 * DESCRIPTION: Validate object and return the descriptor type
621 *
622 ******************************************************************************/
623
624 /* Printable names of object descriptor types */
625
626 static const char *AcpiGbl_DescTypeNames[] =
627 {
628 /* 00 */ "Invalid",
629 /* 01 */ "Cached",
630 /* 02 */ "State-Generic",
631 /* 03 */ "State-Update",
632 /* 04 */ "State-Package",
633 /* 05 */ "State-Control",
634 /* 06 */ "State-RootParseScope",
635 /* 07 */ "State-ParseScope",
636 /* 08 */ "State-WalkScope",
637 /* 09 */ "State-Result",
638 /* 10 */ "State-Notify",
639 /* 11 */ "State-Thread",
640 /* 12 */ "Walk",
641 /* 13 */ "Parser",
642 /* 14 */ "Operand",
643 /* 15 */ "Node"
644 };
645
646
647 char *
AcpiUtGetDescriptorName(void * Object)648 AcpiUtGetDescriptorName (
649 void *Object)
650 {
651
652 if (!Object)
653 {
654 return ("NULL OBJECT");
655 }
656
657 if (ACPI_GET_DESCRIPTOR_TYPE (Object) > ACPI_DESC_TYPE_MAX)
658 {
659 return (ACPI_CAST_PTR (char, AcpiGbl_BadType));
660 }
661
662 return (ACPI_CAST_PTR (char,
663 AcpiGbl_DescTypeNames[ACPI_GET_DESCRIPTOR_TYPE (Object)]));
664
665 }
666
667
668 /*******************************************************************************
669 *
670 * FUNCTION: AcpiUtGetReferenceName
671 *
672 * PARAMETERS: Object - An ACPI reference object
673 *
674 * RETURN: Pointer to a string
675 *
676 * DESCRIPTION: Decode a reference object sub-type to a string.
677 *
678 ******************************************************************************/
679
680 /* Printable names of reference object sub-types */
681
682 static const char *AcpiGbl_RefClassNames[] =
683 {
684 /* 00 */ "Local",
685 /* 01 */ "Argument",
686 /* 02 */ "RefOf",
687 /* 03 */ "Index",
688 /* 04 */ "DdbHandle",
689 /* 05 */ "Named Object",
690 /* 06 */ "Debug"
691 };
692
693 const char *
AcpiUtGetReferenceName(ACPI_OPERAND_OBJECT * Object)694 AcpiUtGetReferenceName (
695 ACPI_OPERAND_OBJECT *Object)
696 {
697
698 if (!Object)
699 {
700 return ("NULL Object");
701 }
702
703 if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
704 {
705 return ("Not an Operand object");
706 }
707
708 if (Object->Common.Type != ACPI_TYPE_LOCAL_REFERENCE)
709 {
710 return ("Not a Reference object");
711 }
712
713 if (Object->Reference.Class > ACPI_REFCLASS_MAX)
714 {
715 return ("Unknown Reference class");
716 }
717
718 return (AcpiGbl_RefClassNames[Object->Reference.Class]);
719 }
720
721
722 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
723 /*
724 * Strings and procedures used for debug only
725 */
726
727 /*******************************************************************************
728 *
729 * FUNCTION: AcpiUtGetMutexName
730 *
731 * PARAMETERS: MutexId - The predefined ID for this mutex.
732 *
733 * RETURN: String containing the name of the mutex. Always returns a valid
734 * pointer.
735 *
736 * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
737 *
738 ******************************************************************************/
739
740 char *
AcpiUtGetMutexName(UINT32 MutexId)741 AcpiUtGetMutexName (
742 UINT32 MutexId)
743 {
744
745 if (MutexId > ACPI_MAX_MUTEX)
746 {
747 return ("Invalid Mutex ID");
748 }
749
750 return (AcpiGbl_MutexNames[MutexId]);
751 }
752
753
754 /*******************************************************************************
755 *
756 * FUNCTION: AcpiUtGetNotifyName
757 *
758 * PARAMETERS: NotifyValue - Value from the Notify() request
759 *
760 * RETURN: String corresponding to the Notify Value.
761 *
762 * DESCRIPTION: Translate a Notify Value to a notify namestring.
763 *
764 ******************************************************************************/
765
766 /* Names for Notify() values, used for debug output */
767
768 static const char *AcpiGbl_NotifyValueNames[] =
769 {
770 "Bus Check",
771 "Device Check",
772 "Device Wake",
773 "Eject Request",
774 "Device Check Light",
775 "Frequency Mismatch",
776 "Bus Mode Mismatch",
777 "Power Fault",
778 "Capabilities Check",
779 "Device PLD Check",
780 "Reserved",
781 "System Locality Update"
782 };
783
784 const char *
AcpiUtGetNotifyName(UINT32 NotifyValue)785 AcpiUtGetNotifyName (
786 UINT32 NotifyValue)
787 {
788
789 if (NotifyValue <= ACPI_NOTIFY_MAX)
790 {
791 return (AcpiGbl_NotifyValueNames[NotifyValue]);
792 }
793 else if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)
794 {
795 return ("Reserved");
796 }
797 else /* Greater or equal to 0x80 */
798 {
799 return ("**Device Specific**");
800 }
801 }
802 #endif
803
804
805 /*******************************************************************************
806 *
807 * FUNCTION: AcpiUtValidObjectType
808 *
809 * PARAMETERS: Type - Object type to be validated
810 *
811 * RETURN: TRUE if valid object type, FALSE otherwise
812 *
813 * DESCRIPTION: Validate an object type
814 *
815 ******************************************************************************/
816
817 BOOLEAN
AcpiUtValidObjectType(ACPI_OBJECT_TYPE Type)818 AcpiUtValidObjectType (
819 ACPI_OBJECT_TYPE Type)
820 {
821
822 if (Type > ACPI_TYPE_LOCAL_MAX)
823 {
824 /* Note: Assumes all TYPEs are contiguous (external/local) */
825
826 return (FALSE);
827 }
828
829 return (TRUE);
830 }
831
832
833 /*******************************************************************************
834 *
835 * FUNCTION: AcpiUtInitGlobals
836 *
837 * PARAMETERS: None
838 *
839 * RETURN: Status
840 *
841 * DESCRIPTION: Init library globals. All globals that require specific
842 * initialization should be initialized here!
843 *
844 ******************************************************************************/
845
846 ACPI_STATUS
AcpiUtInitGlobals(void)847 AcpiUtInitGlobals (
848 void)
849 {
850 ACPI_STATUS Status;
851 UINT32 i;
852
853
854 ACPI_FUNCTION_TRACE (UtInitGlobals);
855
856
857 /* Create all memory caches */
858
859 Status = AcpiUtCreateCaches ();
860 if (ACPI_FAILURE (Status))
861 {
862 return_ACPI_STATUS (Status);
863 }
864
865 /* Mutex locked flags */
866
867 for (i = 0; i < ACPI_NUM_MUTEX; i++)
868 {
869 AcpiGbl_MutexInfo[i].Mutex = NULL;
870 AcpiGbl_MutexInfo[i].ThreadId = ACPI_MUTEX_NOT_ACQUIRED;
871 AcpiGbl_MutexInfo[i].UseCount = 0;
872 }
873
874 for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++)
875 {
876 AcpiGbl_OwnerIdMask[i] = 0;
877 }
878
879 /* Last OwnerID is never valid */
880
881 AcpiGbl_OwnerIdMask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000;
882
883 /* Event counters */
884
885 AcpiMethodCount = 0;
886 AcpiSciCount = 0;
887 AcpiGpeCount = 0;
888
889 for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++)
890 {
891 AcpiFixedEventCount[i] = 0;
892 }
893
894 /* GPE support */
895
896 AcpiGbl_GpeXruptListHead = NULL;
897 AcpiGbl_GpeFadtBlocks[0] = NULL;
898 AcpiGbl_GpeFadtBlocks[1] = NULL;
899 AcpiCurrentGpeCount = 0;
900
901 /* Global handlers */
902
903 AcpiGbl_SystemNotify.Handler = NULL;
904 AcpiGbl_DeviceNotify.Handler = NULL;
905 AcpiGbl_ExceptionHandler = NULL;
906 AcpiGbl_InitHandler = NULL;
907 AcpiGbl_TableHandler = NULL;
908
909 /* Global Lock support */
910
911 AcpiGbl_GlobalLockSemaphore = NULL;
912 AcpiGbl_GlobalLockMutex = NULL;
913 AcpiGbl_GlobalLockAcquired = FALSE;
914 AcpiGbl_GlobalLockHandle = 0;
915 AcpiGbl_GlobalLockPresent = FALSE;
916
917 /* Miscellaneous variables */
918
919 AcpiGbl_CmSingleStep = FALSE;
920 AcpiGbl_DbTerminateThreads = FALSE;
921 AcpiGbl_Shutdown = FALSE;
922 AcpiGbl_NsLookupCount = 0;
923 AcpiGbl_PsFindCount = 0;
924 AcpiGbl_AcpiHardwarePresent = TRUE;
925 AcpiGbl_LastOwnerIdIndex = 0;
926 AcpiGbl_NextOwnerIdOffset = 0;
927 AcpiGbl_TraceMethodName = 0;
928 AcpiGbl_TraceDbgLevel = 0;
929 AcpiGbl_TraceDbgLayer = 0;
930 AcpiGbl_DebuggerConfiguration = DEBUGGER_THREADING;
931 AcpiGbl_DbOutputFlags = ACPI_DB_CONSOLE_OUTPUT;
932 AcpiGbl_OsiData = 0;
933
934 /* Hardware oriented */
935
936 AcpiGbl_EventsInitialized = FALSE;
937 AcpiGbl_SystemAwakeAndRunning = TRUE;
938
939 /* Namespace */
940
941 AcpiGbl_ModuleCodeList = NULL;
942 AcpiGbl_RootNode = NULL;
943 AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME;
944 AcpiGbl_RootNodeStruct.DescriptorType = ACPI_DESC_TYPE_NAMED;
945 AcpiGbl_RootNodeStruct.Type = ACPI_TYPE_DEVICE;
946 AcpiGbl_RootNodeStruct.Child = NULL;
947 AcpiGbl_RootNodeStruct.Peer = NULL;
948 AcpiGbl_RootNodeStruct.Object = NULL;
949 AcpiGbl_RootNodeStruct.Flags = ANOBJ_END_OF_PEER_LIST;
950
951
952 #ifdef ACPI_DISASSEMBLER
953 AcpiGbl_ExternalList = NULL;
954 #endif
955
956 #ifdef ACPI_DEBUG_OUTPUT
957 AcpiGbl_LowestStackPointer = ACPI_CAST_PTR (ACPI_SIZE, ACPI_SIZE_MAX);
958 #endif
959
960 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
961 AcpiGbl_DisplayFinalMemStats = FALSE;
962 #endif
963
964 return_ACPI_STATUS (AE_OK);
965 }
966
967 /* Public globals */
968
969 ACPI_EXPORT_SYMBOL (AcpiGbl_FADT)
970 ACPI_EXPORT_SYMBOL (AcpiDbgLevel)
971 ACPI_EXPORT_SYMBOL (AcpiDbgLayer)
972 ACPI_EXPORT_SYMBOL (AcpiGpeCount)
973 ACPI_EXPORT_SYMBOL (AcpiCurrentGpeCount)
974
975
976