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

   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 <contrib/dev/acpica/include/acpi.h>
  46 #include <contrib/dev/acpica/include/accommon.h>
  47 #include <contrib/dev/acpica/include/amlcode.h>
  48 #include <contrib/dev/acpica/include/acdispat.h>
  49 #include <contrib/dev/acpica/include/acnamesp.h>
  50 #include <contrib/dev/acpica/include/acparser.h>
  51 #include <contrib/dev/acpica/include/acinterp.h>
  52 #include <contrib/dev/acpica/include/acdebug.h>
  53 #include <contrib/dev/acpica/include/acdisasm.h>
  54
  55
  56 #ifdef ACPI_DEBUGGER
  57
  58 #define _COMPONENT          ACPI_CA_DEBUGGER
  59         ACPI_MODULE_NAME    ("dbdisply")
  60
  61 /* Local prototypes */
  62
  63 static void
  64 AcpiDbDumpParserDescriptor (
  65     ACPI_PARSE_OBJECT       *Op);
  66
  67 static void *
  68 AcpiDbGetPointer (
  69     void                    *Target);
  70
  71 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,  "System Notifications"},
 118     {&AcpiGbl_GlobalNotify[1].Handler,  "Device Notifications"},
 119     {&AcpiGbl_TableHandler,             "ACPI Table Events"},
 120     {&AcpiGbl_ExceptionHandler,         "Control Method Exceptions"},
 121     {&AcpiGbl_InterfaceHandler,         "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     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 */