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