utglobal.c revision 217365 
1/******************************************************************************
2 *
3 * Module Name: utglobal - Global variables for the ACPI subsystem
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2011, 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#define __UTGLOBAL_C__
45#define DEFINE_ACPI_GLOBALS
46
47#include <contrib/dev/acpica/include/acpi.h>
48#include <contrib/dev/acpica/include/accommon.h>
49#include <contrib/dev/acpica/include/acnamesp.h>
50
51#define _COMPONENT          ACPI_UTILITIES
52        ACPI_MODULE_NAME    ("utglobal")
53
54
55/*******************************************************************************
56 *
57 * Static global variable initialization.
58 *
59 ******************************************************************************/
60
61/*
62 * We want the debug switches statically initialized so they
63 * are already set when the debugger is entered.
64 */
65
66/* Debug switch - level and trace mask */
67
68#ifdef ACPI_DEBUG_OUTPUT
69UINT32                      AcpiDbgLevel = ACPI_DEBUG_DEFAULT;
70#else
71UINT32                      AcpiDbgLevel = ACPI_NORMAL_DEFAULT;
72#endif
73
74/* Debug switch - layer (component) mask */
75
76UINT32                      AcpiDbgLayer = ACPI_COMPONENT_DEFAULT;
77UINT32                      AcpiGbl_NestingLevel = 0;
78
79/* Debugger globals */
80
81BOOLEAN                     AcpiGbl_DbTerminateThreads = FALSE;
82BOOLEAN                     AcpiGbl_AbortMethod = FALSE;
83BOOLEAN                     AcpiGbl_MethodExecuting = FALSE;
84
85/* System flags */
86
87UINT32                      AcpiGbl_StartupFlags = 0;
88
89/* System starts uninitialized */
90
91BOOLEAN                     AcpiGbl_Shutdown = TRUE;
92
93const char                  *AcpiGbl_SleepStateNames[ACPI_S_STATE_COUNT] =
94{
95    "\\_S0_",
96    "\\_S1_",
97    "\\_S2_",
98    "\\_S3_",
99    "\\_S4_",
100    "\\_S5_"
101};
102
103const char                  *AcpiGbl_LowestDstateNames[ACPI_NUM_SxW_METHODS] =
104{
105    "_S0W",
106    "_S1W",
107    "_S2W",
108    "_S3W",
109    "_S4W"
110};
111
112const char                  *AcpiGbl_HighestDstateNames[ACPI_NUM_SxD_METHODS] =
113{
114    "_S1D",
115    "_S2D",
116    "_S3D",
117    "_S4D"
118};
119
120
121/*******************************************************************************
122 *
123 * FUNCTION:    AcpiFormatException
124 *
125 * PARAMETERS:  Status       - The ACPI_STATUS code to be formatted
126 *
127 * RETURN:      A string containing the exception text. A valid pointer is
128 *              always returned.
129 *
130 * DESCRIPTION: This function translates an ACPI exception into an ASCII string
131 *              It is here instead of utxface.c so it is always present.
132 *
133 ******************************************************************************/
134
135const char *
136AcpiFormatException (
137    ACPI_STATUS             Status)
138{
139    const char              *Exception = NULL;
140
141
142    ACPI_FUNCTION_ENTRY ();
143
144
145    Exception = AcpiUtValidateException (Status);
146    if (!Exception)
147    {
148        /* Exception code was not recognized */
149
150        ACPI_ERROR ((AE_INFO,
151            "Unknown exception code: 0x%8.8X", Status));
152
153        Exception = "UNKNOWN_STATUS_CODE";
154    }
155
156    return (ACPI_CAST_PTR (const char, Exception));
157}
158
159ACPI_EXPORT_SYMBOL (AcpiFormatException)
160
161
162/*******************************************************************************
163 *
164 * Namespace globals
165 *
166 ******************************************************************************/
167
168/*
169 * Predefined ACPI Names (Built-in to the Interpreter)
170 *
171 * NOTES:
172 * 1) _SB_ is defined to be a device to allow \_SB_._INI to be run
173 *    during the initialization sequence.
174 * 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to
175 *    perform a Notify() operation on it. 09/2010: Changed to type Device.
176 *    This still allows notifies, but does not confuse host code that
177 *    searches for valid ThermalZone objects.
178 */
179const ACPI_PREDEFINED_NAMES     AcpiGbl_PreDefinedNames[] =
180{
181    {"_GPE",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
182    {"_PR_",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
183    {"_SB_",    ACPI_TYPE_DEVICE,           NULL},
184    {"_SI_",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
185    {"_TZ_",    ACPI_TYPE_DEVICE,           NULL},
186    {"_REV",    ACPI_TYPE_INTEGER,          (char *) ACPI_CA_SUPPORT_LEVEL},
187    {"_OS_",    ACPI_TYPE_STRING,           ACPI_OS_NAME},
188    {"_GL_",    ACPI_TYPE_MUTEX,            (char *) 1},
189
190#if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)
191    {"_OSI",    ACPI_TYPE_METHOD,           (char *) 1},
192#endif
193
194    /* Table terminator */
195
196    {NULL,      ACPI_TYPE_ANY,              NULL}
197};
198
199/*
200 * Properties of the ACPI Object Types, both internal and external.
201 * The table is indexed by values of ACPI_OBJECT_TYPE
202 */
203const UINT8                     AcpiGbl_NsProperties[ACPI_NUM_NS_TYPES] =
204{
205    ACPI_NS_NORMAL,                     /* 00 Any              */
206    ACPI_NS_NORMAL,                     /* 01 Number           */
207    ACPI_NS_NORMAL,                     /* 02 String           */
208    ACPI_NS_NORMAL,                     /* 03 Buffer           */
209    ACPI_NS_NORMAL,                     /* 04 Package          */
210    ACPI_NS_NORMAL,                     /* 05 FieldUnit        */
211    ACPI_NS_NEWSCOPE,                   /* 06 Device           */
212    ACPI_NS_NORMAL,                     /* 07 Event            */
213    ACPI_NS_NEWSCOPE,                   /* 08 Method           */
214    ACPI_NS_NORMAL,                     /* 09 Mutex            */
215    ACPI_NS_NORMAL,                     /* 10 Region           */
216    ACPI_NS_NEWSCOPE,                   /* 11 Power            */
217    ACPI_NS_NEWSCOPE,                   /* 12 Processor        */
218    ACPI_NS_NEWSCOPE,                   /* 13 Thermal          */
219    ACPI_NS_NORMAL,                     /* 14 BufferField      */
220    ACPI_NS_NORMAL,                     /* 15 DdbHandle        */
221    ACPI_NS_NORMAL,                     /* 16 Debug Object     */
222    ACPI_NS_NORMAL,                     /* 17 DefField         */
223    ACPI_NS_NORMAL,                     /* 18 BankField        */
224    ACPI_NS_NORMAL,                     /* 19 IndexField       */
225    ACPI_NS_NORMAL,                     /* 20 Reference        */
226    ACPI_NS_NORMAL,                     /* 21 Alias            */
227    ACPI_NS_NORMAL,                     /* 22 MethodAlias      */
228    ACPI_NS_NORMAL,                     /* 23 Notify           */
229    ACPI_NS_NORMAL,                     /* 24 Address Handler  */
230    ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,   /* 25 Resource Desc    */
231    ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,   /* 26 Resource Field   */
232    ACPI_NS_NEWSCOPE,                   /* 27 Scope            */
233    ACPI_NS_NORMAL,                     /* 28 Extra            */
234    ACPI_NS_NORMAL,                     /* 29 Data             */
235    ACPI_NS_NORMAL                      /* 30 Invalid          */
236};
237
238
239/* Hex to ASCII conversion table */
240
241static const char           AcpiGbl_HexToAscii[] =
242{
243    '0','1','2','3','4','5','6','7',
244    '8','9','A','B','C','D','E','F'
245};
246
247
248/*******************************************************************************
249 *
250 * FUNCTION:    AcpiUtHexToAsciiChar
251 *
252 * PARAMETERS:  Integer             - Contains the hex digit
253 *              Position            - bit position of the digit within the
254 *                                    integer (multiple of 4)
255 *
256 * RETURN:      The converted Ascii character
257 *
258 * DESCRIPTION: Convert a hex digit to an Ascii character
259 *
260 ******************************************************************************/
261
262char
263AcpiUtHexToAsciiChar (
264    UINT64                  Integer,
265    UINT32                  Position)
266{
267
268    return (AcpiGbl_HexToAscii[(Integer >> Position) & 0xF]);
269}
270
271
272/******************************************************************************
273 *
274 * Event and Hardware globals
275 *
276 ******************************************************************************/
277
278ACPI_BIT_REGISTER_INFO      AcpiGbl_BitRegisterInfo[ACPI_NUM_BITREG] =
279{
280    /* Name                                     Parent Register             Register Bit Position                   Register Bit Mask       */
281
282    /* ACPI_BITREG_TIMER_STATUS         */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_TIMER_STATUS,          ACPI_BITMASK_TIMER_STATUS},
283    /* ACPI_BITREG_BUS_MASTER_STATUS    */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_BUS_MASTER_STATUS,     ACPI_BITMASK_BUS_MASTER_STATUS},
284    /* ACPI_BITREG_GLOBAL_LOCK_STATUS   */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_GLOBAL_LOCK_STATUS,    ACPI_BITMASK_GLOBAL_LOCK_STATUS},
285    /* ACPI_BITREG_POWER_BUTTON_STATUS  */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_POWER_BUTTON_STATUS,   ACPI_BITMASK_POWER_BUTTON_STATUS},
286    /* ACPI_BITREG_SLEEP_BUTTON_STATUS  */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_SLEEP_BUTTON_STATUS,   ACPI_BITMASK_SLEEP_BUTTON_STATUS},
287    /* ACPI_BITREG_RT_CLOCK_STATUS      */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_RT_CLOCK_STATUS,       ACPI_BITMASK_RT_CLOCK_STATUS},
288    /* ACPI_BITREG_WAKE_STATUS          */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_WAKE_STATUS,           ACPI_BITMASK_WAKE_STATUS},
289    /* ACPI_BITREG_PCIEXP_WAKE_STATUS   */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_PCIEXP_WAKE_STATUS,    ACPI_BITMASK_PCIEXP_WAKE_STATUS},
290
291    /* ACPI_BITREG_TIMER_ENABLE         */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_TIMER_ENABLE,          ACPI_BITMASK_TIMER_ENABLE},
292    /* ACPI_BITREG_GLOBAL_LOCK_ENABLE   */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE,    ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
293    /* ACPI_BITREG_POWER_BUTTON_ENABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_POWER_BUTTON_ENABLE,   ACPI_BITMASK_POWER_BUTTON_ENABLE},
294    /* ACPI_BITREG_SLEEP_BUTTON_ENABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE,   ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
295    /* ACPI_BITREG_RT_CLOCK_ENABLE      */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_RT_CLOCK_ENABLE,       ACPI_BITMASK_RT_CLOCK_ENABLE},
296    /* ACPI_BITREG_PCIEXP_WAKE_DISABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE,   ACPI_BITMASK_PCIEXP_WAKE_DISABLE},
297
298    /* ACPI_BITREG_SCI_ENABLE           */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SCI_ENABLE,            ACPI_BITMASK_SCI_ENABLE},
299    /* ACPI_BITREG_BUS_MASTER_RLD       */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_BUS_MASTER_RLD,        ACPI_BITMASK_BUS_MASTER_RLD},
300    /* ACPI_BITREG_GLOBAL_LOCK_RELEASE  */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE,   ACPI_BITMASK_GLOBAL_LOCK_RELEASE},
301    /* ACPI_BITREG_SLEEP_TYPE           */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_TYPE,            ACPI_BITMASK_SLEEP_TYPE},
302    /* ACPI_BITREG_SLEEP_ENABLE         */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_ENABLE,          ACPI_BITMASK_SLEEP_ENABLE},
303
304    /* ACPI_BITREG_ARB_DIS              */   {ACPI_REGISTER_PM2_CONTROL,  ACPI_BITPOSITION_ARB_DISABLE,           ACPI_BITMASK_ARB_DISABLE}
305};
306
307
308ACPI_FIXED_EVENT_INFO       AcpiGbl_FixedEventInfo[ACPI_NUM_FIXED_EVENTS] =
309{
310    /* ACPI_EVENT_PMTIMER       */  {ACPI_BITREG_TIMER_STATUS,          ACPI_BITREG_TIMER_ENABLE,        ACPI_BITMASK_TIMER_STATUS,          ACPI_BITMASK_TIMER_ENABLE},
311    /* ACPI_EVENT_GLOBAL        */  {ACPI_BITREG_GLOBAL_LOCK_STATUS,    ACPI_BITREG_GLOBAL_LOCK_ENABLE,  ACPI_BITMASK_GLOBAL_LOCK_STATUS,    ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
312    /* ACPI_EVENT_POWER_BUTTON  */  {ACPI_BITREG_POWER_BUTTON_STATUS,   ACPI_BITREG_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_STATUS,   ACPI_BITMASK_POWER_BUTTON_ENABLE},
313    /* ACPI_EVENT_SLEEP_BUTTON  */  {ACPI_BITREG_SLEEP_BUTTON_STATUS,   ACPI_BITREG_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_STATUS,   ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
314    /* ACPI_EVENT_RTC           */  {ACPI_BITREG_RT_CLOCK_STATUS,       ACPI_BITREG_RT_CLOCK_ENABLE,     ACPI_BITMASK_RT_CLOCK_STATUS,       ACPI_BITMASK_RT_CLOCK_ENABLE},
315};
316
317/*******************************************************************************
318 *
319 * FUNCTION:    AcpiUtGetRegionName
320 *
321 * PARAMETERS:  None.
322 *
323 * RETURN:      Status
324 *
325 * DESCRIPTION: Translate a Space ID into a name string (Debug only)
326 *
327 ******************************************************************************/
328
329/* Region type decoding */
330
331const char        *AcpiGbl_RegionTypes[ACPI_NUM_PREDEFINED_REGIONS] =
332{
333    "SystemMemory",
334    "SystemIO",
335    "PCI_Config",
336    "EmbeddedControl",
337    "SMBus",
338    "SystemCMOS",
339    "PCIBARTarget",
340    "IPMI",
341    "DataTable"
342};
343
344
345char *
346AcpiUtGetRegionName (
347    UINT8                   SpaceId)
348{
349
350    if (SpaceId >= ACPI_USER_REGION_BEGIN)
351    {
352        return ("UserDefinedRegion");
353    }
354    else if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS)
355    {
356        return ("InvalidSpaceId");
357    }
358
359    return (ACPI_CAST_PTR (char, AcpiGbl_RegionTypes[SpaceId]));
360}
361
362
363/*******************************************************************************
364 *
365 * FUNCTION:    AcpiUtGetEventName
366 *
367 * PARAMETERS:  None.
368 *
369 * RETURN:      Status
370 *
371 * DESCRIPTION: Translate a Event ID into a name string (Debug only)
372 *
373 ******************************************************************************/
374
375/* Event type decoding */
376
377static const char        *AcpiGbl_EventTypes[ACPI_NUM_FIXED_EVENTS] =
378{
379    "PM_Timer",
380    "GlobalLock",
381    "PowerButton",
382    "SleepButton",
383    "RealTimeClock",
384};
385
386
387char *
388AcpiUtGetEventName (
389    UINT32                  EventId)
390{
391
392    if (EventId > ACPI_EVENT_MAX)
393    {
394        return ("InvalidEventID");
395    }
396
397    return (ACPI_CAST_PTR (char, AcpiGbl_EventTypes[EventId]));
398}
399
400
401/*******************************************************************************
402 *
403 * FUNCTION:    AcpiUtGetTypeName
404 *
405 * PARAMETERS:  None.
406 *
407 * RETURN:      Status
408 *
409 * DESCRIPTION: Translate a Type ID into a name string (Debug only)
410 *
411 ******************************************************************************/
412
413/*
414 * Elements of AcpiGbl_NsTypeNames below must match
415 * one-to-one with values of ACPI_OBJECT_TYPE
416 *
417 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
418 * when stored in a table it really means that we have thus far seen no
419 * evidence to indicate what type is actually going to be stored for this entry.
420 */
421static const char           AcpiGbl_BadType[] = "UNDEFINED";
422
423/* Printable names of the ACPI object types */
424
425static const char           *AcpiGbl_NsTypeNames[] =
426{
427    /* 00 */ "Untyped",
428    /* 01 */ "Integer",
429    /* 02 */ "String",
430    /* 03 */ "Buffer",
431    /* 04 */ "Package",
432    /* 05 */ "FieldUnit",
433    /* 06 */ "Device",
434    /* 07 */ "Event",
435    /* 08 */ "Method",
436    /* 09 */ "Mutex",
437    /* 10 */ "Region",
438    /* 11 */ "Power",
439    /* 12 */ "Processor",
440    /* 13 */ "Thermal",
441    /* 14 */ "BufferField",
442    /* 15 */ "DdbHandle",
443    /* 16 */ "DebugObject",
444    /* 17 */ "RegionField",
445    /* 18 */ "BankField",
446    /* 19 */ "IndexField",
447    /* 20 */ "Reference",
448    /* 21 */ "Alias",
449    /* 22 */ "MethodAlias",
450    /* 23 */ "Notify",
451    /* 24 */ "AddrHandler",
452    /* 25 */ "ResourceDesc",
453    /* 26 */ "ResourceFld",
454    /* 27 */ "Scope",
455    /* 28 */ "Extra",
456    /* 29 */ "Data",
457    /* 30 */ "Invalid"
458};
459
460
461char *
462AcpiUtGetTypeName (
463    ACPI_OBJECT_TYPE        Type)
464{
465
466    if (Type > ACPI_TYPE_INVALID)
467    {
468        return (ACPI_CAST_PTR (char, AcpiGbl_BadType));
469    }
470
471    return (ACPI_CAST_PTR (char, AcpiGbl_NsTypeNames[Type]));
472}
473
474
475char *
476AcpiUtGetObjectTypeName (
477    ACPI_OPERAND_OBJECT     *ObjDesc)
478{
479
480    if (!ObjDesc)
481    {
482        return ("[NULL Object Descriptor]");
483    }
484
485    return (AcpiUtGetTypeName (ObjDesc->Common.Type));
486}
487
488
489/*******************************************************************************
490 *
491 * FUNCTION:    AcpiUtGetNodeName
492 *
493 * PARAMETERS:  Object               - A namespace node
494 *
495 * RETURN:      Pointer to a string
496 *
497 * DESCRIPTION: Validate the node and return the node's ACPI name.
498 *
499 ******************************************************************************/
500
501char *
502AcpiUtGetNodeName (
503    void                    *Object)
504{
505    ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) Object;
506
507
508    /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
509
510    if (!Object)
511    {
512        return ("NULL");
513    }
514
515    /* Check for Root node */
516
517    if ((Object == ACPI_ROOT_OBJECT) ||
518        (Object == AcpiGbl_RootNode))
519    {
520        return ("\"\\\" ");
521    }
522
523    /* Descriptor must be a namespace node */
524
525    if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
526    {
527        return ("####");
528    }
529
530    /*
531     * Ensure name is valid. The name was validated/repaired when the node
532     * was created, but make sure it has not been corrupted.
533     */
534    AcpiUtRepairName (Node->Name.Ascii);
535
536    /* Return the name */
537
538    return (Node->Name.Ascii);
539}
540
541
542/*******************************************************************************
543 *
544 * FUNCTION:    AcpiUtGetDescriptorName
545 *
546 * PARAMETERS:  Object               - An ACPI object
547 *
548 * RETURN:      Pointer to a string
549 *
550 * DESCRIPTION: Validate object and return the descriptor type
551 *
552 ******************************************************************************/
553
554/* Printable names of object descriptor types */
555
556static const char           *AcpiGbl_DescTypeNames[] =
557{
558    /* 00 */ "Not a Descriptor",
559    /* 01 */ "Cached",
560    /* 02 */ "State-Generic",
561    /* 03 */ "State-Update",
562    /* 04 */ "State-Package",
563    /* 05 */ "State-Control",
564    /* 06 */ "State-RootParseScope",
565    /* 07 */ "State-ParseScope",
566    /* 08 */ "State-WalkScope",
567    /* 09 */ "State-Result",
568    /* 10 */ "State-Notify",
569    /* 11 */ "State-Thread",
570    /* 12 */ "Walk",
571    /* 13 */ "Parser",
572    /* 14 */ "Operand",
573    /* 15 */ "Node"
574};
575
576
577char *
578AcpiUtGetDescriptorName (
579    void                    *Object)
580{
581
582    if (!Object)
583    {
584        return ("NULL OBJECT");
585    }
586
587    if (ACPI_GET_DESCRIPTOR_TYPE (Object) > ACPI_DESC_TYPE_MAX)
588    {
589        return ("Not a Descriptor");
590    }
591
592    return (ACPI_CAST_PTR (char,
593        AcpiGbl_DescTypeNames[ACPI_GET_DESCRIPTOR_TYPE (Object)]));
594
595}
596
597
598/*******************************************************************************
599 *
600 * FUNCTION:    AcpiUtGetReferenceName
601 *
602 * PARAMETERS:  Object               - An ACPI reference object
603 *
604 * RETURN:      Pointer to a string
605 *
606 * DESCRIPTION: Decode a reference object sub-type to a string.
607 *
608 ******************************************************************************/
609
610/* Printable names of reference object sub-types */
611
612static const char           *AcpiGbl_RefClassNames[] =
613{
614    /* 00 */ "Local",
615    /* 01 */ "Argument",
616    /* 02 */ "RefOf",
617    /* 03 */ "Index",
618    /* 04 */ "DdbHandle",
619    /* 05 */ "Named Object",
620    /* 06 */ "Debug"
621};
622
623const char *
624AcpiUtGetReferenceName (
625    ACPI_OPERAND_OBJECT     *Object)
626{
627
628    if (!Object)
629    {
630        return ("NULL Object");
631    }
632
633    if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
634    {
635        return ("Not an Operand object");
636    }
637
638    if (Object->Common.Type != ACPI_TYPE_LOCAL_REFERENCE)
639    {
640        return ("Not a Reference object");
641    }
642
643    if (Object->Reference.Class > ACPI_REFCLASS_MAX)
644    {
645        return ("Unknown Reference class");
646    }
647
648    return (AcpiGbl_RefClassNames[Object->Reference.Class]);
649}
650
651
652#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
653/*
654 * Strings and procedures used for debug only
655 */
656
657/*******************************************************************************
658 *
659 * FUNCTION:    AcpiUtGetMutexName
660 *
661 * PARAMETERS:  MutexId         - The predefined ID for this mutex.
662 *
663 * RETURN:      String containing the name of the mutex. Always returns a valid
664 *              pointer.
665 *
666 * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
667 *
668 ******************************************************************************/
669
670char *
671AcpiUtGetMutexName (
672    UINT32                  MutexId)
673{
674
675    if (MutexId > ACPI_MAX_MUTEX)
676    {
677        return ("Invalid Mutex ID");
678    }
679
680    return (AcpiGbl_MutexNames[MutexId]);
681}
682
683
684/*******************************************************************************
685 *
686 * FUNCTION:    AcpiUtGetNotifyName
687 *
688 * PARAMETERS:  NotifyValue     - Value from the Notify() request
689 *
690 * RETURN:      String corresponding to the Notify Value.
691 *
692 * DESCRIPTION: Translate a Notify Value to a notify namestring.
693 *
694 ******************************************************************************/
695
696/* Names for Notify() values, used for debug output */
697
698static const char        *AcpiGbl_NotifyValueNames[] =
699{
700    "Bus Check",
701    "Device Check",
702    "Device Wake",
703    "Eject Request",
704    "Device Check Light",
705    "Frequency Mismatch",
706    "Bus Mode Mismatch",
707    "Power Fault",
708    "Capabilities Check",
709    "Device PLD Check",
710    "Reserved",
711    "System Locality Update"
712};
713
714const char *
715AcpiUtGetNotifyName (
716    UINT32                  NotifyValue)
717{
718
719    if (NotifyValue <= ACPI_NOTIFY_MAX)
720    {
721        return (AcpiGbl_NotifyValueNames[NotifyValue]);
722    }
723    else if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)
724    {
725        return ("Reserved");
726    }
727    else /* Greater or equal to 0x80 */
728    {
729        return ("**Device Specific**");
730    }
731}
732#endif
733
734
735/*******************************************************************************
736 *
737 * FUNCTION:    AcpiUtValidObjectType
738 *
739 * PARAMETERS:  Type            - Object type to be validated
740 *
741 * RETURN:      TRUE if valid object type, FALSE otherwise
742 *
743 * DESCRIPTION: Validate an object type
744 *
745 ******************************************************************************/
746
747BOOLEAN
748AcpiUtValidObjectType (
749    ACPI_OBJECT_TYPE        Type)
750{
751
752    if (Type > ACPI_TYPE_LOCAL_MAX)
753    {
754        /* Note: Assumes all TYPEs are contiguous (external/local) */
755
756        return (FALSE);
757    }
758
759    return (TRUE);
760}
761
762
763/*******************************************************************************
764 *
765 * FUNCTION:    AcpiUtInitGlobals
766 *
767 * PARAMETERS:  None
768 *
769 * RETURN:      Status
770 *
771 * DESCRIPTION: Init library globals.  All globals that require specific
772 *              initialization should be initialized here!
773 *
774 ******************************************************************************/
775
776ACPI_STATUS
777AcpiUtInitGlobals (
778    void)
779{
780    ACPI_STATUS             Status;
781    UINT32                  i;
782
783
784    ACPI_FUNCTION_TRACE (UtInitGlobals);
785
786
787    /* Create all memory caches */
788
789    Status = AcpiUtCreateCaches ();
790    if (ACPI_FAILURE (Status))
791    {
792        return_ACPI_STATUS (Status);
793    }
794
795    /* Mutex locked flags */
796
797    for (i = 0; i < ACPI_NUM_MUTEX; i++)
798    {
799        AcpiGbl_MutexInfo[i].Mutex          = NULL;
800        AcpiGbl_MutexInfo[i].ThreadId       = ACPI_MUTEX_NOT_ACQUIRED;
801        AcpiGbl_MutexInfo[i].UseCount       = 0;
802    }
803
804    for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++)
805    {
806        AcpiGbl_OwnerIdMask[i]              = 0;
807    }
808
809    /* Last OwnerID is never valid */
810
811    AcpiGbl_OwnerIdMask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000;
812
813    /* Event counters */
814
815    AcpiMethodCount                     = 0;
816    AcpiSciCount                        = 0;
817    AcpiGpeCount                        = 0;
818
819    for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++)
820    {
821        AcpiFixedEventCount[i]              = 0;
822    }
823
824    /* GPE support */
825
826    AcpiGbl_AllGpesInitialized          = FALSE;
827    AcpiGbl_GpeXruptListHead            = NULL;
828    AcpiGbl_GpeFadtBlocks[0]            = NULL;
829    AcpiGbl_GpeFadtBlocks[1]            = NULL;
830    AcpiCurrentGpeCount                 = 0;
831
832    /* Global handlers */
833
834    AcpiGbl_SystemNotify.Handler        = NULL;
835    AcpiGbl_DeviceNotify.Handler        = NULL;
836    AcpiGbl_ExceptionHandler            = NULL;
837    AcpiGbl_InitHandler                 = NULL;
838    AcpiGbl_TableHandler                = NULL;
839    AcpiGbl_InterfaceHandler            = NULL;
840    AcpiGbl_GlobalEventHandler          = NULL;
841
842    /* Global Lock support */
843
844    AcpiGbl_GlobalLockSemaphore         = NULL;
845    AcpiGbl_GlobalLockMutex             = NULL;
846    AcpiGbl_GlobalLockAcquired          = FALSE;
847    AcpiGbl_GlobalLockHandle            = 0;
848    AcpiGbl_GlobalLockPresent           = FALSE;
849
850    /* Miscellaneous variables */
851
852    AcpiGbl_DSDT                        = NULL;
853    AcpiGbl_CmSingleStep                = FALSE;
854    AcpiGbl_DbTerminateThreads          = FALSE;
855    AcpiGbl_Shutdown                    = FALSE;
856    AcpiGbl_NsLookupCount               = 0;
857    AcpiGbl_PsFindCount                 = 0;
858    AcpiGbl_AcpiHardwarePresent         = TRUE;
859    AcpiGbl_LastOwnerIdIndex            = 0;
860    AcpiGbl_NextOwnerIdOffset           = 0;
861    AcpiGbl_TraceMethodName             = 0;
862    AcpiGbl_TraceDbgLevel               = 0;
863    AcpiGbl_TraceDbgLayer               = 0;
864    AcpiGbl_DebuggerConfiguration       = DEBUGGER_THREADING;
865    AcpiGbl_DbOutputFlags               = ACPI_DB_CONSOLE_OUTPUT;
866    AcpiGbl_OsiData                     = 0;
867    AcpiGbl_OsiMutex                    = NULL;
868
869    /* Hardware oriented */
870
871    AcpiGbl_EventsInitialized           = FALSE;
872    AcpiGbl_SystemAwakeAndRunning       = TRUE;
873
874    /* Namespace */
875
876    AcpiGbl_ModuleCodeList              = NULL;
877    AcpiGbl_RootNode                    = NULL;
878    AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME;
879    AcpiGbl_RootNodeStruct.DescriptorType = ACPI_DESC_TYPE_NAMED;
880    AcpiGbl_RootNodeStruct.Type         = ACPI_TYPE_DEVICE;
881    AcpiGbl_RootNodeStruct.Parent       = NULL;
882    AcpiGbl_RootNodeStruct.Child        = NULL;
883    AcpiGbl_RootNodeStruct.Peer         = NULL;
884    AcpiGbl_RootNodeStruct.Object       = NULL;
885
886
887#ifdef ACPI_DISASSEMBLER
888    AcpiGbl_ExternalList                = NULL;
889#endif
890
891#ifdef ACPI_DEBUG_OUTPUT
892    AcpiGbl_LowestStackPointer          = ACPI_CAST_PTR (ACPI_SIZE, ACPI_SIZE_MAX);
893#endif
894
895#ifdef ACPI_DBG_TRACK_ALLOCATIONS
896    AcpiGbl_DisplayFinalMemStats        = FALSE;
897    AcpiGbl_DisableMemTracking          = FALSE;
898#endif
899
900    return_ACPI_STATUS (AE_OK);
901}
902
903/* Public globals */
904
905ACPI_EXPORT_SYMBOL (AcpiGbl_FADT)
906ACPI_EXPORT_SYMBOL (AcpiDbgLevel)
907ACPI_EXPORT_SYMBOL (AcpiDbgLayer)
908ACPI_EXPORT_SYMBOL (AcpiGpeCount)
909ACPI_EXPORT_SYMBOL (AcpiCurrentGpeCount)
910
911
912