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