hookhal.c File Reference

#include <pci.h>
#include <debug.h>

Include dependency graph for hookhal.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
BOOLEAN NTAPI	PciTranslateBusAddress (IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN PHYSICAL_ADDRESS BusAddress, OUT PULONG AddressSpace, OUT PPHYSICAL_ADDRESS TranslatedAddress)
	_Requires_lock_held_ (PciGlobalLock)
	Finds the PDO of the function in a slot.
static VOID NTAPI	PciStripPrivateDescriptors (_Inout_ PCM_RESOURCE_LIST ResourceList)
	Removes the device private descriptors from an assigned resource list.
static NTSTATUS NTAPI	PciAssignAndProgramLegacy (_In_ PPCI_PDO_EXTENSION PdoExtension, _In_ PPCI_COMMON_HEADER PciData, _In_ PUNICODE_STRING RegistryPath, _In_opt_ PUNICODE_STRING DriverClassName, _In_ PDRIVER_OBJECT DriverObject, _In_opt_ PDEVICE_OBJECT DeviceObject, _Out_ PCM_RESOURCE_LIST *Resources)
	Asks the PnP manager for the ranges of a legacy claimed function and programs them. On success Resources receives the assignment, stripped of private descriptors.
NTSTATUS NTAPI	PciAssignSlotResources (_In_ PUNICODE_STRING RegistryPath, _In_opt_ PUNICODE_STRING DriverClassName, _In_ PDRIVER_OBJECT DriverObject, _In_opt_ PDEVICE_OBJECT DeviceObject, _In_ INTERFACE_TYPE BusType, _In_ ULONG BusNumber, _In_ ULONG SlotNumber, _Inout_ PCM_RESOURCE_LIST *AllocatedResources)
	Assigns resources to a function claimed by a driver outside of PnP.
VOID NTAPI	PciHookHal (VOID)
VOID NTAPI	PciRestoreHalHooks (VOID)
	Gives the HAL back the routines PciHookHal replaced.

Variables
pHalTranslateBusAddress	PcipSavedTranslateBusAddress
pHalAssignSlotResources	PcipSavedAssignSlotResources

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file hookhal.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

PciGlobalLock

)

Finds the PDO of the function in a slot.

Definition at line 52 of file hookhal.c.

{
    PPCI_FDO_EXTENSION DeviceExtension;
    PPCI_PDO_EXTENSION PdoExtension;
    PCI_SLOT_NUMBER PciSlot;
    PciSlot.u.AsULONG = SlotNumber;
 
    /* Now search for the extension */
    DeviceExtension = (PPCI_FDO_EXTENSION)PciFdoExtensionListHead.Next;
    while (DeviceExtension)
    {
        /* If we found it, break out */
        if (DeviceExtension->BaseBus == BusNumber) break;
 
        /* Move to the next device */
        DeviceExtension = (PPCI_FDO_EXTENSION)DeviceExtension->List.Next;
    }
 
    /* Check if the device extension for the bus was found */
    if (!DeviceExtension)
    {
        /* It wasn't, bail out */
        DPRINT1("PCIX - Could not find PCI bus FDO. Bus Number = 0x%x\n", BusNumber);
        return NULL;
    }
 
    /* Acquire this device's lock */
    KeEnterCriticalRegion();
    KeWaitForSingleObject(&DeviceExtension->ChildListLock,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);
 
    /* Loop every child PDO */
    for (PdoExtension = DeviceExtension->ChildPdoList;
         PdoExtension;
         PdoExtension = PdoExtension->Next)
    {
        /* A function that left the slot keeps its PDO until PnP removes it */
        if (PdoExtension->NotPresent || PdoExtension->ReportedMissing)
            continue;
 
        /* Check if the function number and header data matches */
        if ((PdoExtension->Slot.u.bits.FunctionNumber == PciSlot.u.bits.FunctionNumber) &&
            (PdoExtension->Slot.u.bits.DeviceNumber == PciSlot.u.bits.DeviceNumber))
        {
            /* This is considered to be the same PDO */
            ASSERT(PdoExtension->Slot.u.AsULONG == PciSlot.u.AsULONG);
            break;
        }
    }
 
    /* Release this device's lock */
    KeSetEvent(&DeviceExtension->ChildListLock, IO_NO_INCREMENT, FALSE);
    KeLeaveCriticalRegion();
 
    /* Check if we found something */
    if (!PdoExtension)
    {
        /* Let the debugger know */
        DPRINT1("PCIX - Could not find PDO for device @ %x.%x.%x\n",
                BusNumber,
                PciSlot.u.bits.DeviceNumber,
                PciSlot.u.bits.FunctionNumber);
    }
 
    /* If the search found something, this is non-NULL, otherwise it's NULL */
    return PdoExtension;
}

PciAssignAndProgramLegacy()

static NTSTATUS NTAPI PciAssignAndProgramLegacy ( _In_ PPCI_PDO_EXTENSION  PdoExtension, _In_ PPCI_COMMON_HEADER  PciData, _In_ PUNICODE_STRING  RegistryPath, _In_opt_ PUNICODE_STRING  DriverClassName, _In_ PDRIVER_OBJECT  DriverObject, _In_opt_ PDEVICE_OBJECT  DeviceObject, _Out_ PCM_RESOURCE_LIST *  Resources  )

static

Asks the PnP manager for the ranges of a legacy claimed function and programs them. On success Resources receives the assignment, stripped of private descriptors.

Definition at line 166 of file hookhal.c.

{
    PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList = NULL;
    PCM_RESOURCE_LIST Assigned = NULL;
    NTSTATUS Status;
 
    *Resources = NULL;
 
    Status = PciBuildRequirementsList(PdoExtension, PciData, &RequirementsList);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* The shared empty list asks for nothing and must not be freed */
    if (RequirementsList == PciZeroIoResourceRequirements)
        RequirementsList = NULL;
 
    PdoExtension->LegacyDriver = TRUE;
    Status = IoAssignResources(RegistryPath,
                               DriverClassName,
                               DriverObject,
                               DeviceObject,
                               RequirementsList,
                               &Assigned);
    if (RequirementsList)
        ExFreePoolWithTag(RequirementsList, 0);
 
    if (!NT_SUCCESS(Status))
    {
        ASSERT(Assigned == NULL);
        return Status;
    }
 
    /* Program the assignment the way a PnP start does */
    PdoExtension->CommandEnables |= (PCI_ENABLE_IO_SPACE |
                                     PCI_ENABLE_MEMORY_SPACE |
                                     PCI_ENABLE_BUS_MASTER);
    PciComputeNewCurrentSettings(PdoExtension, Assigned);
 
    Status = PciSetResources(PdoExtension, TRUE, TRUE);
    if (!NT_SUCCESS(Status))
    {
        if (Assigned)
            ExFreePoolWithTag(Assigned, 0);
        return Status;
    }
 
    /* The caller only gets the ranges and the interrupt */
    if (Assigned)
        PciStripPrivateDescriptors(Assigned);
 
    *Resources = Assigned;
    return STATUS_SUCCESS;
}

Referenced by PciAssignSlotResources().

PciAssignSlotResources()

NTSTATUS NTAPI PciAssignSlotResources	(	_In_ PUNICODE_STRING	RegistryPath,
		_In_opt_ PUNICODE_STRING	DriverClassName,
		_In_ PDRIVER_OBJECT	DriverObject,
		_In_opt_ PDEVICE_OBJECT	DeviceObject,
		_In_ INTERFACE_TYPE	BusType,
		_In_ ULONG	BusNumber,
		_In_ ULONG	SlotNumber,
		_Inout_ PCM_RESOURCE_LIST *	AllocatedResources
	)

Assigns resources to a function claimed by a driver outside of PnP.

Definition at line 232 of file hookhal.c.

{
    PCI_COMMON_HEADER PciData;
    PPCI_PDO_EXTENSION PdoExtension;
    PDEVICE_OBJECT ExistingDeviceObject;
    NTSTATUS Status;
    PAGED_CODE();
    ASSERT(PcipSavedAssignSlotResources);
 
    *AllocatedResources = NULL;
 
    if (BusType != PCIBus)
        return STATUS_INVALID_PARAMETER;
 
    /* A removed bus is unlinked under this lock before its PDOs are deleted */
    KeEnterCriticalRegion();
    KeWaitForSingleObject(&PciGlobalLock, Executive, KernelMode, FALSE, NULL);
 
    PdoExtension = PciFindPdoByLocation(BusNumber, SlotNumber);
    if (!PdoExtension)
        Status = STATUS_DEVICE_DOES_NOT_EXIST;
    else if (PdoExtension->DeviceState != PciNotStarted)
        Status = STATUS_INVALID_OWNER;
    else
        Status = STATUS_SUCCESS;
 
    if (NT_SUCCESS(Status))
    {
        ASSERT(DeviceObject != PdoExtension->PhysicalDeviceObject);
 
        /* The routing goes to the cache first so interrupt arbitration can find it */
        PciReadDeviceConfig(PdoExtension, &PciData, 0, PCI_COMMON_HDR_LENGTH);
        Status = PciCacheLegacyDeviceRouting(DeviceObject,
                                             BusNumber,
                                             SlotNumber,
                                             PciData.u.type0.InterruptLine,
                                             PciData.u.type0.InterruptPin,
                                             PciData.BaseClass,
                                             PciData.SubClass,
                                             PdoExtension->ParentFdoExtension->
                                             PhysicalDeviceObject,
                                             PdoExtension,
                                             &ExistingDeviceObject);
    }
 
    if (NT_SUCCESS(Status))
    {
        Status = PciAssignAndProgramLegacy(PdoExtension,
                                           &PciData,
                                           RegistryPath,
                                           DriverClassName,
                                           DriverObject,
                                           DeviceObject,
                                           AllocatedResources);
 
        /* Give the slot back to the device object cached for it before */
        if (!NT_SUCCESS(Status))
        {
            PciCacheLegacyDeviceRouting(ExistingDeviceObject,
                                        BusNumber,
                                        SlotNumber,
                                        PciData.u.type0.InterruptLine,
                                        PciData.u.type0.InterruptPin,
                                        PciData.BaseClass,
                                        PciData.SubClass,
                                        PdoExtension->ParentFdoExtension->
                                        PhysicalDeviceObject,
                                        PdoExtension,
                                        NULL);
        }
    }
 
    KeSetEvent(&PciGlobalLock, IO_NO_INCREMENT, FALSE);
    KeLeaveCriticalRegion();
    return Status;
}

Referenced by PciHookHal().

PciHookHal()

VOID NTAPI PciHookHal

(

VOID

)

Definition at line 319 of file hookhal.c.

{
    /* Save the old HAL routines */
    ASSERT(PcipSavedAssignSlotResources == NULL);
    ASSERT(PcipSavedTranslateBusAddress == NULL);
    PcipSavedAssignSlotResources = HalPciAssignSlotResources;
    PcipSavedTranslateBusAddress = HalPciTranslateBusAddress;
 
    /* Take over the HAL's Bus Handler functions */
    HalPciAssignSlotResources = PciAssignSlotResources;
    HalPciTranslateBusAddress = PciTranslateBusAddress;
}

Referenced by DriverEntry().

PciRestoreHalHooks()

VOID NTAPI PciRestoreHalHooks

(

VOID

)

Gives the HAL back the routines PciHookHal replaced.

Definition at line 337 of file hookhal.c.

{
    PAGED_CODE();
    ASSERT(PcipSavedTranslateBusAddress != NULL);
    ASSERT(PcipSavedAssignSlotResources != NULL);
 
    /* Restore the HAL table before dropping the only copies of its routines */
    HalPciTranslateBusAddress = PcipSavedTranslateBusAddress;
    HalPciAssignSlotResources = PcipSavedAssignSlotResources;
 
    PcipSavedTranslateBusAddress = NULL;
    PcipSavedAssignSlotResources = NULL;
}

Referenced by PciDriverUnload().

PciStripPrivateDescriptors()

static VOID NTAPI PciStripPrivateDescriptors ( _Inout_ PCM_RESOURCE_LIST  ResourceList )

static

Removes the device private descriptors from an assigned resource list.

Definition at line 135 of file hookhal.c.

{
    PCM_PARTIAL_RESOURCE_LIST PartialList;
    ULONG Source, Target;
 
    ASSERT(ResourceList->Count == 1);
    PartialList = &ResourceList->List[0].PartialResourceList;
 
    Target = 0;
    for (Source = 0; Source < PartialList->Count; Source++)
    {
        if (PartialList->PartialDescriptors[Source].Type == CmResourceTypeDevicePrivate)
            continue;
 
        if (Target != Source)
            PartialList->PartialDescriptors[Target] = PartialList->PartialDescriptors[Source];
 
        Target++;
    }
 
    PartialList->Count = Target;
}

Referenced by PciAssignAndProgramLegacy().

PciTranslateBusAddress()

BOOLEAN NTAPI PciTranslateBusAddress	(	IN INTERFACE_TYPE	InterfaceType,
		IN ULONG	BusNumber,
		IN PHYSICAL_ADDRESS	BusAddress,
		OUT PULONG	AddressSpace,
		OUT PPHYSICAL_ADDRESS	TranslatedAddress
	)

Definition at line 25 of file hookhal.c.

{
    /* The HAL has the final say on any bus it registered */
    if (PcipSavedTranslateBusAddress(InterfaceType,
                                     BusNumber,
                                     BusAddress,
                                     AddressSpace,
                                     TranslatedAddress))
    {
        return TRUE;
    }
 
    /* Buses the HAL never saw still map PCI addresses 1:1 to processor addresses */
    if (InterfaceType != PCIBus)
        return FALSE;
 
    *TranslatedAddress = BusAddress;
    return TRUE;
}

Referenced by PciHookHal().

Variable Documentation

PcipSavedAssignSlotResources

pHalAssignSlotResources PcipSavedAssignSlotResources

Definition at line 19 of file hookhal.c.

Referenced by PciAssignSlotResources(), PciHookHal(), and PciRestoreHalHooks().

PcipSavedTranslateBusAddress

pHalTranslateBusAddress PcipSavedTranslateBusAddress

Definition at line 18 of file hookhal.c.

Referenced by PciHookHal(), PciRestoreHalHooks(), and PciTranslateBusAddress().