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