1 /******************************************************************************
2 *
3 * Module Name: utglobal - Global variables for the ACPI subsystem
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2008, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44 #define DEFINE_ACPI_GLOBALS
45
46 #include <acpi/acpi.h>
47 #include "accommon.h"
48 #include "acnamesp.h"
49
50 #define _COMPONENT ACPI_UTILITIES
51 ACPI_MODULE_NAME("utglobal")
52
53 /*******************************************************************************
54 *
55 * Static global variable initialization.
56 *
57 ******************************************************************************/
58 /*
59 * We want the debug switches statically initialized so they
60 * are already set when the debugger is entered.
61 */
62 /* Debug switch - level and trace mask */
63 u32 acpi_dbg_level = ACPI_DEBUG_DEFAULT;
64
65 /* Debug switch - layer (component) mask */
66
67 u32 acpi_dbg_layer = 0;
68 u32 acpi_gbl_nesting_level = 0;
69
70 /* Debugger globals */
71
72 u8 acpi_gbl_db_terminate_threads = FALSE;
73 u8 acpi_gbl_abort_method = FALSE;
74 u8 acpi_gbl_method_executing = FALSE;
75
76 /* System flags */
77
78 u32 acpi_gbl_startup_flags = 0;
79
80 /* System starts uninitialized */
81
82 u8 acpi_gbl_shutdown = TRUE;
83
84 const char *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT] = {
85 "\\_S0_",
86 "\\_S1_",
87 "\\_S2_",
88 "\\_S3_",
89 "\\_S4_",
90 "\\_S5_"
91 };
92
93 const char *acpi_gbl_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 '', '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_PCIEXP_WAKE_DISABLE */ {ACPI_REGISTER_PM1_ENABLE,
285 ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE,
286 ACPI_BITMASK_PCIEXP_WAKE_DISABLE},
287
288 /* ACPI_BITREG_SCI_ENABLE */ {ACPI_REGISTER_PM1_CONTROL,
289 ACPI_BITPOSITION_SCI_ENABLE,
290 ACPI_BITMASK_SCI_ENABLE},
291 /* ACPI_BITREG_BUS_MASTER_RLD */ {ACPI_REGISTER_PM1_CONTROL,
292 ACPI_BITPOSITION_BUS_MASTER_RLD,
293 ACPI_BITMASK_BUS_MASTER_RLD},
294 /* ACPI_BITREG_GLOBAL_LOCK_RELEASE */ {ACPI_REGISTER_PM1_CONTROL,
295 ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE,
296 ACPI_BITMASK_GLOBAL_LOCK_RELEASE},
297 /* ACPI_BITREG_SLEEP_TYPE */ {ACPI_REGISTER_PM1_CONTROL,
298 ACPI_BITPOSITION_SLEEP_TYPE,
299 ACPI_BITMASK_SLEEP_TYPE},
300 /* ACPI_BITREG_SLEEP_ENABLE */ {ACPI_REGISTER_PM1_CONTROL,
301 ACPI_BITPOSITION_SLEEP_ENABLE,
302 ACPI_BITMASK_SLEEP_ENABLE},
303
304 /* ACPI_BITREG_ARB_DIS */ {ACPI_REGISTER_PM2_CONTROL,
305 ACPI_BITPOSITION_ARB_DISABLE,
306 ACPI_BITMASK_ARB_DISABLE}
307 };
308
309 struct acpi_fixed_event_info acpi_gbl_fixed_event_info[ACPI_NUM_FIXED_EVENTS] = {
310 /* ACPI_EVENT_PMTIMER */ {ACPI_BITREG_TIMER_STATUS,
311 ACPI_BITREG_TIMER_ENABLE,
312 ACPI_BITMASK_TIMER_STATUS,
313 ACPI_BITMASK_TIMER_ENABLE},
314 /* ACPI_EVENT_GLOBAL */ {ACPI_BITREG_GLOBAL_LOCK_STATUS,
315 ACPI_BITREG_GLOBAL_LOCK_ENABLE,
316 ACPI_BITMASK_GLOBAL_LOCK_STATUS,
317 ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
318 /* ACPI_EVENT_POWER_BUTTON */ {ACPI_BITREG_POWER_BUTTON_STATUS,
319 ACPI_BITREG_POWER_BUTTON_ENABLE,
320 ACPI_BITMASK_POWER_BUTTON_STATUS,
321 ACPI_BITMASK_POWER_BUTTON_ENABLE},
322 /* ACPI_EVENT_SLEEP_BUTTON */ {ACPI_BITREG_SLEEP_BUTTON_STATUS,
323 ACPI_BITREG_SLEEP_BUTTON_ENABLE,
324 ACPI_BITMASK_SLEEP_BUTTON_STATUS,
325 ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
326 /* ACPI_EVENT_RTC */ {ACPI_BITREG_RT_CLOCK_STATUS,
327 ACPI_BITREG_RT_CLOCK_ENABLE,
328 ACPI_BITMASK_RT_CLOCK_STATUS,
329 ACPI_BITMASK_RT_CLOCK_ENABLE},
330 };
331
332 /*******************************************************************************
333 *
334 * FUNCTION: acpi_ut_get_region_name
335 *
336 * PARAMETERS: None.
337 *
338 * RETURN: Status
339 *
340 * DESCRIPTION: Translate a Space ID into a name string (Debug only)
341 *
342 ******************************************************************************/
343
344 /* Region type decoding */
345
346 const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] = {
347 "SystemMemory",
348 "SystemIO",
349 "PCI_Config",
350 "EmbeddedControl",
351 "SMBus",
352 "SystemCMOS",
353 "PCIBARTarget",
354 "DataTable"
355 };
356
357 char *acpi_ut_get_region_name(u8 space_id)
358 {
359
360 if (space_id >= ACPI_USER_REGION_BEGIN) {
361 return ("UserDefinedRegion");
362 } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
363 return ("InvalidSpaceId");
364 }
365
366 return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id]));
367 }
368
369 /*******************************************************************************
370 *
371 * FUNCTION: acpi_ut_get_event_name
372 *
373 * PARAMETERS: None.
374 *
375 * RETURN: Status
376 *
377 * DESCRIPTION: Translate a Event ID into a name string (Debug only)
378 *
379 ******************************************************************************/
380
381 /* Event type decoding */
382
383 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
384 "PM_Timer",
385 "GlobalLock",
386 "PowerButton",
387 "SleepButton",
388 "RealTimeClock",
389 };
390
391 char *acpi_ut_get_event_name(u32 event_id)
392 {
393
394 if (event_id > ACPI_EVENT_MAX) {
395 return ("InvalidEventID");
396 }
397
398 return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id]));
399 }
400
401 /*******************************************************************************
402 *
403 * FUNCTION: acpi_ut_get_type_name
404 *
405 * PARAMETERS: None.
406 *
407 * RETURN: Status
408 *
409 * DESCRIPTION: Translate a Type ID into a name string (Debug only)
410 *
411 ******************************************************************************/
412
413 /*
414 * Elements of acpi_gbl_ns_type_names below must match
415 * one-to-one with values of acpi_object_type
416 *
417 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
418 * when stored in a table it really means that we have thus far seen no
419 * evidence to indicate what type is actually going to be stored for this entry.
420 */
421 static const char acpi_gbl_bad_type[] = "UNDEFINED";
422
423 /* Printable names of the ACPI object types */
424
425 static const char *acpi_gbl_ns_type_names[] = {
426 /* 00 */ "Untyped",
427 /* 01 */ "Integer",
428 /* 02 */ "String",
429 /* 03 */ "Buffer",
430 /* 04 */ "Package",
431 /* 05 */ "FieldUnit",
432 /* 06 */ "Device",
433 /* 07 */ "Event",
434 /* 08 */ "Method",
435 /* 09 */ "Mutex",
436 /* 10 */ "Region",
437 /* 11 */ "Power",
438 /* 12 */ "Processor",
439 /* 13 */ "Thermal",
440 /* 14 */ "BufferField",
441 /* 15 */ "DdbHandle",
442 /* 16 */ "DebugObject",
443 /* 17 */ "RegionField",
444 /* 18 */ "BankField",
445 /* 19 */ "IndexField",
446 /* 20 */ "Reference",
447 /* 21 */ "Alias",
448 /* 22 */ "MethodAlias",
449 /* 23 */ "Notify",
450 /* 24 */ "AddrHandler",
451 /* 25 */ "ResourceDesc",
452 /* 26 */ "ResourceFld",
453 /* 27 */ "Scope",
454 /* 28 */ "Extra",
455 /* 29 */ "Data",
456 /* 30 */ "Invalid"
457 };
458
459 char *acpi_ut_get_type_name(acpi_object_type type)
460 {
461
462 if (type > ACPI_TYPE_INVALID) {
463 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
464 }
465
466 return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
467 }
468
469 char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
470 {
471
472 if (!obj_desc) {
473 return ("[NULL Object Descriptor]");
474 }
475
476 return (acpi_ut_get_type_name(obj_desc->common.type));
477 }
478
479 /*******************************************************************************
480 *
481 * FUNCTION: acpi_ut_get_node_name
482 *
483 * PARAMETERS: Object - A namespace node
484 *
485 * RETURN: Pointer to a string
486 *
487 * DESCRIPTION: Validate the node and return the node's ACPI name.
488 *
489 ******************************************************************************/
490
491 char *acpi_ut_get_node_name(void *object)
492 {
493 struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
494
495 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
496
497 if (!object) {
498 return ("NULL");
499 }
500
501 /* Check for Root node */
502
503 if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
504 return ("\"\\\" ");
505 }
506
507 /* Descriptor must be a namespace node */
508
509 if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
510 return ("####");
511 }
512
513 /* Name must be a valid ACPI name */
514
515 if (!acpi_ut_valid_acpi_name(node->name.integer)) {
516 node->name.integer = acpi_ut_repair_name(node->name.ascii);
517 }
518
519 /* Return the name */
520
521 return (node->name.ascii);
522 }
523
524 /*******************************************************************************
525 *
526 * FUNCTION: acpi_ut_get_descriptor_name
527 *
528 * PARAMETERS: Object - An ACPI object
529 *
530 * RETURN: Pointer to a string
531 *
532 * DESCRIPTION: Validate object and return the descriptor type
533 *
534 ******************************************************************************/
535
536 /* Printable names of object descriptor types */
537
538 static const char *acpi_gbl_desc_type_names[] = {
539 /* 00 */ "Invalid",
540 /* 01 */ "Cached",
541 /* 02 */ "State-Generic",
542 /* 03 */ "State-Update",
543 /* 04 */ "State-Package",
544 /* 05 */ "State-Control",
545 /* 06 */ "State-RootParseScope",
546 /* 07 */ "State-ParseScope",
547 /* 08 */ "State-WalkScope",
548 /* 09 */ "State-Result",
549 /* 10 */ "State-Notify",
550 /* 11 */ "State-Thread",
551 /* 12 */ "Walk",
552 /* 13 */ "Parser",
553 /* 14 */ "Operand",
554 /* 15 */ "Node"
555 };
556
557 char *acpi_ut_get_descriptor_name(void *object)
558 {
559
560 if (!object) {
561 return ("NULL OBJECT");
562 }
563
564 if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
565 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
566 }
567
568 return (ACPI_CAST_PTR(char,
569 acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
570 (object)]));
571
572 }
573
574 /*******************************************************************************
575 *
576 * FUNCTION: acpi_ut_get_reference_name
577 *
578 * PARAMETERS: Object - An ACPI reference object
579 *
580 * RETURN: Pointer to a string
581 *
582 * DESCRIPTION: Decode a reference object sub-type to a string.
583 *
584 ******************************************************************************/
585
586 /* Printable names of reference object sub-types */
587
588 static const char *acpi_gbl_ref_class_names[] = {
589 /* 00 */ "Local",
590 /* 01 */ "Argument",
591 /* 02 */ "RefOf",
592 /* 03 */ "Index",
593 /* 04 */ "DdbHandle",
594 /* 05 */ "Named Object",
595 /* 06 */ "Debug"
596 };
597
598 const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
599 {
600 if (!object)
601 return "NULL Object";
602
603 if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND)
604 return "Not an Operand object";
605
606 if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE)
607 return "Not a Reference object";
608
609 if (object->reference.class > ACPI_REFCLASS_MAX)
610 return "Unknown Reference class";
611
612 return acpi_gbl_ref_class_names[object->reference.class];
613 }
614
615 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
616 /*
617 * Strings and procedures used for debug only
618 */
619
620 /*******************************************************************************
621 *
622 * FUNCTION: acpi_ut_get_mutex_name
623 *
624 * PARAMETERS: mutex_id - The predefined ID for this mutex.
625 *
626 * RETURN: String containing the name of the mutex. Always returns a valid
627 * pointer.
628 *
629 * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
630 *
631 ******************************************************************************/
632
633 char *acpi_ut_get_mutex_name(u32 mutex_id)
634 {
635
636 if (mutex_id > ACPI_MAX_MUTEX) {
637 return ("Invalid Mutex ID");
638 }
639
640 return (acpi_gbl_mutex_names[mutex_id]);
641 }
642
643 /*******************************************************************************
644 *
645 * FUNCTION: acpi_ut_get_notify_name
646 *
647 * PARAMETERS: notify_value - Value from the Notify() request
648 *
649 * RETURN: String corresponding to the Notify Value.
650 *
651 * DESCRIPTION: Translate a Notify Value to a notify namestring.
652 *
653 ******************************************************************************/
654
655 /* Names for Notify() values, used for debug output */
656
657 static const char *acpi_gbl_notify_value_names[] = {
658 "Bus Check",
659 "Device Check",
660 "Device Wake",
661 "Eject Request",
662 "Device Check Light",
663 "Frequency Mismatch",
664 "Bus Mode Mismatch",
665 "Power Fault",
666 "Capabilities Check",
667 "Device PLD Check",
668 "Reserved",
669 "System Locality Update"
670 };
671
672 const char *acpi_ut_get_notify_name(u32 notify_value)
673 {
674
675 if (notify_value <= ACPI_NOTIFY_MAX) {
676 return (acpi_gbl_notify_value_names[notify_value]);
677 } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
678 return ("Reserved");
679 } else { /* Greater or equal to 0x80 */
680
681 return ("**Device Specific**");
682 }
683 }
684 #endif
685
686 /*******************************************************************************
687 *
688 * FUNCTION: acpi_ut_valid_object_type
689 *
690 * PARAMETERS: Type - Object type to be validated
691 *
692 * RETURN: TRUE if valid object type, FALSE otherwise
693 *
694 * DESCRIPTION: Validate an object type
695 *
696 ******************************************************************************/
697
698 u8 acpi_ut_valid_object_type(acpi_object_type type)
699 {
700
701 if (type > ACPI_TYPE_LOCAL_MAX) {
702
703 /* Note: Assumes all TYPEs are contiguous (external/local) */
704
705 return (FALSE);
706 }
707
708 return (TRUE);
709 }
710
711 /*******************************************************************************
712 *
713 * FUNCTION: acpi_ut_init_globals
714 *
715 * PARAMETERS: None
716 *
717 * RETURN: Status
718 *
719 * DESCRIPTION: Init library globals. All globals that require specific
720 * initialization should be initialized here!
721 *
722 ******************************************************************************/
723
724 acpi_status acpi_ut_init_globals(void)
725 {
726 acpi_status status;
727 u32 i;
728
729 ACPI_FUNCTION_TRACE(ut_init_globals);
730
731 /* Create all memory caches */
732
733 status = acpi_ut_create_caches();
734 if (ACPI_FAILURE(status)) {
735 return_ACPI_STATUS(status);
736 }
737
738 /* Mutex locked flags */
739
740 for (i = 0; i < ACPI_NUM_MUTEX; i++) {
741 acpi_gbl_mutex_info[i].mutex = NULL;
742 acpi_gbl_mutex_info[i].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
743 acpi_gbl_mutex_info[i].use_count = 0;
744 }
745
746 for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++) {
747 acpi_gbl_owner_id_mask[i] = 0;
748 }
749
750 /* Last owner_iD is never valid */
751
752 acpi_gbl_owner_id_mask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000;
753
754 /* GPE support */
755
756 acpi_gbl_gpe_xrupt_list_head = NULL;
757 acpi_gbl_gpe_fadt_blocks[0] = NULL;
758 acpi_gbl_gpe_fadt_blocks[1] = NULL;
759 acpi_current_gpe_count = 0;
760
761 /* Global handlers */
762
763 acpi_gbl_system_notify.handler = NULL;
764 acpi_gbl_device_notify.handler = NULL;
765 acpi_gbl_exception_handler = NULL;
766 acpi_gbl_init_handler = NULL;
767 acpi_gbl_table_handler = NULL;
768
769 /* Global Lock support */
770
771 acpi_gbl_global_lock_semaphore = NULL;
772 acpi_gbl_global_lock_mutex = NULL;
773 acpi_gbl_global_lock_acquired = FALSE;
774 acpi_gbl_global_lock_handle = 0;
775 acpi_gbl_global_lock_present = FALSE;
776
777 /* Miscellaneous variables */
778
779 acpi_gbl_cm_single_step = FALSE;
780 acpi_gbl_db_terminate_threads = FALSE;
781 acpi_gbl_shutdown = FALSE;
782 acpi_gbl_ns_lookup_count = 0;
783 acpi_gbl_ps_find_count = 0;
784 acpi_gbl_acpi_hardware_present = TRUE;
785 acpi_gbl_last_owner_id_index = 0;
786 acpi_gbl_next_owner_id_offset = 0;
787 acpi_gbl_trace_method_name = 0;
788 acpi_gbl_trace_dbg_level = 0;
789 acpi_gbl_trace_dbg_layer = 0;
790 acpi_gbl_debugger_configuration = DEBUGGER_THREADING;
791 acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT;
792 acpi_gbl_osi_data = 0;
793
794 /* Hardware oriented */
795
796 acpi_gbl_events_initialized = FALSE;
797 acpi_gbl_system_awake_and_running = TRUE;
798
799 /* Namespace */
800
801 acpi_gbl_root_node = NULL;
802 acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME;
803 acpi_gbl_root_node_struct.descriptor_type = ACPI_DESC_TYPE_NAMED;
804 acpi_gbl_root_node_struct.type = ACPI_TYPE_DEVICE;
805 acpi_gbl_root_node_struct.child = NULL;
806 acpi_gbl_root_node_struct.peer = NULL;
807 acpi_gbl_root_node_struct.object = NULL;
808 acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST;
809
810 #ifdef ACPI_DEBUG_OUTPUT
811 acpi_gbl_lowest_stack_pointer = ACPI_CAST_PTR(acpi_size, ACPI_SIZE_MAX);
812 #endif
813
814 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
815 acpi_gbl_display_final_mem_stats = FALSE;
816 #endif
817
818 return_ACPI_STATUS(AE_OK);
819 }
820
821 ACPI_EXPORT_SYMBOL(acpi_gbl_FADT)
822 ACPI_EXPORT_SYMBOL(acpi_dbg_level)
823 ACPI_EXPORT_SYMBOL(acpi_dbg_layer)
824 ACPI_EXPORT_SYMBOL(acpi_current_gpe_count)
825
|
This page was automatically generated by the
LXR engine.
|