dbnames.c revision 218590 
1189623Srwatson/*******************************************************************************
2189623Srwatson *
3189623Srwatson * Module Name: dbnames - Debugger commands for the acpi namespace
4189623Srwatson *
5189623Srwatson ******************************************************************************/
6189623Srwatson
7189623Srwatson/*
8189623Srwatson * Copyright (C) 2000 - 2011, Intel Corp.
9189623Srwatson * All rights reserved.
10189623Srwatson *
11189623Srwatson * Redistribution and use in source and binary forms, with or without
12189623Srwatson * modification, are permitted provided that the following conditions
13189623Srwatson * are met:
14189623Srwatson * 1. Redistributions of source code must retain the above copyright
15189623Srwatson *    notice, this list of conditions, and the following disclaimer,
16189623Srwatson *    without modification.
17189623Srwatson * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18189623Srwatson *    substantially similar to the "NO WARRANTY" disclaimer below
19189623Srwatson *    ("Disclaimer") and any redistribution must be conditioned upon
20189623Srwatson *    including a substantially similar Disclaimer requirement for further
21189623Srwatson *    binary redistribution.
22189623Srwatson * 3. Neither the names of the above-listed copyright holders nor the names
23189623Srwatson *    of any contributors may be used to endorse or promote products derived
24189623Srwatson *    from this software without specific prior written permission.
25189623Srwatson *
26189623Srwatson * Alternatively, this software may be distributed under the terms of the
27189623Srwatson * GNU General Public License ("GPL") version 2 as published by the Free
28189623Srwatson * Software Foundation.
29189623Srwatson *
30189623Srwatson * NO WARRANTY
31189623Srwatson * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32189623Srwatson * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33208873Srwatson * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34208873Srwatson * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35189623Srwatson * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36189623Srwatson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37189623Srwatson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38189623Srwatson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39189623Srwatson * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40189623Srwatson * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41189623Srwatson * POSSIBILITY OF SUCH DAMAGES.
42189623Srwatson */
43189623Srwatson
44189623Srwatson
45189623Srwatson#include <contrib/dev/acpica/include/acpi.h>
46189623Srwatson#include <contrib/dev/acpica/include/accommon.h>
47189623Srwatson#include <contrib/dev/acpica/include/acnamesp.h>
48189623Srwatson#include <contrib/dev/acpica/include/acdebug.h>
49189623Srwatson
50189623Srwatson
51189623Srwatson#ifdef ACPI_DEBUGGER
52189623Srwatson
53#define _COMPONENT          ACPI_CA_DEBUGGER
54        ACPI_MODULE_NAME    ("dbnames")
55
56
57/* Local prototypes */
58
59static ACPI_STATUS
60AcpiDbWalkAndMatchName (
61    ACPI_HANDLE             ObjHandle,
62    UINT32                  NestingLevel,
63    void                    *Context,
64    void                    **ReturnValue);
65
66static ACPI_STATUS
67AcpiDbWalkForPredefinedNames (
68    ACPI_HANDLE             ObjHandle,
69    UINT32                  NestingLevel,
70    void                    *Context,
71    void                    **ReturnValue);
72
73static ACPI_STATUS
74AcpiDbWalkForSpecificObjects (
75    ACPI_HANDLE             ObjHandle,
76    UINT32                  NestingLevel,
77    void                    *Context,
78    void                    **ReturnValue);
79
80static ACPI_STATUS
81AcpiDbIntegrityWalk (
82    ACPI_HANDLE             ObjHandle,
83    UINT32                  NestingLevel,
84    void                    *Context,
85    void                    **ReturnValue);
86
87static ACPI_STATUS
88AcpiDbWalkForReferences (
89    ACPI_HANDLE             ObjHandle,
90    UINT32                  NestingLevel,
91    void                    *Context,
92    void                    **ReturnValue);
93
94static ACPI_STATUS
95AcpiDbBusWalk (
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 */
105static 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
146void
147AcpiDbSetScope (
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
195ErrorExit:
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
216void
217AcpiDbDumpNamespace (
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
269void
270AcpiDbDumpNamespaceByOwner (
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
313static ACPI_STATUS
314AcpiDbWalkAndMatchName (
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
378ACPI_STATUS
379AcpiDbFindNameInNamespace (
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
425static ACPI_STATUS
426AcpiDbWalkForPredefinedNames (
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
490void
491AcpiDbCheckPredefinedNames (
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
518static ACPI_STATUS
519AcpiDbWalkForSpecificObjects (
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
565ACPI_STATUS
566AcpiDbDisplayObjects (
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
621static ACPI_STATUS
622AcpiDbIntegrityWalk (
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
699void
700AcpiDbCheckIntegrity (
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
730static ACPI_STATUS
731AcpiDbWalkForReferences (
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
773void
774AcpiDbFindReferences (
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
804static ACPI_STATUS
805AcpiDbBusWalk (
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
924void
925AcpiDbGetBusInfo (
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 */
935