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