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