ACPICA: Major update for acpi_get_object_info external interface
[linux-2.6.git] / drivers / acpi / acpica / utglobal.c
1 /******************************************************************************
2  *
3  * Module Name: utglobal - Global variables for the ACPI subsystem
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2008, 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 DEFINE_ACPI_GLOBALS
45
46 #include <acpi/acpi.h>
47 #include "accommon.h"
48 #include "acnamesp.h"
49
50 #define _COMPONENT          ACPI_UTILITIES
51 ACPI_MODULE_NAME("utglobal")
52
53 /*******************************************************************************
54  *
55  * Static global variable initialization.
56  *
57  ******************************************************************************/
58 /*
59  * We want the debug switches statically initialized so they
60  * are already set when the debugger is entered.
61  */
62 /* Debug switch - level and trace mask */
63 u32 acpi_dbg_level = ACPI_DEBUG_DEFAULT;
64
65 /* Debug switch - layer (component) mask */
66
67 u32 acpi_dbg_layer = 0;
68 u32 acpi_gbl_nesting_level = 0;
69
70 /* Debugger globals */
71
72 u8 acpi_gbl_db_terminate_threads = FALSE;
73 u8 acpi_gbl_abort_method = FALSE;
74 u8 acpi_gbl_method_executing = FALSE;
75
76 /* System flags */
77
78 u32 acpi_gbl_startup_flags = 0;
79
80 /* System starts uninitialized */
81
82 u8 acpi_gbl_shutdown = TRUE;
83
84 const char *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT] = {
85         "\\_S0_",
86         "\\_S1_",
87         "\\_S2_",
88         "\\_S3_",
89         "\\_S4_",
90         "\\_S5_"
91 };
92
93 const char *acpi_gbl_lowest_dstate_names[ACPI_NUM_sx_w_METHODS] = {
94         "_S0W",
95         "_S1W",
96         "_S2W",
97         "_S3W",
98         "_S4W"
99 };
100
101 const char *acpi_gbl_highest_dstate_names[ACPI_NUM_sx_d_METHODS] = {
102         "_S1D",
103         "_S2D",
104         "_S3D",
105         "_S4D"
106 };
107
108 /*******************************************************************************
109  *
110  * FUNCTION:    acpi_format_exception
111  *
112  * PARAMETERS:  Status       - The acpi_status code to be formatted
113  *
114  * RETURN:      A string containing the exception text. A valid pointer is
115  *              always returned.
116  *
117  * DESCRIPTION: This function translates an ACPI exception into an ASCII string
118  *              It is here instead of utxface.c so it is always present.
119  *
120  ******************************************************************************/
121
122 const char *acpi_format_exception(acpi_status status)
123 {
124         const char *exception = NULL;
125
126         ACPI_FUNCTION_ENTRY();
127
128         exception = acpi_ut_validate_exception(status);
129         if (!exception) {
130
131                 /* Exception code was not recognized */
132
133                 ACPI_ERROR((AE_INFO,
134                             "Unknown exception code: 0x%8.8X", status));
135
136                 exception = "UNKNOWN_STATUS_CODE";
137                 dump_stack();
138         }
139
140         return (ACPI_CAST_PTR(const char, exception));
141 }
142
143 ACPI_EXPORT_SYMBOL(acpi_format_exception)
144
145 /*******************************************************************************
146  *
147  * Namespace globals
148  *
149  ******************************************************************************/
150 /*
151  * Predefined ACPI Names (Built-in to the Interpreter)
152  *
153  * NOTES:
154  * 1) _SB_ is defined to be a device to allow \_SB_._INI to be run
155  *    during the initialization sequence.
156  * 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to
157  *    perform a Notify() operation on it.
158  */
159 const struct acpi_predefined_names acpi_gbl_pre_defined_names[] = {
160         {"_GPE", ACPI_TYPE_LOCAL_SCOPE, NULL},
161         {"_PR_", ACPI_TYPE_LOCAL_SCOPE, NULL},
162         {"_SB_", ACPI_TYPE_DEVICE, NULL},
163         {"_SI_", ACPI_TYPE_LOCAL_SCOPE, NULL},
164         {"_TZ_", ACPI_TYPE_THERMAL, NULL},
165         {"_REV", ACPI_TYPE_INTEGER, (char *)ACPI_CA_SUPPORT_LEVEL},
166         {"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME},
167         {"_GL_", ACPI_TYPE_MUTEX, (char *)1},
168
169 #if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)
170         {"_OSI", ACPI_TYPE_METHOD, (char *)1},
171 #endif
172
173         /* Table terminator */
174
175         {NULL, ACPI_TYPE_ANY, NULL}
176 };
177
178 /*
179  * Properties of the ACPI Object Types, both internal and external.
180  * The table is indexed by values of acpi_object_type
181  */
182 const u8 acpi_gbl_ns_properties[] = {
183         ACPI_NS_NORMAL,         /* 00 Any              */
184         ACPI_NS_NORMAL,         /* 01 Number           */
185         ACPI_NS_NORMAL,         /* 02 String           */
186         ACPI_NS_NORMAL,         /* 03 Buffer           */
187         ACPI_NS_NORMAL,         /* 04 Package          */
188         ACPI_NS_NORMAL,         /* 05 field_unit       */
189         ACPI_NS_NEWSCOPE,       /* 06 Device           */
190         ACPI_NS_NORMAL,         /* 07 Event            */
191         ACPI_NS_NEWSCOPE,       /* 08 Method           */
192         ACPI_NS_NORMAL,         /* 09 Mutex            */
193         ACPI_NS_NORMAL,         /* 10 Region           */
194         ACPI_NS_NEWSCOPE,       /* 11 Power            */
195         ACPI_NS_NEWSCOPE,       /* 12 Processor        */
196         ACPI_NS_NEWSCOPE,       /* 13 Thermal          */
197         ACPI_NS_NORMAL,         /* 14 buffer_field     */
198         ACPI_NS_NORMAL,         /* 15 ddb_handle       */
199         ACPI_NS_NORMAL,         /* 16 Debug Object     */
200         ACPI_NS_NORMAL,         /* 17 def_field        */
201         ACPI_NS_NORMAL,         /* 18 bank_field       */
202         ACPI_NS_NORMAL,         /* 19 index_field      */
203         ACPI_NS_NORMAL,         /* 20 Reference        */
204         ACPI_NS_NORMAL,         /* 21 Alias            */
205         ACPI_NS_NORMAL,         /* 22 method_alias     */
206         ACPI_NS_NORMAL,         /* 23 Notify           */
207         ACPI_NS_NORMAL,         /* 24 Address Handler  */
208         ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,       /* 25 Resource Desc    */
209         ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,       /* 26 Resource Field   */
210         ACPI_NS_NEWSCOPE,       /* 27 Scope            */
211         ACPI_NS_NORMAL,         /* 28 Extra            */
212         ACPI_NS_NORMAL,         /* 29 Data             */
213         ACPI_NS_NORMAL          /* 30 Invalid          */
214 };
215
216 /* Hex to ASCII conversion table */
217
218 static const char acpi_gbl_hex_to_ascii[] = {
219         '0', '1', '2', '3', '4', '5', '6', '7',
220         '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
221 };
222
223 /*******************************************************************************
224  *
225  * FUNCTION:    acpi_ut_hex_to_ascii_char
226  *
227  * PARAMETERS:  Integer             - Contains the hex digit
228  *              Position            - bit position of the digit within the
229  *                                    integer (multiple of 4)
230  *
231  * RETURN:      The converted Ascii character
232  *
233  * DESCRIPTION: Convert a hex digit to an Ascii character
234  *
235  ******************************************************************************/
236
237 char acpi_ut_hex_to_ascii_char(acpi_integer integer, u32 position)
238 {
239
240         return (acpi_gbl_hex_to_ascii[(integer >> position) & 0xF]);
241 }
242
243 /******************************************************************************
244  *
245  * Event and Hardware globals
246  *
247  ******************************************************************************/
248
249 struct acpi_bit_register_info acpi_gbl_bit_register_info[ACPI_NUM_BITREG] = {
250         /* Name                                     Parent Register             Register Bit Position                   Register Bit Mask       */
251
252         /* ACPI_BITREG_TIMER_STATUS         */ {ACPI_REGISTER_PM1_STATUS,
253                                                 ACPI_BITPOSITION_TIMER_STATUS,
254                                                 ACPI_BITMASK_TIMER_STATUS},
255         /* ACPI_BITREG_BUS_MASTER_STATUS    */ {ACPI_REGISTER_PM1_STATUS,
256                                                 ACPI_BITPOSITION_BUS_MASTER_STATUS,
257                                                 ACPI_BITMASK_BUS_MASTER_STATUS},
258         /* ACPI_BITREG_GLOBAL_LOCK_STATUS   */ {ACPI_REGISTER_PM1_STATUS,
259                                                 ACPI_BITPOSITION_GLOBAL_LOCK_STATUS,
260                                                 ACPI_BITMASK_GLOBAL_LOCK_STATUS},
261         /* ACPI_BITREG_POWER_BUTTON_STATUS  */ {ACPI_REGISTER_PM1_STATUS,
262                                                 ACPI_BITPOSITION_POWER_BUTTON_STATUS,
263                                                 ACPI_BITMASK_POWER_BUTTON_STATUS},
264         /* ACPI_BITREG_SLEEP_BUTTON_STATUS  */ {ACPI_REGISTER_PM1_STATUS,
265                                                 ACPI_BITPOSITION_SLEEP_BUTTON_STATUS,
266                                                 ACPI_BITMASK_SLEEP_BUTTON_STATUS},
267         /* ACPI_BITREG_RT_CLOCK_STATUS      */ {ACPI_REGISTER_PM1_STATUS,
268                                                 ACPI_BITPOSITION_RT_CLOCK_STATUS,
269                                                 ACPI_BITMASK_RT_CLOCK_STATUS},
270         /* ACPI_BITREG_WAKE_STATUS          */ {ACPI_REGISTER_PM1_STATUS,
271                                                 ACPI_BITPOSITION_WAKE_STATUS,
272                                                 ACPI_BITMASK_WAKE_STATUS},
273         /* ACPI_BITREG_PCIEXP_WAKE_STATUS   */ {ACPI_REGISTER_PM1_STATUS,
274                                                 ACPI_BITPOSITION_PCIEXP_WAKE_STATUS,
275                                                 ACPI_BITMASK_PCIEXP_WAKE_STATUS},
276
277         /* ACPI_BITREG_TIMER_ENABLE         */ {ACPI_REGISTER_PM1_ENABLE,
278                                                 ACPI_BITPOSITION_TIMER_ENABLE,
279                                                 ACPI_BITMASK_TIMER_ENABLE},
280         /* ACPI_BITREG_GLOBAL_LOCK_ENABLE   */ {ACPI_REGISTER_PM1_ENABLE,
281                                                 ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE,
282                                                 ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
283         /* ACPI_BITREG_POWER_BUTTON_ENABLE  */ {ACPI_REGISTER_PM1_ENABLE,
284                                                 ACPI_BITPOSITION_POWER_BUTTON_ENABLE,
285                                                 ACPI_BITMASK_POWER_BUTTON_ENABLE},
286         /* ACPI_BITREG_SLEEP_BUTTON_ENABLE  */ {ACPI_REGISTER_PM1_ENABLE,
287                                                 ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE,
288                                                 ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
289         /* ACPI_BITREG_RT_CLOCK_ENABLE      */ {ACPI_REGISTER_PM1_ENABLE,
290                                                 ACPI_BITPOSITION_RT_CLOCK_ENABLE,
291                                                 ACPI_BITMASK_RT_CLOCK_ENABLE},
292         /* ACPI_BITREG_PCIEXP_WAKE_DISABLE  */ {ACPI_REGISTER_PM1_ENABLE,
293                                                 ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE,
294                                                 ACPI_BITMASK_PCIEXP_WAKE_DISABLE},
295
296         /* ACPI_BITREG_SCI_ENABLE           */ {ACPI_REGISTER_PM1_CONTROL,
297                                                 ACPI_BITPOSITION_SCI_ENABLE,
298                                                 ACPI_BITMASK_SCI_ENABLE},
299         /* ACPI_BITREG_BUS_MASTER_RLD       */ {ACPI_REGISTER_PM1_CONTROL,
300                                                 ACPI_BITPOSITION_BUS_MASTER_RLD,
301                                                 ACPI_BITMASK_BUS_MASTER_RLD},
302         /* ACPI_BITREG_GLOBAL_LOCK_RELEASE  */ {ACPI_REGISTER_PM1_CONTROL,
303                                                 ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE,
304                                                 ACPI_BITMASK_GLOBAL_LOCK_RELEASE},
305         /* ACPI_BITREG_SLEEP_TYPE           */ {ACPI_REGISTER_PM1_CONTROL,
306                                                 ACPI_BITPOSITION_SLEEP_TYPE,
307                                                 ACPI_BITMASK_SLEEP_TYPE},
308         /* ACPI_BITREG_SLEEP_ENABLE         */ {ACPI_REGISTER_PM1_CONTROL,
309                                                 ACPI_BITPOSITION_SLEEP_ENABLE,
310                                                 ACPI_BITMASK_SLEEP_ENABLE},
311
312         /* ACPI_BITREG_ARB_DIS              */ {ACPI_REGISTER_PM2_CONTROL,
313                                                 ACPI_BITPOSITION_ARB_DISABLE,
314                                                 ACPI_BITMASK_ARB_DISABLE}
315 };
316
317 struct acpi_fixed_event_info acpi_gbl_fixed_event_info[ACPI_NUM_FIXED_EVENTS] = {
318         /* ACPI_EVENT_PMTIMER       */ {ACPI_BITREG_TIMER_STATUS,
319                                         ACPI_BITREG_TIMER_ENABLE,
320                                         ACPI_BITMASK_TIMER_STATUS,
321                                         ACPI_BITMASK_TIMER_ENABLE},
322         /* ACPI_EVENT_GLOBAL        */ {ACPI_BITREG_GLOBAL_LOCK_STATUS,
323                                         ACPI_BITREG_GLOBAL_LOCK_ENABLE,
324                                         ACPI_BITMASK_GLOBAL_LOCK_STATUS,
325                                         ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
326         /* ACPI_EVENT_POWER_BUTTON  */ {ACPI_BITREG_POWER_BUTTON_STATUS,
327                                         ACPI_BITREG_POWER_BUTTON_ENABLE,
328                                         ACPI_BITMASK_POWER_BUTTON_STATUS,
329                                         ACPI_BITMASK_POWER_BUTTON_ENABLE},
330         /* ACPI_EVENT_SLEEP_BUTTON  */ {ACPI_BITREG_SLEEP_BUTTON_STATUS,
331                                         ACPI_BITREG_SLEEP_BUTTON_ENABLE,
332                                         ACPI_BITMASK_SLEEP_BUTTON_STATUS,
333                                         ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
334         /* ACPI_EVENT_RTC           */ {ACPI_BITREG_RT_CLOCK_STATUS,
335                                         ACPI_BITREG_RT_CLOCK_ENABLE,
336                                         ACPI_BITMASK_RT_CLOCK_STATUS,
337                                         ACPI_BITMASK_RT_CLOCK_ENABLE},
338 };
339
340 /*******************************************************************************
341  *
342  * FUNCTION:    acpi_ut_get_region_name
343  *
344  * PARAMETERS:  None.
345  *
346  * RETURN:      Status
347  *
348  * DESCRIPTION: Translate a Space ID into a name string (Debug only)
349  *
350  ******************************************************************************/
351
352 /* Region type decoding */
353
354 const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] = {
355         "SystemMemory",
356         "SystemIO",
357         "PCI_Config",
358         "EmbeddedControl",
359         "SMBus",
360         "SystemCMOS",
361         "PCIBARTarget",
362         "DataTable"
363 };
364
365 char *acpi_ut_get_region_name(u8 space_id)
366 {
367
368         if (space_id >= ACPI_USER_REGION_BEGIN) {
369                 return ("UserDefinedRegion");
370         } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
371                 return ("InvalidSpaceId");
372         }
373
374         return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id]));
375 }
376
377 /*******************************************************************************
378  *
379  * FUNCTION:    acpi_ut_get_event_name
380  *
381  * PARAMETERS:  None.
382  *
383  * RETURN:      Status
384  *
385  * DESCRIPTION: Translate a Event ID into a name string (Debug only)
386  *
387  ******************************************************************************/
388
389 /* Event type decoding */
390
391 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
392         "PM_Timer",
393         "GlobalLock",
394         "PowerButton",
395         "SleepButton",
396         "RealTimeClock",
397 };
398
399 char *acpi_ut_get_event_name(u32 event_id)
400 {
401
402         if (event_id > ACPI_EVENT_MAX) {
403                 return ("InvalidEventID");
404         }
405
406         return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id]));
407 }
408
409 /*******************************************************************************
410  *
411  * FUNCTION:    acpi_ut_get_type_name
412  *
413  * PARAMETERS:  None.
414  *
415  * RETURN:      Status
416  *
417  * DESCRIPTION: Translate a Type ID into a name string (Debug only)
418  *
419  ******************************************************************************/
420
421 /*
422  * Elements of acpi_gbl_ns_type_names below must match
423  * one-to-one with values of acpi_object_type
424  *
425  * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
426  * when stored in a table it really means that we have thus far seen no
427  * evidence to indicate what type is actually going to be stored for this entry.
428  */
429 static const char acpi_gbl_bad_type[] = "UNDEFINED";
430
431 /* Printable names of the ACPI object types */
432
433 static const char *acpi_gbl_ns_type_names[] = {
434         /* 00 */ "Untyped",
435         /* 01 */ "Integer",
436         /* 02 */ "String",
437         /* 03 */ "Buffer",
438         /* 04 */ "Package",
439         /* 05 */ "FieldUnit",
440         /* 06 */ "Device",
441         /* 07 */ "Event",
442         /* 08 */ "Method",
443         /* 09 */ "Mutex",
444         /* 10 */ "Region",
445         /* 11 */ "Power",
446         /* 12 */ "Processor",
447         /* 13 */ "Thermal",
448         /* 14 */ "BufferField",
449         /* 15 */ "DdbHandle",
450         /* 16 */ "DebugObject",
451         /* 17 */ "RegionField",
452         /* 18 */ "BankField",
453         /* 19 */ "IndexField",
454         /* 20 */ "Reference",
455         /* 21 */ "Alias",
456         /* 22 */ "MethodAlias",
457         /* 23 */ "Notify",
458         /* 24 */ "AddrHandler",
459         /* 25 */ "ResourceDesc",
460         /* 26 */ "ResourceFld",
461         /* 27 */ "Scope",
462         /* 28 */ "Extra",
463         /* 29 */ "Data",
464         /* 30 */ "Invalid"
465 };
466
467 char *acpi_ut_get_type_name(acpi_object_type type)
468 {
469
470         if (type > ACPI_TYPE_INVALID) {
471                 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
472         }
473
474         return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
475 }
476
477 char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
478 {
479
480         if (!obj_desc) {
481                 return ("[NULL Object Descriptor]");
482         }
483
484         return (acpi_ut_get_type_name(obj_desc->common.type));
485 }
486
487 /*******************************************************************************
488  *
489  * FUNCTION:    acpi_ut_get_node_name
490  *
491  * PARAMETERS:  Object               - A namespace node
492  *
493  * RETURN:      Pointer to a string
494  *
495  * DESCRIPTION: Validate the node and return the node's ACPI name.
496  *
497  ******************************************************************************/
498
499 char *acpi_ut_get_node_name(void *object)
500 {
501         struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
502
503         /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
504
505         if (!object) {
506                 return ("NULL");
507         }
508
509         /* Check for Root node */
510
511         if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
512                 return ("\"\\\" ");
513         }
514
515         /* Descriptor must be a namespace node */
516
517         if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
518                 return ("####");
519         }
520
521         /* Name must be a valid ACPI name */
522
523         if (!acpi_ut_valid_acpi_name(node->name.integer)) {
524                 node->name.integer = acpi_ut_repair_name(node->name.ascii);
525         }
526
527         /* Return the name */
528
529         return (node->name.ascii);
530 }
531
532 /*******************************************************************************
533  *
534  * FUNCTION:    acpi_ut_get_descriptor_name
535  *
536  * PARAMETERS:  Object               - An ACPI object
537  *
538  * RETURN:      Pointer to a string
539  *
540  * DESCRIPTION: Validate object and return the descriptor type
541  *
542  ******************************************************************************/
543
544 /* Printable names of object descriptor types */
545
546 static const char *acpi_gbl_desc_type_names[] = {
547         /* 00 */ "Invalid",
548         /* 01 */ "Cached",
549         /* 02 */ "State-Generic",
550         /* 03 */ "State-Update",
551         /* 04 */ "State-Package",
552         /* 05 */ "State-Control",
553         /* 06 */ "State-RootParseScope",
554         /* 07 */ "State-ParseScope",
555         /* 08 */ "State-WalkScope",
556         /* 09 */ "State-Result",
557         /* 10 */ "State-Notify",
558         /* 11 */ "State-Thread",
559         /* 12 */ "Walk",
560         /* 13 */ "Parser",
561         /* 14 */ "Operand",
562         /* 15 */ "Node"
563 };
564
565 char *acpi_ut_get_descriptor_name(void *object)
566 {
567
568         if (!object) {
569                 return ("NULL OBJECT");
570         }
571
572         if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
573                 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
574         }
575
576         return (ACPI_CAST_PTR(char,
577                               acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
578                                                        (object)]));
579
580 }
581
582 /*******************************************************************************
583  *
584  * FUNCTION:    acpi_ut_get_reference_name
585  *
586  * PARAMETERS:  Object               - An ACPI reference object
587  *
588  * RETURN:      Pointer to a string
589  *
590  * DESCRIPTION: Decode a reference object sub-type to a string.
591  *
592  ******************************************************************************/
593
594 /* Printable names of reference object sub-types */
595
596 static const char *acpi_gbl_ref_class_names[] = {
597         /* 00 */ "Local",
598         /* 01 */ "Argument",
599         /* 02 */ "RefOf",
600         /* 03 */ "Index",
601         /* 04 */ "DdbHandle",
602         /* 05 */ "Named Object",
603         /* 06 */ "Debug"
604 };
605
606 const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
607 {
608         if (!object)
609                 return "NULL Object";
610
611         if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND)
612                 return "Not an Operand object";
613
614         if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE)
615                 return "Not a Reference object";
616
617         if (object->reference.class > ACPI_REFCLASS_MAX)
618                 return "Unknown Reference class";
619
620         return acpi_gbl_ref_class_names[object->reference.class];
621 }
622
623 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
624 /*
625  * Strings and procedures used for debug only
626  */
627
628 /*******************************************************************************
629  *
630  * FUNCTION:    acpi_ut_get_mutex_name
631  *
632  * PARAMETERS:  mutex_id        - The predefined ID for this mutex.
633  *
634  * RETURN:      String containing the name of the mutex. Always returns a valid
635  *              pointer.
636  *
637  * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
638  *
639  ******************************************************************************/
640
641 char *acpi_ut_get_mutex_name(u32 mutex_id)
642 {
643
644         if (mutex_id > ACPI_MAX_MUTEX) {
645                 return ("Invalid Mutex ID");
646         }
647
648         return (acpi_gbl_mutex_names[mutex_id]);
649 }
650
651 /*******************************************************************************
652  *
653  * FUNCTION:    acpi_ut_get_notify_name
654  *
655  * PARAMETERS:  notify_value    - Value from the Notify() request
656  *
657  * RETURN:      String corresponding to the Notify Value.
658  *
659  * DESCRIPTION: Translate a Notify Value to a notify namestring.
660  *
661  ******************************************************************************/
662
663 /* Names for Notify() values, used for debug output */
664
665 static const char *acpi_gbl_notify_value_names[] = {
666         "Bus Check",
667         "Device Check",
668         "Device Wake",
669         "Eject Request",
670         "Device Check Light",
671         "Frequency Mismatch",
672         "Bus Mode Mismatch",
673         "Power Fault",
674         "Capabilities Check",
675         "Device PLD Check",
676         "Reserved",
677         "System Locality Update"
678 };
679
680 const char *acpi_ut_get_notify_name(u32 notify_value)
681 {
682
683         if (notify_value <= ACPI_NOTIFY_MAX) {
684                 return (acpi_gbl_notify_value_names[notify_value]);
685         } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
686                 return ("Reserved");
687         } else {                /* Greater or equal to 0x80 */
688
689                 return ("**Device Specific**");
690         }
691 }
692 #endif
693
694 /*******************************************************************************
695  *
696  * FUNCTION:    acpi_ut_valid_object_type
697  *
698  * PARAMETERS:  Type            - Object type to be validated
699  *
700  * RETURN:      TRUE if valid object type, FALSE otherwise
701  *
702  * DESCRIPTION: Validate an object type
703  *
704  ******************************************************************************/
705
706 u8 acpi_ut_valid_object_type(acpi_object_type type)
707 {
708
709         if (type > ACPI_TYPE_LOCAL_MAX) {
710
711                 /* Note: Assumes all TYPEs are contiguous (external/local) */
712
713                 return (FALSE);
714         }
715
716         return (TRUE);
717 }
718
719 /*******************************************************************************
720  *
721  * FUNCTION:    acpi_ut_init_globals
722  *
723  * PARAMETERS:  None
724  *
725  * RETURN:      Status
726  *
727  * DESCRIPTION: Init library globals.  All globals that require specific
728  *              initialization should be initialized here!
729  *
730  ******************************************************************************/
731
732 acpi_status acpi_ut_init_globals(void)
733 {
734         acpi_status status;
735         u32 i;
736
737         ACPI_FUNCTION_TRACE(ut_init_globals);
738
739         /* Create all memory caches */
740
741         status = acpi_ut_create_caches();
742         if (ACPI_FAILURE(status)) {
743                 return_ACPI_STATUS(status);
744         }
745
746         /* Mutex locked flags */
747
748         for (i = 0; i < ACPI_NUM_MUTEX; i++) {
749                 acpi_gbl_mutex_info[i].mutex = NULL;
750                 acpi_gbl_mutex_info[i].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
751                 acpi_gbl_mutex_info[i].use_count = 0;
752         }
753
754         for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++) {
755                 acpi_gbl_owner_id_mask[i] = 0;
756         }
757
758         /* Last owner_iD is never valid */
759
760         acpi_gbl_owner_id_mask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000;
761
762         /* GPE support */
763
764         acpi_gbl_gpe_xrupt_list_head = NULL;
765         acpi_gbl_gpe_fadt_blocks[0] = NULL;
766         acpi_gbl_gpe_fadt_blocks[1] = NULL;
767         acpi_current_gpe_count = 0;
768
769         /* Global handlers */
770
771         acpi_gbl_system_notify.handler = NULL;
772         acpi_gbl_device_notify.handler = NULL;
773         acpi_gbl_exception_handler = NULL;
774         acpi_gbl_init_handler = NULL;
775         acpi_gbl_table_handler = NULL;
776
777         /* Global Lock support */
778
779         acpi_gbl_global_lock_semaphore = NULL;
780         acpi_gbl_global_lock_mutex = NULL;
781         acpi_gbl_global_lock_acquired = FALSE;
782         acpi_gbl_global_lock_handle = 0;
783         acpi_gbl_global_lock_present = FALSE;
784
785         /* Miscellaneous variables */
786
787         acpi_gbl_cm_single_step = FALSE;
788         acpi_gbl_db_terminate_threads = FALSE;
789         acpi_gbl_shutdown = FALSE;
790         acpi_gbl_ns_lookup_count = 0;
791         acpi_gbl_ps_find_count = 0;
792         acpi_gbl_acpi_hardware_present = TRUE;
793         acpi_gbl_last_owner_id_index = 0;
794         acpi_gbl_next_owner_id_offset = 0;
795         acpi_gbl_trace_method_name = 0;
796         acpi_gbl_trace_dbg_level = 0;
797         acpi_gbl_trace_dbg_layer = 0;
798         acpi_gbl_debugger_configuration = DEBUGGER_THREADING;
799         acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT;
800         acpi_gbl_osi_data = 0;
801
802         /* Hardware oriented */
803
804         acpi_gbl_events_initialized = FALSE;
805         acpi_gbl_system_awake_and_running = TRUE;
806
807         /* Namespace */
808
809         acpi_gbl_root_node = NULL;
810         acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME;
811         acpi_gbl_root_node_struct.descriptor_type = ACPI_DESC_TYPE_NAMED;
812         acpi_gbl_root_node_struct.type = ACPI_TYPE_DEVICE;
813         acpi_gbl_root_node_struct.child = NULL;
814         acpi_gbl_root_node_struct.peer = NULL;
815         acpi_gbl_root_node_struct.object = NULL;
816         acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST;
817
818 #ifdef ACPI_DEBUG_OUTPUT
819         acpi_gbl_lowest_stack_pointer = ACPI_CAST_PTR(acpi_size, ACPI_SIZE_MAX);
820 #endif
821
822 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
823         acpi_gbl_display_final_mem_stats = FALSE;
824 #endif
825
826         return_ACPI_STATUS(AE_OK);
827 }
828
829 ACPI_EXPORT_SYMBOL(acpi_gbl_FADT)
830 ACPI_EXPORT_SYMBOL(acpi_dbg_level)
831 ACPI_EXPORT_SYMBOL(acpi_dbg_layer)
832 ACPI_EXPORT_SYMBOL(acpi_current_gpe_count)