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

   1 /*******************************************************************************
   2  *
   3  * Module Name: dbdisply - debug display commands
   4  *
   5  ******************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights.  You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code.  No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision.  In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change.  Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee.  Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution.  In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government.  In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116
 117 #include <contrib/dev/acpica/include/acpi.h>
 118 #include <contrib/dev/acpica/include/accommon.h>
 119 #include <contrib/dev/acpica/include/amlcode.h>
 120 #include <contrib/dev/acpica/include/acdispat.h>
 121 #include <contrib/dev/acpica/include/acnamesp.h>
 122 #include <contrib/dev/acpica/include/acparser.h>
 123 #include <contrib/dev/acpica/include/acinterp.h>
 124 #include <contrib/dev/acpica/include/acdebug.h>
 125 #include <contrib/dev/acpica/include/acdisasm.h>
 126
 127
 128 #ifdef ACPI_DEBUGGER
 129
 130 #define _COMPONENT          ACPI_CA_DEBUGGER
 131         ACPI_MODULE_NAME    ("dbdisply")
 132
 133 /* Local prototypes */
 134
 135 static void
 136 AcpiDbDumpParserDescriptor (
 137     ACPI_PARSE_OBJECT       *Op);
 138
 139 static void *
 140 AcpiDbGetPointer (
 141     void                    *Target);
 142
 143
 144 /*******************************************************************************
 145  *
 146  * FUNCTION:    AcpiDbGetPointer
 147  *
 148  * PARAMETERS:  Target          - Pointer to string to be converted
 149  *
 150  * RETURN:      Converted pointer
 151  *
 152  * DESCRIPTION: Convert an ascii pointer value to a real value
 153  *
 154  ******************************************************************************/
 155
 156 static void *
 157 AcpiDbGetPointer (
 158     void                    *Target)
 159 {
 160     void                    *ObjPtr;
 161
 162
 163     ObjPtr = ACPI_TO_POINTER (ACPI_STRTOUL (Target, NULL, 16));
 164     return (ObjPtr);
 165 }
 166
 167
 168 /*******************************************************************************
 169  *
 170  * FUNCTION:    AcpiDbDumpParserDescriptor
 171  *
 172  * PARAMETERS:  Op              - A parser Op descriptor
 173  *
 174  * RETURN:      None
 175  *
 176  * DESCRIPTION: Display a formatted parser object
 177  *
 178  ******************************************************************************/
 179
 180 static void
 181 AcpiDbDumpParserDescriptor (
 182     ACPI_PARSE_OBJECT       *Op)
 183 {
 184     const ACPI_OPCODE_INFO  *Info;
 185
 186
 187     Info = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 188
 189     AcpiOsPrintf ("Parser Op Descriptor:\n");
 190     AcpiOsPrintf ("%20.20s : %4.4X\n", "Opcode", Op->Common.AmlOpcode);
 191
 192     ACPI_DEBUG_ONLY_MEMBERS (AcpiOsPrintf ("%20.20s : %s\n", "Opcode Name",
 193         Info->Name));
 194
 195     AcpiOsPrintf ("%20.20s : %p\n", "Value/ArgList", Op->Common.Value.Arg);
 196     AcpiOsPrintf ("%20.20s : %p\n", "Parent", Op->Common.Parent);
 197     AcpiOsPrintf ("%20.20s : %p\n", "NextOp", Op->Common.Next);
 198 }
 199
 200
 201 /*******************************************************************************
 202  *
 203  * FUNCTION:    AcpiDbDecodeAndDisplayObject
 204  *
 205  * PARAMETERS:  Target          - String with object to be displayed.  Names
 206  *                                and hex pointers are supported.
 207  *              OutputType      - Byte, Word, Dword, or Qword (B|W|D|Q)
 208  *
 209  * RETURN:      None
 210  *
 211  * DESCRIPTION: Display a formatted ACPI object
 212  *
 213  ******************************************************************************/
 214
 215 void
 216 AcpiDbDecodeAndDisplayObject (
 217     char                    *Target,
 218     char                    *OutputType)
 219 {
 220     void                    *ObjPtr;
 221     ACPI_NAMESPACE_NODE     *Node;
 222     ACPI_OPERAND_OBJECT     *ObjDesc;
 223     UINT32                  Display = DB_BYTE_DISPLAY;
 224     char                    Buffer[80];
 225     ACPI_BUFFER             RetBuf;
 226     ACPI_STATUS             Status;
 227     UINT32                  Size;
 228
 229
 230     if (!Target)
 231     {
 232         return;
 233     }
 234
 235     /* Decode the output type */
 236
 237     if (OutputType)
 238     {
 239         AcpiUtStrupr (OutputType);
 240         if (OutputType[0] == 'W')
 241         {
 242             Display = DB_WORD_DISPLAY;
 243         }
 244         else if (OutputType[0] == 'D')
 245         {
 246             Display = DB_DWORD_DISPLAY;
 247         }
 248         else if (OutputType[0] == 'Q')
 249         {
 250             Display = DB_QWORD_DISPLAY;
 251         }
 252     }
 253
 254     RetBuf.Length = sizeof (Buffer);
 255     RetBuf.Pointer = Buffer;
 256
 257     /* Differentiate between a number and a name */
 258
 259     if ((Target[0] >= 0x30) && (Target[0] <= 0x39))
 260     {
 261         ObjPtr = AcpiDbGetPointer (Target);
 262         if (!AcpiOsReadable (ObjPtr, 16))
 263         {
 264             AcpiOsPrintf ("Address %p is invalid in this address space\n",
 265                 ObjPtr);
 266             return;
 267         }
 268
 269         /* Decode the object type */
 270
 271         switch (ACPI_GET_DESCRIPTOR_TYPE (ObjPtr))
 272         {
 273         case ACPI_DESC_TYPE_NAMED:
 274
 275             /* This is a namespace Node */
 276
 277             if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_NAMESPACE_NODE)))
 278             {
 279                 AcpiOsPrintf (
 280                     "Cannot read entire Named object at address %p\n", ObjPtr);
 281                 return;
 282             }
 283
 284             Node = ObjPtr;
 285             goto DumpNode;
 286
 287
 288         case ACPI_DESC_TYPE_OPERAND:
 289
 290             /* This is a ACPI OPERAND OBJECT */
 291
 292             if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_OPERAND_OBJECT)))
 293             {
 294                 AcpiOsPrintf ("Cannot read entire ACPI object at address %p\n",
 295                     ObjPtr);
 296                 return;
 297             }
 298
 299             AcpiUtDumpBuffer (ObjPtr, sizeof (ACPI_OPERAND_OBJECT), Display,
 300                 ACPI_UINT32_MAX);
 301             AcpiExDumpObjectDescriptor (ObjPtr, 1);
 302             break;
 303
 304
 305         case ACPI_DESC_TYPE_PARSER:
 306
 307             /* This is a Parser Op object */
 308
 309             if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_PARSE_OBJECT)))
 310             {
 311                 AcpiOsPrintf (
 312                     "Cannot read entire Parser object at address %p\n", ObjPtr);
 313                 return;
 314             }
 315
 316             AcpiUtDumpBuffer (ObjPtr, sizeof (ACPI_PARSE_OBJECT), Display,
 317                 ACPI_UINT32_MAX);
 318             AcpiDbDumpParserDescriptor ((ACPI_PARSE_OBJECT *) ObjPtr);
 319             break;
 320
 321
 322         default:
 323
 324             /* Is not a recognizeable object */
 325
 326             Size = 16;
 327             if (AcpiOsReadable (ObjPtr, 64))
 328             {
 329                 Size = 64;
 330             }
 331
 332             /* Just dump some memory */
 333
 334             AcpiUtDumpBuffer (ObjPtr, Size, Display, ACPI_UINT32_MAX);
 335             break;
 336         }
 337
 338         return;
 339     }
 340
 341     /* The parameter is a name string that must be resolved to a Named obj */
 342
 343     Node = AcpiDbLocalNsLookup (Target);
 344     if (!Node)
 345     {
 346         return;
 347     }
 348
 349
 350 DumpNode:
 351     /* Now dump the NS node */
 352
 353     Status = AcpiGetName (Node, ACPI_FULL_PATHNAME, &RetBuf);
 354     if (ACPI_FAILURE (Status))
 355     {
 356         AcpiOsPrintf ("Could not convert name to pathname\n");
 357     }
 358
 359     else
 360     {
 361         AcpiOsPrintf ("Object (%p) Pathname:  %s\n",
 362             Node, (char *) RetBuf.Pointer);
 363     }
 364
 365     if (!AcpiOsReadable (Node, sizeof (ACPI_NAMESPACE_NODE)))
 366     {
 367         AcpiOsPrintf ("Invalid Named object at address %p\n", Node);
 368         return;
 369     }
 370
 371     AcpiUtDumpBuffer ((void *) Node, sizeof (ACPI_NAMESPACE_NODE),
 372         Display, ACPI_UINT32_MAX);
 373     AcpiExDumpNamespaceNode (Node, 1);
 374
 375     ObjDesc = AcpiNsGetAttachedObject (Node);
 376     if (ObjDesc)
 377     {
 378         AcpiOsPrintf ("\nAttached Object (%p):\n", ObjDesc);
 379         if (!AcpiOsReadable (ObjDesc, sizeof (ACPI_OPERAND_OBJECT)))
 380         {
 381             AcpiOsPrintf ("Invalid internal ACPI Object at address %p\n",
 382                 ObjDesc);
 383             return;
 384         }
 385
 386         AcpiUtDumpBuffer ((void *) ObjDesc, sizeof (ACPI_OPERAND_OBJECT),
 387             Display, ACPI_UINT32_MAX);
 388         AcpiExDumpObjectDescriptor (ObjDesc, 1);
 389     }
 390 }
 391
 392
 393 /*******************************************************************************
 394  *
 395  * FUNCTION:    AcpiDbDisplayMethodInfo
 396  *
 397  * PARAMETERS:  StartOp         - Root of the control method parse tree
 398  *
 399  * RETURN:      None
 400  *
 401  * DESCRIPTION: Display information about the current method
 402  *
 403  ******************************************************************************/
 404
 405 void
 406 AcpiDbDisplayMethodInfo (
 407     ACPI_PARSE_OBJECT       *StartOp)
 408 {
 409     ACPI_WALK_STATE         *WalkState;
 410     ACPI_OPERAND_OBJECT     *ObjDesc;
 411     ACPI_NAMESPACE_NODE     *Node;
 412     ACPI_PARSE_OBJECT       *RootOp;
 413     ACPI_PARSE_OBJECT       *Op;
 414     const ACPI_OPCODE_INFO  *OpInfo;
 415     UINT32                  NumOps = 0;
 416     UINT32                  NumOperands = 0;
 417     UINT32                  NumOperators = 0;
 418     UINT32                  NumRemainingOps = 0;
 419     UINT32                  NumRemainingOperands = 0;
 420     UINT32                  NumRemainingOperators = 0;
 421     BOOLEAN                 CountRemaining = FALSE;
 422
 423
 424     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
 425     if (!WalkState)
 426     {
 427         AcpiOsPrintf ("There is no method currently executing\n");
 428         return;
 429     }
 430
 431     ObjDesc = WalkState->MethodDesc;
 432     Node    = WalkState->MethodNode;
 433
 434     AcpiOsPrintf ("Currently executing control method is [%4.4s]\n",
 435             AcpiUtGetNodeName (Node));
 436     AcpiOsPrintf ("%X Arguments, SyncLevel = %X\n",
 437             (UINT32) ObjDesc->Method.ParamCount,
 438             (UINT32) ObjDesc->Method.SyncLevel);
 439
 440
 441     RootOp = StartOp;
 442     while (RootOp->Common.Parent)
 443     {
 444         RootOp = RootOp->Common.Parent;
 445     }
 446
 447     Op = RootOp;
 448
 449     while (Op)
 450     {
 451         if (Op == StartOp)
 452         {
 453             CountRemaining = TRUE;
 454         }
 455
 456         NumOps++;
 457         if (CountRemaining)
 458         {
 459             NumRemainingOps++;
 460         }
 461
 462         /* Decode the opcode */
 463
 464         OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 465         switch (OpInfo->Class)
 466         {
 467         case AML_CLASS_ARGUMENT:
 468             if (CountRemaining)
 469             {
 470                 NumRemainingOperands++;
 471             }
 472
 473             NumOperands++;
 474             break;
 475
 476         case AML_CLASS_UNKNOWN:
 477             /* Bad opcode or ASCII character */
 478
 479             continue;
 480
 481         default:
 482             if (CountRemaining)
 483             {
 484                 NumRemainingOperators++;
 485             }
 486
 487             NumOperators++;
 488             break;
 489         }
 490
 491         Op = AcpiPsGetDepthNext (StartOp, Op);
 492     }
 493
 494     AcpiOsPrintf (
 495         "Method contains:       %X AML Opcodes - %X Operators, %X Operands\n",
 496         NumOps, NumOperators, NumOperands);
 497
 498     AcpiOsPrintf (
 499         "Remaining to execute:  %X AML Opcodes - %X Operators, %X Operands\n",
 500         NumRemainingOps, NumRemainingOperators, NumRemainingOperands);
 501 }
 502
 503
 504 /*******************************************************************************
 505  *
 506  * FUNCTION:    AcpiDbDisplayLocals
 507  *
 508  * PARAMETERS:  None
 509  *
 510  * RETURN:      None
 511  *
 512  * DESCRIPTION: Display all locals for the currently running control method
 513  *
 514  ******************************************************************************/
 515
 516 void
 517 AcpiDbDisplayLocals (
 518     void)
 519 {
 520     ACPI_WALK_STATE         *WalkState;
 521
 522
 523     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
 524     if (!WalkState)
 525     {
 526         AcpiOsPrintf ("There is no method currently executing\n");
 527         return;
 528     }
 529
 530     AcpiDmDisplayLocals (WalkState);
 531 }
 532
 533
 534 /*******************************************************************************
 535  *
 536  * FUNCTION:    AcpiDbDisplayArguments
 537  *
 538  * PARAMETERS:  None
 539  *
 540  * RETURN:      None
 541  *
 542  * DESCRIPTION: Display all arguments for the currently running control method
 543  *
 544  ******************************************************************************/
 545
 546 void
 547 AcpiDbDisplayArguments (
 548     void)
 549 {
 550     ACPI_WALK_STATE         *WalkState;
 551
 552
 553     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
 554     if (!WalkState)
 555     {
 556         AcpiOsPrintf ("There is no method currently executing\n");
 557         return;
 558     }
 559
 560     AcpiDmDisplayArguments (WalkState);
 561 }
 562
 563
 564 /*******************************************************************************
 565  *
 566  * FUNCTION:    AcpiDbDisplayResults
 567  *
 568  * PARAMETERS:  None
 569  *
 570  * RETURN:      None
 571  *
 572  * DESCRIPTION: Display current contents of a method result stack
 573  *
 574  ******************************************************************************/
 575
 576 void
 577 AcpiDbDisplayResults (
 578     void)
 579 {
 580     UINT32                  i;
 581     ACPI_WALK_STATE         *WalkState;
 582     ACPI_OPERAND_OBJECT     *ObjDesc;
 583     UINT32                  ResultCount = 0;
 584     ACPI_NAMESPACE_NODE     *Node;
 585     ACPI_GENERIC_STATE      *Frame;
 586     UINT32                  Index; /* Index onto current frame */
 587
 588
 589     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
 590     if (!WalkState)
 591     {
 592         AcpiOsPrintf ("There is no method currently executing\n");
 593         return;
 594     }
 595
 596     ObjDesc = WalkState->MethodDesc;
 597     Node    = WalkState->MethodNode;
 598
 599     if (WalkState->Results)
 600     {
 601         ResultCount = WalkState->ResultCount;
 602     }
 603
 604     AcpiOsPrintf ("Method [%4.4s] has %X stacked result objects\n",
 605             AcpiUtGetNodeName (Node), ResultCount);
 606
 607     /* From the top element of result stack */
 608
 609     Frame = WalkState->Results;
 610     Index = (ResultCount - 1) % ACPI_RESULTS_FRAME_OBJ_NUM;
 611
 612     for (i = 0; i < ResultCount; i++)
 613     {
 614         ObjDesc = Frame->Results.ObjDesc[Index];
 615         AcpiOsPrintf ("Result%d: ", i);
 616         AcpiDmDisplayInternalObject (ObjDesc, WalkState);
 617         if (Index == 0)
 618         {
 619             Frame = Frame->Results.Next;
 620             Index = ACPI_RESULTS_FRAME_OBJ_NUM;
 621         }
 622         Index--;
 623     }
 624 }
 625
 626
 627 /*******************************************************************************
 628  *
 629  * FUNCTION:    AcpiDbDisplayCallingTree
 630  *
 631  * PARAMETERS:  None
 632  *
 633  * RETURN:      None
 634  *
 635  * DESCRIPTION: Display current calling tree of nested control methods
 636  *
 637  ******************************************************************************/
 638
 639 void
 640 AcpiDbDisplayCallingTree (
 641     void)
 642 {
 643     ACPI_WALK_STATE         *WalkState;
 644     ACPI_NAMESPACE_NODE     *Node;
 645
 646
 647     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
 648     if (!WalkState)
 649     {
 650         AcpiOsPrintf ("There is no method currently executing\n");
 651         return;
 652     }
 653
 654     Node = WalkState->MethodNode;
 655     AcpiOsPrintf ("Current Control Method Call Tree\n");
 656
 657     while (WalkState)
 658     {
 659         Node = WalkState->MethodNode;
 660
 661         AcpiOsPrintf ("    [%4.4s]\n", AcpiUtGetNodeName (Node));
 662
 663         WalkState = WalkState->Next;
 664     }
 665 }
 666
 667
 668 /*******************************************************************************
 669  *
 670  * FUNCTION:    AcpiDbDisplayObjectType
 671  *
 672  * PARAMETERS:  ObjectArg       - User entered NS node handle
 673  *
 674  * RETURN:      None
 675  *
 676  * DESCRIPTION: Display type of an arbitrary NS node
 677  *
 678  ******************************************************************************/
 679
 680 void
 681 AcpiDbDisplayObjectType (
 682     char                    *ObjectArg)
 683 {
 684     ACPI_HANDLE             Handle;
 685     ACPI_DEVICE_INFO        *Info;
 686     ACPI_STATUS             Status;
 687     UINT32                  i;
 688
 689
 690     Handle = ACPI_TO_POINTER (ACPI_STRTOUL (ObjectArg, NULL, 16));
 691
 692     Status = AcpiGetObjectInfo (Handle, &Info);
 693     if (ACPI_FAILURE (Status))
 694     {
 695         AcpiOsPrintf ("Could not get object info, %s\n",
 696             AcpiFormatException (Status));
 697         return;
 698     }
 699
 700     AcpiOsPrintf ("ADR: %8.8X%8.8X, STA: %8.8X, Flags: %X\n",
 701         ACPI_FORMAT_UINT64 (Info->Address),
 702         Info->CurrentStatus, Info->Flags);
 703
 704     AcpiOsPrintf ("S1D-%2.2X S2D-%2.2X S3D-%2.2X S4D-%2.2X\n",
 705         Info->HighestDstates[0], Info->HighestDstates[1],
 706         Info->HighestDstates[2], Info->HighestDstates[3]);
 707
 708     AcpiOsPrintf ("S0W-%2.2X S1W-%2.2X S2W-%2.2X S3W-%2.2X S4W-%2.2X\n",
 709         Info->LowestDstates[0], Info->LowestDstates[1],
 710         Info->LowestDstates[2], Info->LowestDstates[3],
 711         Info->LowestDstates[4]);
 712
 713     if (Info->Valid & ACPI_VALID_HID)
 714     {
 715         AcpiOsPrintf ("HID: %s\n", Info->HardwareId.String);
 716     }
 717     if (Info->Valid & ACPI_VALID_UID)
 718     {
 719         AcpiOsPrintf ("UID: %s\n", Info->UniqueId.String);
 720     }
 721     if (Info->Valid & ACPI_VALID_CID)
 722     {
 723         for (i = 0; i < Info->CompatibleIdList.Count; i++)
 724         {
 725             AcpiOsPrintf ("CID %d: %s\n", i,
 726                 Info->CompatibleIdList.Ids[i].String);
 727         }
 728     }
 729
 730     ACPI_FREE (Info);
 731 }
 732
 733
 734 /*******************************************************************************
 735  *
 736  * FUNCTION:    AcpiDbDisplayResultObject
 737  *
 738  * PARAMETERS:  ObjDesc         - Object to be displayed
 739  *              WalkState       - Current walk state
 740  *
 741  * RETURN:      None
 742  *
 743  * DESCRIPTION: Display the result of an AML opcode
 744  *
 745  * Note: Curently only displays the result object if we are single stepping.
 746  * However, this output may be useful in other contexts and could be enabled
 747  * to do so if needed.
 748  *
 749  ******************************************************************************/
 750
 751 void
 752 AcpiDbDisplayResultObject (
 753     ACPI_OPERAND_OBJECT     *ObjDesc,
 754     ACPI_WALK_STATE         *WalkState)
 755 {
 756
 757     /* Only display if single stepping */
 758
 759     if (!AcpiGbl_CmSingleStep)
 760     {
 761         return;
 762     }
 763
 764     AcpiOsPrintf ("ResultObj: ");
 765     AcpiDmDisplayInternalObject (ObjDesc, WalkState);
 766     AcpiOsPrintf ("\n");
 767 }
 768
 769
 770 /*******************************************************************************
 771  *
 772  * FUNCTION:    AcpiDbDisplayArgumentObject
 773  *
 774  * PARAMETERS:  ObjDesc         - Object to be displayed
 775  *              WalkState       - Current walk state
 776  *
 777  * RETURN:      None
 778  *
 779  * DESCRIPTION: Display the result of an AML opcode
 780  *
 781  ******************************************************************************/
 782
 783 void
 784 AcpiDbDisplayArgumentObject (
 785     ACPI_OPERAND_OBJECT     *ObjDesc,
 786     ACPI_WALK_STATE         *WalkState)
 787 {
 788
 789     if (!AcpiGbl_CmSingleStep)
 790     {
 791         return;
 792     }
 793
 794     AcpiOsPrintf ("ArgObj:    ");
 795     AcpiDmDisplayInternalObject (ObjDesc, WalkState);
 796 }
 797
 798
 799 /*******************************************************************************
 800  *
 801  * FUNCTION:    AcpiDbDisplayGpes
 802  *
 803  * PARAMETERS:  None
 804  *
 805  * RETURN:      None
 806  *
 807  * DESCRIPTION: Display the current GPE structures
 808  *
 809  ******************************************************************************/
 810
 811 void
 812 AcpiDbDisplayGpes (
 813     void)
 814 {
 815     ACPI_GPE_BLOCK_INFO     *GpeBlock;
 816     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo;
 817     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 818     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
 819     UINT32                  GpeIndex;
 820     UINT32                  Block = 0;
 821     UINT32                  i;
 822     UINT32                  j;
 823     char                    Buffer[80];
 824     ACPI_BUFFER             RetBuf;
 825     ACPI_STATUS             Status;
 826
 827
 828     RetBuf.Length = sizeof (Buffer);
 829     RetBuf.Pointer = Buffer;
 830
 831     Block = 0;
 832
 833     /* Walk the GPE lists */
 834
 835     GpeXruptInfo = AcpiGbl_GpeXruptListHead;
 836     while (GpeXruptInfo)
 837     {
 838         GpeBlock = GpeXruptInfo->GpeBlockListHead;
 839         while (GpeBlock)
 840         {
 841             Status = AcpiGetName (GpeBlock->Node, ACPI_FULL_PATHNAME, &RetBuf);
 842             if (ACPI_FAILURE (Status))
 843             {
 844                 AcpiOsPrintf ("Could not convert name to pathname\n");
 845             }
 846
 847             AcpiOsPrintf ("\nBlock %d - Info %p  DeviceNode %p [%s]\n",
 848                 Block, GpeBlock, GpeBlock->Node, Buffer);
 849
 850             AcpiOsPrintf ("    Registers:    %u (%u GPEs)\n",
 851                 GpeBlock->RegisterCount, GpeBlock->GpeCount);
 852
 853             AcpiOsPrintf ("    GPE range:    0x%X to 0x%X on interrupt %u\n",
 854                 GpeBlock->BlockBaseNumber,
 855                 GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1),
 856                 GpeXruptInfo->InterruptNumber);
 857
 858             AcpiOsPrintf (
 859                 "    RegisterInfo: %p  Status %8.8X%8.8X Enable %8.8X%8.8X\n",
 860                 GpeBlock->RegisterInfo,
 861                 ACPI_FORMAT_UINT64 (GpeBlock->RegisterInfo->StatusAddress.Address),
 862                 ACPI_FORMAT_UINT64 (GpeBlock->RegisterInfo->EnableAddress.Address));
 863
 864             AcpiOsPrintf ("    EventInfo:    %p\n", GpeBlock->EventInfo);
 865
 866             /* Examine each GPE Register within the block */
 867
 868             for (i = 0; i < GpeBlock->RegisterCount; i++)
 869             {
 870                 GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
 871
 872                 AcpiOsPrintf (
 873                     "    Reg %u: (GPE %.2X-%.2X)  RunEnable %2.2X WakeEnable %2.2X"
 874                     " Status %8.8X%8.8X Enable %8.8X%8.8X\n",
 875                     i, GpeRegisterInfo->BaseGpeNumber,
 876                     GpeRegisterInfo->BaseGpeNumber + (ACPI_GPE_REGISTER_WIDTH - 1),
 877                     GpeRegisterInfo->EnableForRun,
 878                     GpeRegisterInfo->EnableForWake,
 879                     ACPI_FORMAT_UINT64 (GpeRegisterInfo->StatusAddress.Address),
 880                     ACPI_FORMAT_UINT64 (GpeRegisterInfo->EnableAddress.Address));
 881
 882                 /* Now look at the individual GPEs in this byte register */
 883
 884                 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
 885                 {
 886                     GpeIndex = (i * ACPI_GPE_REGISTER_WIDTH) + j;
 887                     GpeEventInfo = &GpeBlock->EventInfo[GpeIndex];
 888
 889                     if (!(GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK))
 890                     {
 891                         /* This GPE is not used (no method or handler), ignore it */
 892
 893                         continue;
 894                     }
 895
 896                     AcpiOsPrintf (
 897                         "        GPE %.2X: %p  RunRefs %2.2X   WakeRefs %2.2X Flags %2.2X (",
 898                         GpeBlock->BlockBaseNumber + GpeIndex, GpeEventInfo,
 899                         GpeEventInfo->RuntimeCount, GpeEventInfo->WakeupCount,
 900                         GpeEventInfo->Flags);
 901
 902                     /* Decode the flags byte */
 903
 904                     if (GpeEventInfo->Flags & ACPI_GPE_LEVEL_TRIGGERED)
 905                     {
 906                         AcpiOsPrintf ("Level, ");
 907                     }
 908                     else
 909                     {
 910                         AcpiOsPrintf ("Edge,  ");
 911                     }
 912
 913                     if (GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE)
 914                     {
 915                         AcpiOsPrintf ("CanWake, ");
 916                     }
 917                     else
 918                     {
 919                         AcpiOsPrintf ("RunOnly, ");
 920                     }
 921
 922                     switch (GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK)
 923                     {
 924                     case ACPI_GPE_DISPATCH_NOT_USED:
 925                         AcpiOsPrintf ("NotUsed");
 926                         break;
 927                     case ACPI_GPE_DISPATCH_HANDLER:
 928                         AcpiOsPrintf ("Handler");
 929                         break;
 930                     case ACPI_GPE_DISPATCH_METHOD:
 931                         AcpiOsPrintf ("Method");
 932                         break;
 933                     default:
 934                         AcpiOsPrintf ("UNKNOWN: %X",
 935                             GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK);
 936                         break;
 937                     }
 938
 939                     AcpiOsPrintf (")\n");
 940                 }
 941             }
 942             Block++;
 943             GpeBlock = GpeBlock->Next;
 944         }
 945         GpeXruptInfo = GpeXruptInfo->Next;
 946     }
 947 }
 948
 949 #endif /* ACPI_DEBUGGER */
 950