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