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