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