Initial import of the Intel-maintained ACPI Component Architecture. This

is Intel's reference implementation of the core operating-system ACPI
support.  (This import is on the vendor branch.)

1 files changed, 997 insertions, 0 deletions

diff --git a/sys/contrib/dev/acpica/dbcmds.c b/sys/contrib/dev/acpica/dbcmds.c
new file mode 100644
index 0000000..bd357df
--- /dev/null
+++ b/sys/contrib/dev/acpica/dbcmds.c
@@ -0,0 +1,997 @@
+/*******************************************************************************
+ *
+ * Module Name: dbcmds - debug commands and output routines
+ *              $Revision: 41 $
+ *
+ ******************************************************************************/
+
+/******************************************************************************
+ *
+ * 1. Copyright Notice
+ *
+ * Some or all of this work - Copyright (c) 1999, Intel Corp.  All rights
+ * reserved.
+ *
+ * 2. License
+ *
+ * 2.1. This is your license from Intel Corp. under its intellectual property
+ * rights.  You may have additional license terms from the party that provided
+ * you this software, covering your right to use that party's intellectual
+ * property rights.
+ *
+ * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
+ * copy of the source code appearing in this file ("Covered Code") an
+ * irrevocable, perpetual, worldwide license under Intel's copyrights in the
+ * base code distributed originally by Intel ("Original Intel Code") to copy,
+ * make derivatives, distribute, use and display any portion of the Covered
+ * Code in any form, with the right to sublicense such rights; and
+ *
+ * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
+ * license (with the right to sublicense), under only those claims of Intel
+ * patents that are infringed by the Original Intel Code, to make, use, sell,
+ * offer to sell, and import the Covered Code and derivative works thereof
+ * solely to the minimum extent necessary to exercise the above copyright
+ * license, and in no event shall the patent license extend to any additions
+ * to or modifications of the Original Intel Code.  No other license or right
+ * is granted directly or by implication, estoppel or otherwise;
+ *
+ * The above copyright and patent license is granted only if the following
+ * conditions are met:
+ *
+ * 3. Conditions
+ *
+ * 3.1. Redistribution of Source with Rights to Further Distribute Source.
+ * Redistribution of source code of any substantial portion of the Covered
+ * Code or modification with rights to further distribute source must include
+ * the above Copyright Notice, the above License, this list of Conditions,
+ * and the following Disclaimer and Export Compliance provision.  In addition,
+ * Licensee must cause all Covered Code to which Licensee contributes to
+ * contain a file documenting the changes Licensee made to create that Covered
+ * Code and the date of any change.  Licensee must include in that file the
+ * documentation of any changes made by any predecessor Licensee.  Licensee
+ * must include a prominent statement that the modification is derived,
+ * directly or indirectly, from Original Intel Code.
+ *
+ * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
+ * Redistribution of source code of any substantial portion of the Covered
+ * Code or modification without rights to further distribute source must
+ * include the following Disclaimer and Export Compliance provision in the
+ * documentation and/or other materials provided with distribution.  In
+ * addition, Licensee may not authorize further sublicense of source of any
+ * portion of the Covered Code, and must include terms to the effect that the
+ * license from Licensee to its licensee is limited to the intellectual
+ * property embodied in the software Licensee provides to its licensee, and
+ * not to intellectual property embodied in modifications its licensee may
+ * make.
+ *
+ * 3.3. Redistribution of Executable. Redistribution in executable form of any
+ * substantial portion of the Covered Code or modification must reproduce the
+ * above Copyright Notice, and the following Disclaimer and Export Compliance
+ * provision in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3.4. Intel retains all right, title, and interest in and to the Original
+ * Intel Code.
+ *
+ * 3.5. Neither the name Intel nor any other trademark owned or controlled by
+ * Intel shall be used in advertising or otherwise to promote the sale, use or
+ * other dealings in products derived from or relating to the Covered Code
+ * without prior written authorization from Intel.
+ *
+ * 4. Disclaimer and Export Compliance
+ *
+ * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
+ * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
+ * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
+ * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
+ * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
+ * PARTICULAR PURPOSE.
+ *
+ * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
+ * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
+ * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
+ * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
+ * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
+ * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
+ * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
+ * LIMITED REMEDY.
+ *
+ * 4.3. Licensee shall not export, either directly or indirectly, any of this
+ * software or system incorporating such software without first obtaining any
+ * required license or other approval from the U. S. Department of Commerce or
+ * any other agency or department of the United States Government.  In the
+ * event Licensee exports any such software from the United States or
+ * re-exports any such software from a foreign destination, Licensee shall
+ * ensure that the distribution and export/re-export of the software is in
+ * compliance with all laws, regulations, orders, or other restrictions of the
+ * U.S. Export Administration Regulations. Licensee agrees that neither it nor
+ * any of its subsidiaries will export/re-export any technical data, process,
+ * software, or service, directly or indirectly, to any country for which the
+ * United States government or any agency thereof requires an export license,
+ * other governmental approval, or letter of assurance, without first obtaining
+ * such license, approval or letter.
+ *
+ *****************************************************************************/
+
+
+#include "acpi.h"
+#include "acparser.h"
+#include "acdispat.h"
+#include "amlcode.h"
+#include "acnamesp.h"
+#include "acparser.h"
+#include "acevents.h"
+#include "acinterp.h"
+#include "acdebug.h"
+#include "actables.h"
+
+#ifdef ENABLE_DEBUGGER
+
+#define _COMPONENT          DEBUGGER
+        MODULE_NAME         ("dbcmds")
+
+
+/*
+ * Arguments for the Objects command
+ * These object types map directly to the ACPI_TYPES
+ */
+
+ARGUMENT_INFO               AcpiDbObjectTypes [] =
+{
+    {"ANY"},
+    {"NUMBERS"},
+    {"STRINGS"},
+    {"BUFFERS"},
+    {"PACKAGES"},
+    {"FIELDS"},
+    {"DEVICES"},
+    {"EVENTS"},
+    {"METHODS"},
+    {"MUTEXES"},
+    {"REGIONS"},
+    {"POWERRESOURCES"},
+    {"PROCESSORS"},
+    {"THERMALZONES"},
+    {"BUFFERFIELDS"},
+    {"DDBHANDLES"},
+    {NULL}           /* Must be null terminated */
+};
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbWalkForReferences
+ *
+ * PARAMETERS:  Callback from WalkNamespace
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Check if this namespace object refers to the target object
+ *              that is passed in as the context value.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiDbWalkForReferences (
+    ACPI_HANDLE             ObjHandle,
+    UINT32                  NestingLevel,
+    void                    *Context,
+    void                    **ReturnValue)
+{
+    ACPI_OPERAND_OBJECT     *ObjDesc = (ACPI_OPERAND_OBJECT  *) Context;
+    ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
+
+
+    /* Check for match against the namespace node itself */
+
+    if (Node == (void *) ObjDesc)
+    {
+        AcpiOsPrintf ("Object is a Node [%4.4s]\n", &Node->Name);
+    }
+
+    /* Check for match against the object attached to the node */
+
+    if (Node->Object == ObjDesc)
+    {
+        AcpiOsPrintf ("Reference at Node->Object %p [%4.4s]\n", Node, &Node->Name);
+    }
+
+    /* Check first child for a match */
+    /* TBD: [Investigate] probably now obsolete with new datastructure */
+
+    if (Node->Child == (void *) ObjDesc)
+    {
+        AcpiOsPrintf ("Reference at Node->Child %p [%4.4s]\n", Node, &Node->Name);
+    }
+
+    return (AE_OK);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbFindReferences
+ *
+ * PARAMETERS:  ObjectArg       - String with hex value of the object
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Search namespace for all references to the input object
+ *
+ ******************************************************************************/
+
+void
+AcpiDbFindReferences (
+    NATIVE_CHAR             *ObjectArg)
+{
+    ACPI_OPERAND_OBJECT     *ObjDesc;
+
+
+    /* Convert string to object pointer */
+
+    ObjDesc = (ACPI_OPERAND_OBJECT  *) STRTOUL (ObjectArg, NULL, 16);
+
+    /* Search all nodes in namespace */
+
+    AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
+                    AcpiDbWalkForReferences, (void *) ObjDesc, NULL);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbDisplayTableInfo
+ *
+ * PARAMETERS:  TableArg        - String with name of table to be displayed
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Display information about loaded tables.  Current
+ *              implementation displays all loaded tables.
+ *
+ ******************************************************************************/
+
+void
+AcpiDbDisplayTableInfo (
+    NATIVE_CHAR             *TableArg)
+{
+    UINT32                  i;
+
+
+    for (i = 0; i < NUM_ACPI_TABLES; i++)
+    {
+        if (AcpiGbl_AcpiTables[i].Pointer)
+        {
+            AcpiOsPrintf ("%s at 0x%p length 0x%X\n", AcpiGbl_AcpiTableData[i].Name,
+                        AcpiGbl_AcpiTables[i].Pointer, AcpiGbl_AcpiTables[i].Length);
+        }
+    }
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbUnloadAcpiTable
+ *
+ * PARAMETERS:  TableArg        - Name of the table to be unloaded
+ *              InstanceArg     - Which instance of the table to unload (if
+ *                                there are multiple tables of the same type)
+ *
+ * RETURN:      Nonde
+ *
+ * DESCRIPTION: Unload an ACPI table.
+ *              Instance is not implemented
+ *
+ ******************************************************************************/
+
+void
+AcpiDbUnloadAcpiTable (
+    NATIVE_CHAR             *TableArg,
+    NATIVE_CHAR             *InstanceArg)
+{
+    UINT32                  i;
+    ACPI_STATUS             Status;
+
+
+    /* Search all tables for the target type */
+
+    for (i = 0; i < NUM_ACPI_TABLES; i++)
+    {
+        if (!STRNCMP (TableArg, AcpiGbl_AcpiTableData[i].Signature, AcpiGbl_AcpiTableData[i].SigLength))
+        {
+            /* Found the table, unload it */
+
+            Status = AcpiUnloadTable (i);
+            if (ACPI_SUCCESS (Status))
+            {
+                AcpiOsPrintf ("[%s] unloaded and uninstalled\n", TableArg);
+            }
+            else
+            {
+                AcpiOsPrintf ("%s, while unloading [%s]\n", AcpiCmFormatException (Status), TableArg);
+            }
+
+            return;
+        }
+    }
+
+    AcpiOsPrintf ("Unknown table type [%s]\n", TableArg);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbSetMethodBreakpoint
+ *
+ * PARAMETERS:  Location            - AML offset of breakpoint
+ *              WalkState           - Current walk info
+ *              Op                  - Current Op (from parse walk)
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Set a breakpoint in a control method at the specified
+ *              AML offset
+ *
+ ******************************************************************************/
+
+void
+AcpiDbSetMethodBreakpoint (
+    NATIVE_CHAR             *Location,
+    ACPI_WALK_STATE         *WalkState,
+    ACPI_PARSE_OBJECT       *Op)
+{
+    UINT32                  Address;
+
+
+    if (!Op)
+    {
+        AcpiOsPrintf ("There is no method currently executing\n");
+        return;
+    }
+
+    /* Get and verify the breakpoint address */
+
+    Address = STRTOUL (Location, NULL, 16);
+    if (Address <= Op->AmlOffset)
+    {
+        AcpiOsPrintf ("Breakpoint 0x%X is beyond current address 0x%X\n", Address, Op->AmlOffset);
+    }
+
+    /* Save breakpoint in current walk */
+
+    WalkState->MethodBreakpoint = Address;
+    AcpiOsPrintf ("Breakpoint set at AML offset 0x%X\n", Address);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbSetMethodCallBreakpoint
+ *
+ * PARAMETERS:  Op                  - Current Op (from parse walk)
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Set a breakpoint in a control method at the specified
+ *              AML offset
+ *
+ ******************************************************************************/
+
+void
+AcpiDbSetMethodCallBreakpoint (
+    ACPI_PARSE_OBJECT       *Op)
+{
+
+
+    if (!Op)
+    {
+        AcpiOsPrintf ("There is no method currently executing\n");
+        return;
+    }
+
+
+    AcpiGbl_StepToNextCall = TRUE;
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbDisassembleAml
+ *
+ * PARAMETERS:  Statements          - Number of statements to disassemble
+ *              Op                  - Current Op (from parse walk)
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Display disassembled AML (ASL) starting from Op for the number
+ *              of statements specified.
+ *
+ ******************************************************************************/
+
+void
+AcpiDbDisassembleAml (
+    NATIVE_CHAR             *Statements,
+    ACPI_PARSE_OBJECT       *Op)
+{
+    UINT32                  NumStatements = 8;
+
+
+    if (!Op)
+    {
+        AcpiOsPrintf ("There is no method currently executing\n");
+        return;
+    }
+
+    if (Statements)
+    {
+        NumStatements = STRTOUL (Statements, NULL, 0);
+    }
+
+
+    AcpiDbDisplayOp (NULL, Op, NumStatements);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbDumpNamespace
+ *
+ * PARAMETERS:  StartArg        - Node to begin namespace dump
+ *              DepthArg        - Maximum tree depth to be dumped
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Dump entire namespace or a subtree.  Each node is displayed
+ *              with type and other information.
+ *
+ ******************************************************************************/
+
+void
+AcpiDbDumpNamespace (
+    NATIVE_CHAR             *StartArg,
+    NATIVE_CHAR             *DepthArg)
+{
+    ACPI_HANDLE             SubtreeEntry = AcpiGbl_RootNode;
+    UINT32                  MaxDepth = ACPI_UINT32_MAX;
+
+
+    /* No argument given, just start at the root and dump entire namespace */
+
+    if (StartArg)
+    {
+        /* Check if numeric argument, must be a Node */
+
+        if ((StartArg[0] >= 0x30) && (StartArg[0] <= 0x39))
+        {
+            SubtreeEntry = (ACPI_HANDLE) STRTOUL (StartArg, NULL, 16);
+            if (!AcpiOsReadable (SubtreeEntry, sizeof (ACPI_NAMESPACE_NODE)))
+            {
+                AcpiOsPrintf ("Address %p is invalid in this address space\n", SubtreeEntry);
+                return;
+            }
+
+            if (!VALID_DESCRIPTOR_TYPE ((SubtreeEntry), ACPI_DESC_TYPE_NAMED))
+            {
+                AcpiOsPrintf ("Address %p is not a valid Named object\n", SubtreeEntry);
+                return;
+            }
+        }
+
+        /* Alpha argument */
+
+        else
+        {
+            /* The parameter is a name string that must be resolved to a Named obj*/
+
+            SubtreeEntry = AcpiDbLocalNsLookup (StartArg);
+            if (!SubtreeEntry)
+            {
+                SubtreeEntry = AcpiGbl_RootNode;
+            }
+        }
+
+        /* Now we can check for the depth argument */
+
+        if (DepthArg)
+        {
+            MaxDepth = STRTOUL (DepthArg, NULL, 0);
+        }
+    }
+
+
+    AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT);
+    AcpiOsPrintf ("ACPI Namespace (from %p subtree):\n", SubtreeEntry);
+
+    /* Display the subtree */
+
+    AcpiDbSetOutputDestination (DB_REDIRECTABLE_OUTPUT);
+    AcpiNsDumpObjects (ACPI_TYPE_ANY, MaxDepth, ACPI_UINT32_MAX, SubtreeEntry);
+    AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbDumpNamespaceByOwner
+ *
+ * PARAMETERS:  OwnerArg        - Owner ID whose nodes will be displayed
+ *              DepthArg        - Maximum tree depth to be dumped
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Dump elements of the namespace that are owned by the OwnerId.
+ *
+ ******************************************************************************/
+
+void
+AcpiDbDumpNamespaceByOwner (
+    NATIVE_CHAR             *OwnerArg,
+    NATIVE_CHAR             *DepthArg)
+{
+    ACPI_HANDLE             SubtreeEntry = AcpiGbl_RootNode;
+    UINT32                  MaxDepth = ACPI_UINT32_MAX;
+    UINT16                  OwnerId;
+
+
+    OwnerId = (UINT16) STRTOUL (OwnerArg, NULL, 0);
+
+
+    /* Now we can check for the depth argument */
+
+    if (DepthArg)
+    {
+        MaxDepth = STRTOUL (DepthArg, NULL, 0);
+    }
+
+
+    AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT);
+    AcpiOsPrintf ("ACPI Namespace by owner 0x%X:\n", OwnerId);
+
+    /* Display the subtree */
+
+    AcpiDbSetOutputDestination (DB_REDIRECTABLE_OUTPUT);
+    AcpiNsDumpObjects (ACPI_TYPE_ANY, MaxDepth, OwnerId, SubtreeEntry);
+    AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbSendNotify
+ *
+ * PARAMETERS:  Name            - Name of ACPI object to send the notify to
+ *              Value           - Value of the notify to send.
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Send an ACPI notification.  The value specified is sent to the
+ *              named object as an ACPI notify.
+ *
+ ******************************************************************************/
+
+void
+AcpiDbSendNotify (
+    NATIVE_CHAR             *Name,
+    UINT32                  Value)
+{
+    ACPI_NAMESPACE_NODE     *Node;
+
+
+    /* Translate name to an Named object */
+
+    Node = AcpiDbLocalNsLookup (Name);
+    if (!Node)
+    {
+        return;
+    }
+
+    /* Decode Named object type */
+
+    switch (Node->Type)
+    {
+    case ACPI_TYPE_DEVICE:
+    case ACPI_TYPE_THERMAL:
+
+         /* Send the notify */
+
+        AcpiEvNotifyDispatch (Node, Value);
+        break;
+
+    default:
+        AcpiOsPrintf ("Named object is not a device or a thermal object\n");
+        break;
+    }
+
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbSetMethodData
+ *
+ * PARAMETERS:  TypeArg         - L for local, A for argument
+ *              IndexArg        - which one
+ *              ValueArg        - Value to set.
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Set a local or argument for the running control method.
+ *              NOTE: only object supported is Number.
+ *
+ ******************************************************************************/
+
+void
+AcpiDbSetMethodData (
+    NATIVE_CHAR             *TypeArg,
+    NATIVE_CHAR             *IndexArg,
+    NATIVE_CHAR             *ValueArg)
+{
+    NATIVE_CHAR             Type;
+    UINT32                  Index;
+    UINT32                  Value;
+    ACPI_WALK_STATE         *WalkState;
+    ACPI_OPERAND_OBJECT     *ObjDesc;
+
+
+    /* Validate TypeArg */
+
+    STRUPR (TypeArg);
+    Type = TypeArg[0];
+    if ((Type != 'L') &&
+        (Type != 'A'))
+    {
+        AcpiOsPrintf ("Invalid SET operand: %s\n", TypeArg);
+        return;
+    }
+
+    /* Get the index and value */
+
+    Index = STRTOUL (IndexArg, NULL, 16);
+    Value = STRTOUL (ValueArg, NULL, 16);
+
+    WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
+    if (!WalkState)
+    {
+        AcpiOsPrintf ("There is no method currently executing\n");
+        return;
+    }
+
+
+    /* Create and initialize the new object */
+
+    ObjDesc = AcpiCmCreateInternalObject (ACPI_TYPE_NUMBER);
+    if (!ObjDesc)
+    {
+        AcpiOsPrintf ("Could not create an internal object\n");
+        return;
+    }
+
+    ObjDesc->Number.Value = Value;
+
+
+    /* Store the new object into the target */
+
+    switch (Type)
+    {
+    case 'A':
+
+        /* Set a method argument */
+
+        if (Index > MTH_NUM_ARGS)
+        {
+            AcpiOsPrintf ("Arg%d - Invalid argument name\n", Index);
+            return;
+        }
+
+        AcpiDsMethodDataSetValue (MTH_TYPE_ARG, Index, ObjDesc, WalkState);
+        ObjDesc = WalkState->Arguments[Index].Object;
+
+        AcpiOsPrintf ("Arg%d: ", Index);
+        AcpiDbDisplayInternalObject (ObjDesc, WalkState);
+        break;
+
+    case 'L':
+
+        /* Set a method local */
+
+        if (Index > MTH_NUM_LOCALS)
+        {
+            AcpiOsPrintf ("Local%d - Invalid local variable name\n", Index);
+            return;
+        }
+
+        AcpiDsMethodDataSetValue (MTH_TYPE_LOCAL, Index, ObjDesc, WalkState);
+        ObjDesc = WalkState->LocalVariables[Index].Object;
+
+        AcpiOsPrintf ("Local%d: ", Index);
+        AcpiDbDisplayInternalObject (ObjDesc, WalkState);
+        break;
+
+    default:
+        break;
+    }
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbWalkForSpecificObjects
+ *
+ * PARAMETERS:  Callback from WalkNamespace
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Display short info about objects in the namespace
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiDbWalkForSpecificObjects (
+    ACPI_HANDLE             ObjHandle,
+    UINT32                  NestingLevel,
+    void                    *Context,
+    void                    **ReturnValue)
+{
+    ACPI_OPERAND_OBJECT     *ObjDesc;
+    ACPI_STATUS             Status;
+    UINT32                  BufSize;
+    NATIVE_CHAR             buffer[64];
+
+
+    ObjDesc = ((ACPI_NAMESPACE_NODE *)ObjHandle)->Object;
+
+    /* Get and display the full pathname to this object */
+
+    Status = AcpiNsHandleToPathname (ObjHandle, &BufSize, buffer);
+
+    if (ACPI_FAILURE (Status))
+    {
+        AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle);
+        return (AE_OK);
+    }
+
+    AcpiOsPrintf ("%32s", buffer);
+
+
+    /* Display short information about the object */
+
+    if (ObjDesc)
+    {
+        switch (ObjDesc->Common.Type)
+        {
+        case ACPI_TYPE_METHOD:
+            AcpiOsPrintf ("  #Args %d  Concurrency %d", ObjDesc->Method.ParamCount, ObjDesc->Method.Concurrency);
+            break;
+
+        case ACPI_TYPE_NUMBER:
+            AcpiOsPrintf ("  Value 0x%X", ObjDesc->Number.Value);
+            break;
+
+        case ACPI_TYPE_STRING:
+            AcpiOsPrintf ("  \"%s\"", ObjDesc->String.Pointer);
+            break;
+
+        case ACPI_TYPE_REGION:
+            AcpiOsPrintf ("  SpaceId %d Address %X Length %X", ObjDesc->Region.SpaceId, ObjDesc->Region.Address, ObjDesc->Region.Length);
+            break;
+
+        case ACPI_TYPE_PACKAGE:
+            AcpiOsPrintf ("  #Elements %d", ObjDesc->Package.Count);
+            break;
+
+        case ACPI_TYPE_BUFFER:
+            AcpiOsPrintf ("  Length %d", ObjDesc->Buffer.Length);
+            break;
+        }
+    }
+
+    AcpiOsPrintf ("\n");
+    return (AE_OK);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbDisplayObjects
+ *
+ * PARAMETERS:  ObjTypeArg          - Type of object to display
+ *              DisplayCountArg     - Max depth to display
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Display objects in the namespace of the requested type
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiDbDisplayObjects (
+    NATIVE_CHAR             *ObjTypeArg,
+    NATIVE_CHAR             *DisplayCountArg)
+{
+    UINT32                  DisplayCount;
+    OBJECT_TYPE_INTERNAL    Type;
+
+
+    /* Get the object type */
+
+    STRUPR (ObjTypeArg);
+    Type = AcpiDbMatchArgument (ObjTypeArg, AcpiDbObjectTypes);
+    if (Type == ACPI_TYPE_NOT_FOUND)
+    {
+        AcpiOsPrintf ("Invalid or unsupported argument\n");
+        return (AE_OK);
+    }
+
+    /* Get the display depth */
+
+    if (DisplayCountArg)
+    {
+        DisplayCount = STRTOUL (DisplayCountArg, NULL, 0);
+    }
+
+    else
+    {
+        DisplayCount = ACPI_UINT32_MAX;
+    }
+
+    AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT);
+    AcpiOsPrintf ("Objects of type [%s] defined in the current ACPI Namespace: \n", AcpiCmGetTypeName (Type));
+
+    AcpiDbSetOutputDestination (DB_REDIRECTABLE_OUTPUT);
+
+    /* Walk the namespace from the root */
+
+    AcpiWalkNamespace (Type, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
+                        AcpiDbWalkForSpecificObjects, (void *) &Type, NULL);
+
+    AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT);
+    return (AE_OK);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbWalkAndMatchName
+ *
+ * PARAMETERS:  Callback from WalkNamespace
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Find a particular name/names within the namespace.  Wildcards
+ *              are supported -- '?' matches any character.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiDbWalkAndMatchName (
+    ACPI_HANDLE             ObjHandle,
+    UINT32                  NestingLevel,
+    void                    *Context,
+    void                    **ReturnValue)
+{
+    ACPI_OPERAND_OBJECT     *ObjDesc;
+    ACPI_STATUS             Status;
+    NATIVE_CHAR             *RequestedName = (NATIVE_CHAR *) Context;
+    UINT32                  i;
+    UINT32                  BufSize;
+    NATIVE_CHAR             Buffer[96];
+
+
+    ObjDesc = ((ACPI_NAMESPACE_NODE *)ObjHandle)->Object;
+
+
+    /* Check for a name match */
+
+    for (i = 0; i < 4; i++)
+    {
+        /* Wildcard support */
+
+        if ((RequestedName[i] != '?') &&
+            (RequestedName[i] != ((NATIVE_CHAR *) (&((ACPI_NAMESPACE_NODE *) ObjHandle)->Name))[i]))
+        {
+            /* No match, just exit */
+
+            return (AE_OK);
+        }
+    }
+
+
+    /* Get the full pathname to this object */
+
+    BufSize = sizeof (Buffer);
+
+    Status = AcpiNsHandleToPathname (ObjHandle, &BufSize, Buffer);
+    if (ACPI_FAILURE (Status))
+    {
+        AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle);
+    }
+
+    else
+    {
+        AcpiOsPrintf ("%32s (0x%p) - %s\n", Buffer, ObjHandle,
+            AcpiCmGetTypeName (((ACPI_NAMESPACE_NODE *) ObjHandle)->Type));
+    }
+
+    return (AE_OK);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbFindNameInNamespace
+ *
+ * PARAMETERS:  NameArg         - The 4-character ACPI name to find.
+ *                                wildcards are supported.
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Search the namespace for a given name (with wildcards)
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiDbFindNameInNamespace (
+    NATIVE_CHAR             *NameArg)
+{
+
+    if (STRLEN (NameArg) > 4)
+    {
+        AcpiOsPrintf ("Name must be no longer than 4 characters\n");
+        return (AE_OK);
+    }
+
+    /* Walk the namespace from the root */
+
+    AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
+                        AcpiDbWalkAndMatchName, NameArg, NULL);
+
+    AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT);
+    return (AE_OK);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDbSetScope
+ *
+ * PARAMETERS:  Name                - New scope path
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Set the "current scope" as maintained by this utility.
+ *              The scope is used as a prefix to ACPI paths.
+ *
+ ******************************************************************************/
+
+void
+AcpiDbSetScope (
+    NATIVE_CHAR             *Name)
+{
+
+    if (!Name || Name[0] == 0)
+    {
+        AcpiOsPrintf ("Current scope: %s\n", ScopeBuf);
+        return;
+    }
+
+    AcpiDbPrepNamestring (Name);
+
+    /* TBD: [Future] Validate scope here */
+
+    if (Name[0] == '\\')
+    {
+        STRCPY (ScopeBuf, Name);
+        STRCAT (ScopeBuf, "\\");
+    }
+
+    else
+    {
+        STRCAT (ScopeBuf, Name);
+        STRCAT (ScopeBuf, "\\");
+    }
+
+    AcpiOsPrintf ("New scope: %s\n", ScopeBuf);
+}
+
+#endif /* ENABLE_DEBUGGER */