sys/contrib/dev/acpica/source/tools/acpihelp/ahdecode.c

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