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

   1 /*******************************************************************************
   2  *
   3  * Module Name: dbnames - Debugger commands for the acpi namespace
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44
  45 #include <contrib/dev/acpica/include/acpi.h>
  46 #include <contrib/dev/acpica/include/accommon.h>
  47 #include <contrib/dev/acpica/include/acnamesp.h>
  48 #include <contrib/dev/acpica/include/acdebug.h>
  49 #include <contrib/dev/acpica/include/acpredef.h>
  50
  51
  52 #ifdef ACPI_DEBUGGER
  53
  54 #define _COMPONENT          ACPI_CA_DEBUGGER
  55         ACPI_MODULE_NAME    ("dbnames")
  56
  57
  58 /* Local prototypes */
  59
  60 static ACPI_STATUS
  61 AcpiDbWalkAndMatchName (
  62     ACPI_HANDLE             ObjHandle,
  63     UINT32                  NestingLevel,
  64     void                    *Context,
  65     void                    **ReturnValue);
  66
  67 static ACPI_STATUS
  68 AcpiDbWalkForPredefinedNames (
  69     ACPI_HANDLE             ObjHandle,
  70     UINT32                  NestingLevel,
  71     void                    *Context,
  72     void                    **ReturnValue);
  73
  74 static ACPI_STATUS
  75 AcpiDbWalkForSpecificObjects (
  76     ACPI_HANDLE             ObjHandle,
  77     UINT32                  NestingLevel,
  78     void                    *Context,
  79     void                    **ReturnValue);
  80
  81 static ACPI_STATUS
  82 AcpiDbIntegrityWalk (
  83     ACPI_HANDLE             ObjHandle,
  84     UINT32                  NestingLevel,
  85     void                    *Context,
  86     void                    **ReturnValue);
  87
  88 static ACPI_STATUS
  89 AcpiDbWalkForReferences (
  90     ACPI_HANDLE             ObjHandle,
  91     UINT32                  NestingLevel,
  92     void                    *Context,
  93     void                    **ReturnValue);
  94
  95 static ACPI_STATUS
  96 AcpiDbBusWalk (
  97     ACPI_HANDLE             ObjHandle,
  98     UINT32                  NestingLevel,
  99     void                    *Context,
 100     void                    **ReturnValue);
 101
 102 /*
 103  * Arguments for the Objects command
 104  * These object types map directly to the ACPI_TYPES
 105  */
 106 static ACPI_DB_ARGUMENT_INFO    AcpiDbObjectTypes [] =
 107 {
 108     {"ANY"},
 109     {"INTEGERS"},
 110     {"STRINGS"},
 111     {"BUFFERS"},
 112     {"PACKAGES"},
 113     {"FIELDS"},
 114     {"DEVICES"},
 115     {"EVENTS"},
 116     {"METHODS"},
 117     {"MUTEXES"},
 118     {"REGIONS"},
 119     {"POWERRESOURCES"},
 120     {"PROCESSORS"},
 121     {"THERMALZONES"},
 122     {"BUFFERFIELDS"},
 123     {"DDBHANDLES"},
 124     {"DEBUG"},
 125     {"REGIONFIELDS"},
 126     {"BANKFIELDS"},
 127     {"INDEXFIELDS"},
 128     {"REFERENCES"},
 129     {"ALIAS"},
 130     {NULL}           /* Must be null terminated */
 131 };
 132
 133
 134 /*******************************************************************************
 135  *
 136  * FUNCTION:    AcpiDbSetScope
 137  *
 138  * PARAMETERS:  Name                - New scope path
 139  *
 140  * RETURN:      Status
 141  *
 142  * DESCRIPTION: Set the "current scope" as maintained by this utility.
 143  *              The scope is used as a prefix to ACPI paths.
 144  *
 145  ******************************************************************************/
 146
 147 void
 148 AcpiDbSetScope (
 149     char                    *Name)
 150 {
 151     ACPI_STATUS             Status;
 152     ACPI_NAMESPACE_NODE     *Node;
 153
 154
 155     if (!Name || Name[0] == 0)
 156     {
 157         AcpiOsPrintf ("Current scope: %s\n", AcpiGbl_DbScopeBuf);
 158         return;
 159     }
 160
 161     AcpiDbPrepNamestring (Name);
 162
 163     if (ACPI_IS_ROOT_PREFIX (Name[0]))
 164     {
 165         /* Validate new scope from the root */
 166
 167         Status = AcpiNsGetNode (AcpiGbl_RootNode, Name, ACPI_NS_NO_UPSEARCH,
 168                     &Node);
 169         if (ACPI_FAILURE (Status))
 170         {
 171             goto ErrorExit;
 172         }
 173
 174         ACPI_STRCPY (AcpiGbl_DbScopeBuf, Name);
 175         ACPI_STRCAT (AcpiGbl_DbScopeBuf, "\\");
 176     }
 177     else
 178     {
 179         /* Validate new scope relative to old scope */
 180
 181         Status = AcpiNsGetNode (AcpiGbl_DbScopeNode, Name, ACPI_NS_NO_UPSEARCH,
 182                     &Node);
 183         if (ACPI_FAILURE (Status))
 184         {
 185             goto ErrorExit;
 186         }
 187
 188         ACPI_STRCAT (AcpiGbl_DbScopeBuf, Name);
 189         ACPI_STRCAT (AcpiGbl_DbScopeBuf, "\\");
 190     }
 191
 192     AcpiGbl_DbScopeNode = Node;
 193     AcpiOsPrintf ("New scope: %s\n", AcpiGbl_DbScopeBuf);
 194     return;
 195
 196 ErrorExit:
 197
 198     AcpiOsPrintf ("Could not attach scope: %s, %s\n",
 199         Name, AcpiFormatException (Status));
 200 }
 201
 202
 203 /*******************************************************************************
 204  *
 205  * FUNCTION:    AcpiDbDumpNamespace
 206  *
 207  * PARAMETERS:  StartArg        - Node to begin namespace dump
 208  *              DepthArg        - Maximum tree depth to be dumped
 209  *
 210  * RETURN:      None
 211  *
 212  * DESCRIPTION: Dump entire namespace or a subtree. Each node is displayed
 213  *              with type and other information.
 214  *
 215  ******************************************************************************/
 216
 217 void
 218 AcpiDbDumpNamespace (
 219     char                    *StartArg,
 220     char                    *DepthArg)
 221 {
 222     ACPI_HANDLE             SubtreeEntry = AcpiGbl_RootNode;
 223     UINT32                  MaxDepth = ACPI_UINT32_MAX;
 224
 225
 226     /* No argument given, just start at the root and dump entire namespace */
 227
 228     if (StartArg)
 229     {
 230         SubtreeEntry = AcpiDbConvertToNode (StartArg);
 231         if (!SubtreeEntry)
 232         {
 233             return;
 234         }
 235
 236         /* Now we can check for the depth argument */
 237
 238         if (DepthArg)
 239         {
 240             MaxDepth = ACPI_STRTOUL (DepthArg, NULL, 0);
 241         }
 242     }
 243
 244     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 245     AcpiOsPrintf ("ACPI Namespace (from %4.4s (%p) subtree):\n",
 246         ((ACPI_NAMESPACE_NODE *) SubtreeEntry)->Name.Ascii, SubtreeEntry);
 247
 248     /* Display the subtree */
 249
 250     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
 251     AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth,
 252         ACPI_OWNER_ID_MAX, SubtreeEntry);
 253     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 254 }
 255
 256
 257 /*******************************************************************************
 258  *
 259  * FUNCTION:    AcpiDbDumpNamespacePaths
 260  *
 261  * PARAMETERS:  None
 262  *
 263  * RETURN:      None
 264  *
 265  * DESCRIPTION: Dump entire namespace with full object pathnames and object
 266  *              type information. Alternative to "namespace" command.
 267  *
 268  ******************************************************************************/
 269
 270 void
 271 AcpiDbDumpNamespacePaths (
 272     void)
 273 {
 274
 275     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 276     AcpiOsPrintf ("ACPI Namespace (from root):\n");
 277
 278     /* Display the entire namespace */
 279
 280     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
 281     AcpiNsDumpObjectPaths (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY,
 282         ACPI_UINT32_MAX, ACPI_OWNER_ID_MAX, AcpiGbl_RootNode);
 283
 284     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 285 }
 286
 287
 288 /*******************************************************************************
 289  *
 290  * FUNCTION:    AcpiDbDumpNamespaceByOwner
 291  *
 292  * PARAMETERS:  OwnerArg        - Owner ID whose nodes will be displayed
 293  *              DepthArg        - Maximum tree depth to be dumped
 294  *
 295  * RETURN:      None
 296  *
 297  * DESCRIPTION: Dump elements of the namespace that are owned by the OwnerId.
 298  *
 299  ******************************************************************************/
 300
 301 void
 302 AcpiDbDumpNamespaceByOwner (
 303     char                    *OwnerArg,
 304     char                    *DepthArg)
 305 {
 306     ACPI_HANDLE             SubtreeEntry = AcpiGbl_RootNode;
 307     UINT32                  MaxDepth = ACPI_UINT32_MAX;
 308     ACPI_OWNER_ID           OwnerId;
 309
 310
 311     OwnerId = (ACPI_OWNER_ID) ACPI_STRTOUL (OwnerArg, NULL, 0);
 312
 313     /* Now we can check for the depth argument */
 314
 315     if (DepthArg)
 316     {
 317         MaxDepth = ACPI_STRTOUL (DepthArg, NULL, 0);
 318     }
 319
 320     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 321     AcpiOsPrintf ("ACPI Namespace by owner %X:\n", OwnerId);
 322
 323     /* Display the subtree */
 324
 325     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
 326     AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth, OwnerId,
 327         SubtreeEntry);
 328     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 329 }
 330
 331
 332 /*******************************************************************************
 333  *
 334  * FUNCTION:    AcpiDbWalkAndMatchName
 335  *
 336  * PARAMETERS:  Callback from WalkNamespace
 337  *
 338  * RETURN:      Status
 339  *
 340  * DESCRIPTION: Find a particular name/names within the namespace. Wildcards
 341  *              are supported -- '?' matches any character.
 342  *
 343  ******************************************************************************/
 344
 345 static ACPI_STATUS
 346 AcpiDbWalkAndMatchName (
 347     ACPI_HANDLE             ObjHandle,
 348     UINT32                  NestingLevel,
 349     void                    *Context,
 350     void                    **ReturnValue)
 351 {
 352     ACPI_STATUS             Status;
 353     char                    *RequestedName = (char *) Context;
 354     UINT32                  i;
 355     ACPI_BUFFER             Buffer;
 356     ACPI_WALK_INFO          Info;
 357
 358
 359     /* Check for a name match */
 360
 361     for (i = 0; i < 4; i++)
 362     {
 363         /* Wildcard support */
 364
 365         if ((RequestedName[i] != '?') &&
 366             (RequestedName[i] != ((ACPI_NAMESPACE_NODE *) ObjHandle)->Name.Ascii[i]))
 367         {
 368             /* No match, just exit */
 369
 370             return (AE_OK);
 371         }
 372     }
 373
 374     /* Get the full pathname to this object */
 375
 376     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 377     Status = AcpiNsHandleToPathname (ObjHandle, &Buffer);
 378     if (ACPI_FAILURE (Status))
 379     {
 380         AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle);
 381     }
 382     else
 383     {
 384         Info.OwnerId = ACPI_OWNER_ID_MAX;
 385         Info.DebugLevel = ACPI_UINT32_MAX;
 386         Info.DisplayType = ACPI_DISPLAY_SUMMARY | ACPI_DISPLAY_SHORT;
 387
 388         AcpiOsPrintf ("%32s", (char *) Buffer.Pointer);
 389         (void) AcpiNsDumpOneObject (ObjHandle, NestingLevel, &Info, NULL);
 390         ACPI_FREE (Buffer.Pointer);
 391     }
 392
 393     return (AE_OK);
 394 }
 395
 396
 397 /*******************************************************************************
 398  *
 399  * FUNCTION:    AcpiDbFindNameInNamespace
 400  *
 401  * PARAMETERS:  NameArg         - The 4-character ACPI name to find.
 402  *                                wildcards are supported.
 403  *
 404  * RETURN:      None
 405  *
 406  * DESCRIPTION: Search the namespace for a given name (with wildcards)
 407  *
 408  ******************************************************************************/
 409
 410 ACPI_STATUS
 411 AcpiDbFindNameInNamespace (
 412     char                    *NameArg)
 413 {
 414     char                    AcpiName[5] = "____";
 415     char                    *AcpiNamePtr = AcpiName;
 416
 417
 418     if (ACPI_STRLEN (NameArg) > 4)
 419     {
 420         AcpiOsPrintf ("Name must be no longer than 4 characters\n");
 421         return (AE_OK);
 422     }
 423
 424     /* Pad out name with underscores as necessary to create a 4-char name */
 425
 426     AcpiUtStrupr (NameArg);
 427     while (*NameArg)
 428     {
 429         *AcpiNamePtr = *NameArg;
 430         AcpiNamePtr++;
 431         NameArg++;
 432     }
 433
 434     /* Walk the namespace from the root */
 435
 436     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
 437                         AcpiDbWalkAndMatchName, NULL, AcpiName, NULL);
 438
 439     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 440     return (AE_OK);
 441 }
 442
 443
 444 /*******************************************************************************
 445  *
 446  * FUNCTION:    AcpiDbWalkForPredefinedNames
 447  *
 448  * PARAMETERS:  Callback from WalkNamespace
 449  *
 450  * RETURN:      Status
 451  *
 452  * DESCRIPTION: Detect and display predefined ACPI names (names that start with
 453  *              an underscore)
 454  *
 455  ******************************************************************************/
 456
 457 static ACPI_STATUS
 458 AcpiDbWalkForPredefinedNames (
 459     ACPI_HANDLE             ObjHandle,
 460     UINT32                  NestingLevel,
 461     void                    *Context,
 462     void                    **ReturnValue)
 463 {
 464     ACPI_NAMESPACE_NODE         *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 465     UINT32                      *Count = (UINT32 *) Context;
 466     const ACPI_PREDEFINED_INFO  *Predefined;
 467     const ACPI_PREDEFINED_INFO  *Package = NULL;
 468     char                        *Pathname;
 469     char                        StringBuffer[48];
 470
 471
 472     Predefined = AcpiUtMatchPredefinedMethod (Node->Name.Ascii);
 473     if (!Predefined)
 474     {
 475         return (AE_OK);
 476     }
 477
 478     Pathname = AcpiNsGetExternalPathname (Node);
 479     if (!Pathname)
 480     {
 481         return (AE_OK);
 482     }
 483
 484     /* If method returns a package, the info is in the next table entry */
 485
 486     if (Predefined->Info.ExpectedBtypes & ACPI_RTYPE_PACKAGE)
 487     {
 488         Package = Predefined + 1;
 489     }
 490
 491     AcpiUtGetExpectedReturnTypes (StringBuffer,
 492         Predefined->Info.ExpectedBtypes);
 493
 494     AcpiOsPrintf ("%-32s Arguments %X, Return Types: %s", Pathname,
 495         METHOD_GET_ARG_COUNT (Predefined->Info.ArgumentList),
 496         StringBuffer);
 497
 498     if (Package)
 499     {
 500         AcpiOsPrintf (" (PkgType %2.2X, ObjType %2.2X, Count %2.2X)",
 501             Package->RetInfo.Type, Package->RetInfo.ObjectType1,
 502             Package->RetInfo.Count1);
 503     }
 504
 505     AcpiOsPrintf("\n");
 506
 507     /* Check that the declared argument count matches the ACPI spec */
 508
 509     AcpiNsCheckAcpiCompliance (Pathname, Node, Predefined);
 510
 511     ACPI_FREE (Pathname);
 512     (*Count)++;
 513     return (AE_OK);
 514 }
 515
 516
 517 /*******************************************************************************
 518  *
 519  * FUNCTION:    AcpiDbCheckPredefinedNames
 520  *
 521  * PARAMETERS:  None
 522  *
 523  * RETURN:      None
 524  *
 525  * DESCRIPTION: Validate all predefined names in the namespace
 526  *
 527  ******************************************************************************/
 528
 529 void
 530 AcpiDbCheckPredefinedNames (
 531     void)
 532 {
 533     UINT32                  Count = 0;
 534
 535
 536     /* Search all nodes in namespace */
 537
 538     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
 539                 AcpiDbWalkForPredefinedNames, NULL, (void *) &Count, NULL);
 540
 541     AcpiOsPrintf ("Found %u predefined names in the namespace\n", Count);
 542 }
 543
 544
 545 /*******************************************************************************
 546  *
 547  * FUNCTION:    AcpiDbWalkForSpecificObjects
 548  *
 549  * PARAMETERS:  Callback from WalkNamespace
 550  *
 551  * RETURN:      Status
 552  *
 553  * DESCRIPTION: Display short info about objects in the namespace
 554  *
 555  ******************************************************************************/
 556
 557 static ACPI_STATUS
 558 AcpiDbWalkForSpecificObjects (
 559     ACPI_HANDLE             ObjHandle,
 560     UINT32                  NestingLevel,
 561     void                    *Context,
 562     void                    **ReturnValue)
 563 {
 564     ACPI_WALK_INFO          *Info = (ACPI_WALK_INFO *) Context;
 565     ACPI_BUFFER             Buffer;
 566     ACPI_STATUS             Status;
 567
 568
 569     Info->Count++;
 570
 571     /* Get and display the full pathname to this object */
 572
 573     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 574     Status = AcpiNsHandleToPathname (ObjHandle, &Buffer);
 575     if (ACPI_FAILURE (Status))
 576     {
 577         AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle);
 578         return (AE_OK);
 579     }
 580
 581     AcpiOsPrintf ("%32s", (char *) Buffer.Pointer);
 582     ACPI_FREE (Buffer.Pointer);
 583
 584     /* Dump short info about the object */
 585
 586     (void) AcpiNsDumpOneObject (ObjHandle, NestingLevel, Info, NULL);
 587     return (AE_OK);
 588 }
 589
 590
 591 /*******************************************************************************
 592  *
 593  * FUNCTION:    AcpiDbDisplayObjects
 594  *
 595  * PARAMETERS:  ObjTypeArg          - Type of object to display
 596  *              DisplayCountArg     - Max depth to display
 597  *
 598  * RETURN:      None
 599  *
 600  * DESCRIPTION: Display objects in the namespace of the requested type
 601  *
 602  ******************************************************************************/
 603
 604 ACPI_STATUS
 605 AcpiDbDisplayObjects (
 606     char                    *ObjTypeArg,
 607     char                    *DisplayCountArg)
 608 {
 609     ACPI_WALK_INFO          Info;
 610     ACPI_OBJECT_TYPE        Type;
 611
 612
 613     /* Get the object type */
 614
 615     Type = AcpiDbMatchArgument (ObjTypeArg, AcpiDbObjectTypes);
 616     if (Type == ACPI_TYPE_NOT_FOUND)
 617     {
 618         AcpiOsPrintf ("Invalid or unsupported argument\n");
 619         return (AE_OK);
 620     }
 621
 622     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 623     AcpiOsPrintf (
 624         "Objects of type [%s] defined in the current ACPI Namespace:\n",
 625         AcpiUtGetTypeName (Type));
 626
 627     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
 628
 629     Info.Count = 0;
 630     Info.OwnerId = ACPI_OWNER_ID_MAX;
 631     Info.DebugLevel = ACPI_UINT32_MAX;
 632     Info.DisplayType = ACPI_DISPLAY_SUMMARY | ACPI_DISPLAY_SHORT;
 633
 634     /* Walk the namespace from the root */
 635
 636     (void) AcpiWalkNamespace (Type, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
 637                 AcpiDbWalkForSpecificObjects, NULL, (void *) &Info, NULL);
 638
 639     AcpiOsPrintf (
 640         "\nFound %u objects of type [%s] in the current ACPI Namespace\n",
 641         Info.Count, AcpiUtGetTypeName (Type));
 642
 643     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 644     return (AE_OK);
 645 }
 646
 647
 648 /*******************************************************************************
 649  *
 650  * FUNCTION:    AcpiDbIntegrityWalk
 651  *
 652  * PARAMETERS:  Callback from WalkNamespace
 653  *
 654  * RETURN:      Status
 655  *
 656  * DESCRIPTION: Examine one NS node for valid values.
 657  *
 658  ******************************************************************************/
 659
 660 static ACPI_STATUS
 661 AcpiDbIntegrityWalk (
 662     ACPI_HANDLE             ObjHandle,
 663     UINT32                  NestingLevel,
 664     void                    *Context,
 665     void                    **ReturnValue)
 666 {
 667     ACPI_INTEGRITY_INFO     *Info = (ACPI_INTEGRITY_INFO *) Context;
 668     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 669     ACPI_OPERAND_OBJECT     *Object;
 670     BOOLEAN                 Alias = TRUE;
 671
 672
 673     Info->Nodes++;
 674
 675     /* Verify the NS node, and dereference aliases */
 676
 677     while (Alias)
 678     {
 679         if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
 680         {
 681             AcpiOsPrintf ("Invalid Descriptor Type for Node %p [%s] - is %2.2X should be %2.2X\n",
 682                 Node, AcpiUtGetDescriptorName (Node), ACPI_GET_DESCRIPTOR_TYPE (Node),
 683                 ACPI_DESC_TYPE_NAMED);
 684             return (AE_OK);
 685         }
 686
 687         if ((Node->Type == ACPI_TYPE_LOCAL_ALIAS)  ||
 688             (Node->Type == ACPI_TYPE_LOCAL_METHOD_ALIAS))
 689         {
 690             Node = (ACPI_NAMESPACE_NODE *) Node->Object;
 691         }
 692         else
 693         {
 694             Alias = FALSE;
 695         }
 696     }
 697
 698     if (Node->Type > ACPI_TYPE_LOCAL_MAX)
 699     {
 700         AcpiOsPrintf ("Invalid Object Type for Node %p, Type = %X\n",
 701             Node, Node->Type);
 702         return (AE_OK);
 703     }
 704
 705     if (!AcpiUtValidAcpiName (Node->Name.Ascii))
 706     {
 707         AcpiOsPrintf ("Invalid AcpiName for Node %p\n", Node);
 708         return (AE_OK);
 709     }
 710
 711     Object = AcpiNsGetAttachedObject (Node);
 712     if (Object)
 713     {
 714         Info->Objects++;
 715         if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
 716         {
 717             AcpiOsPrintf ("Invalid Descriptor Type for Object %p [%s]\n",
 718                 Object, AcpiUtGetDescriptorName (Object));
 719         }
 720     }
 721
 722     return (AE_OK);
 723 }
 724
 725
 726 /*******************************************************************************
 727  *
 728  * FUNCTION:    AcpiDbCheckIntegrity
 729  *
 730  * PARAMETERS:  None
 731  *
 732  * RETURN:      None
 733  *
 734  * DESCRIPTION: Check entire namespace for data structure integrity
 735  *
 736  ******************************************************************************/
 737
 738 void
 739 AcpiDbCheckIntegrity (
 740     void)
 741 {
 742     ACPI_INTEGRITY_INFO     Info = {0,0};
 743
 744     /* Search all nodes in namespace */
 745
 746     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
 747                     AcpiDbIntegrityWalk, NULL, (void *) &Info, NULL);
 748
 749     AcpiOsPrintf ("Verified %u namespace nodes with %u Objects\n",
 750         Info.Nodes, Info.Objects);
 751 }
 752
 753
 754 /*******************************************************************************
 755  *
 756  * FUNCTION:    AcpiDbWalkForReferences
 757  *
 758  * PARAMETERS:  Callback from WalkNamespace
 759  *
 760  * RETURN:      Status
 761  *
 762  * DESCRIPTION: Check if this namespace object refers to the target object
 763  *              that is passed in as the context value.
 764  *
 765  * Note: Currently doesn't check subobjects within the Node's object
 766  *
 767  ******************************************************************************/
 768
 769 static ACPI_STATUS
 770 AcpiDbWalkForReferences (
 771     ACPI_HANDLE             ObjHandle,
 772     UINT32                  NestingLevel,
 773     void                    *Context,
 774     void                    **ReturnValue)
 775 {
 776     ACPI_OPERAND_OBJECT     *ObjDesc = (ACPI_OPERAND_OBJECT  *) Context;
 777     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 778
 779
 780     /* Check for match against the namespace node itself */
 781
 782     if (Node == (void *) ObjDesc)
 783     {
 784         AcpiOsPrintf ("Object is a Node [%4.4s]\n",
 785             AcpiUtGetNodeName (Node));
 786     }
 787
 788     /* Check for match against the object attached to the node */
 789
 790     if (AcpiNsGetAttachedObject (Node) == ObjDesc)
 791     {
 792         AcpiOsPrintf ("Reference at Node->Object %p [%4.4s]\n",
 793             Node, AcpiUtGetNodeName (Node));
 794     }
 795
 796     return (AE_OK);
 797 }
 798
 799
 800 /*******************************************************************************
 801  *
 802  * FUNCTION:    AcpiDbFindReferences
 803  *
 804  * PARAMETERS:  ObjectArg       - String with hex value of the object
 805  *
 806  * RETURN:      None
 807  *
 808  * DESCRIPTION: Search namespace for all references to the input object
 809  *
 810  ******************************************************************************/
 811
 812 void
 813 AcpiDbFindReferences (
 814     char                    *ObjectArg)
 815 {
 816     ACPI_OPERAND_OBJECT     *ObjDesc;
 817     ACPI_SIZE               Address;
 818
 819
 820     /* Convert string to object pointer */
 821
 822     Address = ACPI_STRTOUL (ObjectArg, NULL, 16);
 823     ObjDesc = ACPI_TO_POINTER (Address);
 824
 825     /* Search all nodes in namespace */
 826
 827     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
 828                     AcpiDbWalkForReferences, NULL, (void *) ObjDesc, NULL);
 829 }
 830
 831
 832 /*******************************************************************************
 833  *
 834  * FUNCTION:    AcpiDbBusWalk
 835  *
 836  * PARAMETERS:  Callback from WalkNamespace
 837  *
 838  * RETURN:      Status
 839  *
 840  * DESCRIPTION: Display info about device objects that have a corresponding
 841  *              _PRT method.
 842  *
 843  ******************************************************************************/
 844
 845 static ACPI_STATUS
 846 AcpiDbBusWalk (
 847     ACPI_HANDLE             ObjHandle,
 848     UINT32                  NestingLevel,
 849     void                    *Context,
 850     void                    **ReturnValue)
 851 {
 852     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 853     ACPI_STATUS             Status;
 854     ACPI_BUFFER             Buffer;
 855     ACPI_NAMESPACE_NODE     *TempNode;
 856     ACPI_DEVICE_INFO        *Info;
 857     UINT32                  i;
 858
 859
 860     if ((Node->Type != ACPI_TYPE_DEVICE) &&
 861         (Node->Type != ACPI_TYPE_PROCESSOR))
 862     {
 863         return (AE_OK);
 864     }
 865
 866     /* Exit if there is no _PRT under this device */
 867
 868     Status = AcpiGetHandle (Node, METHOD_NAME__PRT,
 869                 ACPI_CAST_PTR (ACPI_HANDLE, &TempNode));
 870     if (ACPI_FAILURE (Status))
 871     {
 872         return (AE_OK);
 873     }
 874
 875     /* Get the full path to this device object */
 876
 877     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 878     Status = AcpiNsHandleToPathname (ObjHandle, &Buffer);
 879     if (ACPI_FAILURE (Status))
 880     {
 881         AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle);
 882         return (AE_OK);
 883     }
 884
 885     Status = AcpiGetObjectInfo (ObjHandle, &Info);
 886     if (ACPI_FAILURE (Status))
 887     {
 888         return (AE_OK);
 889     }
 890
 891     /* Display the full path */
 892
 893     AcpiOsPrintf ("%-32s Type %X", (char *) Buffer.Pointer, Node->Type);
 894     ACPI_FREE (Buffer.Pointer);
 895
 896     if (Info->Flags & ACPI_PCI_ROOT_BRIDGE)
 897     {
 898         AcpiOsPrintf ("  - Is PCI Root Bridge");
 899     }
 900     AcpiOsPrintf ("\n");
 901
 902     /* _PRT info */
 903
 904     AcpiOsPrintf ("_PRT: %p\n", TempNode);
 905
 906     /* Dump _ADR, _HID, _UID, _CID */
 907
 908     if (Info->Valid & ACPI_VALID_ADR)
 909     {
 910         AcpiOsPrintf ("_ADR: %8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Info->Address));
 911     }
 912     else
 913     {
 914         AcpiOsPrintf ("_ADR: <Not Present>\n");
 915     }
 916
 917     if (Info->Valid & ACPI_VALID_HID)
 918     {
 919         AcpiOsPrintf ("_HID: %s\n", Info->HardwareId.String);
 920     }
 921     else
 922     {
 923         AcpiOsPrintf ("_HID: <Not Present>\n");
 924     }
 925
 926     if (Info->Valid & ACPI_VALID_UID)
 927     {
 928         AcpiOsPrintf ("_UID: %s\n", Info->UniqueId.String);
 929     }
 930     else
 931     {
 932         AcpiOsPrintf ("_UID: <Not Present>\n");
 933     }
 934
 935     if (Info->Valid & ACPI_VALID_CID)
 936     {
 937         for (i = 0; i < Info->CompatibleIdList.Count; i++)
 938         {
 939             AcpiOsPrintf ("_CID: %s\n",
 940                 Info->CompatibleIdList.Ids[i].String);
 941         }
 942     }
 943     else
 944     {
 945         AcpiOsPrintf ("_CID: <Not Present>\n");
 946     }
 947
 948     ACPI_FREE (Info);
 949     return (AE_OK);
 950 }
 951
 952
 953 /*******************************************************************************
 954  *
 955  * FUNCTION:    AcpiDbGetBusInfo
 956  *
 957  * PARAMETERS:  None
 958  *
 959  * RETURN:      None
 960  *
 961  * DESCRIPTION: Display info about system busses.
 962  *
 963  ******************************************************************************/
 964
 965 void
 966 AcpiDbGetBusInfo (
 967     void)
 968 {
 969     /* Search all nodes in namespace */
 970
 971     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
 972                     AcpiDbBusWalk, NULL, NULL, NULL);
 973 }
 974
 975 #endif /* ACPI_DEBUGGER */