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

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