init.c

Go to the documentation of this file.

/*
 * PROJECT:         ReactOS PCI Bus Driver
 * LICENSE:         BSD - See COPYING.ARM in the top level directory
 * FILE:            drivers/bus/pci/init.c
 * PURPOSE:         Driver Initialization
 * PROGRAMMERS:     ReactOS Portable Systems Group
 */
 
/* INCLUDES *******************************************************************/
 
#include <pci.h>
 
#define NDEBUG
#include <debug.h>
 
/* GLOBALS ********************************************************************/
 
BOOLEAN PciRunningDatacenter;
PDRIVER_OBJECT PciDriverObject;
KEVENT PciGlobalLock;
KEVENT PciBusLock;
KEVENT PciLegacyDescriptionLock;
BOOLEAN PciLockDeviceResources;
BOOLEAN PciEnableNativeModeATA;
ULONG PciSystemWideHackFlags;
PPCI_IRQ_ROUTING_TABLE PciIrqRoutingTable;
PWATCHDOG_TABLE WdTable;
PPCI_HACK_ENTRY PciHackTable;
 
/* FUNCTIONS ******************************************************************/
 
NTSTATUS
NTAPI
PciAcpiFindRsdt(OUT PACPI_BIOS_MULTI_NODE *AcpiMultiNode)
{
    BOOLEAN Result;
    NTSTATUS Status;
    HANDLE KeyHandle, SubKey;
    ULONG NumberOfBytes, i, Length;
    PKEY_FULL_INFORMATION FullInfo;
    PKEY_BASIC_INFORMATION KeyInfo;
    PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
    PACPI_BIOS_MULTI_NODE NodeData;
    UNICODE_STRING ValueName;
    struct
    {
        CM_FULL_RESOURCE_DESCRIPTOR Descriptor;
        ACPI_BIOS_MULTI_NODE Node;
    } *Package;
 
    /* So we know what to free at the end of the body */
    ValueInfo = NULL;
    KeyInfo = NULL;
    KeyHandle = NULL;
    FullInfo = NULL;
    Package = NULL;
    do
    {
        /* Open the ACPI BIOS key */
        Result = PciOpenKey(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\"
                            L"System\\MultiFunctionAdapter",
                            NULL,
                            KEY_QUERY_VALUE,
                            &KeyHandle,
                            &Status);
        if (!Result) break;
 
        /* Query how much space should be allocated for the key information */
        Status = ZwQueryKey(KeyHandle,
                            KeyFullInformation,
                            NULL,
                            sizeof(ULONG),
                            &NumberOfBytes);
        if (Status != STATUS_BUFFER_TOO_SMALL) break;
 
        /* Allocate the space required */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        FullInfo = ExAllocatePoolWithTag(PagedPool, NumberOfBytes, PCI_POOL_TAG);
        if ( !FullInfo ) break;
 
        /* Now query the key information that's needed */
        Status = ZwQueryKey(KeyHandle,
                            KeyFullInformation,
                            FullInfo,
                            NumberOfBytes,
                            &NumberOfBytes);
        if (!NT_SUCCESS(Status)) break;
 
        /* Allocate enough space to hold the value information plus the name */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        Length = FullInfo->MaxNameLen + 26;
        KeyInfo = ExAllocatePoolWithTag(PagedPool, Length, PCI_POOL_TAG);
        if ( !KeyInfo ) break;
 
        /* Allocate the value information and name we expect to find */
        ValueInfo = ExAllocatePoolWithTag(PagedPool,
                                          sizeof(KEY_VALUE_PARTIAL_INFORMATION) +
                                          sizeof(L"ACPI BIOS"),
                                          PCI_POOL_TAG);
        if (!ValueInfo) break;
 
        /* Loop each sub-key */
        i = 0;
        while (TRUE)
        {
            /* Query each sub-key */
            Status = ZwEnumerateKey(KeyHandle,
                                    i++,
                                    KeyBasicInformation,
                                    KeyInfo,
                                    Length,
                                    &NumberOfBytes);
            if (Status == STATUS_NO_MORE_ENTRIES) break;
 
            /* Null-terminate the keyname, because the kernel does not */
            KeyInfo->Name[KeyInfo->NameLength / sizeof(WCHAR)] = UNICODE_NULL;
 
            /* Open this subkey */
            Result = PciOpenKey(KeyInfo->Name,
                                KeyHandle,
                                KEY_QUERY_VALUE,
                                &SubKey,
                                &Status);
            if (Result)
            {
                /* Query the identifier value for this subkey */
                RtlInitUnicodeString(&ValueName, L"Identifier");
                Status = ZwQueryValueKey(SubKey,
                                         &ValueName,
                                         KeyValuePartialInformation,
                                         ValueInfo,
                                         sizeof(KEY_VALUE_PARTIAL_INFORMATION) +
                                         sizeof(L"ACPI BIOS"),
                                         &NumberOfBytes);
                if (NT_SUCCESS(Status))
                {
                    /* Check if this is the ACPI BIOS subkey */
                    if (!wcsncmp((PWCHAR)ValueInfo->Data,
                                 L"ACPI BIOS",
                                 ValueInfo->DataLength))
                    {
                        /* It is, proceed to query the PCI IRQ routing table */
                        Status = PciGetRegistryValue(L"Configuration Data",
                                                     KeyInfo->Name,
                                                     KeyHandle,
                                                     REG_FULL_RESOURCE_DESCRIPTOR,
                                                     (PVOID*)&Package,
                                                     &NumberOfBytes);
                        ZwClose(SubKey);
                        break;
                    }
                }
 
                /* Close the subkey and try the next one */
                ZwClose(SubKey);
            }
        }
 
        /* Check if we got here because the routing table was found */
        if (!NT_SUCCESS(Status))
        {
            /* This should only fail if we're out of entries */
            ASSERT(Status == STATUS_NO_MORE_ENTRIES);
            break;
        }
 
        /* Check if a descriptor was found */
        if (!Package) break;
 
        /* The configuration data is a resource list, and the BIOS node follows */
        NodeData = &Package->Node;
 
        /* How many E820 memory entries are there? */
        Length = sizeof(ACPI_BIOS_MULTI_NODE) +
                 (NodeData->Count - 1) * sizeof(ACPI_E820_ENTRY);
 
        /* Allocate the buffer needed to copy the information */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        *AcpiMultiNode = ExAllocatePoolWithTag(NonPagedPool, Length, PCI_POOL_TAG);
        if (!*AcpiMultiNode) break;
 
        /* Copy the data */
        RtlCopyMemory(*AcpiMultiNode, NodeData, Length);
        Status = STATUS_SUCCESS;
    } while (FALSE);
 
    /* Close any opened keys, free temporary allocations, and return status */
    if (Package) ExFreePoolWithTag(Package, 0);
    if (ValueInfo) ExFreePoolWithTag(ValueInfo, 0);
    if (KeyInfo) ExFreePoolWithTag(KeyInfo, 0);
    if (FullInfo) ExFreePoolWithTag(FullInfo, 0);
    if (KeyHandle) ZwClose(KeyHandle);
    return Status;
}
 
PVOID
NTAPI
PciGetAcpiTable(IN ULONG TableCode)
{
    PDESCRIPTION_HEADER Header;
    PACPI_BIOS_MULTI_NODE AcpiMultiNode;
    PRSDT Rsdt;
    PXSDT Xsdt;
    ULONG EntryCount, TableLength, Offset, CurrentEntry;
    PVOID TableBuffer, MappedAddress;
    PHYSICAL_ADDRESS PhysicalAddress;
    NTSTATUS Status;
 
    /* Try to find the RSDT or XSDT */
    Status = PciAcpiFindRsdt(&AcpiMultiNode);
    if (!NT_SUCCESS(Status))
    {
        /* No ACPI on the machine */
        DPRINT1("PCIX - AcpiFindRsdt() Failed!\n");
        return NULL;
    }
 
    /* Map the RSDT with the minimum size allowed */
    MappedAddress = MmMapIoSpace(AcpiMultiNode->RsdtAddress,
                                 sizeof(DESCRIPTION_HEADER),
                                 MmNonCached);
    Header = MappedAddress;
    if (!Header) return NULL;
 
    /* Check how big the table really is and get rid of the temporary header */
    TableLength = Header->Length;
    MmUnmapIoSpace(Header, sizeof(DESCRIPTION_HEADER));
    Header = NULL;
 
    /* Map its true size */
    MappedAddress = MmMapIoSpace(AcpiMultiNode->RsdtAddress,
                                 TableLength,
                                 MmNonCached);
    Rsdt = MappedAddress;
    Xsdt = MappedAddress;
    ExFreePoolWithTag(AcpiMultiNode, 0);
    if (!Rsdt) return NULL;
 
    /* Validate the table's signature */
    if ((Rsdt->Header.Signature != RSDT_SIGNATURE) &&
        (Rsdt->Header.Signature != XSDT_SIGNATURE))
    {
        /* Very bad: crash */
        HalDisplayString("RSDT table contains invalid signature\r\n");
        MmUnmapIoSpace(Rsdt, TableLength);
        return NULL;
    }
 
    /* Smallest RSDT/XSDT is one without table entries */
    Offset = FIELD_OFFSET(RSDT, Tables);
    if (Rsdt->Header.Signature == XSDT_SIGNATURE)
    {
        /* Figure out total size of table and the offset */
        TableLength = Xsdt->Header.Length;
        if (TableLength < Offset) Offset = Xsdt->Header.Length;
 
        /* The entries are each 64-bits, so count them */
        EntryCount = (TableLength - Offset) / sizeof(PHYSICAL_ADDRESS);
    }
    else
    {
        /* Figure out total size of table and the offset */
        TableLength = Rsdt->Header.Length;
        if (TableLength < Offset) Offset = Rsdt->Header.Length;
 
        /* The entries are each 32-bits, so count them */
        EntryCount = (TableLength - Offset) / sizeof(ULONG);
    }
 
    /* Start at the beginning of the array and loop it */
    for (CurrentEntry = 0; CurrentEntry < EntryCount; CurrentEntry++)
    {
        /* Are we using the XSDT? */
        if (Rsdt->Header.Signature != XSDT_SIGNATURE)
        {
            /* Read the 32-bit physical address */
            PhysicalAddress.QuadPart = Rsdt->Tables[CurrentEntry];
        }
        else
        {
            /* Read the 64-bit physical address */
            PhysicalAddress = Xsdt->Tables[CurrentEntry];
        }
 
        /* Map this table */
        Header = MmMapIoSpace(PhysicalAddress,
                              sizeof(DESCRIPTION_HEADER),
                              MmNonCached);
        if (!Header) break;
 
        /* Check if this is the table that's being asked for */
        if (Header->Signature == TableCode)
        {
            /* Allocate a buffer for it */
            TableBuffer = ExAllocatePoolWithTag(PagedPool,
                                                Header->Length,
                                                PCI_POOL_TAG);
            if (!TableBuffer) break;
 
            /* Copy the table into the buffer */
            RtlCopyMemory(TableBuffer, Header, Header->Length);
        }
 
        /* Done with this table, keep going */
        MmUnmapIoSpace(Header, sizeof(DESCRIPTION_HEADER));
    }
 
    if (Header) MmUnmapIoSpace(Header, sizeof(DESCRIPTION_HEADER));
    return NULL;
}
 
NTSTATUS
NTAPI
PciGetIrqRoutingTableFromRegistry(OUT PPCI_IRQ_ROUTING_TABLE *PciRoutingTable)
{
    BOOLEAN Result;
    NTSTATUS Status;
    HANDLE KeyHandle, SubKey;
    ULONG NumberOfBytes, i, Length;
    PKEY_FULL_INFORMATION FullInfo;
    PKEY_BASIC_INFORMATION KeyInfo;
    PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
    UNICODE_STRING ValueName;
    PCM_FULL_RESOURCE_DESCRIPTOR Package;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR Partial;
    PPCI_IRQ_ROUTING_TABLE Table;
    ULONG Offset, DataLength, HeaderLength;
    UCHAR Checksum;
 
    /* So we know what to free at the end of the body */
    Package = NULL;
    ValueInfo = NULL;
    KeyInfo = NULL;
    KeyHandle = NULL;
    FullInfo = NULL;
    do
    {
        /* Open the BIOS key */
        Result = PciOpenKey(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\"
                            L"System\\MultiFunctionAdapter",
                            NULL,
                            KEY_QUERY_VALUE,
                            &KeyHandle,
                            &Status);
        if (!Result) break;
 
        /* Query how much space should be allocated for the key information */
        Status = ZwQueryKey(KeyHandle,
                            KeyFullInformation,
                            NULL,
                            sizeof(ULONG),
                            &NumberOfBytes);
        if (Status != STATUS_BUFFER_TOO_SMALL) break;
 
        /* Allocate the space required */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        FullInfo = ExAllocatePoolWithTag(PagedPool, NumberOfBytes, PCI_POOL_TAG);
        if ( !FullInfo ) break;
 
        /* Now query the key information that's needed */
        Status = ZwQueryKey(KeyHandle,
                            KeyFullInformation,
                            FullInfo,
                            NumberOfBytes,
                            &NumberOfBytes);
        if (!NT_SUCCESS(Status)) break;
 
        /* Allocate enough space to hold the value information plus the name */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        Length = FullInfo->MaxNameLen + 26;
        KeyInfo = ExAllocatePoolWithTag(PagedPool, Length, PCI_POOL_TAG);
        if (!KeyInfo) break;
 
        /* Allocate the value information and name we expect to find */
        ValueInfo = ExAllocatePoolWithTag(PagedPool,
                                          sizeof(KEY_VALUE_PARTIAL_INFORMATION) +
                                          sizeof(L"PCI BIOS"),
                                          PCI_POOL_TAG);
        if (!ValueInfo) break;
 
        /* Loop each sub-key */
        i = 0;
        while (TRUE)
        {
            /* Query each sub-key */
            Status = ZwEnumerateKey(KeyHandle,
                                    i++,
                                    KeyBasicInformation,
                                    KeyInfo,
                                    Length,
                                    &NumberOfBytes);
            if (Status == STATUS_NO_MORE_ENTRIES) break;
 
            /* Null-terminate the keyname, because the kernel does not */
            KeyInfo->Name[KeyInfo->NameLength / sizeof(WCHAR)] = UNICODE_NULL;
 
            /* Open this subkey */
            Result = PciOpenKey(KeyInfo->Name,
                                KeyHandle,
                                KEY_QUERY_VALUE,
                                &SubKey,
                                &Status);
            if (Result)
            {
                /* Query the identifier value for this subkey */
                RtlInitUnicodeString(&ValueName, L"Identifier");
                Status = ZwQueryValueKey(SubKey,
                                         &ValueName,
                                         KeyValuePartialInformation,
                                         ValueInfo,
                                         sizeof(KEY_VALUE_PARTIAL_INFORMATION) +
                                         sizeof(L"PCI BIOS"),
                                         &NumberOfBytes);
                if (NT_SUCCESS(Status))
                {
                    /* Check if this is the PCI BIOS subkey */
                    if (!wcsncmp((PWCHAR)ValueInfo->Data,
                                 L"PCI BIOS",
                                 ValueInfo->DataLength))
                    {
                        /* It is, proceed to query the PCI IRQ routing table */
                        Status = PciGetRegistryValue(L"Configuration Data",
                                                     L"RealModeIrqRoutingTable"
                                                     L"\\0",
                                                     SubKey,
                                                     REG_FULL_RESOURCE_DESCRIPTOR,
                                                     (PVOID*)&Package,
                                                     &NumberOfBytes);
                        ZwClose(SubKey);
                        break;
                    }
                }
 
                /* Close the subkey and try the next one */
                ZwClose(SubKey);
            }
        }
 
        /* Check if we got here because the routing table was found */
        if (!NT_SUCCESS(Status)) break;
 
        /* Check if a descriptor was found */
        if (!Package) break;
 
        /* The loader lists the bus ahead of the table, so find the data descriptor */
        Status = STATUS_UNSUCCESSFUL;
        Table = NULL;
        DataLength = 0;
        Offset = FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR,
                              PartialResourceList.PartialDescriptors);
        if (NumberOfBytes < Offset)
            break;
 
        Partial = Package->PartialResourceList.PartialDescriptors;
        for (i = 0; i < Package->PartialResourceList.Count; i++)
        {
            Offset += sizeof(*Partial);
            if (Offset > NumberOfBytes)
                break;
 
            if (Partial->Type == CmResourceTypeDeviceSpecific)
            {
                DataLength = Partial->u.DeviceSpecificData.DataSize;
                Table = (PPCI_IRQ_ROUTING_TABLE)(Partial + 1);
                break;
            }
 
            Partial++;
        }
 
        /* The data must hold at least a $PIR header */
        HeaderLength = FIELD_OFFSET(PCI_IRQ_ROUTING_TABLE, Slot);
        if (!Table ||
            (DataLength > NumberOfBytes - Offset) ||
            (DataLength < HeaderLength))
        {
            break;
        }
 
        /* Accept only a version 1.0 table that fits in the data and ends on a slot entry */
        if ((Table->Signature != PCI_IRQ_ROUTING_TABLE_SIGNATURE) ||
            (Table->Version != PCI_IRQ_ROUTING_TABLE_VERSION) ||
            (Table->TableSize < HeaderLength) ||
            (Table->TableSize > DataLength) ||
            (((Table->TableSize - HeaderLength) % sizeof(Table->Slot[0])) != 0))
        {
            break;
        }
 
        /* All bytes of the table must add up to zero */
        Checksum = 0;
        for (i = 0; i < Table->TableSize; i++)
        {
            Checksum += ((PUCHAR)Table)[i];
        }
        if (Checksum != 0)
            break;
 
        /* Allocate space for the table */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        *PciRoutingTable = ExAllocatePoolWithTag(PagedPool,
                                                 Table->TableSize,
                                                 PCI_POOL_TAG);
        if (!*PciRoutingTable) break;
 
        /* Copy the table out of the registry data */
        RtlCopyMemory(*PciRoutingTable, Table, Table->TableSize);
        Status = STATUS_SUCCESS;
    } while (FALSE);
 
    /* Close any opened keys, free temporary allocations, and return status */
    if (Package) ExFreePoolWithTag(Package, 0);
    if (ValueInfo) ExFreePoolWithTag(ValueInfo, 0);
    if (KeyInfo) ExFreePoolWithTag(KeyInfo, 0);
    if (FullInfo) ExFreePoolWithTag(FullInfo, 0);
    if (KeyHandle) ZwClose(KeyHandle);
    return Status;
}
 
NTSTATUS
NTAPI
PciBuildHackTable(IN HANDLE KeyHandle)
{
    PKEY_FULL_INFORMATION FullInfo;
    ULONG i, HackCount;
    PKEY_VALUE_FULL_INFORMATION ValueInfo;
    PPCI_HACK_ENTRY Entry;
    NTSTATUS Status;
    ULONG NameLength, ResultLength;
    ULONGLONG HackFlags;
 
    /* So we know what to free at the end of the body */
    FullInfo = NULL;
    ValueInfo = NULL;
    do
    {
        /* Query the size required for full key information */
        Status = ZwQueryKey(KeyHandle,
                            KeyFullInformation,
                            NULL,
                            0,
                            &ResultLength);
        if (Status != STATUS_BUFFER_TOO_SMALL) break;
 
        /* Allocate the space required to hold the full key information */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        ASSERT(ResultLength > 0);
        FullInfo = ExAllocatePoolWithTag(PagedPool, ResultLength, PCI_POOL_TAG);
        if (!FullInfo) break;
 
        /* Go ahead and query the key information */
        Status = ZwQueryKey(KeyHandle,
                            KeyFullInformation,
                            FullInfo,
                            ResultLength,
                            &ResultLength);
        if (!NT_SUCCESS(Status)) break;
 
        /* The only piece of information that's needed is the count of values */
        HackCount = FullInfo->Values;
 
        /* Free the structure now */
        ExFreePoolWithTag(FullInfo, 0);
        FullInfo = NULL;
 
        /* Allocate the hack table, now that the number of entries is known */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        ResultLength = sizeof(PCI_HACK_ENTRY) * HackCount;
        PciHackTable = ExAllocatePoolWithTag(NonPagedPool,
                                             ResultLength +
                                             sizeof(PCI_HACK_ENTRY),
                                             PCI_POOL_TAG);
        if (!PciHackTable) break;
 
        /* Allocate room for the longest valid name plus the 8 bytes of flags */
        ValueInfo = ExAllocatePoolWithTag(NonPagedPool,
                                          sizeof(*ValueInfo) +
                                          PCI_HACK_ENTRY_FULL_SIZE +
                                          sizeof(Entry->HackFlags),
                                          PCI_POOL_TAG);
        if (!ValueInfo)
            break;
 
        /* Entry only advances once filled */
        Entry = &PciHackTable[0];
        for (i = 0; i < HackCount; i++)
        {
            /* Query the value in the key */
            Status = ZwEnumerateValueKey(KeyHandle,
                                         i,
                                         KeyValueFullInformation,
                                         ValueInfo,
                                         sizeof(*ValueInfo) +
                                         PCI_HACK_ENTRY_FULL_SIZE +
                                         sizeof(Entry->HackFlags),
                                         &ResultLength);
            if (!NT_SUCCESS(Status))
            {
                /* Check why the call failed */
                if ((Status != STATUS_BUFFER_OVERFLOW) &&
                    (Status != STATUS_BUFFER_TOO_SMALL))
                {
                    /* The call failed due to an unknown error, bail out */
                    break;
                }
 
                /* The data seems to mismatch, try the next key in the list */
                continue;
            }
 
            /* Check if the value data matches what's expected */
            if ((ValueInfo->Type != REG_BINARY) ||
                (ValueInfo->DataLength != sizeof(ULONGLONG)))
            {
                /* It doesn't, try the next key in the list */
                continue;
            }
 
            /* Read the actual hack flags */
            HackFlags = *(PULONGLONG)((ULONG_PTR)ValueInfo +
                                      ValueInfo->DataOffset);
 
            /* Check what kind of errata entry this is, based on the name */
            NameLength = ValueInfo->NameLength;
            if ((NameLength != PCI_HACK_ENTRY_SIZE) &&
                (NameLength != PCI_HACK_ENTRY_REV_SIZE) &&
                (NameLength != PCI_HACK_ENTRY_SUBSYS_SIZE) &&
                (NameLength != PCI_HACK_ENTRY_FULL_SIZE))
            {
                /* It's an invalid entry, skip it */
                DPRINT1("PCIX - Skipping hack entry with invalid length name\n");
                continue;
            }
 
            /* Initialize the entry */
            RtlZeroMemory(Entry, sizeof(PCI_HACK_ENTRY));
 
            /* Get the vendor and device data */
            if (!(PciStringToUSHORT(ValueInfo->Name, &Entry->VendorID)) ||
                !(PciStringToUSHORT(&ValueInfo->Name[4], &Entry->DeviceID)))
            {
                /* This failed, try the next entry */
                continue;
            }
 
            /* Check if the entry contains subsystem information */
            if ((NameLength == PCI_HACK_ENTRY_SUBSYS_SIZE) ||
                (NameLength == PCI_HACK_ENTRY_FULL_SIZE))
            {
                /* Get the data */
                if (!(PciStringToUSHORT(&ValueInfo->Name[8],
                                        &Entry->SubVendorID)) ||
                    !(PciStringToUSHORT(&ValueInfo->Name[12],
                                        &Entry->SubSystemID)))
                  {
                      /* This failed, try the next entry */
                      continue;
                  }
 
                  /* Save the fact this entry has finer controls */
                  Entry->Flags |= PCI_HACK_HAS_SUBSYSTEM_INFO;
             }
 
             /* Check if the entry contains revision information */
             if ((NameLength == PCI_HACK_ENTRY_REV_SIZE) ||
                 (NameLength == PCI_HACK_ENTRY_FULL_SIZE))
             {
                 /* The revision ends the name, so parse the last four digits and keep the low byte */
                 if (!PciStringToUSHORT(&ValueInfo->Name[(NameLength / sizeof(WCHAR)) - 4],
                                        &Entry->RevisionID))
                 {
                     /* This failed, try the next entry */
                     continue;
                 }
                 Entry->RevisionID &= 0xFF;
 
                 /* Save the fact this entry has finer controls */
                 Entry->Flags |= PCI_HACK_HAS_REVISION_INFO;
             }
 
            /* Only the last entry should have this set */
            ASSERT(Entry->VendorID != PCI_INVALID_VENDORID);
 
            /* Save the actual hack flags */
            Entry->HackFlags = HackFlags;
 
            /* Print out for the debugger's sake */
#ifdef HACK_DEBUG
            DPRINT1("PCIX - Adding Hack entry for Vendor:0x%04x Device:0x%04x ",
                    Entry->VendorID, Entry->DeviceID);
            if (Entry->Flags & PCI_HACK_HAS_SUBSYSTEM_INFO)
                DbgPrint("SybSys:0x%04x SubVendor:0x%04x ",
                         Entry->SubSystemID, Entry->SubVendorID);
            if (Entry->Flags & PCI_HACK_HAS_REVISION_INFO)
                DbgPrint("Revision:0x%02x", Entry->RevisionID);
            DbgPrint(" = 0x%I64x\n", Entry->HackFlags);
#endif
 
            /* This one is filled in, so the next value gets the next entry */
            Entry++;
        }
 
        /* Leaving the loop early means enumeration hit a real error */
        if (i < HackCount) break;
 
        /* Terminate the table with an invalid entry */
        ASSERT(Entry < (PciHackTable + HackCount + 1));
        Entry->VendorID = PCI_INVALID_VENDORID;
 
        /* Success path, free the temporary registry data */
        ExFreePoolWithTag(ValueInfo, 0);
        return STATUS_SUCCESS;
    } while (TRUE);
 
    /* Failure path, free temporary allocations and return failure code */
    ASSERT(!NT_SUCCESS(Status));
    if (FullInfo) ExFreePool(FullInfo);
    if (ValueInfo) ExFreePool(ValueInfo);
 
    /* DriverEntry continues without a table, and PciGetHackFlags checks for NULL */
    if (PciHackTable)
    {
        ExFreePool(PciHackTable);
        PciHackTable = NULL;
    }
 
    return Status;
}
 
NTSTATUS
NTAPI
PciGetDebugPorts(
    _In_ HANDLE DebugKey)
{
    WCHAR SubKeyName[2];
    PULONG Bus, Slot;
    ULONG Index, BusLength, SlotLength;
    PAGED_CODE();
 
    C_ASSERT(MAX_DEBUGGING_DEVICES_SUPPORTED <= 10);
 
    PciDebugPortsCount = 0;
    SubKeyName[1] = UNICODE_NULL;
    for (Index = 0; Index < MAX_DEBUGGING_DEVICES_SUPPORTED; Index++)
    {
        SubKeyName[0] = (WCHAR)(L'0' + Index);
 
        if (!NT_SUCCESS(PciGetRegistryValue(L"Bus",
                                            SubKeyName,
                                            DebugKey,
                                            REG_DWORD,
                                            (PVOID*)&Bus,
                                            &BusLength)))
        {
            continue;
        }
 
        if (!NT_SUCCESS(PciGetRegistryValue(L"Slot",
                                            SubKeyName,
                                            DebugKey,
                                            REG_DWORD,
                                            (PVOID*)&Slot,
                                            &SlotLength)))
        {
            ExFreePoolWithTag(Bus, 0);
            continue;
        }
 
        if ((BusLength == sizeof(*Bus)) && (SlotLength == sizeof(*Slot)))
        {
            PciDebuggingDevices[PciDebugPortsCount].Bus = *Bus;
            PciDebuggingDevices[PciDebugPortsCount].Slot.u.AsULONG = *Slot;
            PciDebugPortsCount++;
        }
 
        ExFreePoolWithTag(Slot, 0);
        ExFreePoolWithTag(Bus, 0);
    }
 
    return STATUS_SUCCESS;
}
 
DRIVER_UNLOAD PciDriverUnload;
 
VOID
NTAPI
PciDriverUnload(
    _In_ PDRIVER_OBJECT DriverObject)
{
    PAGED_CODE();
    UNREFERENCED_PARAMETER(DriverObject);
 
    /* PnP only unloads the driver once every bus FDO has been removed */
    ASSERT(PciFdoExtensionListHead.Next == NULL);
 
    PciVerifierRelease();
    PciReleaseEcam();
 
    RtlFreeRangeList(&PciIsaBitExclusionList);
    RtlFreeRangeList(&PciVgaAndIsaBitExclusionList);
 
    if (PciIrqRoutingTable)
    {
        ExFreePoolWithTag(PciIrqRoutingTable, PCI_POOL_TAG);
        PciIrqRoutingTable = NULL;
    }
 
    if (WdTable)
    {
        ExFreePoolWithTag(WdTable, PCI_POOL_TAG);
        WdTable = NULL;
    }
 
    if (PciHackTable)
    {
        ExFreePoolWithTag(PciHackTable, PCI_POOL_TAG);
        PciHackTable = NULL;
    }
 
    PciFreeLegacyDeviceCache();
 
    if (PciZeroIoResourceRequirements)
    {
        ExFreePoolWithTag(PciZeroIoResourceRequirements, PCI_POOL_TAG);
        PciZeroIoResourceRequirements = NULL;
    }
 
    PciRestoreHalHooks();
}
 
NTSTATUS
NTAPI
DriverEntry(IN PDRIVER_OBJECT DriverObject,
            IN PUNICODE_STRING RegistryPath)
{
    HANDLE KeyHandle, ParametersKey, DebugKey, ControlSetKey;
    BOOLEAN Result;
    OBJECT_ATTRIBUTES ObjectAttributes;
    ULONG ResultLength;
    PULONG Value;
    PWCHAR StartOptions;
    UNICODE_STRING OptionString, PciLockString;
    NTSTATUS Status;
    DPRINT1("PCIX - DriverEntry!\n");
 
    /* Setup initial loop variables */
    KeyHandle = NULL;
    ParametersKey = NULL;
    DebugKey = NULL;
    ControlSetKey = NULL;
    do
    {
        /* Remember our object so we can get it to it later */
        PciDriverObject = DriverObject;
 
        /* Setup the IRP dispatcher */
        DriverObject->MajorFunction[IRP_MJ_POWER] = PciDispatchIrp;
        DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PciDispatchIrp;
        DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = PciDispatchIrp;
        DriverObject->MajorFunction[IRP_MJ_PNP] = PciDispatchIrp;
        DriverObject->DriverUnload = PciDriverUnload;
 
        /* This is how we'll detect a new PCI bus */
        DriverObject->DriverExtension->AddDevice = PciAddDevice;
 
        /* Open the PCI key */
        InitializeObjectAttributes(&ObjectAttributes,
                                   RegistryPath,
                                   OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                   NULL,
                                   NULL);
        Status = ZwOpenKey(&KeyHandle, KEY_QUERY_VALUE, &ObjectAttributes);
        if (!NT_SUCCESS(Status)) break;
 
        /* Open the Parameters subkey */
        Result = PciOpenKey(L"Parameters",
                            KeyHandle,
                            KEY_QUERY_VALUE,
                            &ParametersKey,
                            &Status);
        //if (!Result) break;
 
        /* Build the list of all known PCI erratas */
        Status = PciBuildHackTable(ParametersKey);
        //if (!NT_SUCCESS(Status)) break;
 
        /* Open the debug key, if it exists */
        Result = PciOpenKey(L"Debug",
                            KeyHandle,
                            KEY_QUERY_VALUE,
                            &DebugKey,
                            &Status);
        if (Result)
        {
            /* There are PCI debug devices, go discover them */
            Status = PciGetDebugPorts(DebugKey);
            if (!NT_SUCCESS(Status)) break;
        }
 
        /* Initialize the synchronization locks */
        KeInitializeEvent(&PciGlobalLock, SynchronizationEvent, TRUE);
        KeInitializeEvent(&PciBusLock, SynchronizationEvent, TRUE);
        KeInitializeEvent(&PciLegacyDescriptionLock, SynchronizationEvent, TRUE);
 
        /* Open the control set key */
        Result = PciOpenKey(L"\\Registry\\Machine\\System\\CurrentControlSet",
                            NULL,
                            KEY_QUERY_VALUE,
                            &ControlSetKey,
                            &Status);
        if (!Result) break;
 
        /* Read the command line */
        Status = PciGetRegistryValue(L"SystemStartOptions",
                                     L"Control",
                                     ControlSetKey,
                                     REG_SZ,
                                     (PVOID*)&StartOptions,
                                     &ResultLength);
        if (NT_SUCCESS(Status))
        {
            /* Initialize the command-line as a string */
            OptionString.Buffer = StartOptions;
            OptionString.MaximumLength = OptionString.Length = ResultLength;
 
            /* Check if the command-line has the PCILOCK argument */
            RtlInitUnicodeString(&PciLockString, L"PCILOCK");
            if (PciUnicodeStringStrStr(&OptionString, &PciLockString, TRUE))
            {
                /* The PCI Bus driver will keep the BIOS-assigned resources */
                PciLockDeviceResources = TRUE;
            }
 
            /* This data isn't needed anymore */
            ExFreePoolWithTag(StartOptions, 0);
        }
 
        /* The PCILOCK feature can also be enabled per-system in the registry */
        Status = PciGetRegistryValue(L"PCILock",
                                     L"Control\\BiosInfo\\PCI",
                                     ControlSetKey,
                                     REG_DWORD,
                                     (PVOID*)&Value,
                                     &ResultLength);
        if (NT_SUCCESS(Status))
        {
            /* Read the value it's been set to. This overrides /PCILOCK */
            if (ResultLength == sizeof(ULONG)) PciLockDeviceResources = *Value;
            ExFreePoolWithTag(Value, 0);
        }
 
        /* The system can have global PCI erratas in the registry */
        Status = PciGetRegistryValue(L"HackFlags",
                                     L"Control\\PnP\\PCI",
                                     ControlSetKey,
                                     REG_DWORD,
                                     (PVOID*)&Value,
                                     &ResultLength);
        if (NT_SUCCESS(Status))
        {
            /* Read them in */
            if (ResultLength == sizeof(ULONG)) PciSystemWideHackFlags = *Value;
            ExFreePoolWithTag(Value, 0);
        }
 
        /* Check if the system should allow native ATA support */
        Status = PciGetRegistryValue(L"EnableNativeModeATA",
                                     L"Control\\PnP\\PCI",
                                     ControlSetKey,
                                     REG_DWORD,
                                     (PVOID*)&Value,
                                     &ResultLength);
        if (NT_SUCCESS(Status))
        {
            /* This key is typically set by drivers, but users can force it */
            if (ResultLength == sizeof(ULONG)) PciEnableNativeModeATA = *Value;
            ExFreePoolWithTag(Value, 0);
        }
 
        /* Build the range lists for all the excluded resource areas */
        Status = PciBuildDefaultExclusionLists();
        if (!NT_SUCCESS(Status)) break;
 
        /* Read the PCI IRQ Routing Table that the loader put in the registry */
        PciGetIrqRoutingTableFromRegistry(&PciIrqRoutingTable);
 
        /* Take over the HAL's default PCI Bus Handler routines */
        PciHookHal();
 
        /* Initialize verification of PCI BIOS and devices, if requested */
        PciVerifierInit(DriverObject);
 
        /* Check if this is a Datacenter SKU, which impacts IRQ alignment */
        PciRunningDatacenter = PciIsDatacenter();
        if (PciRunningDatacenter) DPRINT1("PCIX - Running on datacenter build\n");
 
        /* Check if the system has an ACPI Hardware Watchdog Timer */
        //WdTable = PciGetAcpiTable(WDRT_SIGNATURE);
        Status = STATUS_SUCCESS;
    } while (FALSE);
 
    /* Close all opened keys, return driver status to PnP Manager */
    if (KeyHandle) ZwClose(KeyHandle);
    if (ControlSetKey) ZwClose(ControlSetKey);
    if (ParametersKey) ZwClose(ParametersKey);
    if (DebugKey) ZwClose(DebugKey);
    return Status;
}
 
/* EOF */