tbxfroot.c File Reference

#include "acpi.h"
#include "accommon.h"
#include "actables.h"

Include dependency graph for tbxfroot.c:

Go to the source code of this file.

Macros
#define	_COMPONENT   ACPI_TABLES

Functions
UINT32	AcpiTbGetRsdpLength (ACPI_TABLE_RSDP *Rsdp)
ACPI_STATUS	AcpiTbValidateRsdp (ACPI_TABLE_RSDP *Rsdp)
ACPI_STATUS ACPI_INIT_FUNCTION	AcpiFindRootPointer (ACPI_PHYSICAL_ADDRESS *TableAddress)
UINT8 *	AcpiTbScanMemoryForRsdp (UINT8 *StartAddress, UINT32 Length)

Macro Definition Documentation

_COMPONENT

#define _COMPONENT   ACPI_TABLES

Definition at line 49 of file tbxfroot.c.

Function Documentation

AcpiFindRootPointer()

ACPI_STATUS ACPI_INIT_FUNCTION AcpiFindRootPointer

(

ACPI_PHYSICAL_ADDRESS *

TableAddress

)

Definition at line 160 of file tbxfroot.c.

{
    UINT8                   *TablePtr;
    UINT8                   *MemRover;
    UINT32                  PhysicalAddress;
    UINT32                  EbdaWindowSize;
 
 
    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? */
 
    /*
     * Check that the EBDA pointer from memory is sane and does not point
     * above valid low memory
     */
    if (PhysicalAddress > 0x400 &&
        PhysicalAddress < 0xA0000)
    {
        /*
         * Calculate the scan window size
         * The EBDA is not guaranteed to be larger than a KiB and in case
         * that it is smaller, the scanning function would leave the low
         * memory and continue to the VGA range.
         */
        EbdaWindowSize = ACPI_MIN(ACPI_EBDA_WINDOW_SIZE,
            0xA0000 - PhysicalAddress);
 
        /*
         * 1b) Search EBDA paragraphs
         */
        TablePtr = AcpiOsMapMemory (
            (ACPI_PHYSICAL_ADDRESS) PhysicalAddress,
            EbdaWindowSize);
        if (!TablePtr)
        {
            ACPI_ERROR ((AE_INFO,
                "Could not map memory at 0x%8.8X for length %u",
                PhysicalAddress, EbdaWindowSize));
 
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        MemRover = AcpiTbScanMemoryForRsdp (
            TablePtr, EbdaWindowSize);
        AcpiOsUnmapMemory (TablePtr, EbdaWindowSize);
 
        if (MemRover)
        {
            /* Return the physical address */
 
            PhysicalAddress +=
                (UINT32) ACPI_PTR_DIFF (MemRover, TablePtr);
 
            *TableAddress = (ACPI_PHYSICAL_ADDRESS) 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 = (ACPI_PHYSICAL_ADDRESS) PhysicalAddress;
        return_ACPI_STATUS (AE_OK);
    }
 
    /* A valid RSDP was not found */
 
    ACPI_BIOS_ERROR ((AE_INFO, "A valid RSDP was not found"));
    return_ACPI_STATUS (AE_NOT_FOUND);
}

Referenced by AcpiFindRootPointer(), and AcpiOsGetRootPointer().

AcpiTbGetRsdpLength()

UINT32 AcpiTbGetRsdpLength

(

ACPI_TABLE_RSDP *

Rsdp

)

Definition at line 66 of file tbxfroot.c.

{
 
    if (!ACPI_VALIDATE_RSDP_SIG (Rsdp->Signature))
    {
        /* BAD Signature */
 
        return (0);
    }
 
    /* "Length" field is available if table version >= 2 */
 
    if (Rsdp->Revision >= 2)
    {
        return (Rsdp->Length);
    }
    else
    {
        return (ACPI_RSDP_CHECKSUM_LENGTH);
    }
}

AcpiTbScanMemoryForRsdp()

UINT8 * AcpiTbScanMemoryForRsdp	(	UINT8 *	StartAddress,
		UINT32	Length
	)

Definition at line 296 of file tbxfroot.c.

{
    ACPI_STATUS             Status;
    UINT8                   *MemRover;
    UINT8                   *EndAddress;
 
 
    ACPI_FUNCTION_TRACE (TbScanMemoryForRsdp);
 
 
    EndAddress = StartAddress + Length;
 
    /* Search from given start address for the requested length */
 
    for (MemRover = StartAddress; MemRover < EndAddress;
         MemRover += ACPI_RSDP_SCAN_STEP)
    {
        /* The RSDP signature and checksum must both be correct */
 
        Status = AcpiTbValidateRsdp (
            ACPI_CAST_PTR (ACPI_TABLE_RSDP, MemRover));
        if (ACPI_SUCCESS (Status))
        {
            /* Sig and checksum valid, we have found a real RSDP */
 
            ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
                "RSDP located at physical address %p\n", MemRover));
            return_PTR (MemRover);
        }
 
        /* No sig match or bad checksum, keep searching */
    }
 
    /* Searched entire block, no RSDP was found */
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
        "Searched entire block from %p, valid RSDP was not found\n",
        StartAddress));
    return_PTR (NULL);
}

Referenced by AcpiFindRootPointer().

AcpiTbValidateRsdp()

ACPI_STATUS AcpiTbValidateRsdp

(

ACPI_TABLE_RSDP *

Rsdp

)

Definition at line 103 of file tbxfroot.c.

{
 
    /*
     * The signature and checksum must both be correct
     *
     * Note: Sometimes there exists more than one RSDP in memory; the valid
     * RSDP has a valid checksum, all others have an invalid checksum.
     */
    if (!ACPI_VALIDATE_RSDP_SIG (Rsdp->Signature))
    {
        /* Nope, BAD Signature */
 
        return (AE_BAD_SIGNATURE);
    }
 
    /* Check the standard checksum */
 
    if (AcpiUtChecksum ((UINT8 *) Rsdp, ACPI_RSDP_CHECKSUM_LENGTH) != 0)
    {
        return (AE_BAD_CHECKSUM);
    }
 
    /* Check extended checksum if table version >= 2 */
 
    if ((Rsdp->Revision >= 2) &&
        (AcpiUtChecksum ((UINT8 *) Rsdp, ACPI_RSDP_XCHECKSUM_LENGTH) != 0))
    {
        return (AE_BAD_CHECKSUM);
    }
 
    return (AE_OK);
}

Referenced by AcpiTbScanMemoryForRsdp().