1/******************************************************************************
2 *
3 * Module Name: utdecode - Utility decoding routines (value-to-string)
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2015, 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
117char *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_CAST_PTR(char, 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
155char *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_CAST_PTR(char, 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 entry.
184 */
185static const char acpi_gbl_bad_type[] = "UNDEFINED";
186
187/* Printable names of the ACPI object types */
188
189static const char *acpi_gbl_ns_type_names[] = {
190	/* 00 */ "Untyped",
191	/* 01 */ "Integer",
192	/* 02 */ "String",
193	/* 03 */ "Buffer",
194	/* 04 */ "Package",
195	/* 05 */ "FieldUnit",
196	/* 06 */ "Device",
197	/* 07 */ "Event",
198	/* 08 */ "Method",
199	/* 09 */ "Mutex",
200	/* 10 */ "Region",
201	/* 11 */ "Power",
202	/* 12 */ "Processor",
203	/* 13 */ "Thermal",
204	/* 14 */ "BufferField",
205	/* 15 */ "DdbHandle",
206	/* 16 */ "DebugObject",
207	/* 17 */ "RegionField",
208	/* 18 */ "BankField",
209	/* 19 */ "IndexField",
210	/* 20 */ "Reference",
211	/* 21 */ "Alias",
212	/* 22 */ "MethodAlias",
213	/* 23 */ "Notify",
214	/* 24 */ "AddrHandler",
215	/* 25 */ "ResourceDesc",
216	/* 26 */ "ResourceFld",
217	/* 27 */ "Scope",
218	/* 28 */ "Extra",
219	/* 29 */ "Data",
220	/* 30 */ "Invalid"
221};
222
223char *acpi_ut_get_type_name(acpi_object_type type)
224{
225
226	if (type > ACPI_TYPE_INVALID) {
227		return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
228	}
229
230	return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
231}
232
233char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
234{
235	ACPI_FUNCTION_TRACE(ut_get_object_type_name);
236
237	if (!obj_desc) {
238		ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Null Object Descriptor\n"));
239		return_PTR("[NULL Object Descriptor]");
240	}
241
242	/* These descriptor types share a common area */
243
244	if ((ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_OPERAND) &&
245	    (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_NAMED)) {
246		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
247				  "Invalid object descriptor type: 0x%2.2X [%s] (%p)\n",
248				  ACPI_GET_DESCRIPTOR_TYPE(obj_desc),
249				  acpi_ut_get_descriptor_name(obj_desc),
250				  obj_desc));
251
252		return_PTR("Invalid object");
253	}
254
255	return_PTR(acpi_ut_get_type_name(obj_desc->common.type));
256}
257
258/*******************************************************************************
259 *
260 * FUNCTION:    acpi_ut_get_node_name
261 *
262 * PARAMETERS:  object               - A namespace node
263 *
264 * RETURN:      ASCII name of the node
265 *
266 * DESCRIPTION: Validate the node and return the node's ACPI name.
267 *
268 ******************************************************************************/
269
270char *acpi_ut_get_node_name(void *object)
271{
272	struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
273
274	/* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
275
276	if (!object) {
277		return ("NULL");
278	}
279
280	/* Check for Root node */
281
282	if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
283		return ("\"\\\" ");
284	}
285
286	/* Descriptor must be a namespace node */
287
288	if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
289		return ("####");
290	}
291
292	/*
293	 * Ensure name is valid. The name was validated/repaired when the node
294	 * was created, but make sure it has not been corrupted.
295	 */
296	acpi_ut_repair_name(node->name.ascii);
297
298	/* Return the name */
299
300	return (node->name.ascii);
301}
302
303/*******************************************************************************
304 *
305 * FUNCTION:    acpi_ut_get_descriptor_name
306 *
307 * PARAMETERS:  object               - An ACPI object
308 *
309 * RETURN:      Decoded name of the descriptor type
310 *
311 * DESCRIPTION: Validate object and return the descriptor type
312 *
313 ******************************************************************************/
314
315/* Printable names of object descriptor types */
316
317static const char *acpi_gbl_desc_type_names[] = {
318	/* 00 */ "Not a Descriptor",
319	/* 01 */ "Cached",
320	/* 02 */ "State-Generic",
321	/* 03 */ "State-Update",
322	/* 04 */ "State-Package",
323	/* 05 */ "State-Control",
324	/* 06 */ "State-RootParseScope",
325	/* 07 */ "State-ParseScope",
326	/* 08 */ "State-WalkScope",
327	/* 09 */ "State-Result",
328	/* 10 */ "State-Notify",
329	/* 11 */ "State-Thread",
330	/* 12 */ "Walk",
331	/* 13 */ "Parser",
332	/* 14 */ "Operand",
333	/* 15 */ "Node"
334};
335
336char *acpi_ut_get_descriptor_name(void *object)
337{
338
339	if (!object) {
340		return ("NULL OBJECT");
341	}
342
343	if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
344		return ("Not a Descriptor");
345	}
346
347	return (ACPI_CAST_PTR(char,
348			      acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
349						       (object)]));
350
351}
352
353/*******************************************************************************
354 *
355 * FUNCTION:    acpi_ut_get_reference_name
356 *
357 * PARAMETERS:  object               - An ACPI reference object
358 *
359 * RETURN:      Decoded name of the type of reference
360 *
361 * DESCRIPTION: Decode a reference object sub-type to a string.
362 *
363 ******************************************************************************/
364
365/* Printable names of reference object sub-types */
366
367static const char *acpi_gbl_ref_class_names[] = {
368	/* 00 */ "Local",
369	/* 01 */ "Argument",
370	/* 02 */ "RefOf",
371	/* 03 */ "Index",
372	/* 04 */ "DdbHandle",
373	/* 05 */ "Named Object",
374	/* 06 */ "Debug"
375};
376
377const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
378{
379
380	if (!object) {
381		return ("NULL Object");
382	}
383
384	if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
385		return ("Not an Operand object");
386	}
387
388	if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE) {
389		return ("Not a Reference object");
390	}
391
392	if (object->reference.class > ACPI_REFCLASS_MAX) {
393		return ("Unknown Reference class");
394	}
395
396	return (acpi_gbl_ref_class_names[object->reference.class]);
397}
398
399#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
400/*
401 * Strings and procedures used for debug only
402 */
403
404/*******************************************************************************
405 *
406 * FUNCTION:    acpi_ut_get_mutex_name
407 *
408 * PARAMETERS:  mutex_id        - The predefined ID for this mutex.
409 *
410 * RETURN:      Decoded name of the internal mutex
411 *
412 * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
413 *
414 ******************************************************************************/
415
416/* Names for internal mutex objects, used for debug output */
417
418static char *acpi_gbl_mutex_names[ACPI_NUM_MUTEX] = {
419	"ACPI_MTX_Interpreter",
420	"ACPI_MTX_Namespace",
421	"ACPI_MTX_Tables",
422	"ACPI_MTX_Events",
423	"ACPI_MTX_Caches",
424	"ACPI_MTX_Memory",
425};
426
427char *acpi_ut_get_mutex_name(u32 mutex_id)
428{
429
430	if (mutex_id > ACPI_MAX_MUTEX) {
431		return ("Invalid Mutex ID");
432	}
433
434	return (acpi_gbl_mutex_names[mutex_id]);
435}
436
437/*******************************************************************************
438 *
439 * FUNCTION:    acpi_ut_get_notify_name
440 *
441 * PARAMETERS:  notify_value    - Value from the Notify() request
442 *
443 * RETURN:      Decoded name for the notify value
444 *
445 * DESCRIPTION: Translate a Notify Value to a notify namestring.
446 *
447 ******************************************************************************/
448
449/* Names for Notify() values, used for debug output */
450
451static const char *acpi_gbl_generic_notify[ACPI_NOTIFY_MAX + 1] = {
452	/* 00 */ "Bus Check",
453	/* 01 */ "Device Check",
454	/* 02 */ "Device Wake",
455	/* 03 */ "Eject Request",
456	/* 04 */ "Device Check Light",
457	/* 05 */ "Frequency Mismatch",
458	/* 06 */ "Bus Mode Mismatch",
459	/* 07 */ "Power Fault",
460	/* 08 */ "Capabilities Check",
461	/* 09 */ "Device PLD Check",
462	/* 0A */ "Reserved",
463	/* 0B */ "System Locality Update",
464	/* 0C */ "Shutdown Request",
465	/* 0D */ "System Resource Affinity Update"
466};
467
468static const char *acpi_gbl_device_notify[4] = {
469	/* 80 */ "Status Change",
470	/* 81 */ "Information Change",
471	/* 82 */ "Device-Specific Change",
472	/* 83 */ "Device-Specific Change"
473};
474
475static const char *acpi_gbl_processor_notify[4] = {
476	/* 80 */ "Performance Capability Change",
477	/* 81 */ "C-State Change",
478	/* 82 */ "Throttling Capability Change",
479	/* 83 */ "Device-Specific Change"
480};
481
482static const char *acpi_gbl_thermal_notify[4] = {
483	/* 80 */ "Thermal Status Change",
484	/* 81 */ "Thermal Trip Point Change",
485	/* 82 */ "Thermal Device List Change",
486	/* 83 */ "Thermal Relationship Change"
487};
488
489const char *acpi_ut_get_notify_name(u32 notify_value, acpi_object_type type)
490{
491
492	/* 00 - 0D are common to all object types */
493
494	if (notify_value <= ACPI_NOTIFY_MAX) {
495		return (acpi_gbl_generic_notify[notify_value]);
496	}
497
498	/* 0D - 7F are reserved */
499
500	if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
501		return ("Reserved");
502	}
503
504	/* 80 - 83 are per-object-type */
505
506	if (notify_value <= 0x83) {
507		switch (type) {
508		case ACPI_TYPE_ANY:
509		case ACPI_TYPE_DEVICE:
510			return (acpi_gbl_device_notify[notify_value - 0x80]);
511
512		case ACPI_TYPE_PROCESSOR:
513			return (acpi_gbl_processor_notify[notify_value - 0x80]);
514
515		case ACPI_TYPE_THERMAL:
516			return (acpi_gbl_thermal_notify[notify_value - 0x80]);
517
518		default:
519			return ("Target object type does not support notifies");
520		}
521	}
522
523	/* 84 - BF are device-specific */
524
525	if (notify_value <= ACPI_MAX_DEVICE_SPECIFIC_NOTIFY) {
526		return ("Device-Specific");
527	}
528
529	/* C0 and above are hardware-specific */
530
531	return ("Hardware-Specific");
532}
533#endif
534
535/*******************************************************************************
536 *
537 * FUNCTION:    acpi_ut_valid_object_type
538 *
539 * PARAMETERS:  type            - Object type to be validated
540 *
541 * RETURN:      TRUE if valid object type, FALSE otherwise
542 *
543 * DESCRIPTION: Validate an object type
544 *
545 ******************************************************************************/
546
547u8 acpi_ut_valid_object_type(acpi_object_type type)
548{
549
550	if (type > ACPI_TYPE_LOCAL_MAX) {
551
552		/* Note: Assumes all TYPEs are contiguous (external/local) */
553
554		return (FALSE);
555	}
556
557	return (TRUE);
558}
559