aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorBob Moore <robert.moore@intel.com>2011-02-14 03:00:21 -0500
committerLen Brown <len.brown@intel.com>2011-03-02 19:38:04 -0500
commita257e07527890a7f95982b9c330efd8d2de3707a (patch)
tree11c6cbdd9f2e8cbf7c9e4ca3fd8f613f26cd7332
parent1b74dfb2f735454031584dc8162f8f27aa5265bf (diff)
ACPICA: Split large utglobal into utdecode.c.
utglobal.c contained a lot of code not related to global variables. These utility decode functions are moved to utdecode.c Signed-off-by: Bob Moore <robert.moore@intel.com> Signed-off-by: Lin Ming <ming.m.lin@intel.com> Signed-off-by: Len Brown <len.brown@intel.com>
Diffstat
-rw-r--r--drivers/acpi/acpica/Makefile2
-rw-r--r--drivers/acpi/acpica/aclocal.h19
-rw-r--r--drivers/acpi/acpica/utdecode.c546
-rw-r--r--drivers/acpi/acpica/utglobal.c483
4 files changed, 547 insertions, 503 deletions
diff --git a/drivers/acpi/acpica/Makefile b/drivers/acpi/acpica/Makefile
index eec2eadd2431..b1706aacbe98 100644
--- a/drivers/acpi/acpica/Makefile
+++ b/drivers/acpi/acpica/Makefile
@@ -45,4 +45,4 @@ acpi-y += tbxface.o tbinstal.o tbutils.o tbfind.o tbfadt.o tbxfroot.o
45acpi-y += utalloc.o utdebug.o uteval.o utinit.o utmisc.o utxface.o \ 45acpi-y += utalloc.o utdebug.o uteval.o utinit.o utmisc.o utxface.o \
46 utcopy.o utdelete.o utglobal.o utmath.o utobject.o \ 46 utcopy.o utdelete.o utglobal.o utmath.o utobject.o \
47 utstate.o utmutex.o utobject.o utresrc.o utlock.o utids.o \ 47 utstate.o utmutex.o utobject.o utresrc.o utlock.o utids.o \
48 utosi.o utxferror.o 48 utosi.o utxferror.o utdecode.o
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index 54784bb42cec..01bcab1c5cc4 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -89,25 +89,6 @@ union acpi_parse_object;
89#define ACPI_MAX_MUTEX 7 89#define ACPI_MAX_MUTEX 7
90#define ACPI_NUM_MUTEX ACPI_MAX_MUTEX+1 90#define ACPI_NUM_MUTEX ACPI_MAX_MUTEX+1
91 91
92#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
93#ifdef DEFINE_ACPI_GLOBALS
94
95/* Debug names for the mutexes above */
96
97static char *acpi_gbl_mutex_names[ACPI_NUM_MUTEX] = {
98 "ACPI_MTX_Interpreter",
99 "ACPI_MTX_Namespace",
100 "ACPI_MTX_Tables",
101 "ACPI_MTX_Events",
102 "ACPI_MTX_Caches",
103 "ACPI_MTX_Memory",
104 "ACPI_MTX_CommandComplete",
105 "ACPI_MTX_CommandReady"
106};
107
108#endif
109#endif
110
111/* Lock structure for reader/writer interfaces */ 92/* Lock structure for reader/writer interfaces */
112 93
113struct acpi_rw_lock { 94struct acpi_rw_lock {
diff --git a/drivers/acpi/acpica/utdecode.c b/drivers/acpi/acpica/utdecode.c
new file mode 100644
index 000000000000..ce91e59c449f
--- /dev/null
+++ b/drivers/acpi/acpica/utdecode.c
@@ -0,0 +1,546 @@
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 "DataTable"
175};
176
177char *acpi_ut_get_region_name(u8 space_id)
178{
179
180 if (space_id >= ACPI_USER_REGION_BEGIN) {
181 return ("UserDefinedRegion");
182 } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
183 return ("InvalidSpaceId");
184 }
185
186 return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id]));
187}
188
189/*******************************************************************************
190 *
191 * FUNCTION: acpi_ut_get_event_name
192 *
193 * PARAMETERS: event_id - Fixed event ID
194 *
195 * RETURN: Decoded event ID name
196 *
197 * DESCRIPTION: Translate a Event ID into a name string (Debug only)
198 *
199 ******************************************************************************/
200
201/* Event type decoding */
202
203static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
204 "PM_Timer",
205 "GlobalLock",
206 "PowerButton",
207 "SleepButton",
208 "RealTimeClock",
209};
210
211char *acpi_ut_get_event_name(u32 event_id)
212{
213
214 if (event_id > ACPI_EVENT_MAX) {
215 return ("InvalidEventID");
216 }
217
218 return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id]));
219}
220
221/*******************************************************************************
222 *
223 * FUNCTION: acpi_ut_get_type_name
224 *
225 * PARAMETERS: Type - An ACPI object type
226 *
227 * RETURN: Decoded ACPI object type name
228 *
229 * DESCRIPTION: Translate a Type ID into a name string (Debug only)
230 *
231 ******************************************************************************/
232
233/*
234 * Elements of acpi_gbl_ns_type_names below must match
235 * one-to-one with values of acpi_object_type
236 *
237 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
238 * when stored in a table it really means that we have thus far seen no
239 * evidence to indicate what type is actually going to be stored for this entry.
240 */
241static const char acpi_gbl_bad_type[] = "UNDEFINED";
242
243/* Printable names of the ACPI object types */
244
245static const char *acpi_gbl_ns_type_names[] = {
246 /* 00 */ "Untyped",
247 /* 01 */ "Integer",
248 /* 02 */ "String",
249 /* 03 */ "Buffer",
250 /* 04 */ "Package",
251 /* 05 */ "FieldUnit",
252 /* 06 */ "Device",
253 /* 07 */ "Event",
254 /* 08 */ "Method",
255 /* 09 */ "Mutex",
256 /* 10 */ "Region",
257 /* 11 */ "Power",
258 /* 12 */ "Processor",
259 /* 13 */ "Thermal",
260 /* 14 */ "BufferField",
261 /* 15 */ "DdbHandle",
262 /* 16 */ "DebugObject",
263 /* 17 */ "RegionField",
264 /* 18 */ "BankField",
265 /* 19 */ "IndexField",
266 /* 20 */ "Reference",
267 /* 21 */ "Alias",
268 /* 22 */ "MethodAlias",
269 /* 23 */ "Notify",
270 /* 24 */ "AddrHandler",
271 /* 25 */ "ResourceDesc",
272 /* 26 */ "ResourceFld",
273 /* 27 */ "Scope",
274 /* 28 */ "Extra",
275 /* 29 */ "Data",
276 /* 30 */ "Invalid"
277};
278
279char *acpi_ut_get_type_name(acpi_object_type type)
280{
281
282 if (type > ACPI_TYPE_INVALID) {
283 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
284 }
285
286 return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
287}
288
289char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
290{
291
292 if (!obj_desc) {
293 return ("[NULL Object Descriptor]");
294 }
295
296 return (acpi_ut_get_type_name(obj_desc->common.type));
297}
298
299/*******************************************************************************
300 *
301 * FUNCTION: acpi_ut_get_node_name
302 *
303 * PARAMETERS: Object - A namespace node
304 *
305 * RETURN: ASCII name of the node
306 *
307 * DESCRIPTION: Validate the node and return the node's ACPI name.
308 *
309 ******************************************************************************/
310
311char *acpi_ut_get_node_name(void *object)
312{
313 struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
314
315 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
316
317 if (!object) {
318 return ("NULL");
319 }
320
321 /* Check for Root node */
322
323 if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
324 return ("\"\\\" ");
325 }
326
327 /* Descriptor must be a namespace node */
328
329 if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
330 return ("####");
331 }
332
333 /*
334 * Ensure name is valid. The name was validated/repaired when the node
335 * was created, but make sure it has not been corrupted.
336 */
337 acpi_ut_repair_name(node->name.ascii);
338
339 /* Return the name */
340
341 return (node->name.ascii);
342}
343
344/*******************************************************************************
345 *
346 * FUNCTION: acpi_ut_get_descriptor_name
347 *
348 * PARAMETERS: Object - An ACPI object
349 *
350 * RETURN: Decoded name of the descriptor type
351 *
352 * DESCRIPTION: Validate object and return the descriptor type
353 *
354 ******************************************************************************/
355
356/* Printable names of object descriptor types */
357
358static const char *acpi_gbl_desc_type_names[] = {
359 /* 00 */ "Not a Descriptor",
360 /* 01 */ "Cached",
361 /* 02 */ "State-Generic",
362 /* 03 */ "State-Update",
363 /* 04 */ "State-Package",
364 /* 05 */ "State-Control",
365 /* 06 */ "State-RootParseScope",
366 /* 07 */ "State-ParseScope",
367 /* 08 */ "State-WalkScope",
368 /* 09 */ "State-Result",
369 /* 10 */ "State-Notify",
370 /* 11 */ "State-Thread",
371 /* 12 */ "Walk",
372 /* 13 */ "Parser",
373 /* 14 */ "Operand",
374 /* 15 */ "Node"
375};
376
377char *acpi_ut_get_descriptor_name(void *object)
378{
379
380 if (!object) {
381 return ("NULL OBJECT");
382 }
383
384 if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
385 return ("Not a Descriptor");
386 }
387
388 return (ACPI_CAST_PTR(char,
389 acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
390 (object)]));
391
392}
393
394/*******************************************************************************
395 *
396 * FUNCTION: acpi_ut_get_reference_name
397 *
398 * PARAMETERS: Object - An ACPI reference object
399 *
400 * RETURN: Decoded name of the type of reference
401 *
402 * DESCRIPTION: Decode a reference object sub-type to a string.
403 *
404 ******************************************************************************/
405
406/* Printable names of reference object sub-types */
407
408static const char *acpi_gbl_ref_class_names[] = {
409 /* 00 */ "Local",
410 /* 01 */ "Argument",
411 /* 02 */ "RefOf",
412 /* 03 */ "Index",
413 /* 04 */ "DdbHandle",
414 /* 05 */ "Named Object",
415 /* 06 */ "Debug"
416};
417
418const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
419{
420
421 if (!object) {
422 return ("NULL Object");
423 }
424
425 if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
426 return ("Not an Operand object");
427 }
428
429 if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE) {
430 return ("Not a Reference object");
431 }
432
433 if (object->reference.class > ACPI_REFCLASS_MAX) {
434 return ("Unknown Reference class");
435 }
436
437 return (acpi_gbl_ref_class_names[object->reference.class]);
438}
439
440#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
441/*
442 * Strings and procedures used for debug only
443 */
444
445/*******************************************************************************
446 *
447 * FUNCTION: acpi_ut_get_mutex_name
448 *
449 * PARAMETERS: mutex_id - The predefined ID for this mutex.
450 *
451 * RETURN: Decoded name of the internal mutex
452 *
453 * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
454 *
455 ******************************************************************************/
456
457/* Names for internal mutex objects, used for debug output */
458
459static char *acpi_gbl_mutex_names[ACPI_NUM_MUTEX] = {
460 "ACPI_MTX_Interpreter",
461 "ACPI_MTX_Namespace",
462 "ACPI_MTX_Tables",
463 "ACPI_MTX_Events",
464 "ACPI_MTX_Caches",
465 "ACPI_MTX_Memory",
466 "ACPI_MTX_CommandComplete",
467 "ACPI_MTX_CommandReady"
468};
469
470char *acpi_ut_get_mutex_name(u32 mutex_id)
471{
472
473 if (mutex_id > ACPI_MAX_MUTEX) {
474 return ("Invalid Mutex ID");
475 }
476
477 return (acpi_gbl_mutex_names[mutex_id]);
478}
479
480/*******************************************************************************
481 *
482 * FUNCTION: acpi_ut_get_notify_name
483 *
484 * PARAMETERS: notify_value - Value from the Notify() request
485 *
486 * RETURN: Decoded name for the notify value
487 *
488 * DESCRIPTION: Translate a Notify Value to a notify namestring.
489 *
490 ******************************************************************************/
491
492/* Names for Notify() values, used for debug output */
493
494static const char *acpi_gbl_notify_value_names[] = {
495 "Bus Check",
496 "Device Check",
497 "Device Wake",
498 "Eject Request",
499 "Device Check Light",
500 "Frequency Mismatch",
501 "Bus Mode Mismatch",
502 "Power Fault",
503 "Capabilities Check",
504 "Device PLD Check",
505 "Reserved",
506 "System Locality Update"
507};
508
509const char *acpi_ut_get_notify_name(u32 notify_value)
510{
511
512 if (notify_value <= ACPI_NOTIFY_MAX) {
513 return (acpi_gbl_notify_value_names[notify_value]);
514 } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
515 return ("Reserved");
516 } else { /* Greater or equal to 0x80 */
517
518 return ("**Device Specific**");
519 }
520}
521#endif
522
523/*******************************************************************************
524 *
525 * FUNCTION: acpi_ut_valid_object_type
526 *
527 * PARAMETERS: Type - Object type to be validated
528 *
529 * RETURN: TRUE if valid object type, FALSE otherwise
530 *
531 * DESCRIPTION: Validate an object type
532 *
533 ******************************************************************************/
534
535u8 acpi_ut_valid_object_type(acpi_object_type type)
536{
537
538 if (type > ACPI_TYPE_LOCAL_MAX) {
539
540 /* Note: Assumes all TYPEs are contiguous (external/local) */
541
542 return (FALSE);
543 }
544
545 return (TRUE);
546}
diff --git a/drivers/acpi/acpica/utglobal.c b/drivers/acpi/acpica/utglobal.c
index 97dd9bbf055a..fc9097821516 100644
--- a/drivers/acpi/acpica/utglobal.c
+++ b/drivers/acpi/acpica/utglobal.c
@@ -45,7 +45,6 @@
45 45
46#include <acpi/acpi.h> 46#include <acpi/acpi.h>
47#include "accommon.h" 47#include "accommon.h"
48#include "acnamesp.h"
49 48
50#define _COMPONENT ACPI_UTILITIES 49#define _COMPONENT ACPI_UTILITIES
51ACPI_MODULE_NAME("utglobal") 50ACPI_MODULE_NAME("utglobal")
@@ -107,43 +106,6 @@ const char *acpi_gbl_highest_dstate_names[ACPI_NUM_sx_d_METHODS] = {
107 106
108/******************************************************************************* 107/*******************************************************************************
109 * 108 *
110 * FUNCTION: acpi_format_exception
111 *
112 * PARAMETERS: Status - The acpi_status code to be formatted
113 *
114 * RETURN: A string containing the exception text. A valid pointer is
115 * always returned.
116 *
117 * DESCRIPTION: This function translates an ACPI exception into an ASCII string
118 * It is here instead of utxface.c so it is always present.
119 *
120 ******************************************************************************/
121
122const char *acpi_format_exception(acpi_status status)
123{
124 const char *exception = NULL;
125
126 ACPI_FUNCTION_ENTRY();
127
128 exception = acpi_ut_validate_exception(status);
129 if (!exception) {
130
131 /* Exception code was not recognized */
132
133 ACPI_ERROR((AE_INFO,
134 "Unknown exception code: 0x%8.8X", status));
135
136 exception = "UNKNOWN_STATUS_CODE";
137 dump_stack();
138 }
139
140 return (ACPI_CAST_PTR(const char, exception));
141}
142
143ACPI_EXPORT_SYMBOL(acpi_format_exception)
144
145/*******************************************************************************
146 *
147 * Namespace globals 109 * Namespace globals
148 * 110 *
149 ******************************************************************************/ 111 ******************************************************************************/
@@ -177,71 +139,6 @@ const struct acpi_predefined_names acpi_gbl_pre_defined_names[] = {
177 {NULL, ACPI_TYPE_ANY, NULL} 139 {NULL, ACPI_TYPE_ANY, NULL}
178}; 140};
179 141
180/*
181 * Properties of the ACPI Object Types, both internal and external.
182 * The table is indexed by values of acpi_object_type
183 */
184const u8 acpi_gbl_ns_properties[] = {
185 ACPI_NS_NORMAL, /* 00 Any */
186 ACPI_NS_NORMAL, /* 01 Number */
187 ACPI_NS_NORMAL, /* 02 String */
188 ACPI_NS_NORMAL, /* 03 Buffer */
189 ACPI_NS_NORMAL, /* 04 Package */
190 ACPI_NS_NORMAL, /* 05 field_unit */
191 ACPI_NS_NEWSCOPE, /* 06 Device */
192 ACPI_NS_NORMAL, /* 07 Event */
193 ACPI_NS_NEWSCOPE, /* 08 Method */
194 ACPI_NS_NORMAL, /* 09 Mutex */
195 ACPI_NS_NORMAL, /* 10 Region */
196 ACPI_NS_NEWSCOPE, /* 11 Power */
197 ACPI_NS_NEWSCOPE, /* 12 Processor */
198 ACPI_NS_NEWSCOPE, /* 13 Thermal */
199 ACPI_NS_NORMAL, /* 14 buffer_field */
200 ACPI_NS_NORMAL, /* 15 ddb_handle */
201 ACPI_NS_NORMAL, /* 16 Debug Object */
202 ACPI_NS_NORMAL, /* 17 def_field */
203 ACPI_NS_NORMAL, /* 18 bank_field */
204 ACPI_NS_NORMAL, /* 19 index_field */
205 ACPI_NS_NORMAL, /* 20 Reference */
206 ACPI_NS_NORMAL, /* 21 Alias */
207 ACPI_NS_NORMAL, /* 22 method_alias */
208 ACPI_NS_NORMAL, /* 23 Notify */
209 ACPI_NS_NORMAL, /* 24 Address Handler */
210 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 25 Resource Desc */
211 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 26 Resource Field */
212 ACPI_NS_NEWSCOPE, /* 27 Scope */
213 ACPI_NS_NORMAL, /* 28 Extra */
214 ACPI_NS_NORMAL, /* 29 Data */
215 ACPI_NS_NORMAL /* 30 Invalid */
216};
217
218/* Hex to ASCII conversion table */
219
220static const char acpi_gbl_hex_to_ascii[] = {
221 '0', '1', '2', '3', '4', '5', '6', '7',
222 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
223};
224
225/*******************************************************************************
226 *
227 * FUNCTION: acpi_ut_hex_to_ascii_char
228 *
229 * PARAMETERS: Integer - Contains the hex digit
230 * Position - bit position of the digit within the
231 * integer (multiple of 4)
232 *
233 * RETURN: The converted Ascii character
234 *
235 * DESCRIPTION: Convert a hex digit to an Ascii character
236 *
237 ******************************************************************************/
238
239char acpi_ut_hex_to_ascii_char(u64 integer, u32 position)
240{
241
242 return (acpi_gbl_hex_to_ascii[(integer >> position) & 0xF]);
243}
244
245/****************************************************************************** 142/******************************************************************************
246 * 143 *
247 * Event and Hardware globals 144 * Event and Hardware globals
@@ -341,386 +238,6 @@ struct acpi_fixed_event_info acpi_gbl_fixed_event_info[ACPI_NUM_FIXED_EVENTS] =
341 238
342/******************************************************************************* 239/*******************************************************************************
343 * 240 *
344 * FUNCTION: acpi_ut_get_region_name
345 *
346 * PARAMETERS: None.
347 *
348 * RETURN: Status
349 *
350 * DESCRIPTION: Translate a Space ID into a name string (Debug only)
351 *
352 ******************************************************************************/
353
354/* Region type decoding */
355
356const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] = {
357 "SystemMemory",
358 "SystemIO",
359 "PCI_Config",
360 "EmbeddedControl",
361 "SMBus",
362 "SystemCMOS",
363 "PCIBARTarget",
364 "IPMI",
365 "DataTable"
366};
367
368char *acpi_ut_get_region_name(u8 space_id)
369{
370
371 if (space_id >= ACPI_USER_REGION_BEGIN) {
372 return ("UserDefinedRegion");
373 } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
374 return ("InvalidSpaceId");
375 }
376
377 return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id]));
378}
379
380/*******************************************************************************
381 *
382 * FUNCTION: acpi_ut_get_event_name
383 *
384 * PARAMETERS: None.
385 *
386 * RETURN: Status
387 *
388 * DESCRIPTION: Translate a Event ID into a name string (Debug only)
389 *
390 ******************************************************************************/
391
392/* Event type decoding */
393
394static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
395 "PM_Timer",
396 "GlobalLock",
397 "PowerButton",
398 "SleepButton",
399 "RealTimeClock",
400};
401
402char *acpi_ut_get_event_name(u32 event_id)
403{
404
405 if (event_id > ACPI_EVENT_MAX) {
406 return ("InvalidEventID");
407 }
408
409 return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id]));
410}
411
412/*******************************************************************************
413 *
414 * FUNCTION: acpi_ut_get_type_name
415 *
416 * PARAMETERS: None.
417 *
418 * RETURN: Status
419 *
420 * DESCRIPTION: Translate a Type ID into a name string (Debug only)
421 *
422 ******************************************************************************/
423
424/*
425 * Elements of acpi_gbl_ns_type_names below must match
426 * one-to-one with values of acpi_object_type
427 *
428 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
429 * when stored in a table it really means that we have thus far seen no
430 * evidence to indicate what type is actually going to be stored for this entry.
431 */
432static const char acpi_gbl_bad_type[] = "UNDEFINED";
433
434/* Printable names of the ACPI object types */
435
436static const char *acpi_gbl_ns_type_names[] = {
437 /* 00 */ "Untyped",
438 /* 01 */ "Integer",
439 /* 02 */ "String",
440 /* 03 */ "Buffer",
441 /* 04 */ "Package",
442 /* 05 */ "FieldUnit",
443 /* 06 */ "Device",
444 /* 07 */ "Event",
445 /* 08 */ "Method",
446 /* 09 */ "Mutex",
447 /* 10 */ "Region",
448 /* 11 */ "Power",
449 /* 12 */ "Processor",
450 /* 13 */ "Thermal",
451 /* 14 */ "BufferField",
452 /* 15 */ "DdbHandle",
453 /* 16 */ "DebugObject",
454 /* 17 */ "RegionField",
455 /* 18 */ "BankField",
456 /* 19 */ "IndexField",
457 /* 20 */ "Reference",
458 /* 21 */ "Alias",
459 /* 22 */ "MethodAlias",
460 /* 23 */ "Notify",
461 /* 24 */ "AddrHandler",
462 /* 25 */ "ResourceDesc",
463 /* 26 */ "ResourceFld",
464 /* 27 */ "Scope",
465 /* 28 */ "Extra",
466 /* 29 */ "Data",
467 /* 30 */ "Invalid"
468};
469
470char *acpi_ut_get_type_name(acpi_object_type type)
471{
472
473 if (type > ACPI_TYPE_INVALID) {
474 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
475 }
476
477 return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
478}
479
480char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
481{
482
483 if (!obj_desc) {
484 return ("[NULL Object Descriptor]");
485 }
486
487 return (acpi_ut_get_type_name(obj_desc->common.type));
488}
489
490/*******************************************************************************
491 *
492 * FUNCTION: acpi_ut_get_node_name
493 *
494 * PARAMETERS: Object - A namespace node
495 *
496 * RETURN: Pointer to a string
497 *
498 * DESCRIPTION: Validate the node and return the node's ACPI name.
499 *
500 ******************************************************************************/
501
502char *acpi_ut_get_node_name(void *object)
503{
504 struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
505
506 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
507
508 if (!object) {
509 return ("NULL");
510 }
511
512 /* Check for Root node */
513
514 if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
515 return ("\"\\\" ");
516 }
517
518 /* Descriptor must be a namespace node */
519
520 if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
521 return ("####");
522 }
523
524 /* Name must be a valid ACPI name */
525
526 if (!acpi_ut_valid_acpi_name(node->name.integer)) {
527 node->name.integer = acpi_ut_repair_name(node->name.ascii);
528 }
529
530 /* Return the name */
531
532 return (node->name.ascii);
533}
534
535/*******************************************************************************
536 *
537 * FUNCTION: acpi_ut_get_descriptor_name
538 *
539 * PARAMETERS: Object - An ACPI object
540 *
541 * RETURN: Pointer to a string
542 *
543 * DESCRIPTION: Validate object and return the descriptor type
544 *
545 ******************************************************************************/
546
547/* Printable names of object descriptor types */
548
549static const char *acpi_gbl_desc_type_names[] = {
550 /* 00 */ "Invalid",
551 /* 01 */ "Cached",
552 /* 02 */ "State-Generic",
553 /* 03 */ "State-Update",
554 /* 04 */ "State-Package",
555 /* 05 */ "State-Control",
556 /* 06 */ "State-RootParseScope",
557 /* 07 */ "State-ParseScope",
558 /* 08 */ "State-WalkScope",
559 /* 09 */ "State-Result",
560 /* 10 */ "State-Notify",
561 /* 11 */ "State-Thread",
562 /* 12 */ "Walk",
563 /* 13 */ "Parser",
564 /* 14 */ "Operand",
565 /* 15 */ "Node"
566};
567
568char *acpi_ut_get_descriptor_name(void *object)
569{
570
571 if (!object) {
572 return ("NULL OBJECT");
573 }
574
575 if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
576 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
577 }
578
579 return (ACPI_CAST_PTR(char,
580 acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
581 (object)]));
582
583}
584
585/*******************************************************************************
586 *
587 * FUNCTION: acpi_ut_get_reference_name
588 *
589 * PARAMETERS: Object - An ACPI reference object
590 *
591 * RETURN: Pointer to a string
592 *
593 * DESCRIPTION: Decode a reference object sub-type to a string.
594 *
595 ******************************************************************************/
596
597/* Printable names of reference object sub-types */
598
599static const char *acpi_gbl_ref_class_names[] = {
600 /* 00 */ "Local",
601 /* 01 */ "Argument",
602 /* 02 */ "RefOf",
603 /* 03 */ "Index",
604 /* 04 */ "DdbHandle",
605 /* 05 */ "Named Object",
606 /* 06 */ "Debug"
607};
608
609const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
610{
611 if (!object)
612 return "NULL Object";
613
614 if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND)
615 return "Not an Operand object";
616
617 if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE)
618 return "Not a Reference object";
619
620 if (object->reference.class > ACPI_REFCLASS_MAX)
621 return "Unknown Reference class";
622
623 return acpi_gbl_ref_class_names[object->reference.class];
624}
625
626#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
627/*
628 * Strings and procedures used for debug only
629 */
630
631/*******************************************************************************
632 *
633 * FUNCTION: acpi_ut_get_mutex_name
634 *
635 * PARAMETERS: mutex_id - The predefined ID for this mutex.
636 *
637 * RETURN: String containing the name of the mutex. Always returns a valid
638 * pointer.
639 *
640 * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
641 *
642 ******************************************************************************/
643
644char *acpi_ut_get_mutex_name(u32 mutex_id)
645{
646
647 if (mutex_id > ACPI_MAX_MUTEX) {
648 return ("Invalid Mutex ID");
649 }
650
651 return (acpi_gbl_mutex_names[mutex_id]);
652}
653
654/*******************************************************************************
655 *
656 * FUNCTION: acpi_ut_get_notify_name
657 *
658 * PARAMETERS: notify_value - Value from the Notify() request
659 *
660 * RETURN: String corresponding to the Notify Value.
661 *
662 * DESCRIPTION: Translate a Notify Value to a notify namestring.
663 *
664 ******************************************************************************/
665
666/* Names for Notify() values, used for debug output */
667
668static const char *acpi_gbl_notify_value_names[] = {
669 "Bus Check",
670 "Device Check",
671 "Device Wake",
672 "Eject Request",
673 "Device Check Light",
674 "Frequency Mismatch",
675 "Bus Mode Mismatch",
676 "Power Fault",
677 "Capabilities Check",
678 "Device PLD Check",
679 "Reserved",
680 "System Locality Update"
681};
682
683const char *acpi_ut_get_notify_name(u32 notify_value)
684{
685
686 if (notify_value <= ACPI_NOTIFY_MAX) {
687 return (acpi_gbl_notify_value_names[notify_value]);
688 } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
689 return ("Reserved");
690 } else { /* Greater or equal to 0x80 */
691
692 return ("**Device Specific**");
693 }
694}
695#endif
696
697/*******************************************************************************
698 *
699 * FUNCTION: acpi_ut_valid_object_type
700 *
701 * PARAMETERS: Type - Object type to be validated
702 *
703 * RETURN: TRUE if valid object type, FALSE otherwise
704 *
705 * DESCRIPTION: Validate an object type
706 *
707 ******************************************************************************/
708
709u8 acpi_ut_valid_object_type(acpi_object_type type)
710{
711
712 if (type > ACPI_TYPE_LOCAL_MAX) {
713
714 /* Note: Assumes all TYPEs are contiguous (external/local) */
715
716 return (FALSE);
717 }
718
719 return (TRUE);
720}
721
722/*******************************************************************************
723 *
724 * FUNCTION: acpi_ut_init_globals 241 * FUNCTION: acpi_ut_init_globals
725 * 242 *
726 * PARAMETERS: None 243 * PARAMETERS: None
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-16 14:03:48 -0500