Print this page
acpica-unix2-20130823
PANKOVs restructure
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/intel/io/acpica/utilities/utdecode.c
+++ new/usr/src/common/acpica/components/utilities/utdecode.c
1 1 /******************************************************************************
2 2 *
3 3 * Module Name: utdecode - Utility decoding routines (value-to-string)
4 4 *
5 5 *****************************************************************************/
6 6
7 7 /*
8 - * Copyright (C) 2000 - 2011, Intel Corp.
8 + * Copyright (C) 2000 - 2013, Intel Corp.
9 9 * All rights reserved.
10 10 *
11 11 * Redistribution and use in source and binary forms, with or without
12 12 * modification, are permitted provided that the following conditions
13 13 * are met:
14 14 * 1. Redistributions of source code must retain the above copyright
15 15 * notice, this list of conditions, and the following disclaimer,
16 16 * without modification.
17 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 18 * substantially similar to the "NO WARRANTY" disclaimer below
19 19 * ("Disclaimer") and any redistribution must be conditioned upon
20 20 * including a substantially similar Disclaimer requirement for further
21 21 * binary redistribution.
22 22 * 3. Neither the names of the above-listed copyright holders nor the names
23 23 * of any contributors may be used to endorse or promote products derived
24 24 * from this software without specific prior written permission.
25 25 *
26 26 * Alternatively, this software may be distributed under the terms of the
27 27 * GNU General Public License ("GPL") version 2 as published by the Free
28 28 * Software Foundation.
29 29 *
30 30 * NO WARRANTY
31 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 41 * POSSIBILITY OF SUCH DAMAGES.
42 42 */
43 43
|
↓ open down ↓ |
25 lines elided |
↑ open up ↑ |
44 44 #define __UTDECODE_C__
45 45
46 46 #include "acpi.h"
47 47 #include "accommon.h"
48 48 #include "acnamesp.h"
49 49
50 50 #define _COMPONENT ACPI_UTILITIES
51 51 ACPI_MODULE_NAME ("utdecode")
52 52
53 53
54 -/*******************************************************************************
55 - *
56 - * FUNCTION: AcpiFormatException
57 - *
58 - * PARAMETERS: Status - The ACPI_STATUS code to be formatted
59 - *
60 - * RETURN: A string containing the exception text. A valid pointer is
61 - * always returned.
62 - *
63 - * DESCRIPTION: This function translates an ACPI exception into an ASCII string
64 - * It is here instead of utxface.c so it is always present.
65 - *
66 - ******************************************************************************/
67 -
68 -const char *
69 -AcpiFormatException (
70 - ACPI_STATUS Status)
71 -{
72 - const char *Exception = NULL;
73 -
74 -
75 - ACPI_FUNCTION_ENTRY ();
76 -
77 -
78 - Exception = AcpiUtValidateException (Status);
79 - if (!Exception)
80 - {
81 - /* Exception code was not recognized */
82 -
83 - ACPI_ERROR ((AE_INFO,
84 - "Unknown exception code: 0x%8.8X", Status));
85 -
86 - Exception = "UNKNOWN_STATUS_CODE";
87 - }
88 -
89 - return (ACPI_CAST_PTR (const char, Exception));
90 -}
91 -
92 -ACPI_EXPORT_SYMBOL (AcpiFormatException)
93 -
94 -
95 54 /*
96 55 * Properties of the ACPI Object Types, both internal and external.
97 56 * The table is indexed by values of ACPI_OBJECT_TYPE
98 57 */
99 58 const UINT8 AcpiGbl_NsProperties[ACPI_NUM_NS_TYPES] =
100 59 {
101 60 ACPI_NS_NORMAL, /* 00 Any */
102 61 ACPI_NS_NORMAL, /* 01 Number */
103 62 ACPI_NS_NORMAL, /* 02 String */
104 63 ACPI_NS_NORMAL, /* 03 Buffer */
105 64 ACPI_NS_NORMAL, /* 04 Package */
106 65 ACPI_NS_NORMAL, /* 05 FieldUnit */
107 66 ACPI_NS_NEWSCOPE, /* 06 Device */
108 67 ACPI_NS_NORMAL, /* 07 Event */
109 68 ACPI_NS_NEWSCOPE, /* 08 Method */
110 69 ACPI_NS_NORMAL, /* 09 Mutex */
111 70 ACPI_NS_NORMAL, /* 10 Region */
112 71 ACPI_NS_NEWSCOPE, /* 11 Power */
113 72 ACPI_NS_NEWSCOPE, /* 12 Processor */
114 73 ACPI_NS_NEWSCOPE, /* 13 Thermal */
115 74 ACPI_NS_NORMAL, /* 14 BufferField */
116 75 ACPI_NS_NORMAL, /* 15 DdbHandle */
117 76 ACPI_NS_NORMAL, /* 16 Debug Object */
118 77 ACPI_NS_NORMAL, /* 17 DefField */
119 78 ACPI_NS_NORMAL, /* 18 BankField */
120 79 ACPI_NS_NORMAL, /* 19 IndexField */
121 80 ACPI_NS_NORMAL, /* 20 Reference */
122 81 ACPI_NS_NORMAL, /* 21 Alias */
123 82 ACPI_NS_NORMAL, /* 22 MethodAlias */
124 83 ACPI_NS_NORMAL, /* 23 Notify */
125 84 ACPI_NS_NORMAL, /* 24 Address Handler */
126 85 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 25 Resource Desc */
127 86 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 26 Resource Field */
128 87 ACPI_NS_NEWSCOPE, /* 27 Scope */
129 88 ACPI_NS_NORMAL, /* 28 Extra */
130 89 ACPI_NS_NORMAL, /* 29 Data */
131 90 ACPI_NS_NORMAL /* 30 Invalid */
132 91 };
133 92
134 93
135 94 /*******************************************************************************
136 95 *
137 96 * FUNCTION: AcpiUtHexToAsciiChar
138 97 *
139 98 * PARAMETERS: Integer - Contains the hex digit
140 99 * Position - bit position of the digit within the
141 100 * integer (multiple of 4)
142 101 *
143 102 * RETURN: The converted Ascii character
144 103 *
145 104 * DESCRIPTION: Convert a hex digit to an Ascii character
146 105 *
147 106 ******************************************************************************/
148 107
149 108 /* Hex to ASCII conversion table */
150 109
151 110 static const char AcpiGbl_HexToAscii[] =
152 111 {
153 112 '0','1','2','3','4','5','6','7',
154 113 '8','9','A','B','C','D','E','F'
155 114 };
156 115
157 116 char
158 117 AcpiUtHexToAsciiChar (
159 118 UINT64 Integer,
160 119 UINT32 Position)
161 120 {
162 121
163 122 return (AcpiGbl_HexToAscii[(Integer >> Position) & 0xF]);
164 123 }
165 124
166 125
167 126 /*******************************************************************************
168 127 *
169 128 * FUNCTION: AcpiUtGetRegionName
170 129 *
171 130 * PARAMETERS: Space ID - ID for the region
172 131 *
|
↓ open down ↓ |
68 lines elided |
↑ open up ↑ |
173 132 * RETURN: Decoded region SpaceId name
174 133 *
175 134 * DESCRIPTION: Translate a Space ID into a name string (Debug only)
176 135 *
177 136 ******************************************************************************/
178 137
179 138 /* Region type decoding */
180 139
181 140 const char *AcpiGbl_RegionTypes[ACPI_NUM_PREDEFINED_REGIONS] =
182 141 {
183 - "SystemMemory",
184 - "SystemIO",
185 - "PCI_Config",
186 - "EmbeddedControl",
187 - "SMBus",
188 - "SystemCMOS",
189 - "PCIBARTarget",
190 - "IPMI"
142 + "SystemMemory", /* 0x00 */
143 + "SystemIO", /* 0x01 */
144 + "PCI_Config", /* 0x02 */
145 + "EmbeddedControl", /* 0x03 */
146 + "SMBus", /* 0x04 */
147 + "SystemCMOS", /* 0x05 */
148 + "PCIBARTarget", /* 0x06 */
149 + "IPMI", /* 0x07 */
150 + "GeneralPurposeIo", /* 0x08 */
151 + "GenericSerialBus", /* 0x09 */
152 + "PCC" /* 0x0A */
191 153 };
192 154
193 155
194 156 char *
195 157 AcpiUtGetRegionName (
196 158 UINT8 SpaceId)
197 159 {
198 160
199 161 if (SpaceId >= ACPI_USER_REGION_BEGIN)
200 162 {
201 163 return ("UserDefinedRegion");
202 164 }
203 165 else if (SpaceId == ACPI_ADR_SPACE_DATA_TABLE)
204 166 {
205 167 return ("DataTable");
206 168 }
207 169 else if (SpaceId == ACPI_ADR_SPACE_FIXED_HARDWARE)
208 170 {
209 171 return ("FunctionalFixedHW");
210 172 }
211 173 else if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS)
212 174 {
213 175 return ("InvalidSpaceId");
214 176 }
215 177
216 178 return (ACPI_CAST_PTR (char, AcpiGbl_RegionTypes[SpaceId]));
217 179 }
218 180
219 181
220 182 /*******************************************************************************
221 183 *
222 184 * FUNCTION: AcpiUtGetEventName
223 185 *
224 186 * PARAMETERS: EventId - Fixed event ID
225 187 *
226 188 * RETURN: Decoded event ID name
227 189 *
228 190 * DESCRIPTION: Translate a Event ID into a name string (Debug only)
229 191 *
230 192 ******************************************************************************/
231 193
232 194 /* Event type decoding */
233 195
234 196 static const char *AcpiGbl_EventTypes[ACPI_NUM_FIXED_EVENTS] =
235 197 {
236 198 "PM_Timer",
237 199 "GlobalLock",
238 200 "PowerButton",
239 201 "SleepButton",
240 202 "RealTimeClock",
241 203 };
242 204
243 205
244 206 char *
245 207 AcpiUtGetEventName (
246 208 UINT32 EventId)
247 209 {
248 210
249 211 if (EventId > ACPI_EVENT_MAX)
250 212 {
251 213 return ("InvalidEventID");
252 214 }
253 215
254 216 return (ACPI_CAST_PTR (char, AcpiGbl_EventTypes[EventId]));
255 217 }
256 218
257 219
258 220 /*******************************************************************************
259 221 *
260 222 * FUNCTION: AcpiUtGetTypeName
261 223 *
262 224 * PARAMETERS: Type - An ACPI object type
263 225 *
264 226 * RETURN: Decoded ACPI object type name
265 227 *
266 228 * DESCRIPTION: Translate a Type ID into a name string (Debug only)
267 229 *
268 230 ******************************************************************************/
269 231
270 232 /*
271 233 * Elements of AcpiGbl_NsTypeNames below must match
272 234 * one-to-one with values of ACPI_OBJECT_TYPE
273 235 *
274 236 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
275 237 * when stored in a table it really means that we have thus far seen no
276 238 * evidence to indicate what type is actually going to be stored for this entry.
277 239 */
278 240 static const char AcpiGbl_BadType[] = "UNDEFINED";
279 241
280 242 /* Printable names of the ACPI object types */
281 243
282 244 static const char *AcpiGbl_NsTypeNames[] =
283 245 {
284 246 /* 00 */ "Untyped",
285 247 /* 01 */ "Integer",
286 248 /* 02 */ "String",
287 249 /* 03 */ "Buffer",
288 250 /* 04 */ "Package",
289 251 /* 05 */ "FieldUnit",
290 252 /* 06 */ "Device",
291 253 /* 07 */ "Event",
292 254 /* 08 */ "Method",
293 255 /* 09 */ "Mutex",
294 256 /* 10 */ "Region",
295 257 /* 11 */ "Power",
296 258 /* 12 */ "Processor",
297 259 /* 13 */ "Thermal",
298 260 /* 14 */ "BufferField",
299 261 /* 15 */ "DdbHandle",
300 262 /* 16 */ "DebugObject",
301 263 /* 17 */ "RegionField",
302 264 /* 18 */ "BankField",
303 265 /* 19 */ "IndexField",
304 266 /* 20 */ "Reference",
305 267 /* 21 */ "Alias",
306 268 /* 22 */ "MethodAlias",
307 269 /* 23 */ "Notify",
308 270 /* 24 */ "AddrHandler",
309 271 /* 25 */ "ResourceDesc",
310 272 /* 26 */ "ResourceFld",
311 273 /* 27 */ "Scope",
312 274 /* 28 */ "Extra",
313 275 /* 29 */ "Data",
314 276 /* 30 */ "Invalid"
315 277 };
316 278
317 279
318 280 char *
319 281 AcpiUtGetTypeName (
320 282 ACPI_OBJECT_TYPE Type)
321 283 {
322 284
323 285 if (Type > ACPI_TYPE_INVALID)
324 286 {
325 287 return (ACPI_CAST_PTR (char, AcpiGbl_BadType));
326 288 }
327 289
328 290 return (ACPI_CAST_PTR (char, AcpiGbl_NsTypeNames[Type]));
329 291 }
330 292
331 293
332 294 char *
333 295 AcpiUtGetObjectTypeName (
334 296 ACPI_OPERAND_OBJECT *ObjDesc)
335 297 {
336 298
337 299 if (!ObjDesc)
338 300 {
339 301 return ("[NULL Object Descriptor]");
340 302 }
341 303
342 304 return (AcpiUtGetTypeName (ObjDesc->Common.Type));
343 305 }
344 306
345 307
346 308 /*******************************************************************************
347 309 *
348 310 * FUNCTION: AcpiUtGetNodeName
349 311 *
350 312 * PARAMETERS: Object - A namespace node
351 313 *
352 314 * RETURN: ASCII name of the node
353 315 *
354 316 * DESCRIPTION: Validate the node and return the node's ACPI name.
355 317 *
356 318 ******************************************************************************/
357 319
358 320 char *
359 321 AcpiUtGetNodeName (
360 322 void *Object)
361 323 {
362 324 ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) Object;
363 325
364 326
365 327 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
366 328
367 329 if (!Object)
368 330 {
369 331 return ("NULL");
370 332 }
371 333
372 334 /* Check for Root node */
373 335
374 336 if ((Object == ACPI_ROOT_OBJECT) ||
375 337 (Object == AcpiGbl_RootNode))
376 338 {
377 339 return ("\"\\\" ");
378 340 }
379 341
380 342 /* Descriptor must be a namespace node */
381 343
382 344 if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
383 345 {
384 346 return ("####");
385 347 }
386 348
387 349 /*
388 350 * Ensure name is valid. The name was validated/repaired when the node
389 351 * was created, but make sure it has not been corrupted.
390 352 */
391 353 AcpiUtRepairName (Node->Name.Ascii);
392 354
393 355 /* Return the name */
394 356
395 357 return (Node->Name.Ascii);
396 358 }
397 359
398 360
399 361 /*******************************************************************************
400 362 *
401 363 * FUNCTION: AcpiUtGetDescriptorName
402 364 *
403 365 * PARAMETERS: Object - An ACPI object
404 366 *
405 367 * RETURN: Decoded name of the descriptor type
406 368 *
407 369 * DESCRIPTION: Validate object and return the descriptor type
408 370 *
409 371 ******************************************************************************/
410 372
411 373 /* Printable names of object descriptor types */
412 374
413 375 static const char *AcpiGbl_DescTypeNames[] =
414 376 {
415 377 /* 00 */ "Not a Descriptor",
416 378 /* 01 */ "Cached",
417 379 /* 02 */ "State-Generic",
418 380 /* 03 */ "State-Update",
419 381 /* 04 */ "State-Package",
420 382 /* 05 */ "State-Control",
421 383 /* 06 */ "State-RootParseScope",
422 384 /* 07 */ "State-ParseScope",
423 385 /* 08 */ "State-WalkScope",
424 386 /* 09 */ "State-Result",
425 387 /* 10 */ "State-Notify",
426 388 /* 11 */ "State-Thread",
427 389 /* 12 */ "Walk",
428 390 /* 13 */ "Parser",
429 391 /* 14 */ "Operand",
430 392 /* 15 */ "Node"
431 393 };
432 394
433 395
434 396 char *
435 397 AcpiUtGetDescriptorName (
436 398 void *Object)
437 399 {
438 400
439 401 if (!Object)
440 402 {
441 403 return ("NULL OBJECT");
442 404 }
443 405
444 406 if (ACPI_GET_DESCRIPTOR_TYPE (Object) > ACPI_DESC_TYPE_MAX)
445 407 {
446 408 return ("Not a Descriptor");
447 409 }
448 410
449 411 return (ACPI_CAST_PTR (char,
450 412 AcpiGbl_DescTypeNames[ACPI_GET_DESCRIPTOR_TYPE (Object)]));
451 413
452 414 }
453 415
454 416
455 417 /*******************************************************************************
456 418 *
457 419 * FUNCTION: AcpiUtGetReferenceName
458 420 *
459 421 * PARAMETERS: Object - An ACPI reference object
460 422 *
461 423 * RETURN: Decoded name of the type of reference
462 424 *
463 425 * DESCRIPTION: Decode a reference object sub-type to a string.
464 426 *
465 427 ******************************************************************************/
466 428
467 429 /* Printable names of reference object sub-types */
468 430
469 431 static const char *AcpiGbl_RefClassNames[] =
470 432 {
471 433 /* 00 */ "Local",
472 434 /* 01 */ "Argument",
473 435 /* 02 */ "RefOf",
474 436 /* 03 */ "Index",
475 437 /* 04 */ "DdbHandle",
476 438 /* 05 */ "Named Object",
477 439 /* 06 */ "Debug"
478 440 };
479 441
480 442 const char *
481 443 AcpiUtGetReferenceName (
482 444 ACPI_OPERAND_OBJECT *Object)
483 445 {
484 446
485 447 if (!Object)
486 448 {
487 449 return ("NULL Object");
488 450 }
489 451
490 452 if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
491 453 {
492 454 return ("Not an Operand object");
493 455 }
494 456
495 457 if (Object->Common.Type != ACPI_TYPE_LOCAL_REFERENCE)
496 458 {
497 459 return ("Not a Reference object");
498 460 }
499 461
500 462 if (Object->Reference.Class > ACPI_REFCLASS_MAX)
501 463 {
502 464 return ("Unknown Reference class");
503 465 }
504 466
505 467 return (AcpiGbl_RefClassNames[Object->Reference.Class]);
506 468 }
507 469
508 470
509 471 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
510 472 /*
511 473 * Strings and procedures used for debug only
512 474 */
513 475
514 476 /*******************************************************************************
515 477 *
516 478 * FUNCTION: AcpiUtGetMutexName
517 479 *
518 480 * PARAMETERS: MutexId - The predefined ID for this mutex.
519 481 *
520 482 * RETURN: Decoded name of the internal mutex
521 483 *
522 484 * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
523 485 *
524 486 ******************************************************************************/
525 487
526 488 /* Names for internal mutex objects, used for debug output */
527 489
528 490 static char *AcpiGbl_MutexNames[ACPI_NUM_MUTEX] =
529 491 {
530 492 "ACPI_MTX_Interpreter",
531 493 "ACPI_MTX_Namespace",
532 494 "ACPI_MTX_Tables",
533 495 "ACPI_MTX_Events",
534 496 "ACPI_MTX_Caches",
535 497 "ACPI_MTX_Memory",
536 498 "ACPI_MTX_CommandComplete",
537 499 "ACPI_MTX_CommandReady"
538 500 };
539 501
540 502 char *
541 503 AcpiUtGetMutexName (
542 504 UINT32 MutexId)
543 505 {
544 506
545 507 if (MutexId > ACPI_MAX_MUTEX)
546 508 {
547 509 return ("Invalid Mutex ID");
548 510 }
549 511
550 512 return (AcpiGbl_MutexNames[MutexId]);
551 513 }
552 514
553 515
554 516 /*******************************************************************************
555 517 *
556 518 * FUNCTION: AcpiUtGetNotifyName
557 519 *
|
↓ open down ↓ |
357 lines elided |
↑ open up ↑ |
558 520 * PARAMETERS: NotifyValue - Value from the Notify() request
559 521 *
560 522 * RETURN: Decoded name for the notify value
561 523 *
562 524 * DESCRIPTION: Translate a Notify Value to a notify namestring.
563 525 *
564 526 ******************************************************************************/
565 527
566 528 /* Names for Notify() values, used for debug output */
567 529
568 -static const char *AcpiGbl_NotifyValueNames[] =
530 +static const char *AcpiGbl_NotifyValueNames[ACPI_NOTIFY_MAX + 1] =
569 531 {
570 - "Bus Check",
571 - "Device Check",
572 - "Device Wake",
573 - "Eject Request",
574 - "Device Check Light",
575 - "Frequency Mismatch",
576 - "Bus Mode Mismatch",
577 - "Power Fault",
578 - "Capabilities Check",
579 - "Device PLD Check",
580 - "Reserved",
581 - "System Locality Update"
532 + /* 00 */ "Bus Check",
533 + /* 01 */ "Device Check",
534 + /* 02 */ "Device Wake",
535 + /* 03 */ "Eject Request",
536 + /* 04 */ "Device Check Light",
537 + /* 05 */ "Frequency Mismatch",
538 + /* 06 */ "Bus Mode Mismatch",
539 + /* 07 */ "Power Fault",
540 + /* 08 */ "Capabilities Check",
541 + /* 09 */ "Device PLD Check",
542 + /* 10 */ "Reserved",
543 + /* 11 */ "System Locality Update",
544 + /* 12 */ "Shutdown Request"
582 545 };
583 546
584 547 const char *
585 548 AcpiUtGetNotifyName (
586 549 UINT32 NotifyValue)
587 550 {
588 551
589 552 if (NotifyValue <= ACPI_NOTIFY_MAX)
590 553 {
591 554 return (AcpiGbl_NotifyValueNames[NotifyValue]);
592 555 }
593 556 else if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)
594 557 {
595 558 return ("Reserved");
596 559 }
597 - else /* Greater or equal to 0x80 */
560 + else if (NotifyValue <= ACPI_MAX_DEVICE_SPECIFIC_NOTIFY)
598 561 {
599 - return ("**Device Specific**");
562 + return ("Device Specific");
600 563 }
564 + else
565 + {
566 + return ("Hardware Specific");
567 + }
601 568 }
602 569 #endif
603 570
604 571
605 572 /*******************************************************************************
606 573 *
607 574 * FUNCTION: AcpiUtValidObjectType
608 575 *
609 576 * PARAMETERS: Type - Object type to be validated
610 577 *
611 578 * RETURN: TRUE if valid object type, FALSE otherwise
612 579 *
613 580 * DESCRIPTION: Validate an object type
614 581 *
615 582 ******************************************************************************/
616 583
617 584 BOOLEAN
618 585 AcpiUtValidObjectType (
619 586 ACPI_OBJECT_TYPE Type)
620 587 {
621 588
622 589 if (Type > ACPI_TYPE_LOCAL_MAX)
623 590 {
624 591 /* Note: Assumes all TYPEs are contiguous (external/local) */
625 592
626 593 return (FALSE);
627 594 }
628 595
629 596 return (TRUE);
630 597 }
|
↓ open down ↓ |
20 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX