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