[ACPI] ACPICA 20051021
[linux-3.10.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 /*! [Begin] no source code translation (keep these strings as-is) */
507         "PM_Timer",
508         "GlobalLock",
509         "PowerButton",
510         "SleepButton",
511         "RealTimeClock",
512 /*! [End] no source code translation !*/
513 };
514
515 char *acpi_ut_get_event_name(u32 event_id)
516 {
517
518         if (event_id > ACPI_EVENT_MAX) {
519                 return ("invalid_event_iD");
520         }
521
522         return ((char *)acpi_gbl_event_types[event_id]);
523 }
524
525 /*******************************************************************************
526  *
527  * FUNCTION:    acpi_ut_get_type_name
528  *
529  * PARAMETERS:  None.
530  *
531  * RETURN:      Status
532  *
533  * DESCRIPTION: Translate a Type ID into a name string (Debug only)
534  *
535  ******************************************************************************/
536
537 /*
538  * Elements of acpi_gbl_ns_type_names below must match
539  * one-to-one with values of acpi_object_type
540  *
541  * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
542  * when stored in a table it really means that we have thus far seen no
543  * evidence to indicate what type is actually going to be stored for this entry.
544  */
545 static const char acpi_gbl_bad_type[] = "UNDEFINED";
546
547 /* Printable names of the ACPI object types */
548
549 static const char *acpi_gbl_ns_type_names[] = {
550 /*! [Begin] no source code translation (keep these strings as-is) */
551         /* 00 */ "Untyped",
552         /* 01 */ "Integer",
553         /* 02 */ "String",
554         /* 03 */ "Buffer",
555         /* 04 */ "Package",
556         /* 05 */ "FieldUnit",
557         /* 06 */ "Device",
558         /* 07 */ "Event",
559         /* 08 */ "Method",
560         /* 09 */ "Mutex",
561         /* 10 */ "Region",
562         /* 11 */ "Power",
563         /* 12 */ "Processor",
564         /* 13 */ "Thermal",
565         /* 14 */ "BufferField",
566         /* 15 */ "DdbHandle",
567         /* 16 */ "DebugObject",
568         /* 17 */ "RegionField",
569         /* 18 */ "BankField",
570         /* 19 */ "IndexField",
571         /* 20 */ "Reference",
572         /* 21 */ "Alias",
573         /* 22 */ "MethodAlias",
574         /* 23 */ "Notify",
575         /* 24 */ "AddrHandler",
576         /* 25 */ "ResourceDesc",
577         /* 26 */ "ResourceFld",
578         /* 27 */ "Scope",
579         /* 28 */ "Extra",
580         /* 29 */ "Data",
581         /* 30 */ "Invalid"
582 /*! [End] no source code translation !*/
583 };
584
585 char *acpi_ut_get_type_name(acpi_object_type type)
586 {
587
588         if (type > ACPI_TYPE_INVALID) {
589                 return ((char *)acpi_gbl_bad_type);
590         }
591
592         return ((char *)acpi_gbl_ns_type_names[type]);
593 }
594
595 char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
596 {
597
598         if (!obj_desc) {
599                 return ("[NULL Object Descriptor]");
600         }
601
602         return (acpi_ut_get_type_name(ACPI_GET_OBJECT_TYPE(obj_desc)));
603 }
604
605 /*******************************************************************************
606  *
607  * FUNCTION:    acpi_ut_get_node_name
608  *
609  * PARAMETERS:  Object               - A namespace node
610  *
611  * RETURN:      Pointer to a string
612  *
613  * DESCRIPTION: Validate the node and return the node's ACPI name.
614  *
615  ******************************************************************************/
616
617 char *acpi_ut_get_node_name(void *object)
618 {
619         struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
620
621         /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
622
623         if (!object) {
624                 return ("NULL");
625         }
626
627         /* Check for Root node */
628
629         if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
630                 return ("\"\\\" ");
631         }
632
633         /* Descriptor must be a namespace node */
634
635         if (node->descriptor != ACPI_DESC_TYPE_NAMED) {
636                 return ("####");
637         }
638
639         /* Name must be a valid ACPI name */
640
641         if (!acpi_ut_valid_acpi_name(*(u32 *) node->name.ascii)) {
642                 return ("????");
643         }
644
645         /* Return the name */
646
647         return (node->name.ascii);
648 }
649
650 /*******************************************************************************
651  *
652  * FUNCTION:    acpi_ut_get_descriptor_name
653  *
654  * PARAMETERS:  Object               - An ACPI object
655  *
656  * RETURN:      Pointer to a string
657  *
658  * DESCRIPTION: Validate object and return the descriptor type
659  *
660  ******************************************************************************/
661
662 /* Printable names of object descriptor types */
663
664 static const char *acpi_gbl_desc_type_names[] = {
665 /*! [Begin] no source code translation (keep these ASL Keywords as-is) */
666         /* 00 */ "Invalid",
667         /* 01 */ "Cached",
668         /* 02 */ "State-Generic",
669         /* 03 */ "State-Update",
670         /* 04 */ "State-Package",
671         /* 05 */ "State-Control",
672         /* 06 */ "State-RootParseScope",
673         /* 07 */ "State-ParseScope",
674         /* 08 */ "State-WalkScope",
675         /* 09 */ "State-Result",
676         /* 10 */ "State-Notify",
677         /* 11 */ "State-Thread",
678         /* 12 */ "Walk",
679         /* 13 */ "Parser",
680         /* 14 */ "Operand",
681         /* 15 */ "Node"
682 /*! [End] no source code translation !*/
683 };
684
685 char *acpi_ut_get_descriptor_name(void *object)
686 {
687
688         if (!object) {
689                 return ("NULL OBJECT");
690         }
691
692         if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
693                 return ((char *)acpi_gbl_bad_type);
694         }
695
696         return ((char *)
697                 acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE(object)]);
698
699 }
700
701 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
702 /*
703  * Strings and procedures used for debug only
704  */
705
706 /*******************************************************************************
707  *
708  * FUNCTION:    acpi_ut_get_mutex_name
709  *
710  * PARAMETERS:  mutex_id        - The predefined ID for this mutex.
711  *
712  * RETURN:      String containing the name of the mutex. Always returns a valid
713  *              pointer.
714  *
715  * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
716  *
717  ******************************************************************************/
718
719 char *acpi_ut_get_mutex_name(u32 mutex_id)
720 {
721
722         if (mutex_id > MAX_MUTEX) {
723                 return ("Invalid Mutex ID");
724         }
725
726         return (acpi_gbl_mutex_names[mutex_id]);
727 }
728 #endif
729
730 /*******************************************************************************
731  *
732  * FUNCTION:    acpi_ut_valid_object_type
733  *
734  * PARAMETERS:  Type            - Object type to be validated
735  *
736  * RETURN:      TRUE if valid object type, FALSE otherwise
737  *
738  * DESCRIPTION: Validate an object type
739  *
740  ******************************************************************************/
741
742 u8 acpi_ut_valid_object_type(acpi_object_type type)
743 {
744
745         if (type > ACPI_TYPE_LOCAL_MAX) {
746                 /* Note: Assumes all TYPEs are contiguous (external/local) */
747
748                 return (FALSE);
749         }
750
751         return (TRUE);
752 }
753
754 /*******************************************************************************
755  *
756  * FUNCTION:    acpi_ut_init_globals
757  *
758  * PARAMETERS:  None
759  *
760  * RETURN:      None
761  *
762  * DESCRIPTION: Init library globals.  All globals that require specific
763  *              initialization should be initialized here!
764  *
765  ******************************************************************************/
766
767 void acpi_ut_init_globals(void)
768 {
769         acpi_status status;
770         u32 i;
771
772         ACPI_FUNCTION_TRACE("ut_init_globals");
773
774         /* Create all memory caches */
775
776         status = acpi_ut_create_caches();
777         if (ACPI_FAILURE(status)) {
778                 return;
779         }
780
781         /* ACPI table structure */
782
783         for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++) {
784                 acpi_gbl_table_lists[i].next = NULL;
785                 acpi_gbl_table_lists[i].count = 0;
786         }
787
788         /* Mutex locked flags */
789
790         for (i = 0; i < NUM_MUTEX; i++) {
791                 acpi_gbl_mutex_info[i].mutex = NULL;
792                 acpi_gbl_mutex_info[i].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
793                 acpi_gbl_mutex_info[i].use_count = 0;
794         }
795
796         /* GPE support */
797
798         acpi_gbl_gpe_xrupt_list_head = NULL;
799         acpi_gbl_gpe_fadt_blocks[0] = NULL;
800         acpi_gbl_gpe_fadt_blocks[1] = NULL;
801
802         /* Global notify handlers */
803
804         acpi_gbl_system_notify.handler = NULL;
805         acpi_gbl_device_notify.handler = NULL;
806         acpi_gbl_exception_handler = NULL;
807         acpi_gbl_init_handler = NULL;
808
809         /* Global "typed" ACPI table pointers */
810
811         acpi_gbl_RSDP = NULL;
812         acpi_gbl_XSDT = NULL;
813         acpi_gbl_FACS = NULL;
814         acpi_gbl_FADT = NULL;
815         acpi_gbl_DSDT = NULL;
816
817         /* Global Lock support */
818
819         acpi_gbl_global_lock_acquired = FALSE;
820         acpi_gbl_global_lock_thread_count = 0;
821         acpi_gbl_global_lock_handle = 0;
822
823         /* Miscellaneous variables */
824
825         acpi_gbl_table_flags = ACPI_PHYSICAL_POINTER;
826         acpi_gbl_rsdp_original_location = 0;
827         acpi_gbl_cm_single_step = FALSE;
828         acpi_gbl_db_terminate_threads = FALSE;
829         acpi_gbl_shutdown = FALSE;
830         acpi_gbl_ns_lookup_count = 0;
831         acpi_gbl_ps_find_count = 0;
832         acpi_gbl_acpi_hardware_present = TRUE;
833         acpi_gbl_owner_id_mask = 0;
834         acpi_gbl_trace_method_name = 0;
835         acpi_gbl_trace_dbg_level = 0;
836         acpi_gbl_trace_dbg_layer = 0;
837         acpi_gbl_debugger_configuration = DEBUGGER_THREADING;
838         acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT;
839
840         /* Hardware oriented */
841
842         acpi_gbl_events_initialized = FALSE;
843         acpi_gbl_system_awake_and_running = TRUE;
844
845         /* Namespace */
846
847         acpi_gbl_root_node = NULL;
848
849         acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME;
850         acpi_gbl_root_node_struct.descriptor = ACPI_DESC_TYPE_NAMED;
851         acpi_gbl_root_node_struct.type = ACPI_TYPE_DEVICE;
852         acpi_gbl_root_node_struct.child = NULL;
853         acpi_gbl_root_node_struct.peer = NULL;
854         acpi_gbl_root_node_struct.object = NULL;
855         acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST;
856
857 #ifdef ACPI_DEBUG_OUTPUT
858         acpi_gbl_lowest_stack_pointer = ACPI_SIZE_MAX;
859 #endif
860
861         return_VOID;
862 }