Import the Intel ACPI CA 20011018 snapshot

4 files changed, 2439 insertions, 0 deletions

diff --git a/sys/contrib/dev/acpica/exoparg1.c b/sys/contrib/dev/acpica/exoparg1.c
new file mode 100644
index 000000000000..123c6d36a3c3
--- /dev/null
+++ b/sys/contrib/dev/acpica/exoparg1.c
@@ -0,0 +1,1021 @@
+
+/******************************************************************************
+ *
+ * Module Name: exoparg1 - AML execution - opcodes with 1 argument
+ *              $Revision: 120 $
+ *
+ *****************************************************************************/
+
+/******************************************************************************
+ *
+ * 1. Copyright Notice
+ *
+ * Some or all of this work - Copyright (c) 1999, 2000, 2001, 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.
+ *
+ *****************************************************************************/
+
+#define __EXOPARG1_C__
+
+#include "acpi.h"
+#include "acparser.h"
+#include "acdispat.h"
+#include "acinterp.h"
+#include "amlcode.h"
+#include "acnamesp.h"
+
+
+#define _COMPONENT          ACPI_EXECUTER
+        MODULE_NAME         ("exoparg1")
+
+
+/*!
+ * Naming convention for AML interpreter execution routines.
+ *
+ * The routines that begin execution of AML opcodes are named with a common
+ * convention based upon the number of arguments, the number of target operands,
+ * and whether or not a value is returned:
+ *
+ *      AcpiExOpcode_xA_yT_zR
+ *
+ * Where:  
+ *
+ * xA - ARGUMENTS:    The number of arguments (input operands) that are 
+ *                    required for this opcode type (1 through 6 args).
+ * yT - TARGETS:      The number of targets (output operands) that are required 
+ *                    for this opcode type (0, 1, or 2 targets).
+ * zR - RETURN VALUE: Indicates whether this opcode type returns a value 
+ *                    as the function return (0 or 1).
+ *
+ * The AcpiExOpcode* functions are called via the Dispatcher component with 
+ * fully resolved operands.
+!*/
+
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExOpcode_1A_0T_0R
+ *
+ * PARAMETERS:  WalkState           - Current state (contains AML opcode)
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute Type 1 monadic operator with numeric operand on
+ *              object stack
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExOpcode_1A_0T_0R (
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
+    ACPI_STATUS             Status = AE_OK;
+
+
+    FUNCTION_TRACE_STR ("ExOpcode_1A_0T_0R", AcpiPsGetOpcodeName (WalkState->Opcode));
+
+
+    /* Examine the opcode */
+
+    switch (WalkState->Opcode)  
+    {
+    case AML_RELEASE_OP:    /*  Release (MutexObject) */
+
+        Status = AcpiExReleaseMutex (Operand[0], WalkState);
+        break;
+
+
+    case AML_RESET_OP:      /*  Reset (EventObject) */
+
+        Status = AcpiExSystemResetEvent (Operand[0]);
+        break;
+
+
+    case AML_SIGNAL_OP:     /*  Signal (EventObject) */
+
+        Status = AcpiExSystemSignalEvent (Operand[0]);
+        break;
+
+
+    case AML_SLEEP_OP:      /*  Sleep (MsecTime) */
+
+        AcpiExSystemDoSuspend ((UINT32) Operand[0]->Integer.Value);
+        break;
+
+
+    case AML_STALL_OP:      /*  Stall (UsecTime) */
+
+        AcpiExSystemDoStall ((UINT32) Operand[0]->Integer.Value);
+        break;
+
+
+    case AML_UNLOAD_OP:     /*  Unload (Handle) */
+
+        Status = AcpiExUnloadTable (Operand[0]);
+        break;
+
+
+    default:                /*  Unknown opcode  */
+
+        REPORT_ERROR (("AcpiExOpcode_1A_0T_0R: Unknown opcode %X\n",
+            WalkState->Opcode));
+        Status = AE_AML_BAD_OPCODE;
+        break;
+    }
+
+    return_ACPI_STATUS (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExOpcode_1A_1T_0R
+ *
+ * PARAMETERS:  WalkState           - Current state (contains AML opcode)
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute opcode with one argument, one target, and no
+ *              return value.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExOpcode_1A_1T_0R (
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_STATUS             Status = AE_OK;
+    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
+
+
+    FUNCTION_TRACE_STR ("ExOpcode_1A_1T_0R", AcpiPsGetOpcodeName (WalkState->Opcode));
+
+
+    switch (WalkState->Opcode)
+    {
+
+    case AML_LOAD_OP:
+
+        Status = AcpiExLoadOp (Operand[0], Operand[1]);
+        break;
+
+    default:                        /* Unknown opcode */
+
+        REPORT_ERROR (("AcpiExOpcode_1A_1T_0R: Unknown opcode %X\n",
+            WalkState->Opcode));
+        Status = AE_AML_BAD_OPCODE;
+        goto Cleanup;
+    }
+
+
+Cleanup:
+
+    return_ACPI_STATUS (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExOpcode_1A_1T_1R
+ *
+ * PARAMETERS:  WalkState           - Current state (contains AML opcode)
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute opcode with one argument, one target, and a
+ *              return value.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExOpcode_1A_1T_1R (
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_STATUS             Status = AE_OK;
+    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
+    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
+    ACPI_OPERAND_OBJECT     *ReturnDesc2 = NULL;
+    UINT32                  Temp32;
+    UINT32                  i;
+    UINT32                  j;
+    ACPI_INTEGER            Digit;
+
+
+    FUNCTION_TRACE_STR ("ExOpcode_1A_1T_1R", AcpiPsGetOpcodeName (WalkState->Opcode));
+
+
+    /* Create a return object of type Integer for most opcodes */
+
+    switch (WalkState->Opcode)
+    {
+    case AML_BIT_NOT_OP:
+    case AML_FIND_SET_LEFT_BIT_OP:
+    case AML_FIND_SET_RIGHT_BIT_OP:
+    case AML_FROM_BCD_OP:
+    case AML_TO_BCD_OP:
+    case AML_COND_REF_OF_OP:
+
+        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
+        if (!ReturnDesc)
+        {
+            Status = AE_NO_MEMORY;
+            goto Cleanup;
+        }
+
+        break;
+    }
+
+
+    switch (WalkState->Opcode)
+    {
+
+    case AML_BIT_NOT_OP:            /* Not (Operand, Result)  */
+
+        ReturnDesc->Integer.Value = ~Operand[0]->Integer.Value;
+        break;
+
+
+    case AML_FIND_SET_LEFT_BIT_OP:  /* FindSetLeftBit (Operand, Result) */
+
+
+        ReturnDesc->Integer.Value = Operand[0]->Integer.Value;
+
+        /*
+         * Acpi specification describes Integer type as a little
+         * endian unsigned value, so this boundary condition is valid.
+         */
+        for (Temp32 = 0; ReturnDesc->Integer.Value && Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32)
+        {
+            ReturnDesc->Integer.Value >>= 1;
+        }
+
+        ReturnDesc->Integer.Value = Temp32;
+        break;
+
+
+    case AML_FIND_SET_RIGHT_BIT_OP: /* FindSetRightBit (Operand, Result)  */
+
+
+        ReturnDesc->Integer.Value = Operand[0]->Integer.Value;
+
+        /*
+         * The Acpi specification describes Integer type as a little
+         * endian unsigned value, so this boundary condition is valid.
+         */
+        for (Temp32 = 0; ReturnDesc->Integer.Value && Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32)
+        {
+            ReturnDesc->Integer.Value <<= 1;
+        }
+
+        /* Since the bit position is one-based, subtract from 33 (65) */
+
+        ReturnDesc->Integer.Value = Temp32 == 0 ? 0 : (ACPI_INTEGER_BIT_SIZE + 1) - Temp32;
+        break;
+
+
+    case AML_FROM_BCD_OP:           /* FromBcd (BCDValue, Result)  */
+
+        /*
+         * The 64-bit ACPI integer can hold 16 4-bit BCD integers
+         */
+        ReturnDesc->Integer.Value = 0;
+        for (i = 0; i < ACPI_MAX_BCD_DIGITS; i++)
+        {
+            /* Get one BCD digit */
+
+            Digit = (ACPI_INTEGER) ((Operand[0]->Integer.Value >> (i * 4)) & 0xF);
+
+            /* Check the range of the digit */
+
+            if (Digit > 9)
+            {
+                ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "BCD digit too large: %d\n",
+                    (UINT32) Digit));
+                Status = AE_AML_NUMERIC_OVERFLOW;
+                goto Cleanup;
+            }
+
+            if (Digit > 0)
+            {
+                /* Sum into the result with the appropriate power of 10 */
+
+                for (j = 0; j < i; j++)
+                {
+                    Digit *= 10;
+                }
+
+                ReturnDesc->Integer.Value += Digit;
+            }
+        }
+        break;
+
+
+    case AML_TO_BCD_OP:             /* ToBcd (Operand, Result)  */
+
+        if (Operand[0]->Integer.Value > ACPI_MAX_BCD_VALUE)
+        {
+            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "BCD overflow: %8.8X%8.8X\n",
+                HIDWORD(Operand[0]->Integer.Value), LODWORD(Operand[0]->Integer.Value)));
+            Status = AE_AML_NUMERIC_OVERFLOW;
+            goto Cleanup;
+        }
+
+        ReturnDesc->Integer.Value = 0;
+        for (i = 0; i < ACPI_MAX_BCD_DIGITS; i++)
+        {
+            /* Divide by nth factor of 10 */
+
+            Temp32 = 0;
+            Digit = Operand[0]->Integer.Value;
+            for (j = 0; j < i; j++)
+            {
+                AcpiUtShortDivide (&Digit, 10, &Digit, &Temp32);
+            }
+
+            /* Create the BCD digit from the remainder above */
+
+            if (Digit > 0)
+            {
+                ReturnDesc->Integer.Value += (Temp32 << (i * 4));
+            }
+        }
+        break;
+
+
+    case AML_COND_REF_OF_OP:        /* CondRefOf (SourceObject, Result)  */
+
+        /*
+         * This op is a little strange because the internal return value is
+         * different than the return value stored in the result descriptor
+         * (There are really two return values)
+         */
+        if ((ACPI_NAMESPACE_NODE *) Operand[0] == AcpiGbl_RootNode)
+        {
+            /*
+             * This means that the object does not exist in the namespace,
+             * return FALSE
+             */
+            ReturnDesc->Integer.Value = 0;
+
+            /*
+             * Must delete the result descriptor since there is no reference
+             * being returned
+             */
+            AcpiUtRemoveReference (Operand[1]);
+            goto Cleanup;
+        }
+
+        /* Get the object reference and store it */
+
+        Status = AcpiExGetObjectReference (Operand[0], &ReturnDesc2, WalkState);
+        if (ACPI_FAILURE (Status))
+        {
+            goto Cleanup;
+        }
+
+        Status = AcpiExStore (ReturnDesc2, Operand[1], WalkState);
+
+        /* The object exists in the namespace, return TRUE */
+
+        ReturnDesc->Integer.Value = ACPI_INTEGER_MAX;
+        goto Cleanup;
+        break;
+
+
+    case AML_STORE_OP:              /* Store (Source, Target) */
+
+        /*
+         * A store operand is typically a number, string, buffer or lvalue
+         * Be careful about deleting the source object,
+         * since the object itself may have been stored.
+         */
+        Status = AcpiExStore (Operand[0], Operand[1], WalkState);
+        if (ACPI_FAILURE (Status))
+        {
+            return_ACPI_STATUS (Status);
+        }
+
+        /*
+         * Normally, we would remove a reference on the Operand[0] parameter;
+         * But since it is being used as the internal return object
+         * (meaning we would normally increment it), the two cancel out,
+         * and we simply don't do anything.
+         */
+        WalkState->ResultObj = Operand[0];
+        WalkState->Operands[0] = NULL;  /* Prevent deletion */
+        return_ACPI_STATUS (Status);
+        break;
+
+
+    /*
+     * ACPI 2.0 Opcodes
+     */
+    case AML_COPY_OP:               /* Copy (Source, Target) */
+
+        Status = AE_NOT_IMPLEMENTED;
+        goto Cleanup;
+        break;
+
+
+    case AML_TO_DECSTRING_OP:       /* ToDecimalString (Data, Result) */
+
+        Status = AcpiExConvertToString (Operand[0], &ReturnDesc, 10, ACPI_UINT32_MAX, WalkState);
+        break;
+
+
+    case AML_TO_HEXSTRING_OP:       /* ToHexString (Data, Result) */
+
+        Status = AcpiExConvertToString (Operand[0], &ReturnDesc, 16, ACPI_UINT32_MAX, WalkState);
+        break;
+
+
+    case AML_TO_BUFFER_OP:          /* ToBuffer (Data, Result) */
+
+        Status = AcpiExConvertToBuffer (Operand[0], &ReturnDesc, WalkState);
+        break;
+
+
+    case AML_TO_INTEGER_OP:         /* ToInteger (Data, Result) */
+
+        Status = AcpiExConvertToInteger (Operand[0], &ReturnDesc, WalkState);
+        break;
+
+
+    /*
+     * These are two obsolete opcodes
+     */
+    case AML_SHIFT_LEFT_BIT_OP:     /*  ShiftLeftBit (Source, BitNum)  */
+    case AML_SHIFT_RIGHT_BIT_OP:    /*  ShiftRightBit (Source, BitNum) */
+
+
+        ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%s is obsolete and not implemented\n",
+                        AcpiPsGetOpcodeName (WalkState->Opcode)));
+        Status = AE_SUPPORT;
+        goto Cleanup;
+        break;
+
+
+    default:                        /* Unknown opcode */
+
+        REPORT_ERROR (("AcpiExOpcode_1A_1T_1R: Unknown opcode %X\n",
+            WalkState->Opcode));
+        Status = AE_AML_BAD_OPCODE;
+        goto Cleanup;
+    }
+
+
+    /*
+     * Store the return value computed above into the target object 
+     */
+    Status = AcpiExStore (ReturnDesc, Operand[1], WalkState);
+
+
+Cleanup:
+
+    WalkState->ResultObj = ReturnDesc;
+
+    /* Delete return object on error */
+
+    if (ACPI_FAILURE (Status))
+    {
+        AcpiUtRemoveReference (ReturnDesc);
+    }
+
+    return_ACPI_STATUS (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExOpcode_1A_0T_1R
+ *
+ * PARAMETERS:  WalkState           - Current state (contains AML opcode)
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute opcode with one argument, no target, and a return value
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExOpcode_1A_0T_1R (
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
+    ACPI_OPERAND_OBJECT     *TempDesc;
+    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
+    ACPI_STATUS             Status = AE_OK;
+    UINT32                  Type;
+    ACPI_INTEGER            Value;
+
+
+    FUNCTION_TRACE_STR ("ExOpcode_1A_0T_0R", AcpiPsGetOpcodeName (WalkState->Opcode));
+
+
+
+    /* Get the operand and decode the opcode */
+
+    switch (WalkState->Opcode)
+    {
+
+    case AML_LNOT_OP:               /* LNot (Operand) */
+
+        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
+        if (!ReturnDesc)
+        {
+            Status = AE_NO_MEMORY;
+            goto Cleanup;
+        }
+
+        ReturnDesc->Integer.Value = !Operand[0]->Integer.Value;
+        break;
+
+
+    case AML_DECREMENT_OP:          /* Decrement (Operand)  */
+    case AML_INCREMENT_OP:          /* Increment (Operand)  */
+
+        /*
+         * Since we are expecting a Reference operand, it
+         * can be either a Node or an internal object.
+         */
+        ReturnDesc = Operand[0];
+        if (VALID_DESCRIPTOR_TYPE (Operand[0], ACPI_DESC_TYPE_INTERNAL))
+        {
+            /* Internal reference object - prevent deletion */
+
+            AcpiUtAddReference (ReturnDesc);
+        }
+
+        /*
+         * Convert the ReturnDesc Reference to a Number
+         * (This removes a reference on the ReturnDesc object)
+         */
+        Status = AcpiExResolveOperands (AML_LNOT_OP, &ReturnDesc, WalkState);
+        if (ACPI_FAILURE (Status))
+        {
+            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%s: bad operand(s) %s\n",
+                AcpiPsGetOpcodeName (WalkState->Opcode), AcpiFormatException(Status)));
+
+            goto Cleanup;
+        }
+
+        /* 
+         * ReturnDesc is now guaranteed to be an Integer object
+         * Do the actual increment or decrement 
+         */
+        if (AML_INCREMENT_OP == WalkState->Opcode)
+        {
+            ReturnDesc->Integer.Value++;
+        }
+        else
+        {
+            ReturnDesc->Integer.Value--;
+        }
+
+        /* Store the result back in the original descriptor */
+
+        Status = AcpiExStore (ReturnDesc, Operand[0], WalkState);
+        break;
+
+
+    case AML_TYPE_OP:               /* ObjectType (SourceObject) */
+
+        if (INTERNAL_TYPE_REFERENCE == Operand[0]->Common.Type)
+        {
+            /*
+             * Not a Name -- an indirect name pointer would have
+             * been converted to a direct name pointer in ResolveOperands
+             */
+            switch (Operand[0]->Reference.Opcode)
+            {
+            case AML_ZERO_OP:
+            case AML_ONE_OP:
+            case AML_ONES_OP:
+            case AML_REVISION_OP:
+
+                /* Constants are of type Integer */
+
+                Type = ACPI_TYPE_INTEGER;
+                break;
+
+
+            case AML_DEBUG_OP:
+
+                /* Per 1.0b spec, Debug object is of type "DebugObject" */
+
+                Type = ACPI_TYPE_DEBUG_OBJECT;
+                break;
+
+
+            case AML_INDEX_OP:
+
+                /* Get the type of this reference (index into another object) */
+
+                Type = Operand[0]->Reference.TargetType;
+                if (Type == ACPI_TYPE_PACKAGE)
+                {
+                    /*
+                     * The main object is a package, we want to get the type
+                     * of the individual package element that is referenced by
+                     * the index.
+                     */
+                    Type = (*(Operand[0]->Reference.Where))->Common.Type;
+                }
+
+                break;
+
+
+            case AML_LOCAL_OP:
+            case AML_ARG_OP:
+
+                Type = AcpiDsMethodDataGetType (Operand[0]->Reference.Opcode,
+                                Operand[0]->Reference.Offset, WalkState);
+                break;
+
+
+            default:
+
+                REPORT_ERROR (("AcpiExOpcode_1A_0T_1R/TypeOp: Internal error - Unknown Reference subtype %X\n",
+                    Operand[0]->Reference.Opcode));
+                Status = AE_AML_INTERNAL;
+                goto Cleanup;
+            }
+        }
+
+        else
+        {
+            /*
+             * It's not a Reference, so it must be a direct name pointer.
+             */
+            Type = AcpiNsGetType ((ACPI_NAMESPACE_NODE *) Operand[0]);
+
+            /* Convert internal types to external types */
+
+            switch (Type)
+            {
+            case INTERNAL_TYPE_REGION_FIELD:
+            case INTERNAL_TYPE_BANK_FIELD:
+            case INTERNAL_TYPE_INDEX_FIELD:
+
+                Type = ACPI_TYPE_FIELD_UNIT;
+            }
+
+        }
+
+        /* Allocate a descriptor to hold the type. */
+
+        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
+        if (!ReturnDesc)
+        {
+            Status = AE_NO_MEMORY;
+            goto Cleanup;
+        }
+
+        ReturnDesc->Integer.Value = Type;
+        break;
+
+
+    case AML_SIZE_OF_OP:            /* SizeOf (SourceObject)  */
+
+        TempDesc = Operand[0];
+        if (VALID_DESCRIPTOR_TYPE (Operand[0], ACPI_DESC_TYPE_NAMED))
+        {
+            TempDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) Operand[0]);
+        }
+
+        if (!TempDesc)
+        {
+            Value = 0;
+        }
+
+        else
+        {
+            switch (TempDesc->Common.Type)
+            {
+            case ACPI_TYPE_BUFFER:
+                Value = TempDesc->Buffer.Length;
+                break;
+
+            case ACPI_TYPE_STRING:
+                Value = TempDesc->String.Length;
+                break;
+
+            case ACPI_TYPE_PACKAGE:
+                Value = TempDesc->Package.Count;
+                break;
+
+            case INTERNAL_TYPE_REFERENCE:
+
+                /* TBD: this must be a reference to a buf/str/pkg?? */
+
+                Value = 4;
+                break;
+
+            default:
+                ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Not Buf/Str/Pkg - found type %X\n",
+                    TempDesc->Common.Type));
+                Status = AE_AML_OPERAND_TYPE;
+                goto Cleanup;
+            }
+        }
+
+        /*
+         * Now that we have the size of the object, create a result
+         * object to hold the value
+         */
+        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
+        if (!ReturnDesc)
+        {
+            Status = AE_NO_MEMORY;
+            goto Cleanup;
+        }
+
+        ReturnDesc->Integer.Value = Value;
+        break;
+
+
+    case AML_REF_OF_OP:             /* RefOf (SourceObject) */
+
+        Status = AcpiExGetObjectReference (Operand[0], &ReturnDesc, WalkState);
+        if (ACPI_FAILURE (Status))
+        {
+            goto Cleanup;
+        }
+        break;
+
+
+    case AML_DEREF_OF_OP:           /* DerefOf (ObjReference) */
+
+        /* Check for a method local or argument */
+
+        if (!VALID_DESCRIPTOR_TYPE (Operand[0], ACPI_DESC_TYPE_NAMED))
+        {
+            /*
+             * Must resolve/dereference the local/arg reference first
+             */
+            switch (Operand[0]->Reference.Opcode)
+            {
+            /* Set Operand[0] to the value of the local/arg */
+
+            case AML_LOCAL_OP:
+            case AML_ARG_OP:
+
+                AcpiDsMethodDataGetValue (Operand[0]->Reference.Opcode,
+                        Operand[0]->Reference.Offset, WalkState, &TempDesc);
+
+                /*
+                 * Delete our reference to the input object and
+                 * point to the object just retrieved
+                 */
+                AcpiUtRemoveReference (Operand[0]);
+                Operand[0] = TempDesc;
+                break;
+
+            default:
+
+                /* Index op - handled below */
+                break;
+            }
+        }
+
+
+        /* Operand[0] may have changed from the code above */
+
+        if (VALID_DESCRIPTOR_TYPE (Operand[0], ACPI_DESC_TYPE_NAMED))
+        {
+            /* Get the actual object from the Node (This is the dereference) */
+
+            ReturnDesc = ((ACPI_NAMESPACE_NODE *) Operand[0])->Object;
+
+            /* Returning a pointer to the object, add another reference! */
+
+            AcpiUtAddReference (ReturnDesc);
+        }
+
+        else
+        {
+            /*
+             * This must be a reference object produced by the Index
+             * ASL operation -- check internal opcode
+             */
+            if ((Operand[0]->Reference.Opcode != AML_INDEX_OP) &&
+                (Operand[0]->Reference.Opcode != AML_REF_OF_OP))
+            {
+                ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown opcode in ref(%p) - %X\n",
+                    Operand[0], Operand[0]->Reference.Opcode));
+
+                Status = AE_TYPE;
+                goto Cleanup;
+            }
+
+
+            switch (Operand[0]->Reference.Opcode)
+            {
+            case AML_INDEX_OP:
+
+                /*
+                 * Supported target types for the Index operator are
+                 * 1) A Buffer
+                 * 2) A Package
+                 */
+                if (Operand[0]->Reference.TargetType == ACPI_TYPE_BUFFER_FIELD)
+                {
+                    /*
+                     * The target is a buffer, we must create a new object that
+                     * contains one element of the buffer, the element pointed
+                     * to by the index.
+                     *
+                     * NOTE: index into a buffer is NOT a pointer to a
+                     * sub-buffer of the main buffer, it is only a pointer to a
+                     * single element (byte) of the buffer!
+                     */
+                    ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
+                    if (!ReturnDesc)
+                    {
+                        Status = AE_NO_MEMORY;
+                        goto Cleanup;
+                    }
+
+                    TempDesc = Operand[0]->Reference.Object;
+                    ReturnDesc->Integer.Value =
+                        TempDesc->Buffer.Pointer[Operand[0]->Reference.Offset];
+
+                    /* TBD: [Investigate] (see below) Don't add an additional
+                     * ref!
+                     */
+                }
+
+                else if (Operand[0]->Reference.TargetType == ACPI_TYPE_PACKAGE)
+                {
+                    /*
+                     * The target is a package, we want to return the referenced
+                     * element of the package.  We must add another reference to
+                     * this object, however.
+                     */
+                    ReturnDesc = *(Operand[0]->Reference.Where);
+                    if (!ReturnDesc)
+                    {
+                        /*
+                         * We can't return a NULL dereferenced value.  This is
+                         * an uninitialized package element and is thus a
+                         * severe error.
+                         */
+
+                        ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "NULL package element obj %p\n",
+                            Operand[0]));
+                        Status = AE_AML_UNINITIALIZED_ELEMENT;
+                        goto Cleanup;
+                    }
+
+                    AcpiUtAddReference (ReturnDesc);
+                }
+
+                else
+                {
+                    ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown TargetType %X in obj %p\n",
+                        Operand[0]->Reference.TargetType, Operand[0]));
+                    Status = AE_AML_OPERAND_TYPE;
+                    goto Cleanup;
+                }
+
+                break;
+
+
+            case AML_REF_OF_OP:
+
+                ReturnDesc = Operand[0]->Reference.Object;
+
+                /* Add another reference to the object! */
+
+                AcpiUtAddReference (ReturnDesc);
+                break;
+            }
+        }
+
+        break;
+
+
+    default:
+
+        REPORT_ERROR (("AcpiExOpcode_1A_0T_1R: Unknown opcode %X\n",
+            WalkState->Opcode));
+        Status = AE_AML_BAD_OPCODE;
+        goto Cleanup;
+    }
+
+
+Cleanup:
+
+    /* Delete return object on error */
+
+    if (ACPI_FAILURE (Status))
+    {
+        AcpiUtRemoveReference (ReturnDesc);
+    }
+
+    WalkState->ResultObj = ReturnDesc;
+    return_ACPI_STATUS (Status);
+}
+
diff --git a/sys/contrib/dev/acpica/exoparg2.c b/sys/contrib/dev/acpica/exoparg2.c
new file mode 100644
index 000000000000..32c79683cce6
--- /dev/null
+++ b/sys/contrib/dev/acpica/exoparg2.c
@@ -0,0 +1,691 @@
+/******************************************************************************
+ *
+ * Module Name: exoparg2 - AML execution - opcodes with 2 arguments
+ *              $Revision: 97 $
+ *
+ *****************************************************************************/
+
+/******************************************************************************
+ *
+ * 1. Copyright Notice
+ *
+ * Some or all of this work - Copyright (c) 1999, 2000, 2001, 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.
+ *
+ *****************************************************************************/
+
+
+#define __EXOPARG2_C__
+
+#include "acpi.h"
+#include "acparser.h"
+#include "acnamesp.h"
+#include "acinterp.h"
+#include "acevents.h"
+#include "amlcode.h"
+#include "acdispat.h"
+
+
+#define _COMPONENT          ACPI_EXECUTER
+        MODULE_NAME         ("exoparg2")
+
+
+/*!
+ * Naming convention for AML interpreter execution routines.
+ *
+ * The routines that begin execution of AML opcodes are named with a common
+ * convention based upon the number of arguments, the number of target operands,
+ * and whether or not a value is returned:
+ *
+ *      AcpiExOpcode_xA_yT_zR
+ *
+ * Where:  
+ *
+ * xA - ARGUMENTS:    The number of arguments (input operands) that are 
+ *                    required for this opcode type (1 through 6 args).
+ * yT - TARGETS:      The number of targets (output operands) that are required 
+ *                    for this opcode type (0, 1, or 2 targets).
+ * zR - RETURN VALUE: Indicates whether this opcode type returns a value 
+ *                    as the function return (0 or 1).
+ *
+ * The AcpiExOpcode* functions are called via the Dispatcher component with 
+ * fully resolved operands.
+!*/
+
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExOpcode_2A_0T_0R
+ *
+ * PARAMETERS:  WalkState           - Current walk state
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute opcode with two arguments, no target, and no return
+ *              value.
+ *
+ * ALLOCATION:  Deletes both operands
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExOpcode_2A_0T_0R (
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
+    ACPI_NAMESPACE_NODE     *Node;
+    ACPI_STATUS             Status = AE_OK;
+
+
+    FUNCTION_TRACE_STR ("ExOpcode_2A_0T_0R", AcpiPsGetOpcodeName (WalkState->Opcode));
+
+
+    /* Examine the opcode */
+
+    switch (WalkState->Opcode)
+    {
+
+    case AML_NOTIFY_OP:         /* Notify (NotifyObject, NotifyValue) */
+
+        /* The first operand is a namespace node */
+
+        Node = (ACPI_NAMESPACE_NODE *) Operand[0];
+
+        /* The node must refer to a device or thermal zone */
+
+        if (Node && Operand[1])     /* TBD: is this check necessary? */
+        {
+            switch (Node->Type)
+            {
+            case ACPI_TYPE_DEVICE:
+            case ACPI_TYPE_THERMAL:
+
+                /*
+                 * Dispatch the notify to the appropriate handler
+                 * NOTE: the request is queued for execution after this method
+                 * completes.  The notify handlers are NOT invoked synchronously
+                 * from this thread -- because handlers may in turn run other
+                 * control methods.
+                 */
+                Status = AcpiEvQueueNotifyRequest (Node,
+                                        (UINT32) Operand[1]->Integer.Value);
+                break;
+
+            default:
+                ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unexpected notify object type %X\n",
+                    Node->Type));
+
+                Status = AE_AML_OPERAND_TYPE;
+                break;
+            }
+        }
+        break;
+
+    default:
+
+        REPORT_ERROR (("AcpiExOpcode_2A_0T_0R: Unknown opcode %X\n", WalkState->Opcode));
+        Status = AE_AML_BAD_OPCODE;
+    }
+
+    return_ACPI_STATUS (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExOpcode_2A_2T_1R
+ *
+ * PARAMETERS:  WalkState           - Current walk state
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute a dyadic operator (2 operands) with 2 output targets
+ *              and one implicit return value.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExOpcode_2A_2T_1R (
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
+    ACPI_OPERAND_OBJECT     *ReturnDesc1 = NULL;
+    ACPI_OPERAND_OBJECT     *ReturnDesc2 = NULL;
+    ACPI_STATUS             Status;
+
+
+    FUNCTION_TRACE_STR ("ExOpcode_2A_2T_1R", AcpiPsGetOpcodeName (WalkState->Opcode));
+
+
+    /*
+     * Execute the opcode
+     */
+    switch (WalkState->Opcode)
+    {
+    case AML_DIVIDE_OP:             /* Divide (Dividend, Divisor, RemainderResult QuotientResult) */
+
+        ReturnDesc1 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
+        if (!ReturnDesc1)
+        {
+            Status = AE_NO_MEMORY;
+            goto Cleanup;
+        }
+
+        ReturnDesc2 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
+        if (!ReturnDesc2)
+        {
+            Status = AE_NO_MEMORY;
+            goto Cleanup;
+        }
+
+        /* Quotient to ReturnDesc1, remainder to ReturnDesc2 */
+
+        Status = AcpiUtDivide (&Operand[0]->Integer.Value, &Operand[1]->Integer.Value,
+                               &ReturnDesc1->Integer.Value, &ReturnDesc2->Integer.Value);
+        if (ACPI_FAILURE (Status))
+        {
+            goto Cleanup;
+        }
+        break;
+
+
+    default:
+
+        REPORT_ERROR (("AcpiExOpcode_2A_2T_1R: Unknown opcode %X\n",
+                WalkState->Opcode));
+        Status = AE_AML_BAD_OPCODE;
+        goto Cleanup;
+        break;
+    }
+
+
+    /* Store the results to the target reference operands */
+
+    Status = AcpiExStore (ReturnDesc2, Operand[2], WalkState);
+    if (ACPI_FAILURE (Status))
+    {
+        goto Cleanup;
+    }
+
+    Status = AcpiExStore (ReturnDesc1, Operand[3], WalkState);
+    if (ACPI_FAILURE (Status))
+    {
+        goto Cleanup;
+    }
+
+    /* Return the remainder */
+
+    WalkState->ResultObj = ReturnDesc1;
+
+
+Cleanup:
+    /*
+     * Since the remainder is not returned indirectly, remove a reference to
+     * it. Only the quotient is returned indirectly.
+     */
+    AcpiUtRemoveReference (ReturnDesc2);
+
+    if (ACPI_FAILURE (Status))
+    {
+        /* Delete the return object */
+
+        AcpiUtRemoveReference (ReturnDesc1);
+    }
+
+    return_ACPI_STATUS (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExOpcode_2A_1T_1R
+ *
+ * PARAMETERS:  WalkState           - Current walk state
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute opcode with two arguments, one target, and a return
+ *              value.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExOpcode_2A_1T_1R (
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_OPERAND_OBJECT     **Operand   = &WalkState->Operands[0];
+    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
+    ACPI_OPERAND_OBJECT     *TempDesc;
+    UINT32                  Index;
+    ACPI_STATUS             Status      = AE_OK;
+
+
+    FUNCTION_TRACE_STR ("ExOpcode_2A_1T_1R", AcpiPsGetOpcodeName (WalkState->Opcode));
+
+
+    /*
+     * Execute the opcode
+     */
+    if (WalkState->OpInfo->Flags & AML_MATH)
+    {
+        /* All simple math opcodes (add, etc.) */
+
+        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
+        if (!ReturnDesc)
+        {
+            Status = AE_NO_MEMORY;
+            goto Cleanup;
+        }
+
+        ReturnDesc->Integer.Value = AcpiExDoMathOp (WalkState->Opcode, 
+                                                Operand[0]->Integer.Value, 
+                                                Operand[1]->Integer.Value);
+        goto StoreResultToTarget;
+    }
+
+
+    switch (WalkState->Opcode)
+    {
+    case AML_MOD_OP:                /* Mod (Dividend, Divisor, RemainderResult (ACPI 2.0) */
+
+        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
+        if (!ReturnDesc)
+        {
+            Status = AE_NO_MEMORY;
+            goto Cleanup;
+        }
+
+        /* ReturnDesc will contain the remainder */
+
+        Status = AcpiUtDivide (&Operand[0]->Integer.Value, &Operand[1]->Integer.Value,
+                        NULL, &ReturnDesc->Integer.Value);
+
+        break;
+
+
+    case AML_CONCAT_OP:             /* Concatenate (Data1, Data2, Result) */
+
+        /*
+         * Convert the second operand if necessary.  The first operand
+         * determines the type of the second operand, (See the Data Types
+         * section of the ACPI specification.)  Both object types are
+         * guaranteed to be either Integer/String/Buffer by the operand
+         * resolution mechanism above.
+         */
+        switch (Operand[0]->Common.Type)
+        {
+        case ACPI_TYPE_INTEGER:
+            Status = AcpiExConvertToInteger (Operand[1], &Operand[1], WalkState);
+            break;
+
+        case ACPI_TYPE_STRING:
+            Status = AcpiExConvertToString (Operand[1], &Operand[1], 16, ACPI_UINT32_MAX, WalkState);
+            break;
+
+        case ACPI_TYPE_BUFFER:
+            Status = AcpiExConvertToBuffer (Operand[1], &Operand[1], WalkState);
+            break;
+
+        default:
+            Status = AE_AML_INTERNAL;
+        }
+
+        if (ACPI_FAILURE (Status))
+        {
+            goto Cleanup;
+        }
+
+        /*
+         * Both operands are now known to be the same object type
+         * (Both are Integer, String, or Buffer), and we can now perform the
+         * concatenation.
+         */
+        Status = AcpiExDoConcatenate (Operand[0], Operand[1], &ReturnDesc, WalkState);
+        break;
+
+
+    case AML_TO_STRING_OP:          /* ToString (Buffer, Length, Result) (ACPI 2.0) */
+
+        Status = AcpiExConvertToString (Operand[0], &ReturnDesc, 16,
+                        (UINT32) Operand[1]->Integer.Value, WalkState);
+        break;
+
+
+    case AML_CONCAT_RES_OP:         /* ConcatenateResTemplate (Buffer, Buffer, Result) (ACPI 2.0) */
+
+        Status = AE_NOT_IMPLEMENTED;
+        break;
+
+
+    case AML_INDEX_OP:              /* Index (Source Index Result) */
+
+        /* Create the internal return object */
+
+        ReturnDesc = AcpiUtCreateInternalObject (INTERNAL_TYPE_REFERENCE);
+        if (!ReturnDesc)
+        {
+            Status = AE_NO_MEMORY;
+            goto Cleanup;
+        }
+
+        Index = (UINT32) Operand[1]->Integer.Value;
+
+        /*
+         * At this point, the Source operand is either a Package or a Buffer
+         */
+        if (Operand[0]->Common.Type == ACPI_TYPE_PACKAGE)
+        {
+            /* Object to be indexed is a Package */
+
+            if (Index >= Operand[0]->Package.Count)
+            {
+                ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Index value beyond package end\n"));
+                Status = AE_AML_PACKAGE_LIMIT;
+                goto Cleanup;
+            }
+
+            if ((Operand[2]->Common.Type == INTERNAL_TYPE_REFERENCE) &&
+                (Operand[2]->Reference.Opcode == AML_ZERO_OP))
+            {
+                /*
+                 * There is no actual result descriptor (the ZeroOp Result
+                 * descriptor is a placeholder), so just delete the placeholder and
+                 * return a reference to the package element
+                 */
+                AcpiUtRemoveReference (Operand[2]);
+            }
+
+            else
+            {
+                /*
+                 * Each element of the package is an internal object.  Get the one
+                 * we are after.
+                 */
+                TempDesc                         = Operand[0]->Package.Elements [Index];
+                ReturnDesc->Reference.Opcode     = AML_INDEX_OP;
+                ReturnDesc->Reference.TargetType = TempDesc->Common.Type;
+                ReturnDesc->Reference.Object     = TempDesc;
+
+                Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
+                ReturnDesc->Reference.Object     = NULL;
+            }
+
+            /*
+             * The local return object must always be a reference to the package element,
+             * not the element itself.
+             */
+            ReturnDesc->Reference.Opcode     = AML_INDEX_OP;
+            ReturnDesc->Reference.TargetType = ACPI_TYPE_PACKAGE;
+            ReturnDesc->Reference.Where      = &Operand[0]->Package.Elements [Index];
+        }
+
+        else
+        {
+            /* Object to be indexed is a Buffer */
+
+            if (Index >= Operand[0]->Buffer.Length)
+            {
+                ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Index value beyond end of buffer\n"));
+                Status = AE_AML_BUFFER_LIMIT;
+                goto Cleanup;
+            }
+
+            ReturnDesc->Reference.Opcode       = AML_INDEX_OP;
+            ReturnDesc->Reference.TargetType   = ACPI_TYPE_BUFFER_FIELD;
+            ReturnDesc->Reference.Object       = Operand[0];
+            ReturnDesc->Reference.Offset       = Index;
+
+            Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
+        }
+
+        WalkState->ResultObj = ReturnDesc;
+        goto Cleanup;
+        break;
+
+
+    default:
+
+        REPORT_ERROR (("AcpiExOpcode_2A_1T_1R: Unknown opcode %X\n",
+                WalkState->Opcode));
+        Status = AE_AML_BAD_OPCODE;
+        break;
+    }
+
+
+StoreResultToTarget:
+
+    if (ACPI_SUCCESS (Status))
+    {
+        /*
+         * Store the result of the operation (which is now in ReturnDesc) into
+         * the Target descriptor.
+         */
+        Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
+        if (ACPI_FAILURE (Status))
+        {
+            goto Cleanup;
+        }
+
+        WalkState->ResultObj = ReturnDesc;
+    }
+
+
+Cleanup:
+
+    /* Delete return object on error */
+
+    if (ACPI_FAILURE (Status))
+    {
+        AcpiUtRemoveReference (ReturnDesc);
+    }
+
+    return_ACPI_STATUS (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExOpcode_2A_0T_1R
+ *
+ * PARAMETERS:  WalkState           - Current walk state
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute opcode with 2 arguments, no target, and a return value
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExOpcode_2A_0T_1R (
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
+    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
+    ACPI_STATUS             Status = AE_OK;
+    BOOLEAN                 LogicalResult = FALSE;
+
+
+    FUNCTION_TRACE_STR ("ExOpcode_2A_0T_1R", AcpiPsGetOpcodeName (WalkState->Opcode));
+
+
+    /* Create the internal return object */
+
+    ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
+    if (!ReturnDesc)
+    {
+        Status = AE_NO_MEMORY;
+        goto Cleanup;
+    }
+
+    /*
+     * Execute the Opcode
+     */
+    if (WalkState->OpInfo->Flags & AML_LOGICAL) /* LogicalOp  (Operand0, Operand1) */
+    {
+        LogicalResult = AcpiExDoLogicalOp (WalkState->Opcode, 
+                                            Operand[0]->Integer.Value,
+                                            Operand[1]->Integer.Value);
+        goto StoreLogicalResult;
+    }
+
+
+    switch (WalkState->Opcode)
+    {
+    case AML_ACQUIRE_OP:            /* Acquire (MutexObject, Timeout) */
+
+        Status = AcpiExAcquireMutex (Operand[1], Operand[0], WalkState);
+        if (Status == AE_TIME)
+        {
+            LogicalResult = TRUE;       /* TRUE = Acquire timed out */
+            Status = AE_OK;
+        }
+        break;
+
+
+    case AML_WAIT_OP:               /* Wait (EventObject, Timeout) */
+
+        Status = AcpiExSystemWaitEvent (Operand[1], Operand[0]);
+        if (Status == AE_TIME)
+        {
+            LogicalResult = TRUE;       /* TRUE, Wait timed out */
+            Status = AE_OK;
+        }
+        break;
+
+
+    default:
+
+        REPORT_ERROR (("AcpiExOpcode_2A_0T_1R: Unknown opcode %X\n", WalkState->Opcode));
+        Status = AE_AML_BAD_OPCODE;
+        goto Cleanup;
+        break;
+    }
+
+
+StoreLogicalResult:
+    /* 
+     * Set return value to according to LogicalResult. logical TRUE (all ones)
+     * Default is FALSE (zero) 
+     */
+    if (LogicalResult)
+    {
+        ReturnDesc->Integer.Value = ACPI_INTEGER_MAX;
+    }
+
+    WalkState->ResultObj = ReturnDesc;
+
+
+Cleanup:
+
+    /* Delete return object on error */
+
+    if (ACPI_FAILURE (Status))
+    {
+        AcpiUtRemoveReference (ReturnDesc);
+    }
+
+    return_ACPI_STATUS (Status);
+}
+
+
diff --git a/sys/contrib/dev/acpica/exoparg3.c b/sys/contrib/dev/acpica/exoparg3.c
new file mode 100644
index 000000000000..43c5db4d9b37
--- /dev/null
+++ b/sys/contrib/dev/acpica/exoparg3.c
@@ -0,0 +1,341 @@
+
+/******************************************************************************
+ *
+ * Module Name: exoparg3 - AML execution - opcodes with 3 arguments
+ *              $Revision: 3 $
+ *
+ *****************************************************************************/
+
+/******************************************************************************
+ *
+ * 1. Copyright Notice
+ *
+ * Some or all of this work - Copyright (c) 1999, 2000, 2001, 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.
+ *
+ *****************************************************************************/
+
+#define __EXOPARG3_C__
+
+#include "acpi.h"
+#include "acinterp.h"
+#include "acparser.h"
+#include "amlcode.h"
+
+
+#define _COMPONENT          ACPI_EXECUTER
+        MODULE_NAME         ("exoparg3")
+
+
+/*!
+ * Naming convention for AML interpreter execution routines.
+ *
+ * The routines that begin execution of AML opcodes are named with a common
+ * convention based upon the number of arguments, the number of target operands,
+ * and whether or not a value is returned:
+ *
+ *      AcpiExOpcode_xA_yT_zR
+ *
+ * Where:  
+ *
+ * xA - ARGUMENTS:    The number of arguments (input operands) that are 
+ *                    required for this opcode type (1 through 6 args).
+ * yT - TARGETS:      The number of targets (output operands) that are required 
+ *                    for this opcode type (0, 1, or 2 targets).
+ * zR - RETURN VALUE: Indicates whether this opcode type returns a value 
+ *                    as the function return (0 or 1).
+ *
+ * The AcpiExOpcode* functions are called via the Dispatcher component with 
+ * fully resolved operands.
+!*/
+
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExOpcode_3A_0T_0R
+ *
+ * PARAMETERS:  WalkState           - Current walk state
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute Triadic operator (3 operands)
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExOpcode_3A_0T_0R (
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
+    ACPI_SIGNAL_FATAL_INFO  *Fatal;
+    ACPI_STATUS             Status = AE_OK;
+
+
+    FUNCTION_TRACE_STR ("ExOpcode_3A_0T_0R", AcpiPsGetOpcodeName (WalkState->Opcode));
+
+
+    switch (WalkState->Opcode)
+    {
+
+    case AML_FATAL_OP:          /* Fatal (FatalType  FatalCode  FatalArg)    */
+
+        ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
+            "FatalOp: Type %x Code %x Arg %x <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n",
+            (UINT32) Operand[0]->Integer.Value, (UINT32) Operand[1]->Integer.Value,
+            (UINT32) Operand[2]->Integer.Value));
+
+
+        Fatal = ACPI_MEM_ALLOCATE (sizeof (ACPI_SIGNAL_FATAL_INFO));
+        if (Fatal)
+        {
+            Fatal->Type     = (UINT32) Operand[0]->Integer.Value;
+            Fatal->Code     = (UINT32) Operand[1]->Integer.Value;
+            Fatal->Argument = (UINT32) Operand[2]->Integer.Value;
+        }
+
+        /*
+         * Always signal the OS!
+         */
+        AcpiOsSignal (ACPI_SIGNAL_FATAL, Fatal);
+
+        /* Might return while OS is shutting down, just continue */
+
+        ACPI_MEM_FREE (Fatal);
+        break;
+
+
+    default:
+
+        REPORT_ERROR (("AcpiExOpcode_3A_0T_0R: Unknown opcode %X\n",
+                WalkState->Opcode));
+        Status = AE_AML_BAD_OPCODE;
+        goto Cleanup;
+        break;
+    }
+
+
+
+Cleanup:
+
+    return_ACPI_STATUS (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExOpcode_3A_1T_1R
+ *
+ * PARAMETERS:  WalkState           - Current walk state
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute Triadic operator (3 operands)
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExOpcode_3A_1T_1R (
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
+    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
+    char                    *Buffer;
+    ACPI_STATUS             Status = AE_OK;
+    UINT32                  Index;
+    UINT32                  Length;
+
+
+    FUNCTION_TRACE_STR ("ExOpcode_3A_1T_1R", AcpiPsGetOpcodeName (WalkState->Opcode));
+
+
+
+    switch (WalkState->Opcode)
+    {
+    case AML_MID_OP:        /* Mid  (Source[0], Index[1], Length[2], Result[3]) */
+
+        /* 
+         * Create the return object.  The Source operand is guaranteed to be
+         * either a String or a Buffer, so just use its type.
+         */
+        ReturnDesc = AcpiUtCreateInternalObject (Operand[0]->Common.Type);
+        if (!ReturnDesc)
+        {
+            Status = AE_NO_MEMORY;
+            goto Cleanup;
+        }
+
+        /* Get the Integer values from the objects */
+
+        Index = (UINT32) Operand[1]->Integer.Value;
+        Length = (UINT32) Operand[2]->Integer.Value;
+
+        /*
+         * If the index is beyond the length of the String/Buffer, or if the
+         * requested length is zero, return a zero-length String/Buffer
+         */
+        if ((Index < Operand[0]->String.Length) &&
+            (Length > 0))
+        {
+            /* Truncate request if larger than the actual String/Buffer */
+
+            if ((Index + Length) >
+                Operand[0]->String.Length)
+            {
+                Length = Operand[0]->String.Length - Index;
+            }
+
+            /* Allocate a new buffer for the String/Buffer */
+
+            Buffer = ACPI_MEM_CALLOCATE (Length + 1);
+            if (!Buffer)
+            {
+                return (AE_NO_MEMORY);
+            }
+
+            /* Copy the portion requested */
+
+            MEMCPY (Buffer, Operand[0]->String.Pointer + Index,
+                    Length);
+
+            /* Set the length of the new String/Buffer */
+
+            ReturnDesc->String.Pointer = Buffer;
+            ReturnDesc->String.Length = Length;
+        }
+      
+        break;
+
+
+    default:
+
+        REPORT_ERROR (("AcpiExOpcode_3A_0T_0R: Unknown opcode %X\n",
+                WalkState->Opcode));
+        Status = AE_AML_BAD_OPCODE;
+        goto Cleanup;
+        break;
+    }
+
+    /* Store the result in the target */
+
+    Status = AcpiExStore (ReturnDesc, Operand[3], WalkState);
+
+Cleanup:
+
+    /* Delete return object on error */
+
+    if (ACPI_FAILURE (Status))
+    {
+        AcpiUtRemoveReference (ReturnDesc);
+    }
+
+    /* Set the return object and exit */
+
+    WalkState->ResultObj = ReturnDesc;
+    return_ACPI_STATUS (Status);
+}
+
+
+
+
diff --git a/sys/contrib/dev/acpica/exoparg6.c b/sys/contrib/dev/acpica/exoparg6.c
new file mode 100644
index 000000000000..ad36e138b49a
--- /dev/null
+++ b/sys/contrib/dev/acpica/exoparg6.c
@@ -0,0 +1,386 @@
+
+/******************************************************************************
+ *
+ * Module Name: exoparg6 - AML execution - opcodes with 6 arguments
+ *              $Revision: 4 $
+ *
+ *****************************************************************************/
+
+/******************************************************************************
+ *
+ * 1. Copyright Notice
+ *
+ * Some or all of this work - Copyright (c) 1999, 2000, 2001, 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.
+ *
+ *****************************************************************************/
+
+#define __EXOPARG6_C__
+
+#include "acpi.h"
+#include "acinterp.h"
+#include "acparser.h"
+#include "amlcode.h"
+
+
+#define _COMPONENT          ACPI_EXECUTER
+        MODULE_NAME         ("exoparg6")
+
+
+
+/*!
+ * Naming convention for AML interpreter execution routines.
+ *
+ * The routines that begin execution of AML opcodes are named with a common
+ * convention based upon the number of arguments, the number of target operands,
+ * and whether or not a value is returned:
+ *
+ *      AcpiExOpcode_xA_yT_zR
+ *
+ * Where:  
+ *
+ * xA - ARGUMENTS:    The number of arguments (input operands) that are 
+ *                    required for this opcode type (1 through 6 args).
+ * yT - TARGETS:      The number of targets (output operands) that are required 
+ *                    for this opcode type (0, 1, or 2 targets).
+ * zR - RETURN VALUE: Indicates whether this opcode type returns a value 
+ *                    as the function return (0 or 1).
+ *
+ * The AcpiExOpcode* functions are called via the Dispatcher component with 
+ * fully resolved operands.
+!*/
+
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExDoMatch
+ *
+ * PARAMETERS:  MatchOp         - The AML match operand
+ *              PackageValue    - Value from the target package
+ *              MatchValue      - Value to be matched
+ *
+ * RETURN:      TRUE if the match is successful, FALSE otherwise
+ *
+ * DESCRIPTION: Implements the low-level match for the ASL Match operator
+ *
+ ******************************************************************************/
+
+BOOLEAN
+AcpiExDoMatch (
+    UINT32                  MatchOp,
+    ACPI_INTEGER            PackageValue,
+    ACPI_INTEGER            MatchValue)
+{
+
+    switch (MatchOp)
+    {
+    case MATCH_MTR:   /* always true */
+
+        break;
+
+
+    case MATCH_MEQ:   /* true if equal   */
+
+        if (PackageValue != MatchValue)
+        {
+            return (FALSE);
+        }
+        break;
+
+
+    case MATCH_MLE:   /* true if less than or equal  */
+
+        if (PackageValue > MatchValue)
+        {
+            return (FALSE);
+        }
+        break;
+
+
+    case MATCH_MLT:   /* true if less than   */
+
+        if (PackageValue >= MatchValue)
+        {
+            return (FALSE);
+        }
+        break;
+
+
+    case MATCH_MGE:   /* true if greater than or equal   */
+
+        if (PackageValue < MatchValue)
+        {
+            return (FALSE);
+        }
+        break;
+
+
+    case MATCH_MGT:   /* true if greater than    */
+
+        if (PackageValue <= MatchValue)
+        {
+            return (FALSE);
+        }
+        break;
+
+
+    default:    /* undefined   */
+
+        return (FALSE);
+    }
+
+
+    return TRUE;
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiExOpcode_6A_0T_1R
+ *
+ * PARAMETERS:  WalkState           - Current walk state
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute opcode with 6 arguments, no target, and a return value
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiExOpcode_6A_0T_1R (
+    ACPI_WALK_STATE         *WalkState)
+{
+    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
+    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
+    ACPI_STATUS             Status = AE_OK;
+    UINT32                  Index;
+    ACPI_OPERAND_OBJECT     *ThisElement;
+
+
+    FUNCTION_TRACE_STR ("ExOpcode_6A_0T_1R", AcpiPsGetOpcodeName (WalkState->Opcode));
+
+
+    switch (WalkState->Opcode)
+    {
+    case AML_MATCH_OP:  
+        /* 
+         * Match (SearchPackage[0], MatchOp1[1], MatchObject1[2], 
+         *                          MatchOp2[3], MatchObject2[4], StartIndex[5])
+         */
+
+        /* Validate match comparison sub-opcodes */
+
+        if ((Operand[1]->Integer.Value > MAX_MATCH_OPERATOR) ||
+            (Operand[3]->Integer.Value > MAX_MATCH_OPERATOR))
+        {
+            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "operation encoding out of range\n"));
+            Status = AE_AML_OPERAND_VALUE;
+            goto Cleanup;
+        }
+
+        Index = (UINT32) Operand[5]->Integer.Value;
+        if (Index >= (UINT32) Operand[0]->Package.Count)
+        {
+            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Index beyond package end\n"));
+            Status = AE_AML_PACKAGE_LIMIT;
+            goto Cleanup;
+        }
+
+        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
+        if (!ReturnDesc)
+        {
+            Status = AE_NO_MEMORY;
+            goto Cleanup;
+
+        }
+
+        /* Default return value if no match found */
+
+        ReturnDesc->Integer.Value = ACPI_INTEGER_MAX;
+
+        /*
+         * Examine each element until a match is found.  Within the loop,
+         * "continue" signifies that the current element does not match
+         * and the next should be examined.
+         * Upon finding a match, the loop will terminate via "break" at
+         * the bottom.  If it terminates "normally", MatchValue will be -1
+         * (its initial value) indicating that no match was found.  When
+         * returned as a Number, this will produce the Ones value as specified.
+         */
+        for ( ; Index < Operand[0]->Package.Count; Index++)
+        {
+            ThisElement = Operand[0]->Package.Elements[Index];
+
+            /*
+             * Treat any NULL or non-numeric elements as non-matching.
+             * TBD [Unhandled] - if an element is a Name,
+             *      should we examine its value?
+             */
+            if (!ThisElement ||
+                ThisElement->Common.Type != ACPI_TYPE_INTEGER)
+            {
+                continue;
+            }
+
+
+            /*
+             * Within these switch statements:
+             *      "break" (exit from the switch) signifies a match;
+             *      "continue" (proceed to next iteration of enclosing
+             *          "for" loop) signifies a non-match.
+             */
+            if (!AcpiExDoMatch ((UINT32) Operand[1]->Integer.Value, 
+                                ThisElement->Integer.Value, Operand[2]->Integer.Value))
+            {
+                continue;
+            }
+
+
+            if (!AcpiExDoMatch ((UINT32) Operand[3]->Integer.Value, 
+                                ThisElement->Integer.Value, Operand[4]->Integer.Value))
+            {
+                continue;
+            }
+
+            /* Match found: Index is the return value */
+
+            ReturnDesc->Integer.Value = Index;
+            break;
+        }
+
+        break;
+
+
+    case AML_LOAD_TABLE_OP:
+
+        Status = AE_NOT_IMPLEMENTED;
+        goto Cleanup;
+        break;
+
+
+    default:
+
+        REPORT_ERROR (("AcpiExOpcode_3A_0T_0R: Unknown opcode %X\n",
+                WalkState->Opcode));
+        Status = AE_AML_BAD_OPCODE;
+        goto Cleanup;
+        break;
+    }
+
+
+    WalkState->ResultObj = ReturnDesc;
+
+
+Cleanup:
+
+    /* Delete return object on error */
+
+    if (ACPI_FAILURE (Status))
+    {
+        AcpiUtRemoveReference (ReturnDesc);
+    }
+
+    return_ACPI_STATUS (Status);
+}