1 /******************************************************************************
2 *
3 * Module Name: ahdecode - Operator/Opcode decoding for acpihelp utility
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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 #define ACPI_CREATE_PREDEFINED_TABLE
45 #define ACPI_CREATE_RESOURCE_TABLE
46
47 #include "acpihelp.h"
48 #include "acpredef.h"
49
50
51 /* Device IDs defined in the ACPI specification */
52
53 static const AH_DEVICE_ID AhDeviceIds[] =
54 {
55 {"PNP0A05", "Generic Container Device"},
56 {"PNP0A06", "Generic Container Device"},
57 {"PNP0C08", "ACPI core hardware"},
58 {"PNP0C09", "Embedded Controller Device"},
59 {"PNP0C0A", "Control Method Battery"},
60 {"PNP0C0B", "Fan"},
61 {"PNP0C0C", "Power Button Device"},
62 {"PNP0C0D", "Lid Device"},
63 {"PNP0C0E", "Sleep Button Device"},
64 {"PNP0C0F", "PCI Interrupt Link Device"},
65 {"PNP0C80", "Memory Device"},
66
67 {"ACPI0001", "SMBus 1.0 Host Controller"},
68 {"ACPI0002", "Smart Battery Subsystem"},
69 {"ACPI0003", "Power Source Device"},
70 {"ACPI0004", "Module Device"},
71 {"ACPI0005", "SMBus 2.0 Host Controller"},
72 {"ACPI0006", "GPE Block Device"},
73 {"ACPI0007", "Processor Device"},
74 {"ACPI0008", "Ambient Light Sensor Device"},
75 {"ACPI0009", "I/O xAPIC Device"},
76 {"ACPI000A", "I/O APIC Device"},
77 {"ACPI000B", "I/O SAPIC Device"},
78 {"ACPI000C", "Processor Aggregator Device"},
79 {"ACPI000D", "Power Meter Device"},
80 {"ACPI000E", "Time/Alarm Device"},
81 {"ACPI000F", "User Presence Detection Device"},
82
83 {NULL, NULL}
84 };
85
86 #define AH_DISPLAY_EXCEPTION(Status, Name) \
87 printf ("%.4X: %s\n", Status, Name)
88
89 #define AH_DISPLAY_EXCEPTION_TEXT(Status, Exception) \
90 printf ("%.4X: %-28s (%s)\n", Status, Exception->Name, Exception->Description)
91
92 #define BUFFER_LENGTH 128
93 #define LINE_BUFFER_LENGTH 512
94
95 static char Gbl_Buffer[BUFFER_LENGTH];
96 static char Gbl_LineBuffer[LINE_BUFFER_LENGTH];
97
98 /* Local prototypes */
99
100 static BOOLEAN
101 AhDisplayPredefinedName (
102 char *Name,
103 UINT32 Length);
104
105 static void
106 AhDisplayPredefinedInfo (
107 char *Name);
108
109 static void
110 AhDisplayResourceName (
111 const ACPI_PREDEFINED_INFO *ThisName);
112
113 static void
114 AhDisplayAmlOpcode (
115 const AH_AML_OPCODE *Op);
116
117 static void
118 AhDisplayAslOperator (
119 const AH_ASL_OPERATOR *Op);
120
121 static void
122 AhDisplayOperatorKeywords (
123 const AH_ASL_OPERATOR *Op);
124
125 static void
126 AhDisplayAslKeyword (
127 const AH_ASL_KEYWORD *Op);
128
129 static void
130 AhPrintOneField (
131 UINT32 Indent,
132 UINT32 CurrentPosition,
133 UINT32 MaxPosition,
134 const char *Field);
135
136
137 /*******************************************************************************
138 *
139 * FUNCTION: AhFindPredefinedNames (entry point for predefined name search)
140 *
141 * PARAMETERS: NamePrefix - Name or prefix to find. Must start with
142 * an underscore. NULL means "find all"
143 *
144 * RETURN: None
145 *
146 * DESCRIPTION: Find and display all ACPI predefined names that match the
147 * input name or prefix. Includes the required number of arguments
148 * and the expected return type, if any.
149 *
150 ******************************************************************************/
151
152 void
153 AhFindPredefinedNames (
154 char *NamePrefix)
155 {
156 UINT32 Length;
157 BOOLEAN Found;
158 char Name[9];
159
160
161 if (!NamePrefix)
162 {
163 Found = AhDisplayPredefinedName (Name, 0);
164 return;
165 }
166
167 /* Contruct a local name or name prefix */
168
169 AhStrupr (NamePrefix);
170 if (*NamePrefix == '_')
171 {
172 NamePrefix++;
173 }
174
175 Name[0] = '_';
176 strncpy (&Name[1], NamePrefix, 7);
177
178 Length = strlen (Name);
179 if (Length > 4)
180 {
181 printf ("%.8s: Predefined name must be 4 characters maximum\n", Name);
182 return;
183 }
184
185 Found = AhDisplayPredefinedName (Name, Length);
186 if (!Found)
187 {
188 printf ("%s, no matching predefined names\n", Name);
189 }
190 }
191
192
193 /*******************************************************************************
194 *
195 * FUNCTION: AhDisplayPredefinedName
196 *
197 * PARAMETERS: Name - Name or name prefix
198 *
199 * RETURN: TRUE if any names matched, FALSE otherwise
200 *
201 * DESCRIPTION: Display information about ACPI predefined names that match
202 * the input name or name prefix.
203 *
204 ******************************************************************************/
205
206 static BOOLEAN
207 AhDisplayPredefinedName (
208 char *Name,
209 UINT32 Length)
210 {
211 const AH_PREDEFINED_NAME *Info;
212 BOOLEAN Found = FALSE;
213 BOOLEAN Matched;
214 UINT32 i;
215
216
217 /* Find/display all names that match the input name prefix */
218
219 for (Info = AslPredefinedInfo; Info->Name; Info++)
220 {
221 if (!Name)
222 {
223 Found = TRUE;
224 printf ("%s: <%s>\n", Info->Name, Info->Description);
225 printf ("%*s%s\n", 6, " ", Info->Action);
226
227 AhDisplayPredefinedInfo (Info->Name);
228 continue;
229 }
230
231 Matched = TRUE;
232 for (i = 0; i < Length; i++)
233 {
234 if (Info->Name[i] != Name[i])
235 {
236 Matched = FALSE;
237 break;
238 }
239 }
240
241 if (Matched)
242 {
243 Found = TRUE;
244 printf ("%s: <%s>\n", Info->Name, Info->Description);
245 printf ("%*s%s\n", 6, " ", Info->Action);
246
247 AhDisplayPredefinedInfo (Info->Name);
248 }
249 }
250
251 return (Found);
252 }
253
254
255 /*******************************************************************************
256 *
257 * FUNCTION: AhDisplayPredefinedInfo
258 *
259 * PARAMETERS: Name - Exact 4-character ACPI name.
260 *
261 * RETURN: None
262 *
263 * DESCRIPTION: Find the name in the main ACPICA predefined info table and
264 * display the # of arguments and the return value type.
265 *
266 * Note: Resource Descriptor field names do not appear in this
267 * table -- thus, nothing will be displayed for them.
268 *
269 ******************************************************************************/
270
271 static void
272 AhDisplayPredefinedInfo (
273 char *Name)
274 {
275 const ACPI_PREDEFINED_INFO *ThisName;
276
277
278 /* NOTE: we check both tables always because there are some dupes */
279
280 /* Check against the predefine methods first */
281
282 ThisName = AcpiUtMatchPredefinedMethod (Name);
283 if (ThisName)
284 {
285 AcpiUtDisplayPredefinedMethod (Gbl_Buffer, ThisName, TRUE);
286 }
287
288 /* Check against the predefined resource descriptor names */
289
290 ThisName = AcpiUtMatchResourceName (Name);
291 if (ThisName)
292 {
293 AhDisplayResourceName (ThisName);
294 }
295 }
296
297
298 /*******************************************************************************
299 *
300 * FUNCTION: AhDisplayResourceName
301 *
302 * PARAMETERS: ThisName - Entry in the predefined method/name table
303 *
304 * RETURN: None
305 *
306 * DESCRIPTION: Display information about a resource descriptor name.
307 *
308 ******************************************************************************/
309
310 static void
311 AhDisplayResourceName (
312 const ACPI_PREDEFINED_INFO *ThisName)
313 {
314 UINT32 NumTypes;
315
316
317 NumTypes = AcpiUtGetResourceBitWidth (Gbl_Buffer,
318 ThisName->Info.ArgumentList);
319
320 printf (" %4.4s resource descriptor field is %s bits wide%s\n",
321 ThisName->Info.Name,
322 Gbl_Buffer,
323 (NumTypes > 1) ? " (depending on descriptor type)" : "");
324 }
325
326
327 /*******************************************************************************
328 *
329 * FUNCTION: AhFindAmlOpcode (entry point for AML opcode name search)
330 *
331 * PARAMETERS: Name - Name or prefix for an AML opcode.
332 * NULL means "find all"
333 *
334 * RETURN: None
335 *
336 * DESCRIPTION: Find all AML opcodes that match the input Name or name
337 * prefix.
338 *
339 ******************************************************************************/
340
341 void
342 AhFindAmlOpcode (
343 char *Name)
344 {
345 const AH_AML_OPCODE *Op;
346 BOOLEAN Found = FALSE;
347
348
349 AhStrupr (Name);
350
351 /* Find/display all opcode names that match the input name prefix */
352
353 for (Op = AmlOpcodeInfo; Op->OpcodeString; Op++)
354 {
355 if (!Op->OpcodeName) /* Unused opcodes */
356 {
357 continue;
358 }
359
360 if (!Name)
361 {
362 AhDisplayAmlOpcode (Op);
363 Found = TRUE;
364 continue;
365 }
366
367 /* Upper case the opcode name before substring compare */
368
369 strcpy (Gbl_Buffer, Op->OpcodeName);
370 AhStrupr (Gbl_Buffer);
371
372 if (strstr (Gbl_Buffer, Name) == Gbl_Buffer)
373 {
374 AhDisplayAmlOpcode (Op);
375 Found = TRUE;
376 }
377 }
378
379 if (!Found)
380 {
381 printf ("%s, no matching AML operators\n", Name);
382 }
383 }
384
385
386 /*******************************************************************************
387 *
388 * FUNCTION: AhDecodeAmlOpcode (entry point for AML opcode search)
389 *
390 * PARAMETERS: OpcodeString - String version of AML opcode
391 *
392 * RETURN: None
393 *
394 * DESCRIPTION: Display information about the input AML opcode
395 *
396 ******************************************************************************/
397
398 void
399 AhDecodeAmlOpcode (
400 char *OpcodeString)
401 {
402 const AH_AML_OPCODE *Op;
403 UINT32 Opcode;
404 UINT8 Prefix;
405
406
407 if (!OpcodeString)
408 {
409 AhFindAmlOpcode (NULL);
410 return;
411 }
412
413 Opcode = ACPI_STRTOUL (OpcodeString, NULL, 16);
414 if (Opcode > ACPI_UINT16_MAX)
415 {
416 printf ("Invalid opcode (more than 16 bits)\n");
417 return;
418 }
419
420 /* Only valid opcode extension is 0x5B */
421
422 Prefix = (Opcode & 0x0000FF00) >> 8;
423 if (Prefix && (Prefix != 0x5B))
424 {
425 printf ("Invalid opcode (invalid extension prefix 0x%X)\n",
426 Prefix);
427 return;
428 }
429
430 /* Find/Display the opcode. May fall within an opcode range */
431
432 for (Op = AmlOpcodeInfo; Op->OpcodeString; Op++)
433 {
434 if ((Opcode >= Op->OpcodeRangeStart) &&
435 (Opcode <= Op->OpcodeRangeEnd))
436 {
437 AhDisplayAmlOpcode (Op);
438 }
439 }
440 }
441
442
443 /*******************************************************************************
444 *
445 * FUNCTION: AhDisplayAmlOpcode
446 *
447 * PARAMETERS: Op - An opcode info struct
448 *
449 * RETURN: None
450 *
451 * DESCRIPTION: Display the contents of an AML opcode information struct
452 *
453 ******************************************************************************/
454
455 static void
456 AhDisplayAmlOpcode (
457 const AH_AML_OPCODE *Op)
458 {
459
460 if (!Op->OpcodeName)
461 {
462 printf ("%18s: Opcode=%-9s\n", "Reserved opcode", Op->OpcodeString);
463 return;
464 }
465
466 /* Opcode name and value(s) */
467
468 printf ("%18s: Opcode=%-9s Type (%s)",
469 Op->OpcodeName, Op->OpcodeString, Op->Type);
470
471 /* Optional fixed/static arguments */
472
473 if (Op->FixedArguments)
474 {
475 printf (" FixedArgs (");
476 AhPrintOneField (37, 36 + 7 + strlen (Op->Type) + 12,
477 AH_MAX_AML_LINE_LENGTH, Op->FixedArguments);
478 printf (")");
479 }
480
481 /* Optional variable-length argument list */
482
483 if (Op->VariableArguments)
484 {
485 if (Op->FixedArguments)
486 {
487 printf ("\n%*s", 36, " ");
488 }
489 printf (" VariableArgs (");
490 AhPrintOneField (37, 15, AH_MAX_AML_LINE_LENGTH, Op->VariableArguments);
491 printf (")");
492 }
493 printf ("\n");
494
495 /* Grammar specification */
496
497 if (Op->Grammar)
498 {
499 AhPrintOneField (37, 0, AH_MAX_AML_LINE_LENGTH, Op->Grammar);
500 printf ("\n");
501 }
502 }
503
504
505 /*******************************************************************************
506 *
507 * FUNCTION: AhFindAslKeywords (entry point for ASL keyword search)
508 *
509 * PARAMETERS: Name - Name or prefix for an ASL keyword.
510 * NULL means "find all"
511 *
512 * RETURN: None
513 *
514 * DESCRIPTION: Find all ASL keywords that match the input Name or name
515 * prefix.
516 *
517 ******************************************************************************/
518
519 void
520 AhFindAslKeywords (
521 char *Name)
522 {
523 const AH_ASL_KEYWORD *Keyword;
524 BOOLEAN Found = FALSE;
525
526
527 AhStrupr (Name);
528
529 for (Keyword = AslKeywordInfo; Keyword->Name; Keyword++)
530 {
531 if (!Name)
532 {
533 AhDisplayAslKeyword (Keyword);
534 Found = TRUE;
535 continue;
536 }
537
538 /* Upper case the operator name before substring compare */
539
540 strcpy (Gbl_Buffer, Keyword->Name);
541 AhStrupr (Gbl_Buffer);
542
543 if (strstr (Gbl_Buffer, Name) == Gbl_Buffer)
544 {
545 AhDisplayAslKeyword (Keyword);
546 Found = TRUE;
547 }
548 }
549
550 if (!Found)
551 {
552 printf ("%s, no matching ASL keywords\n", Name);
553 }
554 }
555
556
557 /*******************************************************************************
558 *
559 * FUNCTION: AhDisplayAslKeyword
560 *
561 * PARAMETERS: Op - Pointer to ASL keyword with syntax info
562 *
563 * RETURN: None
564 *
565 * DESCRIPTION: Format and display syntax info for an ASL keyword. Splits
566 * long lines appropriately for reading.
567 *
568 ******************************************************************************/
569
570 static void
571 AhDisplayAslKeyword (
572 const AH_ASL_KEYWORD *Op)
573 {
574
575 /* ASL keyword name and description */
576
577 printf ("%22s: %s\n", Op->Name, Op->Description);
578 if (!Op->KeywordList)
579 {
580 return;
581 }
582
583 /* List of actual keywords */
584
585 AhPrintOneField (24, 0, AH_MAX_ASL_LINE_LENGTH, Op->KeywordList);
586 printf ("\n");
587 }
588
589
590 /*******************************************************************************
591 *
592 * FUNCTION: AhFindAslOperators (entry point for ASL operator search)
593 *
594 * PARAMETERS: Name - Name or prefix for an ASL operator.
595 * NULL means "find all"
596 *
597 * RETURN: None
598 *
599 * DESCRIPTION: Find all ASL operators that match the input Name or name
600 * prefix.
601 *
602 ******************************************************************************/
603
604 void
605 AhFindAslOperators (
606 char *Name)
607 {
608 const AH_ASL_OPERATOR *Operator;
609 BOOLEAN Found = FALSE;
610
611
612 AhStrupr (Name);
613
614 /* Find/display all names that match the input name prefix */
615
616 for (Operator = AslOperatorInfo; Operator->Name; Operator++)
617 {
618 if (!Name)
619 {
620 AhDisplayAslOperator (Operator);
621 Found = TRUE;
622 continue;
623 }
624
625 /* Upper case the operator name before substring compare */
626
627 strcpy (Gbl_Buffer, Operator->Name);
628 AhStrupr (Gbl_Buffer);
629
630 if (strstr (Gbl_Buffer, Name) == Gbl_Buffer)
631 {
632 AhDisplayAslOperator (Operator);
633 Found = TRUE;
634 }
635 }
636
637 if (!Found)
638 {
639 printf ("%s, no matching ASL operators\n", Name);
640 }
641 }
642
643
644 /*******************************************************************************
645 *
646 * FUNCTION: AhDisplayAslOperator
647 *
648 * PARAMETERS: Op - Pointer to ASL operator with syntax info
649 *
650 * RETURN: None
651 *
652 * DESCRIPTION: Format and display syntax info for an ASL operator. Splits
653 * long lines appropriately for reading.
654 *
655 ******************************************************************************/
656
657 static void
658 AhDisplayAslOperator (
659 const AH_ASL_OPERATOR *Op)
660 {
661
662 /* ASL operator name and description */
663
664 printf ("%16s: %s\n", Op->Name, Op->Description);
665 if (!Op->Syntax)
666 {
667 return;
668 }
669
670 /* Syntax for the operator */
671
672 AhPrintOneField (18, 0, AH_MAX_ASL_LINE_LENGTH, Op->Syntax);
673 printf ("\n");
674
675 AhDisplayOperatorKeywords (Op);
676 printf ("\n");
677 }
678
679
680 /*******************************************************************************
681 *
682 * FUNCTION: AhDisplayOperatorKeywords
683 *
684 * PARAMETERS: Op - Pointer to ASL keyword with syntax info
685 *
686 * RETURN: None
687 *
688 * DESCRIPTION: Display any/all keywords that are associated with the ASL
689 * operator.
690 *
691 ******************************************************************************/
692
693 static void
694 AhDisplayOperatorKeywords (
695 const AH_ASL_OPERATOR *Op)
696 {
697 char *Token;
698 char *Separators = "(){}, ";
699 BOOLEAN FirstKeyword = TRUE;
700
701
702 if (!Op || !Op->Syntax)
703 {
704 return;
705 }
706
707 /*
708 * Find all parameters that have the word "keyword" within, and then
709 * display the info about that keyword
710 */
711 strcpy (Gbl_LineBuffer, Op->Syntax);
712 Token = strtok (Gbl_LineBuffer, Separators);
713 while (Token)
714 {
715 if (strstr (Token, "Keyword"))
716 {
717 if (FirstKeyword)
718 {
719 printf ("\n");
720 FirstKeyword = FALSE;
721 }
722
723 /* Found a keyword, display keyword information */
724
725 AhFindAslKeywords (Token);
726 }
727
728 Token = strtok (NULL, Separators);
729 }
730 }
731
732
733 /*******************************************************************************
734 *
735 * FUNCTION: AhPrintOneField
736 *
737 * PARAMETERS: Indent - Indent length for new line(s)
738 * CurrentPosition - Position on current line
739 * MaxPosition - Max allowed line length
740 * Field - Data to output
741 *
742 * RETURN: Line position after field is written
743 *
744 * DESCRIPTION: Split long lines appropriately for ease of reading.
745 *
746 ******************************************************************************/
747
748 static void
749 AhPrintOneField (
750 UINT32 Indent,
751 UINT32 CurrentPosition,
752 UINT32 MaxPosition,
753 const char *Field)
754 {
755 UINT32 Position;
756 UINT32 TokenLength;
757 const char *This;
758 const char *Next;
759 const char *Last;
760
761
762 This = Field;
763 Position = CurrentPosition;
764
765 if (Position == 0)
766 {
767 printf ("%*s", (int) Indent, " ");
768 Position = Indent;
769 }
770
771 Last = This + strlen (This);
772 while ((Next = strpbrk (This, " ")))
773 {
774 TokenLength = Next - This;
775 Position += TokenLength;
776
777 /* Split long lines */
778
779 if (Position > MaxPosition)
780 {
781 printf ("\n%*s", (int) Indent, " ");
782 Position = TokenLength;
783 }
784
785 printf ("%.*s ", (int) TokenLength, This);
786 This = Next + 1;
787 }
788
789 /* Handle last token on the input line */
790
791 TokenLength = Last - This;
792 if (TokenLength > 0)
793 {
794 Position += TokenLength;
795 if (Position > MaxPosition)
796 {
797 printf ("\n%*s", (int) Indent, " ");
798 }
799 printf ("%s", This);
800 }
801 }
802
803
804 /*******************************************************************************
805 *
806 * FUNCTION: AhDisplayDeviceIds
807 *
808 * PARAMETERS: None
809 *
810 * RETURN: None
811 *
812 * DESCRIPTION: Display all PNP* and ACPI* device IDs defined in the ACPI spec.
813 *
814 ******************************************************************************/
815
816 void
817 AhDisplayDeviceIds (
818 void)
819 {
820 const AH_DEVICE_ID *DeviceId = AhDeviceIds;
821
822
823 printf ("ACPI and PNP Device IDs defined in the ACPI specification:\n\n");
824 while (DeviceId->Name)
825 {
826 printf ("%8s %s\n", DeviceId->Name, DeviceId->Description);
827 DeviceId++;
828 }
829 }
830
831
832 /*******************************************************************************
833 *
834 * FUNCTION: AhDecodeException
835 *
836 * PARAMETERS: HexString - ACPI status string from command line, in
837 * hex. If null, display all exceptions.
838 *
839 * RETURN: None
840 *
841 * DESCRIPTION: Decode and display an ACPI_STATUS exception code.
842 *
843 ******************************************************************************/
844
845 void
846 AhDecodeException (
847 char *HexString)
848 {
849 const ACPI_EXCEPTION_INFO *ExceptionInfo;
850 UINT32 Status;
851 UINT32 i;
852
853
854 /*
855 * A null input string means to decode and display all known
856 * exception codes.
857 */
858 if (!HexString)
859 {
860 printf ("All defined ACPICA exception codes:\n\n");
861 AH_DISPLAY_EXCEPTION (0, "AE_OK (No error occurred)");
862
863 /* Display codes in each block of exception types */
864
865 for (i = 1; (i & AE_CODE_MASK) <= AE_CODE_MAX; i += 0x1000)
866 {
867 Status = i;
868 do
869 {
870 ExceptionInfo = AcpiUtValidateException ((ACPI_STATUS) Status);
871 if (ExceptionInfo)
872 {
873 AH_DISPLAY_EXCEPTION_TEXT (Status, ExceptionInfo);
874 }
875 Status++;
876
877 } while (ExceptionInfo);
878 }
879 return;
880 }
881
882 /* Decode a single user-supplied exception code */
883
884 Status = ACPI_STRTOUL (HexString, NULL, 16);
885 if (!Status)
886 {
887 printf ("%s: Invalid hexadecimal exception code value\n", HexString);
888 return;
889 }
890
891 if (Status > ACPI_UINT16_MAX)
892 {
893 AH_DISPLAY_EXCEPTION (Status, "Invalid exception code (more than 16 bits)");
894 return;
895 }
896
897 ExceptionInfo = AcpiUtValidateException ((ACPI_STATUS) Status);
898 if (!ExceptionInfo)
899 {
900 AH_DISPLAY_EXCEPTION (Status, "Unknown exception code");
901 return;
902 }
903
904 AH_DISPLAY_EXCEPTION_TEXT (Status, ExceptionInfo);
905 }