sys/contrib/dev/acpica/debugger/dbdisply.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: dbdisply - debug display commands
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2011, 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
  45 #include <contrib/dev/acpica/include/acpi.h>
  46 #include <contrib/dev/acpica/include/accommon.h>
  47 #include <contrib/dev/acpica/include/amlcode.h>
  48 #include <contrib/dev/acpica/include/acdispat.h>
  49 #include <contrib/dev/acpica/include/acnamesp.h>
  50 #include <contrib/dev/acpica/include/acparser.h>
  51 #include <contrib/dev/acpica/include/acinterp.h>
  52 #include <contrib/dev/acpica/include/acdebug.h>
  53 #include <contrib/dev/acpica/include/acdisasm.h>
  54
  55
  56 #ifdef ACPI_DEBUGGER
  57
  58 #define _COMPONENT          ACPI_CA_DEBUGGER
  59         ACPI_MODULE_NAME    ("dbdisply")
  60
  61 /* Local prototypes */
  62
  63 static void
  64 AcpiDbDumpParserDescriptor (
  65     ACPI_PARSE_OBJECT       *Op);
  66
  67 static void *
  68 AcpiDbGetPointer (
  69     void                    *Target);
  70
  71
  72 /*
  73  * System handler information.
  74  * Used for Handlers command, in AcpiDbDisplayHandlers.
  75  */
  76 #define ACPI_PREDEFINED_PREFIX          "%25s (%.2X) : "
  77 #define ACPI_HANDLER_NAME_STRING               "%30s : "
  78 #define ACPI_HANDLER_PRESENT_STRING                    "%-9s (%p)\n"
  79 #define ACPI_HANDLER_NOT_PRESENT_STRING                "%-9s\n"
  80
  81 /* All predefined Address Space IDs */
  82
  83 static ACPI_ADR_SPACE_TYPE  AcpiGbl_SpaceIdList[] =
  84 {
  85     ACPI_ADR_SPACE_SYSTEM_MEMORY,
  86     ACPI_ADR_SPACE_SYSTEM_IO,
  87     ACPI_ADR_SPACE_PCI_CONFIG,
  88     ACPI_ADR_SPACE_EC,
  89     ACPI_ADR_SPACE_SMBUS,
  90     ACPI_ADR_SPACE_CMOS,
  91     ACPI_ADR_SPACE_PCI_BAR_TARGET,
  92     ACPI_ADR_SPACE_IPMI,
  93     ACPI_ADR_SPACE_DATA_TABLE,
  94     ACPI_ADR_SPACE_FIXED_HARDWARE
  95 };
  96
  97 /* Global handler information */
  98
  99 typedef struct acpi_handler_info
 100 {
 101     void                    *Handler;
 102     char                    *Name;
 103
 104 } ACPI_HANDLER_INFO;
 105
 106 static ACPI_HANDLER_INFO    AcpiGbl_HandlerList[] =
 107 {
 108     {&AcpiGbl_SystemNotify.Handler,     "System Notifications"},
 109     {&AcpiGbl_DeviceNotify.Handler,     "Device Notifications"},
 110     {&AcpiGbl_TableHandler,             "ACPI Table Events"},
 111     {&AcpiGbl_ExceptionHandler,         "Control Method Exceptions"},
 112     {&AcpiGbl_InterfaceHandler,         "OSI Invocations"}
 113 };
 114
 115
 116 /*******************************************************************************
 117  *
 118  * FUNCTION:    AcpiDbGetPointer
 119  *
 120  * PARAMETERS:  Target          - Pointer to string to be converted
 121  *
 122  * RETURN:      Converted pointer
 123  *
 124  * DESCRIPTION: Convert an ascii pointer value to a real value
 125  *
 126  ******************************************************************************/
 127
 128 static void *
 129 AcpiDbGetPointer (
 130     void                    *Target)
 131 {
 132     void                    *ObjPtr;
 133
 134
 135     ObjPtr = ACPI_TO_POINTER (ACPI_STRTOUL (Target, NULL, 16));
 136     return (ObjPtr);
 137 }
 138
 139
 140 /*******************************************************************************
 141  *
 142  * FUNCTION:    AcpiDbDumpParserDescriptor
 143  *
 144  * PARAMETERS:  Op              - A parser Op descriptor
 145  *
 146  * RETURN:      None
 147  *
 148  * DESCRIPTION: Display a formatted parser object
 149  *
 150  ******************************************************************************/
 151
 152 static void
 153 AcpiDbDumpParserDescriptor (
 154     ACPI_PARSE_OBJECT       *Op)
 155 {
 156     const ACPI_OPCODE_INFO  *Info;
 157
 158
 159     Info = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 160
 161     AcpiOsPrintf ("Parser Op Descriptor:\n");
 162     AcpiOsPrintf ("%20.20s : %4.4X\n", "Opcode", Op->Common.AmlOpcode);
 163
 164     ACPI_DEBUG_ONLY_MEMBERS (AcpiOsPrintf ("%20.20s : %s\n", "Opcode Name",
 165         Info->Name));
 166
 167     AcpiOsPrintf ("%20.20s : %p\n", "Value/ArgList", Op->Common.Value.Arg);
 168     AcpiOsPrintf ("%20.20s : %p\n", "Parent", Op->Common.Parent);
 169     AcpiOsPrintf ("%20.20s : %p\n", "NextOp", Op->Common.Next);
 170 }
 171
 172
 173 /*******************************************************************************
 174  *
 175  * FUNCTION:    AcpiDbDecodeAndDisplayObject
 176  *
 177  * PARAMETERS:  Target          - String with object to be displayed.  Names
 178  *                                and hex pointers are supported.
 179  *              OutputType      - Byte, Word, Dword, or Qword (B|W|D|Q)
 180  *
 181  * RETURN:      None
 182  *
 183  * DESCRIPTION: Display a formatted ACPI object
 184  *
 185  ******************************************************************************/
 186
 187 void
 188 AcpiDbDecodeAndDisplayObject (
 189     char                    *Target,
 190     char                    *OutputType)
 191 {
 192     void                    *ObjPtr;
 193     ACPI_NAMESPACE_NODE     *Node;
 194     ACPI_OPERAND_OBJECT     *ObjDesc;
 195     UINT32                  Display = DB_BYTE_DISPLAY;
 196     char                    Buffer[80];
 197     ACPI_BUFFER             RetBuf;
 198     ACPI_STATUS             Status;
 199     UINT32                  Size;
 200
 201
 202     if (!Target)
 203     {
 204         return;
 205     }
 206
 207     /* Decode the output type */
 208
 209     if (OutputType)
 210     {
 211         AcpiUtStrupr (OutputType);
 212         if (OutputType[0] == 'W')
 213         {
 214             Display = DB_WORD_DISPLAY;
 215         }
 216         else if (OutputType[0] == 'D')
 217         {
 218             Display = DB_DWORD_DISPLAY;
 219         }
 220         else if (OutputType[0] == 'Q')
 221         {
 222             Display = DB_QWORD_DISPLAY;
 223         }
 224     }
 225
 226     RetBuf.Length = sizeof (Buffer);
 227     RetBuf.Pointer = Buffer;
 228
 229     /* Differentiate between a number and a name */
 230
 231     if ((Target[0] >= 0x30) && (Target[0] <= 0x39))
 232     {
 233         ObjPtr = AcpiDbGetPointer (Target);
 234         if (!AcpiOsReadable (ObjPtr, 16))
 235         {
 236             AcpiOsPrintf ("Address %p is invalid in this address space\n",
 237                 ObjPtr);
 238             return;
 239         }
 240
 241         /* Decode the object type */
 242
 243         switch (ACPI_GET_DESCRIPTOR_TYPE (ObjPtr))
 244         {
 245         case ACPI_DESC_TYPE_NAMED:
 246
 247             /* This is a namespace Node */
 248
 249             if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_NAMESPACE_NODE)))
 250             {
 251                 AcpiOsPrintf (
 252                     "Cannot read entire Named object at address %p\n", ObjPtr);
 253                 return;
 254             }
 255
 256             Node = ObjPtr;
 257             goto DumpNode;
 258
 259
 260         case ACPI_DESC_TYPE_OPERAND:
 261
 262             /* This is a ACPI OPERAND OBJECT */
 263
 264             if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_OPERAND_OBJECT)))
 265             {
 266                 AcpiOsPrintf ("Cannot read entire ACPI object at address %p\n",
 267                     ObjPtr);
 268                 return;
 269             }
 270
 271             AcpiUtDumpBuffer (ObjPtr, sizeof (ACPI_OPERAND_OBJECT), Display,
 272                 ACPI_UINT32_MAX);
 273             AcpiExDumpObjectDescriptor (ObjPtr, 1);
 274             break;
 275
 276
 277         case ACPI_DESC_TYPE_PARSER:
 278
 279             /* This is a Parser Op object */
 280
 281             if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_PARSE_OBJECT)))
 282             {
 283                 AcpiOsPrintf (
 284                     "Cannot read entire Parser object at address %p\n", ObjPtr);
 285                 return;
 286             }
 287
 288             AcpiUtDumpBuffer (ObjPtr, sizeof (ACPI_PARSE_OBJECT), Display,
 289                 ACPI_UINT32_MAX);
 290             AcpiDbDumpParserDescriptor ((ACPI_PARSE_OBJECT *) ObjPtr);
 291             break;
 292
 293
 294         default:
 295
 296             /* Is not a recognizeable object */
 297
 298             Size = 16;
 299             if (AcpiOsReadable (ObjPtr, 64))
 300             {
 301                 Size = 64;
 302             }
 303
 304             /* Just dump some memory */
 305
 306             AcpiUtDumpBuffer (ObjPtr, Size, Display, ACPI_UINT32_MAX);
 307             break;
 308         }
 309
 310         return;
 311     }
 312
 313     /* The parameter is a name string that must be resolved to a Named obj */
 314
 315     Node = AcpiDbLocalNsLookup (Target);
 316     if (!Node)
 317     {
 318         return;
 319     }
 320
 321
 322 DumpNode:
 323     /* Now dump the NS node */
 324
 325     Status = AcpiGetName (Node, ACPI_FULL_PATHNAME, &RetBuf);
 326     if (ACPI_FAILURE (Status))
 327     {
 328         AcpiOsPrintf ("Could not convert name to pathname\n");
 329     }
 330
 331     else
 332     {
 333         AcpiOsPrintf ("Object (%p) Pathname:  %s\n",
 334             Node, (char *) RetBuf.Pointer);
 335     }
 336
 337     if (!AcpiOsReadable (Node, sizeof (ACPI_NAMESPACE_NODE)))
 338     {
 339         AcpiOsPrintf ("Invalid Named object at address %p\n", Node);
 340         return;
 341     }
 342
 343     AcpiUtDumpBuffer ((void *) Node, sizeof (ACPI_NAMESPACE_NODE),
 344         Display, ACPI_UINT32_MAX);
 345     AcpiExDumpNamespaceNode (Node, 1);
 346
 347     ObjDesc = AcpiNsGetAttachedObject (Node);
 348     if (ObjDesc)
 349     {
 350         AcpiOsPrintf ("\nAttached Object (%p):\n", ObjDesc);
 351         if (!AcpiOsReadable (ObjDesc, sizeof (ACPI_OPERAND_OBJECT)))
 352         {
 353             AcpiOsPrintf ("Invalid internal ACPI Object at address %p\n",
 354                 ObjDesc);
 355             return;
 356         }
 357
 358         AcpiUtDumpBuffer ((void *) ObjDesc, sizeof (ACPI_OPERAND_OBJECT),
 359             Display, ACPI_UINT32_MAX);
 360         AcpiExDumpObjectDescriptor (ObjDesc, 1);
 361     }
 362 }
 363
 364
 365 /*******************************************************************************
 366  *
 367  * FUNCTION:    AcpiDbDisplayMethodInfo
 368  *
 369  * PARAMETERS:  StartOp         - Root of the control method parse tree
 370  *
 371  * RETURN:      None
 372  *
 373  * DESCRIPTION: Display information about the current method
 374  *
 375  ******************************************************************************/
 376
 377 void
 378 AcpiDbDisplayMethodInfo (
 379     ACPI_PARSE_OBJECT       *StartOp)
 380 {
 381     ACPI_WALK_STATE         *WalkState;
 382     ACPI_OPERAND_OBJECT     *ObjDesc;
 383     ACPI_NAMESPACE_NODE     *Node;
 384     ACPI_PARSE_OBJECT       *RootOp;
 385     ACPI_PARSE_OBJECT       *Op;
 386     const ACPI_OPCODE_INFO  *OpInfo;
 387     UINT32                  NumOps = 0;
 388     UINT32                  NumOperands = 0;
 389     UINT32                  NumOperators = 0;
 390     UINT32                  NumRemainingOps = 0;
 391     UINT32                  NumRemainingOperands = 0;
 392     UINT32                  NumRemainingOperators = 0;
 393     BOOLEAN                 CountRemaining = FALSE;
 394
 395
 396     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
 397     if (!WalkState)
 398     {
 399         AcpiOsPrintf ("There is no method currently executing\n");
 400         return;
 401     }
 402
 403     ObjDesc = WalkState->MethodDesc;
 404     Node    = WalkState->MethodNode;
 405
 406     AcpiOsPrintf ("Currently executing control method is [%4.4s]\n",
 407             AcpiUtGetNodeName (Node));
 408     AcpiOsPrintf ("%X Arguments, SyncLevel = %X\n",
 409             (UINT32) ObjDesc->Method.ParamCount,
 410             (UINT32) ObjDesc->Method.SyncLevel);
 411
 412
 413     RootOp = StartOp;
 414     while (RootOp->Common.Parent)
 415     {
 416         RootOp = RootOp->Common.Parent;
 417     }
 418
 419     Op = RootOp;
 420
 421     while (Op)
 422     {
 423         if (Op == StartOp)
 424         {
 425             CountRemaining = TRUE;
 426         }
 427
 428         NumOps++;
 429         if (CountRemaining)
 430         {
 431             NumRemainingOps++;
 432         }
 433
 434         /* Decode the opcode */
 435
 436         OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 437         switch (OpInfo->Class)
 438         {
 439         case AML_CLASS_ARGUMENT:
 440             if (CountRemaining)
 441             {
 442                 NumRemainingOperands++;
 443             }
 444
 445             NumOperands++;
 446             break;
 447
 448         case AML_CLASS_UNKNOWN:
 449             /* Bad opcode or ASCII character */
 450
 451             continue;
 452
 453         default:
 454             if (CountRemaining)
 455             {
 456                 NumRemainingOperators++;
 457             }
 458
 459             NumOperators++;
 460             break;
 461         }
 462
 463         Op = AcpiPsGetDepthNext (StartOp, Op);
 464     }
 465
 466     AcpiOsPrintf (
 467         "Method contains:       %X AML Opcodes - %X Operators, %X Operands\n",
 468         NumOps, NumOperators, NumOperands);
 469
 470     AcpiOsPrintf (
 471         "Remaining to execute:  %X AML Opcodes - %X Operators, %X Operands\n",
 472         NumRemainingOps, NumRemainingOperators, NumRemainingOperands);
 473 }
 474
 475
 476 /*******************************************************************************
 477  *
 478  * FUNCTION:    AcpiDbDisplayLocals
 479  *
 480  * PARAMETERS:  None
 481  *
 482  * RETURN:      None
 483  *
 484  * DESCRIPTION: Display all locals for the currently running control method
 485  *
 486  ******************************************************************************/
 487
 488 void
 489 AcpiDbDisplayLocals (
 490     void)
 491 {
 492     ACPI_WALK_STATE         *WalkState;
 493
 494
 495     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
 496     if (!WalkState)
 497     {
 498         AcpiOsPrintf ("There is no method currently executing\n");
 499         return;
 500     }
 501
 502     AcpiDmDisplayLocals (WalkState);
 503 }
 504
 505
 506 /*******************************************************************************
 507  *
 508  * FUNCTION:    AcpiDbDisplayArguments
 509  *
 510  * PARAMETERS:  None
 511  *
 512  * RETURN:      None
 513  *
 514  * DESCRIPTION: Display all arguments for the currently running control method
 515  *
 516  ******************************************************************************/
 517
 518 void
 519 AcpiDbDisplayArguments (
 520     void)
 521 {
 522     ACPI_WALK_STATE         *WalkState;
 523
 524
 525     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
 526     if (!WalkState)
 527     {
 528         AcpiOsPrintf ("There is no method currently executing\n");
 529         return;
 530     }
 531
 532     AcpiDmDisplayArguments (WalkState);
 533 }
 534
 535
 536 /*******************************************************************************
 537  *
 538  * FUNCTION:    AcpiDbDisplayResults
 539  *
 540  * PARAMETERS:  None
 541  *
 542  * RETURN:      None
 543  *
 544  * DESCRIPTION: Display current contents of a method result stack
 545  *
 546  ******************************************************************************/
 547
 548 void
 549 AcpiDbDisplayResults (
 550     void)
 551 {
 552     UINT32                  i;
 553     ACPI_WALK_STATE         *WalkState;
 554     ACPI_OPERAND_OBJECT     *ObjDesc;
 555     UINT32                  ResultCount = 0;
 556     ACPI_NAMESPACE_NODE     *Node;
 557     ACPI_GENERIC_STATE      *Frame;
 558     UINT32                  Index; /* Index onto current frame */
 559
 560
 561     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
 562     if (!WalkState)
 563     {
 564         AcpiOsPrintf ("There is no method currently executing\n");
 565         return;
 566     }
 567
 568     ObjDesc = WalkState->MethodDesc;
 569     Node    = WalkState->MethodNode;
 570
 571     if (WalkState->Results)
 572     {
 573         ResultCount = WalkState->ResultCount;
 574     }
 575
 576     AcpiOsPrintf ("Method [%4.4s] has %X stacked result objects\n",
 577             AcpiUtGetNodeName (Node), ResultCount);
 578
 579     /* From the top element of result stack */
 580
 581     Frame = WalkState->Results;
 582     Index = (ResultCount - 1) % ACPI_RESULTS_FRAME_OBJ_NUM;
 583
 584     for (i = 0; i < ResultCount; i++)
 585     {
 586         ObjDesc = Frame->Results.ObjDesc[Index];
 587         AcpiOsPrintf ("Result%u: ", i);
 588         AcpiDmDisplayInternalObject (ObjDesc, WalkState);
 589         if (Index == 0)
 590         {
 591             Frame = Frame->Results.Next;
 592             Index = ACPI_RESULTS_FRAME_OBJ_NUM;
 593         }
 594         Index--;
 595     }
 596 }
 597
 598
 599 /*******************************************************************************
 600  *
 601  * FUNCTION:    AcpiDbDisplayCallingTree
 602  *
 603  * PARAMETERS:  None
 604  *
 605  * RETURN:      None
 606  *
 607  * DESCRIPTION: Display current calling tree of nested control methods
 608  *
 609  ******************************************************************************/
 610
 611 void
 612 AcpiDbDisplayCallingTree (
 613     void)
 614 {
 615     ACPI_WALK_STATE         *WalkState;
 616     ACPI_NAMESPACE_NODE     *Node;
 617
 618
 619     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
 620     if (!WalkState)
 621     {
 622         AcpiOsPrintf ("There is no method currently executing\n");
 623         return;
 624     }
 625
 626     Node = WalkState->MethodNode;
 627     AcpiOsPrintf ("Current Control Method Call Tree\n");
 628
 629     while (WalkState)
 630     {
 631         Node = WalkState->MethodNode;
 632
 633         AcpiOsPrintf ("    [%4.4s]\n", AcpiUtGetNodeName (Node));
 634
 635         WalkState = WalkState->Next;
 636     }
 637 }
 638
 639
 640 /*******************************************************************************
 641  *
 642  * FUNCTION:    AcpiDbDisplayObjectType
 643  *
 644  * PARAMETERS:  ObjectArg       - User entered NS node handle
 645  *
 646  * RETURN:      None
 647  *
 648  * DESCRIPTION: Display type of an arbitrary NS node
 649  *
 650  ******************************************************************************/
 651
 652 void
 653 AcpiDbDisplayObjectType (
 654     char                    *ObjectArg)
 655 {
 656     ACPI_HANDLE             Handle;
 657     ACPI_DEVICE_INFO        *Info;
 658     ACPI_STATUS             Status;
 659     UINT32                  i;
 660
 661
 662     Handle = ACPI_TO_POINTER (ACPI_STRTOUL (ObjectArg, NULL, 16));
 663
 664     Status = AcpiGetObjectInfo (Handle, &Info);
 665     if (ACPI_FAILURE (Status))
 666     {
 667         AcpiOsPrintf ("Could not get object info, %s\n",
 668             AcpiFormatException (Status));
 669         return;
 670     }
 671
 672     AcpiOsPrintf ("ADR: %8.8X%8.8X, STA: %8.8X, Flags: %X\n",
 673         ACPI_FORMAT_UINT64 (Info->Address),
 674         Info->CurrentStatus, Info->Flags);
 675
 676     AcpiOsPrintf ("S1D-%2.2X S2D-%2.2X S3D-%2.2X S4D-%2.2X\n",
 677         Info->HighestDstates[0], Info->HighestDstates[1],
 678         Info->HighestDstates[2], Info->HighestDstates[3]);
 679
 680     AcpiOsPrintf ("S0W-%2.2X S1W-%2.2X S2W-%2.2X S3W-%2.2X S4W-%2.2X\n",
 681         Info->LowestDstates[0], Info->LowestDstates[1],
 682         Info->LowestDstates[2], Info->LowestDstates[3],
 683         Info->LowestDstates[4]);
 684
 685     if (Info->Valid & ACPI_VALID_HID)
 686     {
 687         AcpiOsPrintf ("HID: %s\n", Info->HardwareId.String);
 688     }
 689     if (Info->Valid & ACPI_VALID_UID)
 690     {
 691         AcpiOsPrintf ("UID: %s\n", Info->UniqueId.String);
 692     }
 693     if (Info->Valid & ACPI_VALID_CID)
 694     {
 695         for (i = 0; i < Info->CompatibleIdList.Count; i++)
 696         {
 697             AcpiOsPrintf ("CID %u: %s\n", i,
 698                 Info->CompatibleIdList.Ids[i].String);
 699         }
 700     }
 701
 702     ACPI_FREE (Info);
 703 }
 704
 705
 706 /*******************************************************************************
 707  *
 708  * FUNCTION:    AcpiDbDisplayResultObject
 709  *
 710  * PARAMETERS:  ObjDesc         - Object to be displayed
 711  *              WalkState       - Current walk state
 712  *
 713  * RETURN:      None
 714  *
 715  * DESCRIPTION: Display the result of an AML opcode
 716  *
 717  * Note: Curently only displays the result object if we are single stepping.
 718  * However, this output may be useful in other contexts and could be enabled
 719  * to do so if needed.
 720  *
 721  ******************************************************************************/
 722
 723 void
 724 AcpiDbDisplayResultObject (
 725     ACPI_OPERAND_OBJECT     *ObjDesc,
 726     ACPI_WALK_STATE         *WalkState)
 727 {
 728
 729     /* Only display if single stepping */
 730
 731     if (!AcpiGbl_CmSingleStep)
 732     {
 733         return;
 734     }
 735
 736     AcpiOsPrintf ("ResultObj: ");
 737     AcpiDmDisplayInternalObject (ObjDesc, WalkState);
 738     AcpiOsPrintf ("\n");
 739 }
 740
 741
 742 /*******************************************************************************
 743  *
 744  * FUNCTION:    AcpiDbDisplayArgumentObject
 745  *
 746  * PARAMETERS:  ObjDesc         - Object to be displayed
 747  *              WalkState       - Current walk state
 748  *
 749  * RETURN:      None
 750  *
 751  * DESCRIPTION: Display the result of an AML opcode
 752  *
 753  ******************************************************************************/
 754
 755 void
 756 AcpiDbDisplayArgumentObject (
 757     ACPI_OPERAND_OBJECT     *ObjDesc,
 758     ACPI_WALK_STATE         *WalkState)
 759 {
 760
 761     if (!AcpiGbl_CmSingleStep)
 762     {
 763         return;
 764     }
 765
 766     AcpiOsPrintf ("ArgObj:    ");
 767     AcpiDmDisplayInternalObject (ObjDesc, WalkState);
 768 }
 769
 770
 771 /*******************************************************************************
 772  *
 773  * FUNCTION:    AcpiDbDisplayGpes
 774  *
 775  * PARAMETERS:  None
 776  *
 777  * RETURN:      None
 778  *
 779  * DESCRIPTION: Display the current GPE structures
 780  *
 781  ******************************************************************************/
 782
 783 void
 784 AcpiDbDisplayGpes (
 785     void)
 786 {
 787     ACPI_GPE_BLOCK_INFO     *GpeBlock;
 788     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo;
 789     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 790     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
 791     char                    *GpeType;
 792     UINT32                  GpeIndex;
 793     UINT32                  Block = 0;
 794     UINT32                  i;
 795     UINT32                  j;
 796     char                    Buffer[80];
 797     ACPI_BUFFER             RetBuf;
 798     ACPI_STATUS             Status;
 799
 800
 801     RetBuf.Length = sizeof (Buffer);
 802     RetBuf.Pointer = Buffer;
 803
 804     Block = 0;
 805
 806     /* Walk the GPE lists */
 807
 808     GpeXruptInfo = AcpiGbl_GpeXruptListHead;
 809     while (GpeXruptInfo)
 810     {
 811         GpeBlock = GpeXruptInfo->GpeBlockListHead;
 812         while (GpeBlock)
 813         {
 814             Status = AcpiGetName (GpeBlock->Node, ACPI_FULL_PATHNAME, &RetBuf);
 815             if (ACPI_FAILURE (Status))
 816             {
 817                 AcpiOsPrintf ("Could not convert name to pathname\n");
 818             }
 819
 820             if (GpeBlock->Node == AcpiGbl_FadtGpeDevice)
 821             {
 822                 GpeType = "FADT-defined GPE block";
 823             }
 824             else
 825             {
 826                 GpeType = "GPE Block Device";
 827             }
 828
 829             AcpiOsPrintf ("\nBlock %u - Info %p  DeviceNode %p [%s] - %s\n",
 830                 Block, GpeBlock, GpeBlock->Node, Buffer, GpeType);
 831
 832             AcpiOsPrintf ("    Registers:    %u (%u GPEs)\n",
 833                 GpeBlock->RegisterCount, GpeBlock->GpeCount);
 834
 835             AcpiOsPrintf ("    GPE range:    0x%X to 0x%X on interrupt %u\n",
 836                 GpeBlock->BlockBaseNumber,
 837                 GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1),
 838                 GpeXruptInfo->InterruptNumber);
 839
 840             AcpiOsPrintf (
 841                 "    RegisterInfo: %p  Status %8.8X%8.8X Enable %8.8X%8.8X\n",
 842                 GpeBlock->RegisterInfo,
 843                 ACPI_FORMAT_UINT64 (GpeBlock->RegisterInfo->StatusAddress.Address),
 844                 ACPI_FORMAT_UINT64 (GpeBlock->RegisterInfo->EnableAddress.Address));
 845
 846             AcpiOsPrintf ("    EventInfo:    %p\n", GpeBlock->EventInfo);
 847
 848             /* Examine each GPE Register within the block */
 849
 850             for (i = 0; i < GpeBlock->RegisterCount; i++)
 851             {
 852                 GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
 853
 854                 AcpiOsPrintf (
 855                     "    Reg %u: (GPE %.2X-%.2X)  RunEnable %2.2X WakeEnable %2.2X"
 856                     " Status %8.8X%8.8X Enable %8.8X%8.8X\n",
 857                     i, GpeRegisterInfo->BaseGpeNumber,
 858                     GpeRegisterInfo->BaseGpeNumber + (ACPI_GPE_REGISTER_WIDTH - 1),
 859                     GpeRegisterInfo->EnableForRun,
 860                     GpeRegisterInfo->EnableForWake,
 861                     ACPI_FORMAT_UINT64 (GpeRegisterInfo->StatusAddress.Address),
 862                     ACPI_FORMAT_UINT64 (GpeRegisterInfo->EnableAddress.Address));
 863
 864                 /* Now look at the individual GPEs in this byte register */
 865
 866                 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
 867                 {
 868                     GpeIndex = (i * ACPI_GPE_REGISTER_WIDTH) + j;
 869                     GpeEventInfo = &GpeBlock->EventInfo[GpeIndex];
 870
 871                     if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) ==
 872                         ACPI_GPE_DISPATCH_NONE)
 873                     {
 874                         /* This GPE is not used (no method or handler), ignore it */
 875
 876                         continue;
 877                     }
 878
 879                     AcpiOsPrintf (
 880                         "        GPE %.2X: %p  RunRefs %2.2X Flags %2.2X (",
 881                         GpeBlock->BlockBaseNumber + GpeIndex, GpeEventInfo,
 882                         GpeEventInfo->RuntimeCount, GpeEventInfo->Flags);
 883
 884                     /* Decode the flags byte */
 885
 886                     if (GpeEventInfo->Flags & ACPI_GPE_LEVEL_TRIGGERED)
 887                     {
 888                         AcpiOsPrintf ("Level, ");
 889                     }
 890                     else
 891                     {
 892                         AcpiOsPrintf ("Edge,  ");
 893                     }
 894
 895                     if (GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE)
 896                     {
 897                         AcpiOsPrintf ("CanWake, ");
 898                     }
 899                     else
 900                     {
 901                         AcpiOsPrintf ("RunOnly, ");
 902                     }
 903
 904                     switch (GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK)
 905                     {
 906                     case ACPI_GPE_DISPATCH_NONE:
 907                         AcpiOsPrintf ("NotUsed");
 908                         break;
 909                     case ACPI_GPE_DISPATCH_METHOD:
 910                         AcpiOsPrintf ("Method");
 911                         break;
 912                     case ACPI_GPE_DISPATCH_HANDLER:
 913                         AcpiOsPrintf ("Handler");
 914                         break;
 915                     case ACPI_GPE_DISPATCH_NOTIFY:
 916                         AcpiOsPrintf ("Notify");
 917                         break;
 918                     default:
 919                         AcpiOsPrintf ("UNKNOWN: %X",
 920                             GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK);
 921                         break;
 922                     }
 923
 924                     AcpiOsPrintf (")\n");
 925                 }
 926             }
 927             Block++;
 928             GpeBlock = GpeBlock->Next;
 929         }
 930         GpeXruptInfo = GpeXruptInfo->Next;
 931     }
 932 }
 933
 934
 935 /*******************************************************************************
 936  *
 937  * FUNCTION:    AcpiDbDisplayHandlers
 938  *
 939  * PARAMETERS:  None
 940  *
 941  * RETURN:      None
 942  *
 943  * DESCRIPTION: Display the currently installed global handlers
 944  *
 945  ******************************************************************************/
 946
 947 void
 948 AcpiDbDisplayHandlers (
 949     void)
 950 {
 951     ACPI_OPERAND_OBJECT     *ObjDesc;
 952     ACPI_OPERAND_OBJECT     *HandlerObj;
 953     ACPI_ADR_SPACE_TYPE     SpaceId;
 954     UINT32                  i;
 955
 956
 957     /* Operation region handlers */
 958
 959     AcpiOsPrintf ("\nOperation Region Handlers:\n");
 960
 961     ObjDesc = AcpiNsGetAttachedObject (AcpiGbl_RootNode);
 962     if (ObjDesc)
 963     {
 964         for (i = 0; i < ACPI_ARRAY_LENGTH (AcpiGbl_SpaceIdList); i++)
 965         {
 966             SpaceId = AcpiGbl_SpaceIdList[i];
 967             HandlerObj = ObjDesc->Device.Handler;
 968
 969             AcpiOsPrintf (ACPI_PREDEFINED_PREFIX,
 970                 AcpiUtGetRegionName ((UINT8) SpaceId), SpaceId);
 971
 972             while (HandlerObj)
 973             {
 974                 if (i == HandlerObj->AddressSpace.SpaceId)
 975                 {
 976                     AcpiOsPrintf (ACPI_HANDLER_PRESENT_STRING,
 977                         (HandlerObj->AddressSpace.HandlerFlags &
 978                             ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) ? "Default" : "User",
 979                         HandlerObj->AddressSpace.Handler);
 980                     goto FoundHandler;
 981                 }
 982
 983                 HandlerObj = HandlerObj->AddressSpace.Next;
 984             }
 985
 986             /* There is no handler for this SpaceId */
 987
 988             AcpiOsPrintf ("None\n");
 989
 990         FoundHandler:;
 991         }
 992     }
 993
 994     /* Fixed event handlers */
 995
 996     AcpiOsPrintf ("\nFixed Event Handlers:\n");
 997
 998     for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++)
 999     {
1000         AcpiOsPrintf (ACPI_PREDEFINED_PREFIX, AcpiUtGetEventName (i), i);
1001         if (AcpiGbl_FixedEventHandlers[i].Handler)
1002         {
1003             AcpiOsPrintf (ACPI_HANDLER_PRESENT_STRING, "User",
1004                 AcpiGbl_FixedEventHandlers[i].Handler);
1005         }
1006         else
1007         {
1008             AcpiOsPrintf (ACPI_HANDLER_NOT_PRESENT_STRING, "None");
1009         }
1010     }
1011
1012     /* Miscellaneous global handlers */
1013
1014     AcpiOsPrintf ("\nMiscellaneous Global Handlers:\n");
1015
1016     for (i = 0; i < ACPI_ARRAY_LENGTH (AcpiGbl_HandlerList); i++)
1017     {
1018         AcpiOsPrintf (ACPI_HANDLER_NAME_STRING, AcpiGbl_HandlerList[i].Name);
1019         if (AcpiGbl_HandlerList[i].Handler)
1020         {
1021             AcpiOsPrintf (ACPI_HANDLER_PRESENT_STRING, "User",
1022                 AcpiGbl_HandlerList[i].Handler);
1023         }
1024         else
1025         {
1026             AcpiOsPrintf (ACPI_HANDLER_NOT_PRESENT_STRING, "None");
1027         }
1028     }
1029 }
1030
1031 #endif /* ACPI_DEBUGGER */