sys/contrib/dev/acpica/dbdisply.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: dbdisply - debug display commands
   4  *              $Revision: 1.120 $
   5  *
   6  ******************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117
 118 #include <contrib/dev/acpica/acpi.h>
 119 #include <contrib/dev/acpica/amlcode.h>
 120 #include <contrib/dev/acpica/acdispat.h>
 121 #include <contrib/dev/acpica/acnamesp.h>
 122 #include <contrib/dev/acpica/acparser.h>
 123 #include <contrib/dev/acpica/acinterp.h>
 124 #include <contrib/dev/acpica/acdebug.h>
 125 #include <contrib/dev/acpica/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_BUFFER             Buffer;
 686     ACPI_DEVICE_INFO        *Info;
 687     ACPI_STATUS             Status;
 688     ACPI_NATIVE_UINT        i;
 689
 690
 691     Handle = ACPI_TO_POINTER (ACPI_STRTOUL (ObjectArg, NULL, 16));
 692     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 693
 694     Status = AcpiGetObjectInfo (Handle, &Buffer);
 695     if (ACPI_SUCCESS (Status))
 696     {
 697         Info = Buffer.Pointer;
 698         AcpiOsPrintf (
 699             "S1D-%2.2X S2D-%2.2X S3D-%2.2X S4D-%2.2X    HID: %s, ADR: %8.8X%8.8X, Status %8.8X\n",
 700             Info->HighestDstates[0], Info->HighestDstates[1],
 701             Info->HighestDstates[2], Info->HighestDstates[3],
 702             Info->HardwareId.Value,
 703             ACPI_FORMAT_UINT64 (Info->Address),
 704             Info->CurrentStatus);
 705
 706         if (Info->Valid & ACPI_VALID_CID)
 707         {
 708             for (i = 0; i < Info->CompatibilityId.Count; i++)
 709             {
 710                 AcpiOsPrintf ("CID #%d: %s\n", (UINT32) i,
 711                     Info->CompatibilityId.Id[i].Value);
 712             }
 713         }
 714
 715         ACPI_FREE (Info);
 716     }
 717     else
 718     {
 719         AcpiOsPrintf ("%s\n", AcpiFormatException (Status));
 720     }
 721 }
 722
 723
 724 /*******************************************************************************
 725  *
 726  * FUNCTION:    AcpiDbDisplayResultObject
 727  *
 728  * PARAMETERS:  ObjDesc         - Object to be displayed
 729  *              WalkState       - Current walk state
 730  *
 731  * RETURN:      None
 732  *
 733  * DESCRIPTION: Display the result of an AML opcode
 734  *
 735  * Note: Curently only displays the result object if we are single stepping.
 736  * However, this output may be useful in other contexts and could be enabled
 737  * to do so if needed.
 738  *
 739  ******************************************************************************/
 740
 741 void
 742 AcpiDbDisplayResultObject (
 743     ACPI_OPERAND_OBJECT     *ObjDesc,
 744     ACPI_WALK_STATE         *WalkState)
 745 {
 746
 747     /* Only display if single stepping */
 748
 749     if (!AcpiGbl_CmSingleStep)
 750     {
 751         return;
 752     }
 753
 754     AcpiOsPrintf ("ResultObj: ");
 755     AcpiDmDisplayInternalObject (ObjDesc, WalkState);
 756     AcpiOsPrintf ("\n");
 757 }
 758
 759
 760 /*******************************************************************************
 761  *
 762  * FUNCTION:    AcpiDbDisplayArgumentObject
 763  *
 764  * PARAMETERS:  ObjDesc         - Object to be displayed
 765  *              WalkState       - Current walk state
 766  *
 767  * RETURN:      None
 768  *
 769  * DESCRIPTION: Display the result of an AML opcode
 770  *
 771  ******************************************************************************/
 772
 773 void
 774 AcpiDbDisplayArgumentObject (
 775     ACPI_OPERAND_OBJECT     *ObjDesc,
 776     ACPI_WALK_STATE         *WalkState)
 777 {
 778
 779     if (!AcpiGbl_CmSingleStep)
 780     {
 781         return;
 782     }
 783
 784     AcpiOsPrintf ("ArgObj:    ");
 785     AcpiDmDisplayInternalObject (ObjDesc, WalkState);
 786 }
 787
 788
 789 /*******************************************************************************
 790  *
 791  * FUNCTION:    AcpiDbDisplayGpes
 792  *
 793  * PARAMETERS:  None
 794  *
 795  * RETURN:      None
 796  *
 797  * DESCRIPTION: Display the current GPE structures
 798  *
 799  ******************************************************************************/
 800
 801 void
 802 AcpiDbDisplayGpes (
 803     void)
 804 {
 805     ACPI_GPE_BLOCK_INFO     *GpeBlock;
 806     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo;
 807     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 808     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
 809     UINT32                  GpeIndex;
 810     UINT32                  Block = 0;
 811     UINT32                  i;
 812     UINT32                  j;
 813     char                    Buffer[80];
 814     ACPI_BUFFER             RetBuf;
 815     ACPI_STATUS             Status;
 816
 817
 818     RetBuf.Length = sizeof (Buffer);
 819     RetBuf.Pointer = Buffer;
 820
 821     Block = 0;
 822
 823     /* Walk the GPE lists */
 824
 825     GpeXruptInfo = AcpiGbl_GpeXruptListHead;
 826     while (GpeXruptInfo)
 827     {
 828         GpeBlock = GpeXruptInfo->GpeBlockListHead;
 829         while (GpeBlock)
 830         {
 831             Status = AcpiGetName (GpeBlock->Node, ACPI_FULL_PATHNAME, &RetBuf);
 832             if (ACPI_FAILURE (Status))
 833             {
 834                 AcpiOsPrintf ("Could not convert name to pathname\n");
 835             }
 836
 837             AcpiOsPrintf ("\nBlock %d - Info %p  DeviceNode %p [%s]\n",
 838                 Block, GpeBlock, GpeBlock->Node, Buffer);
 839
 840             AcpiOsPrintf ("    Registers:    %u (%u GPEs)\n",
 841                 GpeBlock->RegisterCount,
 842                 ACPI_MUL_8 (GpeBlock->RegisterCount));
 843
 844             AcpiOsPrintf ("    GPE range:    0x%X to 0x%X\n",
 845                 GpeBlock->BlockBaseNumber,
 846                 GpeBlock->BlockBaseNumber +
 847                     (GpeBlock->RegisterCount * 8) -1);
 848
 849             AcpiOsPrintf (
 850                 "    RegisterInfo: %p  Status %8.8X%8.8X Enable %8.8X%8.8X\n",
 851                 GpeBlock->RegisterInfo,
 852                 ACPI_FORMAT_UINT64 (GpeBlock->RegisterInfo->StatusAddress.Address),
 853                 ACPI_FORMAT_UINT64 (GpeBlock->RegisterInfo->EnableAddress.Address));
 854
 855             AcpiOsPrintf ("    EventInfo:    %p\n", GpeBlock->EventInfo);
 856
 857             /* Examine each GPE Register within the block */
 858
 859             for (i = 0; i < GpeBlock->RegisterCount; i++)
 860             {
 861                 GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
 862
 863                 AcpiOsPrintf (
 864                     "    Reg %u:  WakeEnable %2.2X, RunEnable %2.2X  Status %8.8X%8.8X Enable %8.8X%8.8X\n",
 865                     i, GpeRegisterInfo->EnableForWake,
 866                     GpeRegisterInfo->EnableForRun,
 867                     ACPI_FORMAT_UINT64 (GpeRegisterInfo->StatusAddress.Address),
 868                     ACPI_FORMAT_UINT64 (GpeRegisterInfo->EnableAddress.Address));
 869
 870                 /* Now look at the individual GPEs in this byte register */
 871
 872                 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
 873                 {
 874                     GpeIndex = (i * ACPI_GPE_REGISTER_WIDTH) + j;
 875                     GpeEventInfo = &GpeBlock->EventInfo[GpeIndex];
 876
 877                     if (!(GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK))
 878                     {
 879                         /* This GPE is not used (no method or handler) */
 880
 881                         continue;
 882                     }
 883
 884                     AcpiOsPrintf (
 885                         "        GPE %.3X: %p Flags %2.2X: ",
 886                         GpeBlock->BlockBaseNumber + GpeIndex,
 887                         GpeEventInfo,
 888                         GpeEventInfo->Flags);
 889
 890                     if (GpeEventInfo->Flags & ACPI_GPE_LEVEL_TRIGGERED)
 891                     {
 892                         AcpiOsPrintf ("Level, ");
 893                     }
 894                     else
 895                     {
 896                         AcpiOsPrintf ("Edge,  ");
 897                     }
 898
 899                     switch (GpeEventInfo->Flags & ACPI_GPE_TYPE_MASK)
 900                     {
 901                     case ACPI_GPE_TYPE_WAKE:
 902                         AcpiOsPrintf ("WakeOnly: ");
 903                         break;
 904                     case ACPI_GPE_TYPE_RUNTIME:
 905                         AcpiOsPrintf (" RunOnly: ");
 906                         break;
 907                     case ACPI_GPE_TYPE_WAKE_RUN:
 908                         AcpiOsPrintf (" WakeRun: ");
 909                         break;
 910                     default:
 911                         AcpiOsPrintf (" NotUsed: ");
 912                         break;
 913                     }
 914
 915                     if (GpeEventInfo->Flags & ACPI_GPE_WAKE_ENABLED)
 916                     {
 917                         AcpiOsPrintf ("[Wake 1 ");
 918                     }
 919                     else
 920                     {
 921                         AcpiOsPrintf ("[Wake 0 ");
 922                     }
 923
 924                     if (GpeEventInfo->Flags & ACPI_GPE_RUN_ENABLED)
 925                     {
 926                         AcpiOsPrintf ("Run 1], ");
 927                     }
 928                     else
 929                     {
 930                         AcpiOsPrintf ("Run 0], ");
 931                     }
 932
 933                     switch (GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK)
 934                     {
 935                     case ACPI_GPE_DISPATCH_NOT_USED:
 936                         AcpiOsPrintf ("NotUsed");
 937                         break;
 938                     case ACPI_GPE_DISPATCH_HANDLER:
 939                         AcpiOsPrintf ("Handler");
 940                         break;
 941                     case ACPI_GPE_DISPATCH_METHOD:
 942                         AcpiOsPrintf ("Method");
 943                         break;
 944                     default:
 945                         AcpiOsPrintf ("UNKNOWN: %X",
 946                             GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK);
 947                         break;
 948                     }
 949
 950                     AcpiOsPrintf ("\n");
 951                 }
 952             }
 953             Block++;
 954             GpeBlock = GpeBlock->Next;
 955         }
 956         GpeXruptInfo = GpeXruptInfo->Next;
 957     }
 958 }
 959
 960 #endif /* ACPI_DEBUGGER */
 961