arb_comn.c File Reference

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

Include dependency graph for arb_comn.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	PCI_RANGE_FIXED_PLACEMENT   0x04

Functions
NTSTATUS NTAPI	PciArbiter_PreprocessEntry (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE State)
	Sets the range attributes of one arbitration entry before the engine looks for a placement for it.
BOOLEAN NTAPI	PciArbiter_FindSuitableRange (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE State)
	Searches for a placement, remembering on the range whether it came from a fixed alternative.
BOOLEAN NTAPI	PciArbiter_OverrideConflict (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE State)
	Lets a fixed requirement overlap ranges its own device was given by other fixed requirements.
VOID NTAPI	PciArbiter_Reference (_In_ PVOID Context)
VOID NTAPI	PciArbiter_Dereference (_In_ PVOID Context)
NTSTATUS NTAPI	PciArbiterConstructor (_In_ PPCI_FDO_EXTENSION FdoExtension, _In_ PCI_SIGNATURE ArbiterType, _Out_ PARBITER_INTERFACE Interface)
VOID NTAPI	PciArbiterDestructor (IN PPCI_ARBITER_INSTANCE Arbiter)
NTSTATUS NTAPI	PciInitializeArbiters (IN PPCI_FDO_EXTENSION FdoExtension)
static PCM_RESOURCE_LIST NTAPI	PciCollectForwardedRanges (_In_ PPCI_PDO_EXTENSION BridgeExtension)
	Builds a resource list of the ranges a PCI-to-PCI bridge forwards to its secondary bus.
static BOOLEAN NTAPI	PciHasRangeOfType (_In_ PCM_RESOURCE_LIST RangeList, _In_ UCHAR Type)
	Tells whether a resource list holds any range of one resource type.
NTSTATUS NTAPI	PciInitializeArbiterRanges (IN PPCI_FDO_EXTENSION DeviceExtension, IN PCM_RESOURCE_LIST Resources)

Variables
PCHAR	PciArbiterNames []

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file arb_comn.c.

PCI_RANGE_FIXED_PLACEMENT

#define PCI_RANGE_FIXED_PLACEMENT   0x04

Definition at line 19 of file arb_comn.c.

Function Documentation

PciArbiter_Dereference()

VOID NTAPI PciArbiter_Dereference

(

_In_ PVOID

Context

)

Definition at line 191 of file arb_comn.c.

{
    PARBITER_INSTANCE Arbiter = (PARBITER_INSTANCE)Context;
 
    InterlockedDecrement((PLONG)&Arbiter->ReferenceCount);
}

Referenced by PciArbiterConstructor().

PciArbiter_FindSuitableRange()

BOOLEAN NTAPI PciArbiter_FindSuitableRange	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_ALLOCATION_STATE	State
	)

Searches for a placement, remembering on the range whether it came from a fixed alternative.

Parameters

[in]	Arbiter	The arbiter instance placing the entry.
[in,out]	State	The allocation state of the entry.

Returns

TRUE if a placement was found, FALSE otherwise.

Definition at line 97 of file arb_comn.c.

{
    PAGED_CODE();
 
    State->RangeAttributes &= (UCHAR)~PCI_RANGE_FIXED_PLACEMENT;
    if (State->CurrentAlternative &&
        (State->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_FIXED))
    {
        State->RangeAttributes |= PCI_RANGE_FIXED_PLACEMENT;
    }
 
    return ArbiterLibFindSuitableRange(Arbiter, State);
}

Referenced by ario_Initializer(), and armem_Initializer().

PciArbiter_OverrideConflict()

BOOLEAN NTAPI PciArbiter_OverrideConflict	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_ALLOCATION_STATE	State
	)

Lets a fixed requirement overlap ranges its own device was given by other fixed requirements.

Parameters

[in]	Arbiter	The arbiter instance placing the entry.
[in,out]	State	The allocation state of the entry. On success Start and End receive the requested window.

Returns

TRUE if every conflicting range is a fixed placement of the same device, FALSE otherwise.

Remarks

A resized BAR that landed on top of another BAR's firmware address is a movable placement, so the fixed BAR fails and the resized one has to back off to another alternative.

Definition at line 136 of file arb_comn.c.

{
    RTL_RANGE_LIST_ITERATOR Iterator;
    PRTL_RANGE Range;
    BOOLEAN Overridden = FALSE;
 
    PAGED_CODE();
 
    if (!State->Entry ||
        !State->CurrentAlternative ||
        !(State->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_FIXED))
    {
        return FALSE;
    }
 
    if (!NT_SUCCESS(RtlGetFirstRange(Arbiter->PossibleAllocation, &Iterator, &Range)))
        return FALSE;
 
    while (Range)
    {
        if ((Range->Start <= State->CurrentMaximum) &&
            (Range->End >= State->CurrentMinimum) &&
            !(Range->Attributes & State->RangeAvailableAttributes))
        {
            if ((Range->Owner != State->Entry->PhysicalDeviceObject) ||
                !(Range->Attributes & PCI_RANGE_FIXED_PLACEMENT))
            {
                return FALSE;
            }
 
            Overridden = TRUE;
            State->Start = State->CurrentMinimum;
            State->End = State->CurrentMaximum;
        }
 
        if (!NT_SUCCESS(RtlGetNextRange(&Iterator, &Range, TRUE)))
            break;
    }
 
    return Overridden;
}

Referenced by ario_Initializer(), and armem_Initializer().

PciArbiter_PreprocessEntry()

NTSTATUS NTAPI PciArbiter_PreprocessEntry	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_ALLOCATION_STATE	State
	)

Sets the range attributes of one arbitration entry before the engine looks for a placement for it.

Parameters

[in]	Arbiter	The arbiter instance placing the entry.
[in,out]	State	The allocation state of the entry.

Returns

STATUS_SUCCESS.

Remarks

Boot configs and legacy claims treat boot reservations as free. Positive decode ports ignore ISA alias ranges.

Definition at line 51 of file arb_comn.c.

{
    PIO_RESOURCE_DESCRIPTOR Descriptor;
 
    UNREFERENCED_PARAMETER(Arbiter);
 
    PAGED_CODE();
 
    if (!State->Entry)
        return STATUS_SUCCESS;
 
    if ((State->Entry->Flags & ARBITER_FLAG_BOOT_CONFIG) ||
        (State->Entry->RequestSource == ArbiterRequestLegacyReported) ||
        (State->Entry->RequestSource == ArbiterRequestLegacyAssigned))
    {
        State->RangeAvailableAttributes |= ARBITER_RANGE_BOOT_ALLOCATED;
    }
 
    /* CurrentAlternative is not set yet, use the first alternative */
    Descriptor = State->Alternatives ? State->Alternatives->Descriptor : NULL;
    if (Descriptor &&
        (Descriptor->Type == CmResourceTypePort) &&
        (Descriptor->Flags & CM_RESOURCE_PORT_POSITIVE_DECODE))
        State->RangeAvailableAttributes |= ARBITER_RANGE_PORT_ALIAS;
 
    return STATUS_SUCCESS;
}

Referenced by arbusno_Initializer(), ario_Initializer(), and armem_Initializer().

PciArbiter_Reference()

VOID NTAPI PciArbiter_Reference

(

_In_ PVOID

Context

)

Definition at line 182 of file arb_comn.c.

{
    PARBITER_INSTANCE Arbiter = (PARBITER_INSTANCE)Context;
 
    InterlockedIncrement((PLONG)&Arbiter->ReferenceCount);
}

Referenced by PciArbiterConstructor().

PciArbiterConstructor()

NTSTATUS NTAPI PciArbiterConstructor	(	_In_ PPCI_FDO_EXTENSION	FdoExtension,
		_In_ PCI_SIGNATURE	ArbiterType,
		_Out_ PARBITER_INTERFACE	Interface
	)

Definition at line 200 of file arb_comn.c.

{
    PPCI_ARBITER_INSTANCE Arbiter;
    PAGED_CODE();
 
    if (!FdoExtension->ArbitersInitialized) return STATUS_NOT_SUPPORTED;
 
    /* Find the instance this bus built for the requested resource type */
    Arbiter = (PVOID)PciFindNextSecondaryExtension(FdoExtension->
                                                   SecondaryExtension.Next,
                                                   ArbiterType);
    if (!Arbiter)
    {
        DPRINT1("PCIX - FDO ext 0x%p has no %s arbiter to hand out.\n",
                FdoExtension,
                PciArbiterNames[ArbiterType - PciArb_Io]);
        return STATUS_NOT_SUPPORTED;
    }
 
    Interface->Size = sizeof(ARBITER_INTERFACE);
    Interface->Version = ARBITER_INTERFACE_VERSION;
    Interface->Context = &Arbiter->CommonInstance;
    Interface->InterfaceReference = PciArbiter_Reference;
    Interface->InterfaceDereference = PciArbiter_Dereference;
    Interface->ArbiterHandler = ArbiterLibHandler;
    Interface->Flags = 0;
    return STATUS_SUCCESS;
}

Referenced by arbusno_Constructor(), ario_Constructor(), and armem_Constructor().

PciArbiterDestructor()

VOID NTAPI PciArbiterDestructor

(

IN PPCI_ARBITER_INSTANCE

Arbiter

)

Definition at line 233 of file arb_comn.c.

{
    PAGED_CODE();
 
    ArbiterLibDeleteInstance(&Arbiter->CommonInstance);
}

Referenced by PciInitializeArbiters().

PciCollectForwardedRanges()

static PCM_RESOURCE_LIST NTAPI PciCollectForwardedRanges ( _In_ PPCI_PDO_EXTENSION  BridgeExtension )

static

Builds a resource list of the ranges a PCI-to-PCI bridge forwards to its secondary bus.

Parameters

[in]

BridgeExtension

The PDO extension of a positive decode bridge.

Returns

The open windows and, with the VGA enable set, the legacy video ranges. NULL if out of memory.

Definition at line 343 of file arb_comn.c.

{
    PCM_PARTIAL_RESOURCE_DESCRIPTOR First, Descriptor, Window;
    PCM_RESOURCE_LIST RangeList;
    SIZE_T Size;
    ULONG Index;
 
    PAGED_CODE();
 
    /* Room for the I/O, memory and prefetchable windows plus three VGA ranges */
    Size = sizeof(*RangeList) + (5 * sizeof(*Descriptor));
    RangeList = ExAllocatePoolWithTag(PagedPool, Size, PCI_POOL_TAG);
    if (!RangeList)
        return NULL;
 
    RtlZeroMemory(RangeList, Size);
    RangeList->Count = 1;
    RangeList->List[0].InterfaceType = PCIBus;
    RangeList->List[0].BusNumber = BridgeExtension->Dependent.type1.SecondaryBus;
    RangeList->List[0].PartialResourceList.Version = 1;
    RangeList->List[0].PartialResourceList.Revision = 1;
    First = RangeList->List[0].PartialResourceList.PartialDescriptors;
    Descriptor = First;
 
    /* The windows follow the BARs, a closed one was saved as a null descriptor */
    if (BridgeExtension->Resources)
    {
        for (Index = PCI_TYPE1_ADDRESSES; Index < (PCI_TYPE1_ADDRESSES + 3); Index++)
        {
            Window = &BridgeExtension->Resources->Current[Index];
            if ((Window->Type == CmResourceTypeNull) || !Window->u.Generic.Length)
                continue;
 
            *Descriptor = *Window;
            Descriptor++;
        }
    }
 
    if (BridgeExtension->Dependent.type1.VgaBitSet)
    {
        Descriptor->Type = CmResourceTypeMemory;
        Descriptor->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
        Descriptor->u.Memory.Start.QuadPart = 0xA0000;
        Descriptor->u.Memory.Length = 0x20000;
        Descriptor++;
 
        Descriptor->Type = CmResourceTypePort;
        Descriptor->Flags = CM_RESOURCE_PORT_POSITIVE_DECODE | CM_RESOURCE_PORT_10_BIT_DECODE;
        Descriptor->u.Port.Start.QuadPart = 0x3B0;
        Descriptor->u.Port.Length = 0xC;
        Descriptor++;
 
        Descriptor->Type = CmResourceTypePort;
        Descriptor->Flags = CM_RESOURCE_PORT_POSITIVE_DECODE | CM_RESOURCE_PORT_10_BIT_DECODE;
        Descriptor->u.Port.Start.QuadPart = 0x3C0;
        Descriptor->u.Port.Length = 0x20;
        Descriptor++;
    }
 
    RangeList->List[0].PartialResourceList.Count = (ULONG)(Descriptor - First);
    return RangeList;
}

Referenced by PciInitializeArbiterRanges().

PciHasRangeOfType()

static BOOLEAN NTAPI PciHasRangeOfType ( _In_ PCM_RESOURCE_LIST  RangeList, _In_ UCHAR  Type  )

static

Tells whether a resource list holds any range of one resource type.

Parameters

[in]	RangeList	A resource list with a single full descriptor.
[in]	Type	The CmResourceType to look for.

Returns

TRUE if at least one descriptor of that type is present. A large memory range counts as memory.

Definition at line 423 of file arb_comn.c.

{
    PCM_PARTIAL_RESOURCE_LIST PartialList;
    UCHAR RangeType;
    ULONG Index;
 
    PartialList = &RangeList->List[0].PartialResourceList;
    for (Index = 0; Index < PartialList->Count; Index++)
    {
        RangeType = PartialList->PartialDescriptors[Index].Type;
        if ((RangeType == Type) ||
            ((RangeType == CmResourceTypeMemoryLarge) && (Type == CmResourceTypeMemory)))
        {
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by PciInitializeArbiterRanges().

PciInitializeArbiterRanges()

NTSTATUS NTAPI PciInitializeArbiterRanges	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN PCM_RESOURCE_LIST	Resources
	)

Definition at line 447 of file arb_comn.c.

{
    PPCI_PDO_EXTENSION PdoExtension;
    PPCI_ARBITER_INSTANCE Instance;
    PCM_RESOURCE_LIST Ranges;
    PCI_SIGNATURE ArbiterType;
    NTSTATUS Status;
 
    /* Arbiters should not already be initialized */
    if (DeviceExtension->ArbitersInitialized)
    {
        /* Duplicated start request, fail initialization */
        DPRINT1("PCIX - Warning hot start FDOx %p, resource ranges not checked.\n", DeviceExtension);
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    /* A root bus decodes the ranges it was started with */
    Ranges = Resources;
 
    /* Check for non-root FDO */
    if (!PCI_IS_ROOT_FDO(DeviceExtension))
    {
        /* Grab the PDO */
        PdoExtension = (PPCI_PDO_EXTENSION)DeviceExtension->PhysicalDeviceObject->DeviceExtension;
        ASSERT_PDO(PdoExtension);
 
        /* Check if this is a subtractive bus */
        if (PdoExtension->Dependent.type1.SubtractiveDecode)
        {
            /* There is nothing to do regarding arbitration of resources */
            DPRINT1("PCIX - Skipping arbiter initialization for subtractive bridge FDOX %p\n", DeviceExtension);
            return STATUS_SUCCESS;
        }
 
        /* The start resources hold the bridge's own BARs, the bus only gets what it forwards */
        Ranges = PciCollectForwardedRanges(PdoExtension);
        if (!Ranges)
            return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Loop the arbiters that hand out the ranges a bus decodes */
    for (ArbiterType = PciArb_Io; ArbiterType <= PciArb_Memory; ArbiterType++)
    {
        /* Find an arbiter of this type */
        Instance = (PVOID)PciFindNextSecondaryExtension(DeviceExtension->
                                                        SecondaryExtension.Next,
                                                        ArbiterType);
        if (Instance)
        {
            /* The decoded ranges bound what the arbiter may hand out */
            Status = Instance->CommonInstance.StartArbiter(&Instance->CommonInstance,
                                                           Ranges);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("PCIX - FDO ext 0x%p %s arbiter failed to start: %X\n",
                        DeviceExtension,
                        PciArbiterNames[ArbiterType - PciArb_Io],
                        Status);
                goto Exit;
            }
 
            /* An empty seed leaves everything open, but a bridge without the range forwards none */
            if (!PCI_IS_ROOT_FDO(DeviceExtension) &&
                !PciHasRangeOfType(Ranges, (UCHAR)Instance->CommonInstance.ResourceType))
            {
                ArbiterLibReserveRange(&Instance->CommonInstance,
                                       0,
                                       ARBITER_MAXIMUM_ADDRESS,
                                       NULL,
                                       FALSE);
            }
        }
        else
        {
            /* The arbiter was not found, this is an error! */
            DPRINT1("PCIX - FDO ext 0x%p %s arbiter (REQUIRED) is missing.\n",
                    DeviceExtension,
                    PciArbiterNames[ArbiterType - PciArb_Io]);
        }
    }
 
    /* Arbiters are now initialized */
    DeviceExtension->ArbitersInitialized = TRUE;
    Status = STATUS_SUCCESS;
 
Exit:
    if (Ranges != Resources)
        ExFreePoolWithTag(Ranges, PCI_POOL_TAG);
 
    return Status;
}

Referenced by PciFdoIrpStartDevice().

PciInitializeArbiters()

NTSTATUS NTAPI PciInitializeArbiters

(

IN PPCI_FDO_EXTENSION

FdoExtension

)

Definition at line 242 of file arb_comn.c.

{
    PPCI_INTERFACE CurrentInterface, *Interfaces;
    PPCI_PDO_EXTENSION PdoExtension;
    PPCI_ARBITER_INSTANCE ArbiterInterface;
    NTSTATUS Status;
    PCI_SIGNATURE ArbiterType;
    ASSERT_FDO(FdoExtension);
 
    /* A bus that ends up needing no arbiter at all is not a failure */
    Status = STATUS_SUCCESS;
 
    /* A subtractive bus has no arbiters of its own, requests fall through to the parent's */
    if (!PCI_IS_ROOT_FDO(FdoExtension))
    {
        /* Get the PDO extension */
        PdoExtension = FdoExtension->PhysicalDeviceObject->DeviceExtension;
        ASSERT_PDO(PdoExtension);
 
        if (PdoExtension->Dependent.type1.SubtractiveDecode)
        {
            DPRINT1("PCIX - Not creating arbiters for subtractive bus 0x%x\n",
                    FdoExtension->BaseBus);
            return STATUS_SUCCESS;
        }
    }
 
    /* Loop all the arbiters */
    for (ArbiterType = PciArb_Io; ArbiterType <= PciArb_BusNumber; ArbiterType++)
    {
        /* Query all the registered arbiter interfaces */
        Interfaces = PciInterfaces;
        while (*Interfaces)
        {
            /* Find the one that matches the arbiter currently being setup */
            CurrentInterface = *Interfaces;
            if (CurrentInterface->Signature == ArbiterType) break;
            Interfaces++;
        }
 
        /* Check if the required arbiter was not found in the list */
        if (!*Interfaces)
        {
            /* Skip this arbiter and try the next one */
            DPRINT1("PCIX - FDO ext 0x%p no %s arbiter.\n",
                    FdoExtension,
                    PciArbiterNames[ArbiterType - PciArb_Io]);
            continue;
        }
 
        /* An arbiter was found, allocate an instance for it */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        ArbiterInterface = ExAllocatePoolWithTag(PagedPool,
                                                 sizeof(PCI_ARBITER_INSTANCE),
                                                 PCI_POOL_TAG);
        if (!ArbiterInterface) break;
 
        /* Setup the instance */
        ArbiterInterface->BusFdoExtension = FdoExtension;
        ArbiterInterface->Interface = CurrentInterface;
        _swprintf(ArbiterInterface->InstanceName,
                  L"PCI %S (b=%02x)",
                  PciArbiterNames[ArbiterType - PciArb_Io],
                  FdoExtension->BaseBus);
 
        /* Call the interface initializer for it */
        Status = CurrentInterface->Initializer(ArbiterInterface);
        if (!NT_SUCCESS(Status)) break;
 
        /* Link it with this FDO */
        PcipLinkSecondaryExtension(&FdoExtension->SecondaryExtension,
                                   &FdoExtension->SecondaryExtLock,
                                   &ArbiterInterface->Header,
                                   ArbiterType,
                                   PciArbiterDestructor);
 
        /* This arbiter is now initialized, move to the next one */
        DPRINT1("PCIX - FDO ext 0x%p %S arbiter initialized (context 0x%p).\n",
                FdoExtension,
                L"ARBITER HEADER MISSING", //ArbiterInterface->CommonInstance.Name,
                ArbiterInterface);
        Status = STATUS_SUCCESS;
    }
 
    /* Return to caller */
    return Status;
}

Referenced by PciAddDevice().

Variable Documentation

PciArbiterNames

PCHAR PciArbiterNames[]

Initial value:

=
{
    "I/O Port",
    "Memory",
    "Interrupt",
    "Bus Number"
}

Definition at line 21 of file arb_comn.c.

Referenced by PciArbiterConstructor(), PciInitializeArbiterRanges(), and PciInitializeArbiters().