自学教程：C++ AcpiUtCreateIntegerObject函数代码示例

ACPI_STATUSAcpiNsConvertToInteger (    ACPI_OPERAND_OBJECT     *OriginalObject,    ACPI_OPERAND_OBJECT     **ReturnObject){    ACPI_OPERAND_OBJECT     *NewObject;    ACPI_STATUS             Status;    UINT64                  Value = 0;    UINT32                  i;    switch (OriginalObject->Common.Type)    {    case ACPI_TYPE_STRING:        /* String-to-Integer conversion */        Status = AcpiUtStrtoul64 (OriginalObject->String.Pointer,            ACPI_ANY_BASE, AcpiGbl_IntegerByteWidth, &Value);        if (ACPI_FAILURE (Status))        {            return (Status);        }        break;    case ACPI_TYPE_BUFFER:        /* Buffer-to-Integer conversion. Max buffer size is 64 bits. */        if (OriginalObject->Buffer.Length > 8)        {            return (AE_AML_OPERAND_TYPE);        }        /* Extract each buffer byte to create the integer */        for (i = 0; i < OriginalObject->Buffer.Length; i++)        {            Value |= ((UINT64)                OriginalObject->Buffer.Pointer[i] << (i * 8));        }        break;    default:        return (AE_AML_OPERAND_TYPE);    }    NewObject = AcpiUtCreateIntegerObject (Value);    if (!NewObject)    {        return (AE_NO_MEMORY);    }    *ReturnObject = NewObject;    return (AE_OK);}

ACPI_STATUSAcpiExOpcode_0A_0T_1R (    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status = AE_OK;    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;    ACPI_FUNCTION_TRACE_STR (ExOpcode_0A_0T_1R,        AcpiPsGetOpcodeName (WalkState->Opcode));    /* Examine the AML opcode */    switch (WalkState->Opcode)    {    case AML_TIMER_OP:      /*  Timer () */        /* Create a return object of type Integer */        ReturnDesc = AcpiUtCreateIntegerObject (AcpiOsGetTimer ());        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        break;    default:                /*  Unknown opcode  */        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",            WalkState->Opcode));        Status = AE_AML_BAD_OPCODE;        break;    }Cleanup:    /* Delete return object on error */    if ((ACPI_FAILURE (Status)) || WalkState->ResultObj)    {        AcpiUtRemoveReference (ReturnDesc);        WalkState->ResultObj = NULL;    }    else    {        /* Save the return value */        WalkState->ResultObj = ReturnDesc;    }    return_ACPI_STATUS (Status);}

static ACPI_STATUSAcpiNsConvertToPackage (    ACPI_OPERAND_OBJECT     *OriginalObject,    ACPI_OPERAND_OBJECT     **ReturnObject){    ACPI_OPERAND_OBJECT     *NewObject;    ACPI_OPERAND_OBJECT     **Elements;    UINT32                  Length;    UINT8                   *Buffer;    switch (OriginalObject->Common.Type)    {    case ACPI_TYPE_BUFFER:        /* Buffer-to-Package conversion */        Length = OriginalObject->Buffer.Length;        NewObject = AcpiUtCreatePackageObject (Length);        if (!NewObject)        {            return (AE_NO_MEMORY);        }        /* Convert each buffer byte to an integer package element */        Elements = NewObject->Package.Elements;        Buffer = OriginalObject->Buffer.Pointer;        while (Length--)        {            *Elements = AcpiUtCreateIntegerObject ((UINT64) *Buffer);            if (!*Elements)            {                AcpiUtRemoveReference (NewObject);                return (AE_NO_MEMORY);            }            Elements++;            Buffer++;        }        break;    default:        return (AE_AML_OPERAND_TYPE);    }    *ReturnObject = NewObject;    return (AE_OK);}

voidAeDoObjectOverrides (    void){    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_WALK_STATE         *WalkState;    int                     i;    if (!InitFile)    {        return;    }    /* Create needed objects to be reused for each init entry */    ObjDesc = AcpiUtCreateIntegerObject (0);    WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);    NameBuffer[0] = '//';    /* Read the entire file line-by-line */    while (fgets (LineBuffer, AE_FILE_BUFFER_SIZE, InitFile) != NULL)    {        if (sscanf (LineBuffer, "%s %s/n",                &NameBuffer[1], ValueBuffer) != 2)        {            goto CleanupAndExit;        }        /* Add a root prefix if not present in the string */        i = 0;        if (NameBuffer[1] == '//')        {            i = 1;        }        AeDoOneOverride (&NameBuffer[i], ValueBuffer, ObjDesc, WalkState);    }    /* Cleanup */CleanupAndExit:    fclose (InitFile);    AcpiDsDeleteWalkState (WalkState);    AcpiUtRemoveReference (ObjDesc);}

ACPI_STATUSAcpiExOpcode_6A_0T_1R (    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;    ACPI_STATUS             Status = AE_OK;    UINT64                  Index;    ACPI_OPERAND_OBJECT     *ThisElement;    ACPI_FUNCTION_TRACE_STR (ExOpcode_6A_0T_1R,                             AcpiPsGetOpcodeName (WalkState->Opcode));    switch (WalkState->Opcode)    {    case AML_MATCH_OP:        /*         * Match (SearchPkg[0], MatchOp1[1], MatchObj1[2],         *                      MatchOp2[3], MatchObj2[4], StartIndex[5])         */        /* Validate both Match Term Operators (MTR, MEQ, etc.) */        if ((Operand[1]->Integer.Value > MAX_MATCH_OPERATOR) ||                (Operand[3]->Integer.Value > MAX_MATCH_OPERATOR))        {            ACPI_ERROR ((AE_INFO, "Match operator out of range"));            Status = AE_AML_OPERAND_VALUE;            goto Cleanup;        }        /* Get the package StartIndex, validate against the package length */        Index = Operand[5]->Integer.Value;        if (Index >= Operand[0]->Package.Count)        {            ACPI_ERROR ((AE_INFO,                         "Index (0x%8.8X%8.8X) beyond package end (0x%X)",                         ACPI_FORMAT_UINT64 (Index), Operand[0]->Package.Count));            Status = AE_AML_PACKAGE_LIMIT;            goto Cleanup;        }        /* Create an integer for the return value */        /* Default return value is ACPI_UINT64_MAX if no match found */        ReturnDesc = AcpiUtCreateIntegerObject (ACPI_UINT64_MAX);        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        /*         * Examine each element until a match is found. Both match conditions         * must be satisfied for a match to occur. Within the loop,         * "continue" signifies that the current element does not match         * and the next should be examined.         *         * Upon finding a match, the loop will terminate via "break" at         * the bottom. If it terminates "normally", MatchValue will be         * ACPI_UINT64_MAX (Ones) (its initial value) indicating that no         * match was found.         */        for ( ; Index < Operand[0]->Package.Count; Index++)        {            /* Get the current package element */            ThisElement = Operand[0]->Package.Elements[Index];            /* Treat any uninitialized (NULL) elements as non-matching */            if (!ThisElement)            {                continue;            }            /*             * Both match conditions must be satisfied. Execution of a continue             * (proceed to next iteration of enclosing for loop) signifies a             * non-match.             */            if (!AcpiExDoMatch ((UINT32) Operand[1]->Integer.Value,                                ThisElement, Operand[2]))            {                continue;            }            if (!AcpiExDoMatch ((UINT32) Operand[3]->Integer.Value,                                ThisElement, Operand[4]))            {                continue;            }            /* Match found: Index is the return value */            ReturnDesc->Integer.Value = Index;//.........这里部分代码省略.........

ACPI_STATUSAcpiExOpcode_1A_0T_1R (    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_OPERAND_OBJECT     *TempDesc;    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;    ACPI_STATUS             Status = AE_OK;    UINT32                  Type;    UINT64                  Value;    ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_0T_1R,        AcpiPsGetOpcodeName (WalkState->Opcode));    /* Examine the AML opcode */    switch (WalkState->Opcode)    {    case AML_LNOT_OP:               /* LNot (Operand) */        ReturnDesc = AcpiUtCreateIntegerObject ((UINT64) 0);        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        /*         * Set result to ONES (TRUE) if Value == 0. Note:         * ReturnDesc->Integer.Value is initially == 0 (FALSE) from above.         */        if (!Operand[0]->Integer.Value)        {            ReturnDesc->Integer.Value = ACPI_UINT64_MAX;        }        break;    case AML_DECREMENT_OP:          /* Decrement (Operand)  */    case AML_INCREMENT_OP:          /* Increment (Operand)  */        /*         * Create a new integer. Can't just get the base integer and         * increment it because it may be an Arg or Field.         */        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        /*         * Since we are expecting a Reference operand, it can be either a         * NS Node or an internal object.         */        TempDesc = Operand[0];        if (ACPI_GET_DESCRIPTOR_TYPE (TempDesc) == ACPI_DESC_TYPE_OPERAND)        {            /* Internal reference object - prevent deletion */            AcpiUtAddReference (TempDesc);        }        /*         * Convert the Reference operand to an Integer (This removes a         * reference on the Operand[0] object)         *         * NOTE:  We use LNOT_OP here in order to force resolution of the         * reference operand to an actual integer.         */        Status = AcpiExResolveOperands (AML_LNOT_OP, &TempDesc, WalkState);        if (ACPI_FAILURE (Status))        {            ACPI_EXCEPTION ((AE_INFO, Status,                "While resolving operands for [%s]",                AcpiPsGetOpcodeName (WalkState->Opcode)));            goto Cleanup;        }        /*         * TempDesc is now guaranteed to be an Integer object --         * Perform the actual increment or decrement         */        if (WalkState->Opcode == AML_INCREMENT_OP)        {            ReturnDesc->Integer.Value = TempDesc->Integer.Value + 1;        }        else        {            ReturnDesc->Integer.Value = TempDesc->Integer.Value - 1;        }        /* Finished with this Integer object */        AcpiUtRemoveReference (TempDesc);        /*         * Store the result back (indirectly) through the original//.........这里部分代码省略.........

voidAcpiDbSetMethodData (    char                    *TypeArg,    char                    *IndexArg,    char                    *ValueArg){    char                    Type;    UINT32                  Index;    UINT32                  Value;    ACPI_WALK_STATE         *WalkState;    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    /* Validate TypeArg */    AcpiUtStrupr (TypeArg);    Type = TypeArg[0];    if ((Type != 'L') &&        (Type != 'A') &&        (Type != 'N'))    {        AcpiOsPrintf ("Invalid SET operand: %s/n", TypeArg);        return;    }    Value = ACPI_STRTOUL (ValueArg, NULL, 16);    if (Type == 'N')    {        Node = AcpiDbConvertToNode (IndexArg);        if (Node->Type != ACPI_TYPE_INTEGER)        {            AcpiOsPrintf ("Can only set Integer nodes/n");            return;        }        ObjDesc = Node->Object;        ObjDesc->Integer.Value = Value;        return;    }    /* Get the index and value */    Index = ACPI_STRTOUL (IndexArg, NULL, 16);    WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);    if (!WalkState)    {        AcpiOsPrintf ("There is no method currently executing/n");        return;    }    /* Create and initialize the new object */    ObjDesc = AcpiUtCreateIntegerObject ((UINT64) Value);    if (!ObjDesc)    {        AcpiOsPrintf ("Could not create an internal object/n");        return;    }    /* Store the new object into the target */    switch (Type)    {    case 'A':        /* Set a method argument */        if (Index > ACPI_METHOD_MAX_ARG)        {            AcpiOsPrintf ("Arg%u - Invalid argument name/n", Index);            goto Cleanup;        }        Status = AcpiDsStoreObjectToLocal (ACPI_REFCLASS_ARG, Index, ObjDesc,                    WalkState);        if (ACPI_FAILURE (Status))        {            goto Cleanup;        }        ObjDesc = WalkState->Arguments[Index].Object;        AcpiOsPrintf ("Arg%u: ", Index);        AcpiDmDisplayInternalObject (ObjDesc, WalkState);        break;    case 'L':        /* Set a method local */        if (Index > ACPI_METHOD_MAX_LOCAL)        {            AcpiOsPrintf ("Local%u - Invalid local variable name/n", Index);            goto Cleanup;        }        Status = AcpiDsStoreObjectToLocal (ACPI_REFCLASS_LOCAL, Index, ObjDesc,//.........这里部分代码省略.........

//.........这里部分代码省略.........        return_ACPI_STATUS (AE_OK);    case ACPI_TYPE_BUFFER:    case ACPI_TYPE_STRING:        /* Note: Takes advantage of common buffer/string fields */        Pointer = ObjDesc->Buffer.Pointer;        Count   = ObjDesc->Buffer.Length;        break;    default:        return_ACPI_STATUS (AE_TYPE);    }    /*     * Convert the buffer/string to an integer. Note that both buffers and     * strings are treated as raw data - we don't convert ascii to hex for     * strings.     *     * There are two terminating conditions for the loop:     * 1) The size of an integer has been reached, or     * 2) The end of the buffer or string has been reached     */    Result = 0;    /* String conversion is different than Buffer conversion */    switch (ObjDesc->Common.Type)    {    case ACPI_TYPE_STRING:        /*         * Convert string to an integer - for most cases, the string must be         * hexadecimal as per the ACPI specification. The only exception (as         * of ACPI 3.0) is that the ToInteger() operator allows both decimal         * and hexadecimal strings (hex prefixed with "0x").         */        Status = AcpiUtStrtoul64 ((char *) Pointer, Flags, &Result);        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }        break;    case ACPI_TYPE_BUFFER:        /* Check for zero-length buffer */        if (!Count)        {            return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);        }        /* Transfer no more than an integer's worth of data */        if (Count > AcpiGbl_IntegerByteWidth)        {            Count = AcpiGbl_IntegerByteWidth;        }        /*         * Convert buffer to an integer - we simply grab enough raw data         * from the buffer to fill an integer         */        for (i = 0; i < Count; i++)        {            /*             * Get next byte and shift it into the Result.             * Little endian is used, meaning that the first byte of the buffer             * is the LSB of the integer             */            Result |= (((UINT64) Pointer[i]) << (i * 8));        }        break;    default:        /* No other types can get here */        break;    }    /* Create a new integer */    ReturnDesc = AcpiUtCreateIntegerObject (Result);    if (!ReturnDesc)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X/n",        ACPI_FORMAT_UINT64 (Result)));    /* Save the Result */    (void) AcpiExTruncateFor32bitTable (ReturnDesc);    *ResultDesc = ReturnDesc;    return_ACPI_STATUS (AE_OK);}

//.........这里部分代码省略.........        }        /* Delete this walk state and all linked control states */        AcpiPsCleanupScope (&WalkState->ParserState);        PreviousWalkState = WalkState;        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,            "ReturnValue=%p, ImplicitValue=%p State=%p/n",            WalkState->ReturnDesc, WalkState->ImplicitReturnObj, WalkState));        /* Check if we have restarted a preempted walk */        WalkState = AcpiDsGetCurrentWalkState (Thread);        if (WalkState)        {            if (ACPI_SUCCESS (Status))            {                /*                 * There is another walk state, restart it.                 * If the method return value is not used by the parent,                 * The object is deleted                 */                if (!PreviousWalkState->ReturnDesc)                {                    /*                     * In slack mode execution, if there is no return value                     * we should implicitly return zero (0) as a default value.                     */                    if (AcpiGbl_EnableInterpreterSlack &&                        !PreviousWalkState->ImplicitReturnObj)                    {                        PreviousWalkState->ImplicitReturnObj =                            AcpiUtCreateIntegerObject ((UINT64) 0);                        if (!PreviousWalkState->ImplicitReturnObj)                        {                            return_ACPI_STATUS (AE_NO_MEMORY);                        }                    }                    /* Restart the calling control method */                    Status = AcpiDsRestartControlMethod (WalkState,                                PreviousWalkState->ImplicitReturnObj);                }                else                {                    /*                     * We have a valid return value, delete any implicit                     * return value.                     */                    AcpiDsClearImplicitReturn (PreviousWalkState);                    Status = AcpiDsRestartControlMethod (WalkState,                                PreviousWalkState->ReturnDesc);                }                if (ACPI_SUCCESS (Status))                {                    WalkState->WalkType |= ACPI_WALK_METHOD_RESTART;                }            }            else            {                /* On error, delete any return object or implicit return */                AcpiUtRemoveReference (PreviousWalkState->ReturnDesc);

ACPI_STATUSAcpiExLoadTableOp (    ACPI_WALK_STATE         *WalkState,    ACPI_OPERAND_OBJECT     **ReturnDesc){    ACPI_STATUS             Status;    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_NAMESPACE_NODE     *ParentNode;    ACPI_NAMESPACE_NODE     *StartNode;    ACPI_NAMESPACE_NODE     *ParameterNode = NULL;    ACPI_OPERAND_OBJECT     *DdbHandle;    ACPI_TABLE_HEADER       *Table;    UINT32                  TableIndex;    ACPI_FUNCTION_TRACE (ExLoadTableOp);    /* Validate lengths for the SignatureString, OEMIDString, OEMTableID */    if ((Operand[0]->String.Length > ACPI_NAME_SIZE) ||        (Operand[1]->String.Length > ACPI_OEM_ID_SIZE) ||        (Operand[2]->String.Length > ACPI_OEM_TABLE_ID_SIZE))    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Find the ACPI table in the RSDT/XSDT */    Status = AcpiTbFindTable (Operand[0]->String.Pointer,                              Operand[1]->String.Pointer,                              Operand[2]->String.Pointer, &TableIndex);    if (ACPI_FAILURE (Status))    {        if (Status != AE_NOT_FOUND)        {            return_ACPI_STATUS (Status);        }        /* Table not found, return an Integer=0 and AE_OK */        DdbHandle = AcpiUtCreateIntegerObject ((UINT64) 0);        if (!DdbHandle)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }        *ReturnDesc = DdbHandle;        return_ACPI_STATUS (AE_OK);    }    /* Default nodes */    StartNode = WalkState->ScopeInfo->Scope.Node;    ParentNode = AcpiGbl_RootNode;    /* RootPath (optional parameter) */    if (Operand[3]->String.Length > 0)    {        /*         * Find the node referenced by the RootPathString.  This is the         * location within the namespace where the table will be loaded.         */        Status = AcpiNsGetNode (StartNode, Operand[3]->String.Pointer,                    ACPI_NS_SEARCH_PARENT, &ParentNode);        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }    }    /* ParameterPath (optional parameter) */    if (Operand[4]->String.Length > 0)    {        if ((Operand[4]->String.Pointer[0] != '//') &&            (Operand[4]->String.Pointer[0] != '^'))        {            /*             * Path is not absolute, so it will be relative to the node             * referenced by the RootPathString (or the NS root if omitted)             */            StartNode = ParentNode;        }        /* Find the node referenced by the ParameterPathString */        Status = AcpiNsGetNode (StartNode, Operand[4]->String.Pointer,                    ACPI_NS_SEARCH_PARENT, &ParameterNode);        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }    }    /* Load the table into the namespace */    Status = AcpiExAddTable (TableIndex, ParentNode, &DdbHandle);    if (ACPI_FAILURE (Status))//.........这里部分代码省略.........

ACPI_STATUSAcpiDsMethodDataGetValue (    UINT8                   Type,    UINT32                  Index,    ACPI_WALK_STATE         *WalkState,    ACPI_OPERAND_OBJECT     **DestDesc){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    ACPI_OPERAND_OBJECT     *Object;    ACPI_FUNCTION_TRACE (DsMethodDataGetValue);    /* Validate the object descriptor */    if (!DestDesc)    {        ACPI_ERROR ((AE_INFO, "Null object descriptor pointer"));        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Get the namespace node for the arg/local */    Status = AcpiDsMethodDataGetNode (Type, Index, WalkState, &Node);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Get the object from the node */    Object = Node->Object;    /* Examine the returned object, it must be valid. */    if (!Object)    {        /*         * Index points to uninitialized object.         * This means that either 1) The expected argument was         * not passed to the method, or 2) A local variable         * was referenced by the method (via the ASL)         * before it was initialized.  Either case is an error.         */        /* If slack enabled, init the LocalX/ArgX to an Integer of value zero */        if (AcpiGbl_EnableInterpreterSlack)        {            Object = AcpiUtCreateIntegerObject ((UINT64) 0);            if (!Object)            {                return_ACPI_STATUS (AE_NO_MEMORY);            }            Node->Object = Object;        }        /* Otherwise, return the error */        else switch (Type)        {        case ACPI_REFCLASS_ARG:            ACPI_ERROR ((AE_INFO,                "Uninitialized Arg[%u] at node %p",                Index, Node));            return_ACPI_STATUS (AE_AML_UNINITIALIZED_ARG);        case ACPI_REFCLASS_LOCAL:            /*             * No error message for this case, will be trapped again later to             * detect and ignore cases of Store(LocalX,LocalX)             */            return_ACPI_STATUS (AE_AML_UNINITIALIZED_LOCAL);        default:            ACPI_ERROR ((AE_INFO, "Not a Arg/Local opcode: 0x%X", Type));            return_ACPI_STATUS (AE_AML_INTERNAL);        }    }    /*     * The Index points to an initialized and valid object.     * Return an additional reference to the object     */    *DestDesc = Object;    AcpiUtAddReference (Object);    return_ACPI_STATUS (AE_OK);}

ACPI_STATUSAcpiEvExecuteRegMethod (    ACPI_OPERAND_OBJECT     *RegionObj,    UINT32                  Function){    ACPI_EVALUATE_INFO      *Info;    ACPI_OPERAND_OBJECT     *Args[3];    ACPI_OPERAND_OBJECT     *RegionObj2;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (EvExecuteRegMethod);    RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);    if (!RegionObj2)    {        return_ACPI_STATUS (AE_NOT_EXIST);    }    if (RegionObj2->Extra.Method_REG == NULL)    {        return_ACPI_STATUS (AE_OK);    }    /* Allocate and initialize the evaluation information block */    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));    if (!Info)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Info->PrefixNode = RegionObj2->Extra.Method_REG;    Info->RelativePathname = NULL;    Info->Parameters = Args;    Info->Flags = ACPI_IGNORE_RETURN_VALUE;    /*     * The _REG method has two arguments:     *     * Arg0 - Integer:     *  Operation region space ID Same value as RegionObj->Region.SpaceId     *     * Arg1 - Integer:     *  connection status 1 for connecting the handler, 0 for disconnecting     *  the handler (Passed as a parameter)     */    Args[0] = AcpiUtCreateIntegerObject ((UINT64) RegionObj->Region.SpaceId);    if (!Args[0])    {        Status = AE_NO_MEMORY;        goto Cleanup1;    }    Args[1] = AcpiUtCreateIntegerObject ((UINT64) Function);    if (!Args[1])    {        Status = AE_NO_MEMORY;        goto Cleanup2;    }    Args[2] = NULL; /* Terminate list */    /* Execute the method, no return value */    ACPI_DEBUG_EXEC (        AcpiUtDisplayInitPathname (ACPI_TYPE_METHOD, Info->PrefixNode, NULL));    Status = AcpiNsEvaluate (Info);    AcpiUtRemoveReference (Args[1]);Cleanup2:    AcpiUtRemoveReference (Args[0]);Cleanup1:    ACPI_FREE (Info);    return_ACPI_STATUS (Status);}

//.........这里部分代码省略.........    Op = AcpiPsCreateScopeOp (Info->ObjDesc->Method.AmlStart);    if (!Op)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    /* Create and initialize a new walk state */    Info->PassNumber = ACPI_IMODE_EXECUTE;    WalkState = AcpiDsCreateWalkState (        Info->ObjDesc->Method.OwnerId, NULL, NULL, NULL);    if (!WalkState)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    Status = AcpiDsInitAmlWalk (WalkState, Op, Info->Node,        Info->ObjDesc->Method.AmlStart,        Info->ObjDesc->Method.AmlLength, Info, Info->PassNumber);    if (ACPI_FAILURE (Status))    {        AcpiDsDeleteWalkState (WalkState);        goto Cleanup;    }    if (Info->ObjDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL)    {        WalkState->ParseFlags |= ACPI_PARSE_MODULE_LEVEL;    }    /* Invoke an internal method if necessary */    if (Info->ObjDesc->Method.InfoFlags & ACPI_METHOD_INTERNAL_ONLY)    {        Status = Info->ObjDesc->Method.Dispatch.Implementation (WalkState);        Info->ReturnObject = WalkState->ReturnDesc;        /* Cleanup states */        AcpiDsScopeStackClear (WalkState);        AcpiPsCleanupScope (&WalkState->ParserState);        AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);        AcpiDsDeleteWalkState (WalkState);        goto Cleanup;    }    /*     * Start method evaluation with an implicit return of zero.     * This is done for Windows compatibility.     */    if (AcpiGbl_EnableInterpreterSlack)    {        WalkState->ImplicitReturnObj =            AcpiUtCreateIntegerObject ((UINT64) 0);        if (!WalkState->ImplicitReturnObj)        {            Status = AE_NO_MEMORY;            AcpiDsDeleteWalkState (WalkState);            goto Cleanup;        }    }    /* Parse the AML */    Status = AcpiPsParseAml (WalkState);    /* WalkState was deleted by ParseAml */Cleanup:    AcpiPsDeleteParseTree (Op);    /* Take away the extra reference that we gave the parameters above */    AcpiPsUpdateParameterList (Info, REF_DECREMENT);    /* Exit now if error above */    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /*     * If the method has returned an object, signal this to the caller with     * a control exception code     */    if (Info->ReturnObject)    {        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Method returned ObjDesc=%p/n",            Info->ReturnObject));        ACPI_DUMP_STACK_ENTRY (Info->ReturnObject);        Status = AE_CTRL_RETURN_VALUE;    }    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiEvExecuteRegMethod (    ACPI_OPERAND_OBJECT     *RegionObj,    UINT32                  Function){    ACPI_EVALUATE_INFO      *Info;    ACPI_OPERAND_OBJECT     *Args[3];    ACPI_OPERAND_OBJECT     *RegionObj2;    const ACPI_NAME         *RegNamePtr = ACPI_CAST_PTR (ACPI_NAME, METHOD_NAME__REG);    ACPI_NAMESPACE_NODE     *MethodNode;    ACPI_NAMESPACE_NODE     *Node;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (EvExecuteRegMethod);    if (!AcpiGbl_NamespaceInitialized ||        RegionObj->Region.Handler == NULL)    {        return_ACPI_STATUS (AE_OK);    }    RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);    if (!RegionObj2)    {        return_ACPI_STATUS (AE_NOT_EXIST);    }    /*     * Find any "_REG" method associated with this region definition.     * The method should always be updated as this function may be     * invoked after a namespace change.     */    Node = RegionObj->Region.Node->Parent;    Status = AcpiNsSearchOneScope (        *RegNamePtr, Node, ACPI_TYPE_METHOD, &MethodNode);    if (ACPI_SUCCESS (Status))    {        /*         * The _REG method is optional and there can be only one per         * region definition. This will be executed when the handler is         * attached or removed.         */        RegionObj2->Extra.Method_REG = MethodNode;    }    if (RegionObj2->Extra.Method_REG == NULL)    {        return_ACPI_STATUS (AE_OK);    }    /* _REG(DISCONNECT) should be paired with _REG(CONNECT) */    if ((Function == ACPI_REG_CONNECT &&        RegionObj->Common.Flags & AOPOBJ_REG_CONNECTED) ||        (Function == ACPI_REG_DISCONNECT &&         !(RegionObj->Common.Flags & AOPOBJ_REG_CONNECTED)))    {        return_ACPI_STATUS (AE_OK);    }    /* Allocate and initialize the evaluation information block */    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));    if (!Info)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Info->PrefixNode = RegionObj2->Extra.Method_REG;    Info->RelativePathname = NULL;    Info->Parameters = Args;    Info->Flags = ACPI_IGNORE_RETURN_VALUE;    /*     * The _REG method has two arguments:     *     * Arg0 - Integer:     *  Operation region space ID Same value as RegionObj->Region.SpaceId     *     * Arg1 - Integer:     *  connection status 1 for connecting the handler, 0 for disconnecting     *  the handler (Passed as a parameter)     */    Args[0] = AcpiUtCreateIntegerObject ((UINT64) RegionObj->Region.SpaceId);    if (!Args[0])    {        Status = AE_NO_MEMORY;        goto Cleanup1;    }    Args[1] = AcpiUtCreateIntegerObject ((UINT64) Function);    if (!Args[1])    {        Status = AE_NO_MEMORY;        goto Cleanup2;    }    Args[2] = NULL; /* Terminate list *///.........这里部分代码省略.........

ACPI_STATUSAcpiNsRepairNullElement (    ACPI_EVALUATE_INFO      *Info,    UINT32                  ExpectedBtypes,    UINT32                  PackageIndex,    ACPI_OPERAND_OBJECT     **ReturnObjectPtr){    ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;    ACPI_OPERAND_OBJECT     *NewObject;    ACPI_FUNCTION_NAME (NsRepairNullElement);    /* No repair needed if return object is non-NULL */    if (ReturnObject)    {        return (AE_OK);    }    /*     * Attempt to repair a NULL element of a Package object. This applies to     * predefined names that return a fixed-length package and each element     * is required. It does not apply to variable-length packages where NULL     * elements are allowed, especially at the end of the package.     */    if (ExpectedBtypes & ACPI_RTYPE_INTEGER)    {        /* Need an Integer - create a zero-value integer */        NewObject = AcpiUtCreateIntegerObject ((UINT64) 0);    }    else if (ExpectedBtypes & ACPI_RTYPE_STRING)    {        /* Need a String - create a NULL string */        NewObject = AcpiUtCreateStringObject (0);    }    else if (ExpectedBtypes & ACPI_RTYPE_BUFFER)    {        /* Need a Buffer - create a zero-length buffer */        NewObject = AcpiUtCreateBufferObject (0);    }    else    {        /* Error for all other expected types */        return (AE_AML_OPERAND_TYPE);    }    if (!NewObject)    {        return (AE_NO_MEMORY);    }    /* Set the reference count according to the parent Package object */    NewObject->Common.ReferenceCount =        Info->ParentPackage->Common.ReferenceCount;    ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,        "%s: Converted NULL package element to expected %s at index %u/n",        Info->FullPathname, AcpiUtGetObjectTypeName (NewObject),        PackageIndex));    *ReturnObjectPtr = NewObject;    Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;    return (AE_OK);}

//.........这里部分代码省略.........            Length = ACPI_SMBUS_BUFFER_SIZE;            Function = ACPI_READ | (ObjDesc->Field.Attribute << 16);        }        else if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS)        {            Length = ACPI_GSBUS_BUFFER_SIZE;            Function = ACPI_READ | (ObjDesc->Field.Attribute << 16);        }        else /* IPMI */        {            Length = ACPI_IPMI_BUFFER_SIZE;            Function = ACPI_READ;        }        BufferDesc = AcpiUtCreateBufferObject (Length);        if (!BufferDesc)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }        /* Lock entire transaction if requested */        AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);        /* Call the region handler for the read */        Status = AcpiExAccessRegion (ObjDesc, 0,                    ACPI_CAST_PTR (UINT64, BufferDesc->Buffer.Pointer),                    Function);        AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);        goto Exit;    }    /*     * Allocate a buffer for the contents of the field.     *     * If the field is larger than the current integer width, create     * a BUFFER to hold it.  Otherwise, use an INTEGER.  This allows     * the use of arithmetic operators on the returned value if the     * field size is equal or smaller than an Integer.     *     * Note: Field.length is in bits.     */    Length = (ACPI_SIZE) ACPI_ROUND_BITS_UP_TO_BYTES (ObjDesc->Field.BitLength);    if (Length > AcpiGbl_IntegerByteWidth)    {        /* Field is too large for an Integer, create a Buffer instead */        BufferDesc = AcpiUtCreateBufferObject (Length);        if (!BufferDesc)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }        Buffer = BufferDesc->Buffer.Pointer;    }    else    {        /* Field will fit within an Integer (normal case) */        BufferDesc = AcpiUtCreateIntegerObject ((UINT64) 0);        if (!BufferDesc)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }        Length = AcpiGbl_IntegerByteWidth;        Buffer = &BufferDesc->Integer.Value;    }    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,        "FieldRead [TO]:   Obj %p, Type %X, Buf %p, ByteLen %X/n",        ObjDesc, ObjDesc->Common.Type, Buffer, (UINT32) Length));    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,        "FieldRead [FROM]: BitLen %X, BitOff %X, ByteOff %X/n",        ObjDesc->CommonField.BitLength,        ObjDesc->CommonField.StartFieldBitOffset,        ObjDesc->CommonField.BaseByteOffset));    /* Lock entire transaction if requested */    AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);    /* Read from the field */    Status = AcpiExExtractFromField (ObjDesc, Buffer, (UINT32) Length);    AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);Exit:    if (ACPI_FAILURE (Status))    {        AcpiUtRemoveReference (BufferDesc);    }    else    {        *RetBufferDesc = BufferDesc;    }    return_ACPI_STATUS (Status);}