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

static ACPI_STATUSOslMapTable (    ACPI_SIZE               Address,    char                    *Signature,    ACPI_TABLE_HEADER       **Table){    ACPI_TABLE_HEADER       *MappedTable;    UINT32                  Length;    /* Map the header so we can get the table length */    MappedTable = AcpiOsMapMemory (Address, sizeof (*MappedTable));    if (!MappedTable)    {        return (AE_BAD_ADDRESS);    }    /* Check if table is valid */    if (!ApIsValidHeader (MappedTable))    {        AcpiOsUnmapMemory (MappedTable, sizeof (*MappedTable));        return (AE_BAD_HEADER);    }    /* If specified, signature must match */    if (Signature &&        !ACPI_COMPARE_NAME (Signature, MappedTable->Signature))    {        AcpiOsUnmapMemory (MappedTable, sizeof (*MappedTable));        return (AE_NOT_EXIST);    }    /* Map the entire table */    Length = MappedTable->Length;    AcpiOsUnmapMemory (MappedTable, sizeof (*MappedTable));    MappedTable = AcpiOsMapMemory (Address, Length);    if (!MappedTable)    {        return (AE_BAD_ADDRESS);    }    (void) ApIsValidChecksum (MappedTable);    *Table = MappedTable;    return (AE_OK);}

ACPI_STATUSAcpiOsReadMemory(ACPI_PHYSICAL_ADDRESS Address, UINT32 *Value, UINT32 Width){    void	*LogicalAddress;    LogicalAddress = AcpiOsMapMemory(Address, Width / 8);    if (LogicalAddress == NULL)	return (AE_NOT_EXIST);    switch (Width) {    case 8:	*(u_int8_t *)Value = (*(volatile u_int8_t *)LogicalAddress);	break;    case 16:	*(u_int16_t *)Value = (*(volatile u_int16_t *)LogicalAddress);	break;    case 32:	*(u_int32_t *)Value = (*(volatile u_int32_t *)LogicalAddress);	break;    case 64:	*(u_int64_t *)Value = (*(volatile u_int64_t *)LogicalAddress);	break;    default:	/* debug trap goes here */	break;    }    AcpiOsUnmapMemory(LogicalAddress, Width / 8);    return (AE_OK);}

ACPI_STATUSAcpiOsWriteMemory(ACPI_PHYSICAL_ADDRESS Address, UINT64 Value, UINT32 Width){    void	*LogicalAddress;    LogicalAddress = AcpiOsMapMemory(Address, Width / 8);    if (LogicalAddress == NULL)	return (AE_NOT_EXIST);    switch (Width) {    case 8:	*(volatile uint8_t *)LogicalAddress = Value;	break;    case 16:	*(volatile uint16_t *)LogicalAddress = Value;	break;    case 32:	*(volatile uint32_t *)LogicalAddress = Value;	break;    case 64:	*(volatile uint64_t *)LogicalAddress = Value;	break;    }    AcpiOsUnmapMemory(LogicalAddress, Width / 8);    return (AE_OK);}

/* * AcpiOsWriteMemory: * *	Write a value to a memory location. */ACPI_STATUSAcpiOsWriteMemory(ACPI_PHYSICAL_ADDRESS Address, UINT32 Value, UINT32 Width){	void *LogicalAddress;	ACPI_STATUS rv = AE_OK;	LogicalAddress = AcpiOsMapMemory(Address, Width / 8);	if (LogicalAddress == NULL)		return AE_NOT_FOUND;	switch (Width) {	case 8:		*(volatile uint8_t *) LogicalAddress = Value;		break;	case 16:		*(volatile uint16_t *) LogicalAddress = Value;		break;	case 32:		*(volatile uint32_t *) LogicalAddress = Value;		break;	default:		rv = AE_BAD_PARAMETER;	}	AcpiOsUnmapMemory(LogicalAddress, Width / 8);	return rv;}

voidAcpiTbDeleteSingleTable (    ACPI_TABLE_DESC         *TableDesc){    /* Must have a valid table descriptor and pointer */    if ((!TableDesc) ||         (!TableDesc->Pointer))    {        return;    }    /* Valid table, determine type of memory allocation */    switch (TableDesc->Allocation)    {    case ACPI_MEM_NOT_ALLOCATED:        break;    case ACPI_MEM_ALLOCATED:        ACPI_FREE (TableDesc->Pointer);        break;    case ACPI_MEM_MAPPED:        AcpiOsUnmapMemory (TableDesc->Pointer, TableDesc->Length);        break;    default:        break;    }}

voidAcpiTbParseFadt (    void){    UINT32                  Length;    ACPI_TABLE_HEADER       *Table;    /*     * The FADT has multiple versions with different lengths,     * and it contains pointers to both the DSDT and FACS tables.     *     * Get a local copy of the FADT and convert it to a common format     * Map entire FADT, assumed to be smaller than one page.     */    Length = AcpiGbl_RootTableList.Tables[AcpiGbl_FadtIndex].Length;    Table = AcpiOsMapMemory (        AcpiGbl_RootTableList.Tables[AcpiGbl_FadtIndex].Address, Length);    if (!Table)    {        return;    }    /*     * Validate the FADT checksum before we copy the table. Ignore     * checksum error as we want to try to get the DSDT and FACS.     */    (void) AcpiTbVerifyChecksum (Table, Length);    /* Create a local copy of the FADT in common ACPI 2.0+ format */    AcpiTbCreateLocalFadt (Table, Length);    /* All done with the real FADT, unmap it */    AcpiOsUnmapMemory (Table, Length);    /* Obtain the DSDT and FACS tables via their addresses within the FADT */    AcpiTbInstallFixedTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XDsdt,        ACPI_SIG_DSDT, &AcpiGbl_DsdtIndex);    /* If Hardware Reduced flag is set, there is no FACS */    if (!AcpiGbl_ReducedHardware)    {        if (AcpiGbl_FADT.Facs)        {            AcpiTbInstallFixedTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.Facs,                ACPI_SIG_FACS, &AcpiGbl_FacsIndex);        }        if (AcpiGbl_FADT.XFacs)        {            AcpiTbInstallFixedTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XFacs,                ACPI_SIG_FACS, &AcpiGbl_XFacsIndex);        }    }}

ACPI_STATUSAcpiOsGetTableByAddress (    ACPI_PHYSICAL_ADDRESS   Address,    ACPI_TABLE_HEADER       **Table){    ACPI_TABLE_HEADER       *MappedTable;    ACPI_TABLE_HEADER       *LocalTable;    ACPI_STATUS             Status;    /* Validate the input physical address to avoid program crash */    if (Address < ACPI_HI_RSDP_WINDOW_BASE)    {        fprintf (stderr, "Invalid table address: 0x%8.8X%8.8X/n",            ACPI_FORMAT_UINT64 (Address));        return (AE_BAD_ADDRESS);    }    /* Map the table and validate it */    Status = OslMapTable (Address, NULL, &MappedTable);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /* Copy table to local buffer and return it */    LocalTable = calloc (1, MappedTable->Length);    if (!LocalTable)    {        AcpiOsUnmapMemory (MappedTable, MappedTable->Length);        return (AE_NO_MEMORY);    }    ACPI_MEMCPY (LocalTable, MappedTable, MappedTable->Length);    AcpiOsUnmapMemory (MappedTable, MappedTable->Length);    *Table = LocalTable;    return (AE_OK);}

ACPI_STATUSAcpiEvSystemMemoryRegionSetup (    ACPI_HANDLE             Handle,    UINT32                  Function,    void                    *HandlerContext,    void                    **RegionContext){    ACPI_OPERAND_OBJECT     *RegionDesc = (ACPI_OPERAND_OBJECT *) Handle;    ACPI_MEM_SPACE_CONTEXT  *LocalRegionContext;    ACPI_FUNCTION_TRACE (EvSystemMemoryRegionSetup);    if (Function == ACPI_REGION_DEACTIVATE)    {        if (*RegionContext)        {            LocalRegionContext = (ACPI_MEM_SPACE_CONTEXT *) *RegionContext;            /* Delete a cached mapping if present */            if (LocalRegionContext->MappedLength)            {                AcpiOsUnmapMemory (LocalRegionContext->MappedLogicalAddress,                    LocalRegionContext->MappedLength);            }            ACPI_FREE (LocalRegionContext);            *RegionContext = NULL;        }        return_ACPI_STATUS (AE_OK);    }    /* Create a new context */    LocalRegionContext = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_MEM_SPACE_CONTEXT));    if (!(LocalRegionContext))    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Save the region length and address for use in the handler */    LocalRegionContext->Length  = RegionDesc->Region.Length;    LocalRegionContext->Address = RegionDesc->Region.Address;    *RegionContext = LocalRegionContext;    return_ACPI_STATUS (AE_OK);}

ACPI_STATUSAcpiTbAcquireTempTable (    ACPI_TABLE_DESC         *TableDesc,    ACPI_PHYSICAL_ADDRESS   Address,    UINT8                   Flags){    ACPI_TABLE_HEADER       *TableHeader;    switch (Flags & ACPI_TABLE_ORIGIN_MASK)    {    case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:        /* Get the length of the full table from the header */        TableHeader = AcpiOsMapMemory (Address, sizeof (ACPI_TABLE_HEADER));        if (!TableHeader)        {            return (AE_NO_MEMORY);        }        AcpiTbInitTableDescriptor (TableDesc, Address, Flags, TableHeader);        AcpiOsUnmapMemory (TableHeader, sizeof (ACPI_TABLE_HEADER));        return (AE_OK);    case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:    case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:        TableHeader = ACPI_CAST_PTR (ACPI_TABLE_HEADER,            ACPI_PHYSADDR_TO_PTR (Address));        if (!TableHeader)        {            return (AE_NO_MEMORY);        }        AcpiTbInitTableDescriptor (TableDesc, Address, Flags, TableHeader);        return (AE_OK);    default:        break;    }    /* Table is not valid yet */    return (AE_NO_MEMORY);}

voidAcpiTbParseFadt (    ACPI_NATIVE_UINT        TableIndex,    UINT8                   Flags){    UINT32                  Length;    ACPI_TABLE_HEADER       *Table;    /*     * The FADT has multiple versions with different lengths,     * and it contains pointers to both the DSDT and FACS tables.     *     * Get a local copy of the FADT and convert it to a common format     * Map entire FADT, assumed to be smaller than one page.     */    Length = AcpiGbl_RootTableList.Tables[TableIndex].Length;    Table = AcpiOsMapMemory (                AcpiGbl_RootTableList.Tables[TableIndex].Address, Length);    if (!Table)    {        return;    }    /*     * Validate the FADT checksum before we copy the table. Ignore     * checksum error as we want to try to get the DSDT and FACS.     */    (void) AcpiTbVerifyChecksum (Table, Length);    /* Obtain a local copy of the FADT in common ACPI 2.0+ format */    AcpiTbCreateLocalFadt (Table, Length);    /* All done with the real FADT, unmap it */    AcpiOsUnmapMemory (Table, Length);    /* Obtain the DSDT and FACS tables via their addresses within the FADT */    AcpiTbInstallTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XDsdt,        Flags, ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT);    AcpiTbInstallTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XFacs,        Flags, ACPI_SIG_FACS, ACPI_TABLE_INDEX_FACS);}

voidAcpiTbReleaseTable (    ACPI_TABLE_HEADER       *Table,    UINT32                  TableLength,    UINT8                   TableFlags){    switch (TableFlags & ACPI_TABLE_ORIGIN_MASK)    {    case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:        AcpiOsUnmapMemory (Table, TableLength);        break;    case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:    case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:    default:        break;    }}

ACPI_STATUSAcpiTbFindRsdp (    ACPI_TABLE_DESC         *TableInfo,    UINT32                  Flags){    UINT8                   *TablePtr;    UINT8                   *MemRover;    UINT64                  PhysAddr;    ACPI_STATUS             Status = AE_OK;    ACPI_FUNCTION_TRACE ("TbFindRsdp");    /*     * Scan supports either 1) Logical addressing or 2) Physical addressing     */    if ((Flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING)    {        /*         * 1) Search EBDA (low memory) paragraphs         */        Status = AcpiOsMapMemory ((UINT64) ACPI_LO_RSDP_WINDOW_BASE, ACPI_LO_RSDP_WINDOW_SIZE,                                    (void **) &TablePtr);        if (ACPI_FAILURE (Status))        {            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not map memory at %X for length %X/n",                ACPI_LO_RSDP_WINDOW_BASE, ACPI_LO_RSDP_WINDOW_SIZE));            return_ACPI_STATUS (Status);        }        MemRover = AcpiTbScanMemoryForRsdp (TablePtr, ACPI_LO_RSDP_WINDOW_SIZE);        AcpiOsUnmapMemory (TablePtr, ACPI_LO_RSDP_WINDOW_SIZE);        if (MemRover)        {            /* Found it, return the physical address */            PhysAddr = ACPI_LO_RSDP_WINDOW_BASE;            PhysAddr += ACPI_PTR_DIFF (MemRover,TablePtr);            TableInfo->PhysicalAddress = PhysAddr;            return_ACPI_STATUS (AE_OK);        }        /*         * 2) Search upper memory: 16-byte boundaries in E0000h-F0000h         */        Status = AcpiOsMapMemory ((UINT64) ACPI_HI_RSDP_WINDOW_BASE, ACPI_HI_RSDP_WINDOW_SIZE,                                    (void **) &TablePtr);        if (ACPI_FAILURE (Status))        {            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not map memory at %X for length %X/n",                ACPI_HI_RSDP_WINDOW_BASE, ACPI_HI_RSDP_WINDOW_SIZE));            return_ACPI_STATUS (Status);        }        MemRover = AcpiTbScanMemoryForRsdp (TablePtr, ACPI_HI_RSDP_WINDOW_SIZE);        AcpiOsUnmapMemory (TablePtr, ACPI_HI_RSDP_WINDOW_SIZE);        if (MemRover)        {            /* Found it, return the physical address */            PhysAddr = ACPI_HI_RSDP_WINDOW_BASE;            PhysAddr += ACPI_PTR_DIFF (MemRover, TablePtr);            TableInfo->PhysicalAddress = PhysAddr;            return_ACPI_STATUS (AE_OK);        }    }    /*     * Physical addressing     */    else    {        /*         * 1) Search EBDA (low memory) paragraphs         */        MemRover = AcpiTbScanMemoryForRsdp (ACPI_PHYSADDR_TO_PTR (ACPI_LO_RSDP_WINDOW_BASE),                        ACPI_LO_RSDP_WINDOW_SIZE);        if (MemRover)        {            /* Found it, return the physical address */            TableInfo->PhysicalAddress = ACPI_TO_INTEGER (MemRover);            return_ACPI_STATUS (AE_OK);        }        /*         * 2) Search upper memory: 16-byte boundaries in E0000h-F0000h         */        MemRover = AcpiTbScanMemoryForRsdp (ACPI_PHYSADDR_TO_PTR (ACPI_HI_RSDP_WINDOW_BASE),                        ACPI_HI_RSDP_WINDOW_SIZE);        if (MemRover)        {            /* Found it, return the physical address */            TableInfo->PhysicalAddress = ACPI_TO_INTEGER (MemRover);//.........这里部分代码省略.........

ACPI_STATUSAcpiTbParseRootTable (    ACPI_PHYSICAL_ADDRESS   RsdpAddress){    ACPI_TABLE_RSDP         *Rsdp;    UINT32                  TableEntrySize;    UINT32                  i;    UINT32                  TableCount;    ACPI_TABLE_HEADER       *Table;    ACPI_PHYSICAL_ADDRESS   Address;    UINT32                  Length;    UINT8                   *TableEntry;    ACPI_STATUS             Status;    UINT32                  TableIndex;    ACPI_FUNCTION_TRACE (TbParseRootTable);    /* Map the entire RSDP and extract the address of the RSDT or XSDT */    Rsdp = AcpiOsMapMemory (RsdpAddress, sizeof (ACPI_TABLE_RSDP));    if (!Rsdp)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    AcpiTbPrintTableHeader (RsdpAddress,        ACPI_CAST_PTR (ACPI_TABLE_HEADER, Rsdp));    /* Use XSDT if present and not overridden. Otherwise, use RSDT */    if ((Rsdp->Revision > 1) &&        Rsdp->XsdtPhysicalAddress &&        !AcpiGbl_DoNotUseXsdt)    {        /*         * RSDP contains an XSDT (64-bit physical addresses). We must use         * the XSDT if the revision is > 1 and the XSDT pointer is present,         * as per the ACPI specification.         */        Address = (ACPI_PHYSICAL_ADDRESS) Rsdp->XsdtPhysicalAddress;        TableEntrySize = ACPI_XSDT_ENTRY_SIZE;    }    else    {        /* Root table is an RSDT (32-bit physical addresses) */        Address = (ACPI_PHYSICAL_ADDRESS) Rsdp->RsdtPhysicalAddress;        TableEntrySize = ACPI_RSDT_ENTRY_SIZE;    }    /*     * It is not possible to map more than one entry in some environments,     * so unmap the RSDP here before mapping other tables     */    AcpiOsUnmapMemory (Rsdp, sizeof (ACPI_TABLE_RSDP));    /* Map the RSDT/XSDT table header to get the full table length */    Table = AcpiOsMapMemory (Address, sizeof (ACPI_TABLE_HEADER));    if (!Table)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    AcpiTbPrintTableHeader (Address, Table);    /*     * Validate length of the table, and map entire table.     * Minimum length table must contain at least one entry.     */    Length = Table->Length;    AcpiOsUnmapMemory (Table, sizeof (ACPI_TABLE_HEADER));    if (Length < (sizeof (ACPI_TABLE_HEADER) + TableEntrySize))    {        ACPI_BIOS_ERROR ((AE_INFO,            "Invalid table length 0x%X in RSDT/XSDT", Length));        return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH);    }    Table = AcpiOsMapMemory (Address, Length);    if (!Table)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Validate the root table checksum */    Status = AcpiTbVerifyChecksum (Table, Length);    if (ACPI_FAILURE (Status))    {        AcpiOsUnmapMemory (Table, Length);        return_ACPI_STATUS (Status);    }    /* Get the number of entries and pointer to first entry */    TableCount = (UINT32) ((Table->Length - sizeof (ACPI_TABLE_HEADER)) ///.........这里部分代码省略.........

ACPI_STATUSAcpiExSystemMemorySpaceHandler (    UINT32                  Function,    ACPI_PHYSICAL_ADDRESS   Address,    UINT32                  BitWidth,    UINT64                  *Value,    void                    *HandlerContext,    void                    *RegionContext){    ACPI_STATUS             Status = AE_OK;    void                    *LogicalAddrPtr = NULL;    ACPI_MEM_SPACE_CONTEXT  *MemInfo = RegionContext;    UINT32                  Length;    ACPI_SIZE               MapLength;    ACPI_SIZE               PageBoundaryMapLength;#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED    UINT32                  Remainder;#endif    ACPI_FUNCTION_TRACE (ExSystemMemorySpaceHandler);    /* Validate and translate the bit width */    switch (BitWidth)    {    case 8:        Length = 1;        break;    case 16:        Length = 2;        break;    case 32:        Length = 4;        break;    case 64:        Length = 8;        break;    default:        ACPI_ERROR ((AE_INFO, "Invalid SystemMemory width %u",            BitWidth));        return_ACPI_STATUS (AE_AML_OPERAND_VALUE);    }#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED    /*     * Hardware does not support non-aligned data transfers, we must verify     * the request.     */    (void) AcpiUtShortDivide ((UINT64) Address, Length, NULL, &Remainder);    if (Remainder != 0)    {        return_ACPI_STATUS (AE_AML_ALIGNMENT);    }#endif    /*     * Does the request fit into the cached memory mapping?     * Is 1) Address below the current mapping? OR     *    2) Address beyond the current mapping?     */    if ((Address < MemInfo->MappedPhysicalAddress) ||        (((UINT64) Address + Length) >            ((UINT64)            MemInfo->MappedPhysicalAddress + MemInfo->MappedLength)))    {        /*         * The request cannot be resolved by the current memory mapping;         * Delete the existing mapping and create a new one.         */        if (MemInfo->MappedLength)        {            /* Valid mapping, delete it */            AcpiOsUnmapMemory (MemInfo->MappedLogicalAddress,                MemInfo->MappedLength);        }        /*         * October 2009: Attempt to map from the requested address to the         * end of the region. However, we will never map more than one         * page, nor will we cross a page boundary.         */        MapLength = (ACPI_SIZE)            ((MemInfo->Address + MemInfo->Length) - Address);        /*         * If mapping the entire remaining portion of the region will cross         * a page boundary, just map up to the page boundary, do not cross.         * On some systems, crossing a page boundary while mapping regions//.........这里部分代码省略.........

ACPI_STATUSAcpiFindRootPointer (    ACPI_SIZE               *TableAddress){    UINT8                   *TablePtr;    UINT8                   *MemRover;    UINT32                  PhysicalAddress;    ACPI_FUNCTION_TRACE (AcpiFindRootPointer);    /* 1a) Get the location of the Extended BIOS Data Area (EBDA) */    TablePtr = AcpiOsMapMemory (                (ACPI_PHYSICAL_ADDRESS) ACPI_EBDA_PTR_LOCATION,                ACPI_EBDA_PTR_LENGTH);    if (!TablePtr)    {        ACPI_ERROR ((AE_INFO,            "Could not map memory at 0x%8.8X for length %u",            ACPI_EBDA_PTR_LOCATION, ACPI_EBDA_PTR_LENGTH));        return_ACPI_STATUS (AE_NO_MEMORY);    }    ACPI_MOVE_16_TO_32 (&PhysicalAddress, TablePtr);    /* Convert segment part to physical address */    PhysicalAddress <<= 4;    AcpiOsUnmapMemory (TablePtr, ACPI_EBDA_PTR_LENGTH);    /* EBDA present? */    if (PhysicalAddress > 0x400)    {        /*         * 1b) Search EBDA paragraphs (EBDA is required to be a         *     minimum of 1K length)         */        TablePtr = AcpiOsMapMemory (                    (ACPI_PHYSICAL_ADDRESS) PhysicalAddress,                    ACPI_EBDA_WINDOW_SIZE);        if (!TablePtr)        {            ACPI_ERROR ((AE_INFO,                "Could not map memory at 0x%8.8X for length %u",                PhysicalAddress, ACPI_EBDA_WINDOW_SIZE));            return_ACPI_STATUS (AE_NO_MEMORY);        }        MemRover = AcpiTbScanMemoryForRsdp (TablePtr, ACPI_EBDA_WINDOW_SIZE);        AcpiOsUnmapMemory (TablePtr, ACPI_EBDA_WINDOW_SIZE);        if (MemRover)        {            /* Return the physical address */            PhysicalAddress += (UINT32) ACPI_PTR_DIFF (MemRover, TablePtr);            *TableAddress = PhysicalAddress;            return_ACPI_STATUS (AE_OK);        }    }    /*     * 2) Search upper memory: 16-byte boundaries in E0000h-FFFFFh     */    TablePtr = AcpiOsMapMemory (                (ACPI_PHYSICAL_ADDRESS) ACPI_HI_RSDP_WINDOW_BASE,                ACPI_HI_RSDP_WINDOW_SIZE);    if (!TablePtr)    {        ACPI_ERROR ((AE_INFO,            "Could not map memory at 0x%8.8X for length %u",            ACPI_HI_RSDP_WINDOW_BASE, ACPI_HI_RSDP_WINDOW_SIZE));        return_ACPI_STATUS (AE_NO_MEMORY);    }    MemRover = AcpiTbScanMemoryForRsdp (TablePtr, ACPI_HI_RSDP_WINDOW_SIZE);    AcpiOsUnmapMemory (TablePtr, ACPI_HI_RSDP_WINDOW_SIZE);    if (MemRover)    {        /* Return the physical address */        PhysicalAddress = (UINT32)            (ACPI_HI_RSDP_WINDOW_BASE + ACPI_PTR_DIFF (MemRover, TablePtr));        *TableAddress = PhysicalAddress;        return_ACPI_STATUS (AE_OK);    }    /* A valid RSDP was not found */    ACPI_BIOS_ERROR ((AE_INFO, "A valid RSDP was not found"));//.........这里部分代码省略.........

//.........这里部分代码省略.........    for (i = 0; i < 4; i++)    {        NewInfo = calloc (1, sizeof (*NewInfo));        if (!NewInfo)        {            return (AE_NO_MEMORY);        }        switch (i) {        case 0:            Gbl_TableListHead = Info = NewInfo;            continue;        case 1:            ACPI_MOVE_NAME (NewInfo->Signature,                Gbl_Revision ? ACPI_SIG_XSDT : ACPI_SIG_RSDT);            break;        case 2:            ACPI_MOVE_NAME (NewInfo->Signature, ACPI_SIG_FACS);            break;        default:            ACPI_MOVE_NAME (NewInfo->Signature, ACPI_SIG_DSDT);        }        Info->Next = NewInfo;        Info = NewInfo;        Gbl_TableListHead->Instance++;    }    /* Add normal tables from RSDT/XSDT to global list */    if (Gbl_Revision)    {        NumberOfTables =            (Gbl_Xsdt->Header.Length - sizeof (Gbl_Xsdt->Header))            / sizeof (Gbl_Xsdt->TableOffsetEntry[0]);    }    else    {        NumberOfTables =            (Gbl_Rsdt->Header.Length - sizeof (Gbl_Rsdt->Header))            / sizeof (Gbl_Rsdt->TableOffsetEntry[0]);    }    for (i = 0; i < NumberOfTables; i++)    {        if (Gbl_Revision)        {            TableAddress = Gbl_Xsdt->TableOffsetEntry[i];        }        else        {            TableAddress = Gbl_Rsdt->TableOffsetEntry[i];        }        Table = AcpiOsMapMemory (TableAddress, sizeof (*Table));        if (!Table)        {            return (AE_BAD_ADDRESS);        }        Instance = 0;        NewInfo = Gbl_TableListHead;        while (NewInfo->Next != NULL)        {            NewInfo = NewInfo->Next;            if (ACPI_COMPARE_NAME (Table->Signature, NewInfo->Signature))            {                Instance++;            }        }        NewInfo = calloc (1, sizeof (*NewInfo));        if (!NewInfo)        {            AcpiOsUnmapMemory (Table, sizeof (*Table));            return (AE_NO_MEMORY);        }        ACPI_MOVE_NAME (NewInfo->Signature, Table->Signature);        AcpiOsUnmapMemory (Table, sizeof (*Table));        NewInfo->Instance = Instance;        NewInfo->Address = TableAddress;        Info->Next = NewInfo;        Info = NewInfo;        Gbl_TableListHead->Instance++;    }    Gbl_TableListInitialized = TRUE;    return (AE_OK);}

static ACPI_STATUSOslGetTableViaRoot (    char                    *Signature,    UINT32                  Instance,    ACPI_TABLE_HEADER       **Table,    ACPI_PHYSICAL_ADDRESS   *Address){    ACPI_TABLE_HEADER       *LocalTable = NULL;    ACPI_TABLE_HEADER       *MappedTable = NULL;    UINT8                   NumberOfTables;    UINT32                  CurrentInstance = 0;    ACPI_PHYSICAL_ADDRESS   TableAddress = 0;    ACPI_STATUS             Status;    UINT32                  i;    /* DSDT and FACS address must be extracted from the FADT */    if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_DSDT) ||        ACPI_COMPARE_NAME (Signature, ACPI_SIG_FACS))    {        /*         * Get the appropriate address, either 32-bit or 64-bit. Be very         * careful about the FADT length and validate table addresses.         * Note: The 64-bit addresses have priority.         */        if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_DSDT))        {            if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_XDSDT) &&                Gbl_Fadt->XDsdt)            {                TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->XDsdt;            }            else if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_DSDT) &&                Gbl_Fadt->Dsdt)            {                TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->Dsdt;            }        }        else /* FACS */        {            if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_XFACS) &&                Gbl_Fadt->XFacs)            {                TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->XFacs;            }            else if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_FACS) &&                Gbl_Fadt->Facs)            {                TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->Facs;            }        }    }    else /* Case for a normal ACPI table */    {        if (Gbl_Revision)        {            NumberOfTables =                (Gbl_Xsdt->Header.Length - sizeof (Gbl_Xsdt->Header))                / sizeof (Gbl_Xsdt->TableOffsetEntry[0]);        }        else /* Use RSDT if XSDT is not available */        {            NumberOfTables =                (Gbl_Rsdt->Header.Length - sizeof (Gbl_Rsdt->Header))                / sizeof (Gbl_Rsdt->TableOffsetEntry[0]);        }        /* Search RSDT/XSDT for the requested table */        for (i = 0; i < NumberOfTables; i++)        {            if (Gbl_Revision)            {                TableAddress = Gbl_Xsdt->TableOffsetEntry[i];            }            else            {                TableAddress = Gbl_Rsdt->TableOffsetEntry[i];            }            MappedTable = AcpiOsMapMemory (TableAddress, sizeof (*MappedTable));            if (!MappedTable)            {                return (AE_BAD_ADDRESS);            }            /* Does this table match the requested signature? */            if (ACPI_COMPARE_NAME (MappedTable->Signature, Signature))            {                /* Match table instance (for SSDT/UEFI tables) */                if (CurrentInstance == Instance)                {                    AcpiOsUnmapMemory (MappedTable, sizeof (*MappedTable));                    break;                }//.........这里部分代码省略.........

static ACPI_STATUSOslTableInitialize (    void){    char                    Buffer[32];    ACPI_TABLE_HEADER       *MappedTable;    UINT8                   *TableAddress;    UINT8                   *RsdpAddress;    ACPI_PHYSICAL_ADDRESS   RsdpBase;    ACPI_SIZE               RsdpSize;    ACPI_STATUS             Status;    u_long                  Address = 0;    size_t                  Length = sizeof (Address);    /* Get main ACPI tables from memory on first invocation of this function */    if (Gbl_MainTableObtained)    {        return (AE_OK);    }    /* Attempt to use kenv or sysctl to find RSD PTR record. */    if (Gbl_RsdpBase)    {        Address = Gbl_RsdpBase;    }    else if (kenv (KENV_GET, SYSTEM_KENV, Buffer, sizeof (Buffer)) > 0)    {        Address = ACPI_STRTOUL (Buffer, NULL, 0);    }    if (!Address)    {        if (sysctlbyname (SYSTEM_SYSCTL, &Address, &Length, NULL, 0) != 0)        {            Address = 0;        }    }    if (Address)    {        RsdpBase = Address;        RsdpSize = sizeof (Gbl_Rsdp);    }    else    {        RsdpBase = ACPI_HI_RSDP_WINDOW_BASE;        RsdpSize = ACPI_HI_RSDP_WINDOW_SIZE;    }    /* Get RSDP from memory */    RsdpAddress = AcpiOsMapMemory (RsdpBase, RsdpSize);    if (!RsdpAddress)    {        return (AE_BAD_ADDRESS);    }    /* Search low memory for the RSDP */    TableAddress = AcpiTbScanMemoryForRsdp (RsdpAddress, RsdpSize);    if (!TableAddress)    {        AcpiOsUnmapMemory (RsdpAddress, RsdpSize);        return (AE_ERROR);    }    ACPI_MEMCPY (&Gbl_Rsdp, TableAddress, sizeof (Gbl_Rsdp));    AcpiOsUnmapMemory (RsdpAddress, RsdpSize);    /* Get XSDT from memory */    if (Gbl_Rsdp.Revision)    {        Status = OslMapTable (Gbl_Rsdp.XsdtPhysicalAddress,            ACPI_SIG_XSDT, &MappedTable);        if (ACPI_FAILURE (Status))        {            return (Status);        }        Gbl_Revision = 2;        Gbl_Xsdt = calloc (1, MappedTable->Length);        if (!Gbl_Xsdt)        {            fprintf (stderr,                "XSDT: Could not allocate buffer for table of length %X/n",                MappedTable->Length);            AcpiOsUnmapMemory (MappedTable, MappedTable->Length);            return (AE_NO_MEMORY);        }        ACPI_MEMCPY (Gbl_Xsdt, MappedTable, MappedTable->Length);        AcpiOsUnmapMemory (MappedTable, MappedTable->Length);    }    /* Get RSDT from memory */    if (Gbl_Rsdp.RsdtPhysicalAddress)    {//.........这里部分代码省略.........

/* * Find the BIOS date, and return TRUE if supplied * date is same or later than the BIOS date, or FALSE * if the BIOS date can't be fetched for any reason */static intacpica_check_bios_date(int yy, int mm, int dd){	char *datep;	int bios_year, bios_month, bios_day;	/* If firmware has no bios, skip the check */	if (ddi_prop_exists(DDI_DEV_T_ANY, ddi_root_node(), DDI_PROP_DONTPASS,	    "efi-systab"))		return (TRUE);	/*	 * PC BIOSes contain a string in the form of	 * "mm/dd/yy" at absolute address 0xffff5,	 * where mm, dd and yy are all ASCII digits.	 * We map the string, pluck out the values,	 * and accept all BIOSes from 1 Jan 1999 on	 * as valid.	 */	if ((datep = (char *)AcpiOsMapMemory(0xffff5, 8)) == NULL)		return (FALSE);	/* year */	bios_year = ((int)(*(datep + 6) - '0') * 10) + (*(datep + 7) - '0');	/* month */	bios_month = ((int)(*datep - '0') * 10) + (*(datep + 1) - '0');	/* day */	bios_day = ((int)(*(datep + 3) - '0') * 10) + (*(datep + 4) - '0');	AcpiOsUnmapMemory((void *) datep, 8);	if (bios_year < 0 || bios_year > 99 || bios_month < 0 ||	    bios_month > 99 || bios_day < 0 || bios_day > 99) {		/* non-digit chars in BIOS date */		return (FALSE);	}	/*	 * Adjust for 2-digit year; note to grand-children:	 * need a new scheme before 2080 rolls around	 */	bios_year += (bios_year >= 80 && bios_year <= 99) ?	    1900 : 2000;	if (bios_year < yy)		return (FALSE);	else if (bios_year > yy)		return (TRUE);	if (bios_month < mm)		return (FALSE);	else if (bios_month > mm)		return (TRUE);	if (bios_day < dd)		return (FALSE);	return (TRUE);}

ACPI_STATUSAcpiGetTableHeader (    char                    *Signature,    UINT32                  Instance,    ACPI_TABLE_HEADER       *OutTableHeader){    UINT32                  i;    UINT32                  j;    ACPI_TABLE_HEADER       *Header;    /* Parameter validation */    if (!Signature || !OutTableHeader)    {        return (AE_BAD_PARAMETER);    }    /* Walk the root table list */    for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)    {        if (!ACPI_COMPARE_NAME (                &(AcpiGbl_RootTableList.Tables[i].Signature), Signature))        {            continue;        }        if (++j < Instance)        {            continue;        }        if (!AcpiGbl_RootTableList.Tables[i].Pointer)        {            if ((AcpiGbl_RootTableList.Tables[i].Flags &                    ACPI_TABLE_ORIGIN_MASK) ==                ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL)            {                Header = AcpiOsMapMemory (                    AcpiGbl_RootTableList.Tables[i].Address,                    sizeof (ACPI_TABLE_HEADER));                if (!Header)                {                    return (AE_NO_MEMORY);                }                memcpy (OutTableHeader, Header, sizeof (ACPI_TABLE_HEADER));                AcpiOsUnmapMemory (Header, sizeof (ACPI_TABLE_HEADER));            }            else            {                return (AE_NOT_FOUND);            }        }        else        {            memcpy (OutTableHeader,                AcpiGbl_RootTableList.Tables[i].Pointer,                sizeof (ACPI_TABLE_HEADER));        }        return (AE_OK);    }    return (AE_NOT_FOUND);}