5 * 6 ******************************************************************************/ 7 8/****************************************************************************** 9 * 10 * 1. Copyright Notice 11 * 12 * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp. 13 * All rights reserved. 14 * 15 * 2. License 16 * 17 * 2.1. This is your license from Intel Corp. under its intellectual property 18 * rights. You may have additional license terms from the party that provided 19 * you this software, covering your right to use that party's intellectual 20 * property rights. 21 * 22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 23 * copy of the source code appearing in this file ("Covered Code") an 24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 25 * base code distributed originally by Intel ("Original Intel Code") to copy, 26 * make derivatives, distribute, use and display any portion of the Covered 27 * Code in any form, with the right to sublicense such rights; and 28 * 29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 30 * license (with the right to sublicense), under only those claims of Intel 31 * patents that are infringed by the Original Intel Code, to make, use, sell, 32 * offer to sell, and import the Covered Code and derivative works thereof 33 * solely to the minimum extent necessary to exercise the above copyright 34 * license, and in no event shall the patent license extend to any additions 35 * to or modifications of the Original Intel Code. No other license or right 36 * is granted directly or by implication, estoppel or otherwise; 37 * 38 * The above copyright and patent license is granted only if the following 39 * conditions are met: 40 * 41 * 3. Conditions 42 * 43 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 44 * Redistribution of source code of any substantial portion of the Covered 45 * Code or modification with rights to further distribute source must include 46 * the above Copyright Notice, the above License, this list of Conditions, 47 * and the following Disclaimer and Export Compliance provision. In addition, 48 * Licensee must cause all Covered Code to which Licensee contributes to 49 * contain a file documenting the changes Licensee made to create that Covered 50 * Code and the date of any change. Licensee must include in that file the 51 * documentation of any changes made by any predecessor Licensee. Licensee 52 * must include a prominent statement that the modification is derived, 53 * directly or indirectly, from Original Intel Code. 54 * 55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 56 * Redistribution of source code of any substantial portion of the Covered 57 * Code or modification without rights to further distribute source must 58 * include the following Disclaimer and Export Compliance provision in the 59 * documentation and/or other materials provided with distribution. In 60 * addition, Licensee may not authorize further sublicense of source of any 61 * portion of the Covered Code, and must include terms to the effect that the 62 * license from Licensee to its licensee is limited to the intellectual 63 * property embodied in the software Licensee provides to its licensee, and 64 * not to intellectual property embodied in modifications its licensee may 65 * make. 66 * 67 * 3.3. Redistribution of Executable. Redistribution in executable form of any 68 * substantial portion of the Covered Code or modification must reproduce the 69 * above Copyright Notice, and the following Disclaimer and Export Compliance 70 * provision in the documentation and/or other materials provided with the 71 * distribution. 72 * 73 * 3.4. Intel retains all right, title, and interest in and to the Original 74 * Intel Code. 75 * 76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 77 * Intel shall be used in advertising or otherwise to promote the sale, use or 78 * other dealings in products derived from or relating to the Covered Code 79 * without prior written authorization from Intel. 80 * 81 * 4. Disclaimer and Export Compliance 82 * 83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 89 * PARTICULAR PURPOSE. 90 * 91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 98 * LIMITED REMEDY. 99 * 100 * 4.3. Licensee shall not export, either directly or indirectly, any of this 101 * software or system incorporating such software without first obtaining any 102 * required license or other approval from the U. S. Department of Commerce or 103 * any other agency or department of the United States Government. In the 104 * event Licensee exports any such software from the United States or 105 * re-exports any such software from a foreign destination, Licensee shall 106 * ensure that the distribution and export/re-export of the software is in 107 * compliance with all laws, regulations, orders, or other restrictions of the 108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 109 * any of its subsidiaries will export/re-export any technical data, process, 110 * software, or service, directly or indirectly, to any country for which the 111 * United States government or any agency thereof requires an export license, 112 * other governmental approval, or letter of assurance, without first obtaining 113 * such license, approval or letter. 114 * 115 *****************************************************************************/ 116 117 118#include "acpi.h" 119#include "acdispat.h" 120#include "amlcode.h" 121#include "acnamesp.h" 122#include "acevents.h" 123#include "acdebug.h" 124#include "acresrc.h" 125#include "acdisasm.h" 126 127#ifdef ACPI_DEBUGGER 128 129#define _COMPONENT ACPI_CA_DEBUGGER 130 ACPI_MODULE_NAME ("dbcmds") 131 132 133/* 134 * Arguments for the Objects command 135 * These object types map directly to the ACPI_TYPES 136 */ 137 138static ARGUMENT_INFO AcpiDbObjectTypes [] = 139{ 140 {"ANY"}, 141 {"NUMBERS"}, 142 {"STRINGS"}, 143 {"BUFFERS"}, 144 {"PACKAGES"}, 145 {"FIELDS"}, 146 {"DEVICES"}, 147 {"EVENTS"}, 148 {"METHODS"}, 149 {"MUTEXES"}, 150 {"REGIONS"}, 151 {"POWERRESOURCES"}, 152 {"PROCESSORS"}, 153 {"THERMALZONES"}, 154 {"BUFFERFIELDS"}, 155 {"DDBHANDLES"}, 156 {NULL} /* Must be null terminated */ 157}; 158 159 160ACPI_STATUS 161AcpiDbSleep ( 162 char *ObjectArg) 163{
| 5 * 6 ******************************************************************************/ 7 8/****************************************************************************** 9 * 10 * 1. Copyright Notice 11 * 12 * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp. 13 * All rights reserved. 14 * 15 * 2. License 16 * 17 * 2.1. This is your license from Intel Corp. under its intellectual property 18 * rights. You may have additional license terms from the party that provided 19 * you this software, covering your right to use that party's intellectual 20 * property rights. 21 * 22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 23 * copy of the source code appearing in this file ("Covered Code") an 24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 25 * base code distributed originally by Intel ("Original Intel Code") to copy, 26 * make derivatives, distribute, use and display any portion of the Covered 27 * Code in any form, with the right to sublicense such rights; and 28 * 29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 30 * license (with the right to sublicense), under only those claims of Intel 31 * patents that are infringed by the Original Intel Code, to make, use, sell, 32 * offer to sell, and import the Covered Code and derivative works thereof 33 * solely to the minimum extent necessary to exercise the above copyright 34 * license, and in no event shall the patent license extend to any additions 35 * to or modifications of the Original Intel Code. No other license or right 36 * is granted directly or by implication, estoppel or otherwise; 37 * 38 * The above copyright and patent license is granted only if the following 39 * conditions are met: 40 * 41 * 3. Conditions 42 * 43 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 44 * Redistribution of source code of any substantial portion of the Covered 45 * Code or modification with rights to further distribute source must include 46 * the above Copyright Notice, the above License, this list of Conditions, 47 * and the following Disclaimer and Export Compliance provision. In addition, 48 * Licensee must cause all Covered Code to which Licensee contributes to 49 * contain a file documenting the changes Licensee made to create that Covered 50 * Code and the date of any change. Licensee must include in that file the 51 * documentation of any changes made by any predecessor Licensee. Licensee 52 * must include a prominent statement that the modification is derived, 53 * directly or indirectly, from Original Intel Code. 54 * 55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 56 * Redistribution of source code of any substantial portion of the Covered 57 * Code or modification without rights to further distribute source must 58 * include the following Disclaimer and Export Compliance provision in the 59 * documentation and/or other materials provided with distribution. In 60 * addition, Licensee may not authorize further sublicense of source of any 61 * portion of the Covered Code, and must include terms to the effect that the 62 * license from Licensee to its licensee is limited to the intellectual 63 * property embodied in the software Licensee provides to its licensee, and 64 * not to intellectual property embodied in modifications its licensee may 65 * make. 66 * 67 * 3.3. Redistribution of Executable. Redistribution in executable form of any 68 * substantial portion of the Covered Code or modification must reproduce the 69 * above Copyright Notice, and the following Disclaimer and Export Compliance 70 * provision in the documentation and/or other materials provided with the 71 * distribution. 72 * 73 * 3.4. Intel retains all right, title, and interest in and to the Original 74 * Intel Code. 75 * 76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 77 * Intel shall be used in advertising or otherwise to promote the sale, use or 78 * other dealings in products derived from or relating to the Covered Code 79 * without prior written authorization from Intel. 80 * 81 * 4. Disclaimer and Export Compliance 82 * 83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 89 * PARTICULAR PURPOSE. 90 * 91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 98 * LIMITED REMEDY. 99 * 100 * 4.3. Licensee shall not export, either directly or indirectly, any of this 101 * software or system incorporating such software without first obtaining any 102 * required license or other approval from the U. S. Department of Commerce or 103 * any other agency or department of the United States Government. In the 104 * event Licensee exports any such software from the United States or 105 * re-exports any such software from a foreign destination, Licensee shall 106 * ensure that the distribution and export/re-export of the software is in 107 * compliance with all laws, regulations, orders, or other restrictions of the 108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 109 * any of its subsidiaries will export/re-export any technical data, process, 110 * software, or service, directly or indirectly, to any country for which the 111 * United States government or any agency thereof requires an export license, 112 * other governmental approval, or letter of assurance, without first obtaining 113 * such license, approval or letter. 114 * 115 *****************************************************************************/ 116 117 118#include "acpi.h" 119#include "acdispat.h" 120#include "amlcode.h" 121#include "acnamesp.h" 122#include "acevents.h" 123#include "acdebug.h" 124#include "acresrc.h" 125#include "acdisasm.h" 126 127#ifdef ACPI_DEBUGGER 128 129#define _COMPONENT ACPI_CA_DEBUGGER 130 ACPI_MODULE_NAME ("dbcmds") 131 132 133/* 134 * Arguments for the Objects command 135 * These object types map directly to the ACPI_TYPES 136 */ 137 138static ARGUMENT_INFO AcpiDbObjectTypes [] = 139{ 140 {"ANY"}, 141 {"NUMBERS"}, 142 {"STRINGS"}, 143 {"BUFFERS"}, 144 {"PACKAGES"}, 145 {"FIELDS"}, 146 {"DEVICES"}, 147 {"EVENTS"}, 148 {"METHODS"}, 149 {"MUTEXES"}, 150 {"REGIONS"}, 151 {"POWERRESOURCES"}, 152 {"PROCESSORS"}, 153 {"THERMALZONES"}, 154 {"BUFFERFIELDS"}, 155 {"DDBHANDLES"}, 156 {NULL} /* Must be null terminated */ 157}; 158 159 160ACPI_STATUS 161AcpiDbSleep ( 162 char *ObjectArg) 163{
|
188} 189 190 191/******************************************************************************* 192 * 193 * FUNCTION: AcpiDbWalkForReferences 194 * 195 * PARAMETERS: Callback from WalkNamespace 196 * 197 * RETURN: Status 198 * 199 * DESCRIPTION: Check if this namespace object refers to the target object 200 * that is passed in as the context value. 201 * 202 * Note: Currently doesn't check subobjects within the Node's object 203 * 204 ******************************************************************************/ 205 206ACPI_STATUS 207AcpiDbWalkForReferences ( 208 ACPI_HANDLE ObjHandle, 209 UINT32 NestingLevel, 210 void *Context, 211 void **ReturnValue) 212{ 213 ACPI_OPERAND_OBJECT *ObjDesc = (ACPI_OPERAND_OBJECT *) Context; 214 ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) ObjHandle; 215 216 217 /* Check for match against the namespace node itself */ 218 219 if (Node == (void *) ObjDesc) 220 { 221 AcpiOsPrintf ("Object is a Node [%4.4s]\n", 222 AcpiUtGetNodeName (Node)); 223 } 224 225 /* Check for match against the object attached to the node */ 226 227 if (AcpiNsGetAttachedObject (Node) == ObjDesc) 228 { 229 AcpiOsPrintf ("Reference at Node->Object %p [%4.4s]\n", 230 Node, AcpiUtGetNodeName (Node)); 231 } 232 233 return (AE_OK); 234} 235 236 237/******************************************************************************* 238 * 239 * FUNCTION: AcpiDbFindReferences 240 * 241 * PARAMETERS: ObjectArg - String with hex value of the object 242 * 243 * RETURN: None 244 * 245 * DESCRIPTION: Search namespace for all references to the input object 246 * 247 ******************************************************************************/ 248 249void 250AcpiDbFindReferences ( 251 char *ObjectArg) 252{ 253 ACPI_OPERAND_OBJECT *ObjDesc; 254 255 256 /* Convert string to object pointer */ 257 258 ObjDesc = ACPI_TO_POINTER (ACPI_STRTOUL (ObjectArg, NULL, 16)); 259 260 /* Search all nodes in namespace */ 261 262 (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, 263 AcpiDbWalkForReferences, (void *) ObjDesc, NULL); 264} 265 266 267/******************************************************************************* 268 * 269 * FUNCTION: AcpiDbDisplayLocks 270 * 271 * PARAMETERS: None 272 * 273 * RETURN: None 274 * 275 * DESCRIPTION: Display information about internal mutexes. 276 * 277 ******************************************************************************/ 278 279void 280AcpiDbDisplayLocks (void) 281{ 282 UINT32 i; 283 284 285 for (i = 0; i < MAX_MUTEX; i++) 286 { 287 AcpiOsPrintf ("%26s : %s\n", AcpiUtGetMutexName (i), 288 AcpiGbl_MutexInfo[i].OwnerId == ACPI_MUTEX_NOT_ACQUIRED 289 ? "Locked" : "Unlocked"); 290 } 291} 292 293 294/******************************************************************************* 295 * 296 * FUNCTION: AcpiDbDisplayTableInfo 297 * 298 * PARAMETERS: TableArg - String with name of table to be displayed 299 * 300 * RETURN: None 301 * 302 * DESCRIPTION: Display information about loaded tables. Current 303 * implementation displays all loaded tables. 304 * 305 ******************************************************************************/ 306 307void 308AcpiDbDisplayTableInfo ( 309 char *TableArg) 310{ 311 UINT32 i; 312 ACPI_TABLE_DESC *TableDesc; 313 314 315 for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++) 316 { 317 TableDesc = AcpiGbl_TableLists[i].Next; 318 while (TableDesc) 319 { 320 AcpiOsPrintf ( "%s at %p length %.5X", 321 AcpiGbl_TableData[i].Name, TableDesc->Pointer, 322 (UINT32) TableDesc->Length); 323 324 if (i != ACPI_TABLE_FACS) 325 { 326 AcpiOsPrintf (" OemID=%6s TableId=%8s OemRevision=%8.8X", 327 TableDesc->Pointer->OemId, 328 TableDesc->Pointer->OemTableId, 329 TableDesc->Pointer->OemRevision); 330 } 331 AcpiOsPrintf ("\n"); 332 333 TableDesc = TableDesc->Next; 334 } 335 } 336} 337 338 339/******************************************************************************* 340 * 341 * FUNCTION: AcpiDbUnloadAcpiTable 342 * 343 * PARAMETERS: TableArg - Name of the table to be unloaded 344 * InstanceArg - Which instance of the table to unload (if 345 * there are multiple tables of the same type) 346 * 347 * RETURN: Nonde 348 * 349 * DESCRIPTION: Unload an ACPI table. 350 * Instance is not implemented 351 * 352 ******************************************************************************/ 353 354void 355AcpiDbUnloadAcpiTable ( 356 char *TableArg, 357 char *InstanceArg) 358{ 359 UINT32 i; 360 ACPI_STATUS Status; 361 362 363 /* Search all tables for the target type */ 364 365 for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++) 366 { 367 if (!ACPI_STRNCMP (TableArg, AcpiGbl_TableData[i].Signature, 368 AcpiGbl_TableData[i].SigLength)) 369 { 370 /* Found the table, unload it */ 371 372 Status = AcpiUnloadTable (i); 373 if (ACPI_SUCCESS (Status)) 374 { 375 AcpiOsPrintf ("[%s] unloaded and uninstalled\n", TableArg); 376 } 377 else 378 { 379 AcpiOsPrintf ("%s, while unloading [%s]\n", 380 AcpiFormatException (Status), TableArg); 381 } 382 383 return; 384 } 385 } 386 387 AcpiOsPrintf ("Unknown table type [%s]\n", TableArg); 388} 389 390 391/******************************************************************************* 392 * 393 * FUNCTION: AcpiDbSetMethodBreakpoint 394 * 395 * PARAMETERS: Location - AML offset of breakpoint 396 * WalkState - Current walk info 397 * Op - Current Op (from parse walk) 398 * 399 * RETURN: None 400 * 401 * DESCRIPTION: Set a breakpoint in a control method at the specified 402 * AML offset 403 * 404 ******************************************************************************/ 405 406void 407AcpiDbSetMethodBreakpoint ( 408 char *Location, 409 ACPI_WALK_STATE *WalkState, 410 ACPI_PARSE_OBJECT *Op) 411{ 412 UINT32 Address; 413 414 415 if (!Op) 416 { 417 AcpiOsPrintf ("There is no method currently executing\n"); 418 return; 419 } 420 421 /* Get and verify the breakpoint address */ 422 423 Address = ACPI_STRTOUL (Location, NULL, 16); 424 if (Address <= Op->Common.AmlOffset) 425 { 426 AcpiOsPrintf ("Breakpoint %X is beyond current address %X\n", Address, Op->Common.AmlOffset); 427 } 428 429 /* Save breakpoint in current walk */ 430 431 WalkState->UserBreakpoint = Address; 432 AcpiOsPrintf ("Breakpoint set at AML offset %X\n", Address); 433} 434 435 436/******************************************************************************* 437 * 438 * FUNCTION: AcpiDbSetMethodCallBreakpoint 439 * 440 * PARAMETERS: Op - Current Op (from parse walk) 441 * 442 * RETURN: None 443 * 444 * DESCRIPTION: Set a breakpoint in a control method at the specified 445 * AML offset 446 * 447 ******************************************************************************/ 448 449void 450AcpiDbSetMethodCallBreakpoint ( 451 ACPI_PARSE_OBJECT *Op) 452{ 453 454 455 if (!Op) 456 { 457 AcpiOsPrintf ("There is no method currently executing\n"); 458 return; 459 } 460 461 AcpiGbl_StepToNextCall = TRUE; 462} 463 464 465/******************************************************************************* 466 * 467 * FUNCTION: AcpiDbDisassembleAml 468 * 469 * PARAMETERS: Statements - Number of statements to disassemble 470 * Op - Current Op (from parse walk) 471 * 472 * RETURN: None 473 * 474 * DESCRIPTION: Display disassembled AML (ASL) starting from Op for the number 475 * of statements specified. 476 * 477 ******************************************************************************/ 478 479void 480AcpiDbDisassembleAml ( 481 char *Statements, 482 ACPI_PARSE_OBJECT *Op) 483{ 484 UINT32 NumStatements = 8; 485 486 487 if (!Op) 488 { 489 AcpiOsPrintf ("There is no method currently executing\n"); 490 return; 491 } 492 493 if (Statements) 494 { 495 NumStatements = ACPI_STRTOUL (Statements, NULL, 0); 496 } 497 498 AcpiDmDisassemble (NULL, Op, NumStatements); 499} 500 501 502/******************************************************************************* 503 * 504 * FUNCTION: AcpiDbDumpNamespace 505 * 506 * PARAMETERS: StartArg - Node to begin namespace dump 507 * DepthArg - Maximum tree depth to be dumped 508 * 509 * RETURN: None 510 * 511 * DESCRIPTION: Dump entire namespace or a subtree. Each node is displayed 512 * with type and other information. 513 * 514 ******************************************************************************/ 515 516void 517AcpiDbDumpNamespace ( 518 char *StartArg, 519 char *DepthArg) 520{ 521 ACPI_HANDLE SubtreeEntry = AcpiGbl_RootNode; 522 UINT32 MaxDepth = ACPI_UINT32_MAX; 523 524 525 /* No argument given, just start at the root and dump entire namespace */ 526 527 if (StartArg) 528 { 529 /* Check if numeric argument, must be a Node */ 530 531 if ((StartArg[0] >= 0x30) && (StartArg[0] <= 0x39)) 532 { 533 SubtreeEntry = ACPI_TO_POINTER (ACPI_STRTOUL (StartArg, NULL, 16)); 534 if (!AcpiOsReadable (SubtreeEntry, sizeof (ACPI_NAMESPACE_NODE))) 535 { 536 AcpiOsPrintf ("Address %p is invalid in this address space\n", SubtreeEntry); 537 return; 538 } 539 540 if (ACPI_GET_DESCRIPTOR_TYPE (SubtreeEntry) != ACPI_DESC_TYPE_NAMED) 541 { 542 AcpiOsPrintf ("Address %p is not a valid NS node [%s]\n", 543 SubtreeEntry, AcpiUtGetDescriptorName (SubtreeEntry)); 544 return; 545 } 546 } 547 else 548 { 549 /* Alpha argument */ 550 /* The parameter is a name string that must be resolved to a Named obj*/ 551 552 SubtreeEntry = AcpiDbLocalNsLookup (StartArg); 553 if (!SubtreeEntry) 554 { 555 SubtreeEntry = AcpiGbl_RootNode; 556 } 557 } 558 559 /* Now we can check for the depth argument */ 560 561 if (DepthArg) 562 { 563 MaxDepth = ACPI_STRTOUL (DepthArg, NULL, 0); 564 } 565 } 566 567 AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT); 568 AcpiOsPrintf ("ACPI Namespace (from %p subtree):\n", SubtreeEntry); 569 570 /* Display the subtree */ 571 572 AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT); 573 AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth, ACPI_UINT32_MAX, SubtreeEntry); 574 AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT); 575} 576 577 578/******************************************************************************* 579 * 580 * FUNCTION: AcpiDbDumpNamespaceByOwner 581 * 582 * PARAMETERS: OwnerArg - Owner ID whose nodes will be displayed 583 * DepthArg - Maximum tree depth to be dumped 584 * 585 * RETURN: None 586 * 587 * DESCRIPTION: Dump elements of the namespace that are owned by the OwnerId. 588 * 589 ******************************************************************************/ 590 591void 592AcpiDbDumpNamespaceByOwner ( 593 char *OwnerArg, 594 char *DepthArg) 595{ 596 ACPI_HANDLE SubtreeEntry = AcpiGbl_RootNode; 597 UINT32 MaxDepth = ACPI_UINT32_MAX; 598 UINT16 OwnerId; 599 600 601 OwnerId = (UINT16) ACPI_STRTOUL (OwnerArg, NULL, 0); 602 603 /* Now we can check for the depth argument */ 604 605 if (DepthArg) 606 { 607 MaxDepth = ACPI_STRTOUL (DepthArg, NULL, 0); 608 } 609 610 AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT); 611 AcpiOsPrintf ("ACPI Namespace by owner %X:\n", OwnerId); 612 613 /* Display the subtree */ 614 615 AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT); 616 AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth, OwnerId, SubtreeEntry); 617 AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT); 618} 619 620 621/******************************************************************************* 622 * 623 * FUNCTION: AcpiDbSendNotify 624 * 625 * PARAMETERS: Name - Name of ACPI object to send the notify to 626 * Value - Value of the notify to send. 627 * 628 * RETURN: None 629 * 630 * DESCRIPTION: Send an ACPI notification. The value specified is sent to the 631 * named object as an ACPI notify. 632 * 633 ******************************************************************************/ 634 635void 636AcpiDbSendNotify ( 637 char *Name, 638 UINT32 Value) 639{ 640 ACPI_NAMESPACE_NODE *Node; 641 ACPI_STATUS Status; 642 643 644 /* Translate name to an Named object */ 645 646 Node = AcpiDbLocalNsLookup (Name); 647 if (!Node) 648 { 649 return; 650 } 651 652 /* Decode Named object type */ 653 654 switch (Node->Type) 655 { 656 case ACPI_TYPE_DEVICE: 657 case ACPI_TYPE_THERMAL: 658 659 /* Send the notify */ 660 661 Status = AcpiEvQueueNotifyRequest (Node, Value); 662 if (ACPI_FAILURE (Status)) 663 { 664 AcpiOsPrintf ("Could not queue notify\n"); 665 } 666 break; 667 668 default: 669 AcpiOsPrintf ("Named object is not a device or a thermal object\n"); 670 break; 671 } 672} 673 674 675/******************************************************************************* 676 * 677 * FUNCTION: AcpiDbSetMethodData 678 * 679 * PARAMETERS: TypeArg - L for local, A for argument 680 * IndexArg - which one 681 * ValueArg - Value to set. 682 * 683 * RETURN: None 684 * 685 * DESCRIPTION: Set a local or argument for the running control method. 686 * NOTE: only object supported is Number. 687 * 688 ******************************************************************************/ 689 690void 691AcpiDbSetMethodData ( 692 char *TypeArg, 693 char *IndexArg, 694 char *ValueArg) 695{ 696 char Type; 697 UINT32 Index; 698 UINT32 Value; 699 ACPI_WALK_STATE *WalkState; 700 ACPI_OPERAND_OBJECT *ObjDesc; 701 ACPI_STATUS Status; 702 703 704 /* Validate TypeArg */ 705 706 ACPI_STRUPR (TypeArg); 707 Type = TypeArg[0]; 708 if ((Type != 'L') && 709 (Type != 'A')) 710 { 711 AcpiOsPrintf ("Invalid SET operand: %s\n", TypeArg); 712 return; 713 } 714 715 /* Get the index and value */ 716 717 Index = ACPI_STRTOUL (IndexArg, NULL, 16); 718 Value = ACPI_STRTOUL (ValueArg, NULL, 16); 719 720 WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList); 721 if (!WalkState) 722 { 723 AcpiOsPrintf ("There is no method currently executing\n"); 724 return; 725 } 726 727 /* Create and initialize the new object */ 728 729 ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); 730 if (!ObjDesc) 731 { 732 AcpiOsPrintf ("Could not create an internal object\n"); 733 return; 734 } 735 736 ObjDesc->Integer.Value = Value; 737 738 /* Store the new object into the target */ 739 740 switch (Type) 741 { 742 case 'A': 743 744 /* Set a method argument */ 745 746 if (Index > ACPI_METHOD_MAX_ARG) 747 { 748 AcpiOsPrintf ("Arg%d - Invalid argument name\n", Index); 749 return; 750 } 751 752 Status = AcpiDsStoreObjectToLocal (AML_ARG_OP, Index, ObjDesc, WalkState); 753 if (ACPI_FAILURE (Status)) 754 { 755 return; 756 } 757 758 ObjDesc = WalkState->Arguments[Index].Object; 759 760 AcpiOsPrintf ("Arg%d: ", Index); 761 AcpiDmDisplayInternalObject (ObjDesc, WalkState); 762 break; 763 764 case 'L': 765 766 /* Set a method local */ 767 768 if (Index > ACPI_METHOD_MAX_LOCAL) 769 { 770 AcpiOsPrintf ("Local%d - Invalid local variable name\n", Index); 771 return; 772 } 773 774 Status = AcpiDsStoreObjectToLocal (AML_LOCAL_OP, Index, ObjDesc, WalkState); 775 if (ACPI_FAILURE (Status)) 776 { 777 return; 778 } 779 780 ObjDesc = WalkState->LocalVariables[Index].Object; 781 782 AcpiOsPrintf ("Local%d: ", Index); 783 AcpiDmDisplayInternalObject (ObjDesc, WalkState); 784 break; 785 786 default: 787 break; 788 } 789} 790 791 792/******************************************************************************* 793 * 794 * FUNCTION: AcpiDbWalkForSpecificObjects 795 * 796 * PARAMETERS: Callback from WalkNamespace 797 * 798 * RETURN: Status 799 * 800 * DESCRIPTION: Display short info about objects in the namespace 801 * 802 ******************************************************************************/ 803 804ACPI_STATUS 805AcpiDbWalkForSpecificObjects ( 806 ACPI_HANDLE ObjHandle, 807 UINT32 NestingLevel, 808 void *Context, 809 void **ReturnValue) 810{ 811 ACPI_OPERAND_OBJECT *ObjDesc; 812 ACPI_STATUS Status; 813 ACPI_BUFFER Buffer; 814 815 816 ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) ObjHandle); 817 818 /* Get and display the full pathname to this object */ 819 820 Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER; 821 Status = AcpiNsHandleToPathname (ObjHandle, &Buffer); 822 if (ACPI_FAILURE (Status)) 823 { 824 AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle); 825 return (AE_OK); 826 } 827 828 AcpiOsPrintf ("%32s", (char *) Buffer.Pointer); 829 ACPI_MEM_FREE (Buffer.Pointer); 830 831 /* Display short information about the object */ 832 833 if (ObjDesc) 834 { 835 switch (ACPI_GET_OBJECT_TYPE (ObjDesc)) 836 { 837 case ACPI_TYPE_METHOD: 838 AcpiOsPrintf (" #Args %d Concurrency %X", 839 ObjDesc->Method.ParamCount, ObjDesc->Method.Concurrency); 840 break; 841 842 case ACPI_TYPE_INTEGER: 843 AcpiOsPrintf (" Value %8.8X%8.8X", 844 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value)); 845 break; 846 847 case ACPI_TYPE_STRING: 848 AcpiOsPrintf (" \"%s\"", ObjDesc->String.Pointer); 849 break; 850 851 case ACPI_TYPE_REGION: 852 AcpiOsPrintf (" SpaceId %X Length %X Address %8.8X%8.8X", 853 ObjDesc->Region.SpaceId, 854 ObjDesc->Region.Length, 855 ACPI_FORMAT_UINT64 (ObjDesc->Region.Address)); 856 break; 857 858 case ACPI_TYPE_PACKAGE: 859 AcpiOsPrintf (" #Elements %X", ObjDesc->Package.Count); 860 break; 861 862 case ACPI_TYPE_BUFFER: 863 AcpiOsPrintf (" Length %X", ObjDesc->Buffer.Length); 864 break; 865 866 default: 867 /* Ignore other object types */ 868 break; 869 } 870 } 871 872 AcpiOsPrintf ("\n"); 873 return (AE_OK); 874} 875 876 877/******************************************************************************* 878 * 879 * FUNCTION: AcpiDbDisplayObjects 880 * 881 * PARAMETERS: ObjTypeArg - Type of object to display 882 * DisplayCountArg - Max depth to display 883 * 884 * RETURN: None 885 * 886 * DESCRIPTION: Display objects in the namespace of the requested type 887 * 888 ******************************************************************************/ 889 890ACPI_STATUS 891AcpiDbDisplayObjects ( 892 char *ObjTypeArg, 893 char *DisplayCountArg) 894{ 895 ACPI_OBJECT_TYPE Type; 896 897 898 /* Get the object type */ 899 900 Type = AcpiDbMatchArgument (ObjTypeArg, AcpiDbObjectTypes); 901 if (Type == ACPI_TYPE_NOT_FOUND) 902 { 903 AcpiOsPrintf ("Invalid or unsupported argument\n"); 904 return (AE_OK); 905 } 906 907 AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT); 908 AcpiOsPrintf ("Objects of type [%s] defined in the current ACPI Namespace: \n", 909 AcpiUtGetTypeName (Type)); 910 911 AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT); 912 913 /* Walk the namespace from the root */ 914 915 (void) AcpiWalkNamespace (Type, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, 916 AcpiDbWalkForSpecificObjects, (void *) &Type, NULL); 917 918 AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT); 919 return (AE_OK); 920} 921 922 923/******************************************************************************* 924 * 925 * FUNCTION: AcpiDbWalkAndMatchName 926 * 927 * PARAMETERS: Callback from WalkNamespace 928 * 929 * RETURN: Status 930 * 931 * DESCRIPTION: Find a particular name/names within the namespace. Wildcards 932 * are supported -- '?' matches any character. 933 * 934 ******************************************************************************/ 935 936ACPI_STATUS 937AcpiDbWalkAndMatchName ( 938 ACPI_HANDLE ObjHandle, 939 UINT32 NestingLevel, 940 void *Context, 941 void **ReturnValue) 942{ 943 ACPI_STATUS Status; 944 char *RequestedName = (char *) Context; 945 UINT32 i; 946 ACPI_BUFFER Buffer; 947 948 949 /* Check for a name match */ 950 951 for (i = 0; i < 4; i++) 952 { 953 /* Wildcard support */ 954 955 if ((RequestedName[i] != '?') && 956 (RequestedName[i] != ((ACPI_NAMESPACE_NODE *) ObjHandle)->Name.Ascii[i])) 957 { 958 /* No match, just exit */ 959 960 return (AE_OK); 961 } 962 } 963 964 /* Get the full pathname to this object */ 965 966 Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER; 967 Status = AcpiNsHandleToPathname (ObjHandle, &Buffer); 968 if (ACPI_FAILURE (Status)) 969 { 970 AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle); 971 } 972 else 973 { 974 AcpiOsPrintf ("%32s (%p) - %s\n", (char *) Buffer.Pointer, ObjHandle, 975 AcpiUtGetTypeName (((ACPI_NAMESPACE_NODE *) ObjHandle)->Type)); 976 ACPI_MEM_FREE (Buffer.Pointer); 977 } 978 979 return (AE_OK); 980} 981 982 983/******************************************************************************* 984 * 985 * FUNCTION: AcpiDbFindNameInNamespace 986 * 987 * PARAMETERS: NameArg - The 4-character ACPI name to find. 988 * wildcards are supported. 989 * 990 * RETURN: None 991 * 992 * DESCRIPTION: Search the namespace for a given name (with wildcards) 993 * 994 ******************************************************************************/ 995 996ACPI_STATUS 997AcpiDbFindNameInNamespace ( 998 char *NameArg) 999{ 1000 1001 if (ACPI_STRLEN (NameArg) > 4) 1002 { 1003 AcpiOsPrintf ("Name must be no longer than 4 characters\n"); 1004 return (AE_OK); 1005 } 1006 1007 /* Walk the namespace from the root */ 1008 1009 (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, 1010 AcpiDbWalkAndMatchName, NameArg, NULL); 1011 1012 AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT); 1013 return (AE_OK); 1014} 1015 1016 1017/******************************************************************************* 1018 * 1019 * FUNCTION: AcpiDbSetScope 1020 * 1021 * PARAMETERS: Name - New scope path 1022 * 1023 * RETURN: Status 1024 * 1025 * DESCRIPTION: Set the "current scope" as maintained by this utility. 1026 * The scope is used as a prefix to ACPI paths. 1027 * 1028 ******************************************************************************/ 1029 1030void 1031AcpiDbSetScope ( 1032 char *Name) 1033{ 1034 ACPI_STATUS Status; 1035 ACPI_NAMESPACE_NODE *Node; 1036 1037 1038 if (!Name || Name[0] == 0) 1039 { 1040 AcpiOsPrintf ("Current scope: %s\n", AcpiGbl_DbScopeBuf); 1041 return; 1042 } 1043 1044 AcpiDbPrepNamestring (Name); 1045 1046 if (Name[0] == '\\') 1047 { 1048 /* Validate new scope from the root */ 1049 1050 Status = AcpiNsGetNodeByPath (Name, AcpiGbl_RootNode, ACPI_NS_NO_UPSEARCH, &Node); 1051 if (ACPI_FAILURE (Status)) 1052 { 1053 goto ErrorExit; 1054 } 1055 1056 ACPI_STRCPY (AcpiGbl_DbScopeBuf, Name); 1057 ACPI_STRCAT (AcpiGbl_DbScopeBuf, "\\"); 1058 } 1059 else 1060 { 1061 /* Validate new scope relative to old scope */ 1062 1063 Status = AcpiNsGetNodeByPath (Name, AcpiGbl_DbScopeNode, ACPI_NS_NO_UPSEARCH, &Node); 1064 if (ACPI_FAILURE (Status)) 1065 { 1066 goto ErrorExit; 1067 } 1068 1069 ACPI_STRCAT (AcpiGbl_DbScopeBuf, Name); 1070 ACPI_STRCAT (AcpiGbl_DbScopeBuf, "\\"); 1071 } 1072 1073 AcpiGbl_DbScopeNode = Node; 1074 AcpiOsPrintf ("New scope: %s\n", AcpiGbl_DbScopeBuf); 1075 return; 1076 1077ErrorExit: 1078 1079 AcpiOsPrintf ("Could not attach scope: %s, %s\n", Name, AcpiFormatException (Status)); 1080} 1081 1082 1083/******************************************************************************* 1084 * 1085 * FUNCTION: AcpiDbDisplayResources 1086 * 1087 * PARAMETERS: ObjectArg - String with hex value of the object 1088 * 1089 * RETURN: None 1090 * 1091 * DESCRIPTION: Display the resource objects associated with a device. 1092 * 1093 ******************************************************************************/ 1094 1095void 1096AcpiDbDisplayResources ( 1097 char *ObjectArg) 1098{ 1099#if ACPI_MACHINE_WIDTH != 16 1100 1101 ACPI_OPERAND_OBJECT *ObjDesc; 1102 ACPI_STATUS Status; 1103 ACPI_BUFFER ReturnObj; 1104 1105 1106 AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT); 1107 AcpiDbgLevel |= ACPI_LV_RESOURCES; 1108 1109 /* Convert string to object pointer */ 1110 1111 ObjDesc = ACPI_TO_POINTER (ACPI_STRTOUL (ObjectArg, NULL, 16)); 1112 1113 /* Prepare for a return object of arbitrary size */ 1114 1115 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1116 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1117 1118 /* _PRT */ 1119 1120 AcpiOsPrintf ("Evaluating _PRT\n"); 1121 1122 Status = AcpiEvaluateObject (ObjDesc, "_PRT", NULL, &ReturnObj); 1123 if (ACPI_FAILURE (Status)) 1124 { 1125 AcpiOsPrintf ("Could not obtain _PRT: %s\n", AcpiFormatException (Status)); 1126 goto GetCrs; 1127 } 1128 1129 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1130 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1131 1132 Status = AcpiGetIrqRoutingTable (ObjDesc, &ReturnObj); 1133 if (ACPI_FAILURE (Status)) 1134 { 1135 AcpiOsPrintf ("GetIrqRoutingTable failed: %s\n", AcpiFormatException (Status)); 1136 } 1137 else 1138 { 1139 AcpiRsDumpIrqList ((UINT8 *) AcpiGbl_DbBuffer); 1140 } 1141 1142 1143 /* _CRS */ 1144 1145GetCrs: 1146 AcpiOsPrintf ("Evaluating _CRS\n"); 1147 1148 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1149 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1150 1151 Status = AcpiEvaluateObject (ObjDesc, "_CRS", NULL, &ReturnObj); 1152 if (ACPI_FAILURE (Status)) 1153 { 1154 AcpiOsPrintf ("Could not obtain _CRS: %s\n", AcpiFormatException (Status)); 1155 goto GetPrs; 1156 } 1157 1158 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1159 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1160 1161 Status = AcpiGetCurrentResources (ObjDesc, &ReturnObj); 1162 if (ACPI_FAILURE (Status)) 1163 { 1164 AcpiOsPrintf ("AcpiGetCurrentResources failed: %s\n", AcpiFormatException (Status)); 1165 goto GetPrs; 1166 } 1167 else 1168 { 1169 AcpiRsDumpResourceList (ACPI_CAST_PTR (ACPI_RESOURCE, AcpiGbl_DbBuffer)); 1170 } 1171 1172 Status = AcpiSetCurrentResources (ObjDesc, &ReturnObj); 1173 if (ACPI_FAILURE (Status)) 1174 { 1175 AcpiOsPrintf ("AcpiSetCurrentResources failed: %s\n", AcpiFormatException (Status)); 1176 goto GetPrs; 1177 } 1178 1179 1180 /* _PRS */ 1181 1182GetPrs: 1183 AcpiOsPrintf ("Evaluating _PRS\n"); 1184 1185 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1186 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1187 1188 Status = AcpiEvaluateObject (ObjDesc, "_PRS", NULL, &ReturnObj); 1189 if (ACPI_FAILURE (Status)) 1190 { 1191 AcpiOsPrintf ("Could not obtain _PRS: %s\n", AcpiFormatException (Status)); 1192 goto Cleanup; 1193 } 1194 1195 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1196 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1197 1198 Status = AcpiGetPossibleResources (ObjDesc, &ReturnObj); 1199 if (ACPI_FAILURE (Status)) 1200 { 1201 AcpiOsPrintf ("AcpiGetPossibleResources failed: %s\n", AcpiFormatException (Status)); 1202 } 1203 else 1204 { 1205 AcpiRsDumpResourceList (ACPI_CAST_PTR (ACPI_RESOURCE, AcpiGbl_DbBuffer)); 1206 } 1207 1208Cleanup: 1209 1210 AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT); 1211 return; 1212#endif 1213} 1214 1215 1216/******************************************************************************* 1217 * 1218 * FUNCTION: AcpiDbIntegrityWalk 1219 * 1220 * PARAMETERS: Callback from WalkNamespace 1221 * 1222 * RETURN: Status 1223 * 1224 * DESCRIPTION: Examine one NS node for valid values. 1225 * 1226 ******************************************************************************/ 1227 1228ACPI_STATUS 1229AcpiDbIntegrityWalk ( 1230 ACPI_HANDLE ObjHandle, 1231 UINT32 NestingLevel, 1232 void *Context, 1233 void **ReturnValue) 1234{ 1235 ACPI_INTEGRITY_INFO *Info = (ACPI_INTEGRITY_INFO *) Context; 1236 ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) ObjHandle; 1237 ACPI_OPERAND_OBJECT *Object; 1238 1239 1240 Info->Nodes++; 1241 if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED) 1242 { 1243 AcpiOsPrintf ("Invalid Descriptor Type for Node %p [%s]\n", 1244 Node, AcpiUtGetDescriptorName (Node)); 1245 } 1246 1247 if (Node->Type > ACPI_TYPE_LOCAL_MAX) 1248 { 1249 AcpiOsPrintf ("Invalid Object Type for Node %p, Type = %X\n", 1250 Node, Node->Type); 1251 } 1252 1253 if (!AcpiUtValidAcpiName (Node->Name.Integer)) 1254 { 1255 AcpiOsPrintf ("Invalid AcpiName for Node %p\n", Node); 1256 } 1257 1258 Object = AcpiNsGetAttachedObject (Node); 1259 if (Object) 1260 { 1261 Info->Objects++; 1262 if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND) 1263 { 1264 AcpiOsPrintf ("Invalid Descriptor Type for Object %p [%s]\n", 1265 Object, AcpiUtGetDescriptorName (Object)); 1266 } 1267 } 1268 1269 return (AE_OK); 1270} 1271 1272 1273/******************************************************************************* 1274 * 1275 * FUNCTION: AcpiDbCheckIntegrity 1276 * 1277 * PARAMETERS: None 1278 * 1279 * RETURN: None 1280 * 1281 * DESCRIPTION: Check entire namespace for data structure integrity 1282 * 1283 ******************************************************************************/ 1284 1285void 1286AcpiDbCheckIntegrity (void) 1287{ 1288 ACPI_INTEGRITY_INFO Info = {0,0}; 1289 1290 /* Search all nodes in namespace */ 1291 1292 (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, 1293 AcpiDbIntegrityWalk, (void *) &Info, NULL); 1294 1295 AcpiOsPrintf ("Verified %d namespace nodes with %d Objects\n", Info.Nodes, Info.Objects); 1296} 1297 1298 1299/******************************************************************************* 1300 * 1301 * FUNCTION: AcpiDbGenerateGpe 1302 * 1303 * PARAMETERS: None 1304 * 1305 * RETURN: None 1306 * 1307 * DESCRIPTION: Generate a GPE 1308 * 1309 ******************************************************************************/ 1310 1311void 1312AcpiDbGenerateGpe ( 1313 char *GpeArg, 1314 char *BlockArg) 1315{ 1316 UINT32 BlockNumber; 1317 UINT32 GpeNumber; 1318 ACPI_GPE_EVENT_INFO *GpeEventInfo; 1319 1320 1321 GpeNumber = ACPI_STRTOUL (GpeArg, NULL, 0); 1322 BlockNumber = ACPI_STRTOUL (BlockArg, NULL, 0); 1323 1324 1325 GpeEventInfo = AcpiEvGetGpeEventInfo (ACPI_TO_POINTER (BlockNumber), GpeNumber); 1326 if (!GpeEventInfo) 1327 { 1328 AcpiOsPrintf ("Invalid GPE\n"); 1329 return; 1330 } 1331 1332 (void) AcpiEvGpeDispatch (GpeEventInfo, GpeNumber); 1333} 1334 1335#endif /* ACPI_DEBUGGER */
| 192} 193 194 195/******************************************************************************* 196 * 197 * FUNCTION: AcpiDbWalkForReferences 198 * 199 * PARAMETERS: Callback from WalkNamespace 200 * 201 * RETURN: Status 202 * 203 * DESCRIPTION: Check if this namespace object refers to the target object 204 * that is passed in as the context value. 205 * 206 * Note: Currently doesn't check subobjects within the Node's object 207 * 208 ******************************************************************************/ 209 210ACPI_STATUS 211AcpiDbWalkForReferences ( 212 ACPI_HANDLE ObjHandle, 213 UINT32 NestingLevel, 214 void *Context, 215 void **ReturnValue) 216{ 217 ACPI_OPERAND_OBJECT *ObjDesc = (ACPI_OPERAND_OBJECT *) Context; 218 ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) ObjHandle; 219 220 221 /* Check for match against the namespace node itself */ 222 223 if (Node == (void *) ObjDesc) 224 { 225 AcpiOsPrintf ("Object is a Node [%4.4s]\n", 226 AcpiUtGetNodeName (Node)); 227 } 228 229 /* Check for match against the object attached to the node */ 230 231 if (AcpiNsGetAttachedObject (Node) == ObjDesc) 232 { 233 AcpiOsPrintf ("Reference at Node->Object %p [%4.4s]\n", 234 Node, AcpiUtGetNodeName (Node)); 235 } 236 237 return (AE_OK); 238} 239 240 241/******************************************************************************* 242 * 243 * FUNCTION: AcpiDbFindReferences 244 * 245 * PARAMETERS: ObjectArg - String with hex value of the object 246 * 247 * RETURN: None 248 * 249 * DESCRIPTION: Search namespace for all references to the input object 250 * 251 ******************************************************************************/ 252 253void 254AcpiDbFindReferences ( 255 char *ObjectArg) 256{ 257 ACPI_OPERAND_OBJECT *ObjDesc; 258 259 260 /* Convert string to object pointer */ 261 262 ObjDesc = ACPI_TO_POINTER (ACPI_STRTOUL (ObjectArg, NULL, 16)); 263 264 /* Search all nodes in namespace */ 265 266 (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, 267 AcpiDbWalkForReferences, (void *) ObjDesc, NULL); 268} 269 270 271/******************************************************************************* 272 * 273 * FUNCTION: AcpiDbDisplayLocks 274 * 275 * PARAMETERS: None 276 * 277 * RETURN: None 278 * 279 * DESCRIPTION: Display information about internal mutexes. 280 * 281 ******************************************************************************/ 282 283void 284AcpiDbDisplayLocks (void) 285{ 286 UINT32 i; 287 288 289 for (i = 0; i < MAX_MUTEX; i++) 290 { 291 AcpiOsPrintf ("%26s : %s\n", AcpiUtGetMutexName (i), 292 AcpiGbl_MutexInfo[i].OwnerId == ACPI_MUTEX_NOT_ACQUIRED 293 ? "Locked" : "Unlocked"); 294 } 295} 296 297 298/******************************************************************************* 299 * 300 * FUNCTION: AcpiDbDisplayTableInfo 301 * 302 * PARAMETERS: TableArg - String with name of table to be displayed 303 * 304 * RETURN: None 305 * 306 * DESCRIPTION: Display information about loaded tables. Current 307 * implementation displays all loaded tables. 308 * 309 ******************************************************************************/ 310 311void 312AcpiDbDisplayTableInfo ( 313 char *TableArg) 314{ 315 UINT32 i; 316 ACPI_TABLE_DESC *TableDesc; 317 318 319 for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++) 320 { 321 TableDesc = AcpiGbl_TableLists[i].Next; 322 while (TableDesc) 323 { 324 AcpiOsPrintf ( "%s at %p length %.5X", 325 AcpiGbl_TableData[i].Name, TableDesc->Pointer, 326 (UINT32) TableDesc->Length); 327 328 if (i != ACPI_TABLE_FACS) 329 { 330 AcpiOsPrintf (" OemID=%6s TableId=%8s OemRevision=%8.8X", 331 TableDesc->Pointer->OemId, 332 TableDesc->Pointer->OemTableId, 333 TableDesc->Pointer->OemRevision); 334 } 335 AcpiOsPrintf ("\n"); 336 337 TableDesc = TableDesc->Next; 338 } 339 } 340} 341 342 343/******************************************************************************* 344 * 345 * FUNCTION: AcpiDbUnloadAcpiTable 346 * 347 * PARAMETERS: TableArg - Name of the table to be unloaded 348 * InstanceArg - Which instance of the table to unload (if 349 * there are multiple tables of the same type) 350 * 351 * RETURN: Nonde 352 * 353 * DESCRIPTION: Unload an ACPI table. 354 * Instance is not implemented 355 * 356 ******************************************************************************/ 357 358void 359AcpiDbUnloadAcpiTable ( 360 char *TableArg, 361 char *InstanceArg) 362{ 363 UINT32 i; 364 ACPI_STATUS Status; 365 366 367 /* Search all tables for the target type */ 368 369 for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++) 370 { 371 if (!ACPI_STRNCMP (TableArg, AcpiGbl_TableData[i].Signature, 372 AcpiGbl_TableData[i].SigLength)) 373 { 374 /* Found the table, unload it */ 375 376 Status = AcpiUnloadTable (i); 377 if (ACPI_SUCCESS (Status)) 378 { 379 AcpiOsPrintf ("[%s] unloaded and uninstalled\n", TableArg); 380 } 381 else 382 { 383 AcpiOsPrintf ("%s, while unloading [%s]\n", 384 AcpiFormatException (Status), TableArg); 385 } 386 387 return; 388 } 389 } 390 391 AcpiOsPrintf ("Unknown table type [%s]\n", TableArg); 392} 393 394 395/******************************************************************************* 396 * 397 * FUNCTION: AcpiDbSetMethodBreakpoint 398 * 399 * PARAMETERS: Location - AML offset of breakpoint 400 * WalkState - Current walk info 401 * Op - Current Op (from parse walk) 402 * 403 * RETURN: None 404 * 405 * DESCRIPTION: Set a breakpoint in a control method at the specified 406 * AML offset 407 * 408 ******************************************************************************/ 409 410void 411AcpiDbSetMethodBreakpoint ( 412 char *Location, 413 ACPI_WALK_STATE *WalkState, 414 ACPI_PARSE_OBJECT *Op) 415{ 416 UINT32 Address; 417 418 419 if (!Op) 420 { 421 AcpiOsPrintf ("There is no method currently executing\n"); 422 return; 423 } 424 425 /* Get and verify the breakpoint address */ 426 427 Address = ACPI_STRTOUL (Location, NULL, 16); 428 if (Address <= Op->Common.AmlOffset) 429 { 430 AcpiOsPrintf ("Breakpoint %X is beyond current address %X\n", Address, Op->Common.AmlOffset); 431 } 432 433 /* Save breakpoint in current walk */ 434 435 WalkState->UserBreakpoint = Address; 436 AcpiOsPrintf ("Breakpoint set at AML offset %X\n", Address); 437} 438 439 440/******************************************************************************* 441 * 442 * FUNCTION: AcpiDbSetMethodCallBreakpoint 443 * 444 * PARAMETERS: Op - Current Op (from parse walk) 445 * 446 * RETURN: None 447 * 448 * DESCRIPTION: Set a breakpoint in a control method at the specified 449 * AML offset 450 * 451 ******************************************************************************/ 452 453void 454AcpiDbSetMethodCallBreakpoint ( 455 ACPI_PARSE_OBJECT *Op) 456{ 457 458 459 if (!Op) 460 { 461 AcpiOsPrintf ("There is no method currently executing\n"); 462 return; 463 } 464 465 AcpiGbl_StepToNextCall = TRUE; 466} 467 468 469/******************************************************************************* 470 * 471 * FUNCTION: AcpiDbDisassembleAml 472 * 473 * PARAMETERS: Statements - Number of statements to disassemble 474 * Op - Current Op (from parse walk) 475 * 476 * RETURN: None 477 * 478 * DESCRIPTION: Display disassembled AML (ASL) starting from Op for the number 479 * of statements specified. 480 * 481 ******************************************************************************/ 482 483void 484AcpiDbDisassembleAml ( 485 char *Statements, 486 ACPI_PARSE_OBJECT *Op) 487{ 488 UINT32 NumStatements = 8; 489 490 491 if (!Op) 492 { 493 AcpiOsPrintf ("There is no method currently executing\n"); 494 return; 495 } 496 497 if (Statements) 498 { 499 NumStatements = ACPI_STRTOUL (Statements, NULL, 0); 500 } 501 502 AcpiDmDisassemble (NULL, Op, NumStatements); 503} 504 505 506/******************************************************************************* 507 * 508 * FUNCTION: AcpiDbDumpNamespace 509 * 510 * PARAMETERS: StartArg - Node to begin namespace dump 511 * DepthArg - Maximum tree depth to be dumped 512 * 513 * RETURN: None 514 * 515 * DESCRIPTION: Dump entire namespace or a subtree. Each node is displayed 516 * with type and other information. 517 * 518 ******************************************************************************/ 519 520void 521AcpiDbDumpNamespace ( 522 char *StartArg, 523 char *DepthArg) 524{ 525 ACPI_HANDLE SubtreeEntry = AcpiGbl_RootNode; 526 UINT32 MaxDepth = ACPI_UINT32_MAX; 527 528 529 /* No argument given, just start at the root and dump entire namespace */ 530 531 if (StartArg) 532 { 533 /* Check if numeric argument, must be a Node */ 534 535 if ((StartArg[0] >= 0x30) && (StartArg[0] <= 0x39)) 536 { 537 SubtreeEntry = ACPI_TO_POINTER (ACPI_STRTOUL (StartArg, NULL, 16)); 538 if (!AcpiOsReadable (SubtreeEntry, sizeof (ACPI_NAMESPACE_NODE))) 539 { 540 AcpiOsPrintf ("Address %p is invalid in this address space\n", SubtreeEntry); 541 return; 542 } 543 544 if (ACPI_GET_DESCRIPTOR_TYPE (SubtreeEntry) != ACPI_DESC_TYPE_NAMED) 545 { 546 AcpiOsPrintf ("Address %p is not a valid NS node [%s]\n", 547 SubtreeEntry, AcpiUtGetDescriptorName (SubtreeEntry)); 548 return; 549 } 550 } 551 else 552 { 553 /* Alpha argument */ 554 /* The parameter is a name string that must be resolved to a Named obj*/ 555 556 SubtreeEntry = AcpiDbLocalNsLookup (StartArg); 557 if (!SubtreeEntry) 558 { 559 SubtreeEntry = AcpiGbl_RootNode; 560 } 561 } 562 563 /* Now we can check for the depth argument */ 564 565 if (DepthArg) 566 { 567 MaxDepth = ACPI_STRTOUL (DepthArg, NULL, 0); 568 } 569 } 570 571 AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT); 572 AcpiOsPrintf ("ACPI Namespace (from %p subtree):\n", SubtreeEntry); 573 574 /* Display the subtree */ 575 576 AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT); 577 AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth, ACPI_UINT32_MAX, SubtreeEntry); 578 AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT); 579} 580 581 582/******************************************************************************* 583 * 584 * FUNCTION: AcpiDbDumpNamespaceByOwner 585 * 586 * PARAMETERS: OwnerArg - Owner ID whose nodes will be displayed 587 * DepthArg - Maximum tree depth to be dumped 588 * 589 * RETURN: None 590 * 591 * DESCRIPTION: Dump elements of the namespace that are owned by the OwnerId. 592 * 593 ******************************************************************************/ 594 595void 596AcpiDbDumpNamespaceByOwner ( 597 char *OwnerArg, 598 char *DepthArg) 599{ 600 ACPI_HANDLE SubtreeEntry = AcpiGbl_RootNode; 601 UINT32 MaxDepth = ACPI_UINT32_MAX; 602 UINT16 OwnerId; 603 604 605 OwnerId = (UINT16) ACPI_STRTOUL (OwnerArg, NULL, 0); 606 607 /* Now we can check for the depth argument */ 608 609 if (DepthArg) 610 { 611 MaxDepth = ACPI_STRTOUL (DepthArg, NULL, 0); 612 } 613 614 AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT); 615 AcpiOsPrintf ("ACPI Namespace by owner %X:\n", OwnerId); 616 617 /* Display the subtree */ 618 619 AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT); 620 AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth, OwnerId, SubtreeEntry); 621 AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT); 622} 623 624 625/******************************************************************************* 626 * 627 * FUNCTION: AcpiDbSendNotify 628 * 629 * PARAMETERS: Name - Name of ACPI object to send the notify to 630 * Value - Value of the notify to send. 631 * 632 * RETURN: None 633 * 634 * DESCRIPTION: Send an ACPI notification. The value specified is sent to the 635 * named object as an ACPI notify. 636 * 637 ******************************************************************************/ 638 639void 640AcpiDbSendNotify ( 641 char *Name, 642 UINT32 Value) 643{ 644 ACPI_NAMESPACE_NODE *Node; 645 ACPI_STATUS Status; 646 647 648 /* Translate name to an Named object */ 649 650 Node = AcpiDbLocalNsLookup (Name); 651 if (!Node) 652 { 653 return; 654 } 655 656 /* Decode Named object type */ 657 658 switch (Node->Type) 659 { 660 case ACPI_TYPE_DEVICE: 661 case ACPI_TYPE_THERMAL: 662 663 /* Send the notify */ 664 665 Status = AcpiEvQueueNotifyRequest (Node, Value); 666 if (ACPI_FAILURE (Status)) 667 { 668 AcpiOsPrintf ("Could not queue notify\n"); 669 } 670 break; 671 672 default: 673 AcpiOsPrintf ("Named object is not a device or a thermal object\n"); 674 break; 675 } 676} 677 678 679/******************************************************************************* 680 * 681 * FUNCTION: AcpiDbSetMethodData 682 * 683 * PARAMETERS: TypeArg - L for local, A for argument 684 * IndexArg - which one 685 * ValueArg - Value to set. 686 * 687 * RETURN: None 688 * 689 * DESCRIPTION: Set a local or argument for the running control method. 690 * NOTE: only object supported is Number. 691 * 692 ******************************************************************************/ 693 694void 695AcpiDbSetMethodData ( 696 char *TypeArg, 697 char *IndexArg, 698 char *ValueArg) 699{ 700 char Type; 701 UINT32 Index; 702 UINT32 Value; 703 ACPI_WALK_STATE *WalkState; 704 ACPI_OPERAND_OBJECT *ObjDesc; 705 ACPI_STATUS Status; 706 707 708 /* Validate TypeArg */ 709 710 ACPI_STRUPR (TypeArg); 711 Type = TypeArg[0]; 712 if ((Type != 'L') && 713 (Type != 'A')) 714 { 715 AcpiOsPrintf ("Invalid SET operand: %s\n", TypeArg); 716 return; 717 } 718 719 /* Get the index and value */ 720 721 Index = ACPI_STRTOUL (IndexArg, NULL, 16); 722 Value = ACPI_STRTOUL (ValueArg, NULL, 16); 723 724 WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList); 725 if (!WalkState) 726 { 727 AcpiOsPrintf ("There is no method currently executing\n"); 728 return; 729 } 730 731 /* Create and initialize the new object */ 732 733 ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); 734 if (!ObjDesc) 735 { 736 AcpiOsPrintf ("Could not create an internal object\n"); 737 return; 738 } 739 740 ObjDesc->Integer.Value = Value; 741 742 /* Store the new object into the target */ 743 744 switch (Type) 745 { 746 case 'A': 747 748 /* Set a method argument */ 749 750 if (Index > ACPI_METHOD_MAX_ARG) 751 { 752 AcpiOsPrintf ("Arg%d - Invalid argument name\n", Index); 753 return; 754 } 755 756 Status = AcpiDsStoreObjectToLocal (AML_ARG_OP, Index, ObjDesc, WalkState); 757 if (ACPI_FAILURE (Status)) 758 { 759 return; 760 } 761 762 ObjDesc = WalkState->Arguments[Index].Object; 763 764 AcpiOsPrintf ("Arg%d: ", Index); 765 AcpiDmDisplayInternalObject (ObjDesc, WalkState); 766 break; 767 768 case 'L': 769 770 /* Set a method local */ 771 772 if (Index > ACPI_METHOD_MAX_LOCAL) 773 { 774 AcpiOsPrintf ("Local%d - Invalid local variable name\n", Index); 775 return; 776 } 777 778 Status = AcpiDsStoreObjectToLocal (AML_LOCAL_OP, Index, ObjDesc, WalkState); 779 if (ACPI_FAILURE (Status)) 780 { 781 return; 782 } 783 784 ObjDesc = WalkState->LocalVariables[Index].Object; 785 786 AcpiOsPrintf ("Local%d: ", Index); 787 AcpiDmDisplayInternalObject (ObjDesc, WalkState); 788 break; 789 790 default: 791 break; 792 } 793} 794 795 796/******************************************************************************* 797 * 798 * FUNCTION: AcpiDbWalkForSpecificObjects 799 * 800 * PARAMETERS: Callback from WalkNamespace 801 * 802 * RETURN: Status 803 * 804 * DESCRIPTION: Display short info about objects in the namespace 805 * 806 ******************************************************************************/ 807 808ACPI_STATUS 809AcpiDbWalkForSpecificObjects ( 810 ACPI_HANDLE ObjHandle, 811 UINT32 NestingLevel, 812 void *Context, 813 void **ReturnValue) 814{ 815 ACPI_OPERAND_OBJECT *ObjDesc; 816 ACPI_STATUS Status; 817 ACPI_BUFFER Buffer; 818 819 820 ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) ObjHandle); 821 822 /* Get and display the full pathname to this object */ 823 824 Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER; 825 Status = AcpiNsHandleToPathname (ObjHandle, &Buffer); 826 if (ACPI_FAILURE (Status)) 827 { 828 AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle); 829 return (AE_OK); 830 } 831 832 AcpiOsPrintf ("%32s", (char *) Buffer.Pointer); 833 ACPI_MEM_FREE (Buffer.Pointer); 834 835 /* Display short information about the object */ 836 837 if (ObjDesc) 838 { 839 switch (ACPI_GET_OBJECT_TYPE (ObjDesc)) 840 { 841 case ACPI_TYPE_METHOD: 842 AcpiOsPrintf (" #Args %d Concurrency %X", 843 ObjDesc->Method.ParamCount, ObjDesc->Method.Concurrency); 844 break; 845 846 case ACPI_TYPE_INTEGER: 847 AcpiOsPrintf (" Value %8.8X%8.8X", 848 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value)); 849 break; 850 851 case ACPI_TYPE_STRING: 852 AcpiOsPrintf (" \"%s\"", ObjDesc->String.Pointer); 853 break; 854 855 case ACPI_TYPE_REGION: 856 AcpiOsPrintf (" SpaceId %X Length %X Address %8.8X%8.8X", 857 ObjDesc->Region.SpaceId, 858 ObjDesc->Region.Length, 859 ACPI_FORMAT_UINT64 (ObjDesc->Region.Address)); 860 break; 861 862 case ACPI_TYPE_PACKAGE: 863 AcpiOsPrintf (" #Elements %X", ObjDesc->Package.Count); 864 break; 865 866 case ACPI_TYPE_BUFFER: 867 AcpiOsPrintf (" Length %X", ObjDesc->Buffer.Length); 868 break; 869 870 default: 871 /* Ignore other object types */ 872 break; 873 } 874 } 875 876 AcpiOsPrintf ("\n"); 877 return (AE_OK); 878} 879 880 881/******************************************************************************* 882 * 883 * FUNCTION: AcpiDbDisplayObjects 884 * 885 * PARAMETERS: ObjTypeArg - Type of object to display 886 * DisplayCountArg - Max depth to display 887 * 888 * RETURN: None 889 * 890 * DESCRIPTION: Display objects in the namespace of the requested type 891 * 892 ******************************************************************************/ 893 894ACPI_STATUS 895AcpiDbDisplayObjects ( 896 char *ObjTypeArg, 897 char *DisplayCountArg) 898{ 899 ACPI_OBJECT_TYPE Type; 900 901 902 /* Get the object type */ 903 904 Type = AcpiDbMatchArgument (ObjTypeArg, AcpiDbObjectTypes); 905 if (Type == ACPI_TYPE_NOT_FOUND) 906 { 907 AcpiOsPrintf ("Invalid or unsupported argument\n"); 908 return (AE_OK); 909 } 910 911 AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT); 912 AcpiOsPrintf ("Objects of type [%s] defined in the current ACPI Namespace: \n", 913 AcpiUtGetTypeName (Type)); 914 915 AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT); 916 917 /* Walk the namespace from the root */ 918 919 (void) AcpiWalkNamespace (Type, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, 920 AcpiDbWalkForSpecificObjects, (void *) &Type, NULL); 921 922 AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT); 923 return (AE_OK); 924} 925 926 927/******************************************************************************* 928 * 929 * FUNCTION: AcpiDbWalkAndMatchName 930 * 931 * PARAMETERS: Callback from WalkNamespace 932 * 933 * RETURN: Status 934 * 935 * DESCRIPTION: Find a particular name/names within the namespace. Wildcards 936 * are supported -- '?' matches any character. 937 * 938 ******************************************************************************/ 939 940ACPI_STATUS 941AcpiDbWalkAndMatchName ( 942 ACPI_HANDLE ObjHandle, 943 UINT32 NestingLevel, 944 void *Context, 945 void **ReturnValue) 946{ 947 ACPI_STATUS Status; 948 char *RequestedName = (char *) Context; 949 UINT32 i; 950 ACPI_BUFFER Buffer; 951 952 953 /* Check for a name match */ 954 955 for (i = 0; i < 4; i++) 956 { 957 /* Wildcard support */ 958 959 if ((RequestedName[i] != '?') && 960 (RequestedName[i] != ((ACPI_NAMESPACE_NODE *) ObjHandle)->Name.Ascii[i])) 961 { 962 /* No match, just exit */ 963 964 return (AE_OK); 965 } 966 } 967 968 /* Get the full pathname to this object */ 969 970 Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER; 971 Status = AcpiNsHandleToPathname (ObjHandle, &Buffer); 972 if (ACPI_FAILURE (Status)) 973 { 974 AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle); 975 } 976 else 977 { 978 AcpiOsPrintf ("%32s (%p) - %s\n", (char *) Buffer.Pointer, ObjHandle, 979 AcpiUtGetTypeName (((ACPI_NAMESPACE_NODE *) ObjHandle)->Type)); 980 ACPI_MEM_FREE (Buffer.Pointer); 981 } 982 983 return (AE_OK); 984} 985 986 987/******************************************************************************* 988 * 989 * FUNCTION: AcpiDbFindNameInNamespace 990 * 991 * PARAMETERS: NameArg - The 4-character ACPI name to find. 992 * wildcards are supported. 993 * 994 * RETURN: None 995 * 996 * DESCRIPTION: Search the namespace for a given name (with wildcards) 997 * 998 ******************************************************************************/ 999 1000ACPI_STATUS 1001AcpiDbFindNameInNamespace ( 1002 char *NameArg) 1003{ 1004 1005 if (ACPI_STRLEN (NameArg) > 4) 1006 { 1007 AcpiOsPrintf ("Name must be no longer than 4 characters\n"); 1008 return (AE_OK); 1009 } 1010 1011 /* Walk the namespace from the root */ 1012 1013 (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, 1014 AcpiDbWalkAndMatchName, NameArg, NULL); 1015 1016 AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT); 1017 return (AE_OK); 1018} 1019 1020 1021/******************************************************************************* 1022 * 1023 * FUNCTION: AcpiDbSetScope 1024 * 1025 * PARAMETERS: Name - New scope path 1026 * 1027 * RETURN: Status 1028 * 1029 * DESCRIPTION: Set the "current scope" as maintained by this utility. 1030 * The scope is used as a prefix to ACPI paths. 1031 * 1032 ******************************************************************************/ 1033 1034void 1035AcpiDbSetScope ( 1036 char *Name) 1037{ 1038 ACPI_STATUS Status; 1039 ACPI_NAMESPACE_NODE *Node; 1040 1041 1042 if (!Name || Name[0] == 0) 1043 { 1044 AcpiOsPrintf ("Current scope: %s\n", AcpiGbl_DbScopeBuf); 1045 return; 1046 } 1047 1048 AcpiDbPrepNamestring (Name); 1049 1050 if (Name[0] == '\\') 1051 { 1052 /* Validate new scope from the root */ 1053 1054 Status = AcpiNsGetNodeByPath (Name, AcpiGbl_RootNode, ACPI_NS_NO_UPSEARCH, &Node); 1055 if (ACPI_FAILURE (Status)) 1056 { 1057 goto ErrorExit; 1058 } 1059 1060 ACPI_STRCPY (AcpiGbl_DbScopeBuf, Name); 1061 ACPI_STRCAT (AcpiGbl_DbScopeBuf, "\\"); 1062 } 1063 else 1064 { 1065 /* Validate new scope relative to old scope */ 1066 1067 Status = AcpiNsGetNodeByPath (Name, AcpiGbl_DbScopeNode, ACPI_NS_NO_UPSEARCH, &Node); 1068 if (ACPI_FAILURE (Status)) 1069 { 1070 goto ErrorExit; 1071 } 1072 1073 ACPI_STRCAT (AcpiGbl_DbScopeBuf, Name); 1074 ACPI_STRCAT (AcpiGbl_DbScopeBuf, "\\"); 1075 } 1076 1077 AcpiGbl_DbScopeNode = Node; 1078 AcpiOsPrintf ("New scope: %s\n", AcpiGbl_DbScopeBuf); 1079 return; 1080 1081ErrorExit: 1082 1083 AcpiOsPrintf ("Could not attach scope: %s, %s\n", Name, AcpiFormatException (Status)); 1084} 1085 1086 1087/******************************************************************************* 1088 * 1089 * FUNCTION: AcpiDbDisplayResources 1090 * 1091 * PARAMETERS: ObjectArg - String with hex value of the object 1092 * 1093 * RETURN: None 1094 * 1095 * DESCRIPTION: Display the resource objects associated with a device. 1096 * 1097 ******************************************************************************/ 1098 1099void 1100AcpiDbDisplayResources ( 1101 char *ObjectArg) 1102{ 1103#if ACPI_MACHINE_WIDTH != 16 1104 1105 ACPI_OPERAND_OBJECT *ObjDesc; 1106 ACPI_STATUS Status; 1107 ACPI_BUFFER ReturnObj; 1108 1109 1110 AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT); 1111 AcpiDbgLevel |= ACPI_LV_RESOURCES; 1112 1113 /* Convert string to object pointer */ 1114 1115 ObjDesc = ACPI_TO_POINTER (ACPI_STRTOUL (ObjectArg, NULL, 16)); 1116 1117 /* Prepare for a return object of arbitrary size */ 1118 1119 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1120 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1121 1122 /* _PRT */ 1123 1124 AcpiOsPrintf ("Evaluating _PRT\n"); 1125 1126 Status = AcpiEvaluateObject (ObjDesc, "_PRT", NULL, &ReturnObj); 1127 if (ACPI_FAILURE (Status)) 1128 { 1129 AcpiOsPrintf ("Could not obtain _PRT: %s\n", AcpiFormatException (Status)); 1130 goto GetCrs; 1131 } 1132 1133 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1134 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1135 1136 Status = AcpiGetIrqRoutingTable (ObjDesc, &ReturnObj); 1137 if (ACPI_FAILURE (Status)) 1138 { 1139 AcpiOsPrintf ("GetIrqRoutingTable failed: %s\n", AcpiFormatException (Status)); 1140 } 1141 else 1142 { 1143 AcpiRsDumpIrqList ((UINT8 *) AcpiGbl_DbBuffer); 1144 } 1145 1146 1147 /* _CRS */ 1148 1149GetCrs: 1150 AcpiOsPrintf ("Evaluating _CRS\n"); 1151 1152 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1153 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1154 1155 Status = AcpiEvaluateObject (ObjDesc, "_CRS", NULL, &ReturnObj); 1156 if (ACPI_FAILURE (Status)) 1157 { 1158 AcpiOsPrintf ("Could not obtain _CRS: %s\n", AcpiFormatException (Status)); 1159 goto GetPrs; 1160 } 1161 1162 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1163 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1164 1165 Status = AcpiGetCurrentResources (ObjDesc, &ReturnObj); 1166 if (ACPI_FAILURE (Status)) 1167 { 1168 AcpiOsPrintf ("AcpiGetCurrentResources failed: %s\n", AcpiFormatException (Status)); 1169 goto GetPrs; 1170 } 1171 else 1172 { 1173 AcpiRsDumpResourceList (ACPI_CAST_PTR (ACPI_RESOURCE, AcpiGbl_DbBuffer)); 1174 } 1175 1176 Status = AcpiSetCurrentResources (ObjDesc, &ReturnObj); 1177 if (ACPI_FAILURE (Status)) 1178 { 1179 AcpiOsPrintf ("AcpiSetCurrentResources failed: %s\n", AcpiFormatException (Status)); 1180 goto GetPrs; 1181 } 1182 1183 1184 /* _PRS */ 1185 1186GetPrs: 1187 AcpiOsPrintf ("Evaluating _PRS\n"); 1188 1189 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1190 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1191 1192 Status = AcpiEvaluateObject (ObjDesc, "_PRS", NULL, &ReturnObj); 1193 if (ACPI_FAILURE (Status)) 1194 { 1195 AcpiOsPrintf ("Could not obtain _PRS: %s\n", AcpiFormatException (Status)); 1196 goto Cleanup; 1197 } 1198 1199 ReturnObj.Pointer = AcpiGbl_DbBuffer; 1200 ReturnObj.Length = ACPI_DEBUG_BUFFER_SIZE; 1201 1202 Status = AcpiGetPossibleResources (ObjDesc, &ReturnObj); 1203 if (ACPI_FAILURE (Status)) 1204 { 1205 AcpiOsPrintf ("AcpiGetPossibleResources failed: %s\n", AcpiFormatException (Status)); 1206 } 1207 else 1208 { 1209 AcpiRsDumpResourceList (ACPI_CAST_PTR (ACPI_RESOURCE, AcpiGbl_DbBuffer)); 1210 } 1211 1212Cleanup: 1213 1214 AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT); 1215 return; 1216#endif 1217} 1218 1219 1220/******************************************************************************* 1221 * 1222 * FUNCTION: AcpiDbIntegrityWalk 1223 * 1224 * PARAMETERS: Callback from WalkNamespace 1225 * 1226 * RETURN: Status 1227 * 1228 * DESCRIPTION: Examine one NS node for valid values. 1229 * 1230 ******************************************************************************/ 1231 1232ACPI_STATUS 1233AcpiDbIntegrityWalk ( 1234 ACPI_HANDLE ObjHandle, 1235 UINT32 NestingLevel, 1236 void *Context, 1237 void **ReturnValue) 1238{ 1239 ACPI_INTEGRITY_INFO *Info = (ACPI_INTEGRITY_INFO *) Context; 1240 ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) ObjHandle; 1241 ACPI_OPERAND_OBJECT *Object; 1242 1243 1244 Info->Nodes++; 1245 if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED) 1246 { 1247 AcpiOsPrintf ("Invalid Descriptor Type for Node %p [%s]\n", 1248 Node, AcpiUtGetDescriptorName (Node)); 1249 } 1250 1251 if (Node->Type > ACPI_TYPE_LOCAL_MAX) 1252 { 1253 AcpiOsPrintf ("Invalid Object Type for Node %p, Type = %X\n", 1254 Node, Node->Type); 1255 } 1256 1257 if (!AcpiUtValidAcpiName (Node->Name.Integer)) 1258 { 1259 AcpiOsPrintf ("Invalid AcpiName for Node %p\n", Node); 1260 } 1261 1262 Object = AcpiNsGetAttachedObject (Node); 1263 if (Object) 1264 { 1265 Info->Objects++; 1266 if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND) 1267 { 1268 AcpiOsPrintf ("Invalid Descriptor Type for Object %p [%s]\n", 1269 Object, AcpiUtGetDescriptorName (Object)); 1270 } 1271 } 1272 1273 return (AE_OK); 1274} 1275 1276 1277/******************************************************************************* 1278 * 1279 * FUNCTION: AcpiDbCheckIntegrity 1280 * 1281 * PARAMETERS: None 1282 * 1283 * RETURN: None 1284 * 1285 * DESCRIPTION: Check entire namespace for data structure integrity 1286 * 1287 ******************************************************************************/ 1288 1289void 1290AcpiDbCheckIntegrity (void) 1291{ 1292 ACPI_INTEGRITY_INFO Info = {0,0}; 1293 1294 /* Search all nodes in namespace */ 1295 1296 (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, 1297 AcpiDbIntegrityWalk, (void *) &Info, NULL); 1298 1299 AcpiOsPrintf ("Verified %d namespace nodes with %d Objects\n", Info.Nodes, Info.Objects); 1300} 1301 1302 1303/******************************************************************************* 1304 * 1305 * FUNCTION: AcpiDbGenerateGpe 1306 * 1307 * PARAMETERS: None 1308 * 1309 * RETURN: None 1310 * 1311 * DESCRIPTION: Generate a GPE 1312 * 1313 ******************************************************************************/ 1314 1315void 1316AcpiDbGenerateGpe ( 1317 char *GpeArg, 1318 char *BlockArg) 1319{ 1320 UINT32 BlockNumber; 1321 UINT32 GpeNumber; 1322 ACPI_GPE_EVENT_INFO *GpeEventInfo; 1323 1324 1325 GpeNumber = ACPI_STRTOUL (GpeArg, NULL, 0); 1326 BlockNumber = ACPI_STRTOUL (BlockArg, NULL, 0); 1327 1328 1329 GpeEventInfo = AcpiEvGetGpeEventInfo (ACPI_TO_POINTER (BlockNumber), GpeNumber); 1330 if (!GpeEventInfo) 1331 { 1332 AcpiOsPrintf ("Invalid GPE\n"); 1333 return; 1334 } 1335 1336 (void) AcpiEvGpeDispatch (GpeEventInfo, GpeNumber); 1337} 1338 1339#endif /* ACPI_DEBUGGER */
|