arch/all-pc/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 - 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 }