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

voidAcpiDmDumpMethodInfo (    ACPI_STATUS             Status,    ACPI_WALK_STATE         *WalkState,    ACPI_PARSE_OBJECT       *Op){    ACPI_PARSE_OBJECT       *Next;    ACPI_THREAD_STATE       *Thread;    ACPI_WALK_STATE         *NextWalkState;    ACPI_NAMESPACE_NODE     *PreviousMethod = NULL;    /* Ignore control codes, they are not errors */    if ((Status & AE_CODE_MASK) == AE_CODE_CONTROL)    {        return;    }    /* We may be executing a deferred opcode */    if (WalkState->DeferredNode)    {        AcpiOsPrintf ("Executing subtree for Buffer/Package/Region/n");        return;    }    /*     * If there is no Thread, we are not actually executing a method.     * This can happen when the iASL compiler calls the interpreter     * to perform constant folding.     */    Thread = WalkState->Thread;    if (!Thread)    {        return;    }    /* Display exception and method name */    AcpiOsPrintf ("/n**** Exception %s during execution of method ",        AcpiFormatException (Status));    AcpiNsPrintNodePathname (WalkState->MethodNode, NULL);    /* Display stack of executing methods */    AcpiOsPrintf ("/n/nMethod Execution Stack:/n");    NextWalkState = Thread->WalkStateList;    /* Walk list of linked walk states */    while (NextWalkState)    {        AcpiOsPrintf ("    Method [%4.4s] executing: ",                AcpiUtGetNodeName (NextWalkState->MethodNode));        /* First method is the currently executing method */        if (NextWalkState == WalkState)        {            if (Op)            {                /* Display currently executing ASL statement */                Next = Op->Common.Next;                Op->Common.Next = NULL;                AcpiDmDisassemble (NextWalkState, Op, ACPI_UINT32_MAX);                Op->Common.Next = Next;            }        }        else        {            /*             * This method has called another method             * NOTE: the method call parse subtree is already deleted at this             * point, so we cannot disassemble the method invocation.             */            AcpiOsPrintf ("Call to method ");            AcpiNsPrintNodePathname (PreviousMethod, NULL);        }        PreviousMethod = NextWalkState->MethodNode;        NextWalkState = NextWalkState->Next;        AcpiOsPrintf ("/n");    }    /* Display the method locals and arguments */    AcpiOsPrintf ("/n");    AcpiDmDisplayLocals (WalkState);    AcpiOsPrintf ("/n");    AcpiDmDisplayArguments (WalkState);    AcpiOsPrintf ("/n");}

voidAcpiDbDisplayInterfaces (    char                    *ActionArg,    char                    *InterfaceNameArg){    ACPI_INTERFACE_INFO     *NextInterface;    char                    *SubString;    ACPI_STATUS             Status;    /* If no arguments, just display current interface list */    if (!ActionArg)    {        (void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex,                    ACPI_WAIT_FOREVER);        NextInterface = AcpiGbl_SupportedInterfaces;        while (NextInterface)        {            if (!(NextInterface->Flags & ACPI_OSI_INVALID))            {                AcpiOsPrintf ("%s/n", NextInterface->Name);            }            NextInterface = NextInterface->Next;        }        AcpiOsReleaseMutex (AcpiGbl_OsiMutex);        return;    }    /* If ActionArg exists, so must InterfaceNameArg */    if (!InterfaceNameArg)    {        AcpiOsPrintf ("Missing Interface Name argument/n");        return;    }    /* Uppercase the action for match below */    AcpiUtStrupr (ActionArg);    /* Install - install an interface */    SubString = ACPI_STRSTR ("INSTALL", ActionArg);    if (SubString)    {        Status = AcpiInstallInterface (InterfaceNameArg);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("%s, while installing /"%s/"/n",                AcpiFormatException (Status), InterfaceNameArg);        }        return;    }    /* Remove - remove an interface */    SubString = ACPI_STRSTR ("REMOVE", ActionArg);    if (SubString)    {        Status = AcpiRemoveInterface (InterfaceNameArg);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("%s, while removing /"%s/"/n",                AcpiFormatException (Status), InterfaceNameArg);        }        return;    }    /* Invalid ActionArg */    AcpiOsPrintf ("Invalid action argument: %s/n", ActionArg);    return;}

static ACPI_STATUSAcpiDbDeviceResources (    ACPI_HANDLE             ObjHandle,    UINT32                  NestingLevel,    void                    *Context,    void                    **ReturnValue){    ACPI_NAMESPACE_NODE     *Node;    ACPI_NAMESPACE_NODE     *PrtNode = NULL;    ACPI_NAMESPACE_NODE     *CrsNode = NULL;    ACPI_NAMESPACE_NODE     *PrsNode = NULL;    ACPI_NAMESPACE_NODE     *AeiNode = NULL;    char                    *ParentPath;    ACPI_BUFFER             ReturnObj;    ACPI_STATUS             Status;    Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle);    ParentPath = AcpiNsGetExternalPathname (Node);    if (!ParentPath)    {        return (AE_NO_MEMORY);    }    /* Get handles to the resource methods for this device */    (void) AcpiGetHandle (Node, METHOD_NAME__PRT, ACPI_CAST_PTR (ACPI_HANDLE, &PrtNode));    (void) AcpiGetHandle (Node, METHOD_NAME__CRS, ACPI_CAST_PTR (ACPI_HANDLE, &CrsNode));    (void) AcpiGetHandle (Node, METHOD_NAME__PRS, ACPI_CAST_PTR (ACPI_HANDLE, &PrsNode));    (void) AcpiGetHandle (Node, METHOD_NAME__AEI, ACPI_CAST_PTR (ACPI_HANDLE, &AeiNode));    if (!PrtNode && !CrsNode && !PrsNode && !AeiNode)    {        goto Cleanup;   /* Nothing to do */    }    AcpiOsPrintf ("/nDevice: %s/n", ParentPath);    /* Prepare for a return object of arbitrary size */    ReturnObj.Pointer = AcpiGbl_DbBuffer;    ReturnObj.Length  = ACPI_DEBUG_BUFFER_SIZE;    /* _PRT */    if (PrtNode)    {        AcpiOsPrintf ("Evaluating _PRT/n");        Status = AcpiEvaluateObject (PrtNode, NULL, NULL, &ReturnObj);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("Could not evaluate _PRT: %s/n",                AcpiFormatException (Status));            goto GetCrs;        }        ReturnObj.Pointer = AcpiGbl_DbBuffer;        ReturnObj.Length  = ACPI_DEBUG_BUFFER_SIZE;        Status = AcpiGetIrqRoutingTable (Node, &ReturnObj);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("GetIrqRoutingTable failed: %s/n",                AcpiFormatException (Status));            goto GetCrs;        }        AcpiRsDumpIrqList (ACPI_CAST_PTR (UINT8, AcpiGbl_DbBuffer));    }    /* _CRS */GetCrs:    if (CrsNode)    {        AcpiOsPrintf ("Evaluating _CRS/n");        ReturnObj.Pointer = AcpiGbl_DbBuffer;        ReturnObj.Length  = ACPI_DEBUG_BUFFER_SIZE;        Status = AcpiEvaluateObject (CrsNode, NULL, NULL, &ReturnObj);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("Could not evaluate _CRS: %s/n",                AcpiFormatException (Status));            goto GetPrs;        }        /* This code is here to exercise the AcpiWalkResources interface */        Status = AcpiWalkResources (Node, METHOD_NAME__CRS,            AcpiDbResourceCallback, NULL);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("AcpiWalkResources failed: %s/n",                AcpiFormatException (Status));            goto GetPrs;        }//.........这里部分代码省略.........

voidAcpiDbExecute (    NATIVE_CHAR             *Name,    NATIVE_CHAR             **Args,    UINT32                  Flags){    ACPI_STATUS             Status;    ACPI_BUFFER             ReturnObj;#ifdef ACPI_DEBUG    UINT32                  PreviousAllocations;    UINT32                  Allocations;    /* Memory allocation tracking */    PreviousAllocations = AcpiDbGetOutstandingAllocations ();#endif    AcpiGbl_DbMethodInfo.Name = Name;    AcpiGbl_DbMethodInfo.Args = Args;    AcpiGbl_DbMethodInfo.Flags = Flags;    AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);    Status = AcpiDbExecuteMethod (&AcpiGbl_DbMethodInfo, &ReturnObj);    /*     * Allow any handlers in separate threads to complete.     * (Such as Notify handlers invoked from AML executed above).     */    AcpiOsSleep (0, 10);#ifdef ACPI_DEBUG    /* Memory allocation tracking */    Allocations = AcpiDbGetOutstandingAllocations () - PreviousAllocations;    AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT);    if (Allocations > 0)    {        AcpiOsPrintf ("Outstanding: %ld allocations after execution/n",                        Allocations);    }#endif    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Execution of %s failed with status %s/n",            AcpiGbl_DbMethodInfo.Pathname, AcpiFormatException (Status));    }    else    {        /* Display a return object, if any */        if (ReturnObj.Length)        {            AcpiOsPrintf ("Execution of %s returned object %p Buflen %X/n",                AcpiGbl_DbMethodInfo.Pathname, ReturnObj.Pointer, ReturnObj.Length);            AcpiDbDumpObject (ReturnObj.Pointer, 1);        }    }    AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT);}

//.........这里部分代码省略.........        Status = AcpiNsEvaluate (Info);    }    /*     * If we are expecting a return value, and all went well above,     * copy the return value to an external object.     */    if (ReturnBuffer)    {        if (!Info->ReturnObject)        {            ReturnBuffer->Length = 0;        }        else        {            if (ACPI_GET_DESCRIPTOR_TYPE (Info->ReturnObject) ==                    ACPI_DESC_TYPE_NAMED)            {                /*                 * If we received a NS Node as a return object, this means that                 * the object we are evaluating has nothing interesting to                 * return (such as a mutex, etc.)  We return an error because                 * these types are essentially unsupported by this interface.                 * We don't check up front because this makes it easier to add                 * support for various types at a later date if necessary.                 */                Status = AE_TYPE;                Info->ReturnObject = NULL;   /* No need to delete a NS Node */                ReturnBuffer->Length = 0;            }            if (ACPI_SUCCESS (Status))            {                /* Dereference Index and RefOf references */                AcpiNsResolveReferences (Info);                /* Get the size of the returned object */                Status = AcpiUtGetObjectSize (Info->ReturnObject,                                              &BufferSpaceNeeded);                if (ACPI_SUCCESS (Status))                {                    /* Validate/Allocate/Clear caller buffer */                    Status = AcpiUtInitializeBuffer (ReturnBuffer,                                                     BufferSpaceNeeded);                    if (ACPI_FAILURE (Status))                    {                        /*                         * Caller's buffer is too small or a new one can't                         * be allocated                         */                        ACPI_DEBUG_PRINT ((ACPI_DB_INFO,                                           "Needed buffer size %X, %s/n",                                           (UINT32) BufferSpaceNeeded,                                           AcpiFormatException (Status)));                    }                    else                    {                        /* We have enough space for the object, build it */                        Status = AcpiUtCopyIobjectToEobject (Info->ReturnObject,                                                             ReturnBuffer);                    }                }            }        }    }    if (Info->ReturnObject)    {        /*         * Delete the internal return object. NOTE: Interpreter must be         * locked to avoid race condition.         */        AcpiExEnterInterpreter ();        /* Remove one reference on the return object (should delete it) */        AcpiUtRemoveReference (Info->ReturnObject);        AcpiExExitInterpreter ();    }Cleanup:    /* Free the input parameter list (if we created one) */    if (Info->Parameters)    {        /* Free the allocated parameter block */        AcpiUtDeleteInternalObjectList (Info->Parameters);    }    ACPI_FREE (Info);    return_ACPI_STATUS (Status);}

static voidAcpiDbDoOneSleepState (    UINT8                   SleepState){    ACPI_STATUS             Status;    UINT8                   SleepTypeA;    UINT8                   SleepTypeB;    /* Validate parameter */    if (SleepState > ACPI_S_STATES_MAX)    {        AcpiOsPrintf ("Sleep state %d out of range (%d max)/n",            SleepState, ACPI_S_STATES_MAX);        return;    }    AcpiOsPrintf ("/n---- Invoking sleep state S%d (%s):/n",        SleepState, AcpiGbl_SleepStateNames[SleepState]);    /* Get the values for the sleep type registers (for display only) */    Status = AcpiGetSleepTypeData (SleepState, &SleepTypeA, &SleepTypeB);    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Could not evaluate [%s] method, %s/n",            AcpiGbl_SleepStateNames[SleepState],            AcpiFormatException (Status));        return;    }    AcpiOsPrintf (        "Register values for sleep state S%d: Sleep-A: %.2X, Sleep-B: %.2X/n",        SleepState, SleepTypeA, SleepTypeB);    /* Invoke the various sleep/wake interfaces */    AcpiOsPrintf ("**** Sleep: Prepare to sleep (S%d) ****/n",        SleepState);    Status = AcpiEnterSleepStatePrep (SleepState);    if (ACPI_FAILURE (Status))    {        goto ErrorExit;    }    AcpiOsPrintf ("**** Sleep: Going to sleep (S%d) ****/n",        SleepState);    Status = AcpiEnterSleepState (SleepState);    if (ACPI_FAILURE (Status))    {        goto ErrorExit;    }    AcpiOsPrintf ("**** Wake: Prepare to return from sleep (S%d) ****/n",        SleepState);    Status = AcpiLeaveSleepStatePrep (SleepState);    if (ACPI_FAILURE (Status))    {        goto ErrorExit;    }    AcpiOsPrintf ("**** Wake: Return from sleep (S%d) ****/n",        SleepState);    Status = AcpiLeaveSleepState (SleepState);    if (ACPI_FAILURE (Status))    {        goto ErrorExit;    }    return;ErrorExit:    ACPI_EXCEPTION ((AE_INFO, Status, "During invocation of sleep state S%d",        SleepState));}

ACPI_STATUSAcpiDsInitOneObject (    ACPI_HANDLE             ObjHandle,    UINT32                  Level,    void                    *Context,    void                    **ReturnValue){    ACPI_OBJECT_TYPE        Type;    ACPI_STATUS             Status;    ACPI_INIT_WALK_INFO     *Info = (ACPI_INIT_WALK_INFO *) Context;    ACPI_FUNCTION_NAME ("DsInitOneObject");    /*     * We are only interested in objects owned by the table that     * was just loaded     */    if (((ACPI_NAMESPACE_NODE *) ObjHandle)->OwnerId !=            Info->TableDesc->TableId)    {        return (AE_OK);    }    Info->ObjectCount++;    /* And even then, we are only interested in a few object types */    Type = AcpiNsGetType (ObjHandle);    switch (Type)    {    case ACPI_TYPE_REGION:        Status = AcpiDsInitializeRegion (ObjHandle);        if (ACPI_FAILURE (Status))        {            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Region %p [%4.4s] - Init failure, %s/n",                ObjHandle, ((ACPI_NAMESPACE_NODE *) ObjHandle)->Name.Ascii,                AcpiFormatException (Status)));        }        Info->OpRegionCount++;        break;    case ACPI_TYPE_METHOD:        Info->MethodCount++;        /* Print a dot for each method unless we are going to print the entire pathname */        if (!(AcpiDbgLevel & ACPI_LV_INIT_NAMES))        {            ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT, "."));        }        /*         * Set the execution data width (32 or 64) based upon the         * revision number of the parent ACPI table.         * TBD: This is really for possible future support of integer width         * on a per-table basis. Currently, we just use a global for the width.         */        if (Info->TableDesc->Pointer->Revision == 1)        {            ((ACPI_NAMESPACE_NODE *) ObjHandle)->Flags |= ANOBJ_DATA_WIDTH_32;        }        /*         * Always parse methods to detect errors, we may delete         * the parse tree below         */        Status = AcpiDsParseMethod (ObjHandle);        if (ACPI_FAILURE (Status))        {            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Method %p [%4.4s] - parse failure, %s/n",                ObjHandle, ((ACPI_NAMESPACE_NODE *) ObjHandle)->Name.Ascii,                AcpiFormatException (Status)));            /* This parse failed, but we will continue parsing more methods */            break;        }        /*         * Delete the parse tree.  We simple re-parse the method         * for every execution since there isn't much overhead         */        AcpiNsDeleteNamespaceSubtree (ObjHandle);        AcpiNsDeleteNamespaceByOwner (((ACPI_NAMESPACE_NODE *) ObjHandle)->Object->Method.OwningId);        break;    case ACPI_TYPE_DEVICE:        Info->DeviceCount++;        break;//.........这里部分代码省略.........

ACPI_STATUSAeInstallEarlyHandlers (    void){    ACPI_STATUS             Status;    ACPI_HANDLE             Handle;    ACPI_FUNCTION_ENTRY ();    Status = AcpiInstallInterfaceHandler (AeInterfaceHandler);    if (ACPI_FAILURE (Status))    {        printf ("Could not install interface handler, %s/n",            AcpiFormatException (Status));    }    Status = AcpiInstallTableHandler (AeTableHandler, NULL);    if (ACPI_FAILURE (Status))    {        printf ("Could not install table handler, %s/n",            AcpiFormatException (Status));    }    Status = AcpiInstallExceptionHandler (AeExceptionHandler);    if (ACPI_FAILURE (Status))    {        printf ("Could not install exception handler, %s/n",            AcpiFormatException (Status));    }    /* Install global notify handlers */    Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,        AeSystemNotifyHandler, NULL);    if (ACPI_FAILURE (Status))    {        printf ("Could not install a global system notify handler, %s/n",            AcpiFormatException (Status));    }    Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_DEVICE_NOTIFY,        AeDeviceNotifyHandler, NULL);    if (ACPI_FAILURE (Status))    {        printf ("Could not install a global notify handler, %s/n",            AcpiFormatException (Status));    }    Status = AcpiGetHandle (NULL, "//_SB", &Handle);    if (ACPI_SUCCESS (Status))    {        Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,            AeNotifyHandler1, NULL);        if (ACPI_FAILURE (Status))        {            printf ("Could not install a notify handler, %s/n",                AcpiFormatException (Status));        }        Status = AcpiRemoveNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,            AeNotifyHandler1);        if (ACPI_FAILURE (Status))        {            printf ("Could not remove a notify handler, %s/n",                AcpiFormatException (Status));        }        Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,            AeNotifyHandler1, NULL);        ACPI_CHECK_OK (AcpiInstallNotifyHandler, Status);        Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY,            AeNotifyHandler1);        ACPI_CHECK_OK (AcpiRemoveNotifyHandler, Status);#if 0        Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,            AeNotifyHandler1, NULL);        if (ACPI_FAILURE (Status))        {            printf ("Could not install a notify handler, %s/n",                AcpiFormatException (Status));        }#endif        /* Install two handlers for _SB_ */        Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,            AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567));        Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,            AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF));        /* Attempt duplicate handler installation, should fail */        Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,            AeNotifyHandler1, ACPI_CAST_PTR (void, 0x77777777));//.........这里部分代码省略.........

ACPI_STATUSAcpiDbLoadAcpiTable (    NATIVE_CHAR             *Filename){#ifdef ACPI_APPLICATION    FILE                    *fp;    ACPI_STATUS             Status;    ACPI_TABLE_HEADER       *TablePtr;    UINT32                  TableLength;    /* Open the file */    fp = fopen (Filename, "rb");    if (!fp)    {        AcpiOsPrintf ("Could not open file %s/n", Filename);        return (AE_ERROR);    }    /* Get the entire file */    AcpiOsPrintf ("Loading Acpi table from file %s/n", Filename);    Status = AcpiDbLoadTable (fp, &TablePtr, &TableLength);    fclose(fp);    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Couldn't get table from the file/n");        return (Status);    }    /* Attempt to recognize and install the table */    Status = AeLocalLoadTable (TablePtr);    if (ACPI_FAILURE (Status))    {        if (Status == AE_EXIST)        {            AcpiOsPrintf ("Table %4.4s is already installed/n",                            &TablePtr->Signature);        }        else        {            AcpiOsPrintf ("Could not install table, %s/n",                            AcpiFormatException (Status));        }        ACPI_MEM_FREE (TablePtr);        return (Status);    }    AcpiOsPrintf ("%4.4s at %p successfully installed and loaded/n",                                &TablePtr->Signature, TablePtr);    AcpiGbl_AcpiHardwarePresent = FALSE;#endif  /* ACPI_APPLICATION */    return (AE_OK);}

        Status = AcpiAttachData (ACPI_ROOT_OBJECT, AeAttachedDataHandler2,            AcpiGbl_RootNode);        ACPI_CHECK_OK (AcpiAttachData, Status);        /* Test support for multiple attaches */        Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle);        ACPI_CHECK_OK (AcpiAttachData, Status);        Status = AcpiAttachData (Handle, AeAttachedDataHandler2, Handle);        ACPI_CHECK_OK (AcpiAttachData, Status);    }    else    {        printf ("No _SB_ found, %s/n", AcpiFormatException (Status));    }    /*     * Install handlers that will override the default handlers for some of     * the space IDs.     */    AeOverrideRegionHandlers ();    /*     * Initialize the global Region Handler space     * MCW 3/23/00     */    AeRegions.NumberOfRegions = 0;    AeRegions.RegionList = NULL;    return (AE_OK);

static ACPI_STATUSAeExceptionHandler (    ACPI_STATUS             AmlStatus,    ACPI_NAME               Name,    UINT16                  Opcode,    UINT32                  AmlOffset,    void                    *Context){    ACPI_STATUS             NewAmlStatus = AmlStatus;    ACPI_STATUS             Status;    ACPI_BUFFER             ReturnObj;    ACPI_OBJECT_LIST        ArgList;    ACPI_OBJECT             Arg[3];    const char              *Exception;    Exception = AcpiFormatException (AmlStatus);    AcpiOsPrintf ("[AcpiExec] Exception %s during execution ", Exception);    if (Name)    {        AcpiOsPrintf ("of method [%4.4s]", (char *) &Name);    }    else    {        AcpiOsPrintf ("at module level (table load)");    }    AcpiOsPrintf (" Opcode [%s] @%X/n", AcpiPsGetOpcodeName (Opcode), AmlOffset);    /*     * Invoke the _ERR method if present     *     * Setup parameter object     */    ArgList.Count = 3;    ArgList.Pointer = Arg;    Arg[0].Type = ACPI_TYPE_INTEGER;    Arg[0].Integer.Value = AmlStatus;    Arg[1].Type = ACPI_TYPE_STRING;    Arg[1].String.Pointer = ACPI_CAST_PTR (char, Exception);    Arg[1].String.Length = strlen (Exception);    Arg[2].Type = ACPI_TYPE_INTEGER;    Arg[2].Integer.Value = AcpiOsGetThreadId();    /* Setup return buffer */    ReturnObj.Pointer = NULL;    ReturnObj.Length = ACPI_ALLOCATE_BUFFER;    Status = AcpiEvaluateObject (NULL, "//_ERR", &ArgList, &ReturnObj);    if (ACPI_SUCCESS (Status))    {        if (ReturnObj.Pointer)        {            /* Override original status */            NewAmlStatus = (ACPI_STATUS)                ((ACPI_OBJECT *) ReturnObj.Pointer)->Integer.Value;            /* Free a buffer created via ACPI_ALLOCATE_BUFFER */            AcpiOsFree (ReturnObj.Pointer);        }    }    else if (Status != AE_NOT_FOUND)    {        AcpiOsPrintf ("[AcpiExec] Could not execute _ERR method, %s/n",            AcpiFormatException (Status));    }    /* Global override */    if (AcpiGbl_IgnoreErrors)    {        NewAmlStatus = AE_OK;    }    if (NewAmlStatus != AmlStatus)    {        AcpiOsPrintf ("[AcpiExec] Exception override, new status %s/n/n",            AcpiFormatException (NewAmlStatus));    }    return (NewAmlStatus);}

//.........这里部分代码省略.........     * If we are expecting a return value, and all went well above,     * copy the return value to an external object.     */    if (!ReturnBuffer)    {        goto CleanupReturnObject;    }    if (!Info->ReturnObject)    {        ReturnBuffer->Length = 0;        goto Cleanup;    }    if (ACPI_GET_DESCRIPTOR_TYPE (Info->ReturnObject) ==        ACPI_DESC_TYPE_NAMED)    {        /*         * If we received a NS Node as a return object, this means that         * the object we are evaluating has nothing interesting to         * return (such as a mutex, etc.)  We return an error because         * these types are essentially unsupported by this interface.         * We don't check up front because this makes it easier to add         * support for various types at a later date if necessary.         */        Status = AE_TYPE;        Info->ReturnObject = NULL;   /* No need to delete a NS Node */        ReturnBuffer->Length = 0;    }    if (ACPI_FAILURE (Status))    {        goto CleanupReturnObject;    }    /* Dereference Index and RefOf references */    AcpiNsResolveReferences (Info);    /* Get the size of the returned object */    Status = AcpiUtGetObjectSize (Info->ReturnObject,        &BufferSpaceNeeded);    if (ACPI_SUCCESS (Status))    {        /* Validate/Allocate/Clear caller buffer */        Status = AcpiUtInitializeBuffer (ReturnBuffer,            BufferSpaceNeeded);        if (ACPI_FAILURE (Status))        {            /*             * Caller's buffer is too small or a new one can't             * be allocated             */            ACPI_DEBUG_PRINT ((ACPI_DB_INFO,                "Needed buffer size %X, %s/n",                (UINT32) BufferSpaceNeeded,                AcpiFormatException (Status)));        }        else        {            /* We have enough space for the object, build it */            Status = AcpiUtCopyIobjectToEobject (                Info->ReturnObject, ReturnBuffer);        }    }CleanupReturnObject:    if (Info->ReturnObject)    {        /*         * Delete the internal return object. NOTE: Interpreter must be         * locked to avoid race condition.         */        AcpiExEnterInterpreter ();        /* Remove one reference on the return object (should delete it) */        AcpiUtRemoveReference (Info->ReturnObject);        AcpiExExitInterpreter ();    }Cleanup:    /* Free the input parameter list (if we created one) */    if (Info->Parameters)    {        /* Free the allocated parameter block */        AcpiUtDeleteInternalObjectList (Info->Parameters);    }    ACPI_FREE (Info);    return_ACPI_STATUS (Status);}

static voidacpi_cmbat_get_bif(void *arg){    struct acpi_cmbat_softc *sc;    ACPI_STATUS	as;    ACPI_OBJECT	*res;    ACPI_HANDLE	h;    ACPI_BUFFER	bif_buffer;    device_t dev;    ACPI_SERIAL_ASSERT(cmbat);    dev = arg;    sc = device_get_softc(dev);    h = acpi_get_handle(dev);    bif_buffer.Pointer = NULL;    bif_buffer.Length = ACPI_ALLOCATE_BUFFER;    as = AcpiEvaluateObject(h, "_BIF", NULL, &bif_buffer);    if (ACPI_FAILURE(as)) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "error fetching current battery info -- %s/n",		    AcpiFormatException(as));	goto end;    }    res = (ACPI_OBJECT *)bif_buffer.Pointer;    if (!ACPI_PKG_VALID(res, 13)) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "battery info corrupted/n");	goto end;    }    if (acpi_PkgInt32(res, 0, &sc->bif.units) != 0)	goto end;    if (acpi_PkgInt32(res, 1, &sc->bif.dcap) != 0)	goto end;    if (acpi_PkgInt32(res, 2, &sc->bif.lfcap) != 0)	goto end;    if (acpi_PkgInt32(res, 3, &sc->bif.btech) != 0)	goto end;    if (acpi_PkgInt32(res, 4, &sc->bif.dvol) != 0)	goto end;    if (acpi_PkgInt32(res, 5, &sc->bif.wcap) != 0)	goto end;    if (acpi_PkgInt32(res, 6, &sc->bif.lcap) != 0)	goto end;    if (acpi_PkgInt32(res, 7, &sc->bif.gra1) != 0)	goto end;    if (acpi_PkgInt32(res, 8, &sc->bif.gra2) != 0)	goto end;    if (acpi_PkgStr(res,  9, sc->bif.model, ACPI_CMBAT_MAXSTRLEN) != 0)	goto end;    if (acpi_PkgStr(res, 10, sc->bif.serial, ACPI_CMBAT_MAXSTRLEN) != 0)	goto end;    if (acpi_PkgStr(res, 11, sc->bif.type, ACPI_CMBAT_MAXSTRLEN) != 0)	goto end;    if (acpi_PkgStr(res, 12, sc->bif.oeminfo, ACPI_CMBAT_MAXSTRLEN) != 0)	goto end;end:    if (bif_buffer.Pointer != NULL)	AcpiOsFree(bif_buffer.Pointer);}

static voidacpi_cmbat_get_bst(void *arg){    struct acpi_cmbat_softc *sc;    ACPI_STATUS	as;    ACPI_OBJECT	*res;    ACPI_HANDLE	h;    ACPI_BUFFER	bst_buffer;    device_t dev;    ACPI_SERIAL_ASSERT(cmbat);    dev = arg;    sc = device_get_softc(dev);    h = acpi_get_handle(dev);    bst_buffer.Pointer = NULL;    bst_buffer.Length = ACPI_ALLOCATE_BUFFER;    if (!acpi_cmbat_info_expired(&sc->bst_lastupdated))	goto end;    as = AcpiEvaluateObject(h, "_BST", NULL, &bst_buffer);    if (ACPI_FAILURE(as)) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "error fetching current battery status -- %s/n",		    AcpiFormatException(as));	goto end;    }    res = (ACPI_OBJECT *)bst_buffer.Pointer;    if (!ACPI_PKG_VALID(res, 4)) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "battery status corrupted/n");	goto end;    }    if (acpi_PkgInt32(res, 0, &sc->bst.state) != 0)	goto end;    if (acpi_PkgInt32(res, 1, &sc->bst.rate) != 0)	goto end;    if (acpi_PkgInt32(res, 2, &sc->bst.cap) != 0)	goto end;    if (acpi_PkgInt32(res, 3, &sc->bst.volt) != 0)	goto end;    acpi_cmbat_info_updated(&sc->bst_lastupdated);    /* Clear out undefined/extended bits that might be set by hardware. */    sc->bst.state &= ACPI_BATT_STAT_BST_MASK;    if ((sc->bst.state & ACPI_BATT_STAT_INVALID) == ACPI_BATT_STAT_INVALID)	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),	    "battery reports simultaneous charging and discharging/n");    /* XXX If all batteries are critical, perhaps we should suspend. */    if (sc->bst.state & ACPI_BATT_STAT_CRITICAL) {    	if ((sc->flags & ACPI_BATT_STAT_CRITICAL) == 0) {	    sc->flags |= ACPI_BATT_STAT_CRITICAL;	    device_printf(dev, "critically low charge!/n");	}    } else	sc->flags &= ~ACPI_BATT_STAT_CRITICAL;end:    if (bst_buffer.Pointer != NULL)	AcpiOsFree(bst_buffer.Pointer);}

static bool radeon_atrm_get_bios(struct radeon_device *rdev){	int ret;	int size = 256 * 1024;	int i;	device_t dev;	ACPI_HANDLE dhandle, atrm_handle;	ACPI_STATUS status;	bool found = false;	DRM_INFO("%s: ===> Try ATRM.../n", __func__);	/* ATRM is for the discrete card only */	if (rdev->flags & RADEON_IS_IGP) {		DRM_INFO("%s: IGP card detected, skipping this method.../n",		    __func__);		return false;	}#ifdef FREEBSD_WIP	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {#endif /* FREEBSD_WIP */	if ((dev = pci_find_class(PCIC_DISPLAY, PCIS_DISPLAY_VGA)) != NULL) {		DRM_INFO("%s: pci_find_class() found: %d:%d:%d:%d, vendor=%04x, device=%04x/n",		    __func__,		    pci_get_domain(dev),		    pci_get_bus(dev),		    pci_get_slot(dev),		    pci_get_function(dev),		    pci_get_vendor(dev),		    pci_get_device(dev));		DRM_INFO("%s: Get ACPI device handle/n", __func__);		dhandle = acpi_get_handle(dev);#ifdef FREEBSD_WIP		if (!dhandle)			continue;#endif /* FREEBSD_WIP */		if (!dhandle)			return false;		DRM_INFO("%s: Get ACPI handle for /"ATRM/"/n", __func__);		status = AcpiGetHandle(dhandle, "ATRM", &atrm_handle);		if (!ACPI_FAILURE(status)) {			found = true;#ifdef FREEBSD_WIP			break;#endif /* FREEBSD_WIP */		} else {			DRM_INFO("%s: Failed to get /"ATRM/" handle: %s/n",			    __func__, AcpiFormatException(status));		}	}	if (!found)		return false;	rdev->bios = malloc(size, DRM_MEM_DRIVER, M_NOWAIT);	if (!rdev->bios) {		DRM_ERROR("Unable to allocate bios/n");		return false;	}	for (i = 0; i < size / ATRM_BIOS_PAGE; i++) {		DRM_INFO("%s: Call radeon_atrm_call()/n", __func__);		ret = radeon_atrm_call(atrm_handle,				       rdev->bios,				       (i * ATRM_BIOS_PAGE),				       ATRM_BIOS_PAGE);		if (ret < ATRM_BIOS_PAGE)			break;	}	if (i == 0 || rdev->bios[0] != 0x55 || rdev->bios[1] != 0xaa) {		if (i == 0) {			DRM_INFO("%s: Incorrect BIOS size/n", __func__);		} else {			DRM_INFO("%s: Incorrect BIOS signature: 0x%02X%02X/n",			    __func__, rdev->bios[0], rdev->bios[1]);		}		free(rdev->bios, DRM_MEM_DRIVER);		return false;	}	return true;}#elsestatic inline bool radeon_atrm_get_bios(struct radeon_device *rdev){	return false;}#endifstatic bool ni_read_disabled_bios(struct radeon_device *rdev){	u32 bus_cntl;	u32 d1vga_control;	u32 d2vga_control;	u32 vga_render_control;	u32 rom_cntl;	bool r;//.........这里部分代码省略.........

voidAcpiDmResourceTemplate (    ACPI_OP_WALK_INFO       *Info,    ACPI_PARSE_OBJECT       *Op,    UINT8                   *ByteData,    UINT32                  ByteCount){    ACPI_STATUS             Status;    UINT32                  CurrentByteOffset;    UINT8                   ResourceType;    UINT32                  ResourceLength;    void                    *Aml;    UINT32                  Level;    BOOLEAN                 DependentFns = FALSE;    UINT8                   ResourceIndex;    ACPI_NAMESPACE_NODE     *Node;    Level = Info->Level;    ResourceName = ACPI_DEFAULT_RESNAME;    Node = Op->Common.Node;    if (Node)    {        Node = Node->Child;    }    for (CurrentByteOffset = 0; CurrentByteOffset < ByteCount;)    {        Aml = &ByteData[CurrentByteOffset];        /* Get the descriptor type and length */        ResourceType = AcpiUtGetResourceType (Aml);        ResourceLength = AcpiUtGetResourceLength (Aml);        /* Validate the Resource Type and Resource Length */        Status = AcpiUtValidateResource (NULL, Aml, &ResourceIndex);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("/*** Could not validate Resource, type (%X) %s***//n",                ResourceType, AcpiFormatException (Status));            return;        }        /* Point to next descriptor */        CurrentByteOffset += AcpiUtGetDescriptorLength (Aml);        /* Descriptor pre-processing */        switch (ResourceType)        {        case ACPI_RESOURCE_NAME_START_DEPENDENT:            /* Finish a previous StartDependentFns */            if (DependentFns)            {                Level--;                AcpiDmIndent (Level);                AcpiOsPrintf ("}/n");            }            break;        case ACPI_RESOURCE_NAME_END_DEPENDENT:            Level--;            DependentFns = FALSE;            break;        case ACPI_RESOURCE_NAME_END_TAG:            /* Normal exit, the resource list is finished */            if (DependentFns)            {                /*                 * Close an open StartDependentDescriptor. This indicates a                 * missing EndDependentDescriptor.                 */                Level--;                DependentFns = FALSE;                /* Go ahead and insert EndDependentFn() */                AcpiDmEndDependentDescriptor (Aml, ResourceLength, Level);                AcpiDmIndent (Level);                AcpiOsPrintf (                    "/*** Disassembler: inserted missing EndDependentFn () ***//n");            }            return;        default:            break;        }        /* Disassemble the resource structure *///.........这里部分代码省略.........

static ACPI_STATUSAslDoDisassembly (    void){    ACPI_STATUS             Status;    /* ACPICA subsystem initialization */    Status = AdInitialize ();    if (ACPI_FAILURE (Status))    {        return (Status);    }    Status = AcpiAllocateRootTable (4);    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Could not initialize ACPI Table Manager, %s/n",            AcpiFormatException (Status));        return (Status);    }    /* Handle additional output files for disassembler */    AslGbl_FileType = ASL_INPUT_TYPE_BINARY_ACPI_TABLE;    Status = FlOpenMiscOutputFiles (AslGbl_OutputFilenamePrefix);    /* This is where the disassembly happens */    AcpiGbl_DmOpt_Disasm = TRUE;    Status = AdAmlDisassemble (AslToFile,        AslGbl_Files[ASL_FILE_INPUT].Filename, AslGbl_OutputFilenamePrefix,        &AslGbl_Files[ASL_FILE_INPUT].Filename);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /* Check if any control methods were unresolved */    AcpiDmUnresolvedWarning (0);    /* Shutdown compiler and ACPICA subsystem */    AeClearErrorLog ();    (void) AcpiTerminate ();    /*     * AslGbl_Files[ASL_FILE_INPUT].Filename was replaced with the     * .DSL disassembly file, which can now be compiled if requested     */    if (AslGbl_DoCompile)    {        AcpiOsPrintf ("/nCompiling /"%s/"/n",            AslGbl_Files[ASL_FILE_INPUT].Filename);        return (AE_CTRL_CONTINUE);    }    /* No need to free the filename string */    AslGbl_Files[ASL_FILE_INPUT].Filename = NULL;    UtDeleteLocalCaches ();    return (AE_OK);}

static void ACPI_SYSTEM_XFACEAcpiDbMethodThread (    void                    *Context){    ACPI_STATUS             Status;    ACPI_DB_METHOD_INFO     *Info = Context;    ACPI_DB_METHOD_INFO     LocalInfo;    UINT32                  i;    UINT8                   Allow;    ACPI_BUFFER             ReturnObj;    /*     * AcpiGbl_DbMethodInfo.Arguments will be passed as method arguments.     * Prevent AcpiGbl_DbMethodInfo from being modified by multiple threads     * concurrently.     *     * Note: The arguments we are passing are used by the ASL test suite     * (aslts). Do not change them without updating the tests.     */    (void) AcpiOsWaitSemaphore (Info->InfoGate, 1, ACPI_WAIT_FOREVER);    if (Info->InitArgs)    {        AcpiDbUint32ToHexString (Info->NumCreated,            Info->IndexOfThreadStr);        AcpiDbUint32ToHexString ((UINT32) AcpiOsGetThreadId (),            Info->IdOfThreadStr);    }    if (Info->Threads && (Info->NumCreated < Info->NumThreads))    {        Info->Threads[Info->NumCreated++] = AcpiOsGetThreadId();    }    LocalInfo = *Info;    LocalInfo.Args = LocalInfo.Arguments;    LocalInfo.Arguments[0] = LocalInfo.NumThreadsStr;    LocalInfo.Arguments[1] = LocalInfo.IdOfThreadStr;    LocalInfo.Arguments[2] = LocalInfo.IndexOfThreadStr;    LocalInfo.Arguments[3] = NULL;    LocalInfo.Types = LocalInfo.ArgTypes;    (void) AcpiOsSignalSemaphore (Info->InfoGate, 1);    for (i = 0; i < Info->NumLoops; i++)    {        Status = AcpiDbExecuteMethod (&LocalInfo, &ReturnObj);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("%s During evaluation of %s at iteration %X/n",                AcpiFormatException (Status), Info->Pathname, i);            if (Status == AE_ABORT_METHOD)            {                break;            }        }#if 0        if ((i % 100) == 0)        {            AcpiOsPrintf ("%u loops, Thread 0x%x/n",                i, AcpiOsGetThreadId ());        }        if (ReturnObj.Length)        {            AcpiOsPrintf ("Evaluation of %s returned object %p Buflen %X/n",                Info->Pathname, ReturnObj.Pointer,                (UINT32) ReturnObj.Length);            AcpiDbDumpExternalObject (ReturnObj.Pointer, 1);        }#endif    }    /* Signal our completion */    Allow = 0;    (void) AcpiOsWaitSemaphore (Info->ThreadCompleteGate,        1, ACPI_WAIT_FOREVER);    Info->NumCompleted++;    if (Info->NumCompleted == Info->NumThreads)    {        /* Do signal for main thread once only */        Allow = 1;    }    (void) AcpiOsSignalSemaphore (Info->ThreadCompleteGate, 1);    if (Allow)    {        Status = AcpiOsSignalSemaphore (Info->MainThreadGate, 1);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf (                "Could not signal debugger thread sync semaphore, %s/n",                AcpiFormatException (Status));        }//.........这里部分代码省略.........

static ACPI_STATUSAcpiDbWalkForExecute (    ACPI_HANDLE             ObjHandle,    UINT32                  NestingLevel,    void                    *Context,    void                    **ReturnValue){    ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;    ACPI_EXECUTE_WALK       *Info = (ACPI_EXECUTE_WALK *) Context;    ACPI_BUFFER             ReturnObj;    ACPI_STATUS             Status;    char                    *Pathname;    UINT32                  i;    ACPI_DEVICE_INFO        *ObjInfo;    ACPI_OBJECT_LIST        ParamObjects;    ACPI_OBJECT             Params[ACPI_METHOD_NUM_ARGS];    const ACPI_PREDEFINED_INFO *Predefined;    Predefined = AcpiNsCheckForPredefinedName (Node);    if (!Predefined)    {        return (AE_OK);    }    if (Node->Type == ACPI_TYPE_LOCAL_SCOPE)    {        return (AE_OK);    }    Pathname = AcpiNsGetExternalPathname (Node);    if (!Pathname)    {        return (AE_OK);    }    /* Get the object info for number of method parameters */    Status = AcpiGetObjectInfo (ObjHandle, &ObjInfo);    if (ACPI_FAILURE (Status))    {        return (Status);    }    ParamObjects.Pointer = NULL;    ParamObjects.Count   = 0;    if (ObjInfo->Type == ACPI_TYPE_METHOD)    {        /* Setup default parameters */        for (i = 0; i < ObjInfo->ParamCount; i++)        {            Params[i].Type           = ACPI_TYPE_INTEGER;            Params[i].Integer.Value  = 1;        }        ParamObjects.Pointer     = Params;        ParamObjects.Count       = ObjInfo->ParamCount;    }    ACPI_FREE (ObjInfo);    ReturnObj.Pointer = NULL;    ReturnObj.Length = ACPI_ALLOCATE_BUFFER;    /* Do the actual method execution */    AcpiGbl_MethodExecuting = TRUE;    Status = AcpiEvaluateObject (Node, NULL, &ParamObjects, &ReturnObj);    AcpiOsPrintf ("%-32s returned %s/n", Pathname, AcpiFormatException (Status));    AcpiGbl_MethodExecuting = FALSE;    ACPI_FREE (Pathname);    /* Ignore status from method execution */    Status = AE_OK;    /* Update count, check if we have executed enough methods */    Info->Count++;    if (Info->Count >= Info->MaxCount)    {        Status = AE_CTRL_TERMINATE;    }    return (Status);}

voidAcpiDbCreateExecutionThreads (    char                    *NumThreadsArg,    char                    *NumLoopsArg,    char                    *MethodNameArg){    ACPI_STATUS             Status;    UINT32                  NumThreads;    UINT32                  NumLoops;    UINT32                  i;    UINT32                  Size;    ACPI_MUTEX              MainThreadGate;    ACPI_MUTEX              ThreadCompleteGate;    ACPI_MUTEX              InfoGate;    /* Get the arguments */    NumThreads = strtoul (NumThreadsArg, NULL, 0);    NumLoops = strtoul (NumLoopsArg, NULL, 0);    if (!NumThreads || !NumLoops)    {        AcpiOsPrintf ("Bad argument: Threads %X, Loops %X/n",            NumThreads, NumLoops);        return;    }    /*     * Create the semaphore for synchronization of     * the created threads with the main thread.     */    Status = AcpiOsCreateSemaphore (1, 0, &MainThreadGate);    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Could not create semaphore for "            "synchronization with the main thread, %s/n",            AcpiFormatException (Status));        return;    }    /*     * Create the semaphore for synchronization     * between the created threads.     */    Status = AcpiOsCreateSemaphore (1, 1, &ThreadCompleteGate);    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Could not create semaphore for "            "synchronization between the created threads, %s/n",            AcpiFormatException (Status));        (void) AcpiOsDeleteSemaphore (MainThreadGate);        return;    }    Status = AcpiOsCreateSemaphore (1, 1, &InfoGate);    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Could not create semaphore for "            "synchronization of AcpiGbl_DbMethodInfo, %s/n",            AcpiFormatException (Status));        (void) AcpiOsDeleteSemaphore (ThreadCompleteGate);        (void) AcpiOsDeleteSemaphore (MainThreadGate);        return;    }    memset (&AcpiGbl_DbMethodInfo, 0, sizeof (ACPI_DB_METHOD_INFO));    /* Array to store IDs of threads */    AcpiGbl_DbMethodInfo.NumThreads = NumThreads;    Size = sizeof (ACPI_THREAD_ID) * AcpiGbl_DbMethodInfo.NumThreads;    AcpiGbl_DbMethodInfo.Threads = AcpiOsAllocate (Size);    if (AcpiGbl_DbMethodInfo.Threads == NULL)    {        AcpiOsPrintf ("No memory for thread IDs array/n");        (void) AcpiOsDeleteSemaphore (MainThreadGate);        (void) AcpiOsDeleteSemaphore (ThreadCompleteGate);        (void) AcpiOsDeleteSemaphore (InfoGate);        return;    }    memset (AcpiGbl_DbMethodInfo.Threads, 0, Size);    /* Setup the context to be passed to each thread */    AcpiGbl_DbMethodInfo.Name = MethodNameArg;    AcpiGbl_DbMethodInfo.Flags = 0;    AcpiGbl_DbMethodInfo.NumLoops = NumLoops;    AcpiGbl_DbMethodInfo.MainThreadGate = MainThreadGate;    AcpiGbl_DbMethodInfo.ThreadCompleteGate = ThreadCompleteGate;    AcpiGbl_DbMethodInfo.InfoGate = InfoGate;    /* Init arguments to be passed to method */    AcpiGbl_DbMethodInfo.InitArgs = 1;    AcpiGbl_DbMethodInfo.Args = AcpiGbl_DbMethodInfo.Arguments;    AcpiGbl_DbMethodInfo.Arguments[0] = AcpiGbl_DbMethodInfo.NumThreadsStr;//.........这里部分代码省略.........

ACPI_STATUSAslDoOneFile (    char                    *Filename){    ACPI_STATUS             Status;    Gbl_Files[ASL_FILE_INPUT].Filename = Filename;    /* Re-initialize "some" compiler globals */    AslInitializeGlobals ();    /*     * AML Disassembly (Optional)     */    if (Gbl_DisasmFlag || Gbl_GetAllTables)    {        /* ACPI CA subsystem initialization */        Status = AdInitialize ();        if (ACPI_FAILURE (Status))        {            return (Status);        }        Status = AcpiAllocateRootTable (4);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("Could not initialize ACPI Table Manager, %s/n",                AcpiFormatException (Status));            return (Status);        }        /* This is where the disassembly happens */        AcpiGbl_DbOpt_disasm = TRUE;        Status = AdAmlDisassemble (AslToFile,                    Gbl_Files[ASL_FILE_INPUT].Filename,                    Gbl_OutputFilenamePrefix,                    &Gbl_Files[ASL_FILE_INPUT].Filename,                    Gbl_GetAllTables);        if (ACPI_FAILURE (Status))        {            return (Status);        }        /* Shutdown compiler and ACPICA subsystem */        AeClearErrorLog ();        AcpiTerminate ();        /*         * Gbl_Files[ASL_FILE_INPUT].Filename was replaced with the         * .DSL disassembly file, which can now be compiled if requested         */        if (Gbl_DoCompile)        {            AcpiOsPrintf ("/nCompiling /"%s/"/n",                Gbl_Files[ASL_FILE_INPUT].Filename);        }    }    /*     * ASL Compilation (Optional)     */    if (Gbl_DoCompile)    {        /*         * If -p not specified, we will use the input filename as the         * output filename prefix         */        if (Gbl_UseDefaultAmlFilename)        {            Gbl_OutputFilenamePrefix = Gbl_Files[ASL_FILE_INPUT].Filename;        }        /* ACPI CA subsystem initialization (Must be re-initialized) */        Status = AdInitialize ();        if (ACPI_FAILURE (Status))        {            return (Status);        }        Status = CmDoCompile ();        AcpiTerminate ();        /*         * 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))        {            return (AE_ERROR);        }        AeClearErrorLog ();    }//.........这里部分代码省略.........

ACPI_STATUSAdAmlDisassemble (    BOOLEAN                 OutToFile,    char                    *Filename,    char                    *Prefix,    char                    **OutFilename){    ACPI_STATUS             Status;    char                    *DisasmFilename = NULL;    char                    *ExternalFilename;    ACPI_EXTERNAL_FILE      *ExternalFileList = AcpiGbl_ExternalFileList;    FILE                    *File = NULL;    ACPI_TABLE_HEADER       *Table = NULL;    ACPI_TABLE_HEADER       *ExternalTable;    ACPI_OWNER_ID           OwnerId;    /*     * Input: AML code from either a file or via GetTables (memory or     * registry)     */    if (Filename)    {        Status = AcpiDbGetTableFromFile (Filename, &Table);        if (ACPI_FAILURE (Status))        {            return (Status);        }        /*         * External filenames separated by commas         * Example: iasl -e file1,file2,file3 -d xxx.aml         */        while (ExternalFileList)        {            ExternalFilename = ExternalFileList->Path;            if (!ACPI_STRCMP (ExternalFilename, Filename))            {                /* Next external file */                ExternalFileList = ExternalFileList->Next;                continue;            }            Status = AcpiDbGetTableFromFile (ExternalFilename, &ExternalTable);            if (ACPI_FAILURE (Status))            {                return (Status);            }            /* Load external table for symbol resolution */            if (ExternalTable)            {                Status = AdParseTable (ExternalTable, &OwnerId, TRUE, TRUE);                if (ACPI_FAILURE (Status))                {                    AcpiOsPrintf ("Could not parse external ACPI tables, %s/n",                                  AcpiFormatException (Status));                    return (Status);                }                /*                 * Load namespace from names created within control methods                 * Set owner id of nodes in external table                 */                AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,                                           AcpiGbl_RootNode, OwnerId);                AcpiPsDeleteParseTree (AcpiGbl_ParseOpRoot);            }            /* Next external file */            ExternalFileList = ExternalFileList->Next;        }        /* Clear external list generated by Scope in external tables */        if (AcpiGbl_ExternalFileList)        {            AcpiDmClearExternalList ();        }        /* Load any externals defined in the optional external ref file */        AcpiDmGetExternalsFromFile ();    }    else    {        Status = AdGetLocalTables ();        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("Could not get ACPI tables, %s/n",                          AcpiFormatException (Status));            return (Status);        }        if (!AcpiGbl_DbOpt_disasm)        {            return (AE_OK);//.........这里部分代码省略.........

voidAcpiDbCreateExecutionThreads (    NATIVE_CHAR             *NumThreadsArg,    NATIVE_CHAR             *NumLoopsArg,    NATIVE_CHAR             *MethodNameArg){    ACPI_STATUS             Status;    UINT32                  NumThreads;    UINT32                  NumLoops;    UINT32                  i;    ACPI_HANDLE             ThreadGate;    /* Get the arguments */    NumThreads = STRTOUL (NumThreadsArg, NULL, 0);    NumLoops = STRTOUL (NumLoopsArg, NULL, 0);    if (!NumThreads || !NumLoops)    {        AcpiOsPrintf ("Bad argument: Threads %X, Loops %X/n", NumThreads, NumLoops);        return;    }    /* Create the synchronization semaphore */    Status = AcpiOsCreateSemaphore (1, 0, &ThreadGate);    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Could not create semaphore, %s/n", AcpiFormatException (Status));        return;    }    /* Setup the context to be passed to each thread */    AcpiGbl_DbMethodInfo.Name = MethodNameArg;    AcpiGbl_DbMethodInfo.Args = NULL;    AcpiGbl_DbMethodInfo.Flags = 0;    AcpiGbl_DbMethodInfo.NumLoops = NumLoops;    AcpiGbl_DbMethodInfo.ThreadGate = ThreadGate;    AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);    /* Create the threads */    AcpiOsPrintf ("Creating %X threads to execute %X times each/n", NumThreads, NumLoops);    for (i = 0; i < (NumThreads); i++)    {        AcpiOsQueueForExecution (OSD_PRIORITY_MED, AcpiDbMethodThread, &AcpiGbl_DbMethodInfo);    }    /* Wait for all threads to complete */    i = NumThreads;    while (i)   /* Brain damage for OSD implementations that only support wait of 1 unit */    {        Status = AcpiOsWaitSemaphore (ThreadGate, 1, WAIT_FOREVER);        i--;    }    /* Cleanup and exit */    AcpiOsDeleteSemaphore (ThreadGate);    AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT);    AcpiOsPrintf ("All threads (%X) have completed/n", NumThreads);    AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT);}

voidAcpiDbExecute (    char                    *Name,    char                    **Args,    UINT32                  Flags){    ACPI_STATUS             Status;    ACPI_BUFFER             ReturnObj;#ifdef ACPI_DEBUG_OUTPUT    UINT32                  PreviousAllocations;    UINT32                  Allocations;    /* Memory allocation tracking */    PreviousAllocations = AcpiDbGetOutstandingAllocations ();#endif    if (*Name == '*')    {        (void) AcpiWalkNamespace (ACPI_TYPE_METHOD, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,                    AcpiDbExecutionWalk, NULL, NULL);        return;    }    else    {        AcpiGbl_DbMethodInfo.Name = Name;        AcpiGbl_DbMethodInfo.Args = Args;        AcpiGbl_DbMethodInfo.Flags = Flags;        ReturnObj.Pointer = NULL;        ReturnObj.Length = ACPI_ALLOCATE_BUFFER;        AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);        Status = AcpiDbExecuteMethod (&AcpiGbl_DbMethodInfo, &ReturnObj);    }    /*     * Allow any handlers in separate threads to complete.     * (Such as Notify handlers invoked from AML executed above).     */    AcpiOsSleep (0, 10);#ifdef ACPI_DEBUG_OUTPUT    /* Memory allocation tracking */    Allocations = AcpiDbGetOutstandingAllocations () - PreviousAllocations;    AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);    if (Allocations > 0)    {        AcpiOsPrintf ("Outstanding: %ld allocations after execution/n",                        Allocations);    }#endif    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Execution of %s failed with status %s/n",            AcpiGbl_DbMethodInfo.Pathname, AcpiFormatException (Status));    }    else    {        /* Display a return object, if any */        if (ReturnObj.Length)        {            AcpiOsPrintf ("Execution of %s returned object %p Buflen %X/n",                AcpiGbl_DbMethodInfo.Pathname, ReturnObj.Pointer,                (UINT32) ReturnObj.Length);            AcpiDbDumpObject (ReturnObj.Pointer, 1);        }        else        {            AcpiOsPrintf ("No return object from execution of %s/n",                AcpiGbl_DbMethodInfo.Pathname);        }    }    AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);}

ACPI_STATUSAcpiPsParseAml (    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status;    ACPI_THREAD_STATE       *Thread;    ACPI_THREAD_STATE       *PrevWalkList = AcpiGbl_CurrentWalkList;    ACPI_WALK_STATE         *PreviousWalkState;    ACPI_FUNCTION_TRACE (PsParseAml);    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,        "Entered with WalkState=%p Aml=%p size=%X/n",        WalkState, WalkState->ParserState.Aml,        WalkState->ParserState.AmlSize));    if (!WalkState->ParserState.Aml)    {        return_ACPI_STATUS (AE_NULL_OBJECT);    }    /* Create and initialize a new thread state */    Thread = AcpiUtCreateThreadState ();    if (!Thread)    {        if (WalkState->MethodDesc)        {            /* Executing a control method - additional cleanup */            AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);        }        AcpiDsDeleteWalkState (WalkState);        return_ACPI_STATUS (AE_NO_MEMORY);    }    WalkState->Thread = Thread;    /*     * If executing a method, the starting SyncLevel is this method's     * SyncLevel     */    if (WalkState->MethodDesc)    {        WalkState->Thread->CurrentSyncLevel =            WalkState->MethodDesc->Method.SyncLevel;    }    AcpiDsPushWalkState (WalkState, Thread);    /*     * This global allows the AML debugger to get a handle to the currently     * executing control method.     */    AcpiGbl_CurrentWalkList = Thread;    /*     * Execute the walk loop as long as there is a valid Walk State. This     * handles nested control method invocations without recursion.     */    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "State=%p/n", WalkState));    Status = AE_OK;    while (WalkState)    {        if (ACPI_SUCCESS (Status))        {            /*             * The ParseLoop executes AML until the method terminates             * or calls another method.             */            Status = AcpiPsParseLoop (WalkState);        }        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,            "Completed one call to walk loop, %s State=%p/n",            AcpiFormatException (Status), WalkState));        if (Status == AE_CTRL_TRANSFER)        {            /*             * A method call was detected.             * Transfer control to the called control method             */            Status = AcpiDsCallControlMethod (Thread, WalkState, NULL);            if (ACPI_FAILURE (Status))            {                Status = AcpiDsMethodError (Status, WalkState);            }            /*             * If the transfer to the new method method call worked             *, a new walk state was created -- get it             */            WalkState = AcpiDsGetCurrentWalkState (Thread);            continue;        }        else if (Status == AE_CTRL_TERMINATE)//.........这里部分代码省略.........

static intacpi_cpu_attach(device_t dev){    ACPI_BUFFER		   buf;    ACPI_OBJECT		   arg[4], *obj;    ACPI_OBJECT_LIST	   arglist;    struct pcpu		   *pcpu_data;    struct acpi_cpu_softc *sc;    struct acpi_softc	  *acpi_sc;    ACPI_STATUS		   status;    u_int		   features;    int			   cpu_id, drv_count, i;    driver_t 		  **drivers;    uint32_t		   cap_set[3];    /* UUID needed by _OSC evaluation */    static uint8_t cpu_oscuuid[16] = { 0x16, 0xA6, 0x77, 0x40, 0x0C, 0x29,				       0xBE, 0x47, 0x9E, 0xBD, 0xD8, 0x70,				       0x58, 0x71, 0x39, 0x53 };    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);    sc = device_get_softc(dev);    sc->cpu_dev = dev;    sc->cpu_handle = acpi_get_handle(dev);    cpu_id = acpi_get_magic(dev);    cpu_softc[cpu_id] = sc;    pcpu_data = pcpu_find(cpu_id);    pcpu_data->pc_device = dev;    sc->cpu_pcpu = pcpu_data;    cpu_smi_cmd = AcpiGbl_FADT.SmiCommand;    cpu_cst_cnt = AcpiGbl_FADT.CstControl;    buf.Pointer = NULL;    buf.Length = ACPI_ALLOCATE_BUFFER;    status = AcpiEvaluateObject(sc->cpu_handle, NULL, NULL, &buf);    if (ACPI_FAILURE(status)) {	device_printf(dev, "attach failed to get Processor obj - %s/n",		      AcpiFormatException(status));	return (ENXIO);    }    obj = (ACPI_OBJECT *)buf.Pointer;    sc->cpu_p_blk = obj->Processor.PblkAddress;    sc->cpu_p_blk_len = obj->Processor.PblkLength;    sc->cpu_acpi_id = obj->Processor.ProcId;    AcpiOsFree(obj);    ACPI_DEBUG_PRINT((ACPI_DB_INFO, "acpi_cpu%d: P_BLK at %#x/%d/n",		     device_get_unit(dev), sc->cpu_p_blk, sc->cpu_p_blk_len));    /*     * If this is the first cpu we attach, create and initialize the generic     * resources that will be used by all acpi cpu devices.     */    if (device_get_unit(dev) == 0) {	/* Assume we won't be using generic Cx mode by default */	cpu_cx_generic = FALSE;	/* Install hw.acpi.cpu sysctl tree */	acpi_sc = acpi_device_get_parent_softc(dev);	sysctl_ctx_init(&cpu_sysctl_ctx);	cpu_sysctl_tree = SYSCTL_ADD_NODE(&cpu_sysctl_ctx,	    SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO, "cpu",	    CTLFLAG_RD, 0, "node for CPU children");	/* Queue post cpu-probing task handler */	AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_cpu_startup, NULL);    }    /*     * Before calling any CPU methods, collect child driver feature hints     * and notify ACPI of them.  We support unified SMP power control     * so advertise this ourselves.  Note this is not the same as independent     * SMP control where each CPU can have different settings.     */    sc->cpu_features = ACPI_CAP_SMP_SAME | ACPI_CAP_SMP_SAME_C3;    if (devclass_get_drivers(acpi_cpu_devclass, &drivers, &drv_count) == 0) {	for (i = 0; i < drv_count; i++) {	    if (ACPI_GET_FEATURES(drivers[i], &features) == 0)		sc->cpu_features |= features;	}	free(drivers, M_TEMP);    }    /*     * CPU capabilities are specified as a buffer of 32-bit integers:     * revision, count, and one or more capabilities.  The revision of     * "1" is not specified anywhere but seems to match Linux.     */    if (sc->cpu_features) {	arglist.Pointer = arg;	arglist.Count = 1;	arg[0].Type = ACPI_TYPE_BUFFER;	arg[0].Buffer.Length = sizeof(cap_set);	arg[0].Buffer.Pointer = (uint8_t *)cap_set;	cap_set[0] = 1; /* revision */	cap_set[1] = 1; /* number of capabilities integers */	cap_set[2] = sc->cpu_features;	AcpiEvaluateObject(sc->cpu_handle, "_PDC", &arglist, NULL);	/*//.........这里部分代码省略.........

static ACPI_STATUSAcpiDmTestResourceConversion (    ACPI_NAMESPACE_NODE     *Node,    char                    *Name){    ACPI_STATUS             Status;    ACPI_BUFFER             ReturnObj;    ACPI_BUFFER             ResourceObj;    ACPI_BUFFER             NewAml;    ACPI_OBJECT             *OriginalAml;    AcpiOsPrintf ("Resource Conversion Comparison:/n");    NewAml.Length = ACPI_ALLOCATE_LOCAL_BUFFER;    ReturnObj.Length = ACPI_ALLOCATE_LOCAL_BUFFER;    ResourceObj.Length = ACPI_ALLOCATE_LOCAL_BUFFER;    /* Get the original _CRS AML resource template */    Status = AcpiEvaluateObject (Node, Name, NULL, &ReturnObj);    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Could not obtain %s: %s/n",            Name, AcpiFormatException (Status));        return (Status);    }    /* Get the AML resource template, converted to internal resource structs */    Status = AcpiGetCurrentResources (Node, &ResourceObj);    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("AcpiGetCurrentResources failed: %s/n",            AcpiFormatException (Status));        goto Exit1;    }    /* Convert internal resource list to external AML resource template */    Status = AcpiRsCreateAmlResources (ResourceObj.Pointer, &NewAml);    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("AcpiRsCreateAmlResources failed: %s/n",            AcpiFormatException (Status));        goto Exit2;    }    /* Compare original AML to the newly created AML resource list */    OriginalAml = ReturnObj.Pointer;    AcpiDmCompareAmlResources (        OriginalAml->Buffer.Pointer, (ACPI_RSDESC_SIZE) OriginalAml->Buffer.Length,        NewAml.Pointer, (ACPI_RSDESC_SIZE) NewAml.Length);    /* Cleanup and exit */    ACPI_FREE (NewAml.Pointer);Exit2:    ACPI_FREE (ResourceObj.Pointer);Exit1:    ACPI_FREE (ReturnObj.Pointer);    return (Status);}

intApDumpTableByName (    char                    *Signature){    char                    LocalSignature [ACPI_NAME_SIZE + 1];    UINT32                  Instance;    ACPI_TABLE_HEADER       *Table;    ACPI_PHYSICAL_ADDRESS   Address;    ACPI_STATUS             Status;    int                     TableStatus;    if (strlen (Signature) != ACPI_NAME_SIZE)    {        AcpiLogError (            "Invalid table signature [%s]: must be exactly 4 characters/n",            Signature);        return (-1);    }    /* Table signatures are expected to be uppercase */    strcpy (LocalSignature, Signature);    AcpiUtStrupr (LocalSignature);    /* To be friendly, handle tables whose signatures do not match the name */    if (ACPI_COMPARE_NAME (LocalSignature, "FADT"))    {        strcpy (LocalSignature, ACPI_SIG_FADT);    }    else if (ACPI_COMPARE_NAME (LocalSignature, "MADT"))    {        strcpy (LocalSignature, ACPI_SIG_MADT);    }    /* Dump all instances of this signature (to handle multiple SSDTs) */    for (Instance = 0; Instance < AP_MAX_ACPI_FILES; Instance++)    {        Status = AcpiOsGetTableByName (LocalSignature, Instance,            &Table, &Address);        if (ACPI_FAILURE (Status))        {            /* AE_LIMIT means that no more tables are available */            if (Status == AE_LIMIT)            {                return (0);            }            AcpiLogError (                "Could not get ACPI table with signature [%s], %s/n",                LocalSignature, AcpiFormatException (Status));            return (-1);        }        TableStatus = ApDumpTableBuffer (Table, Instance, Address);        ACPI_FREE (Table);        if (TableStatus)        {            break;        }    }    /* Something seriously bad happened if the loop terminates here */    return (-1);}

static ACPI_STATUSAcpiDbReadFromObject (    ACPI_NAMESPACE_NODE     *Node,    ACPI_OBJECT_TYPE        ExpectedType,    ACPI_OBJECT             **Value){    ACPI_OBJECT             *RetValue;    ACPI_OBJECT_LIST        ParamObjects;    ACPI_OBJECT             Params[2];    ACPI_BUFFER             ReturnObj;    ACPI_STATUS             Status;    Params[0].Type = ACPI_TYPE_LOCAL_REFERENCE;    Params[0].Reference.ActualType = Node->Type;    Params[0].Reference.Handle = ACPI_CAST_PTR (ACPI_HANDLE, Node);    ParamObjects.Count = 1;    ParamObjects.Pointer = Params;    ReturnObj.Length  = ACPI_ALLOCATE_BUFFER;    AcpiGbl_MethodExecuting = TRUE;    Status = AcpiEvaluateObject (ReadHandle, NULL,        &ParamObjects, &ReturnObj);    AcpiGbl_MethodExecuting = FALSE;    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Could not read from object, %s",            AcpiFormatException (Status));        return (Status);    }    RetValue = (ACPI_OBJECT *) ReturnObj.Pointer;    switch (RetValue->Type)    {    case ACPI_TYPE_INTEGER:    case ACPI_TYPE_BUFFER:    case ACPI_TYPE_STRING:        /*         * Did we receive the type we wanted? Most important for the         * Integer/Buffer case (when a field is larger than an Integer,         * it should return a Buffer).         */        if (RetValue->Type != ExpectedType)        {            AcpiOsPrintf (" Type mismatch:  Expected %s, Received %s",                AcpiUtGetTypeName (ExpectedType),                AcpiUtGetTypeName (RetValue->Type));            return (AE_TYPE);        }        *Value = RetValue;        break;    default:        AcpiOsPrintf (" Unsupported return object type, %s",            AcpiUtGetTypeName (RetValue->Type));        AcpiOsFree (ReturnObj.Pointer);        return (AE_TYPE);    }    return (Status);}