arbport.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Kernel
 * LICENSE:     MIT (https://spdx.org/licenses/MIT)
 * PURPOSE:     PnP manager Root Port Arbiter
 * COPYRIGHT:   Copyright 2025-2026 Justin Miller <justin.miller@reactos.org>
 */
 
/* INCLUDES *****************************************************************/
 
#include <ntoskrnl.h>
#define NDEBUG
#include <debug.h>
 
/* GLOBALS *******************************************************************/
 
extern ARBITER_INSTANCE IopRootPortArbiter;
 
ULONGLONG
NTAPI
RtlIoDecodeMemIoResource(
    _In_ PIO_RESOURCE_DESCRIPTOR Descriptor,
    _Out_opt_ PULONGLONG Alignment,
    _Out_opt_ PULONGLONG MinimumAddress,
    _Out_opt_ PULONGLONG MaximumAddress);
 
ULONGLONG
NTAPI
RtlCmDecodeMemIoResource(
    _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,
    _Out_opt_ PULONGLONG Start);
 
/*
 * A card that decodes only the low 10 or 12 address lines answers not just on
 * its own range but on every "alias" a multiple of 0x400 / 0x1000 above it, up
 * to the top of the 64 KB port space.
 */
#define PORT_ALIAS_STRIDE_10_BIT    0x400
#define PORT_ALIAS_STRIDE_12_BIT    0x1000
#define PORT_MAX_ADDRESS            0xFFFF
 
/* FUNCTIONS *****************************************************************/
 
static
NTSTATUS
IopArbPortTranslateAddress(
    _In_ UCHAR SourceType,
    _In_ PHYSICAL_ADDRESS SourceAddress,
    _Out_ PPHYSICAL_ADDRESS TranslatedAddress,
    _Out_ PUCHAR TranslatedType)
{
    ULONG AddressSpace;
 
    PAGED_CODE();
 
    if (SourceType == CmResourceTypePort)
        AddressSpace = 1; /* I/O port space */
    else if (SourceType == CmResourceTypeMemory || SourceType == CmResourceTypeMemoryLarge)
        AddressSpace = 0; /* System memory */
    else
        return STATUS_INVALID_PARAMETER;
 
    if (!HalTranslateBusAddress(Isa, 0, SourceAddress, &AddressSpace, TranslatedAddress))
        return STATUS_UNSUCCESSFUL;
 
    /* The HAL reports back the space it landed in; only these two are expected. */
    if (AddressSpace == 1)
    {
        *TranslatedType = CmResourceTypePort;
    }
    else if (AddressSpace == 0)
    {
        *TranslatedType = (SourceType == CmResourceTypeMemoryLarge)
                          ? CmResourceTypeMemoryLarge
                          : CmResourceTypeMemory;
    }
    else
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    return STATUS_SUCCESS;
}
 
static
BOOLEAN
IopArbPortGetNextAlias(
    _In_ USHORT DescriptorFlags,
    _In_ UINT64 LastAlias,
    _Out_ PUINT64 NextAlias)
{
    UINT64 Next;
 
    PAGED_CODE();
 
    if (DescriptorFlags & CM_RESOURCE_PORT_10_BIT_DECODE)
        Next = LastAlias + PORT_ALIAS_STRIDE_10_BIT;
    else if (DescriptorFlags & CM_RESOURCE_PORT_12_BIT_DECODE)
        Next = LastAlias + PORT_ALIAS_STRIDE_12_BIT;
    else
        return FALSE;
 
    if (Next > PORT_MAX_ADDRESS)
        return FALSE;
 
    *NextAlias = Next;
    return TRUE;
}
 
static
NTSTATUS
NTAPI
IopArbPortUnpackRequirements(
    _In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor,
    _Out_ PUINT64 OutMinimumAddress,
    _Out_ PUINT64 OutMaximumAddress,
    _Out_ PUINT64 OutLength,
    _Out_ PUINT64 OutAlignment)
{
    PAGED_CODE();
 
    *OutLength = RtlIoDecodeMemIoResource(IoDescriptor,
                                          OutAlignment,
                                          OutMinimumAddress,
                                          OutMaximumAddress);
 
    if (*OutAlignment == 0)
        *OutAlignment = 1;
 
    return STATUS_SUCCESS;
}
 
static
NTSTATUS
NTAPI
IopArbPortPackResource(
    _In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor,
    _In_ UINT64 Start,
    _Out_ PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescriptor)
{
    PAGED_CODE();
 
    CmDescriptor->Type = IoDescriptor->Type;
    CmDescriptor->Flags = IoDescriptor->Flags;
    CmDescriptor->ShareDisposition = IoDescriptor->ShareDisposition;
 
    CmDescriptor->u.Generic.Start.QuadPart = Start;
    CmDescriptor->u.Generic.Length = IoDescriptor->u.Generic.Length;
 
    return STATUS_SUCCESS;
}
 
static
NTSTATUS
NTAPI
IopArbPortUnpackResource(
    _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescriptor,
    _Out_ PUINT64 Start,
    _Out_ PUINT64 OutLength)
{
    PAGED_CODE();
 
    *OutLength = RtlCmDecodeMemIoResource(CmDescriptor, Start);
 
    return STATUS_SUCCESS;
}
 
static
INT32
NTAPI
IopArbPortScoreRequirement(
    _In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor)
{
    UINT64 Length, Alignment;
    UINT64 Minimum, Maximum, AlignedMinimum;
    UINT64 Span, Placements;
 
    PAGED_CODE();
 
    Length = RtlIoDecodeMemIoResource(IoDescriptor, &Alignment, &Minimum, &Maximum);
 
    if (Alignment == 0)
        Alignment = 1;
 
    /* Round the window's base up to the first address the device can sit at. */
    AlignedMinimum = (Minimum + Alignment - 1) & ~(Alignment - 1);
    if (AlignedMinimum < Minimum || AlignedMinimum > Maximum)
        return -1;
 
    /* Count in addresses above the base, so a full-width window cannot overflow. */
    Span = Maximum - AlignedMinimum;
 
    if (Length != 0)
    {
        if (Length - 1 > Span)
            return -1;
 
        Span -= Length - 1;
    }
 
    Placements = Span / Alignment + 1;
    return (INT32)min(Placements, MAXLONG);
}
 
static
NTSTATUS
NTAPI
IopArbPortTranslateOrdering(
    _Out_ PIO_RESOURCE_DESCRIPTOR OutIoDescriptor,
    _In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor)
{
    UCHAR SourceType;
    UCHAR MinimumType;
    UCHAR MaximumType;
 
    PAGED_CODE();
 
    *OutIoDescriptor = *IoDescriptor;
 
    SourceType = IoDescriptor->Type;
    if (SourceType != CmResourceTypePort &&
        SourceType != CmResourceTypeMemory &&
        SourceType != CmResourceTypeMemoryLarge)
    {
        return STATUS_SUCCESS;
    }
 
    MinimumType = SourceType;
    MaximumType = SourceType;
 
    if (!NT_SUCCESS(IopArbPortTranslateAddress(SourceType,
                                               IoDescriptor->u.Generic.MinimumAddress,
                                               &OutIoDescriptor->u.Generic.MinimumAddress,
                                               &MinimumType)) ||
        !NT_SUCCESS(IopArbPortTranslateAddress(SourceType,
                                               IoDescriptor->u.Generic.MaximumAddress,
                                               &OutIoDescriptor->u.Generic.MaximumAddress,
                                               &MaximumType)))
    {
        OutIoDescriptor->Type = CmResourceTypeNull;
    }
    else
    {
        OutIoDescriptor->Type = MaximumType;
    }
 
    return STATUS_SUCCESS;
}
 
static
BOOLEAN
NTAPI
IopArbPortFindSuitableRange(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PARBITER_ALLOCATION_STATE ArbState)
{
    PAGED_CODE();
 
    if (ArbState->Entry != NULL && (ArbState->Entry->Flags & ARBITER_FLAG_BOOT_CONFIG))
        ArbState->RangeAvailableAttributes |= ARBITER_RANGE_BOOT_ALLOCATED;
 
    return ArbiterLibFindSuitableRange(Arbiter, ArbState);
}
 
static
VOID
NTAPI
IopArbPortAddAllocation(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PARBITER_ALLOCATION_STATE ArbState)
{
    PARBITER_ALTERNATIVE Alternative = ArbState->CurrentAlternative;
    PVOID Owner = ArbState->Entry ? ArbState->Entry->PhysicalDeviceObject : NULL;
    ULONG Flags = RTL_RANGE_LIST_ADD_IF_CONFLICT;
    UINT64 Alias;
    UINT64 Span;
 
    PAGED_CODE();
 
    if (Alternative != NULL && (Alternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED))
        Flags |= RTL_RANGE_LIST_ADD_SHARED;
 
    RtlAddRange(Arbiter->PossibleAllocation,
                ArbState->Start,
                ArbState->End,
                ArbState->RangeAttributes,
                Flags,
                NULL,
                Owner);
 
    if (Alternative == NULL)
        return;
 
    /* Alias the width actually granted, not the width asked for. */
    Span = ArbState->End - ArbState->Start;
 
    Alias = ArbState->Start;
    while (IopArbPortGetNextAlias(Alternative->Descriptor->Flags, Alias, &Alias))
    {
        RtlAddRange(Arbiter->PossibleAllocation,
                    Alias,
                    Alias + Span,
                    ArbState->RangeAttributes | ARBITER_RANGE_PORT_ALIAS,
                    Flags,
                    NULL,
                    Owner);
    }
}
 
static
VOID
NTAPI
IopArbPortBacktrackAllocation(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PARBITER_ALLOCATION_STATE ArbState)
{
    PARBITER_ALTERNATIVE Alternative = ArbState->CurrentAlternative;
    PVOID Owner = ArbState->Entry ? ArbState->Entry->PhysicalDeviceObject : NULL;
    UINT64 Alias;
    UINT64 Span;
 
    PAGED_CODE();
 
    if (Alternative != NULL)
    {
        Span = ArbState->End - ArbState->Start;
 
        Alias = ArbState->Start;
        while (IopArbPortGetNextAlias(Alternative->Descriptor->Flags, Alias, &Alias))
        {
            RtlDeleteRange(Arbiter->PossibleAllocation, Alias, Alias + Span, Owner);
        }
    }
 
    RtlDeleteRange(Arbiter->PossibleAllocation, ArbState->Start, ArbState->End, Owner);
}
 
NTSTATUS
NTAPI
IopArbPortInitialize(VOID)
{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    IopRootPortArbiter.Name = L"RootPort";
    IopRootPortArbiter.UnpackRequirement = IopArbPortUnpackRequirements;
    IopRootPortArbiter.PackResource = IopArbPortPackResource;
    IopRootPortArbiter.UnpackResource = IopArbPortUnpackResource;
    IopRootPortArbiter.ScoreRequirement = IopArbPortScoreRequirement;
 
    /* Port-specific placement: boot-config leniency and ISA decode aliasing. */
    IopRootPortArbiter.FindSuitableRange = IopArbPortFindSuitableRange;
    IopRootPortArbiter.AddAllocation = IopArbPortAddAllocation;
    IopRootPortArbiter.BacktrackAllocation = IopArbPortBacktrackAllocation;
 
    Status = ArbiterLibInitializeInstance(&IopRootPortArbiter,
                                          NULL,
                                          CmResourceTypePort,
                                          IopRootPortArbiter.Name,
                                          L"Root",
                                          IopArbPortTranslateOrdering);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbPortInitialize: Failed with %X\n", Status);
    }
 
    return Status;
}