ACPICA: Update all ACPICA copyrights and signons to 2010
[linux-3.10.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 - 2010, 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         "IPMI",
363         "DataTable"
364 };
365
366 char *acpi_ut_get_region_name(u8 space_id)
367 {
368
369         if (space_id >= ACPI_USER_REGION_BEGIN) {
370                 return ("UserDefinedRegion");
371         } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
372                 return ("InvalidSpaceId");
373         }
374
375         return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id]));
376 }
377
378 /*******************************************************************************
379  *
380  * FUNCTION:    acpi_ut_get_event_name
381  *
382  * PARAMETERS:  None.
383  *
384  * RETURN:      Status
385  *
386  * DESCRIPTION: Translate a Event ID into a name string (Debug only)
387  *
388  ******************************************************************************/
389
390 /* Event type decoding */
391
392 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
393         "PM_Timer",
394         "GlobalLock",
395         "PowerButton",
396         "SleepButton",
397         "RealTimeClock",
398 };
399
400 char *acpi_ut_get_event_name(u32 event_id)
401 {
402
403         if (event_id > ACPI_EVENT_MAX) {
404                 return ("InvalidEventID");
405         }
406
407         return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id]));
408 }
409
410 /*******************************************************************************
411  *
412  * FUNCTION:    acpi_ut_get_type_name
413  *
414  * PARAMETERS:  None.
415  *
416  * RETURN:      Status
417  *
418  * DESCRIPTION: Translate a Type ID into a name string (Debug only)
419  *
420  ******************************************************************************/
421
422 /*
423  * Elements of acpi_gbl_ns_type_names below must match
424  * one-to-one with values of acpi_object_type
425  *
426  * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
427  * when stored in a table it really means that we have thus far seen no
428  * evidence to indicate what type is actually going to be stored for this entry.
429  */
430 static const char acpi_gbl_bad_type[] = "UNDEFINED";
431
432 /* Printable names of the ACPI object types */
433
434 static const char *acpi_gbl_ns_type_names[] = {
435         /* 00 */ "Untyped",
436         /* 01 */ "Integer",
437         /* 02 */ "String",
438         /* 03 */ "Buffer",
439         /* 04 */ "Package",
440         /* 05 */ "FieldUnit",
441         /* 06 */ "Device",
442         /* 07 */ "Event",
443         /* 08 */ "Method",
444         /* 09 */ "Mutex",
445         /* 10 */ "Region",
446         /* 11 */ "Power",
447         /* 12 */ "Processor",
448         /* 13 */ "Thermal",
449         /* 14 */ "BufferField",
450         /* 15 */ "DdbHandle",
451         /* 16 */ "DebugObject",
452         /* 17 */ "RegionField",
453         /* 18 */ "BankField",
454         /* 19 */ "IndexField",
455         /* 20 */ "Reference",
456         /* 21 */ "Alias",
457         /* 22 */ "MethodAlias",
458         /* 23 */ "Notify",
459         /* 24 */ "AddrHandler",
460         /* 25 */ "ResourceDesc",
461         /* 26 */ "ResourceFld",
462         /* 27 */ "Scope",
463         /* 28 */ "Extra",
464         /* 29 */ "Data",
465         /* 30 */ "Invalid"
466 };
467
468 char *acpi_ut_get_type_name(acpi_object_type type)
469 {
470
471         if (type > ACPI_TYPE_INVALID) {
472                 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
473         }
474
475         return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
476 }
477
478 char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
479 {
480
481         if (!obj_desc) {
482                 return ("[NULL Object Descriptor]");
483         }
484
485         return (acpi_ut_get_type_name(obj_desc->common.type));
486 }
487
488 /*******************************************************************************
489  *
490  * FUNCTION:    acpi_ut_get_node_name
491  *
492  * PARAMETERS:  Object               - A namespace node
493  *
494  * RETURN:      Pointer to a string
495  *
496  * DESCRIPTION: Validate the node and return the node's ACPI name.
497  *
498  ******************************************************************************/
499
500 char *acpi_ut_get_node_name(void *object)
501 {
502         struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
503
504         /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
505
506         if (!object) {
507                 return ("NULL");
508         }
509
510         /* Check for Root node */
511
512         if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
513                 return ("\"\\\" ");
514         }
515
516         /* Descriptor must be a namespace node */
517
518         if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
519                 return ("####");
520         }
521
522         /* Name must be a valid ACPI name */
523
524         if (!acpi_ut_valid_acpi_name(node->name.integer)) {
525                 node->name.integer = acpi_ut_repair_name(node->name.ascii);
526         }
527
528         /* Return the name */
529
530         return (node->name.ascii);
531 }
532
533 /*******************************************************************************
534  *
535  * FUNCTION:    acpi_ut_get_descriptor_name
536  *
537  * PARAMETERS:  Object               - An ACPI object
538  *
539  * RETURN:      Pointer to a string
540  *
541  * DESCRIPTION: Validate object and return the descriptor type
542  *
543  ******************************************************************************/
544
545 /* Printable names of object descriptor types */
546
547 static const char *acpi_gbl_desc_type_names[] = {
548         /* 00 */ "Invalid",
549         /* 01 */ "Cached",
550         /* 02 */ "State-Generic",
551         /* 03 */ "State-Update",
552         /* 04 */ "State-Package",
553         /* 05 */ "State-Control",
554         /* 06 */ "State-RootParseScope",
555         /* 07 */ "State-ParseScope",
556         /* 08 */ "State-WalkScope",
557         /* 09 */ "State-Result",
558         /* 10 */ "State-Notify",
559         /* 11 */ "State-Thread",
560         /* 12 */ "Walk",
561         /* 13 */ "Parser",
562         /* 14 */ "Operand",
563         /* 15 */ "Node"
564 };
565
566 char *acpi_ut_get_descriptor_name(void *object)
567 {
568
569         if (!object) {
570                 return ("NULL OBJECT");
571         }
572
573         if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
574                 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
575         }
576
577         return (ACPI_CAST_PTR(char,
578                               acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
579                                                        (object)]));
580
581 }
582
583 /*******************************************************************************
584  *
585  * FUNCTION:    acpi_ut_get_reference_name
586  *
587  * PARAMETERS:  Object               - An ACPI reference object
588  *
589  * RETURN:      Pointer to a string
590  *
591  * DESCRIPTION: Decode a reference object sub-type to a string.
592  *
593  ******************************************************************************/
594
595 /* Printable names of reference object sub-types */
596
597 static const char *acpi_gbl_ref_class_names[] = {
598         /* 00 */ "Local",
599         /* 01 */ "Argument",
600         /* 02 */ "RefOf",
601         /* 03 */ "Index",
602         /* 04 */ "DdbHandle",
603         /* 05 */ "Named Object",
604         /* 06 */ "Debug"
605 };
606
607 const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
608 {
609         if (!object)
610                 return "NULL Object";
611
612         if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND)
613                 return "Not an Operand object";
614
615         if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE)
616                 return "Not a Reference object";
617
618         if (object->reference.class > ACPI_REFCLASS_MAX)
619                 return "Unknown Reference class";
620
621         return acpi_gbl_ref_class_names[object->reference.class];
622 }
623
624 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
625 /*
626  * Strings and procedures used for debug only
627  */
628
629 /*******************************************************************************
630  *
631  * FUNCTION:    acpi_ut_get_mutex_name
632  *
633  * PARAMETERS:  mutex_id        - The predefined ID for this mutex.
634  *
635  * RETURN:      String containing the name of the mutex. Always returns a valid
636  *              pointer.
637  *
638  * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
639  *
640  ******************************************************************************/
641
642 char *acpi_ut_get_mutex_name(u32 mutex_id)
643 {
644
645         if (mutex_id > ACPI_MAX_MUTEX) {
646                 return ("Invalid Mutex ID");
647         }
648
649         return (acpi_gbl_mutex_names[mutex_id]);
650 }
651
652 /*******************************************************************************
653  *
654  * FUNCTION:    acpi_ut_get_notify_name
655  *
656  * PARAMETERS:  notify_value    - Value from the Notify() request
657  *
658  * RETURN:      String corresponding to the Notify Value.
659  *
660  * DESCRIPTION: Translate a Notify Value to a notify namestring.
661  *
662  ******************************************************************************/
663
664 /* Names for Notify() values, used for debug output */
665
666 static const char *acpi_gbl_notify_value_names[] = {
667         "Bus Check",
668         "Device Check",
669         "Device Wake",
670         "Eject Request",
671         "Device Check Light",
672         "Frequency Mismatch",
673         "Bus Mode Mismatch",
674         "Power Fault",
675         "Capabilities Check",
676         "Device PLD Check",
677         "Reserved",
678         "System Locality Update"
679 };
680
681 const char *acpi_ut_get_notify_name(u32 notify_value)
682 {
683
684         if (notify_value <= ACPI_NOTIFY_MAX) {
685                 return (acpi_gbl_notify_value_names[notify_value]);
686         } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
687                 return ("Reserved");
688         } else {                /* Greater or equal to 0x80 */
689
690                 return ("**Device Specific**");
691         }
692 }
693 #endif
694
695 /*******************************************************************************
696  *
697  * FUNCTION:    acpi_ut_valid_object_type
698  *
699  * PARAMETERS:  Type            - Object type to be validated
700  *
701  * RETURN:      TRUE if valid object type, FALSE otherwise
702  *
703  * DESCRIPTION: Validate an object type
704  *
705  ******************************************************************************/
706
707 u8 acpi_ut_valid_object_type(acpi_object_type type)
708 {
709
710         if (type > ACPI_TYPE_LOCAL_MAX) {
711
712                 /* Note: Assumes all TYPEs are contiguous (external/local) */
713
714                 return (FALSE);
715         }
716
717         return (TRUE);
718 }
719
720 /*******************************************************************************
721  *
722  * FUNCTION:    acpi_ut_init_globals
723  *
724  * PARAMETERS:  None
725  *
726  * RETURN:      Status
727  *
728  * DESCRIPTION: Init library globals.  All globals that require specific
729  *              initialization should be initialized here!
730  *
731  ******************************************************************************/
732
733 acpi_status acpi_ut_init_globals(void)
734 {
735         acpi_status status;
736         u32 i;
737
738         ACPI_FUNCTION_TRACE(ut_init_globals);
739
740         /* Create all memory caches */
741
742         status = acpi_ut_create_caches();
743         if (ACPI_FAILURE(status)) {
744                 return_ACPI_STATUS(status);
745         }
746
747         /* Mutex locked flags */
748
749         for (i = 0; i < ACPI_NUM_MUTEX; i++) {
750                 acpi_gbl_mutex_info[i].mutex = NULL;
751                 acpi_gbl_mutex_info[i].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
752                 acpi_gbl_mutex_info[i].use_count = 0;
753         }
754
755         for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++) {
756                 acpi_gbl_owner_id_mask[i] = 0;
757         }
758
759         /* Last owner_iD is never valid */
760
761         acpi_gbl_owner_id_mask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000;
762
763         /* GPE support */
764
765         acpi_gbl_gpe_xrupt_list_head = NULL;
766         acpi_gbl_gpe_fadt_blocks[0] = NULL;
767         acpi_gbl_gpe_fadt_blocks[1] = NULL;
768         acpi_current_gpe_count = 0;
769
770         /* Global handlers */
771
772         acpi_gbl_system_notify.handler = NULL;
773         acpi_gbl_device_notify.handler = NULL;
774         acpi_gbl_exception_handler = NULL;
775         acpi_gbl_init_handler = NULL;
776         acpi_gbl_table_handler = NULL;
777
778         /* Global Lock support */
779
780         acpi_gbl_global_lock_semaphore = NULL;
781         acpi_gbl_global_lock_mutex = NULL;
782         acpi_gbl_global_lock_acquired = FALSE;
783         acpi_gbl_global_lock_handle = 0;
784         acpi_gbl_global_lock_present = FALSE;
785
786         /* Miscellaneous variables */
787
788         acpi_gbl_cm_single_step = FALSE;
789         acpi_gbl_db_terminate_threads = FALSE;
790         acpi_gbl_shutdown = FALSE;
791         acpi_gbl_ns_lookup_count = 0;
792         acpi_gbl_ps_find_count = 0;
793         acpi_gbl_acpi_hardware_present = TRUE;
794         acpi_gbl_last_owner_id_index = 0;
795         acpi_gbl_next_owner_id_offset = 0;
796         acpi_gbl_trace_method_name = 0;
797         acpi_gbl_trace_dbg_level = 0;
798         acpi_gbl_trace_dbg_layer = 0;
799         acpi_gbl_debugger_configuration = DEBUGGER_THREADING;
800         acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT;
801         acpi_gbl_osi_data = 0;
802
803         /* Hardware oriented */
804
805         acpi_gbl_events_initialized = FALSE;
806         acpi_gbl_system_awake_and_running = TRUE;
807
808         /* Namespace */
809
810         acpi_gbl_module_code_list = NULL;
811         acpi_gbl_root_node = NULL;
812         acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME;
813         acpi_gbl_root_node_struct.descriptor_type = ACPI_DESC_TYPE_NAMED;
814         acpi_gbl_root_node_struct.type = ACPI_TYPE_DEVICE;
815         acpi_gbl_root_node_struct.child = NULL;
816         acpi_gbl_root_node_struct.peer = NULL;
817         acpi_gbl_root_node_struct.object = NULL;
818         acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST;
819
820 #ifdef ACPI_DEBUG_OUTPUT
821         acpi_gbl_lowest_stack_pointer = ACPI_CAST_PTR(acpi_size, ACPI_SIZE_MAX);
822 #endif
823
824 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
825         acpi_gbl_display_final_mem_stats = FALSE;
826 #endif
827
828         return_ACPI_STATUS(AE_OK);
829 }
830
831 ACPI_EXPORT_SYMBOL(acpi_gbl_FADT)
832 ACPI_EXPORT_SYMBOL(acpi_dbg_level)
833 ACPI_EXPORT_SYMBOL(acpi_dbg_layer)
834 ACPI_EXPORT_SYMBOL(acpi_current_gpe_count)