1 /******************************************************************************
2 *
3 * Module Name: utdecode - Utility decoding routines (value-to-string)
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2011, 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 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acnamesp.h"
47
48 #define _COMPONENT ACPI_UTILITIES
49 ACPI_MODULE_NAME("utdecode")
50
51 /*******************************************************************************
52 *
53 * FUNCTION: acpi_format_exception
54 *
55 * PARAMETERS: Status - The acpi_status code to be formatted
56 *
57 * RETURN: A string containing the exception text. A valid pointer is
58 * always returned.
59 *
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.
62 *
63 ******************************************************************************/
acpi_format_exception(acpi_status status)64 const char *acpi_format_exception(acpi_status status)
65 {
66 const char *exception = NULL;
67
68 ACPI_FUNCTION_ENTRY();
69
70 exception = acpi_ut_validate_exception(status);
71 if (!exception) {
72
73 /* Exception code was not recognized */
74
75 ACPI_ERROR((AE_INFO,
76 "Unknown exception code: 0x%8.8X", status));
77
78 exception = "UNKNOWN_STATUS_CODE";
79 }
80
81 return (ACPI_CAST_PTR(const char, exception));
82 }
83
84 ACPI_EXPORT_SYMBOL(acpi_format_exception)
85
86 /*
87 * Properties of the ACPI Object Types, both internal and external.
88 * The table is indexed by values of acpi_object_type
89 */
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 */
122 };
123
124 /*******************************************************************************
125 *
126 * FUNCTION: acpi_ut_hex_to_ascii_char
127 *
128 * PARAMETERS: Integer - Contains the hex digit
129 * Position - bit position of the digit within the
130 * integer (multiple of 4)
131 *
132 * RETURN: The converted Ascii character
133 *
134 * DESCRIPTION: Convert a hex digit to an Ascii character
135 *
136 ******************************************************************************/
137
138 /* Hex to ASCII conversion table */
139
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'
143 };
144
acpi_ut_hex_to_ascii_char(u64 integer,u32 position)145 char acpi_ut_hex_to_ascii_char(u64 integer, u32 position)
146 {
147
148 return (acpi_gbl_hex_to_ascii[(integer >> position) & 0xF]);
149 }
150
151 /*******************************************************************************
152 *
153 * FUNCTION: acpi_ut_get_region_name
154 *
155 * PARAMETERS: Space ID - ID for the region
156 *
157 * RETURN: Decoded region space_id name
158 *
159 * DESCRIPTION: Translate a Space ID into a name string (Debug only)
160 *
161 ******************************************************************************/
162
163 /* Region type decoding */
164
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",
174 "DataTable"
175 };
176
acpi_ut_get_region_name(u8 space_id)177 char *acpi_ut_get_region_name(u8 space_id)
178 {
179
180 if (space_id >= ACPI_USER_REGION_BEGIN) {
181 return ("UserDefinedRegion");
182 } else if (space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
183 return ("FunctionalFixedHW");
184 } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
185 return ("InvalidSpaceId");
186 }
187
188 return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id]));
189 }
190
191 /*******************************************************************************
192 *
193 * FUNCTION: acpi_ut_get_event_name
194 *
195 * PARAMETERS: event_id - Fixed event ID
196 *
197 * RETURN: Decoded event ID name
198 *
199 * DESCRIPTION: Translate a Event ID into a name string (Debug only)
200 *
201 ******************************************************************************/
202
203 /* Event type decoding */
204
205 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
206 "PM_Timer",
207 "GlobalLock",
208 "PowerButton",
209 "SleepButton",
210 "RealTimeClock",
211 };
212
acpi_ut_get_event_name(u32 event_id)213 char *acpi_ut_get_event_name(u32 event_id)
214 {
215
216 if (event_id > ACPI_EVENT_MAX) {
217 return ("InvalidEventID");
218 }
219
220 return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id]));
221 }
222
223 /*******************************************************************************
224 *
225 * FUNCTION: acpi_ut_get_type_name
226 *
227 * PARAMETERS: Type - An ACPI object type
228 *
229 * RETURN: Decoded ACPI object type name
230 *
231 * DESCRIPTION: Translate a Type ID into a name string (Debug only)
232 *
233 ******************************************************************************/
234
235 /*
236 * Elements of acpi_gbl_ns_type_names below must match
237 * one-to-one with values of acpi_object_type
238 *
239 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
240 * when stored in a table it really means that we have thus far seen no
241 * evidence to indicate what type is actually going to be stored for this entry.
242 */
243 static const char acpi_gbl_bad_type[] = "UNDEFINED";
244
245 /* Printable names of the ACPI object types */
246
247 static const char *acpi_gbl_ns_type_names[] = {
248 /* 00 */ "Untyped",
249 /* 01 */ "Integer",
250 /* 02 */ "String",
251 /* 03 */ "Buffer",
252 /* 04 */ "Package",
253 /* 05 */ "FieldUnit",
254 /* 06 */ "Device",
255 /* 07 */ "Event",
256 /* 08 */ "Method",
257 /* 09 */ "Mutex",
258 /* 10 */ "Region",
259 /* 11 */ "Power",
260 /* 12 */ "Processor",
261 /* 13 */ "Thermal",
262 /* 14 */ "BufferField",
263 /* 15 */ "DdbHandle",
264 /* 16 */ "DebugObject",
265 /* 17 */ "RegionField",
266 /* 18 */ "BankField",
267 /* 19 */ "IndexField",
268 /* 20 */ "Reference",
269 /* 21 */ "Alias",
270 /* 22 */ "MethodAlias",
271 /* 23 */ "Notify",
272 /* 24 */ "AddrHandler",
273 /* 25 */ "ResourceDesc",
274 /* 26 */ "ResourceFld",
275 /* 27 */ "Scope",
276 /* 28 */ "Extra",
277 /* 29 */ "Data",
278 /* 30 */ "Invalid"
279 };
280
acpi_ut_get_type_name(acpi_object_type type)281 char *acpi_ut_get_type_name(acpi_object_type type)
282 {
283
284 if (type > ACPI_TYPE_INVALID) {
285 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
286 }
287
288 return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
289 }
290
acpi_ut_get_object_type_name(union acpi_operand_object * obj_desc)291 char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
292 {
293
294 if (!obj_desc) {
295 return ("[NULL Object Descriptor]");
296 }
297
298 return (acpi_ut_get_type_name(obj_desc->common.type));
299 }
300
301 /*******************************************************************************
302 *
303 * FUNCTION: acpi_ut_get_node_name
304 *
305 * PARAMETERS: Object - A namespace node
306 *
307 * RETURN: ASCII name of the node
308 *
309 * DESCRIPTION: Validate the node and return the node's ACPI name.
310 *
311 ******************************************************************************/
312
acpi_ut_get_node_name(void * object)313 char *acpi_ut_get_node_name(void *object)
314 {
315 struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
316
317 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
318
319 if (!object) {
320 return ("NULL");
321 }
322
323 /* Check for Root node */
324
325 if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
326 return ("\"\\\" ");
327 }
328
329 /* Descriptor must be a namespace node */
330
331 if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
332 return ("####");
333 }
334
335 /*
336 * Ensure name is valid. The name was validated/repaired when the node
337 * was created, but make sure it has not been corrupted.
338 */
339 acpi_ut_repair_name(node->name.ascii);
340
341 /* Return the name */
342
343 return (node->name.ascii);
344 }
345
346 /*******************************************************************************
347 *
348 * FUNCTION: acpi_ut_get_descriptor_name
349 *
350 * PARAMETERS: Object - An ACPI object
351 *
352 * RETURN: Decoded name of the descriptor type
353 *
354 * DESCRIPTION: Validate object and return the descriptor type
355 *
356 ******************************************************************************/
357
358 /* Printable names of object descriptor types */
359
360 static const char *acpi_gbl_desc_type_names[] = {
361 /* 00 */ "Not a Descriptor",
362 /* 01 */ "Cached",
363 /* 02 */ "State-Generic",
364 /* 03 */ "State-Update",
365 /* 04 */ "State-Package",
366 /* 05 */ "State-Control",
367 /* 06 */ "State-RootParseScope",
368 /* 07 */ "State-ParseScope",
369 /* 08 */ "State-WalkScope",
370 /* 09 */ "State-Result",
371 /* 10 */ "State-Notify",
372 /* 11 */ "State-Thread",
373 /* 12 */ "Walk",
374 /* 13 */ "Parser",
375 /* 14 */ "Operand",
376 /* 15 */ "Node"
377 };
378
acpi_ut_get_descriptor_name(void * object)379 char *acpi_ut_get_descriptor_name(void *object)
380 {
381
382 if (!object) {
383 return ("NULL OBJECT");
384 }
385
386 if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
387 return ("Not a Descriptor");
388 }
389
390 return (ACPI_CAST_PTR(char,
391 acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
392 (object)]));
393
394 }
395
396 /*******************************************************************************
397 *
398 * FUNCTION: acpi_ut_get_reference_name
399 *
400 * PARAMETERS: Object - An ACPI reference object
401 *
402 * RETURN: Decoded name of the type of reference
403 *
404 * DESCRIPTION: Decode a reference object sub-type to a string.
405 *
406 ******************************************************************************/
407
408 /* Printable names of reference object sub-types */
409
410 static const char *acpi_gbl_ref_class_names[] = {
411 /* 00 */ "Local",
412 /* 01 */ "Argument",
413 /* 02 */ "RefOf",
414 /* 03 */ "Index",
415 /* 04 */ "DdbHandle",
416 /* 05 */ "Named Object",
417 /* 06 */ "Debug"
418 };
419
acpi_ut_get_reference_name(union acpi_operand_object * object)420 const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
421 {
422
423 if (!object) {
424 return ("NULL Object");
425 }
426
427 if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
428 return ("Not an Operand object");
429 }
430
431 if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE) {
432 return ("Not a Reference object");
433 }
434
435 if (object->reference.class > ACPI_REFCLASS_MAX) {
436 return ("Unknown Reference class");
437 }
438
439 return (acpi_gbl_ref_class_names[object->reference.class]);
440 }
441
442 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
443 /*
444 * Strings and procedures used for debug only
445 */
446
447 /*******************************************************************************
448 *
449 * FUNCTION: acpi_ut_get_mutex_name
450 *
451 * PARAMETERS: mutex_id - The predefined ID for this mutex.
452 *
453 * RETURN: Decoded name of the internal mutex
454 *
455 * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
456 *
457 ******************************************************************************/
458
459 /* Names for internal mutex objects, used for debug output */
460
461 static char *acpi_gbl_mutex_names[ACPI_NUM_MUTEX] = {
462 "ACPI_MTX_Interpreter",
463 "ACPI_MTX_Namespace",
464 "ACPI_MTX_Tables",
465 "ACPI_MTX_Events",
466 "ACPI_MTX_Caches",
467 "ACPI_MTX_Memory",
468 "ACPI_MTX_CommandComplete",
469 "ACPI_MTX_CommandReady"
470 };
471
acpi_ut_get_mutex_name(u32 mutex_id)472 char *acpi_ut_get_mutex_name(u32 mutex_id)
473 {
474
475 if (mutex_id > ACPI_MAX_MUTEX) {
476 return ("Invalid Mutex ID");
477 }
478
479 return (acpi_gbl_mutex_names[mutex_id]);
480 }
481
482 /*******************************************************************************
483 *
484 * FUNCTION: acpi_ut_get_notify_name
485 *
486 * PARAMETERS: notify_value - Value from the Notify() request
487 *
488 * RETURN: Decoded name for the notify value
489 *
490 * DESCRIPTION: Translate a Notify Value to a notify namestring.
491 *
492 ******************************************************************************/
493
494 /* Names for Notify() values, used for debug output */
495
496 static const char *acpi_gbl_notify_value_names[] = {
497 "Bus Check",
498 "Device Check",
499 "Device Wake",
500 "Eject Request",
501 "Device Check Light",
502 "Frequency Mismatch",
503 "Bus Mode Mismatch",
504 "Power Fault",
505 "Capabilities Check",
506 "Device PLD Check",
507 "Reserved",
508 "System Locality Update"
509 };
510
acpi_ut_get_notify_name(u32 notify_value)511 const char *acpi_ut_get_notify_name(u32 notify_value)
512 {
513
514 if (notify_value <= ACPI_NOTIFY_MAX) {
515 return (acpi_gbl_notify_value_names[notify_value]);
516 } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
517 return ("Reserved");
518 } else { /* Greater or equal to 0x80 */
519
520 return ("**Device Specific**");
521 }
522 }
523 #endif
524
525 /*******************************************************************************
526 *
527 * FUNCTION: acpi_ut_valid_object_type
528 *
529 * PARAMETERS: Type - Object type to be validated
530 *
531 * RETURN: TRUE if valid object type, FALSE otherwise
532 *
533 * DESCRIPTION: Validate an object type
534 *
535 ******************************************************************************/
536
acpi_ut_valid_object_type(acpi_object_type type)537 u8 acpi_ut_valid_object_type(acpi_object_type type)
538 {
539
540 if (type > ACPI_TYPE_LOCAL_MAX) {
541
542 /* Note: Assumes all TYPEs are contiguous (external/local) */
543
544 return (FALSE);
545 }
546
547 return (TRUE);
548 }
549