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