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