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