本文整理汇总了C++中AcpiOsUnmapMemory函数的典型用法代码示例。如果您正苦于以下问题:C++ AcpiOsUnmapMemory函数的具体用法?C++ AcpiOsUnmapMemory怎么用?C++ AcpiOsUnmapMemory使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了AcpiOsUnmapMemory函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: OslMapTable
static ACPI_STATUS
OslMapTable (
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);
}
示例2: AcpiOsReadMemory
ACPI_STATUS
AcpiOsReadMemory(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);
}
示例3: AcpiOsWriteMemory
ACPI_STATUS
AcpiOsWriteMemory(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);
}
示例4: AcpiOsWriteMemory
/*
* AcpiOsWriteMemory:
*
* Write a value to a memory location.
*/
ACPI_STATUS
AcpiOsWriteMemory(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;
}
示例5: AcpiTbDeleteSingleTable
void
AcpiTbDeleteSingleTable (
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;
}
}
示例6: AcpiTbParseFadt
void
AcpiTbParseFadt (
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);
}
}
}
示例7: AcpiOsGetTableByAddress
ACPI_STATUS
AcpiOsGetTableByAddress (
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);
}
示例8: AcpiEvSystemMemoryRegionSetup
ACPI_STATUS
AcpiEvSystemMemoryRegionSetup (
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);
}
示例9: AcpiTbAcquireTempTable
ACPI_STATUS
AcpiTbAcquireTempTable (
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);
}
示例10: AcpiTbParseFadt
void
AcpiTbParseFadt (
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);
}
示例11: AcpiTbReleaseTable
void
AcpiTbReleaseTable (
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;
}
}
示例12: AcpiTbFindRsdp
ACPI_STATUS
AcpiTbFindRsdp (
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);
//.........这里部分代码省略.........
示例13: AcpiTbParseRootTable
ACPI_STATUS
AcpiTbParseRootTable (
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)) /
//.........这里部分代码省略.........
示例14: AcpiExSystemMemorySpaceHandler
ACPI_STATUS
AcpiExSystemMemorySpaceHandler (
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
//.........这里部分代码省略.........
示例15: AcpiFindRootPointer
ACPI_STATUS
AcpiFindRootPointer (
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"));
//.........这里部分代码省略.........