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 #define __UTDECODE_C__
45
46 #include "acpi.h"
47 #include "accommon.h"
48 #include "acnamesp.h"
49
50 #define _COMPONENT ACPI_UTILITIES
51 ACPI_MODULE_NAME ("utdecode")
52
53
54 /*******************************************************************************
55 *
56 * FUNCTION: AcpiFormatException
57 *
58 * PARAMETERS: Status - The ACPI_STATUS code to be formatted
59 *
60 * RETURN: A string containing the exception text. A valid pointer is
61 * always returned.
62 *
63 * DESCRIPTION: This function translates an ACPI exception into an ASCII string
64 * It is here instead of utxface.c so it is always present.
65 *
66 ******************************************************************************/
67
68 const char *
69 AcpiFormatException (
70 ACPI_STATUS Status)
71 {
72 const char *Exception = NULL;
73
74
75 ACPI_FUNCTION_ENTRY ();
76
77
78 Exception = AcpiUtValidateException (Status);
79 if (!Exception)
80 {
81 /* Exception code was not recognized */
82
83 ACPI_ERROR ((AE_INFO,
84 "Unknown exception code: 0x%8.8X", Status));
85
86 Exception = "UNKNOWN_STATUS_CODE";
87 }
88
89 return (ACPI_CAST_PTR (const char, Exception));
90 }
91
92 ACPI_EXPORT_SYMBOL (AcpiFormatException)
93
94
95 /*
96 * Properties of the ACPI Object Types, both internal and external.
97 * The table is indexed by values of ACPI_OBJECT_TYPE
98 */
99 const UINT8 AcpiGbl_NsProperties[ACPI_NUM_NS_TYPES] =
100 {
101 ACPI_NS_NORMAL, /* 00 Any */
102 ACPI_NS_NORMAL, /* 01 Number */
103 ACPI_NS_NORMAL, /* 02 String */
104 ACPI_NS_NORMAL, /* 03 Buffer */
105 ACPI_NS_NORMAL, /* 04 Package */
106 ACPI_NS_NORMAL, /* 05 FieldUnit */
107 ACPI_NS_NEWSCOPE, /* 06 Device */
108 ACPI_NS_NORMAL, /* 07 Event */
109 ACPI_NS_NEWSCOPE, /* 08 Method */
110 ACPI_NS_NORMAL, /* 09 Mutex */
111 ACPI_NS_NORMAL, /* 10 Region */
112 ACPI_NS_NEWSCOPE, /* 11 Power */
113 ACPI_NS_NEWSCOPE, /* 12 Processor */
114 ACPI_NS_NEWSCOPE, /* 13 Thermal */
115 ACPI_NS_NORMAL, /* 14 BufferField */
116 ACPI_NS_NORMAL, /* 15 DdbHandle */
117 ACPI_NS_NORMAL, /* 16 Debug Object */
118 ACPI_NS_NORMAL, /* 17 DefField */
119 ACPI_NS_NORMAL, /* 18 BankField */
120 ACPI_NS_NORMAL, /* 19 IndexField */
121 ACPI_NS_NORMAL, /* 20 Reference */
122 ACPI_NS_NORMAL, /* 21 Alias */
123 ACPI_NS_NORMAL, /* 22 MethodAlias */
124 ACPI_NS_NORMAL, /* 23 Notify */
125 ACPI_NS_NORMAL, /* 24 Address Handler */
126 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 25 Resource Desc */
127 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 26 Resource Field */
128 ACPI_NS_NEWSCOPE, /* 27 Scope */
129 ACPI_NS_NORMAL, /* 28 Extra */
130 ACPI_NS_NORMAL, /* 29 Data */
131 ACPI_NS_NORMAL /* 30 Invalid */
132 };
133
134
135 /*******************************************************************************
136 *
137 * FUNCTION: AcpiUtHexToAsciiChar
138 *
139 * PARAMETERS: Integer - Contains the hex digit
140 * Position - bit position of the digit within the
141 * integer (multiple of 4)
142 *
143 * RETURN: The converted Ascii character
144 *
145 * DESCRIPTION: Convert a hex digit to an Ascii character
146 *
147 ******************************************************************************/
148
149 /* Hex to ASCII conversion table */
150
151 static const char AcpiGbl_HexToAscii[] =
152 {
153 '0','1','2','3','4','5','6','7',
154 '8','9','A','B','C','D','E','F'
155 };
156
157 char
158 AcpiUtHexToAsciiChar (
159 UINT64 Integer,
160 UINT32 Position)
161 {
162
163 return (AcpiGbl_HexToAscii[(Integer >> Position) & 0xF]);
164 }
165
166
167 /*******************************************************************************
168 *
169 * FUNCTION: AcpiUtGetRegionName
170 *
171 * PARAMETERS: Space ID - ID for the region
172 *
173 * RETURN: Decoded region SpaceId name
174 *
175 * DESCRIPTION: Translate a Space ID into a name string (Debug only)
176 *
177 ******************************************************************************/
178
179 /* Region type decoding */
180
181 const char *AcpiGbl_RegionTypes[ACPI_NUM_PREDEFINED_REGIONS] =
182 {
183 "SystemMemory",
184 "SystemIO",
185 "PCI_Config",
186 "EmbeddedControl",
187 "SMBus",
188 "SystemCMOS",
189 "PCIBARTarget",
190 "IPMI"
191 };
192
193
194 char *
195 AcpiUtGetRegionName (
196 UINT8 SpaceId)
197 {
198
199 if (SpaceId >= ACPI_USER_REGION_BEGIN)
200 {
201 return ("UserDefinedRegion");
202 }
203 else if (SpaceId == ACPI_ADR_SPACE_DATA_TABLE)
204 {
205 return ("DataTable");
206 }
207 else if (SpaceId == ACPI_ADR_SPACE_FIXED_HARDWARE)
208 {
209 return ("FunctionalFixedHW");
210 }
211 else if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS)
212 {
213 return ("InvalidSpaceId");
214 }
215
216 return (ACPI_CAST_PTR (char, AcpiGbl_RegionTypes[SpaceId]));
217 }
218
219
220 /*******************************************************************************
221 *
222 * FUNCTION: AcpiUtGetEventName
223 *
224 * PARAMETERS: EventId - Fixed event ID
225 *
226 * RETURN: Decoded event ID name
227 *
228 * DESCRIPTION: Translate a Event ID into a name string (Debug only)
229 *
230 ******************************************************************************/
231
232 /* Event type decoding */
233
234 static const char *AcpiGbl_EventTypes[ACPI_NUM_FIXED_EVENTS] =
235 {
236 "PM_Timer",
237 "GlobalLock",
238 "PowerButton",
239 "SleepButton",
240 "RealTimeClock",
241 };
242
243
244 char *
245 AcpiUtGetEventName (
246 UINT32 EventId)
247 {
248
249 if (EventId > ACPI_EVENT_MAX)
250 {
251 return ("InvalidEventID");
252 }
253
254 return (ACPI_CAST_PTR (char, AcpiGbl_EventTypes[EventId]));
255 }
256
257
258 /*******************************************************************************
259 *
260 * FUNCTION: AcpiUtGetTypeName
261 *
262 * PARAMETERS: Type - An ACPI object type
263 *
264 * RETURN: Decoded ACPI object type name
265 *
266 * DESCRIPTION: Translate a Type ID into a name string (Debug only)
267 *
268 ******************************************************************************/
269
270 /*
271 * Elements of AcpiGbl_NsTypeNames below must match
272 * one-to-one with values of ACPI_OBJECT_TYPE
273 *
274 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
275 * when stored in a table it really means that we have thus far seen no
276 * evidence to indicate what type is actually going to be stored for this entry.
277 */
278 static const char AcpiGbl_BadType[] = "UNDEFINED";
279
280 /* Printable names of the ACPI object types */
281
282 static const char *AcpiGbl_NsTypeNames[] =
283 {
284 /* 00 */ "Untyped",
285 /* 01 */ "Integer",
286 /* 02 */ "String",
287 /* 03 */ "Buffer",
288 /* 04 */ "Package",
289 /* 05 */ "FieldUnit",
290 /* 06 */ "Device",
291 /* 07 */ "Event",
292 /* 08 */ "Method",
293 /* 09 */ "Mutex",
294 /* 10 */ "Region",
295 /* 11 */ "Power",
296 /* 12 */ "Processor",
297 /* 13 */ "Thermal",
298 /* 14 */ "BufferField",
299 /* 15 */ "DdbHandle",
300 /* 16 */ "DebugObject",
301 /* 17 */ "RegionField",
302 /* 18 */ "BankField",
303 /* 19 */ "IndexField",
304 /* 20 */ "Reference",
305 /* 21 */ "Alias",
306 /* 22 */ "MethodAlias",
307 /* 23 */ "Notify",
308 /* 24 */ "AddrHandler",
309 /* 25 */ "ResourceDesc",
310 /* 26 */ "ResourceFld",
311 /* 27 */ "Scope",
312 /* 28 */ "Extra",
313 /* 29 */ "Data",
314 /* 30 */ "Invalid"
315 };
316
317
318 char *
319 AcpiUtGetTypeName (
320 ACPI_OBJECT_TYPE Type)
321 {
322
323 if (Type > ACPI_TYPE_INVALID)
324 {
325 return (ACPI_CAST_PTR (char, AcpiGbl_BadType));
326 }
327
328 return (ACPI_CAST_PTR (char, AcpiGbl_NsTypeNames[Type]));
329 }
330
331
332 char *
333 AcpiUtGetObjectTypeName (
334 ACPI_OPERAND_OBJECT *ObjDesc)
335 {
336
337 if (!ObjDesc)
338 {
339 return ("[NULL Object Descriptor]");
340 }
341
342 return (AcpiUtGetTypeName (ObjDesc->Common.Type));
343 }
344
345
346 /*******************************************************************************
347 *
348 * FUNCTION: AcpiUtGetNodeName
349 *
350 * PARAMETERS: Object - A namespace node
351 *
352 * RETURN: ASCII name of the node
353 *
354 * DESCRIPTION: Validate the node and return the node's ACPI name.
355 *
356 ******************************************************************************/
357
358 char *
359 AcpiUtGetNodeName (
360 void *Object)
361 {
362 ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) Object;
363
364
365 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
366
367 if (!Object)
368 {
369 return ("NULL");
370 }
371
372 /* Check for Root node */
373
374 if ((Object == ACPI_ROOT_OBJECT) ||
375 (Object == AcpiGbl_RootNode))
376 {
377 return ("\"\\\" ");
378 }
379
380 /* Descriptor must be a namespace node */
381
382 if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
383 {
384 return ("####");
385 }
386
387 /*
388 * Ensure name is valid. The name was validated/repaired when the node
389 * was created, but make sure it has not been corrupted.
390 */
391 AcpiUtRepairName (Node->Name.Ascii);
392
393 /* Return the name */
394
395 return (Node->Name.Ascii);
396 }
397
398
399 /*******************************************************************************
400 *
401 * FUNCTION: AcpiUtGetDescriptorName
402 *
403 * PARAMETERS: Object - An ACPI object
404 *
405 * RETURN: Decoded name of the descriptor type
406 *
407 * DESCRIPTION: Validate object and return the descriptor type
408 *
409 ******************************************************************************/
410
411 /* Printable names of object descriptor types */
412
413 static const char *AcpiGbl_DescTypeNames[] =
414 {
415 /* 00 */ "Not a Descriptor",
416 /* 01 */ "Cached",
417 /* 02 */ "State-Generic",
418 /* 03 */ "State-Update",
419 /* 04 */ "State-Package",
420 /* 05 */ "State-Control",
421 /* 06 */ "State-RootParseScope",
422 /* 07 */ "State-ParseScope",
423 /* 08 */ "State-WalkScope",
424 /* 09 */ "State-Result",
425 /* 10 */ "State-Notify",
426 /* 11 */ "State-Thread",
427 /* 12 */ "Walk",
428 /* 13 */ "Parser",
429 /* 14 */ "Operand",
430 /* 15 */ "Node"
431 };
432
433
434 char *
435 AcpiUtGetDescriptorName (
436 void *Object)
437 {
438
439 if (!Object)
440 {
441 return ("NULL OBJECT");
442 }
443
444 if (ACPI_GET_DESCRIPTOR_TYPE (Object) > ACPI_DESC_TYPE_MAX)
445 {
446 return ("Not a Descriptor");
447 }
448
449 return (ACPI_CAST_PTR (char,
450 AcpiGbl_DescTypeNames[ACPI_GET_DESCRIPTOR_TYPE (Object)]));
451
452 }
453
454
455 /*******************************************************************************
456 *
457 * FUNCTION: AcpiUtGetReferenceName
458 *
459 * PARAMETERS: Object - An ACPI reference object
460 *
461 * RETURN: Decoded name of the type of reference
462 *
463 * DESCRIPTION: Decode a reference object sub-type to a string.
464 *
465 ******************************************************************************/
466
467 /* Printable names of reference object sub-types */
468
469 static const char *AcpiGbl_RefClassNames[] =
470 {
471 /* 00 */ "Local",
472 /* 01 */ "Argument",
473 /* 02 */ "RefOf",
474 /* 03 */ "Index",
475 /* 04 */ "DdbHandle",
476 /* 05 */ "Named Object",
477 /* 06 */ "Debug"
478 };
479
480 const char *
481 AcpiUtGetReferenceName (
482 ACPI_OPERAND_OBJECT *Object)
483 {
484
485 if (!Object)
486 {
487 return ("NULL Object");
488 }
489
490 if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
491 {
492 return ("Not an Operand object");
493 }
494
495 if (Object->Common.Type != ACPI_TYPE_LOCAL_REFERENCE)
496 {
497 return ("Not a Reference object");
498 }
499
500 if (Object->Reference.Class > ACPI_REFCLASS_MAX)
501 {
502 return ("Unknown Reference class");
503 }
504
505 return (AcpiGbl_RefClassNames[Object->Reference.Class]);
506 }
507
508
509 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
510 /*
511 * Strings and procedures used for debug only
512 */
513
514 /*******************************************************************************
515 *
516 * FUNCTION: AcpiUtGetMutexName
517 *
518 * PARAMETERS: MutexId - The predefined ID for this mutex.
519 *
520 * RETURN: Decoded name of the internal mutex
521 *
522 * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
523 *
524 ******************************************************************************/
525
526 /* Names for internal mutex objects, used for debug output */
527
528 static char *AcpiGbl_MutexNames[ACPI_NUM_MUTEX] =
529 {
530 "ACPI_MTX_Interpreter",
531 "ACPI_MTX_Namespace",
532 "ACPI_MTX_Tables",
533 "ACPI_MTX_Events",
534 "ACPI_MTX_Caches",
535 "ACPI_MTX_Memory",
536 "ACPI_MTX_CommandComplete",
537 "ACPI_MTX_CommandReady"
538 };
539
540 char *
541 AcpiUtGetMutexName (
542 UINT32 MutexId)
543 {
544
545 if (MutexId > ACPI_MAX_MUTEX)
546 {
547 return ("Invalid Mutex ID");
548 }
549
550 return (AcpiGbl_MutexNames[MutexId]);
551 }
552
553
554 /*******************************************************************************
555 *
556 * FUNCTION: AcpiUtGetNotifyName
557 *
558 * PARAMETERS: NotifyValue - Value from the Notify() request
559 *
560 * RETURN: Decoded name for the notify value
561 *
562 * DESCRIPTION: Translate a Notify Value to a notify namestring.
563 *
564 ******************************************************************************/
565
566 /* Names for Notify() values, used for debug output */
567
568 static const char *AcpiGbl_NotifyValueNames[] =
569 {
570 "Bus Check",
571 "Device Check",
572 "Device Wake",
573 "Eject Request",
574 "Device Check Light",
575 "Frequency Mismatch",
576 "Bus Mode Mismatch",
577 "Power Fault",
578 "Capabilities Check",
579 "Device PLD Check",
580 "Reserved",
581 "System Locality Update"
582 };
583
584 const char *
585 AcpiUtGetNotifyName (
586 UINT32 NotifyValue)
587 {
588
589 if (NotifyValue <= ACPI_NOTIFY_MAX)
590 {
591 return (AcpiGbl_NotifyValueNames[NotifyValue]);
592 }
593 else if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)
594 {
595 return ("Reserved");
596 }
597 else /* Greater or equal to 0x80 */
598 {
599 return ("**Device Specific**");
600 }
601 }
602 #endif
603
604
605 /*******************************************************************************
606 *
607 * FUNCTION: AcpiUtValidObjectType
608 *
609 * PARAMETERS: Type - Object type to be validated
610 *
611 * RETURN: TRUE if valid object type, FALSE otherwise
612 *
613 * DESCRIPTION: Validate an object type
614 *
615 ******************************************************************************/
616
617 BOOLEAN
618 AcpiUtValidObjectType (
619 ACPI_OBJECT_TYPE Type)
620 {
621
622 if (Type > ACPI_TYPE_LOCAL_MAX)
623 {
624 /* Note: Assumes all TYPEs are contiguous (external/local) */
625
626 return (FALSE);
627 }
628
629 return (TRUE);
630 }