Merge branch 'upstream' of git://git.linux-mips.org/pub/scm/upstream-linus
[linux-btrfs-devel.git] / drivers / acpi / acpica / utdecode.c
blob97cb36f85ce9d4e98f8e5576df9a4d70a049aeb6
1 /******************************************************************************
3 * Module Name: utdecode - Utility decoding routines (value-to-string)
5 *****************************************************************************/
7 /*
8 * Copyright (C) 2000 - 2011, Intel Corp.
9 * All rights reserved.
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.
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.
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.
44 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acnamesp.h"
48 #define _COMPONENT ACPI_UTILITIES
49 ACPI_MODULE_NAME("utdecode")
51 /*******************************************************************************
53 * FUNCTION: acpi_format_exception
55 * PARAMETERS: Status - The acpi_status code to be formatted
57 * RETURN: A string containing the exception text. A valid pointer is
58 * always returned.
60 * DESCRIPTION: This function translates an ACPI exception into an ASCII string
61 * It is here instead of utxface.c so it is always present.
63 ******************************************************************************/
64 const char *acpi_format_exception(acpi_status status)
66 const char *exception = NULL;
68 ACPI_FUNCTION_ENTRY();
70 exception = acpi_ut_validate_exception(status);
71 if (!exception) {
73 /* Exception code was not recognized */
75 ACPI_ERROR((AE_INFO,
76 "Unknown exception code: 0x%8.8X", status));
78 exception = "UNKNOWN_STATUS_CODE";
81 return (ACPI_CAST_PTR(const char, exception));
84 ACPI_EXPORT_SYMBOL(acpi_format_exception)
87 * Properties of the ACPI Object Types, both internal and external.
88 * The table is indexed by values of acpi_object_type
90 const u8 acpi_gbl_ns_properties[ACPI_NUM_NS_TYPES] = {
91 ACPI_NS_NORMAL, /* 00 Any */
92 ACPI_NS_NORMAL, /* 01 Number */
93 ACPI_NS_NORMAL, /* 02 String */
94 ACPI_NS_NORMAL, /* 03 Buffer */
95 ACPI_NS_NORMAL, /* 04 Package */
96 ACPI_NS_NORMAL, /* 05 field_unit */
97 ACPI_NS_NEWSCOPE, /* 06 Device */
98 ACPI_NS_NORMAL, /* 07 Event */
99 ACPI_NS_NEWSCOPE, /* 08 Method */
100 ACPI_NS_NORMAL, /* 09 Mutex */
101 ACPI_NS_NORMAL, /* 10 Region */
102 ACPI_NS_NEWSCOPE, /* 11 Power */
103 ACPI_NS_NEWSCOPE, /* 12 Processor */
104 ACPI_NS_NEWSCOPE, /* 13 Thermal */
105 ACPI_NS_NORMAL, /* 14 buffer_field */
106 ACPI_NS_NORMAL, /* 15 ddb_handle */
107 ACPI_NS_NORMAL, /* 16 Debug Object */
108 ACPI_NS_NORMAL, /* 17 def_field */
109 ACPI_NS_NORMAL, /* 18 bank_field */
110 ACPI_NS_NORMAL, /* 19 index_field */
111 ACPI_NS_NORMAL, /* 20 Reference */
112 ACPI_NS_NORMAL, /* 21 Alias */
113 ACPI_NS_NORMAL, /* 22 method_alias */
114 ACPI_NS_NORMAL, /* 23 Notify */
115 ACPI_NS_NORMAL, /* 24 Address Handler */
116 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 25 Resource Desc */
117 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 26 Resource Field */
118 ACPI_NS_NEWSCOPE, /* 27 Scope */
119 ACPI_NS_NORMAL, /* 28 Extra */
120 ACPI_NS_NORMAL, /* 29 Data */
121 ACPI_NS_NORMAL /* 30 Invalid */
124 /*******************************************************************************
126 * FUNCTION: acpi_ut_hex_to_ascii_char
128 * PARAMETERS: Integer - Contains the hex digit
129 * Position - bit position of the digit within the
130 * integer (multiple of 4)
132 * RETURN: The converted Ascii character
134 * DESCRIPTION: Convert a hex digit to an Ascii character
136 ******************************************************************************/
138 /* Hex to ASCII conversion table */
140 static const char acpi_gbl_hex_to_ascii[] = {
141 '0', '1', '2', '3', '4', '5', '6', '7',
142 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
145 char acpi_ut_hex_to_ascii_char(u64 integer, u32 position)
148 return (acpi_gbl_hex_to_ascii[(integer >> position) & 0xF]);
151 /*******************************************************************************
153 * FUNCTION: acpi_ut_get_region_name
155 * PARAMETERS: Space ID - ID for the region
157 * RETURN: Decoded region space_id name
159 * DESCRIPTION: Translate a Space ID into a name string (Debug only)
161 ******************************************************************************/
163 /* Region type decoding */
165 const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] = {
166 "SystemMemory",
167 "SystemIO",
168 "PCI_Config",
169 "EmbeddedControl",
170 "SMBus",
171 "SystemCMOS",
172 "PCIBARTarget",
173 "IPMI"
176 char *acpi_ut_get_region_name(u8 space_id)
179 if (space_id >= ACPI_USER_REGION_BEGIN) {
180 return ("UserDefinedRegion");
181 } else if (space_id == ACPI_ADR_SPACE_DATA_TABLE) {
182 return ("DataTable");
183 } else if (space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
184 return ("FunctionalFixedHW");
185 } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
186 return ("InvalidSpaceId");
189 return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id]));
192 /*******************************************************************************
194 * FUNCTION: acpi_ut_get_event_name
196 * PARAMETERS: event_id - Fixed event ID
198 * RETURN: Decoded event ID name
200 * DESCRIPTION: Translate a Event ID into a name string (Debug only)
202 ******************************************************************************/
204 /* Event type decoding */
206 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
207 "PM_Timer",
208 "GlobalLock",
209 "PowerButton",
210 "SleepButton",
211 "RealTimeClock",
214 char *acpi_ut_get_event_name(u32 event_id)
217 if (event_id > ACPI_EVENT_MAX) {
218 return ("InvalidEventID");
221 return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id]));
224 /*******************************************************************************
226 * FUNCTION: acpi_ut_get_type_name
228 * PARAMETERS: Type - An ACPI object type
230 * RETURN: Decoded ACPI object type name
232 * DESCRIPTION: Translate a Type ID into a name string (Debug only)
234 ******************************************************************************/
237 * Elements of acpi_gbl_ns_type_names below must match
238 * one-to-one with values of acpi_object_type
240 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
241 * when stored in a table it really means that we have thus far seen no
242 * evidence to indicate what type is actually going to be stored for this entry.
244 static const char acpi_gbl_bad_type[] = "UNDEFINED";
246 /* Printable names of the ACPI object types */
248 static const char *acpi_gbl_ns_type_names[] = {
249 /* 00 */ "Untyped",
250 /* 01 */ "Integer",
251 /* 02 */ "String",
252 /* 03 */ "Buffer",
253 /* 04 */ "Package",
254 /* 05 */ "FieldUnit",
255 /* 06 */ "Device",
256 /* 07 */ "Event",
257 /* 08 */ "Method",
258 /* 09 */ "Mutex",
259 /* 10 */ "Region",
260 /* 11 */ "Power",
261 /* 12 */ "Processor",
262 /* 13 */ "Thermal",
263 /* 14 */ "BufferField",
264 /* 15 */ "DdbHandle",
265 /* 16 */ "DebugObject",
266 /* 17 */ "RegionField",
267 /* 18 */ "BankField",
268 /* 19 */ "IndexField",
269 /* 20 */ "Reference",
270 /* 21 */ "Alias",
271 /* 22 */ "MethodAlias",
272 /* 23 */ "Notify",
273 /* 24 */ "AddrHandler",
274 /* 25 */ "ResourceDesc",
275 /* 26 */ "ResourceFld",
276 /* 27 */ "Scope",
277 /* 28 */ "Extra",
278 /* 29 */ "Data",
279 /* 30 */ "Invalid"
282 char *acpi_ut_get_type_name(acpi_object_type type)
285 if (type > ACPI_TYPE_INVALID) {
286 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
289 return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
292 char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
295 if (!obj_desc) {
296 return ("[NULL Object Descriptor]");
299 return (acpi_ut_get_type_name(obj_desc->common.type));
302 /*******************************************************************************
304 * FUNCTION: acpi_ut_get_node_name
306 * PARAMETERS: Object - A namespace node
308 * RETURN: ASCII name of the node
310 * DESCRIPTION: Validate the node and return the node's ACPI name.
312 ******************************************************************************/
314 char *acpi_ut_get_node_name(void *object)
316 struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
318 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
320 if (!object) {
321 return ("NULL");
324 /* Check for Root node */
326 if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
327 return ("\"\\\" ");
330 /* Descriptor must be a namespace node */
332 if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
333 return ("####");
337 * Ensure name is valid. The name was validated/repaired when the node
338 * was created, but make sure it has not been corrupted.
340 acpi_ut_repair_name(node->name.ascii);
342 /* Return the name */
344 return (node->name.ascii);
347 /*******************************************************************************
349 * FUNCTION: acpi_ut_get_descriptor_name
351 * PARAMETERS: Object - An ACPI object
353 * RETURN: Decoded name of the descriptor type
355 * DESCRIPTION: Validate object and return the descriptor type
357 ******************************************************************************/
359 /* Printable names of object descriptor types */
361 static const char *acpi_gbl_desc_type_names[] = {
362 /* 00 */ "Not a Descriptor",
363 /* 01 */ "Cached",
364 /* 02 */ "State-Generic",
365 /* 03 */ "State-Update",
366 /* 04 */ "State-Package",
367 /* 05 */ "State-Control",
368 /* 06 */ "State-RootParseScope",
369 /* 07 */ "State-ParseScope",
370 /* 08 */ "State-WalkScope",
371 /* 09 */ "State-Result",
372 /* 10 */ "State-Notify",
373 /* 11 */ "State-Thread",
374 /* 12 */ "Walk",
375 /* 13 */ "Parser",
376 /* 14 */ "Operand",
377 /* 15 */ "Node"
380 char *acpi_ut_get_descriptor_name(void *object)
383 if (!object) {
384 return ("NULL OBJECT");
387 if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
388 return ("Not a Descriptor");
391 return (ACPI_CAST_PTR(char,
392 acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
393 (object)]));
397 /*******************************************************************************
399 * FUNCTION: acpi_ut_get_reference_name
401 * PARAMETERS: Object - An ACPI reference object
403 * RETURN: Decoded name of the type of reference
405 * DESCRIPTION: Decode a reference object sub-type to a string.
407 ******************************************************************************/
409 /* Printable names of reference object sub-types */
411 static const char *acpi_gbl_ref_class_names[] = {
412 /* 00 */ "Local",
413 /* 01 */ "Argument",
414 /* 02 */ "RefOf",
415 /* 03 */ "Index",
416 /* 04 */ "DdbHandle",
417 /* 05 */ "Named Object",
418 /* 06 */ "Debug"
421 const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
424 if (!object) {
425 return ("NULL Object");
428 if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
429 return ("Not an Operand object");
432 if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE) {
433 return ("Not a Reference object");
436 if (object->reference.class > ACPI_REFCLASS_MAX) {
437 return ("Unknown Reference class");
440 return (acpi_gbl_ref_class_names[object->reference.class]);
443 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
445 * Strings and procedures used for debug only
448 /*******************************************************************************
450 * FUNCTION: acpi_ut_get_mutex_name
452 * PARAMETERS: mutex_id - The predefined ID for this mutex.
454 * RETURN: Decoded name of the internal mutex
456 * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
458 ******************************************************************************/
460 /* Names for internal mutex objects, used for debug output */
462 static char *acpi_gbl_mutex_names[ACPI_NUM_MUTEX] = {
463 "ACPI_MTX_Interpreter",
464 "ACPI_MTX_Namespace",
465 "ACPI_MTX_Tables",
466 "ACPI_MTX_Events",
467 "ACPI_MTX_Caches",
468 "ACPI_MTX_Memory",
469 "ACPI_MTX_CommandComplete",
470 "ACPI_MTX_CommandReady"
473 char *acpi_ut_get_mutex_name(u32 mutex_id)
476 if (mutex_id > ACPI_MAX_MUTEX) {
477 return ("Invalid Mutex ID");
480 return (acpi_gbl_mutex_names[mutex_id]);
483 /*******************************************************************************
485 * FUNCTION: acpi_ut_get_notify_name
487 * PARAMETERS: notify_value - Value from the Notify() request
489 * RETURN: Decoded name for the notify value
491 * DESCRIPTION: Translate a Notify Value to a notify namestring.
493 ******************************************************************************/
495 /* Names for Notify() values, used for debug output */
497 static const char *acpi_gbl_notify_value_names[] = {
498 "Bus Check",
499 "Device Check",
500 "Device Wake",
501 "Eject Request",
502 "Device Check Light",
503 "Frequency Mismatch",
504 "Bus Mode Mismatch",
505 "Power Fault",
506 "Capabilities Check",
507 "Device PLD Check",
508 "Reserved",
509 "System Locality Update"
512 const char *acpi_ut_get_notify_name(u32 notify_value)
515 if (notify_value <= ACPI_NOTIFY_MAX) {
516 return (acpi_gbl_notify_value_names[notify_value]);
517 } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
518 return ("Reserved");
519 } else { /* Greater or equal to 0x80 */
521 return ("**Device Specific**");
524 #endif
526 /*******************************************************************************
528 * FUNCTION: acpi_ut_valid_object_type
530 * PARAMETERS: Type - Object type to be validated
532 * RETURN: TRUE if valid object type, FALSE otherwise
534 * DESCRIPTION: Validate an object type
536 ******************************************************************************/
538 u8 acpi_ut_valid_object_type(acpi_object_type type)
541 if (type > ACPI_TYPE_LOCAL_MAX) {
543 /* Note: Assumes all TYPEs are contiguous (external/local) */
545 return (FALSE);
548 return (TRUE);