FreeBSD/Linux Kernel Cross Reference
sys/contrib/dev/acpica/components/debugger/dbtest.c

     /*******************************************************************************
      *
      * Module Name: dbtest - Various debug-related tests
      *
      ******************************************************************************/
     
     /******************************************************************************
      *
      * 1. Copyright Notice
     *
     * Some or all of this work - Copyright (c) 1999 - 2022, 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.
    *
    *****************************************************************************
    *
    * Alternatively, you may choose to be licensed under the terms of the
    * following license:
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    * 1. Redistributions of source code must retain the above copyright
    *    notice, this list of conditions, and the following disclaimer,
    *    without modification.
    * 2. Redistributions in binary form must reproduce at minimum a disclaimer
    *    substantially similar to the "NO WARRANTY" disclaimer below
    *    ("Disclaimer") and any redistribution must be conditioned upon
    *    including a substantially similar Disclaimer requirement for further
    *    binary redistribution.
    * 3. Neither the names of the above-listed copyright holders nor the names
    *    of any contributors may be used to endorse or promote products derived
    *    from this software without specific prior written permission.
    *
    * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *
    * Alternatively, you may choose to be licensed under the terms of the
    * GNU General Public License ("GPL") version 2 as published by the Free
    * Software Foundation.
    *
    *****************************************************************************/
   
   #include <contrib/dev/acpica/include/acpi.h>
   #include <contrib/dev/acpica/include/accommon.h>
   #include <contrib/dev/acpica/include/acdebug.h>
   #include <contrib/dev/acpica/include/acnamesp.h>
   #include <contrib/dev/acpica/include/acpredef.h>
   #include <contrib/dev/acpica/include/acinterp.h>
   
   
   #define _COMPONENT          ACPI_CA_DEBUGGER
           ACPI_MODULE_NAME    ("dbtest")
   
   
   /* Local prototypes */
   
   static void
   AcpiDbTestAllObjects (
       void);
   
   static ACPI_STATUS
   AcpiDbTestOneObject (
       ACPI_HANDLE             ObjHandle,
       UINT32                  NestingLevel,
       void                    *Context,
       void                    **ReturnValue);
   
   static ACPI_STATUS
   AcpiDbTestIntegerType (
       ACPI_NAMESPACE_NODE     *Node,
       UINT32                  BitLength);
   
   static ACPI_STATUS
   AcpiDbTestBufferType (
       ACPI_NAMESPACE_NODE     *Node,
       UINT32                  BitLength);
   
   static ACPI_STATUS
   AcpiDbTestStringType (
       ACPI_NAMESPACE_NODE     *Node,
       UINT32                  ByteLength);
   
   static ACPI_STATUS
   AcpiDbTestPackageType (
       ACPI_NAMESPACE_NODE     *Node);
   
   static ACPI_STATUS
   AcpiDbTestFieldUnitType (
       ACPI_OPERAND_OBJECT     *ObjDesc);
   
   static ACPI_STATUS
   AcpiDbReadFromObject (
       ACPI_NAMESPACE_NODE     *Node,
       ACPI_OBJECT_TYPE        ExpectedType,
       ACPI_OBJECT             **Value);
   
   static ACPI_STATUS
   AcpiDbWriteToObject (
       ACPI_NAMESPACE_NODE     *Node,
       ACPI_OBJECT             *Value);
   
   static void
   AcpiDbEvaluateAllPredefinedNames (
       char                    *CountArg);
   
   static ACPI_STATUS
   AcpiDbEvaluateOnePredefinedName (
       ACPI_HANDLE             ObjHandle,
       UINT32                  NestingLevel,
       void                    *Context,
       void                    **ReturnValue);
   
   /*
    * Test subcommands
    */
   static ACPI_DB_ARGUMENT_INFO    AcpiDbTestTypes [] =
   {
       {"OBJECTS"},
       {"PREDEFINED"},
       {NULL}           /* Must be null terminated */
   };
   
   #define CMD_TEST_OBJECTS        0
   #define CMD_TEST_PREDEFINED     1
   
   #define BUFFER_FILL_VALUE       0xFF
   
   /*
    * Support for the special debugger read/write control methods.
    * These methods are installed into the current namespace and are
    * used to read and write the various namespace objects. The point
    * is to force the AML interpreter do all of the work.
    */
   #define ACPI_DB_READ_METHOD     "\\_T98"
   #define ACPI_DB_WRITE_METHOD    "\\_T99"
   
   static ACPI_HANDLE          ReadHandle = NULL;
   static ACPI_HANDLE          WriteHandle = NULL;
   
   /* ASL Definitions of the debugger read/write control methods. AML below. */
   
   #if 0
   DefinitionBlock ("ssdt.aml", "SSDT", 2, "Intel", "DEBUG", 0x00000001)
   {
       Method (_T98, 1, NotSerialized)     /* Read */
       {
           Return (DeRefOf (Arg0))
       }
   }
   DefinitionBlock ("ssdt2.aml", "SSDT", 2, "Intel", "DEBUG", 0x00000001)
   {
       Method (_T99, 2, NotSerialized)     /* Write */
       {
           Store (Arg1, Arg0)
       }
   }
   #endif
   
   static unsigned char ReadMethodCode[] =
   {
       0x53,0x53,0x44,0x54,0x2E,0x00,0x00,0x00,  /* 00000000    "SSDT...." */
       0x02,0xC9,0x49,0x6E,0x74,0x65,0x6C,0x00,  /* 00000008    "..Intel." */
       0x44,0x45,0x42,0x55,0x47,0x00,0x00,0x00,  /* 00000010    "DEBUG..." */
       0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C,  /* 00000018    "....INTL" */
       0x18,0x12,0x13,0x20,0x14,0x09,0x5F,0x54,  /* 00000020    "... .._T" */
       0x39,0x38,0x01,0xA4,0x83,0x68             /* 00000028    "98...h"   */
   };
   
   static unsigned char WriteMethodCode[] =
   {
       0x53,0x53,0x44,0x54,0x2E,0x00,0x00,0x00,  /* 00000000    "SSDT...." */
       0x02,0x15,0x49,0x6E,0x74,0x65,0x6C,0x00,  /* 00000008    "..Intel." */
       0x44,0x45,0x42,0x55,0x47,0x00,0x00,0x00,  /* 00000010    "DEBUG..." */
       0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C,  /* 00000018    "....INTL" */
       0x18,0x12,0x13,0x20,0x14,0x09,0x5F,0x54,  /* 00000020    "... .._T" */
       0x39,0x39,0x02,0x70,0x69,0x68             /* 00000028    "99.pih"   */
   };
   
   
   /*******************************************************************************
    *
    * FUNCTION:    AcpiDbExecuteTest
    *
    * PARAMETERS:  TypeArg         - Subcommand
    *
    * RETURN:      None
    *
    * DESCRIPTION: Execute various debug tests.
    *
    * Note: Code is prepared for future expansion of the TEST command.
    *
    ******************************************************************************/
   
   void
   AcpiDbExecuteTest (
       char                    *TypeArg)
   {
       UINT32                  Temp;
   
   
       AcpiUtStrupr (TypeArg);
       Temp = AcpiDbMatchArgument (TypeArg, AcpiDbTestTypes);
       if (Temp == ACPI_TYPE_NOT_FOUND)
       {
           AcpiOsPrintf ("Invalid or unsupported argument\n");
           return;
       }
   
       switch (Temp)
       {
       case CMD_TEST_OBJECTS:
   
           AcpiDbTestAllObjects ();
           break;
   
       case CMD_TEST_PREDEFINED:
   
           AcpiDbEvaluateAllPredefinedNames (NULL);
           break;
   
       default:
           break;
       }
   }
   
   
   /*******************************************************************************
    *
    * FUNCTION:    AcpiDbTestAllObjects
    *
    * PARAMETERS:  None
    *
    * RETURN:      None
    *
    * DESCRIPTION: This test implements the OBJECTS subcommand. It exercises the
    *              namespace by reading/writing/comparing all data objects such
    *              as integers, strings, buffers, fields, buffer fields, etc.
    *
    ******************************************************************************/
   
   static void
   AcpiDbTestAllObjects (
       void)
   {
       ACPI_STATUS             Status;
   
   
       /* Install the debugger read-object control method if necessary */
   
       if (!ReadHandle)
       {
           Status = AcpiInstallMethod (ReadMethodCode);
           if (ACPI_FAILURE (Status))
           {
               AcpiOsPrintf ("%s, Could not install debugger read method\n",
                   AcpiFormatException (Status));
               return;
           }
   
           Status = AcpiGetHandle (NULL, ACPI_DB_READ_METHOD, &ReadHandle);
           if (ACPI_FAILURE (Status))
           {
               AcpiOsPrintf ("Could not obtain handle for debug method %s\n",
                   ACPI_DB_READ_METHOD);
               return;
           }
       }
   
       /* Install the debugger write-object control method if necessary */
   
       if (!WriteHandle)
       {
           Status = AcpiInstallMethod (WriteMethodCode);
           if (ACPI_FAILURE (Status))
           {
               AcpiOsPrintf ("%s, Could not install debugger write method\n",
                   AcpiFormatException (Status));
               return;
           }
   
           Status = AcpiGetHandle (NULL, ACPI_DB_WRITE_METHOD, &WriteHandle);
           if (ACPI_FAILURE (Status))
           {
               AcpiOsPrintf ("Could not obtain handle for debug method %s\n",
                   ACPI_DB_WRITE_METHOD);
               return;
           }
       }
   
       /* Walk the entire namespace, testing each supported named data object */
   
       (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
           ACPI_UINT32_MAX, AcpiDbTestOneObject, NULL, NULL, NULL);
   }
   
   
   /*******************************************************************************
    *
    * FUNCTION:    AcpiDbTestOneObject
    *
    * PARAMETERS:  ACPI_WALK_CALLBACK
    *
    * RETURN:      Status
    *
    * DESCRIPTION: Test one namespace object. Supported types are Integer,
    *              String, Buffer, Package, BufferField, and FieldUnit.
    *              All other object types are simply ignored.
    *
    ******************************************************************************/
   
   static ACPI_STATUS
   AcpiDbTestOneObject (
       ACPI_HANDLE             ObjHandle,
       UINT32                  NestingLevel,
       void                    *Context,
       void                    **ReturnValue)
   {
       ACPI_NAMESPACE_NODE     *Node;
       ACPI_OPERAND_OBJECT     *ObjDesc;
       ACPI_OBJECT_TYPE        LocalType;
       UINT32                  BitLength = 0;
       UINT32                  ByteLength = 0;
       ACPI_STATUS             Status = AE_OK;
   
   
       Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle);
       ObjDesc = Node->Object;
   
       /*
        * For the supported types, get the actual bit length or
        * byte length. Map the type to one of Integer/String/Buffer.
        */
       switch (Node->Type)
       {
       case ACPI_TYPE_INTEGER:
   
           /* Integer width is either 32 or 64 */
   
           LocalType = ACPI_TYPE_INTEGER;
           BitLength = AcpiGbl_IntegerBitWidth;
           break;
   
       case ACPI_TYPE_STRING:
   
           LocalType = ACPI_TYPE_STRING;
           ByteLength = ObjDesc->String.Length;
           break;
   
       case ACPI_TYPE_BUFFER:
   
           LocalType = ACPI_TYPE_BUFFER;
           ByteLength = ObjDesc->Buffer.Length;
           BitLength = ByteLength * 8;
           break;
   
       case ACPI_TYPE_PACKAGE:
   
           LocalType = ACPI_TYPE_PACKAGE;
           break;
   
       case ACPI_TYPE_FIELD_UNIT:
       case ACPI_TYPE_LOCAL_REGION_FIELD:
       case ACPI_TYPE_LOCAL_INDEX_FIELD:
       case ACPI_TYPE_LOCAL_BANK_FIELD:
   
           LocalType = ACPI_TYPE_FIELD_UNIT;
           break;
   
       case ACPI_TYPE_BUFFER_FIELD:
           /*
            * The returned object will be a Buffer if the field length
            * is larger than the size of an Integer (32 or 64 bits
            * depending on the DSDT version).
            */
           LocalType = ACPI_TYPE_INTEGER;
           if (ObjDesc)
           {
               BitLength = ObjDesc->CommonField.BitLength;
               ByteLength = ACPI_ROUND_BITS_UP_TO_BYTES (BitLength);
               if (BitLength > AcpiGbl_IntegerBitWidth)
               {
                   LocalType = ACPI_TYPE_BUFFER;
               }
           }
           break;
   
   default:
   
           /* Ignore all non-data types - Methods, Devices, Scopes, etc. */
   
           return (AE_OK);
       }
   
       /* Emit the common prefix: Type:Name */
   
       AcpiOsPrintf ("%14s: %4.4s",
           AcpiUtGetTypeName (Node->Type), Node->Name.Ascii);
   
       if (!ObjDesc)
       {
           AcpiOsPrintf (" No attached sub-object, ignoring\n");
           return (AE_OK);
       }
   
       /* At this point, we have resolved the object to one of the major types */
   
       switch (LocalType)
       {
       case ACPI_TYPE_INTEGER:
   
           Status = AcpiDbTestIntegerType (Node, BitLength);
           break;
   
       case ACPI_TYPE_STRING:
   
           Status = AcpiDbTestStringType (Node, ByteLength);
           break;
   
       case ACPI_TYPE_BUFFER:
   
           Status = AcpiDbTestBufferType (Node, BitLength);
           break;
   
       case ACPI_TYPE_PACKAGE:
   
           Status = AcpiDbTestPackageType (Node);
           break;
   
       case ACPI_TYPE_FIELD_UNIT:
   
           Status = AcpiDbTestFieldUnitType (ObjDesc);
           break;
   
       default:
   
           AcpiOsPrintf (" Ignoring, type not implemented (%2.2X)",
               LocalType);
           break;
       }
   
       /* Exit on error, but don't abort the namespace walk */
   
       if (ACPI_FAILURE (Status))
       {
           Status = AE_OK;
       }
   
       AcpiOsPrintf ("\n");
       return (Status);
   }
   
   
   /*******************************************************************************
    *
    * FUNCTION:    AcpiDbTestIntegerType
    *
    * PARAMETERS:  Node                - Parent NS node for the object
    *              BitLength           - Actual length of the object. Used for
    *                                    support of arbitrary length FieldUnit
    *                                    and BufferField objects.
    *
    * RETURN:      Status
    *
    * DESCRIPTION: Test read/write for an Integer-valued object. Performs a
    *              write/read/compare of an arbitrary new value, then performs
    *              a write/read/compare of the original value.
    *
    ******************************************************************************/
   
   static ACPI_STATUS
   AcpiDbTestIntegerType (
       ACPI_NAMESPACE_NODE     *Node,
       UINT32                  BitLength)
   {
       ACPI_OBJECT             *Temp1 = NULL;
       ACPI_OBJECT             *Temp2 = NULL;
       ACPI_OBJECT             *Temp3 = NULL;
       ACPI_OBJECT             WriteValue;
       UINT64                  ValueToWrite;
       ACPI_STATUS             Status;
   
   
       if (BitLength > 64)
       {
           AcpiOsPrintf (" Invalid length for an Integer: %u", BitLength);
           return (AE_OK);
       }
   
       /* Read the original value */
   
       Status = AcpiDbReadFromObject (Node, ACPI_TYPE_INTEGER, &Temp1);
       if (ACPI_FAILURE (Status))
       {
           return (Status);
       }
   
       AcpiOsPrintf (ACPI_DEBUG_LENGTH_FORMAT " %8.8X%8.8X",
           BitLength, ACPI_ROUND_BITS_UP_TO_BYTES (BitLength),
           ACPI_FORMAT_UINT64 (Temp1->Integer.Value));
   
       ValueToWrite = ACPI_UINT64_MAX >> (64 - BitLength);
       if (Temp1->Integer.Value == ValueToWrite)
       {
           ValueToWrite = 0;
       }
       /* Write a new value */
   
       WriteValue.Type = ACPI_TYPE_INTEGER;
       WriteValue.Integer.Value = ValueToWrite;
       Status = AcpiDbWriteToObject (Node, &WriteValue);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       /* Ensure that we can read back the new value */
   
       Status = AcpiDbReadFromObject (Node, ACPI_TYPE_INTEGER, &Temp2);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       if (Temp2->Integer.Value != ValueToWrite)
       {
           AcpiOsPrintf (" MISMATCH 2: %8.8X%8.8X, expecting %8.8X%8.8X",
               ACPI_FORMAT_UINT64 (Temp2->Integer.Value),
               ACPI_FORMAT_UINT64 (ValueToWrite));
       }
   
       /* Write back the original value */
   
       WriteValue.Integer.Value = Temp1->Integer.Value;
       Status = AcpiDbWriteToObject (Node, &WriteValue);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       /* Ensure that we can read back the original value */
   
       Status = AcpiDbReadFromObject (Node, ACPI_TYPE_INTEGER, &Temp3);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       if (Temp3->Integer.Value != Temp1->Integer.Value)
       {
           AcpiOsPrintf (" MISMATCH 3: %8.8X%8.8X, expecting %8.8X%8.8X",
               ACPI_FORMAT_UINT64 (Temp3->Integer.Value),
               ACPI_FORMAT_UINT64 (Temp1->Integer.Value));
       }
   
   Exit:
       if (Temp1) {AcpiOsFree (Temp1);}
       if (Temp2) {AcpiOsFree (Temp2);}
       if (Temp3) {AcpiOsFree (Temp3);}
       return (AE_OK);
   }
   
   
   /*******************************************************************************
    *
    * FUNCTION:    AcpiDbTestBufferType
    *
    * PARAMETERS:  Node                - Parent NS node for the object
    *              BitLength           - Actual length of the object.
    *
    * RETURN:      Status
    *
    * DESCRIPTION: Test read/write for an Buffer-valued object. Performs a
    *              write/read/compare of an arbitrary new value, then performs
    *              a write/read/compare of the original value.
    *
    ******************************************************************************/
   
   static ACPI_STATUS
   AcpiDbTestBufferType (
       ACPI_NAMESPACE_NODE     *Node,
       UINT32                  BitLength)
   {
       ACPI_OBJECT             *Temp1 = NULL;
       ACPI_OBJECT             *Temp2 = NULL;
       ACPI_OBJECT             *Temp3 = NULL;
       UINT8                   *Buffer;
       ACPI_OBJECT             WriteValue;
       ACPI_STATUS             Status;
       UINT32                  ByteLength;
       UINT32                  i;
       UINT8                   ExtraBits;
   
   
       ByteLength = ACPI_ROUND_BITS_UP_TO_BYTES (BitLength);
       if (ByteLength == 0)
       {
           AcpiOsPrintf (" Ignoring zero length buffer");
           return (AE_OK);
       }
   
       /* Allocate a local buffer */
   
       Buffer = ACPI_ALLOCATE_ZEROED (ByteLength);
       if (!Buffer)
       {
           return (AE_NO_MEMORY);
       }
   
       /* Read the original value */
   
       Status = AcpiDbReadFromObject (Node, ACPI_TYPE_BUFFER, &Temp1);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       /* Emit a few bytes of the buffer */
   
       AcpiOsPrintf (ACPI_DEBUG_LENGTH_FORMAT, BitLength, Temp1->Buffer.Length);
       for (i = 0; ((i < 8) && (i < ByteLength)); i++)
       {
           AcpiOsPrintf (" %2.2X", Temp1->Buffer.Pointer[i]);
       }
       AcpiOsPrintf ("...  ");
   
       /*
        * Write a new value.
        *
        * Handle possible extra bits at the end of the buffer. Can
        * happen for FieldUnits larger than an integer, but the bit
        * count is not an integral number of bytes. Zero out the
        * unused bits.
        */
       memset (Buffer, BUFFER_FILL_VALUE, ByteLength);
       ExtraBits = BitLength % 8;
       if (ExtraBits)
       {
           Buffer [ByteLength - 1] = ACPI_MASK_BITS_ABOVE (ExtraBits);
       }
   
       WriteValue.Type = ACPI_TYPE_BUFFER;
       WriteValue.Buffer.Length = ByteLength;
       WriteValue.Buffer.Pointer = Buffer;
   
       Status = AcpiDbWriteToObject (Node, &WriteValue);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       /* Ensure that we can read back the new value */
   
       Status = AcpiDbReadFromObject (Node, ACPI_TYPE_BUFFER, &Temp2);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       if (memcmp (Temp2->Buffer.Pointer, Buffer, ByteLength))
       {
           AcpiOsPrintf (" MISMATCH 2: New buffer value");
       }
   
       /* Write back the original value */
   
       WriteValue.Buffer.Length = ByteLength;
       WriteValue.Buffer.Pointer = Temp1->Buffer.Pointer;
   
       Status = AcpiDbWriteToObject (Node, &WriteValue);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       /* Ensure that we can read back the original value */
   
       Status = AcpiDbReadFromObject (Node, ACPI_TYPE_BUFFER, &Temp3);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       if (memcmp (Temp1->Buffer.Pointer,
               Temp3->Buffer.Pointer, ByteLength))
       {
           AcpiOsPrintf (" MISMATCH 3: While restoring original buffer");
       }
   
   Exit:
       ACPI_FREE (Buffer);
       if (Temp1) {AcpiOsFree (Temp1);}
       if (Temp2) {AcpiOsFree (Temp2);}
       if (Temp3) {AcpiOsFree (Temp3);}
       return (Status);
   }
   
   
   /*******************************************************************************
    *
    * FUNCTION:    AcpiDbTestStringType
    *
    * PARAMETERS:  Node                - Parent NS node for the object
    *              ByteLength          - Actual length of the object.
    *
    * RETURN:      Status
    *
    * DESCRIPTION: Test read/write for an String-valued object. Performs a
    *              write/read/compare of an arbitrary new value, then performs
    *              a write/read/compare of the original value.
    *
    ******************************************************************************/
   
   static ACPI_STATUS
   AcpiDbTestStringType (
       ACPI_NAMESPACE_NODE     *Node,
       UINT32                  ByteLength)
   {
       ACPI_OBJECT             *Temp1 = NULL;
       ACPI_OBJECT             *Temp2 = NULL;
       ACPI_OBJECT             *Temp3 = NULL;
       char                    *ValueToWrite = "Test String from AML Debugger";
       ACPI_OBJECT             WriteValue;
       ACPI_STATUS             Status;
   
   
       /* Read the original value */
   
       Status = AcpiDbReadFromObject (Node, ACPI_TYPE_STRING, &Temp1);
       if (ACPI_FAILURE (Status))
       {
           return (Status);
       }
   
       AcpiOsPrintf (ACPI_DEBUG_LENGTH_FORMAT " \"%s\"", (Temp1->String.Length * 8),
           Temp1->String.Length, Temp1->String.Pointer);
   
       /* Write a new value */
   
       WriteValue.Type = ACPI_TYPE_STRING;
       WriteValue.String.Length = strlen (ValueToWrite);
       WriteValue.String.Pointer = ValueToWrite;
   
       Status = AcpiDbWriteToObject (Node, &WriteValue);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       /* Ensure that we can read back the new value */
   
       Status = AcpiDbReadFromObject (Node, ACPI_TYPE_STRING, &Temp2);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       if (strcmp (Temp2->String.Pointer, ValueToWrite))
       {
           AcpiOsPrintf (" MISMATCH 2: %s, expecting %s",
               Temp2->String.Pointer, ValueToWrite);
       }
   
       /* Write back the original value */
   
       WriteValue.String.Length = strlen (Temp1->String.Pointer);
       WriteValue.String.Pointer = Temp1->String.Pointer;
   
       Status = AcpiDbWriteToObject (Node, &WriteValue);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       /* Ensure that we can read back the original value */
   
       Status = AcpiDbReadFromObject (Node, ACPI_TYPE_STRING, &Temp3);
       if (ACPI_FAILURE (Status))
       {
           goto Exit;
       }
   
       if (strcmp (Temp1->String.Pointer, Temp3->String.Pointer))
       {
           AcpiOsPrintf (" MISMATCH 3: %s, expecting %s",
               Temp3->String.Pointer, Temp1->String.Pointer);
       }
   
   Exit:
       if (Temp1) {AcpiOsFree (Temp1);}
       if (Temp2) {AcpiOsFree (Temp2);}
       if (Temp3) {AcpiOsFree (Temp3);}
       return (Status);
   }
   
   
   /*******************************************************************************
    *
    * FUNCTION:    AcpiDbTestPackageType
    *
    * PARAMETERS:  Node                - Parent NS node for the object
    *
    * RETURN:      Status
    *
    * DESCRIPTION: Test read for a Package object.
    *
    ******************************************************************************/
   
   static ACPI_STATUS
   AcpiDbTestPackageType (
       ACPI_NAMESPACE_NODE     *Node)
   {
       ACPI_OBJECT             *Temp1 = NULL;
       ACPI_STATUS             Status;
   
   
       /* Read the original value */
   
       Status = AcpiDbReadFromObject (Node, ACPI_TYPE_PACKAGE, &Temp1);
       if (ACPI_FAILURE (Status))
       {
           return (Status);
       }
   
       AcpiOsPrintf (" %.2X Elements", Temp1->Package.Count);
       AcpiOsFree (Temp1);
       return (Status);
   }
   
   
   /*******************************************************************************
    *
    * FUNCTION:    AcpiDbTestFieldUnitType
    *
    * PARAMETERS:  ObjDesc                 - A field unit object
    *
    * RETURN:      Status
    *
    * DESCRIPTION: Test read/write on a named field unit.
    *
    ******************************************************************************/
   
   static ACPI_STATUS
   AcpiDbTestFieldUnitType (
       ACPI_OPERAND_OBJECT     *ObjDesc)
   {
       ACPI_OPERAND_OBJECT     *RegionObj;
       UINT32                  BitLength = 0;
       UINT32                  ByteLength = 0;
       ACPI_STATUS             Status = AE_OK;
       ACPI_OPERAND_OBJECT     *RetBufferDesc;
   
   
       /* Supported spaces are memory/io/pci_config */
   
       RegionObj = ObjDesc->Field.RegionObj;
       switch (RegionObj->Region.SpaceId)
       {
       case ACPI_ADR_SPACE_SYSTEM_MEMORY:
       case ACPI_ADR_SPACE_SYSTEM_IO:
       case ACPI_ADR_SPACE_PCI_CONFIG:
   
           /* Need the interpreter to execute */
   
           AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER);
           AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
   
           /* Exercise read-then-write */
   
           Status = AcpiExReadDataFromField (NULL, ObjDesc, &RetBufferDesc);
           if (Status == AE_OK)
           {
               AcpiExWriteDataToField (RetBufferDesc, ObjDesc, NULL);
               AcpiUtRemoveReference (RetBufferDesc);
           }
   
           AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
           AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
   
           BitLength = ObjDesc->CommonField.BitLength;
           ByteLength = ACPI_ROUND_BITS_UP_TO_BYTES (BitLength);
   
           AcpiOsPrintf (ACPI_DEBUG_LENGTH_FORMAT " [%s]", BitLength,
               ByteLength, AcpiUtGetRegionName (RegionObj->Region.SpaceId));
           return (Status);
   
       default:
   
           AcpiOsPrintf (
               "      %s address space is not supported in this command [%4.4s]",
               AcpiUtGetRegionName (RegionObj->Region.SpaceId),
              RegionObj->Region.Node->Name.Ascii);
          return (AE_OK);
      }
  }
  
  
  /*******************************************************************************
   *
   * FUNCTION:    AcpiDbReadFromObject
   *
   * PARAMETERS:  Node                - Parent NS node for the object
   *              ExpectedType        - Object type expected from the read
   *              Value               - Where the value read is returned
   *
   * RETURN:      Status
   *
   * DESCRIPTION: Performs a read from the specified object by invoking the
   *              special debugger control method that reads the object. Thus,
   *              the AML interpreter is doing all of the work, increasing the
   *              validity of the test.
   *
   ******************************************************************************/
  
  static ACPI_STATUS
  AcpiDbReadFromObject (
      ACPI_NAMESPACE_NODE     *Node,
      ACPI_OBJECT_TYPE        ExpectedType,
      ACPI_OBJECT             **Value)
  {
      ACPI_OBJECT             *RetValue;
      ACPI_OBJECT_LIST        ParamObjects;
      ACPI_OBJECT             Params[2];
      ACPI_BUFFER             ReturnObj;
      ACPI_STATUS             Status;
  
  
      Params[0].Type = ACPI_TYPE_LOCAL_REFERENCE;
      Params[0].Reference.ActualType = Node->Type;
      Params[0].Reference.Handle = ACPI_CAST_PTR (ACPI_HANDLE, Node);
  
      ParamObjects.Count = 1;
      ParamObjects.Pointer = Params;
  
      ReturnObj.Length  = ACPI_ALLOCATE_BUFFER;
  
      AcpiGbl_MethodExecuting = TRUE;
      Status = AcpiEvaluateObject (ReadHandle, NULL,
          &ParamObjects, &ReturnObj);
  
      AcpiGbl_MethodExecuting = FALSE;
      if (ACPI_FAILURE (Status))
      {
          AcpiOsPrintf ("Could not read from object, %s",
              AcpiFormatException (Status));
          return (Status);
      }
  
      RetValue = (ACPI_OBJECT *) ReturnObj.Pointer;
  
      switch (RetValue->Type)
      {
      case ACPI_TYPE_INTEGER:
      case ACPI_TYPE_BUFFER:
      case ACPI_TYPE_STRING:
      case ACPI_TYPE_PACKAGE:
          /*
           * Did we receive the type we wanted? Most important for the
           * Integer/Buffer case (when a field is larger than an Integer,
           * it should return a Buffer).
           */
          if (RetValue->Type != ExpectedType)
          {
              AcpiOsPrintf (" Type mismatch:  Expected %s, Received %s",
                  AcpiUtGetTypeName (ExpectedType),
                  AcpiUtGetTypeName (RetValue->Type));
  
              AcpiOsFree (ReturnObj.Pointer);
              return (AE_TYPE);
          }
  
          *Value = RetValue;
          break;
  
      default:
  
          AcpiOsPrintf (" Unsupported return object type, %s",
              AcpiUtGetTypeName (RetValue->Type));
  
          AcpiOsFree (ReturnObj.Pointer);
          return (AE_TYPE);
      }
  
      return (Status);
  }
  
  
  /*******************************************************************************
   *
   * FUNCTION:    AcpiDbWriteToObject
   *
   * PARAMETERS:  Node                - Parent NS node for the object
   *              Value               - Value to be written
   *
   * RETURN:      Status
   *
   * DESCRIPTION: Performs a write to the specified object by invoking the
   *              special debugger control method that writes the object. Thus,
   *              the AML interpreter is doing all of the work, increasing the
   *              validity of the test.
   *
   ******************************************************************************/
  
  static ACPI_STATUS
  AcpiDbWriteToObject (
      ACPI_NAMESPACE_NODE     *Node,
      ACPI_OBJECT             *Value)
  {
      ACPI_OBJECT_LIST        ParamObjects;
      ACPI_OBJECT             Params[2];
      ACPI_STATUS             Status;
  
  
      Params[0].Type = ACPI_TYPE_LOCAL_REFERENCE;
      Params[0].Reference.ActualType = Node->Type;
      Params[0].Reference.Handle = ACPI_CAST_PTR (ACPI_HANDLE, Node);
  
      /* Copy the incoming user parameter */
  
      memcpy (&Params[1], Value, sizeof (ACPI_OBJECT));
  
      ParamObjects.Count = 2;
      ParamObjects.Pointer = Params;
  
      AcpiGbl_MethodExecuting = TRUE;
      Status = AcpiEvaluateObject (WriteHandle, NULL, &ParamObjects, NULL);
      AcpiGbl_MethodExecuting = FALSE;
  
      if (ACPI_FAILURE (Status))
      {
          AcpiOsPrintf ("Could not write to object, %s",
              AcpiFormatException (Status));
      }
  
      return (Status);
  }
  
  
  /*******************************************************************************
   *
   * FUNCTION:    AcpiDbEvaluateAllPredefinedNames
   *
   * PARAMETERS:  CountArg            - Max number of methods to execute
   *
   * RETURN:      None
   *
   * DESCRIPTION: Namespace batch execution. Execute predefined names in the
   *              namespace, up to the max count, if specified.
   *
   ******************************************************************************/
  
  static void
  AcpiDbEvaluateAllPredefinedNames (
      char                    *CountArg)
  {
      ACPI_DB_EXECUTE_WALK    Info;
  
  
      Info.Count = 0;
      Info.MaxCount = ACPI_UINT32_MAX;
  
      if (CountArg)
      {
          Info.MaxCount = strtoul (CountArg, NULL, 0);
      }
  
      /* Search all nodes in namespace */
  
      (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
          ACPI_UINT32_MAX, AcpiDbEvaluateOnePredefinedName, NULL,
          (void *) &Info, NULL);
  
      AcpiOsPrintf (
          "Evaluated %u predefined names in the namespace\n", Info.Count);
  }
  
  
  /*******************************************************************************
   *
   * FUNCTION:    AcpiDbEvaluateOnePredefinedName
   *
   * PARAMETERS:  Callback from WalkNamespace
   *
   * RETURN:      Status
   *
   * DESCRIPTION: Batch execution module. Currently only executes predefined
   *              ACPI names.
   *
   ******************************************************************************/
  
  static ACPI_STATUS
  AcpiDbEvaluateOnePredefinedName (
      ACPI_HANDLE             ObjHandle,
      UINT32                  NestingLevel,
      void                    *Context,
      void                    **ReturnValue)
  {
      ACPI_NAMESPACE_NODE         *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
      ACPI_DB_EXECUTE_WALK        *Info = (ACPI_DB_EXECUTE_WALK *) Context;
      char                        *Pathname;
      const ACPI_PREDEFINED_INFO  *Predefined;
      ACPI_DEVICE_INFO            *ObjInfo;
      ACPI_OBJECT_LIST            ParamObjects;
      ACPI_OBJECT                 Params[ACPI_METHOD_NUM_ARGS];
      ACPI_OBJECT                 *ThisParam;
      ACPI_BUFFER                 ReturnObj;
      ACPI_STATUS                 Status;
      UINT16                      ArgTypeList;
      UINT8                       ArgCount;
      UINT8                       ArgType;
      UINT32                      i;
  
  
      /* The name must be a predefined ACPI name */
  
      Predefined = AcpiUtMatchPredefinedMethod (Node->Name.Ascii);
      if (!Predefined)
      {
          return (AE_OK);
      }
  
      if (Node->Type == ACPI_TYPE_LOCAL_SCOPE)
      {
          return (AE_OK);
      }
  
      Pathname = AcpiNsGetNormalizedPathname (Node, TRUE);
      if (!Pathname)
      {
          return (AE_OK);
      }
  
      /* Get the object info for number of method parameters */
  
      Status = AcpiGetObjectInfo (ObjHandle, &ObjInfo);
      if (ACPI_FAILURE (Status))
      {
          ACPI_FREE (Pathname);
          return (Status);
      }
  
      ParamObjects.Count = 0;
      ParamObjects.Pointer = NULL;
  
      if (ObjInfo->Type == ACPI_TYPE_METHOD)
      {
          /* Setup default parameters (with proper types) */
  
          ArgTypeList = Predefined->Info.ArgumentList;
          ArgCount = METHOD_GET_ARG_COUNT (ArgTypeList);
  
          /*
           * Setup the ACPI-required number of arguments, regardless of what
           * the actual method defines. If there is a difference, then the
           * method is wrong and a warning will be issued during execution.
           */
          ThisParam = Params;
          for (i = 0; i < ArgCount; i++)
          {
              ArgType = METHOD_GET_NEXT_TYPE (ArgTypeList);
              ThisParam->Type = ArgType;
  
              switch (ArgType)
              {
              case ACPI_TYPE_INTEGER:
  
                  ThisParam->Integer.Value = 1;
                  break;
  
              case ACPI_TYPE_STRING:
  
                  ThisParam->String.Pointer =
                      "This is the default argument string";
                  ThisParam->String.Length =
                      strlen (ThisParam->String.Pointer);
                  break;
  
              case ACPI_TYPE_BUFFER:
  
                  ThisParam->Buffer.Pointer = (UINT8 *) Params; /* just a garbage buffer */
                  ThisParam->Buffer.Length = 48;
                  break;
  
               case ACPI_TYPE_PACKAGE:
  
                  ThisParam->Package.Elements = NULL;
                  ThisParam->Package.Count = 0;
                  break;
  
             default:
  
                  AcpiOsPrintf ("%s: Unsupported argument type: %u\n",
                      Pathname, ArgType);
                  break;
              }
  
              ThisParam++;
          }
  
          ParamObjects.Count = ArgCount;
          ParamObjects.Pointer = Params;
      }
  
      ACPI_FREE (ObjInfo);
      ReturnObj.Pointer = NULL;
      ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
  
      /* Do the actual method execution */
  
      AcpiGbl_MethodExecuting = TRUE;
  
      Status = AcpiEvaluateObject (Node, NULL, &ParamObjects, &ReturnObj);
  
      AcpiOsPrintf ("%-32s returned %s\n",
          Pathname, AcpiFormatException (Status));
      AcpiGbl_MethodExecuting = FALSE;
      ACPI_FREE (Pathname);
  
      /* Ignore status from method execution */
  
      Status = AE_OK;
  
      /* Update count, check if we have executed enough methods */
  
      Info->Count++;
      if (Info->Count >= Info->MaxCount)
      {
          Status = AE_CTRL_TERMINATE;
      }
  
      return (Status);
  }

Cache object: 358c985db063a11458e7e2c7c4feaed2