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