halacpi.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_ACPI_CACHED_TABLE

Typedefs
typedef struct _ACPI_CACHED_TABLE	ACPI_CACHED_TABLE
typedef struct _ACPI_CACHED_TABLE *	PACPI_CACHED_TABLE

Functions
NTSTATUS NTAPI	HalpAcpiTableCacheInit (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
PVOID NTAPI	HalpAcpiGetTable (IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN ULONG Signature)
NTSTATUS NTAPI	HalpSetupAcpiPhase0 (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
PVOID NTAPI	HalAcpiGetTable (IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN ULONG Signature)

Typedef Documentation

ACPI_CACHED_TABLE

typedef struct _ACPI_CACHED_TABLE ACPI_CACHED_TABLE

PACPI_CACHED_TABLE

typedef struct _ACPI_CACHED_TABLE * PACPI_CACHED_TABLE

Function Documentation

HalAcpiGetTable()

PVOID NTAPI HalAcpiGetTable	(	IN PLOADER_PARAMETER_BLOCK	LoaderBlock,
		IN ULONG	Signature
	)

Definition at line 446 of file halacpi.c.

{
    PDESCRIPTION_HEADER TableHeader;
 
    /* Is this phase0 */
    if (LoaderBlock)
    {
        /* Initialize the cache first */
        if (!NT_SUCCESS(HalpAcpiTableCacheInit(LoaderBlock))) return NULL;
    }
    else
    {
        /* Lock the cache */
        ExAcquireFastMutex(&HalpAcpiTableCacheLock);
    }
 
    /* Get the table */
    TableHeader = HalpAcpiGetTable(LoaderBlock, Signature);
 
    /* Release the lock in phase 1 */
    if (!LoaderBlock) ExReleaseFastMutex(&HalpAcpiTableCacheLock);
 
    /* Return the table */
    return TableHeader;
}

Referenced by HalpAddDevice(), HalpGetHotPlugMemoryInfo(), HalpInitBootTable(), HalpNumaInitializeStaticConfiguration(), HalpParseApicTables(), and HalpSetupAcpiPhase0().

HalpAcpiGetTable()

PVOID NTAPI HalpAcpiGetTable	(	IN PLOADER_PARAMETER_BLOCK	LoaderBlock,
		IN ULONG	Signature
	)

Definition at line 404 of file halacpi.c.

{
    PFN_COUNT PageCount;
    PDESCRIPTION_HEADER TableAddress, BiosCopy;
 
    /* See if we have a cached table? */
    TableAddress = HalpAcpiGetCachedTable(Signature);
    if (!TableAddress)
    {
        /* No cache, search the BIOS */
        TableAddress = HalpAcpiGetTableFromBios(LoaderBlock, Signature);
        if (TableAddress)
        {
            /* Found it, copy it into our own memory */
            BiosCopy = HalpAcpiCopyBiosTable(LoaderBlock, TableAddress);
 
            /* Get the pages, and unmap the BIOS copy */
            PageCount = BYTES_TO_PAGES(TableAddress->Length);
            if (LoaderBlock)
            {
                /* Phase 0, use the HAL heap */
                HalpUnmapVirtualAddress(TableAddress, PageCount);
            }
            else
            {
                /* Phase 1, use Mm */
                MmUnmapIoSpace(TableAddress, PageCount << PAGE_SHIFT);
            }
 
            /* Cache the bios copy */
            TableAddress = BiosCopy;
            if (BiosCopy) HalpAcpiCacheTable(BiosCopy);
        }
    }
 
    /* Return the table */
    return TableAddress;
}

Referenced by HalAcpiGetTable(), and HalpAcpiGetTableFromBios().

HalpAcpiTableCacheInit()

NTSTATUS NTAPI HalpAcpiTableCacheInit

(

IN PLOADER_PARAMETER_BLOCK

LoaderBlock

)

Definition at line 642 of file halacpi.c.

{
    PACPI_BIOS_MULTI_NODE AcpiMultiNode;
    NTSTATUS Status = STATUS_SUCCESS;
    PHYSICAL_ADDRESS PhysicalAddress;
    PVOID MappedAddress;
    ULONG TableLength;
    PRSDT Rsdt;
    PLOADER_PARAMETER_EXTENSION LoaderExtension;
 
    /* Only initialize once */
    if (HalpAcpiTableCacheList.Flink) return Status;
 
    /* Setup the lock and table */
    ExInitializeFastMutex(&HalpAcpiTableCacheLock);
    InitializeListHead(&HalpAcpiTableCacheList);
 
    /* Find the RSDT */
    Status = HalpAcpiFindRsdtPhase0(LoaderBlock, &AcpiMultiNode);
    if (!NT_SUCCESS(Status)) return Status;
 
    PhysicalAddress.QuadPart = AcpiMultiNode->RsdtAddress.QuadPart;
 
    /* Map the RSDT */
    if (LoaderBlock)
    {
        /* Phase0: Use HAL Heap to map the RSDT, we assume it's about 2 pages */
        MappedAddress = HalpMapPhysicalMemory64(PhysicalAddress, 2);
    }
    else
    {
        /* Use an I/O map */
        MappedAddress = MmMapIoSpace(PhysicalAddress, PAGE_SIZE * 2, MmNonCached);
    }
 
    /* Get the RSDT */
    Rsdt = MappedAddress;
    if (!MappedAddress)
    {
        /* Fail, no memory */
        DPRINT1("HAL: Failed to map RSDT\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Validate it */
    if ((Rsdt->Header.Signature != RSDT_SIGNATURE) &&
        (Rsdt->Header.Signature != XSDT_SIGNATURE))
    {
        /* Very bad: crash */
        HalDisplayString("Bad RSDT pointer\r\n");
        KeBugCheckEx(MISMATCHED_HAL, 4, __LINE__, 0, 0);
    }
 
    /* We assumed two pages -- do we need less or more? */
    TableLength = ADDRESS_AND_SIZE_TO_SPAN_PAGES(PhysicalAddress.LowPart,
                                                 Rsdt->Header.Length);
    if (TableLength != 2)
    {
        /* Are we in phase 0 or 1? */
        if (!LoaderBlock)
        {
            /* Unmap the old table, remap the new one, using Mm I/O space */
            MmUnmapIoSpace(MappedAddress, 2 * PAGE_SIZE);
            MappedAddress = MmMapIoSpace(PhysicalAddress,
                                         TableLength << PAGE_SHIFT,
                                         MmNonCached);
        }
        else
        {
            /* Unmap the old table, remap the new one, using HAL heap */
            HalpUnmapVirtualAddress(MappedAddress, 2);
            MappedAddress = HalpMapPhysicalMemory64(PhysicalAddress, TableLength);
        }
 
        /* Get the remapped table */
        Rsdt = MappedAddress;
        if (!MappedAddress)
        {
            /* Fail, no memory */
            DPRINT1("HAL: Couldn't remap RSDT\n");
            return STATUS_INSUFFICIENT_RESOURCES;
        }
    }
 
    /* Now take the BIOS copy and make our own local copy */
    Rsdt = HalpAcpiCopyBiosTable(LoaderBlock, &Rsdt->Header);
    if (!Rsdt)
    {
        /* Fail, no memory */
        DPRINT1("HAL: Couldn't remap RSDT\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Get rid of the BIOS mapping */
    if (LoaderBlock)
    {
        /* Use HAL heap */
        HalpUnmapVirtualAddress(MappedAddress, TableLength);
 
        LoaderExtension = LoaderBlock->Extension;
    }
    else
    {
        /* Use Mm */
        MmUnmapIoSpace(MappedAddress, TableLength << PAGE_SHIFT);
 
        LoaderExtension = NULL;
    }
 
    /* Cache the RSDT */
    HalpAcpiCacheTable(&Rsdt->Header);
 
    /* Check for compatible loader block extension */
    if (LoaderExtension && (LoaderExtension->Size >= 0x58))
    {
        /* Compatible loader: did it provide an ACPI table override? */
        if ((LoaderExtension->AcpiTable) && (LoaderExtension->AcpiTableSize))
        {
            /* Great, because we don't support it! */
            DPRINT1("ACPI Table Overrides Not Supported!\n");
        }
    }
 
    /* Done */
    return Status;
}

Referenced by HalAcpiGetTable(), and HalpSetupAcpiPhase0().

HalpSetupAcpiPhase0()

NTSTATUS NTAPI HalpSetupAcpiPhase0

(

IN PLOADER_PARAMETER_BLOCK

LoaderBlock

)

Definition at line 792 of file halacpi.c.

{
    NTSTATUS Status;
    PFADT Fadt;
    ULONG TableLength;
    PHYSICAL_ADDRESS PhysicalAddress;
 
    /* Only do this once */
    if (HalpProcessedACPIPhase0) return STATUS_SUCCESS;
 
    /* Setup the ACPI table cache */
    Status = HalpAcpiTableCacheInit(LoaderBlock);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Grab the FADT */
    Fadt = HalAcpiGetTable(LoaderBlock, FADT_SIGNATURE);
    if (!Fadt)
    {
        /* Fail */
        DPRINT1("HAL: Didn't find the FACP\n");
        return STATUS_NOT_FOUND;
    }
 
    /* Assume typical size, otherwise whatever the descriptor table says */
    TableLength = sizeof(FADT);
    if (Fadt->Header.Length < sizeof(FADT)) TableLength = Fadt->Header.Length;
 
    /* Copy it in the HAL static buffer */
    RtlCopyMemory(&HalpFixedAcpiDescTable, Fadt, TableLength);
 
    /* Anything special this HAL needs to do? */
    HalpAcpiDetectMachineSpecificActions(LoaderBlock, &HalpFixedAcpiDescTable);
 
    /* Get the debug table for KD */
    HalpDebugPortTable = HalAcpiGetTable(LoaderBlock, DBGP_SIGNATURE);
 
    /* Initialize NUMA through the SRAT */
    HalpNumaInitializeStaticConfiguration(LoaderBlock);
 
    /* Initialize hotplug through the SRAT */
    HalpDynamicSystemResourceConfiguration(LoaderBlock);
    if (HalpAcpiSrat)
    {
        DPRINT1("Your machine has a SRAT, but NUMA/HotPlug are not supported!\n");
    }
 
    /* Can there be memory higher than 4GB? */
    if (HalpMaxHotPlugMemoryAddress.HighPart >= 1)
    {
        /* We'll need this for DMA later */
        HalpPhysicalMemoryMayAppearAbove4GB = TRUE;
    }
 
    /* Setup the ACPI timer */
    HaliAcpiTimerInit(0, 0);
 
    /* Do we have a low stub address yet? */
    if (!HalpLowStubPhysicalAddress.QuadPart)
    {
        /* Allocate it */
        HalpLowStubPhysicalAddress.QuadPart = HalpAllocPhysicalMemory(LoaderBlock,
                                                                      0x100000,
                                                                      HALP_LOW_STUB_SIZE_IN_PAGES,
                                                                      FALSE);
        if (HalpLowStubPhysicalAddress.QuadPart)
        {
            /* Map it */
            HalpLowStub = HalpMapPhysicalMemory64(HalpLowStubPhysicalAddress, HALP_LOW_STUB_SIZE_IN_PAGES);
        }
    }
 
    /* Grab a page for flushes */
    PhysicalAddress.QuadPart = 0x100000;
    HalpVirtAddrForFlush = HalpMapPhysicalMemory64(PhysicalAddress, 1);
    HalpPteForFlush = HalAddressToPte(HalpVirtAddrForFlush);
 
    /* Don't do this again */
    HalpProcessedACPIPhase0 = TRUE;
 
    /* Setup the boot table */
    HalpInitBootTable(LoaderBlock);
 
    /* Log some ACPI data */
    {
        PLIST_ENTRY NextEntry;
        PCSTR AcpiVersion = NULL;
 
        /* Find the ACPI version (range) out */
        // v1.0+: Revision is major version.
        // v5.1+: minor_revision is minor version.
        // v6.4+: errata bits are errata version.
        switch (Fadt->Header.Revision)
        {
            case 0: // Should not happen.
                AcpiVersion = "Unknown_0";
                break;
            case 1:
                AcpiVersion = "1.0-1.0b";
                break;
            case 2: // Should not happen.
                AcpiVersion = "Unknown_2";
                break;
            case 3:
                AcpiVersion = "1.5-2.0_C";
                break;
            case 4:
                AcpiVersion = "3.0-4.0_A";
                break;
            case 5:
                if (Fadt->minor_revision == 0)
                    AcpiVersion = "5.0-5.0_B";
                else if (Fadt->minor_revision == 1)
                    AcpiVersion = "5.1-5.1_B";
                break;
            case 6:
                if (Fadt->minor_revision == 0)
                    AcpiVersion = "6.0-6.0_A";
                else if (Fadt->minor_revision == 1)
                    AcpiVersion = "6.1-6.1_A";
                else if (Fadt->minor_revision == 2)
                    AcpiVersion = "6.2-6.2_B";
                else if (Fadt->minor_revision == 3)
                    AcpiVersion = "6.3-6.3_A";
                else if ((Fadt->minor_revision & 0x0F) == 0x04)
                {
                    if ((Fadt->minor_revision & 0xF0) == 0x00)
                        AcpiVersion = "6.4";
                    else if ((Fadt->minor_revision & 0xF0) == 0x10)
                        AcpiVersion = "6.4_A";
                }
                else if (Fadt->minor_revision == 5) // v6.5_A too is documented as errata=0.
                    AcpiVersion = "6.5-6.6";
                break;
        }
 
        /* Print the ACPI version */
        DPRINT1("ACPI v");
        if (AcpiVersion == NULL)
        {
            // Unknown past values, or newer than v6.6 (documented as 6.5).
            DbgPrint("Unknown_%u_%u", Fadt->Header.Revision, Fadt->minor_revision);
        }
        else
        {
            DbgPrint("%s", AcpiVersion);
        }
        DbgPrint(" detected. Tables:");
 
        /* List cached tables */
        for (NextEntry = HalpAcpiTableCacheList.Flink;
             NextEntry != &HalpAcpiTableCacheList;
             NextEntry = NextEntry->Flink)
        {
            PACPI_CACHED_TABLE CachedTable = CONTAINING_RECORD(NextEntry, ACPI_CACHED_TABLE, Links);
 
            /* Print the table signature */
            DbgPrint(" [%c%c%c%c]",
                      CachedTable->Header.Signature & 0x000000FF,
                     (CachedTable->Header.Signature & 0x0000FF00) >>  8,
                     (CachedTable->Header.Signature & 0x00FF0000) >> 16,
                     (CachedTable->Header.Signature & 0xFF000000) >> 24);
        }
        DbgPrint("\n");
    }
 
    /* Return success */
    return STATUS_SUCCESS;
}

Referenced by HalInitSystem().