Vendor import of Intel ACPI-CA 20070320

28 files changed, 1573 insertions, 624 deletions

diff --git a/sys/contrib/dev/acpica/compiler/aslanalyze.c b/sys/contrib/dev/acpica/compiler/aslanalyze.c
index 42f2247..93f2f0b 100644
--- a/sys/contrib/dev/acpica/compiler/aslanalyze.c
+++ b/sys/contrib/dev/acpica/compiler/aslanalyze.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslanalyze.c - check for semantic errors
- *              $Revision: 1.96 $
+ *              $Revision: 1.115 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -171,6 +171,68 @@ AnCheckMethodReturnValue (
     UINT32                  RequiredBtypes,
     UINT32                  ThisNodeBtype);
 
+static BOOLEAN
+AnIsInternalMethod (
+    ACPI_PARSE_OBJECT       *Op);
+
+static UINT32
+AnGetInternalMethodReturnType (
+    ACPI_PARSE_OBJECT       *Op);
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AnIsInternalMethod
+ *
+ * PARAMETERS:  Op              - Current op
+ *
+ * RETURN:      Boolean
+ *
+ * DESCRIPTION: Check for an internal control method.
+ *
+ ******************************************************************************/
+
+static BOOLEAN
+AnIsInternalMethod (
+    ACPI_PARSE_OBJECT       *Op)
+{
+
+    if ((!ACPI_STRCMP (Op->Asl.ExternalName, "\\_OSI")) ||
+        (!ACPI_STRCMP (Op->Asl.ExternalName, "_OSI")))
+    {
+        return (TRUE);
+    }
+
+    return (FALSE);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AnGetInternalMethodReturnType
+ *
+ * PARAMETERS:  Op              - Current op
+ *
+ * RETURN:      Btype
+ *
+ * DESCRIPTION: Get the return type of an internal method
+ *
+ ******************************************************************************/
+
+static UINT32
+AnGetInternalMethodReturnType (
+    ACPI_PARSE_OBJECT       *Op)
+{
+
+    if ((!ACPI_STRCMP (Op->Asl.ExternalName, "\\_OSI")) ||
+        (!ACPI_STRCMP (Op->Asl.ExternalName, "_OSI")))
+    {
+        return (ACPI_BTYPE_STRING);
+    }
+
+    return (0);
+}
+
 
 /*******************************************************************************
  *
@@ -182,7 +244,7 @@ AnCheckMethodReturnValue (
  * RETURN:      The corresponding Bit-encoded types
  *
  * DESCRIPTION: Convert an encoded ARGI required argument type code into a
- *              bitfield type code.  Implements the implicit source conversion
+ *              bitfield type code. Implements the implicit source conversion
  *              rules.
  *
  ******************************************************************************/
@@ -263,8 +325,11 @@ AnMapArgTypeToBtype (
     case ARGI_REF_OR_STRING:
         return (ACPI_BTYPE_STRING | ACPI_BTYPE_REFERENCE);
 
-    case ARGI_REGION_OR_FIELD:
-        return (ACPI_BTYPE_REGION | ACPI_BTYPE_FIELD_UNIT);
+    case ARGI_REGION_OR_BUFFER:
+
+        /* Used by Load() only. Allow buffers in addition to regions/fields */
+
+        return (ACPI_BTYPE_REGION | ACPI_BTYPE_BUFFER | ACPI_BTYPE_FIELD_UNIT);
 
     case ARGI_DATAREFOBJ:
         return (ACPI_BTYPE_INTEGER |ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER |
@@ -287,7 +352,7 @@ AnMapArgTypeToBtype (
  * RETURN:      Btype corresponding to the Etype
  *
  * DESCRIPTION: Convert an encoded ACPI type to a bitfield type applying the
- *              operand conversion rules.  In other words, returns the type(s)
+ *              operand conversion rules. In other words, returns the type(s)
  *              this Etype is implicitly converted to during interpretation.
  *
  ******************************************************************************/
@@ -480,7 +545,8 @@ AnGetBtype (
         ThisNodeBtype = AnMapEtypeToBtype (Node->Type);
         if (!ThisNodeBtype)
         {
-            AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op, NULL);
+            AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
+                "could not map type");
         }
 
         /*
@@ -494,8 +560,16 @@ AnGetBtype (
             ReferencedNode = Node->Op;
             if (!ReferencedNode)
             {
-               printf ("No back ptr to Op: type %X\n", Node->Type);
-               return ACPI_UINT32_MAX;
+                /* Check for an internal method */
+
+                if (AnIsInternalMethod (Op))
+                {
+                    return (AnGetInternalMethodReturnType (Op));
+                }
+
+                AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
+                    "null Op pointer");
+                return ACPI_UINT32_MAX;
             }
 
             if (ReferencedNode->Asl.CompileFlags & NODE_METHOD_TYPED)
@@ -555,7 +629,7 @@ AnCheckForReservedName (
 
     for (i = 0; ReservedMethods[i].Name; i++)
     {
-        if (!ACPI_STRNCMP (Name, ReservedMethods[i].Name, ACPI_NAME_SIZE))
+        if (ACPI_COMPARE_NAME (Name, ReservedMethods[i].Name))
         {
             if (ReservedMethods[i].Flags & ASL_RSVD_SCOPE)
             {
@@ -613,7 +687,7 @@ AnCheckForReservedName (
     }
 
     /*
-     * The name didn't match any of the known reserved names.  Flag it as a
+     * The name didn't match any of the known reserved names. Flag it as a
      * warning, since the entire namespace starting with an underscore is
      * reserved by the ACPI spec.
      */
@@ -668,7 +742,7 @@ AnCheckForReservedMethod (
 
         if (MethodInfo->NumArguments != 0)
         {
-            sprintf (MsgBuffer, " %s requires %d",
+            sprintf (MsgBuffer, "%s requires %d",
                         Op->Asl.ExternalName, 0);
 
             AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op, MsgBuffer);
@@ -684,7 +758,7 @@ AnCheckForReservedMethod (
 
         if (MethodInfo->NumArguments != ReservedMethods[Index].NumArguments)
         {
-            sprintf (MsgBuffer, " %s requires %d",
+            sprintf (MsgBuffer, "%s requires %d",
                         ReservedMethods[Index].Name,
                         ReservedMethods[Index].NumArguments);
 
@@ -790,7 +864,7 @@ AnMapObjTypeToBtype (
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Descending callback for the analysis walk.  Check methods for :
+ * DESCRIPTION: Descending callback for the analysis walk. Check methods for:
  *              1) Initialized local variables
  *              2) Valid arguments
  *              3) Return types
@@ -816,9 +890,6 @@ AnMethodAnalysisWalkBegin (
     UINT8                   ActualArgs = 0;
 
 
-    ACPI_FUNCTION_NAME ("AnMethodAnalysisWalkBegin");
-
-
     switch (Op->Asl.ParseOpcode)
     {
     case PARSEOP_METHOD:
@@ -942,7 +1013,7 @@ AnMethodAnalysisWalkBegin (
              * Probably was an error in the method declaration,
              * no additional error here
              */
-            ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "%p, No parent method\n", Op));
+            ACPI_WARNING ((AE_INFO, "%p, No parent method", Op));
             return (AE_ERROR);
         }
 
@@ -986,7 +1057,7 @@ AnMethodAnalysisWalkBegin (
              * Probably was an error in the method declaration,
              * no additional error here
              */
-            ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "%p, No parent method\n", Op));
+            ACPI_WARNING ((AE_INFO, "%p, No parent method", Op));
             return (AE_ERROR);
         }
 
@@ -1031,7 +1102,7 @@ AnMethodAnalysisWalkBegin (
              * Probably was an error in the method declaration,
              * no additional error here
              */
-            ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "%p, No parent method\n", Op));
+            ACPI_WARNING ((AE_INFO, "%p, No parent method", Op));
             return (AE_ERROR);
         }
 
@@ -1152,7 +1223,6 @@ AnMethodAnalysisWalkBegin (
                 }
             }
         }
-
         break;
 
 
@@ -1170,10 +1240,10 @@ AnMethodAnalysisWalkBegin (
  *
  * PARAMETERS:  Op            - A method parse node
  *
- * RETURN:      TRUE if last statement is an ASL RETURN.  False otherwise
+ * RETURN:      TRUE if last statement is an ASL RETURN. False otherwise
  *
  * DESCRIPTION: Walk down the list of top level statements within a method
- *              to find the last one.  Check if that last statement is in
+ *              to find the last one. Check if that last statement is in
  *              fact a RETURN statement.
  *
  ******************************************************************************/
@@ -1212,7 +1282,7 @@ AnLastStatementIsReturn (
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Ascending callback for analysis walk.  Complete method
+ * DESCRIPTION: Ascending callback for analysis walk. Complete method
  *              return analysis.
  *
  ******************************************************************************/
@@ -1261,14 +1331,14 @@ AnMethodAnalysisWalkEnd (
         {
             /*
              * No return statement, and execution can possibly exit
-             * via this path.  This is equivalent to Return ()
+             * via this path. This is equivalent to Return ()
              */
             MethodInfo->NumReturnNoValue++;
         }
 
         /*
          * Check for case where some return statements have a return value
-         * and some do not.  Exit without a return statement is a return with
+         * and some do not. Exit without a return statement is a return with
          * no value
          */
         if (MethodInfo->NumReturnNoValue &&
@@ -1281,7 +1351,7 @@ AnMethodAnalysisWalkEnd (
         /*
          * If there are any RETURN() statements with no value, or there is a
          * control path that allows the method to exit without a return value,
-         * we mark the method as a method that does not return a value.  This
+         * we mark the method as a method that does not return a value. This
          * knowledge can be used to check method invocations that expect a
          * returned value.
          */
@@ -1302,7 +1372,7 @@ AnMethodAnalysisWalkEnd (
          * and correct number of arguments
          */
         AnCheckForReservedMethod (Op, MethodInfo);
-        ACPI_MEM_FREE (MethodInfo);
+        ACPI_FREE (MethodInfo);
         break;
 
 
@@ -1321,7 +1391,7 @@ AnMethodAnalysisWalkEnd (
         /*
          * If there is a peer node after the return statement, then this
          * node is unreachable code -- i.e., it won't be executed because of
-         *  thepreceeding Return() statement.
+         * the preceeding Return() statement.
          */
         if (Op->Asl.Next)
         {
@@ -1337,7 +1407,7 @@ AnMethodAnalysisWalkEnd (
             (Op->Asl.Next->Asl.ParseOpcode == PARSEOP_ELSE))
         {
             /*
-             * This IF has a corresponding ELSE.  The IF block has no exit,
+             * This IF has a corresponding ELSE. The IF block has no exit,
              * (it contains an unconditional Return)
              * mark the ELSE block to remember this fact.
              */
@@ -1353,7 +1423,7 @@ AnMethodAnalysisWalkEnd (
         {
             /*
              * This ELSE block has no exit and the corresponding IF block
-             * has no exit either.  Therefore, the parent node has no exit.
+             * has no exit either. Therefore, the parent node has no exit.
              */
             Op->Asl.Parent->Asl.CompileFlags |= NODE_HAS_NO_EXIT;
         }
@@ -1407,8 +1477,8 @@ AnMethodTypingWalkBegin (
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Ascending callback for typing walk.  Complete method
- *              return analysis.  Check methods for :
+ * DESCRIPTION: Ascending callback for typing walk. Complete the method
+ *              return analysis. Check methods for:
  *              1) Initialized local variables
  *              2) Valid arguments
  *              3) Return types
@@ -1442,17 +1512,24 @@ AnMethodTypingWalkEnd (
                 (ThisNodeBtype == (ACPI_UINT32_MAX -1)))
             {
                 /*
-                 * The method is untyped at this time (typically a forward
-                 *  reference). We must recursively type the method here
+                 * The called method is untyped at this time (typically a
+                 * forward reference).
+                 *
+                 * Check for a recursive method call first.
                  */
-                TrWalkParseTree (Op->Asl.Child->Asl.Node->Op,
-                    ASL_WALK_VISIT_TWICE, AnMethodTypingWalkBegin,
-                    AnMethodTypingWalkEnd, NULL);
+                if (Op->Asl.ParentMethod != Op->Asl.Child->Asl.Node->Op)
+                {
+                    /* We must type the method here */
 
-                ThisNodeBtype = AnGetBtype (Op->Asl.Child);
+                    TrWalkParseTree (Op->Asl.Child->Asl.Node->Op,
+                        ASL_WALK_VISIT_TWICE, AnMethodTypingWalkBegin,
+                        AnMethodTypingWalkEnd, NULL);
+
+                    ThisNodeBtype = AnGetBtype (Op->Asl.Child);
+                }
             }
 
-            /* Returns a value, get it's type */
+            /* Returns a value, save the value type */
 
             if (Op->Asl.ParentMethod)
             {
@@ -1550,7 +1627,7 @@ AnCheckMethodReturnValue (
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Descending callback for the analysis walk.  Check methods for:
+ * DESCRIPTION: Descending callback for the analysis walk. Check methods for:
  *              1) Initialized local variables
  *              2) Valid arguments
  *              3) Return types
@@ -1576,7 +1653,7 @@ AnOperandTypecheckWalkBegin (
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Ascending callback for analysis walk.  Complete method
+ * DESCRIPTION: Ascending callback for analysis walk. Complete method
  *              return analysis.
  *
  ******************************************************************************/
@@ -1641,7 +1718,9 @@ AnOperandTypecheckWalkEnd (
 
         if (ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL)
         {
-            if (!ACPI_STRCMP (ArgOp->Asl.ExternalName, "\\_OSI"))
+            /* Check for an internal method */
+
+            if (AnIsInternalMethod (ArgOp))
             {
                 return (AE_OK);
             }
@@ -1812,6 +1891,11 @@ AnOperandTypecheckWalkEnd (
 
             if (ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL)
             {
+                if (AnIsInternalMethod (ArgOp))
+                {
+                    return (AE_OK);
+                }
+
                 /* Check a method call for a valid return value */
 
                 AnCheckMethodReturnValue (Op, OpInfo, ArgOp,
@@ -1851,16 +1935,81 @@ AnOperandTypecheckWalkEnd (
 
 /*******************************************************************************
  *
+ * FUNCTION:    AnIsResultUsed
+ *
+ * PARAMETERS:  Op              - Parent op for the operator
+ *
+ * RETURN:      TRUE if result from this operation is actually consumed
+ *
+ * DESCRIPTION: Determine if the function result value from an operator is
+ *              used.
+ *
+ ******************************************************************************/
+
+BOOLEAN
+AnIsResultUsed (
+    ACPI_PARSE_OBJECT       *Op)
+{
+    ACPI_PARSE_OBJECT       *Parent;
+
+
+    switch (Op->Asl.ParseOpcode)
+    {
+    case PARSEOP_INCREMENT:
+    case PARSEOP_DECREMENT:
+
+        /* These are standalone operators, no return value */
+
+        return (TRUE);
+
+    default:
+        break;
+    }
+
+    /* Examine parent to determine if the return value is used */
+
+    Parent = Op->Asl.Parent;
+    switch (Parent->Asl.ParseOpcode)
+    {
+    /* If/While - check if the operator is the predicate */
+
+    case PARSEOP_IF:
+    case PARSEOP_WHILE:
+
+        /* First child is the predicate */
+
+        if (Parent->Asl.Child == Op)
+        {
+            return (TRUE);
+        }
+        return (FALSE);
+
+    /* Not used if one of these is the parent */
+
+    case PARSEOP_METHOD:
+    case PARSEOP_DEFINITIONBLOCK:
+    case PARSEOP_ELSE:
+
+        return (FALSE);
+
+    default:
+        /* Any other type of parent means that the result is used */
+
+        return (TRUE);
+    }
+}
+
+
+/*******************************************************************************
+ *
  * FUNCTION:    AnOtherSemanticAnalysisWalkBegin
  *
  * PARAMETERS:  ASL_WALK_CALLBACK
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Descending callback for the analysis walk.  Check methods for :
- *              1) Initialized local variables
- *              2) Valid arguments
- *              3) Return types
+ * DESCRIPTION: Descending callback for the analysis walk. Checks for
+ *              miscellaneous issues in the code.
  *
  ******************************************************************************/
 
@@ -1870,6 +2019,130 @@ AnOtherSemanticAnalysisWalkBegin (
     UINT32                  Level,
     void                    *Context)
 {
+    ACPI_PARSE_OBJECT       *ArgNode;
+    ACPI_PARSE_OBJECT       *PrevArgNode = NULL;
+    const ACPI_OPCODE_INFO  *OpInfo;
+
+
+    OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
+
+    /*
+     * Determine if an execution class operator actually does something by
+     * checking if it has a target and/or the function return value is used.
+     * (Target is optional, so a standalone statement can actually do nothing.)
+     */
+    if ((OpInfo->Class == AML_CLASS_EXECUTE) &&
+        (OpInfo->Flags & AML_HAS_RETVAL) &&
+        (!AnIsResultUsed (Op)))
+    {
+        if (OpInfo->Flags & AML_HAS_TARGET)
+        {
+            /*
+             * Find the target node, it is always the last child. If the traget
+             * is not specified in the ASL, a default node of type Zero was
+             * created by the parser.
+             */
+            ArgNode = Op->Asl.Child;
+            while (ArgNode->Asl.Next)
+            {
+                PrevArgNode = ArgNode;
+                ArgNode = ArgNode->Asl.Next;
+            }
+
+            /* Divide() is the only weird case, it has two targets */
+
+            if (Op->Asl.AmlOpcode == AML_DIVIDE_OP)
+            {
+                if ((ArgNode->Asl.ParseOpcode == PARSEOP_ZERO) &&
+                    (PrevArgNode->Asl.ParseOpcode == PARSEOP_ZERO))
+                {
+                    AslError (ASL_WARNING, ASL_MSG_RESULT_NOT_USED, Op, Op->Asl.ExternalName);
+                }
+            }
+            else if (ArgNode->Asl.ParseOpcode == PARSEOP_ZERO)
+            {
+                AslError (ASL_WARNING, ASL_MSG_RESULT_NOT_USED, Op, Op->Asl.ExternalName);
+            }
+        }
+        else
+        {
+            /*
+             * Has no target and the result is not used. Only a couple opcodes
+             * can have this combination.
+             */
+            switch (Op->Asl.ParseOpcode)
+            {
+            case PARSEOP_ACQUIRE:
+            case PARSEOP_WAIT:
+                break;
+
+            default:
+                AslError (ASL_WARNING, ASL_MSG_RESULT_NOT_USED, Op, Op->Asl.ExternalName);
+                break;
+            }
+        }
+    }
+
+
+    /*
+     * Semantic checks for individual ASL operators
+     */
+    switch (Op->Asl.ParseOpcode)
+    {
+    case PARSEOP_ACQUIRE:
+    case PARSEOP_WAIT:
+        /*
+         * Emit a warning if the timeout parameter for these operators is not
+         * ACPI_WAIT_FOREVER, and the result value from the operator is not
+         * checked, meaning that a timeout could happen, but the code
+         * would not know about it.
+         */
+
+        /* First child is the namepath, 2nd child is timeout */
+
+        ArgNode = Op->Asl.Child;
+        ArgNode = ArgNode->Asl.Next;
+
+        /*
+         * Check for the WAIT_FOREVER case - defined by the ACPI spec to be
+         * 0xFFFF or greater
+         */
+        if (((ArgNode->Asl.ParseOpcode == PARSEOP_WORDCONST) ||
+             (ArgNode->Asl.ParseOpcode == PARSEOP_INTEGER))  &&
+             (ArgNode->Asl.Value.Integer >= (ACPI_INTEGER) ACPI_WAIT_FOREVER))
+        {
+            break;
+        }
+
+        /*
+         * The operation could timeout. If the return value is not used
+         * (indicates timeout occurred), issue a warning
+         */
+        if (!AnIsResultUsed (Op))
+        {
+            AslError (ASL_WARNING, ASL_MSG_TIMEOUT, ArgNode, Op->Asl.ExternalName);
+        }
+        break;
+
+    case PARSEOP_CREATEFIELD:
+        /*
+         * Check for a zero Length (NumBits) operand. NumBits is the 3rd operand
+         */
+        ArgNode = Op->Asl.Child;
+        ArgNode = ArgNode->Asl.Next;
+        ArgNode = ArgNode->Asl.Next;
+
+        if ((ArgNode->Asl.ParseOpcode == PARSEOP_ZERO) ||
+           ((ArgNode->Asl.ParseOpcode == PARSEOP_INTEGER) &&
+            (ArgNode->Asl.Value.Integer == 0)))
+        {
+            AslError (ASL_ERROR, ASL_MSG_NON_ZERO, ArgNode, NULL);
+        }
+        break;
+
+    default:
+        break;
+    }
 
     return AE_OK;
 }
@@ -1883,7 +2156,7 @@ AnOtherSemanticAnalysisWalkBegin (
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Ascending callback for analysis walk.  Complete method
+ * DESCRIPTION: Ascending callback for analysis walk. Complete method
  *              return analysis.
  *
  ******************************************************************************/
diff --git a/sys/contrib/dev/acpica/compiler/aslcodegen.c b/sys/contrib/dev/acpica/compiler/aslcodegen.c
index 234b17a..25ee729 100644
--- a/sys/contrib/dev/acpica/compiler/aslcodegen.c
+++ b/sys/contrib/dev/acpica/compiler/aslcodegen.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslcodegen - AML code generation
- *              $Revision: 1.57 $
+ *              $Revision: 1.62 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -205,6 +205,18 @@ CgAmlWriteWalk (
     void                    *Context)
 {
 
+    /*
+     * Print header at level 0. Alignment assumes 32-bit pointers
+     */
+    if (!Level)
+    {
+        DbgPrint (ASL_TREE_OUTPUT,
+            "Final parse tree used for AML output:\n");
+        DbgPrint (ASL_TREE_OUTPUT,
+            "%*s Value    P_Op A_Op OpLen PByts Len  SubLen PSubLen OpPtr    Child    Parent   Flags    AcTyp    Final Col L\n",
+            76, " ");
+    }
+
     /* Debug output */
 
     DbgPrint (ASL_TREE_OUTPUT,
@@ -223,23 +235,24 @@ CgAmlWriteWalk (
         DbgPrint (ASL_TREE_OUTPUT, "                ");
     }
 
-    DbgPrint (ASL_TREE_OUTPUT,
-        "Val-%08X POp-%04X AOp-%04X OpLen-%01X PByts-%01X Len-%04X SubLen-%04X PSubLen-%04X Op-%08X Chld-%08X Paren-%08X Flags-%04X AcTyp-%08X C-%2d L-%d\n",
-                (UINT32) Op->Asl.Value.Integer,
-                Op->Asl.ParseOpcode,
-                Op->Asl.AmlOpcode,
-                Op->Asl.AmlOpcodeLength,
-                Op->Asl.AmlPkgLenBytes,
-                Op->Asl.AmlLength,
-                Op->Asl.AmlSubtreeLength,
-                Op->Asl.Parent ? Op->Asl.Parent->Asl.AmlSubtreeLength : 0,
-                Op,
-                Op->Asl.Child,
-                Op->Asl.Parent,
-                Op->Asl.CompileFlags,
-                Op->Asl.AcpiBtype,
-                Op->Asl.Column,
-                Op->Asl.LineNumber);
+        DbgPrint (ASL_TREE_OUTPUT,
+        "%08X %04X %04X %01X     %04X  %04X %04X   %04X    %08X %08X %08X %08X %08X %04X  %02d  %02d\n",
+                /* 1  */ (UINT32) Op->Asl.Value.Integer,
+                /* 2  */ Op->Asl.ParseOpcode,
+                /* 3  */ Op->Asl.AmlOpcode,
+                /* 4  */ Op->Asl.AmlOpcodeLength,
+                /* 5  */ Op->Asl.AmlPkgLenBytes,
+                /* 6  */ Op->Asl.AmlLength,
+                /* 7  */ Op->Asl.AmlSubtreeLength,
+                /* 8  */ Op->Asl.Parent ? Op->Asl.Parent->Asl.AmlSubtreeLength : 0,
+                /* 9  */ Op,
+                /* 10 */ Op->Asl.Child,
+                /* 11 */ Op->Asl.Parent,
+                /* 12 */ Op->Asl.CompileFlags,
+                /* 13 */ Op->Asl.AcpiBtype,
+                /* 14 */ Op->Asl.FinalAmlLength,
+                /* 15 */ Op->Asl.Column,
+                /* 16 */ Op->Asl.LineNumber);
 
     /* Generate the AML for this node */
 
@@ -383,7 +396,7 @@ CgWriteAmlOpcode (
 
             CgLocalWriteAmlData (Op, &PkgLen.LenBytes[0], 1);
         }
-        else
+        else if (Op->Asl.AmlPkgLenBytes != 0)
         {
             /*
              * Encode the "bytes to follow" in the first byte, top two bits.
@@ -575,8 +588,6 @@ CgWriteNode (
     ASL_RESOURCE_NODE       *Rnode;
 
 
-    Op->Asl.FinalAmlLength = 0;
-
     /* Always check for DEFAULT_ARG and other "Noop" nodes */
     /* TBD: this may not be the best place for this check */
 
@@ -588,6 +599,8 @@ CgWriteNode (
         return;
     }
 
+    Op->Asl.FinalAmlLength = 0;
+
     switch (Op->Asl.AmlOpcode)
     {
     case AML_RAW_DATA_BYTE:
diff --git a/sys/contrib/dev/acpica/compiler/aslcompile.c b/sys/contrib/dev/acpica/compiler/aslcompile.c
index e6c2149..eba3552 100644
--- a/sys/contrib/dev/acpica/compiler/aslcompile.c
+++ b/sys/contrib/dev/acpica/compiler/aslcompile.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslcompile - top level compile module
- *              $Revision: 1.88 $
+ *              $Revision: 1.97 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -328,13 +328,97 @@ CmFlushSourceCode (
 
 /*******************************************************************************
  *
+ * FUNCTION:    FlConsume*
+ *
+ * PARAMETERS:  FileInfo        - Points to an open input file
+ *
+ * RETURN:      Number of lines consumed
+ *
+ * DESCRIPTION: Step over both types of comment during check for ascii chars
+ *
+ ******************************************************************************/
+
+void
+FlConsumeAnsiComment (
+    ASL_FILE_INFO           *FileInfo,
+    ASL_FILE_STATUS         *Status)
+{
+    UINT8                   Byte;
+    BOOLEAN                 ClosingComment = FALSE;
+
+
+    while (fread (&Byte, 1, 1, FileInfo->Handle))
+    {
+        /* Scan until comment close is found */
+
+        if (ClosingComment)
+        {
+            if (Byte == '/')
+            {
+                return;
+            }
+
+            if (Byte != '*')
+            {
+                /* Reset */
+
+                ClosingComment = FALSE;
+            }
+        }
+        else if (Byte == '*')
+        {
+            ClosingComment = TRUE;
+        }
+
+        /* Maintain line count */
+
+        if (Byte == 0x0A)
+        {
+            Status->Line++;
+        }
+
+        Status->Offset++;
+    }
+}
+
+
+void
+FlConsumeNewComment (
+    ASL_FILE_INFO           *FileInfo,
+    ASL_FILE_STATUS         *Status)
+{
+    UINT8                   Byte;
+
+
+    while (fread (&Byte, 1, 1, FileInfo->Handle))
+    {
+        Status->Offset++;
+
+        /* Comment ends at newline */
+
+        if (Byte == 0x0A)
+        {
+            Status->Line++;
+            return;
+        }
+    }
+}
+
+
+/*******************************************************************************
+ *
  * FUNCTION:    FlCheckForAscii
  *
  * PARAMETERS:  FileInfo        - Points to an open input file
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Verify that the input file is entirely ASCII.
+ * DESCRIPTION: Verify that the input file is entirely ASCII. Ignores characters
+ *              within comments. Note: does not handle nested comments and does
+ *              not handle comment delimiters within string literals. However,
+ *              on the rare chance this happens and an invalid character is
+ *              missed, the parser will catch the error by failing in some
+ *              spectactular manner.
  *
  ******************************************************************************/
 
@@ -344,13 +428,42 @@ FlCheckForAscii (
 {
     UINT8                   Byte;
     ACPI_SIZE               BadBytes = 0;
-    ACPI_SIZE               Offset = 0;
+    BOOLEAN                 OpeningComment = FALSE;
+    ASL_FILE_STATUS         Status;
+
 
+    Status.Line = 1;
+    Status.Offset = 0;
 
     /* Read the entire file */
 
     while (fread (&Byte, 1, 1, FileInfo->Handle))
     {
+        /* Ignore comment fields (allow non-ascii within) */
+
+        if (OpeningComment)
+        {
+            /* Check for second comment open delimiter */
+
+            if (Byte == '*')
+            {
+                FlConsumeAnsiComment (FileInfo, &Status);
+            }
+
+            if (Byte == '/')
+            {
+                FlConsumeNewComment (FileInfo, &Status);
+            }
+
+            /* Reset */
+
+            OpeningComment = FALSE;
+        }
+        else if (Byte == '/')
+        {
+            OpeningComment = TRUE;
+        }
+
         /* Check for an ASCII character */
 
         if (!isascii (Byte))
@@ -358,12 +471,21 @@ FlCheckForAscii (
             if (BadBytes < 10)
             {
                 AcpiOsPrintf (
-                    "Non-ASCII character [0x%2.2X] found at file offset 0x%8.8X\n",
-                    Byte, Offset);
+                    "Non-ASCII character [0x%2.2X] found in line %u, file offset 0x%.2X\n",
+                    Byte, Status.Line, Status.Offset);
             }
+
             BadBytes++;
         }
-        Offset++;
+
+        /* Update line counter */
+
+        else if (Byte == 0x0A)
+        {
+            Status.Line++;
+        }
+
+        Status.Offset++;
     }
 
     /* Seek back to the beginning of the source file */
@@ -375,9 +497,9 @@ FlCheckForAscii (
     if (BadBytes)
     {
         AcpiOsPrintf (
-            "%d non-ASCII characters found in input file, could be a binary file\n",
+            "%u non-ASCII characters found in input source text, could be a binary file\n",
             BadBytes);
-        AslError (ASL_WARNING, ASL_MSG_NON_ASCII, NULL, FileInfo->Filename);
+        AslError (ASL_ERROR, ASL_MSG_NON_ASCII, NULL, FileInfo->Filename);
         return (AE_BAD_CHARACTER);
     }
 
@@ -420,19 +542,13 @@ CmDoCompile (
         return -1;
     }
 
-    /* Optional check for 100% ASCII source file */
+    /* Check for 100% ASCII source file (comments are ignored) */
 
-    if (Gbl_CheckForAscii)
+    Status = FlCheckForAscii (&Gbl_Files[ASL_FILE_INPUT]);
+    if (ACPI_FAILURE (Status))
     {
-        /*
-         * NOTE: This code is optional because there can be "special" characters
-         * embedded in comments (such as the "copyright" symbol, 0xA9).
-         * Just emit a warning if there are non-ascii characters present.
-         */
-
-        /* Check if the input file is 100% ASCII text */
-
-        Status = FlCheckForAscii (&Gbl_Files[ASL_FILE_INPUT]);
+        AePrintErrorLog (ASL_FILE_STDERR);
+        return -1;
     }
 
     Status = FlOpenMiscOutputFiles (Gbl_OutputFilenamePrefix);
@@ -462,6 +578,10 @@ CmDoCompile (
         return -1;
     }
 
+    /* Optional parse tree dump, compiler debug output only */
+
+    LsDumpParseTree ();
+
     OpcGetIntegerWidth (RootNode);
     UtEndEvent (Event);
 
@@ -549,16 +669,20 @@ CmDoCompile (
         return -1;
     }
 
-    /* Namespace lookup */
+    /* Namespace cross-reference */
 
     AslGbl_NamespaceEvent = UtBeginEvent ("Cross reference parse tree and Namespace");
     Status = LkCrossReferenceNamespace ();
-    UtEndEvent (AslGbl_NamespaceEvent);
     if (ACPI_FAILURE (Status))
     {
         return -1;
     }
 
+    /* Namespace - Check for non-referenced objects */
+
+    LkFindUnreferencedObjects ();
+    UtEndEvent (AslGbl_NamespaceEvent);
+
     /*
      * Semantic analysis.  This can happen only after the
      * namespace has been loaded and cross-referenced.
@@ -774,24 +898,28 @@ CmCleanupAndExit (
      */
     if (!Gbl_SourceOutputFlag)
     {
-        unlink (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename);
+        remove (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename);
     }
 
     /* Delete AML file if there are errors */
 
     if ((Gbl_ExceptionCount[ASL_ERROR] > 0) && (!Gbl_IgnoreErrors))
     {
-        unlink (Gbl_Files[ASL_FILE_AML_OUTPUT].Filename);
+        remove (Gbl_Files[ASL_FILE_AML_OUTPUT].Filename);
     }
 
     if (Gbl_ExceptionCount[ASL_ERROR] > ASL_MAX_ERROR_COUNT)
     {
-        printf ("\nMaximum error count (%d) exceeded.\n", ASL_MAX_ERROR_COUNT);
+        printf ("\nMaximum error count (%d) exceeded\n", ASL_MAX_ERROR_COUNT);
     }
 
     UtDisplaySummary (ASL_FILE_STDOUT);
 
-    if (Gbl_ExceptionCount[ASL_ERROR] > 0)
+    /*
+     * Return non-zero exit code if there have been errors, unless the
+     * global ignore error flag has been set
+     */
+    if ((Gbl_ExceptionCount[ASL_ERROR] > 0) && (!Gbl_IgnoreErrors))
     {
         exit (1);
     }
diff --git a/sys/contrib/dev/acpica/compiler/aslcompiler.h b/sys/contrib/dev/acpica/compiler/aslcompiler.h
index d3216a6..6477665 100644
--- a/sys/contrib/dev/acpica/compiler/aslcompiler.h
+++ b/sys/contrib/dev/acpica/compiler/aslcompiler.h
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslcompiler.h - common include file for iASL
- *              $Revision: 1.142 $
+ *              $Revision: 1.148 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -307,10 +307,9 @@ void
 AePrintErrorLog (
     UINT32                  FileId);
 
-ACPI_STATUS
+ACPI_PHYSICAL_ADDRESS
 AeLocalGetRootPointer (
-    UINT32                  Flags,
-    ACPI_PHYSICAL_ADDRESS   *RsdpPhysicalAddress);
+    void);
 
 
 /*
@@ -333,6 +332,9 @@ void
 LsDoHexOutput (
     void);
 
+void
+LsDumpParseTree (
+    void);
 
 /*
  * aslfold - constant folding
@@ -607,6 +609,10 @@ ACPI_STATUS
 LkCrossReferenceNamespace (
     void);
 
+void
+LkFindUnreferencedObjects (
+    void);
+
 ACPI_STATUS
 LsDisplayNamespace (
     void);
@@ -760,6 +766,11 @@ RsDoResourceTemplate (
  * aslrestype1 - generate Small descriptors
  */
 ASL_RESOURCE_NODE *
+RsDoEndTagDescriptor (
+    ACPI_PARSE_OBJECT       *Op,
+    UINT32                  CurrentByteOffset);
+
+ASL_RESOURCE_NODE *
 RsDoDmaDescriptor (
     ACPI_PARSE_OBJECT       *Op,
     UINT32                  CurrentByteOffset);
diff --git a/sys/contrib/dev/acpica/compiler/aslcompiler.l b/sys/contrib/dev/acpica/compiler/aslcompiler.l
index e5eb3c5..78be4ea 100644
--- a/sys/contrib/dev/acpica/compiler/aslcompiler.l
+++ b/sys/contrib/dev/acpica/compiler/aslcompiler.l
@@ -3,7 +3,7 @@
 /******************************************************************************
  *
  * Module Name: aslcompiler.l - Flex input file
- *              $Revision: 1.74 $
+ *              $Revision: 1.79 $
  *
  *****************************************************************************/
 
@@ -11,7 +11,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -579,7 +579,7 @@ AslPopInputFileStack (
 
     /* All done with this node */
 
-    ACPI_MEM_FREE (Fnode);
+    ACPI_FREE (Fnode);
     return 0;
 }
 
@@ -926,13 +926,13 @@ comment2 (void)
 char
 literal (void)
 {
-    char                *s = MsgBuffer;
+    char                *StringBuffer = MsgBuffer;
+    char                *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE;
     char                *CleanString;
     char                StringChar;
     UINT32              State = ASL_NORMAL_CHAR;
     UINT32              i = 0;
     UINT8               Digit;
-    UINT8               StringLength = 0;
     char                ConvertBuffer[4];
 
 
@@ -944,17 +944,6 @@ literal (void)
     InsertLineBuffer ('\"');
     while ((StringChar = (char) input()) != EOF)
     {
-        StringLength++;
-        if (StringLength == ACPI_MAX_STRING_CONVERSION)
-        {
-            /* Emit error only once, but keep going */
-
-            AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
-                            Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
-                            Gbl_CurrentLineOffset, Gbl_CurrentColumn,
-                            Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
-        }
-
         InsertLineBuffer (StringChar);
 
 DoCharacter:
@@ -1073,8 +1062,12 @@ DoCharacter:
                 }
                 else
                 {
-                    *s = (char) Digit;
-                    s++;
+                    *StringBuffer = (char) Digit;
+                    StringBuffer++;
+                    if (StringBuffer >= EndBuffer)
+                    {
+                        goto BufferOverflow;
+                    }
                 }
 
                 State = ASL_NORMAL_CHAR;
@@ -1114,8 +1107,12 @@ DoCharacter:
                 }
                 else
                 {
-                    *s = (char) Digit;
-                    s++;
+                    *StringBuffer = (char) Digit;
+                    StringBuffer++;
+                    if (StringBuffer >= EndBuffer)
+                    {
+                        goto BufferOverflow;
+                    }
                 }
 
                 State = ASL_NORMAL_CHAR;
@@ -1132,8 +1129,12 @@ DoCharacter:
 
         /* Save the finished character */
 
-        *s = StringChar;
-        s++;
+        *StringBuffer = StringChar;
+        StringBuffer++;
+        if (StringBuffer >= EndBuffer)
+        {
+            goto BufferOverflow;
+        }
     }
 
     /*
@@ -1150,7 +1151,7 @@ CompletedString:
     /*
      * Null terminate the input string and copy string to a new buffer
      */
-    *s = 0;
+    *StringBuffer = 0;
 
     CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1);
     if (!CleanString)
@@ -1165,6 +1166,17 @@ CompletedString:
     ACPI_STRCPY (CleanString, MsgBuffer);
     AslCompilerlval.s = CleanString;
     return (TRUE);
+
+
+BufferOverflow:
+
+    /* Literal was too long */
+
+    AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
+                    Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
+                    Gbl_CurrentLineOffset, Gbl_CurrentColumn,
+                    Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096");
+    return (FALSE);
 }
 
 
diff --git a/sys/contrib/dev/acpica/compiler/aslcompiler.y b/sys/contrib/dev/acpica/compiler/aslcompiler.y
index d7d9773..0b33d38 100644
--- a/sys/contrib/dev/acpica/compiler/aslcompiler.y
+++ b/sys/contrib/dev/acpica/compiler/aslcompiler.y
@@ -3,7 +3,7 @@
 /******************************************************************************
  *
  * Module Name: aslcompiler.y - Bison input file (ASL grammar and actions)
- *              $Revision: 1.92 $
+ *              $Revision: 1.105 $
  *
  *****************************************************************************/
 
@@ -11,7 +11,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -133,6 +133,19 @@
 #define _COMPONENT          ACPI_COMPILER
         ACPI_MODULE_NAME    ("aslparse")
 
+/*
+ * Global Notes:
+ *
+ * October 2005: The following list terms have been optimized (from the
+ * original ASL grammar in the ACPI specification) to force the immediate
+ * reduction of each list item so that the parse stack use doesn't increase on
+ * each list element and possibly overflow on very large lists (>4000 items).
+ * This dramatically reduces use of the parse stack overall.
+ *
+ *      ArgList, TermList, Objectlist, ByteList, DWordList, PackageList,
+ *      ResourceMacroList, and FieldUnitList
+ */
+
 
 /*
  * Next statement is important - this makes everything public so that
@@ -166,14 +179,20 @@ AslLocalAllocate (unsigned int Size);
  */
 
 %union {
-    UINT64          i;
-    char            *s;
-    ACPI_PARSE_OBJECT  *n;
+    UINT64              i;
+    char                *s;
+    ACPI_PARSE_OBJECT   *n;
 }
 
 
 /*! [Begin] no source code translation */
 
+/*
+ * These shift/reduce conflicts are expected. There should be zer0
+ * reduce/reduce conflicts.
+ */
+%expect 64
+
 
 /*
  * Token types: These are returned by the lexer
@@ -255,6 +274,7 @@ AslLocalAllocate (unsigned int Size);
 %token <i> PARSEOP_ELSE
 %token <i> PARSEOP_ELSEIF
 %token <i> PARSEOP_ENDDEPENDENTFN
+%token <i> PARSEOP_ENDTAG
 %token <i> PARSEOP_ERRORNODE
 %token <i> PARSEOP_EVENT
 %token <i> PARSEOP_EXTENDEDIO
@@ -464,7 +484,6 @@ AslLocalAllocate (unsigned int Size);
 %type <n> NameSpaceModifier
 %type <n> UserTerm
 %type <n> ArgList
-%type <n> ArgListTail
 %type <n> TermArg
 %type <n> Target
 %type <n> RequiredTarget
@@ -494,7 +513,6 @@ AslLocalAllocate (unsigned int Size);
 %type <n> ExternalTerm
 
 %type <n> FieldUnitList
-%type <n> FieldUnitListTail
 %type <n> FieldUnit
 %type <n> FieldUnitEntry
 
@@ -552,8 +570,8 @@ AslLocalAllocate (unsigned int Size);
 %type <n> SleepTerm
 %type <n> StallTerm
 %type <n> SwitchTerm
-%type <n> CaseTermList
-%type <n> DefaultTermList
+%type <n> CaseDefaultTermList
+//%type <n> CaseTermList
 %type <n> CaseTerm
 %type <n> DefaultTerm
 %type <n> UnloadTerm
@@ -652,19 +670,11 @@ AslLocalAllocate (unsigned int Size);
 %type <n> LocalTerm
 %type <n> DebugTerm
 
-
 %type <n> Integer
-
 %type <n> ByteConst
 %type <n> WordConst
 %type <n> DWordConst
 %type <n> QWordConst
-
-/* Useless
-%type <n> WordConst
-%type <n> QWordConst
-*/
-
 %type <n> String
 
 %type <n> ConstTerm
@@ -676,13 +686,10 @@ AslLocalAllocate (unsigned int Size);
 
 %type <n> BufferTerm
 %type <n> ByteList
-%type <n> ByteListTail
 %type <n> DWordList
-%type <n> DWordListTail
 
 %type <n> PackageTerm
 %type <n> PackageList
-%type <n> PackageListTail
 %type <n> PackageElement
 
 %type <n> VarPackageLengthTerm
@@ -802,8 +809,8 @@ DefinitionBlockTerm
 
 TermList
     :                               {$$ = NULL;}
-    | Term TermList                 {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);}
-    | Term ';' TermList             {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);}
+    | TermList Term                 {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);}
+    | TermList ';' Term             {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);}
     ;
 
 Term
@@ -826,7 +833,7 @@ CompilerDirective
 
 ObjectList
     :                               {$$ = NULL;}
-    | Object ObjectList             {$$ = TrLinkPeerNode ($1,$2);}
+    | ObjectList Object             {$$ = TrLinkPeerNode ($1,$2);}
     | error                         {$$ = AslDoError(); yyclearin;}
     ;
 
@@ -901,21 +908,23 @@ UserTerm
 
 ArgList
     :                               {$$ = NULL;}
-    | TermArg ArgListTail           {$$ = TrLinkPeerNode ($1,$2);}
-    ;
-
-ArgListTail
-    :                               {$$ = NULL;}
-    | ',' TermArg ArgListTail       {$$ = TrLinkPeerNode ($2,$3);}
-    | ','                           {$$ = NULL;}   /* Allows a trailing comma at list end */
+    | TermArg
+    | ArgList ','                   /* Allows a trailing comma at list end */
+    | ArgList ','
+        TermArg                     {$$ = TrLinkPeerNode ($1,$3);}
     ;
 
-TermArg
-    : Type2Opcode                   {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
+/*
+Removed from TermArg due to reduce/reduce conflicts
     | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
     | Type2StringOpcode             {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
     | Type2BufferOpcode             {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
     | Type2BufferOrStringOpcode     {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
+
+*/
+
+TermArg
+    : Type2Opcode                   {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
     | DataObject                    {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
     | NameString                    {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
     | ArgTerm                       {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
@@ -938,61 +947,43 @@ SimpleTarget
     | ArgTerm                       {}
     ;
 
-/* Rules for specifying the Return type for control methods */
+/* Rules for specifying the type of one method argument or return value */
 
 ParameterTypePackage
     :                               {$$ = NULL;}
     | ObjectTypeKeyword             {$$ = $1;}
-    | '{''}'                        {$$ = NULL;}
-    | '{'
-        ObjectTypeKeyword
-      '}'                           {$$ = $2;}
-    | '{'
-        ParameterTypePackageList
-      '}'                           {$$ = $2;}
+    | ParameterTypePackage ','
+        ObjectTypeKeyword           {$$ = TrLinkPeerNodes (2,$1,$3);}
     ;
 
 ParameterTypePackageList
     :                               {$$ = NULL;}
     | ObjectTypeKeyword             {$$ = $1;}
-    | ObjectTypeKeyword ','
-        ParameterTypePackageList    {$$ = TrLinkPeerNodes (2,$1,$3);}
+    | '{' ParameterTypePackage '}'  {$$ = $2;}
     ;
 
 OptionalParameterTypePackage
     :                               {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
-    | ','                           {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
-    | ',' ParameterTypePackage      {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
+    | ',' ParameterTypePackageList  {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
     ;
 
-/* Rules for specifying the Argument types for control methods */
+/* Rules for specifying the types for method arguments */
 
 ParameterTypesPackage
-    :                               {$$ = NULL;}
-    | ObjectTypeKeyword             {$$ = $1;}
-    | '{''}'                        {$$ = NULL;}
-    | '{'
-        ObjectTypeKeyword
-      '}'                           {$$ = $2;}
-    | '{'
-        ParameterTypesPackageList
-      '}'                           {$$ = $2;}
+    : ParameterTypePackageList      {$$ = $1;}
+    | ParameterTypesPackage ','
+        ParameterTypePackageList    {$$ = TrLinkPeerNodes (2,$1,$3);}
     ;
 
 ParameterTypesPackageList
     :                               {$$ = NULL;}
     | ObjectTypeKeyword             {$$ = $1;}
-    | ParameterTypesPackage         {$$ = $1;}
-    | ParameterTypesPackage ','
-        ParameterTypesPackageList   {$$ = TrLinkPeerNodes (2,$1,$3);}
-    | ParameterTypesPackage ','
-        ParameterTypesPackage       {$$ = TrLinkPeerNodes (2,$1,$3);}
+    | '{' ParameterTypesPackage '}' {$$ = $2;}
     ;
 
 OptionalParameterTypesPackage
     :                               {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
-    | ','                           {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
-    | ',' ParameterTypesPackage     {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
+    | ',' ParameterTypesPackageList {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
     ;
 
 
@@ -1172,14 +1163,9 @@ BankFieldTerm
 FieldUnitList
     :                               {$$ = NULL;}
     | FieldUnit
-        FieldUnitListTail           {$$ = TrLinkPeerNode ($1,$2);}
-    ;
-
-FieldUnitListTail
-    :                               {$$ = NULL;}
-    | ','                           {$$ = NULL;}  /* Allows a trailing comma at list end */
-    | ',' FieldUnit
-            FieldUnitListTail       {$$ = TrLinkPeerNode ($2,$3);}
+    | FieldUnitList ','             /* Allows a trailing comma at list end */
+    | FieldUnitList ','
+        FieldUnit                   {$$ = TrLinkPeerNode ($1,$3);}
     ;
 
 FieldUnit
@@ -1475,8 +1461,8 @@ IfTerm
     : PARSEOP_IF '('				{$$ = TrCreateLeafNode (PARSEOP_IF);}
         TermArg
         ')' '{'
-            TermList '}'
-                                    {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
+            TermList '}'            {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
+
     | PARSEOP_IF '('
         error ')'                   {$$ = AslDoError(); yyclearin;}
     ;
@@ -1484,19 +1470,26 @@ IfTerm
 ElseTerm
     :                               {$$ = NULL;}
     | PARSEOP_ELSE '{'				{$$ = TrCreateLeafNode (PARSEOP_ELSE);}
-        TermList '}'
-                                    {$$ = TrLinkChildren ($<n>3,1,$4);}
+        TermList '}'                {$$ = TrLinkChildren ($<n>3,1,$4);}
+
     | PARSEOP_ELSE '{'
         error '}'                   {$$ = AslDoError(); yyclearin;}
 
+    | PARSEOP_ELSE
+        error                       {$$ = AslDoError(); yyclearin;}
+
     | PARSEOP_ELSEIF '('			{$$ = TrCreateLeafNode (PARSEOP_ELSE);}
         TermArg						{$$ = TrCreateLeafNode (PARSEOP_IF);}
         ')' '{'
-        TermList '}'			    {$$ = TrLinkChildren ($<n>5,2,$4,$8);}
+            TermList '}'		    {$$ = TrLinkChildren ($<n>5,2,$4,$8);}
         ElseTerm                    {$$ = TrLinkPeerNode ($<n>5,$11);}
                                     {$$ = TrLinkChildren ($<n>3,1,$<n>5);}
+
     | PARSEOP_ELSEIF '('
         error ')'                   {$$ = AslDoError(); yyclearin;}
+
+    | PARSEOP_ELSEIF
+        error                       {$$ = AslDoError(); yyclearin;}
     ;
 
 LoadTerm
@@ -1574,27 +1567,44 @@ SwitchTerm
     : PARSEOP_SWITCH '('			{$$ = TrCreateLeafNode (PARSEOP_SWITCH);}
         TermArg
         ')' '{'
-            CaseTermList '}'
+            CaseDefaultTermList '}'
                                     {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
     | PARSEOP_SWITCH '('
         error ')'                   {$$ = AslDoError(); yyclearin;}
     ;
 
-CaseTermList
+/*
+ * Case-Default list; allow only one Default term and unlimited Case terms
+ */
+
+CaseDefaultTermList
     :                               {$$ = NULL;}
-    | CaseTerm                      {}
-    | DefaultTerm
-        DefaultTermList             {$$ = TrLinkPeerNode ($1,$2);}
-    | CaseTerm
-        CaseTermList                {$$ = TrLinkPeerNode ($1,$2);}
+    | CaseTerm  {}
+    | DefaultTerm   {}
+    | CaseDefaultTermList
+        CaseTerm                    {$$ = TrLinkPeerNode ($1,$2);}
+    | CaseDefaultTermList
+        DefaultTerm                 {$$ = TrLinkPeerNode ($1,$2);}
+
+/* Original - attempts to force zero or one default term within the switch */
+
+/*
+CaseDefaultTermList
+    :                               {$$ = NULL;}
+    | CaseTermList
+        DefaultTerm
+        CaseTermList                {$$ = TrLinkPeerNode ($1,TrLinkPeerNode ($2, $3));}
+    | CaseTermList
+        CaseTerm                    {$$ = TrLinkPeerNode ($1,$2);}
     ;
 
-DefaultTermList
+CaseTermList
     :                               {$$ = NULL;}
     | CaseTerm                      {}
-    | CaseTerm
-        DefaultTermList             {$$ = TrLinkPeerNode ($1,$2);}
+    | CaseTermList
+        CaseTerm                    {$$ = TrLinkPeerNode ($1,$2);}
     ;
+*/
 
 CaseTerm
     : PARSEOP_CASE '('				{$$ = TrCreateLeafNode (PARSEOP_CASE);}
@@ -2405,27 +2415,17 @@ BufferTermData
 ByteList
     :                               {$$ = NULL;}
     | ByteConstExpr
-        ByteListTail                {$$ = TrLinkPeerNode ($1,$2);}
-    ;
-
-ByteListTail
-    :                               {$$ = NULL;}
-    |  ','                          {$$ = NULL;}   /* Allows a trailing comma at list end */
-    |  ',' ByteConstExpr
-         ByteListTail               {$$ = TrLinkPeerNode ($2,$3);}
+    | ByteList ','                  /* Allows a trailing comma at list end */
+    | ByteList ','
+        ByteConstExpr               {$$ = TrLinkPeerNode ($1,$3);}
     ;
 
 DWordList
     :                               {$$ = NULL;}
     | DWordConstExpr
-        DWordListTail               {$$ = TrLinkPeerNode ($1,$2);}
-    ;
-
-DWordListTail
-    :                               {$$ = NULL;}
-    | ','                           {$$ = NULL;}   /* Allows a trailing comma at list end */
-    | ',' DWordConstExpr
-        DWordListTail               {$$ = TrLinkPeerNode ($2,$3);}
+    | DWordList ','                 /* Allows a trailing comma at list end */
+    | DWordList ','
+        DWordConstExpr              {$$ = TrLinkPeerNode ($1,$3);}
     ;
 
 PackageTerm
@@ -2445,14 +2445,9 @@ VarPackageLengthTerm
 PackageList
     :                               {$$ = NULL;}
     | PackageElement
-        PackageListTail             {$$ = TrLinkPeerNode ($1,$2);}
-    ;
-
-PackageListTail
-    :                               {$$ = NULL;}
-    | ','                           {$$ = NULL;}   /* Allows a trailing comma at list end */
-    | ',' PackageElement
-        PackageListTail             {$$ = TrLinkPeerNode ($2,$3);}
+    | PackageList ','               /* Allows a trailing comma at list end */
+    | PackageList ','
+        PackageElement              {$$ = TrLinkPeerNode ($1,$3);}
     ;
 
 PackageElement
@@ -2471,12 +2466,18 @@ EISAIDTerm
 /******* Resources and Memory ***********************************************/
 
 
+/*
+ * Note: Create two default nodes to allow conversion to a Buffer AML opcode
+ * Also, insert the EndTag at the end of the template.
+ */
 ResourceTemplateTerm
     : PARSEOP_RESOURCETEMPLATE '(' ')'
         '{'
-        ResourceMacroList '}'       {$$ = TrCreateNode (PARSEOP_RESOURCETEMPLATE,3,
+        ResourceMacroList '}'       {$$ = TrCreateNode (PARSEOP_RESOURCETEMPLATE,4,
                                           TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
-                                          TrCreateLeafNode (PARSEOP_DEFAULT_ARG),$5);}
+                                          TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
+                                          $5,
+                                          TrCreateLeafNode (PARSEOP_ENDTAG));}
     ;
 
 UnicodeTerm
@@ -2489,8 +2490,8 @@ UnicodeTerm
 
 ResourceMacroList
     :                               {$$ = NULL;}
-    | ResourceMacroTerm
-        ResourceMacroList           {$$ = TrLinkPeerNode ($1,$2);}
+    | ResourceMacroList
+        ResourceMacroTerm           {$$ = TrLinkPeerNode ($1,$2);}
     ;
 
 ResourceMacroTerm
@@ -2841,7 +2842,8 @@ RegisterTerm
         ',' ByteConstExpr
         ',' QWordConstExpr
         OptionalAccessSize
-        ')'                         {$$ = TrLinkChildren ($<n>3,5,$4,$6,$8,$10,$11);}
+        OptionalNameString_Last
+        ')'                         {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$11,$12);}
     | PARSEOP_REGISTER '('
         error ')'                   {$$ = AslDoError(); yyclearin;}
     ;
@@ -2947,10 +2949,14 @@ WordSpaceTerm
 
 /******* Object References ***********************************************/
 
+/* Allow IO, DMA, IRQ Resource macro names to also be used as identifiers */
 
 NameString
     : NameSeg                       {}
     | PARSEOP_NAMESTRING            {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) AslCompilerlval.s);}
+    | PARSEOP_IO                    {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IO");}
+    | PARSEOP_DMA                   {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "DMA");}
+    | PARSEOP_IRQ                   {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IRQ");}
     ;
 
 NameSeg
@@ -3160,7 +3166,7 @@ AslLocalAllocate (unsigned int Size)
 
     DbgPrint (ASL_PARSE_OUTPUT, "\nAslLocalAllocate: Expanding Stack to %d\n\n", Size);
 
-    Mem = ACPI_MEM_CALLOCATE (Size);
+    Mem = ACPI_ALLOCATE_ZEROED (Size);
     if (!Mem)
     {
         AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
diff --git a/sys/contrib/dev/acpica/compiler/asldefine.h b/sys/contrib/dev/acpica/compiler/asldefine.h
index 0f3a2f4..29f3568 100644
--- a/sys/contrib/dev/acpica/compiler/asldefine.h
+++ b/sys/contrib/dev/acpica/compiler/asldefine.h
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: asldefine.h - Common defines for the iASL compiler
- *              $Revision: 1.4 $
+ *              $Revision: 1.7 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -128,8 +128,8 @@
 #define IntelAcpiCA                 "Intel ACPI Component Architecture"
 #define CompilerId                  "ASL Optimizing Compiler"
 #define DisassemblerId              "AML Disassembler"
-#define CompilerCopyright           "Copyright (C) 2000 - 2005 Intel Corporation"
-#define CompilerCompliance          "Supports ACPI Specification Revision 3.0"
+#define CompilerCopyright           "Copyright (C) 2000 - 2007 Intel Corporation"
+#define CompilerCompliance          "Supports ACPI Specification Revision 3.0a"
 #define CompilerName                "iasl"
 #define CompilerCreatorId           "INTL"
 
diff --git a/sys/contrib/dev/acpica/compiler/aslerror.c b/sys/contrib/dev/acpica/compiler/aslerror.c
index 7031fde..7600158 100644
--- a/sys/contrib/dev/acpica/compiler/aslerror.c
+++ b/sys/contrib/dev/acpica/compiler/aslerror.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslerror - Error handling and statistics
- *              $Revision: 1.88 $
+ *              $Revision: 1.92 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -503,7 +503,7 @@ AslCommonError (
     Gbl_ExceptionCount[Level]++;
     if (Gbl_ExceptionCount[ASL_ERROR] > ASL_MAX_ERROR_COUNT)
     {
-        printf ("\nMaximum error count (%d) exceeded.\n", ASL_MAX_ERROR_COUNT);
+        printf ("\nMaximum error count (%d) exceeded\n", ASL_MAX_ERROR_COUNT);
 
         Gbl_SourceLine = 0;
         Gbl_NextError = Gbl_ErrorLog;
@@ -539,6 +539,21 @@ AslError (
     char                    *ExtraMessage)
 {
 
+    switch (Level)
+    {
+    case ASL_WARNING2:
+    case ASL_WARNING3:
+        if (Gbl_WarningLevel < Level)
+        {
+            return;
+        }
+        break;
+
+    default:
+        break;
+    }
+
+
     if (Op)
     {
         AslCommonError (Level, MessageId, Op->Asl.LineNumber,
diff --git a/sys/contrib/dev/acpica/compiler/aslfiles.c b/sys/contrib/dev/acpica/compiler/aslfiles.c
index 7fd26f8..9eace43 100644
--- a/sys/contrib/dev/acpica/compiler/aslfiles.c
+++ b/sys/contrib/dev/acpica/compiler/aslfiles.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslfiles - file I/O suppoert
- *              $Revision: 1.52 $
+ *              $Revision: 1.54 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
diff --git a/sys/contrib/dev/acpica/compiler/aslfold.c b/sys/contrib/dev/acpica/compiler/aslfold.c
index 8ee845f..d744021 100644
--- a/sys/contrib/dev/acpica/compiler/aslfold.c
+++ b/sys/contrib/dev/acpica/compiler/aslfold.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslfold - Constant folding
- *              $Revision: 1.18 $
+ *              $Revision: 1.20 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
diff --git a/sys/contrib/dev/acpica/compiler/aslglobal.h b/sys/contrib/dev/acpica/compiler/aslglobal.h
index 3b3306d..07e8a46 100644
--- a/sys/contrib/dev/acpica/compiler/aslglobal.h
+++ b/sys/contrib/dev/acpica/compiler/aslglobal.h
@@ -3,7 +3,7 @@
 /******************************************************************************
  *
  * Module Name: aslglobal.h - Global variable definitions
- *              $Revision: 1.50 $
+ *              $Revision: 1.56 $
  *
  *****************************************************************************/
 
@@ -11,7 +11,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -147,7 +147,7 @@ extern char                         *AslCompilertext;
 extern char                         hex[];
 
 #define ASL_LINE_BUFFER_SIZE        512
-#define ASL_MSG_BUFFER_SIZE         (ASL_LINE_BUFFER_SIZE * 2)
+#define ASL_MSG_BUFFER_SIZE         4096
 #define HEX_TABLE_LINE_SIZE         8
 #define HEX_LISTING_LINE_SIZE       16
 
@@ -172,7 +172,6 @@ extern UINT32                       Gbl_ExceptionCount[];
 /* Option flags */
 
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_Acpi2, FALSE);
-ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_CheckForAscii, FALSE);
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_UseDefaultAmlFilename, TRUE);
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_NsOutputFlag, FALSE);
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_DebugFlag, FALSE);
@@ -182,7 +181,6 @@ ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_AsmIncludeOutputFlag, F
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_C_IncludeOutputFlag, FALSE);
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_ListingFlag, FALSE);
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_IgnoreErrors, FALSE);
-ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_GenerateExternals, FALSE);
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_SourceOutputFlag, FALSE);
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_ParseOnlyFlag, FALSE);
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_CompileTimesFlag, FALSE);
@@ -194,6 +192,8 @@ ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_IntegerOptimizationFlag
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_ReferenceOptimizationFlag, TRUE);
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_DisplayRemarks, TRUE);
 ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_DisplayOptimizations, FALSE);
+ASL_EXTERN UINT8                    ASL_INIT_GLOBAL (Gbl_WarningLevel, ASL_WARNING);
+
 
 #define HEX_OUTPUT_NONE         0
 #define HEX_OUTPUT_C            1
@@ -206,6 +206,7 @@ ASL_EXTERN BOOLEAN                  ASL_INIT_GLOBAL (Gbl_HexOutputFlag, HEX_OUTP
 ASL_EXTERN ASL_FILE_INFO            Gbl_Files [ASL_NUM_FILES];
 
 ASL_EXTERN char                     *Gbl_DirectoryPath;
+ASL_EXTERN char                     ASL_INIT_GLOBAL (*Gbl_ExternalFilename, NULL);
 ASL_EXTERN char                     ASL_INIT_GLOBAL (*Gbl_IncludeFilename, NULL);
 ASL_EXTERN char                     ASL_INIT_GLOBAL (*Gbl_OutputFilenamePrefix, NULL);
 ASL_EXTERN char                     *Gbl_CurrentInputFilename;
diff --git a/sys/contrib/dev/acpica/compiler/asllength.c b/sys/contrib/dev/acpica/compiler/asllength.c
index 7d44ff0..056aaeb 100644
--- a/sys/contrib/dev/acpica/compiler/asllength.c
+++ b/sys/contrib/dev/acpica/compiler/asllength.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: asllength - Tree walk to determine package and opcode lengths
- *              $Revision: 1.35 $
+ *              $Revision: 1.37 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
diff --git a/sys/contrib/dev/acpica/compiler/asllisting.c b/sys/contrib/dev/acpica/compiler/asllisting.c
index a83b18c..31f70b8 100644
--- a/sys/contrib/dev/acpica/compiler/asllisting.c
+++ b/sys/contrib/dev/acpica/compiler/asllisting.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: asllisting - Listing file generation
- *              $Revision: 1.58 $
+ *              $Revision: 1.63 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -202,6 +202,54 @@ LsDoHexOutputAsm (
 
 /*******************************************************************************
  *
+ * FUNCTION:    LsTreeWriteWalk
+ *
+ * PARAMETERS:  ASL_WALK_CALLBACK
+ *
+ *
+ * RETURN:      None.
+ *
+ * DESCRIPTION: Dump entire parse tree, for compiler debug only
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+LsTreeWriteWalk (
+    ACPI_PARSE_OBJECT       *Op,
+    UINT32                  Level,
+    void                    *Context)
+{
+
+    /* Debug output */
+
+    DbgPrint (ASL_TREE_OUTPUT,
+        "%5.5d [%2d]", Op->Asl.LogicalLineNumber, Level);
+    UtPrintFormattedName (Op->Asl.ParseOpcode, Level);
+
+
+    DbgPrint (ASL_TREE_OUTPUT, "\n");
+    return (AE_OK);
+}
+
+
+void
+LsDumpParseTree (
+    void)
+{
+
+    if (!Gbl_DebugFlag)
+    {
+        return;
+    }
+
+    DbgPrint (ASL_TREE_OUTPUT, "\nOriginal parse tree from parser:\n\n");
+    TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD,
+        LsTreeWriteWalk, NULL, NULL);
+}
+
+
+/*******************************************************************************
+ *
  * FUNCTION:    LsDumpAscii
  *
  * PARAMETERS:  FileId          - ID of current listing file
@@ -319,11 +367,18 @@ LsAmlListingWalk (
 {
     UINT8                   FileByte;
     UINT32                  i;
-    UINT32                  FileId = (UINT32) Context;
+    UINT32                  FileId = (UINT32) ACPI_TO_INTEGER (Context);
 
 
     LsWriteNodeToListing (Op, FileId);
 
+    if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DATA)
+    {
+        /* Buffer is a resource template, don't dump the data all at once */
+
+        return (AE_OK);
+    }
+
     /* Write the hex bytes to the listing file(s) (if requested) */
 
     for (i = 0; i < Op->Asl.FinalAmlLength; i++)
@@ -491,7 +546,7 @@ LsPopNode (
     }
 
     Gbl_ListingNode = Lnode->Next;
-    ACPI_MEM_FREE (Lnode);
+    ACPI_FREE (Lnode);
 
     /* New "Current" node is the new head */
 
@@ -1081,6 +1136,12 @@ LsWriteNodeToListing (
 
 
     case PARSEOP_DEFAULT_ARG:
+
+        if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
+        {
+            LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.EndLogicalLine,
+                FileId);
+        }
         return;
 
 
@@ -1109,7 +1170,6 @@ LsWriteNodeToListing (
         case AML_FIELD_OP:
         case AML_INDEX_FIELD_OP:
         case AML_BANK_FIELD_OP:
-        case AML_NAME_OP:
 
             /*
              * For fields, we want to dump all the AML after the
@@ -1119,6 +1179,24 @@ LsWriteNodeToListing (
                 FileId);
             break;
 
+        case AML_NAME_OP:
+
+            if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
+            {
+                LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
+                    FileId);
+            }
+            else
+            {
+                /*
+                 * For fields, we want to dump all the AML after the
+                 * entire definition
+                 */
+                LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine,
+                    FileId);
+            }
+            break;
+
         default:
             LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
                 FileId);
@@ -1194,7 +1272,7 @@ LsWriteNodeToListing (
                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
                         }
                     }
-                    ACPI_MEM_FREE (Pathname);
+                    ACPI_FREE (Pathname);
                 }
                 break;
 
@@ -1209,6 +1287,12 @@ LsWriteNodeToListing (
     case AML_CLASS_CREATE:
     default:
 
+        if ((Op->Asl.ParseOpcode == PARSEOP_BUFFER) &&
+            (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC))
+        {
+            return;
+        }
+
         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
             FileId);
         break;
diff --git a/sys/contrib/dev/acpica/compiler/aslload.c b/sys/contrib/dev/acpica/compiler/aslload.c
index f3e75be..ebbc487 100644
--- a/sys/contrib/dev/acpica/compiler/aslload.c
+++ b/sys/contrib/dev/acpica/compiler/aslload.c
@@ -1,7 +1,7 @@
 /******************************************************************************
  *
  * Module Name: dswload - Dispatcher namespace load callbacks
- *              $Revision: 1.71 $
+ *              $Revision: 1.77 $
  *
  *****************************************************************************/
 
@@ -9,7 +9,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -341,6 +341,9 @@ LdLoadResourceElements (
         return (Status);
     }
 
+    Node->Value = (UINT32) Op->Asl.Value.Integer;
+    Node->Op = Op;
+
     /*
      * Now enter the predefined fields, for easy lookup when referenced
      * by the source ASL
@@ -412,9 +415,10 @@ LdNamespace1Begin (
     UINT32                  Flags = ACPI_NS_NO_UPSEARCH;
     ACPI_PARSE_OBJECT       *Arg;
     UINT32                  i;
+    BOOLEAN                 ForceNewScope = FALSE;
 
 
-    ACPI_FUNCTION_NAME ("LdNamespace1Begin");
+    ACPI_FUNCTION_NAME (LdNamespace1Begin);
     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op %p [%s]\n",
         Op, Op->Asl.ParseOpName));
 
@@ -460,6 +464,16 @@ LdNamespace1Begin (
         Arg = Op->Asl.Child;  /* Get the NameSeg/NameString node */
         Arg = Arg->Asl.Next;  /* First peer is the object to be associated with the name */
 
+        /*
+         * If this name refers to a ResourceTemplate, we will need to open
+         * a new scope so that the resource subfield names can be entered into
+         * the namespace underneath this name
+         */
+        if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
+        {
+            ForceNewScope = TRUE;
+        }
+
         /* Get the data type associated with the named object, not the name itself */
 
         /* Log2 loop to convert from Btype (binary) to Etype (encoded) */
@@ -483,12 +497,30 @@ LdNamespace1Begin (
          */
         ActualObjectType = (UINT8) Op->Asl.Child->Asl.Next->Asl.Value.Integer;
         ObjectType = ACPI_TYPE_ANY;
-        break;
 
+        /*
+         * We will mark every new node along the path as "External". This
+         * allows some or all of the nodes to be created later in the ASL
+         * code. Handles cases like this:
+         *
+         *   External (\_SB_.PCI0.ABCD, IntObj)
+         *   Scope (_SB_)
+         *   {
+         *       Device (PCI0)
+         *       {
+         *       }
+         *   }
+         *   Method (X)
+         *   {
+         *       Store (\_SB_.PCI0.ABCD, Local0)
+         *   }
+         */
+        Flags |= ACPI_NS_EXTERNAL;
+        break;
 
     case PARSEOP_DEFAULT_ARG:
 
-        if(Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC)
+        if (Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC)
         {
             Status = LdLoadResourceElements (Op, WalkState);
             goto Exit;
@@ -626,7 +658,7 @@ LdNamespace1Begin (
      * parse tree later.
      */
     Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
-                    ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &(Node));
+                    ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);
     if (ACPI_FAILURE (Status))
     {
         if (Status == AE_ALREADY_EXISTS)
@@ -635,11 +667,36 @@ LdNamespace1Begin (
 
             if (Node->Type == ACPI_TYPE_LOCAL_SCOPE)
             {
+                /* Allow multiple references to the same scope */
+
                 Node->Type = (UINT8) ObjectType;
                 Status = AE_OK;
             }
+            else if (Node->Flags & ANOBJ_IS_EXTERNAL)
+            {
+                /*
+                 * Allow one create on an object or segment that was
+                 * previously declared External
+                 */
+                Node->Flags &= ~ANOBJ_IS_EXTERNAL;
+                Node->Type = (UINT8) ObjectType;
+
+                /* Just retyped a node, probably will need to open a scope */
+
+                if (AcpiNsOpensScope (ObjectType))
+                {
+                    Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
+                    if (ACPI_FAILURE (Status))
+                    {
+                        return_ACPI_STATUS (Status);
+                    }
+                }
+                Status = AE_OK;
+            }
             else
             {
+                /* Valid error, object already exists */
+
                 AslError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Op,
                     Op->Asl.ExternalName);
                 Status = AE_OK;
@@ -654,6 +711,14 @@ LdNamespace1Begin (
         }
     }
 
+    if (ForceNewScope)
+    {
+        Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
+        if (ACPI_FAILURE (Status))
+        {
+            return_ACPI_STATUS (Status);
+        }
+    }
 
 FinishNode:
     /*
@@ -706,9 +771,10 @@ LdNamespace1End (
 {
     ACPI_WALK_STATE         *WalkState = (ACPI_WALK_STATE *) Context;
     ACPI_OBJECT_TYPE        ObjectType;
+    BOOLEAN                 ForceNewScope = FALSE;
 
 
-    ACPI_FUNCTION_NAME ("LdNamespace1End");
+    ACPI_FUNCTION_NAME (LdNamespace1End);
 
 
     /* We are only interested in opcodes that have an associated name */
@@ -732,9 +798,19 @@ LdNamespace1End (
         ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);
     }
 
+    /* Pop scope that was pushed for Resource Templates */
+
+    if (Op->Asl.ParseOpcode == PARSEOP_NAME)
+    {
+        if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
+        {
+            ForceNewScope = TRUE;
+        }
+    }
+
     /* Pop the scope stack */
 
-    if (AcpiNsOpensScope (ObjectType))
+    if (ForceNewScope || AcpiNsOpensScope (ObjectType))
     {
 
         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
diff --git a/sys/contrib/dev/acpica/compiler/asllookup.c b/sys/contrib/dev/acpica/compiler/asllookup.c
index 750d53b..a970f12 100644
--- a/sys/contrib/dev/acpica/compiler/asllookup.c
+++ b/sys/contrib/dev/acpica/compiler/asllookup.c
@@ -1,7 +1,7 @@
 /******************************************************************************
  *
  * Module Name: asllookup- Namespace lookup
- *              $Revision: 1.95 $
+ *              $Revision: 1.103 $
  *
  *****************************************************************************/
 
@@ -9,7 +9,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -167,6 +167,13 @@ LkNamespaceLocateEnd (
     UINT32                  Level,
     void                    *Context);
 
+static ACPI_STATUS
+LkIsObjectUsed (
+    ACPI_HANDLE             ObjHandle,
+    UINT32                  Level,
+    void                    *Context,
+    void                    **ReturnValue);
+
 
 /*******************************************************************************
  *
@@ -196,9 +203,9 @@ LsDoOneNamespaceObject (
     Gbl_NumNamespaceObjects++;
 
     FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT, "%5d  [%d]  %*s %4.4s - %s",
-                        Gbl_NumNamespaceObjects, Level, (Level * 3), " ",
-                        &Node->Name,
-                        AcpiUtGetTypeName (Node->Type));
+        Gbl_NumNamespaceObjects, Level, (Level * 3), " ",
+        &Node->Name,
+        AcpiUtGetTypeName (Node->Type));
 
     Op = Node->Op;
     ObjDesc = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Node->Object);
@@ -211,7 +218,7 @@ LsDoOneNamespaceObject (
 
 
     if ((ObjDesc) &&
-        (ObjDesc->Common.Descriptor == ACPI_DESC_TYPE_OPERAND))
+        (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND))
     {
         switch (Node->Type)
         {
@@ -358,7 +365,7 @@ LsDoOneNamespaceObject (
             }
             Op = Op->Asl.Child;
 
-            if (Op->Asl.ParseOpcode == PARSEOP_INTEGER)
+            if (Op && (Op->Asl.ParseOpcode == PARSEOP_INTEGER))
             {
                 FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
                     "        [Initial Length  0x%.2X bytes]",
@@ -375,6 +382,29 @@ LsDoOneNamespaceObject (
             break;
 
 
+        case ACPI_TYPE_LOCAL_RESOURCE:
+
+            FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
+                "  [Desc Offset     0x%.4X Bytes]", Node->Value);
+            break;
+
+
+        case ACPI_TYPE_LOCAL_RESOURCE_FIELD:
+
+            if (Node->Flags & 0x80)
+            {
+                FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
+                    "   [Field Offset    0x%.4X Bits 0x%.4X Bytes]",
+                    Node->Value, Node->Value / 8);
+            }
+            else
+            {
+                FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT,
+                    "   [Field Offset    0x%.4X Bytes]", Node->Value);
+            }
+            break;
+
+
         default:
             /* Nothing to do for other types */
             break;
@@ -386,6 +416,15 @@ LsDoOneNamespaceObject (
 }
 
 
+void
+LsSetupNsList (void * Handle)
+{
+
+    Gbl_NsOutputFlag = TRUE;
+    Gbl_Files[ASL_FILE_NAMESPACE_OUTPUT].Handle = Handle;
+}
+
+
 /*******************************************************************************
  *
  * FUNCTION:    LsDisplayNamespace
@@ -412,6 +451,8 @@ LsDisplayNamespace (
         return (AE_OK);
     }
 
+    Gbl_NumNamespaceObjects = 0;
+
     /* File header */
 
     FlPrintFile (ASL_FILE_NAMESPACE_OUTPUT, "Contents of ACPI Namespace\n\n");
@@ -498,6 +539,153 @@ LkObjectExists (
 
 /*******************************************************************************
  *
+ * FUNCTION:    LkGetNameOp
+ *
+ * PARAMETERS:  Op              - Current Op
+ *
+ * RETURN:      NameOp associated with the input op
+ *
+ * DESCRIPTION: Find the name declaration op associated with the operator
+ *
+ ******************************************************************************/
+
+ACPI_PARSE_OBJECT *
+LkGetNameOp (
+    ACPI_PARSE_OBJECT       *Op)
+{
+    const ACPI_OPCODE_INFO  *OpInfo;
+    ACPI_PARSE_OBJECT       *NameOp = Op;
+
+
+    OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
+
+
+    /* Get the NamePath from the appropriate place */
+
+    if (OpInfo->Flags & AML_NAMED)
+    {
+        /* For nearly all NAMED operators, the name reference is the first child */
+
+        NameOp = Op->Asl.Child;
+        if (Op->Asl.AmlOpcode == AML_ALIAS_OP)
+        {
+            /*
+             * ALIAS is the only oddball opcode, the name declaration
+             * (alias name) is the second operand
+             */
+            NameOp = Op->Asl.Child->Asl.Next;
+        }
+    }
+    else if (OpInfo->Flags & AML_CREATE)
+    {
+        /* Name must appear as the last parameter */
+
+        NameOp = Op->Asl.Child;
+        while (!(NameOp->Asl.CompileFlags & NODE_IS_NAME_DECLARATION))
+        {
+            NameOp = NameOp->Asl.Next;
+        }
+    }
+
+    return (NameOp);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    LkIsObjectUsed
+ *
+ * PARAMETERS:  ACPI_WALK_CALLBACK
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Check for an unreferenced namespace object and emit a warning.
+ *              We have to be careful, because some types and names are
+ *              typically or always unreferenced, we don't want to issue
+ *              excessive warnings.
+ *
+ ******************************************************************************/
+
+static ACPI_STATUS
+LkIsObjectUsed (
+    ACPI_HANDLE             ObjHandle,
+    UINT32                  Level,
+    void                    *Context,
+    void                    **ReturnValue)
+{
+    ACPI_NAMESPACE_NODE     *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle);
+
+
+    /* Referenced flag is set during the namespace xref */
+
+    if (Node->Flags & ANOBJ_IS_REFERENCED)
+    {
+        return (AE_OK);
+    }
+
+    /*
+     * Ignore names that start with an underscore,
+     * these are the reserved ACPI names and are typically not referenced,
+     * they are called by the host OS.
+     */
+    if (Node->Name.Ascii[0] == '_')
+    {
+        return (AE_OK);
+    }
+
+    /* There are some types that are typically not referenced, ignore them */
+
+    switch (Node->Type)
+    {
+    case ACPI_TYPE_DEVICE:
+    case ACPI_TYPE_PROCESSOR:
+    case ACPI_TYPE_POWER:
+    case ACPI_TYPE_LOCAL_RESOURCE:
+        return (AE_OK);
+
+    default:
+        break;
+    }
+
+    /* All others are valid unreferenced namespace objects */
+
+    if (Node->Op)
+    {
+        AslError (ASL_WARNING2, ASL_MSG_NOT_REFERENCED, LkGetNameOp (Node->Op), NULL);
+    }
+    return (AE_OK);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    LkFindUnreferencedObjects
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Namespace walk to find objects that are not referenced in any
+ *              way. Must be called after the namespace has been cross
+ *              referenced.
+ *
+ ******************************************************************************/
+
+void
+LkFindUnreferencedObjects (
+    void)
+{
+
+    /* Walk entire namespace from the supplied root */
+
+    (void) AcpiNsWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
+                ACPI_UINT32_MAX, FALSE, LkIsObjectUsed,
+                NULL, NULL);
+}
+
+
+/*******************************************************************************
+ *
  * FUNCTION:    LkCrossReferenceNamespace
  *
  * PARAMETERS:  None
@@ -641,7 +829,7 @@ LkNamespaceLocateBegin (
     UINT32                  Flags;
 
 
-    ACPI_FUNCTION_TRACE_PTR ("LkNamespaceLocateBegin", Op);
+    ACPI_FUNCTION_TRACE_PTR (LkNamespaceLocateBegin, Op);
 
     /*
      * If this node is the actual declaration of a name
@@ -688,7 +876,7 @@ LkNamespaceLocateBegin (
 
     if (OpInfo->Flags & AML_NAMED)
     {
-        /* For all NAMED operators, the name reference is the first child */
+        /* For nearly all NAMED operators, the name reference is the first child */
 
         Path = Op->Asl.Child->Asl.Value.String;
         if (Op->Asl.AmlOpcode == AML_ALIAS_OP)
@@ -729,7 +917,7 @@ LkNamespaceLocateBegin (
      */
     Gbl_NsLookupCount++;
 
-    Status = AcpiNsLookup (WalkState->ScopeInfo,  Path, ObjectType,
+    Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
                 ACPI_IMODE_EXECUTE, Flags, WalkState, &(Node));
     if (ACPI_FAILURE (Status))
     {
@@ -803,13 +991,23 @@ LkNamespaceLocateBegin (
         return (Status);
     }
 
+    /* Check for a reference vs. name declaration */
+
+    if (!(OpInfo->Flags & AML_NAMED) &&
+        !(OpInfo->Flags & AML_CREATE))
+    {
+        /* This node has been referenced, mark it for reference check */
+
+        Node->Flags |= ANOBJ_IS_REFERENCED;
+    }
+
     /* Attempt to optimize the NamePath */
 
     OptOptimizeNamePath (Op, OpInfo->Flags, WalkState, Path, Node);
 
     /*
-     * Dereference an alias. (A name reference that is an alias.)
-     * Aliases are not nested;  The alias always points to the final object
+     * 1) Dereference an alias (A name reference that is an alias)
+     *    Aliases are not nested, the alias always points to the final object
      */
     if ((Op->Asl.ParseOpcode != PARSEOP_ALIAS) &&
         (Node->Type == ACPI_TYPE_LOCAL_ALIAS))
@@ -822,22 +1020,19 @@ LkNamespaceLocateBegin (
 
         NextOp = NextOp->Asl.Child;
 
-        /* Who in turn points back to original target alias node */
+        /* That in turn points back to original target alias node */
 
         if (NextOp->Asl.Node)
         {
             Node = NextOp->Asl.Node;
         }
-        else
-        {
-            AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
-                "Missing alias link");
-        }
+
+        /* Else - forward reference to alias, will be resolved later */
     }
 
-    /* 1) Check for a reference to a resource descriptor */
+    /* 2) Check for a reference to a resource descriptor */
 
-    else if ((Node->Type == ACPI_TYPE_LOCAL_RESOURCE_FIELD) ||
+    if ((Node->Type == ACPI_TYPE_LOCAL_RESOURCE_FIELD) ||
              (Node->Type == ACPI_TYPE_LOCAL_RESOURCE))
     {
         /*
@@ -910,7 +1105,7 @@ LkNamespaceLocateBegin (
         OpcGenerateAmlOpcode (Op);
     }
 
-    /* 2) Check for a method invocation */
+    /* 3) Check for a method invocation */
 
     else if ((((Op->Asl.ParseOpcode == PARSEOP_NAMESTRING) || (Op->Asl.ParseOpcode == PARSEOP_NAMESEG)) &&
                 (Node->Type == ACPI_TYPE_METHOD) &&
@@ -996,7 +1191,7 @@ LkNamespaceLocateBegin (
         }
     }
 
-    /* 3) Check for an ASL Field definition */
+    /* 4) Check for an ASL Field definition */
 
     else if ((Op->Asl.Parent) &&
             ((Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_FIELD)     ||
@@ -1137,7 +1332,7 @@ LkNamespaceLocateEnd (
     const ACPI_OPCODE_INFO  *OpInfo;
 
 
-    ACPI_FUNCTION_TRACE ("LkNamespaceLocateEnd");
+    ACPI_FUNCTION_TRACE (LkNamespaceLocateEnd);
 
 
     /* We are only interested in opcodes that have an associated name */
diff --git a/sys/contrib/dev/acpica/compiler/aslmain.c b/sys/contrib/dev/acpica/compiler/aslmain.c
index 3e8d2c6..6fe94b4 100644
--- a/sys/contrib/dev/acpica/compiler/aslmain.c
+++ b/sys/contrib/dev/acpica/compiler/aslmain.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslmain - compiler main and utilities
- *              $Revision: 1.87 $
+ *              $Revision: 1.96 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -120,6 +120,7 @@
 
 #include <contrib/dev/acpica/compiler/aslcompiler.h>
 #include <contrib/dev/acpica/acnamesp.h>
+#include <contrib/dev/acpica/actables.h>
 #include <contrib/dev/acpica/acapps.h>
 
 #ifdef _DEBUG
@@ -162,10 +163,8 @@ AslCommandLine (
     char                    **argv);
 
 #ifdef _DEBUG
-#if ACPI_MACHINE_WIDTH != 16
 #include <crtdbg.h>
 #endif
-#endif
 
 /*******************************************************************************
  *
@@ -190,6 +189,7 @@ Options (
     printf ("  -vo            Enable optimization comments\n");
     printf ("  -vr            Disable remarks\n");
     printf ("  -vs            Disable signon\n");
+    printf ("  -w<1|2|3>      Set warning reporting level\n");
 
     printf ("\nAML Output Files:\n");
     printf ("  -s<a|c>        Create AML in assembler or C source file (*.asm or *.c)\n");
@@ -209,16 +209,13 @@ Options (
     printf ("  -ls            Create combined source file (expanded includes) (*.src)\n");
 
     printf ("\nAML Disassembler:\n");
-    printf ("  -d  [file]     Disassemble AML to ASL source code file (*.dsl)\n");
+    printf ("  -d  [file]     Disassemble or decode binary ACPI table to file (*.dsl)\n");
     printf ("  -dc [file]     Disassemble AML and immediately compile it\n");
     printf ("                 (Obtain DSDT from current system if no input file)\n");
+    printf ("  -e  [file]     Include ACPI table for external symbol resolution\n");
     printf ("  -2             Emit ACPI 2.0 compatible ASL code\n");
-    printf ("  -e             Generate External() statements for unresolved symbols\n");
     printf ("  -g             Get ACPI tables and write to files (*.dat)\n");
 
-    printf ("\nMiscellaneous:\n");
-    printf ("  -a             Verify source file is entirely ASCII text (0x00-0x7F)\n");
-
     printf ("\nHelp:\n");
     printf ("  -h             Additional help and compiler debug options\n");
     printf ("  -hc            Display operators allowed in constant expressions\n");
@@ -254,7 +251,7 @@ HelpMessage (
 
     Options ();
 
-    printf ("\nCompiler Debug Options:\n");
+    printf ("\nCompiler/Disassembler Debug Options:\n");
     printf ("  -b<p|t|b>      Create compiler debug/trace file (*.txt)\n");
     printf ("                   Types: Parse/Tree/Both\n");
     printf ("  -f             Ignore errors, force creation of AML output file(s)\n");
@@ -357,18 +354,13 @@ AslCommandLine (
 
     /* Get the command line options */
 
-    while ((j = AcpiGetopt (argc, argv, "2ab:cd^efgh^i^l^o:p:r:s:t:v:x:")) != EOF) switch (j)
+    while ((j = AcpiGetopt (argc, argv, "2b:cd^e:fgh^i^l^o:p:r:s:t:v:w:x:")) != EOF) switch (j)
     {
     case '2':
         Gbl_Acpi2 = TRUE;
         break;
 
 
-    case 'a':
-        Gbl_CheckForAscii = TRUE;
-        break;
-
-
     case 'b':
 
         switch (AcpiGbl_Optarg[0])
@@ -425,10 +417,7 @@ AslCommandLine (
 
 
     case 'e':
-
-        /* Generate external statements for unresolved symbols */
-
-        Gbl_GenerateExternals = TRUE;
+        Gbl_ExternalFilename = AcpiGbl_Optarg;
         break;
 
 
@@ -672,6 +661,30 @@ AslCommandLine (
         break;
 
 
+    case 'w': /* Set warning levels */
+
+        switch (AcpiGbl_Optarg[0])
+        {
+        case '1':
+            Gbl_WarningLevel = ASL_WARNING;
+            break;
+
+        case '2':
+            Gbl_WarningLevel = ASL_WARNING2;
+            break;
+
+        case '3':
+            Gbl_WarningLevel = ASL_WARNING3;
+            break;
+
+        default:
+            printf ("Unknown option: -w%s\n", AcpiGbl_Optarg);
+            BadCommandLine = TRUE;
+            break;
+        }
+        break;
+
+
     case 'x':
 
         AcpiDbgLevel = strtoul (AcpiGbl_Optarg, NULL, 16);
@@ -741,11 +754,9 @@ main (
 
 
 #ifdef _DEBUG
-#if ACPI_MACHINE_WIDTH != 16
     _CrtSetDbgFlag (_CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF |
                     _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG));
 #endif
-#endif
 
     /* Init and command line */
 
@@ -774,17 +785,17 @@ main (
     {
         /* ACPI CA subsystem initialization */
 
-        Status = AcpiOsInitialize ();
-        AcpiUtInitGlobals ();
-        Status = AcpiUtMutexInitialize ();
+        Status = AdInitialize ();
         if (ACPI_FAILURE (Status))
         {
             return -1;
         }
 
-        Status = AcpiNsRootInitialize ();
+        Status = AcpiAllocateRootTable (4);
         if (ACPI_FAILURE (Status))
         {
+            AcpiOsPrintf ("Could not initialize ACPI Table Manager, %s\n",
+                AcpiFormatException (Status));
             return -1;
         }
 
diff --git a/sys/contrib/dev/acpica/compiler/aslmap.c b/sys/contrib/dev/acpica/compiler/aslmap.c
index 0969065..5384d0b 100644
--- a/sys/contrib/dev/acpica/compiler/aslmap.c
+++ b/sys/contrib/dev/acpica/compiler/aslmap.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslmap - parser to AML opcode mapping table
- *              $Revision: 1.80 $
+ *              $Revision: 1.87 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -308,7 +308,7 @@ const ASL_RESERVED_INFO         ReservedMethods[] = {
     {"_EJ3",     1,      0},
     {"_EJ4",     1,      0},
     {"_EJD",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_ERR",     2,      ASL_RSVD_RETURN_VALUE},
+    {"_ERR",     3,      ASL_RSVD_RETURN_VALUE},
     {"_FDE",     0,      ASL_RSVD_RETURN_VALUE},
     {"_FDI",     0,      ASL_RSVD_RETURN_VALUE},
     {"_FDM",     1,      0},
@@ -421,6 +421,7 @@ const ASL_RESERVED_INFO         ReservedMethods[] = {
     {"_SWS",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
     {"_TC1",     0,      ASL_RSVD_RETURN_VALUE},
     {"_TC2",     0,      ASL_RSVD_RETURN_VALUE},
+    {"_TDL",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0b */
     {"_TMP",     0,      ASL_RSVD_RETURN_VALUE},
     {"_TPC",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
     {"_TPT",     1,      0},                        /* Acpi 3.0 */
@@ -445,6 +446,8 @@ const ASL_RESERVED_INFO         ReservedMethods[] = {
     {"_UPP",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
     {"_VPO",     0,      ASL_RSVD_RETURN_VALUE},
     {"_WAK",     1,      ASL_RSVD_RETURN_VALUE},
+    {"_WDG",     0,      ASL_RSVD_RETURN_VALUE},    /* MS Extension */
+    {"_WED",     1,      ASL_RSVD_RETURN_VALUE},    /* MS Extension */
     {NULL,       0,      0},
 };
 
@@ -551,6 +554,7 @@ const ASL_MAPPING_ENTRY     AslKeywordMapping [] =
 /* ELSE */                      OP_TABLE_ENTRY (AML_ELSE_OP,                0,                              NODE_AML_PACKAGE,   0),
 /* ELSEIF */                    OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP,         0,                              NODE_AML_PACKAGE,   0),
 /* ENDDEPENDENTFN */            OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP,         0,                              0,                  0),
+/* ENDTAG */                    OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP,         0,                              0,                  0),
 /* ERRORNODE */                 OP_TABLE_ENTRY (AML_NOOP_OP,                0,                              0,                  0),
 /* EVENT */                     OP_TABLE_ENTRY (AML_EVENT_OP,               0,                              0,                  0),
 /* EXTENDEDIO */                OP_TABLE_ENTRY (AML_BYTE_OP,                0,                              0,                  0),
diff --git a/sys/contrib/dev/acpica/compiler/aslopcodes.c b/sys/contrib/dev/acpica/compiler/aslopcodes.c
index 2191741..ae91dc8 100644
--- a/sys/contrib/dev/acpica/compiler/aslopcodes.c
+++ b/sys/contrib/dev/acpica/compiler/aslopcodes.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslopcode - AML opcode generation
- *              $Revision: 1.71 $
+ *              $Revision: 1.74 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -213,7 +213,6 @@ OpcAmlOpcodeWalk (
 
     OpcGenerateAmlOpcode (Op);
     OpnGenerateAmlOperands (Op);
-
     return (AE_OK);
 }
 
@@ -593,14 +592,15 @@ OpcDoEisaId (
     {
         /* Create ID big-endian first (bits are contiguous) */
 
-        BigEndianId  =  (UINT32) (InString[0] - 0x40) << 26 |
-                        (UINT32) (InString[1] - 0x40) << 21 |
-                        (UINT32) (InString[2] - 0x40) << 16 |
+        BigEndianId =
+            (UINT32) (InString[0] - 0x40) << 26 |
+            (UINT32) (InString[1] - 0x40) << 21 |
+            (UINT32) (InString[2] - 0x40) << 16 |
 
-                        (UtHexCharToValue (InString[3])) << 12 |
-                        (UtHexCharToValue (InString[4])) << 8  |
-                        (UtHexCharToValue (InString[5])) << 4  |
-                         UtHexCharToValue (InString[6]);
+            (UtHexCharToValue (InString[3])) << 12 |
+            (UtHexCharToValue (InString[4])) << 8  |
+            (UtHexCharToValue (InString[5])) << 4  |
+             UtHexCharToValue (InString[6]);
 
         /* Swap to little-endian to get final ID (see function header) */
 
diff --git a/sys/contrib/dev/acpica/compiler/asloperands.c b/sys/contrib/dev/acpica/compiler/asloperands.c
index fb465e9..8f4500e 100644
--- a/sys/contrib/dev/acpica/compiler/asloperands.c
+++ b/sys/contrib/dev/acpica/compiler/asloperands.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: asloperands - AML operand processing
- *              $Revision: 1.57 $
+ *              $Revision: 1.61 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -959,10 +959,12 @@ OpnDoDefinitionBlock (
      * as AML opcodes!
      */
 
-    /* AML filename */
+    /* Get AML filename. Use it if non-null */
 
     Child = Op->Asl.Child;
-    if ((Child->Asl.Value.Buffer) && (Gbl_UseDefaultAmlFilename))
+    if (Child->Asl.Value.Buffer  &&
+        *Child->Asl.Value.Buffer &&
+        (Gbl_UseDefaultAmlFilename))
     {
         Gbl_OutputFilenamePrefix = (char *) Child->Asl.Value.Buffer;
     }
@@ -995,10 +997,9 @@ OpnDoDefinitionBlock (
 
     Child = Child->Asl.Next;
     Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
-
-    /* Use the revision to set the integer width */
-
-    AcpiUtSetIntegerWidth ((UINT8) Child->Asl.Value.Integer);
+    /*
+     * We used the revision to set the integer width earlier
+     */
 
     /* OEMID */
 
diff --git a/sys/contrib/dev/acpica/compiler/aslopt.c b/sys/contrib/dev/acpica/compiler/aslopt.c
index e406abb..2ea9aea 100644
--- a/sys/contrib/dev/acpica/compiler/aslopt.c
+++ b/sys/contrib/dev/acpica/compiler/aslopt.c
@@ -1,7 +1,7 @@
 /******************************************************************************
  *
  * Module Name: aslopt- Compiler optimizations
- *              $Revision: 1.21 $
+ *              $Revision: 1.26 $
  *
  *****************************************************************************/
 
@@ -9,7 +9,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -196,7 +196,7 @@ OptSearchToRoot (
     char                    *Path;
 
 
-    ACPI_FUNCTION_NAME ("OptSearchToRoot");
+    ACPI_FUNCTION_NAME (OptSearchToRoot);
 
 
     /*
@@ -241,7 +241,7 @@ OptSearchToRoot (
 
     /* We must allocate a new string for the name (TargetPath gets deleted) */
 
-    *NewPath = ACPI_MEM_CALLOCATE (ACPI_NAME_SIZE + 1);
+    *NewPath = ACPI_ALLOCATE_ZEROED (ACPI_NAME_SIZE + 1);
     ACPI_STRCPY (*NewPath, Path);
 
     if (ACPI_STRNCMP (*NewPath, "_T_", 3))
@@ -299,7 +299,7 @@ OptBuildShortestPath (
     BOOLEAN                 SubPath = FALSE;
 
 
-    ACPI_FUNCTION_NAME ("OptBuildShortestPath");
+    ACPI_FUNCTION_NAME (OptBuildShortestPath);
 
 
     ScopeInfo.Scope.Node = CurrentNode;
@@ -372,7 +372,8 @@ OptBuildShortestPath (
     /*
      * Construct a new target string
      */
-    NewPathExternal = ACPI_MEM_CALLOCATE (TargetPath->Length + NumCarats + 1);
+    NewPathExternal = ACPI_ALLOCATE_ZEROED (
+        TargetPath->Length + NumCarats + 1);
 
     /* Insert the Carats into the Target string */
 
@@ -415,7 +416,6 @@ OptBuildShortestPath (
         Index = TargetPath->Length;
     }
 
-
     ACPI_STRCPY (&NewPathExternal[i], &((char *) TargetPath->Pointer)[Index]);
     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, " %-24s", NewPathExternal));
 
@@ -425,21 +425,20 @@ OptBuildShortestPath (
      * original string is already optimal, there is no point in continuing.
      */
     Status = AcpiNsInternalizeName (NewPathExternal, &NewPath);
-
     if (ACPI_FAILURE (Status))
     {
         AslCoreSubsystemError (Op, Status, "Internalizing new NamePath",
             ASL_NO_ABORT);
-        ACPI_MEM_FREE (NewPathExternal);
+        ACPI_FREE (NewPathExternal);
         return (Status);
     }
 
     if (ACPI_STRLEN (NewPath) >= AmlNameStringLength)
     {
         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
-            " NOT SHORTER (New %d old %d)",
+            " NOT SHORTER (New %u old %u)",
             ACPI_STRLEN (NewPath), AmlNameStringLength));
-        ACPI_MEM_FREE (NewPathExternal);
+        ACPI_FREE (NewPathExternal);
         return (AE_NOT_FOUND);
     }
 
@@ -482,7 +481,7 @@ OptBuildShortestPath (
             "Not using optimized name - did not find node");
     }
 
-    ACPI_MEM_FREE (NewPathExternal);
+    ACPI_FREE (NewPathExternal);
     return (Status);
 }
 
@@ -519,7 +518,7 @@ OptOptimizeNameDeclaration (
     ACPI_NAMESPACE_NODE     *Node;
 
 
-    ACPI_FUNCTION_TRACE ("OptOptimizeNameDeclaration");
+    ACPI_FUNCTION_TRACE (OptOptimizeNameDeclaration);
 
 
     if (((CurrentNode == AcpiGbl_RootNode) ||
@@ -587,7 +586,7 @@ OptOptimizeNameDeclaration (
                 "Not using optimized name - did not find node");
         }
 
-        ACPI_MEM_FREE (NewPathExternal);
+        ACPI_FREE (NewPathExternal);
         return (Status);
     }
 
@@ -634,7 +633,7 @@ OptOptimizeNamePath (
     ACPI_PARSE_OBJECT       *NextOp;
 
 
-    ACPI_FUNCTION_TRACE ("OptOptimizeNamePath");
+    ACPI_FUNCTION_TRACE (OptOptimizeNamePath);
 
 
     /* This is an optional optimization */
@@ -753,11 +752,11 @@ OptOptimizeNamePath (
     }
 
     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS,
-        "%37s (%2d) ==> %-32s(%2d) %-32s",
+        "%37s (%2u) ==> %-32s(%2u) %-32s",
         (char *) CurrentPath.Pointer, CurrentPath.Length,
         (char *) TargetPath.Pointer, TargetPath.Length, ExternalNameString));
 
-    ACPI_MEM_FREE (ExternalNameString);
+    ACPI_FREE (ExternalNameString);
 
     /*
      * Attempt an optmization depending on the type of namepath
@@ -812,7 +811,7 @@ OptOptimizeNamePath (
         HowMuchShorter = (AmlNameStringLength - ACPI_STRLEN (NewPath));
         OptTotal += HowMuchShorter;
 
-        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, " REDUCED %2d (%d)",
+        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, " REDUCED %2u (%u)",
             HowMuchShorter, OptTotal));
 
         if (Flags & AML_NAMED)
@@ -861,8 +860,8 @@ OptOptimizeNamePath (
 
     /* Cleanup path buffers */
 
-    ACPI_MEM_FREE (TargetPath.Pointer);
-    ACPI_MEM_FREE (CurrentPath.Pointer);
+    ACPI_FREE (TargetPath.Pointer);
+    ACPI_FREE (CurrentPath.Pointer);
 
     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OPTIMIZATIONS, "\n"));
     return_VOID;
diff --git a/sys/contrib/dev/acpica/compiler/aslresource.c b/sys/contrib/dev/acpica/compiler/aslresource.c
index 6623fbe..c33637e 100644
--- a/sys/contrib/dev/acpica/compiler/aslresource.c
+++ b/sys/contrib/dev/acpica/compiler/aslresource.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslresource - Resource templates and descriptors
- *              $Revision: 1.38 $
+ *              $Revision: 1.43 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -376,7 +376,7 @@ RsDoOneResourceDescriptor (
     ASL_RESOURCE_NODE       *Rnode = NULL;
 
 
-    /* Determine type of resource */
+    /* Construct the resource */
 
     switch (DescriptorTypeOp->Asl.ParseOpcode)
     {
@@ -423,6 +423,11 @@ RsDoOneResourceDescriptor (
                     CurrentByteOffset);
         break;
 
+    case PARSEOP_ENDTAG:
+        Rnode = RsDoEndTagDescriptor (DescriptorTypeOp,
+                    CurrentByteOffset);
+        break;
+
     case PARSEOP_EXTENDEDIO:
         Rnode = RsDoExtendedIoDescriptor (DescriptorTypeOp,
                     CurrentByteOffset);
@@ -580,6 +585,12 @@ RsDoOneResourceDescriptor (
      */
     DescriptorTypeOp->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
     DescriptorTypeOp->Asl.CompileFlags = NODE_IS_RESOURCE_DESC;
+    DescriptorTypeOp->Asl.Value.Integer = CurrentByteOffset;
+
+    if (Rnode)
+    {
+        DescriptorTypeOp->Asl.FinalAmlLength = Rnode->BufferLength;
+    }
 
     return (Rnode);
 }
@@ -658,7 +669,6 @@ RsDoResourceTemplate (
     ACPI_PARSE_OBJECT       *BufferOp;
     ACPI_PARSE_OBJECT       *DescriptorTypeOp;
     ACPI_PARSE_OBJECT       *LastOp = NULL;
-    AML_RESOURCE            *Descriptor;
     UINT32                  CurrentByteOffset = 0;
     ASL_RESOURCE_NODE       HeadRnode;
     ASL_RESOURCE_NODE       *PreviousRnode;
@@ -666,6 +676,13 @@ RsDoResourceTemplate (
     UINT8                   State;
 
 
+    /* Mark parent as containing a resource template */
+
+    if (Op->Asl.Parent)
+    {
+        Op->Asl.Parent->Asl.CompileFlags |= NODE_IS_RESOURCE_DESC;
+    }
+
     /* ResourceTemplate Opcode is first (Op) */
     /* Buffer Length node is first child */
 
@@ -679,12 +696,16 @@ RsDoResourceTemplate (
 
     DescriptorTypeOp = ASL_GET_PEER_NODE (BufferOp);
 
-    /* Process all resource descriptors in the list */
-
+    /*
+     * Process all resource descriptors in the list
+     * Note: It is assumed that the EndTag node has been automatically
+     * inserted at the end of the template by the parser.
+     */
     State = ACPI_RSTATE_NORMAL;
     PreviousRnode = &HeadRnode;
     while (DescriptorTypeOp)
     {
+        DescriptorTypeOp->Asl.CompileFlags |= NODE_IS_RESOURCE_DESC;
         Rnode = RsDoOneResourceDescriptor (DescriptorTypeOp, CurrentByteOffset,
                     &State);
 
@@ -712,19 +733,6 @@ RsDoResourceTemplate (
     }
 
     /*
-     * Insert the EndTag descriptor after all other descriptors have
-     * been processed
-     */
-    Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_END_TAG));
-
-    Descriptor = Rnode->Buffer;
-    Descriptor->EndTag.DescriptorType = ACPI_RESOURCE_NAME_END_TAG |
-                                        ASL_RDESC_END_TAG_SIZE;
-    Descriptor->EndTag.Checksum = 0;
-
-    CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode, Rnode);
-
-    /*
      * Transform the nodes into the following
      *
      * Op           -> AML_BUFFER_OP
@@ -733,11 +741,10 @@ RsDoResourceTemplate (
      */
     Op->Asl.ParseOpcode               = PARSEOP_BUFFER;
     Op->Asl.AmlOpcode                 = AML_BUFFER_OP;
-    Op->Asl.CompileFlags              = NODE_AML_PACKAGE;
+    Op->Asl.CompileFlags              = NODE_AML_PACKAGE | NODE_IS_RESOURCE_DESC;
 
     BufferLengthOp->Asl.ParseOpcode   = PARSEOP_INTEGER;
     BufferLengthOp->Asl.Value.Integer = CurrentByteOffset;
-
     (void) OpcSetOptimalIntegerSize (BufferLengthOp);
 
     BufferOp->Asl.ParseOpcode         = PARSEOP_RAW_DATA;
@@ -745,6 +752,7 @@ RsDoResourceTemplate (
     BufferOp->Asl.AmlOpcodeLength     = 0;
     BufferOp->Asl.AmlLength           = CurrentByteOffset;
     BufferOp->Asl.Value.Buffer        = (UINT8 *) HeadRnode.Next;
+    BufferOp->Asl.CompileFlags       |= NODE_IS_RESOURCE_DATA;
 
     return;
 }
diff --git a/sys/contrib/dev/acpica/compiler/aslrestype1.c b/sys/contrib/dev/acpica/compiler/aslrestype1.c
index e81bcdd..e317436 100644
--- a/sys/contrib/dev/acpica/compiler/aslrestype1.c
+++ b/sys/contrib/dev/acpica/compiler/aslrestype1.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslrestype1 - Short (type1) resource templates and descriptors
- *              $Revision: 1.35 $
+ *              $Revision: 1.40 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -125,6 +125,40 @@
 
 /*******************************************************************************
  *
+ * FUNCTION:    RsDoEndTagDescriptor
+ *
+ * PARAMETERS:  Op                  - Parent resource descriptor parse node
+ *              CurrentByteOffset   - Offset into the resource template AML
+ *                                    buffer (to track references to the desc)
+ *
+ * RETURN:      Completed resource node
+ *
+ * DESCRIPTION: Construct a short "EndDependentFn" descriptor
+ *
+ ******************************************************************************/
+
+ASL_RESOURCE_NODE *
+RsDoEndTagDescriptor (
+    ACPI_PARSE_OBJECT       *Op,
+    UINT32                  CurrentByteOffset)
+{
+    AML_RESOURCE            *Descriptor;
+    ASL_RESOURCE_NODE       *Rnode;
+
+
+    Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_END_TAG));
+
+    Descriptor = Rnode->Buffer;
+    Descriptor->EndTag.DescriptorType = ACPI_RESOURCE_NAME_END_TAG |
+                                        ASL_RDESC_END_TAG_SIZE;
+    Descriptor->EndTag.Checksum = 0;
+
+    return (Rnode);
+}
+
+
+/*******************************************************************************
+ *
  * FUNCTION:    RsDoDmaDescriptor
  *
  * PARAMETERS:  Op                  - Parent resource descriptor parse node
@@ -166,21 +200,21 @@ RsDoDmaDescriptor (
         case 0: /* DMA type */
 
             RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 5, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DMATYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DMATYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 5);
             break;
 
         case 1: /* Bus Master */
 
             RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_BUSMASTER,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_BUSMASTER,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 2);
             break;
 
         case 2: /* Xfer Type (transfer width) */
 
             RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 0, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_XFERTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_XFERTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 0);
             break;
 
@@ -227,7 +261,7 @@ RsDoDmaDescriptor (
 
                 /* Create a named field at the start of the list */
 
-                RsCreateByteField (InitializerOp, ASL_RESNAME_DMA,
+                RsCreateByteField (InitializerOp, ACPI_RESTAG_DMA,
                     CurrentByteOffset +
                     ASL_RESDESC_OFFSET (Dma.DmaChannelMask));
             }
@@ -318,7 +352,7 @@ RsDoFixedIoDescriptor (
 
             Descriptor->FixedIo.Address =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_BASEADDRESS,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_BASEADDRESS,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedIo.Address));
             break;
 
@@ -326,7 +360,7 @@ RsDoFixedIoDescriptor (
 
             Descriptor->FixedIo.AddressLength =
                 (UINT8) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedIo.AddressLength));
             break;
 
@@ -389,7 +423,7 @@ RsDoIoDescriptor (
         case 0: /* Decode size */
 
             RsSetFlagBits (&Descriptor->Io.Flags, InitializerOp, 0, 1);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Flags), 0);
             break;
 
@@ -397,7 +431,7 @@ RsDoIoDescriptor (
 
             Descriptor->Io.Minimum =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Minimum));
             break;
 
@@ -405,7 +439,7 @@ RsDoIoDescriptor (
 
             Descriptor->Io.Maximum =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Maximum));
             break;
 
@@ -413,7 +447,7 @@ RsDoIoDescriptor (
 
             Descriptor->Io.Alignment =
                 (UINT8) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_ALIGNMENT,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Alignment));
             break;
 
@@ -421,7 +455,7 @@ RsDoIoDescriptor (
 
             Descriptor->Io.AddressLength =
                 (UINT8) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.AddressLength));
             break;
 
@@ -488,21 +522,21 @@ RsDoIrqDescriptor (
         case 0: /* Interrupt Type (or Mode - edge/level) */
 
             RsSetFlagBits (&Descriptor->Irq.Flags, InitializerOp, 0, 1);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.Flags), 0);
             break;
 
         case 1: /* Interrupt Level (or Polarity - Active high/low) */
 
             RsSetFlagBits (&Descriptor->Irq.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTLEVEL,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTLEVEL,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.Flags), 3);
             break;
 
         case 2: /* Share Type - Default: exclusive (0) */
 
             RsSetFlagBits (&Descriptor->Irq.Flags, InitializerOp, 4, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTSHARE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.Flags), 4);
             break;
 
@@ -550,7 +584,7 @@ RsDoIrqDescriptor (
 
                 /* Create a named field at the start of the list */
 
-                RsCreateByteField (InitializerOp, ASL_RESNAME_INTERRUPT,
+                RsCreateByteField (InitializerOp, ACPI_RESTAG_INTERRUPT,
                     CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.IrqMask));
             }
             break;
@@ -650,7 +684,7 @@ RsDoIrqNoFlagsDescriptor (
 
                 /* Create a named field at the start of the list */
 
-                RsCreateByteField (InitializerOp, ASL_RESNAME_INTERRUPT,
+                RsCreateByteField (InitializerOp, ACPI_RESTAG_INTERRUPT,
                     CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.IrqMask));
             }
             break;
@@ -707,35 +741,35 @@ RsDoMemory24Descriptor (
         case 0: /* Read/Write type */
 
             RsSetFlagBits (&Descriptor->Memory24.Flags, InitializerOp, 0, 1);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Flags), 0);
             break;
 
         case 1: /* Min Address */
 
             Descriptor->Memory24.Minimum = (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Minimum));
             break;
 
         case 2: /* Max Address */
 
             Descriptor->Memory24.Maximum = (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Maximum));
             break;
 
         case 3: /* Alignment */
 
             Descriptor->Memory24.Alignment = (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_ALIGNMENT,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Alignment));
             break;
 
         case 4: /* Length */
 
             Descriptor->Memory24.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.AddressLength));
             break;
 
@@ -798,35 +832,35 @@ RsDoMemory32Descriptor (
         case 0: /* Read/Write type */
 
             RsSetFlagBits (&Descriptor->Memory32.Flags, InitializerOp, 0, 1);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Flags), 0);
             break;
 
         case 1:  /* Min Address */
 
             Descriptor->Memory32.Minimum = (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Minimum));
             break;
 
         case 2: /* Max Address */
 
             Descriptor->Memory32.Maximum = (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Maximum));
             break;
 
         case 3: /* Alignment */
 
             Descriptor->Memory32.Alignment = (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_ALIGNMENT,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Alignment));
             break;
 
         case 4: /* Length */
 
             Descriptor->Memory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.AddressLength));
             break;
 
@@ -889,21 +923,21 @@ RsDoMemory32FixedDescriptor (
         case 0: /* Read/Write type */
 
             RsSetFlagBits (&Descriptor->FixedMemory32.Flags, InitializerOp, 0, 1);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Flags), 0);
             break;
 
         case 1: /* Address */
 
             Descriptor->FixedMemory32.Address = (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_BASEADDRESS,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_BASEADDRESS,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Address));
             break;
 
         case 2: /* Length */
 
             Descriptor->FixedMemory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.AddressLength));
             break;
 
@@ -1115,6 +1149,11 @@ RsDoVendorSmallDescriptor (
     InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
     for (i = 0; InitializerOp; i++)
     {
+        if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
+        {
+            break;
+        }
+
         /* Maximum 7 vendor data bytes allowed (0-6) */
 
         if (i >= 7)
diff --git a/sys/contrib/dev/acpica/compiler/aslrestype2.c b/sys/contrib/dev/acpica/compiler/aslrestype2.c
index 02e0f30..c42e4a9 100644
--- a/sys/contrib/dev/acpica/compiler/aslrestype2.c
+++ b/sys/contrib/dev/acpica/compiler/aslrestype2.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslrestype2 - Long (type2) resource templates and descriptors
- *              $Revision: 1.42 $
+ *              $Revision: 1.51 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -222,28 +222,28 @@ RsDoDwordIoDescriptor (
         case 1: /* MinType */
 
             RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
             break;
 
         case 2: /* MaxType */
 
             RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
             break;
 
         case 3: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
             break;
 
         case 4: /* Range Type */
 
             RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 3);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0);
             break;
 
@@ -251,7 +251,7 @@ RsDoDwordIoDescriptor (
 
             Descriptor->Address32.Granularity =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
             break;
 
@@ -259,7 +259,7 @@ RsDoDwordIoDescriptor (
 
             Descriptor->Address32.Minimum =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
             break;
 
@@ -267,7 +267,7 @@ RsDoDwordIoDescriptor (
 
             Descriptor->Address32.Maximum =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
             break;
 
@@ -275,7 +275,7 @@ RsDoDwordIoDescriptor (
 
             Descriptor->Address32.TranslationOffset =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
             break;
 
@@ -283,7 +283,7 @@ RsDoDwordIoDescriptor (
 
             Descriptor->Address32.AddressLength =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
             break;
 
@@ -347,14 +347,14 @@ RsDoDwordIoDescriptor (
         case 13: /* Type */
 
             RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 4, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 4);
             break;
 
         case 14: /* Translation Type */
 
             RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
             break;
 
@@ -436,35 +436,35 @@ RsDoDwordMemoryDescriptor (
         case 1: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
             break;
 
         case 2: /* MinType */
 
             RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
             break;
 
         case 3: /* MaxType */
 
             RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
             break;
 
         case 4: /* Memory Type */
 
             RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MEMTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 1);
             break;
 
         case 5: /* Read/Write Type */
 
             RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 1);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0);
             break;
 
@@ -472,7 +472,7 @@ RsDoDwordMemoryDescriptor (
 
             Descriptor->Address32.Granularity =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
             break;
 
@@ -480,7 +480,7 @@ RsDoDwordMemoryDescriptor (
 
             Descriptor->Address32.Minimum =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
             break;
 
@@ -488,7 +488,7 @@ RsDoDwordMemoryDescriptor (
 
             Descriptor->Address32.Maximum =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
             break;
 
@@ -496,7 +496,7 @@ RsDoDwordMemoryDescriptor (
 
             Descriptor->Address32.TranslationOffset =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
             break;
 
@@ -504,7 +504,7 @@ RsDoDwordMemoryDescriptor (
 
             Descriptor->Address32.AddressLength =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
             break;
 
@@ -565,14 +565,14 @@ RsDoDwordMemoryDescriptor (
         case 14: /* Address Range */
 
             RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MEMATTRIBUTES,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 3);
             break;
 
         case 15: /* Type */
 
             RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
             break;
 
@@ -658,21 +658,21 @@ RsDoDwordSpaceDescriptor (
         case 2: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
             break;
 
         case 3: /* MinType */
 
             RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
             break;
 
         case 4: /* MaxType */
 
             RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
             break;
 
@@ -686,7 +686,7 @@ RsDoDwordSpaceDescriptor (
 
             Descriptor->Address32.Granularity =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
             break;
 
@@ -694,7 +694,7 @@ RsDoDwordSpaceDescriptor (
 
             Descriptor->Address32.Minimum =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
             break;
 
@@ -702,7 +702,7 @@ RsDoDwordSpaceDescriptor (
 
             Descriptor->Address32.Maximum =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
             break;
 
@@ -710,7 +710,7 @@ RsDoDwordSpaceDescriptor (
 
             Descriptor->Address32.TranslationOffset =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
             break;
 
@@ -718,7 +718,7 @@ RsDoDwordSpaceDescriptor (
 
             Descriptor->Address32.AddressLength =
                 (UINT32) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
             break;
 
@@ -814,7 +814,6 @@ RsDoExtendedIoDescriptor (
     ACPI_PARSE_OBJECT       *InitializerOp;
     ASL_RESOURCE_NODE       *Rnode;
     UINT16                  StringLength = 0;
-//    UINT32                  OptionIndex = 0;
     UINT32                  i;
 
 
@@ -847,70 +846,70 @@ RsDoExtendedIoDescriptor (
         case 1: /* MinType */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
             break;
 
         case 2: /* MaxType */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
             break;
 
         case 3: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
             break;
 
         case 4: /* Range Type */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
             break;
 
         case 5: /* Address Granularity */
 
             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
            break;
 
         case 6: /* Address Min */
 
             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
             break;
 
         case 7: /* Address Max */
 
             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
             break;
 
         case 8: /* Translation Offset */
 
             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
             break;
 
         case 9: /* Address Length */
 
             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
             break;
 
         case 10: /* Type-Specific Attributes */
 
             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TYPESPECIFICATTRIBUTES,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
             break;
 
@@ -922,14 +921,14 @@ RsDoExtendedIoDescriptor (
         case 12: /* Type */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
             break;
 
         case 13: /* Translation Type */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
             break;
 
@@ -1002,77 +1001,77 @@ RsDoExtendedMemoryDescriptor (
         case 1: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
             break;
 
         case 2: /* MinType */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
             break;
 
         case 3: /* MaxType */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
             break;
 
         case 4: /* Memory Type */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MEMTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1);
             break;
 
         case 5: /* Read/Write Type */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
             break;
 
         case 6: /* Address Granularity */
 
             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
             break;
 
         case 7: /* Min Address */
 
             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
             break;
 
         case 8: /* Max Address */
 
             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
             break;
 
         case 9: /* Translation Offset */
 
             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
             break;
 
         case 10: /* Address Length */
 
             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
             break;
 
         case 11: /* Type-Specific Attributes */
 
             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TYPESPECIFICATTRIBUTES,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
             break;
 
@@ -1085,14 +1084,14 @@ RsDoExtendedMemoryDescriptor (
         case 13: /* Address Range */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MEMATTRIBUTES,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3);
             break;
 
         case 14: /* Type */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
             break;
 
@@ -1170,21 +1169,21 @@ RsDoExtendedSpaceDescriptor (
         case 2: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
             break;
 
         case 3: /* MinType */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
             break;
 
         case 4: /* MaxType */
 
             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
             break;
 
@@ -1197,42 +1196,42 @@ RsDoExtendedSpaceDescriptor (
         case 6: /* Address Granularity */
 
             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
             break;
 
         case 7: /* Min Address */
 
             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
             break;
 
         case 8: /* Max Address */
 
             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
             break;
 
         case 9: /* Translation Offset */
 
             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
             break;
 
         case 10: /* Address Length */
 
             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
             break;
 
         case 11: /* Type-Specific Attributes */
 
             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TYPESPECIFICATTRIBUTES,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
             break;
 
@@ -1317,63 +1316,63 @@ RsDoQwordIoDescriptor (
         case 1: /* MinType */
 
             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
             break;
 
         case 2: /* MaxType */
 
             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
             break;
 
         case 3: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
             break;
 
         case 4: /* Range Type */
 
             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 3);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
             break;
 
         case 5: /* Address Granularity */
 
             Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
            break;
 
         case 6: /* Address Min */
 
             Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
             break;
 
         case 7: /* Address Max */
 
             Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
             break;
 
         case 8: /* Translation Offset */
 
             Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
             break;
 
         case 9: /* Address Length */
 
             Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
             break;
 
@@ -1433,14 +1432,14 @@ RsDoQwordIoDescriptor (
         case 13: /* Type */
 
             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 4, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 4);
             break;
 
         case 14: /* Translation Type */
 
             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
             break;
 
@@ -1521,70 +1520,70 @@ RsDoQwordMemoryDescriptor (
         case 1: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
             break;
 
         case 2: /* MinType */
 
             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
             break;
 
         case 3: /* MaxType */
 
             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
             break;
 
         case 4: /* Memory Type */
 
             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MEMTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 1);
             break;
 
         case 5: /* Read/Write Type */
 
             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 1);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
             break;
 
         case 6: /* Address Granularity */
 
             Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
             break;
 
         case 7: /* Min Address */
 
             Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
             break;
 
         case 8: /* Max Address */
 
             Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
             break;
 
         case 9: /* Translation Offset */
 
             Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
             break;
 
         case 10: /* Address Length */
 
             Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
             break;
 
@@ -1645,14 +1644,14 @@ RsDoQwordMemoryDescriptor (
         case 14: /* Address Range */
 
             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MEMATTRIBUTES,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 3);
             break;
 
         case 15: /* Type */
 
             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
             break;
 
@@ -1707,7 +1706,7 @@ RsDoQwordSpaceDescriptor (
                 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
 
     Descriptor = Rnode->Buffer;
-    Descriptor->Address64.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS32;
+    Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64;
 
     /*
      * Initial descriptor length -- may be enlarged if there are
@@ -1738,21 +1737,21 @@ RsDoQwordSpaceDescriptor (
         case 2: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
             break;
 
         case 3: /* MinType */
 
             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
             break;
 
         case 4: /* MaxType */
 
             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
             break;
 
@@ -1765,35 +1764,35 @@ RsDoQwordSpaceDescriptor (
         case 6: /* Address Granularity */
 
             Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
             break;
 
         case 7: /* Min Address */
 
             Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
             break;
 
         case 8: /* Max Address */
 
             Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
             break;
 
         case 9: /* Translation Offset */
 
             Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
             break;
 
         case 10: /* Address Length */
 
             Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
             break;
 
@@ -1927,63 +1926,63 @@ RsDoWordIoDescriptor (
         case 1: /* MinType */
 
             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
             break;
 
         case 2: /* MaxType */
 
             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
             break;
 
         case 3: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
             break;
 
         case 4: /* Range Type */
 
             RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 0, 3);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 0);
             break;
 
         case 5: /* Address Granularity */
 
             Descriptor->Address16.Granularity = (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
             break;
 
         case 6: /* Address Min */
 
             Descriptor->Address16.Minimum = (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
             break;
 
         case 7: /* Address Max */
 
             Descriptor->Address16.Maximum = (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
             break;
 
         case 8: /* Translation Offset */
 
             Descriptor->Address16.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
             break;
 
         case 9: /* Address Length */
 
             Descriptor->Address16.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                  CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
             break;
 
@@ -2043,14 +2042,14 @@ RsDoWordIoDescriptor (
         case 13: /* Type */
 
             RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 4, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 4);
             break;
 
         case 14: /* Translation Type */
 
             RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 5, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 5);
             break;
 
@@ -2131,21 +2130,21 @@ RsDoWordBusNumberDescriptor (
         case 1: /* MinType */
 
             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
             break;
 
         case 2: /* MaxType */
 
             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
             break;
 
         case 3: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
             break;
 
@@ -2153,7 +2152,7 @@ RsDoWordBusNumberDescriptor (
 
             Descriptor->Address16.Granularity =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
             break;
 
@@ -2161,7 +2160,7 @@ RsDoWordBusNumberDescriptor (
 
             Descriptor->Address16.Minimum =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
             break;
 
@@ -2169,7 +2168,7 @@ RsDoWordBusNumberDescriptor (
 
             Descriptor->Address16.Maximum =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
             break;
 
@@ -2177,7 +2176,7 @@ RsDoWordBusNumberDescriptor (
 
             Descriptor->Address16.TranslationOffset =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
             break;
 
@@ -2185,7 +2184,7 @@ RsDoWordBusNumberDescriptor (
 
             Descriptor->Address16.AddressLength =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                  CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
             break;
 
@@ -2324,21 +2323,21 @@ RsDoWordSpaceDescriptor (
         case 2: /* DecodeType */
 
             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
             break;
 
         case 3: /* MinType */
 
             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
             break;
 
         case 4: /* MaxType */
 
             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
             break;
 
@@ -2352,7 +2351,7 @@ RsDoWordSpaceDescriptor (
 
             Descriptor->Address16.Granularity =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
             break;
 
@@ -2360,7 +2359,7 @@ RsDoWordSpaceDescriptor (
 
             Descriptor->Address16.Minimum =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
             break;
 
@@ -2368,7 +2367,7 @@ RsDoWordSpaceDescriptor (
 
             Descriptor->Address16.Maximum =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
             break;
 
@@ -2376,7 +2375,7 @@ RsDoWordSpaceDescriptor (
 
             Descriptor->Address16.TranslationOffset =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
             break;
 
@@ -2384,7 +2383,7 @@ RsDoWordSpaceDescriptor (
 
             Descriptor->Address16.AddressLength =
                 (UINT16) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
             break;
 
@@ -2540,21 +2539,21 @@ RsDoInterruptDescriptor (
         case 1: /* Interrupt Type (or Mode - edge/level) */
 
             RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 1, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTTYPE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTTYPE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 1);
             break;
 
         case 2: /* Interrupt Level (or Polarity - Active high/low) */
 
             RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 2, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTLEVEL,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTLEVEL,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 2);
             break;
 
         case 3: /* Share Type - Default: exclusive (0) */
 
             RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 3, 0);
-            RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTSHARE,
+            RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 3);
             break;
 
@@ -2628,8 +2627,8 @@ RsDoInterruptDescriptor (
 
             /* Save the integer and move pointer to the next one */
 
-            Rover->U32Item = (UINT32) InitializerOp->Asl.Value.Integer;
-            Rover = ACPI_PTR_ADD (AML_RESOURCE, &(Rover->U32Item), 4);
+            Rover->DwordItem = (UINT32) InitializerOp->Asl.Value.Integer;
+            Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->DwordItem), 4);
             Descriptor->ExtendedIrq.InterruptCount++;
             Descriptor->ExtendedIrq.ResourceLength += 4;
 
@@ -2643,7 +2642,7 @@ RsDoInterruptDescriptor (
 
                 /* Create a named field at the start of the list */
 
-                RsCreateByteField (InitializerOp, ASL_RESNAME_INTERRUPT,
+                RsCreateByteField (InitializerOp, ACPI_RESTAG_INTERRUPT,
                     CurrentByteOffset +
                     ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0]));
             }
@@ -2657,8 +2656,8 @@ RsDoInterruptDescriptor (
 
     if (HasResSourceIndex)
     {
-        Rover->U8Item = ResSourceIndex;
-        Rover = ACPI_PTR_ADD (AML_RESOURCE, &(Rover->U8Item), 1);
+        Rover->ByteItem = ResSourceIndex;
+        Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->ByteItem), 1);
         Descriptor->ExtendedIrq.ResourceLength += 1;
     }
 
@@ -2668,8 +2667,8 @@ RsDoInterruptDescriptor (
     {
 
         strcpy ((char *) Rover, (char *) ResSourceString);
-        Rover = ACPI_PTR_ADD (
-                    AML_RESOURCE, &(Rover->U8Item), StringLength);
+        Rover = ACPI_ADD_PTR (
+                    AML_RESOURCE, &(Rover->ByteItem), StringLength);
 
         Descriptor->ExtendedIrq.ResourceLength = (UINT16)
             (Descriptor->ExtendedIrq.ResourceLength + StringLength);
@@ -2715,6 +2714,10 @@ RsDoVendorLargeDescriptor (
 
     for (i = 0; InitializerOp; i++)
     {
+        if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
+        {
+            break;
+        }
         InitializerOp = InitializerOp->Asl.Next;
     }
 
@@ -2734,8 +2737,12 @@ RsDoVendorLargeDescriptor (
 
     for (i = 0; InitializerOp; i++)
     {
-        VendorData[i] = (UINT8) InitializerOp->Asl.Value.Integer;
+        if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
+        {
+            break;
+        }
 
+        VendorData[i] = (UINT8) InitializerOp->Asl.Value.Integer;
         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
     }
 
@@ -2784,38 +2791,43 @@ RsDoGeneralRegisterDescriptor (
         case 0: /* Address space */
 
             Descriptor->GenericReg.AddressSpaceId = (UINT8) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_ADDRESSSPACE,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_ADDRESSSPACE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AddressSpaceId));
            break;
 
         case 1: /* Register Bit Width */
 
             Descriptor->GenericReg.BitWidth = (UINT8) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_REGISTERBITWIDTH,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITWIDTH,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitWidth));
             break;
 
         case 2: /* Register Bit Offset */
 
             Descriptor->GenericReg.BitOffset = (UINT8) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_REGISTERBITOFFSET,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITOFFSET,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitOffset));
             break;
 
         case 3: /* Register Address */
 
             Descriptor->GenericReg.Address = InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_ADDRESS,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_ADDRESS,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.Address));
             break;
 
         case 4: /* Access Size (ACPI 3.0) */
 
             Descriptor->GenericReg.AccessSize = (UINT8) InitializerOp->Asl.Value.Integer;
-            RsCreateByteField (InitializerOp, ASL_RESNAME_ACCESSSIZE,
+            RsCreateByteField (InitializerOp, ACPI_RESTAG_ACCESSSIZE,
                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AccessSize));
             break;
 
+        case 5: /* ResourceTag (ACPI 3.0b) */
+
+            UtAttachNamepathToOwner (Op, InitializerOp);
+            break;
+
         default:
 
             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
diff --git a/sys/contrib/dev/acpica/compiler/aslstubs.c b/sys/contrib/dev/acpica/compiler/aslstubs.c
index fa2b63f..eb6b12a 100644
--- a/sys/contrib/dev/acpica/compiler/aslstubs.c
+++ b/sys/contrib/dev/acpica/compiler/aslstubs.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslstubs - Stubs used to link to Aml interpreter
- *              $Revision: 1.14 $
+ *              $Revision: 1.20 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -129,12 +129,19 @@
  * Things like Events, Global Lock, etc. are not used
  * by the compiler, so they are stubbed out here.
  */
-ACPI_STATUS
+ACPI_PHYSICAL_ADDRESS
 AeLocalGetRootPointer (
-    UINT32                  Flags,
-    ACPI_PHYSICAL_ADDRESS   *RsdpPhysicalAddress)
+    void)
+{
+    return 0;
+}
+
+ACPI_STATUS
+AcpiDsMethodError (
+    ACPI_STATUS             Status,
+    ACPI_WALK_STATE         *WalkState)
 {
-    return AE_ERROR;
+    return (Status);
 }
 
 ACPI_STATUS
@@ -266,7 +273,7 @@ AcpiTbFindTable (
     char                    *Signature,
     char                    *OemId,
     char                    *OemTableId,
-    ACPI_TABLE_HEADER       **TablePtr)
+    ACPI_NATIVE_UINT        *TableIndex)
 {
     return (AE_SUPPORT);
 }
diff --git a/sys/contrib/dev/acpica/compiler/asltransform.c b/sys/contrib/dev/acpica/compiler/asltransform.c
index 9ff4925..b76a266 100644
--- a/sys/contrib/dev/acpica/compiler/asltransform.c
+++ b/sys/contrib/dev/acpica/compiler/asltransform.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: asltransform - Parse tree transforms
- *              $Revision: 1.35 $
+ *              $Revision: 1.42 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -429,7 +429,7 @@ TrDoDefinitionBlock (
              * to be at the root of the namespace;  Therefore, namepath
              * optimization can only be performed on the DSDT.
              */
-            if (ACPI_STRNCMP (Next->Asl.Value.String, "DSDT", 4))
+            if (!ACPI_COMPARE_NAME (Next->Asl.Value.String, ACPI_SIG_DSDT))
             {
                 Gbl_ReferenceOptimizationFlag = FALSE;
             }
@@ -661,15 +661,16 @@ TrDoSwitch (
             {
                 /*
                  * More than one Default
-                 * (Parser should catch this, should not get here)
+                 * (Parser does not catch this, must check here)
                  */
-                AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Next,
-                    "Found more than one Default()");
+                AslError (ASL_ERROR, ASL_MSG_MULTIPLE_DEFAULT, Next, NULL);
             }
+            else
+            {
+                /* Save the DEFAULT node for later, after CASEs */
 
-            /* Save the DEFAULT node for later, after CASEs */
-
-            DefaultOp = Next;
+                DefaultOp = Next;
+            }
         }
         else
         {
@@ -708,28 +709,55 @@ TrDoSwitch (
         AslError (ASL_ERROR, ASL_MSG_NO_CASES, StartNode, NULL);
     }
 
+
     /*
-     * Add a NAME node for the temp integer:
-     * Change the SWITCH node to a Name (_T_x, Type)
+     * Create a Name(_T_x, ...) statement. This statement must appear at the
+     * method level, in case a loop surrounds the switch statement and could
+     * cause the name to be created twice (error).
      */
+
+    /* Create the Name node */
+
     Predicate = StartNode->Asl.Child;
-    TrAmlInitNode (StartNode, PARSEOP_NAME);
+    NewOp = TrCreateLeafNode (PARSEOP_NAME);
 
-    NewOp = StartNode;
+    /* Find the parent method */
+
+    Next = StartNode;
+    while ((Next->Asl.ParseOpcode != PARSEOP_METHOD) &&
+           (Next->Asl.ParseOpcode != PARSEOP_DEFINITIONBLOCK))
+    {
+        Next = Next->Asl.Parent;
+    }
 
     NewOp->Asl.CompileFlags |= NODE_COMPILER_EMITTED;
+    NewOp->Asl.Parent = Next;
+
+    /* Insert name after the method name and arguments */
+
+    Next = Next->Asl.Child;
+    Next = Next->Asl.Next;
+    Next = Next->Asl.Next;
+    Next = Next->Asl.Next;
+    Next = Next->Asl.Next;
+    Next = Next->Asl.Next;
+
+    TrAmlInsertPeer (Next, NewOp);
+    TrAmlInitLineNumbers (NewOp, Next);
+
+    /* Create the NameSeg child for the Name node */
 
     NewOp2 = TrCreateValuedLeafNode (PARSEOP_NAMESEG,
                 (ACPI_INTEGER) ACPI_TO_INTEGER (PredicateValueName));
     NewOp2->Asl.CompileFlags |= NODE_IS_NAME_DECLARATION;
     NewOp->Asl.Child  = NewOp2;
 
-    /* Btype was already validated above */
+    /* Create the initial value for the Name. Btype was already validated above */
 
     switch (Btype)
     {
     case ACPI_BTYPE_INTEGER:
-        NewOp2->Asl.Next  = TrCreateValuedLeafNode (PARSEOP_ZERO,
+        NewOp2->Asl.Next = TrCreateValuedLeafNode (PARSEOP_ZERO,
                                 (ACPI_INTEGER) 0);
         break;
 
@@ -757,26 +785,21 @@ TrDoSwitch (
     TrAmlSetSubtreeParent (NewOp2, NewOp);
 
     /*
-     * Create and insert a new Store() node which will be used to save the
+     * Transform the Switch() into a Store() node which will be used to save the
      * Switch() value.  The store is of the form: Store (Value, _T_x)
      * where _T_x is the temp variable.
      */
-    Next = TrCreateLeafNode (PARSEOP_STORE);
-    TrAmlInsertPeer (StartNode, Next);
-    TrAmlSetSubtreeParent (Next, StartNode->Asl.Parent);
-
-    TrAmlInitLineNumbers (Next, StartNode);
-    TrAmlInitLineNumbers (NewOp2, StartNode);
-    TrAmlInitLineNumbers (NewOp2->Asl.Next, StartNode);
+    TrAmlInitNode (StartNode, PARSEOP_STORE);
+    StartNode->Asl.Child = NULL;
 
     /* Complete the Store subtree */
 
-    Next->Asl.Child       = Predicate;
-    Predicate->Asl.Parent = Next;
+    StartNode->Asl.Child = Predicate;
+    Predicate->Asl.Parent = StartNode;
 
     NewOp = TrCreateValuedLeafNode (PARSEOP_NAMESEG,
                 (ACPI_INTEGER) ACPI_TO_INTEGER (PredicateValueName));
-    NewOp->Asl.Parent    = Next;
+    NewOp->Asl.Parent    = StartNode;
     Predicate->Asl.Next  = NewOp;
 }
 
diff --git a/sys/contrib/dev/acpica/compiler/asltree.c b/sys/contrib/dev/acpica/compiler/asltree.c
index 6092607..db9893d 100644
--- a/sys/contrib/dev/acpica/compiler/asltree.c
+++ b/sys/contrib/dev/acpica/compiler/asltree.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: asltree - parse tree management
- *              $Revision: 1.60 $
+ *              $Revision: 1.63 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -467,8 +467,8 @@ TrCreateLeafNode (
     Op = TrAllocateNode (ParseOpcode);
 
     DbgPrint (ASL_PARSE_OUTPUT,
-        "\nCreateLeafNode  Line %d NewNode %p  Op %s\n\n",
-        Op->Asl.LineNumber, Op, UtGetOpName(ParseOpcode));
+        "\nCreateLeafNode  Ln/Col %d/%d NewNode %p  Op %s\n\n",
+        Op->Asl.LineNumber, Op->Asl.Column, Op, UtGetOpName(ParseOpcode));
 
     return Op;
 }
@@ -499,8 +499,8 @@ TrCreateValuedLeafNode (
     Op = TrAllocateNode (ParseOpcode);
 
     DbgPrint (ASL_PARSE_OUTPUT,
-        "\nCreateValuedLeafNode  Line %d NewNode %p  Op %s  Value %8.8X%8.8X  ",
-        Op->Asl.LineNumber, Op, UtGetOpName(ParseOpcode),
+        "\nCreateValuedLeafNode  Ln/Col %d/%d NewNode %p  Op %s  Value %8.8X%8.8X  ",
+        Op->Asl.LineNumber, Op->Asl.Column, Op, UtGetOpName(ParseOpcode),
         ACPI_FORMAT_UINT64 (Value));
     Op->Asl.Value.Integer = Value;
 
@@ -576,8 +576,8 @@ TrCreateNode (
     Op = TrAllocateNode (ParseOpcode);
 
     DbgPrint (ASL_PARSE_OUTPUT,
-        "\nCreateNode  Line %d NewParent %p Child %d Op %s  ",
-        Op->Asl.LineNumber, Op, NumChildren, UtGetOpName(ParseOpcode));
+        "\nCreateNode  Ln/Col %d/%d NewParent %p Child %d Op %s  ",
+        Op->Asl.LineNumber, Op->Asl.Column, Op, NumChildren, UtGetOpName(ParseOpcode));
 
     /* Some extra debug output based on the parse opcode */
 
diff --git a/sys/contrib/dev/acpica/compiler/asltypes.h b/sys/contrib/dev/acpica/compiler/asltypes.h
index e681376..51beeb2 100644
--- a/sys/contrib/dev/acpica/compiler/asltypes.h
+++ b/sys/contrib/dev/acpica/compiler/asltypes.h
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: asltypes.h - compiler data types and struct definitions
- *              $Revision: 1.78 $
+ *              $Revision: 1.89 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -148,6 +148,7 @@
 #define NODE_IS_NAME_DECLARATION    0x00010000
 #define NODE_COMPILER_EMITTED       0x00020000
 #define NODE_IS_DUPLICATE           0x00040000
+#define NODE_IS_RESOURCE_DATA       0x00080000
 
 /* Keeps information about individual control methods */
 
@@ -222,6 +223,13 @@ typedef struct asl_file_info
 
 } ASL_FILE_INFO;
 
+typedef struct asl_file_status
+{
+    UINT32                  Line;
+    UINT32                  Offset;
+
+} ASL_FILE_STATUS;
+
 
 /* File types */
 
@@ -296,15 +304,18 @@ typedef struct asl_event_info
 } ASL_EVENT_INFO;
 
 
-#define ASL_ERROR               0
-#define ASL_WARNING             1
-#define ASL_REMARK              2
-#define ASL_OPTIMIZATION        3
-#define ASL_NUM_REPORT_LEVELS   4
+#define ASL_WARNING             0
+#define ASL_WARNING2            1
+#define ASL_WARNING3            2
+#define ASL_ERROR               3
+#define ASL_REMARK              4
+#define ASL_OPTIMIZATION        5
+#define ASL_NUM_REPORT_LEVELS   6
 
 
 typedef enum
 {
+    ASL_MSG_RESERVED = 0,
     ASL_MSG_ALPHANUMERIC_STRING,
     ASL_MSG_AML_NOT_IMPLEMENTED,
     ASL_MSG_ARG_COUNT_HI,
@@ -396,7 +407,6 @@ typedef enum
     ASL_MSG_SEEK,
     ASL_MSG_SINGLE_NAME_OPTIMIZATION,
     ASL_MSG_SOME_NO_RETVAL,
-    ASL_MSG_STRING_LENGTH,
     ASL_MSG_SWITCH_TYPE,
     ASL_MSG_SYNC_LEVEL,
     ASL_MSG_SYNTAX,
@@ -406,13 +416,20 @@ typedef enum
     ASL_MSG_UNREACHABLE_CODE,
     ASL_MSG_UNSUPPORTED,
     ASL_MSG_VENDOR_LIST,
-    ASL_MSG_WRITE
+    ASL_MSG_WRITE,
+    ASL_MSG_MULTIPLE_DEFAULT,
+    ASL_MSG_TIMEOUT,
+    ASL_MSG_RESULT_NOT_USED,
+    ASL_MSG_NOT_REFERENCED,
+    ASL_MSG_NON_ZERO,
+    ASL_MSG_STRING_LENGTH
 
 } ASL_MESSAGE_IDS;
 
 #ifdef ASL_EXCEPTIONS
 
 char                        *AslMessages [] = {
+/*    The zeroth message is resesrved */    "",
 /*    ASL_MSG_ALPHANUMERIC_STRING */        "String must be entirely alphanumeric",
 /*    ASL_MSG_AML_NOT_IMPLEMENTED */        "Opcode is not implemented in compiler AML code generator",
 /*    ASL_MSG_ARG_COUNT_HI */               "Too many arguments",
@@ -470,7 +487,7 @@ char                        *AslMessages [] = {
 /*    ASL_MSG_NAME_EXISTS */                "Name already exists in scope",
 /*    ASL_MSG_NAME_OPTIMIZATION */          "NamePath optimized",
 /*    ASL_MSG_NESTED_COMMENT */             "Nested comment found",
-/*    ASL_MSG_NO_CASES */                   "No Case() statements under Switch()",
+/*    ASL_MSG_NO_CASES */                   "No Case statements under Switch",
 /*    ASL_MSG_NO_RETVAL */                  "Called method returns no value",
 /*    ASL_MSG_NO_WHILE */                   "No enclosing While statement",
 /*    ASL_MSG_NON_ASCII */                  "Invalid characters found in file",
@@ -478,7 +495,7 @@ char                        *AslMessages [] = {
 /*    ASL_MSG_NOT_FOUND */                  "Object not found or not accessible from scope",
 /*    ASL_MSG_NOT_METHOD */                 "Not a control method, cannot invoke",
 /*    ASL_MSG_NOT_PARAMETER */              "Not a parameter, used as local only",
-/*    ASL_MSG_NOT_REACHABLE */              "Object not accessible from this scope",
+/*    ASL_MSG_NOT_REACHABLE */              "Object is not accessible from this scope",
 /*    ASL_MSG_OPEN */                       "Could not open file",
 /*    ASL_MSG_OUTPUT_FILE_OPEN */           "Could not open output AML file",
 /*    ASL_MSG_OUTPUT_FILENAME */            "Could not create output filename",
@@ -499,12 +516,11 @@ char                        *AslMessages [] = {
 /*    ASL_MSG_RESOURCE_LIST */              "Too many resource items (internal error)",
 /*    ASL_MSG_RESOURCE_SOURCE */            "Missing ResourceSource string (required)",
 /*    ASL_MSG_RETURN_TYPES */               "Not all control paths return a value",
-/*    ASL_MSG_SCOPE_FWD_REF */              "Forward references from Scope() not allowed",
+/*    ASL_MSG_SCOPE_FWD_REF */              "Forward references from Scope operator not allowed",
 /*    ASL_MSG_SCOPE_TYPE */                 "Existing object has invalid type for Scope operator",
 /*    ASL_MSG_SEEK */                       "Could not seek file",
 /*    ASL_MSG_SINGLE_NAME_OPTIMIZATION */   "NamePath optimized to NameSeg (uses run-time search path)",
 /*    ASL_MSG_SOME_NO_RETVAL */             "Called method may not always return a value",
-/*    ASL_MSG_STRING_LENGTH */              "String constant too long (200 max)",
 /*    ASL_MSG_SWITCH_TYPE */                "Switch expression is not a static Integer/Buffer/String data type, defaulting to Integer",
 /*    ASL_MSG_SYNC_LEVEL */                 "SyncLevel must be in the range 0-15",
 /*    ASL_MSG_SYNTAX */                     "",
@@ -514,14 +530,22 @@ char                        *AslMessages [] = {
 /*    ASL_MSG_UNREACHABLE_CODE */           "Statement is unreachable",
 /*    ASL_MSG_UNSUPPORTED */                "Unsupported feature",
 /*    ASL_MSG_VENDOR_LIST */                "Too many vendor data bytes (7 max)",
-/*    ASL_MSG_WRITE */                      "Could not write file"
+/*    ASL_MSG_WRITE */                      "Could not write file",
+/*    ASL_MSG_MULTIPLE_DEFAULT */           "More than one Default statement within Switch construct",
+/*    ASL_MSG_TIMEOUT */                    "Possible operator timeout is ignored",
+/*    ASL_MSG_RESULT_NOT_USED */            "Result is not used, operator has no effect",
+/*    ASL_MSG_NOT_REFERENCED */             "Namespace object is not referenced",
+/*    ASL_MSG_NON_ZERO */                   "Operand evaluates to zero",
+/*    ASL_MSG_STRING_LENGTH */              "String literal too long"
 
 };
 
 
 char                    *AslErrorLevel [ASL_NUM_REPORT_LEVELS] = {
-    "Error   ",
     "Warning ",
+    "Warning ",
+    "Warning ",
+    "Error   ",
     "Remark  ",
     "Optimize"
 };
@@ -530,7 +554,7 @@ char                    *AslErrorLevel [ASL_NUM_REPORT_LEVELS] = {
 
 /* Exception counters */
 
-UINT32                  Gbl_ExceptionCount[ASL_NUM_REPORT_LEVELS] = {0,0,0,0};
+UINT32                  Gbl_ExceptionCount[ASL_NUM_REPORT_LEVELS] = {0,0,0,0,0,0};
 
 #endif
 
diff --git a/sys/contrib/dev/acpica/compiler/aslutils.c b/sys/contrib/dev/acpica/compiler/aslutils.c
index 1c9f48b..5acf1fc 100644
--- a/sys/contrib/dev/acpica/compiler/aslutils.c
+++ b/sys/contrib/dev/acpica/compiler/aslutils.c
@@ -2,7 +2,7 @@
 /******************************************************************************
  *
  * Module Name: aslutils -- compiler utilities
- *              $Revision: 1.66 $
+ *              $Revision: 1.72 $
  *
  *****************************************************************************/
 
@@ -10,7 +10,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -166,7 +166,7 @@ void
 UtDisplayConstantOpcodes (
     void)
 {
-    UINT32              i;
+    UINT32                  i;
 
 
     printf ("Constant expression opcode information\n\n");
@@ -202,7 +202,7 @@ UtLocalCalloc (
     void                    *Allocated;
 
 
-    Allocated = ACPI_MEM_CALLOCATE (Size);
+    Allocated = ACPI_ALLOCATE_ZEROED (Size);
     if (!Allocated)
     {
         AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
@@ -214,7 +214,7 @@ UtLocalCalloc (
 
     TotalAllocations++;
     TotalAllocated += Size;
-    return Allocated;
+    return (Allocated);
 }
 
 
@@ -359,7 +359,6 @@ UtConvertByteToAsmHex (
 {
 
     Buffer[0] = '0';
-
     Buffer[1] = (UINT8) hex[(RawByte >> 4) & 0xF];
     Buffer[2] = (UINT8) hex[RawByte & 0xF];
     Buffer[3] = 'h';
@@ -430,9 +429,13 @@ UtPrintFormattedName (
     UINT32                  Level)
 {
 
+    if (Level)
+    {
+        DbgPrint (ASL_TREE_OUTPUT,
+            "%*s", (3 * Level), " ");
+    }
     DbgPrint (ASL_TREE_OUTPUT,
-        "%*s %-16.16s", (3 * Level), " ",
-        UtGetOpName (ParseOpcode));
+        " %-20.20s", UtGetOpName (ParseOpcode));
 
     if (Level < TEXT_OFFSET)
     {
@@ -459,7 +462,8 @@ UtSetParseOpName (
     ACPI_PARSE_OBJECT       *Op)
 {
 
-    strncpy (Op->Asl.ParseOpName, UtGetOpName (Op->Asl.ParseOpcode), 12);
+    strncpy (Op->Asl.ParseOpName, UtGetOpName (Op->Asl.ParseOpcode),
+        ACPI_MAX_PARSEOP_NAME);
 }
 
 
@@ -484,7 +488,8 @@ UtGetOpName (
      * First entries (ASL_YYTNAME_START) in yytname are special reserved names.
      * Ignore first 8 characters of the name
      */
-    return ((char *) yytname [(ParseOpcode - ASL_FIRST_PARSE_OPCODE) + ASL_YYTNAME_START] + 8);
+    return ((char *) yytname
+        [(ParseOpcode - ASL_FIRST_PARSE_OPCODE) + ASL_YYTNAME_START] + 8);
 }
 
 
@@ -535,7 +540,9 @@ UtDisplaySummary (
     FlPrintFile (FileId,
         "Compilation complete. %d Errors, %d Warnings, %d Remarks, %d Optimizations\n",
         Gbl_ExceptionCount[ASL_ERROR],
-        Gbl_ExceptionCount[ASL_WARNING],
+        Gbl_ExceptionCount[ASL_WARNING] +
+            Gbl_ExceptionCount[ASL_WARNING2] +
+            Gbl_ExceptionCount[ASL_WARNING3],
         Gbl_ExceptionCount[ASL_REMARK],
         Gbl_ExceptionCount[ASL_OPTIMIZATION]);
 }
@@ -545,7 +552,7 @@ UtDisplaySummary (
  *
  * FUNCTION:    UtDisplaySummary
  *
- * PARAMETERS:  Op            - Integer parse node
+ * PARAMETERS:  Op              - Integer parse node
  *              LowValue        - Smallest allowed value
  *              HighValue       - Largest allowed value
  *