isapnp.c File Reference

#include "isapnp.h"
#include <debug.h>

Include dependency graph for isapnp.c:

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

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
	_Guarded_by_ (BusSyncEvent)
static VOID	IsaConvertIrqRequirement (_Out_ PIO_RESOURCE_DESCRIPTOR Descriptor, _In_ PISAPNP_IRQ_DESCRIPTION Description, _In_ ULONG Vector, _In_ BOOLEAN FirstDescriptor)
static VOID	IsaConvertDmaRequirement (_Out_ PIO_RESOURCE_DESCRIPTOR Descriptor, _In_ PISAPNP_DMA_DESCRIPTION Description, _In_ ULONG Channel, _In_ BOOLEAN FirstDescriptor)
static VOID	IsaConvertMemRangeRequirement (_Out_ PIO_RESOURCE_DESCRIPTOR Descriptor, _In_ PISAPNP_MEMRANGE_DESCRIPTION Description)
static VOID	IsaConvertMemRange32Requirement (_Out_ PIO_RESOURCE_DESCRIPTOR Descriptor, _In_ PISAPNP_MEMRANGE32_DESCRIPTION Description)
static NTSTATUS	IsaPnpCreateLogicalDeviceRequirements (_In_ PISAPNP_PDO_EXTENSION PdoExt)
BOOLEAN	FindIoDescriptor (_In_ PISAPNP_LOGICAL_DEVICE LogDevice, _In_opt_ ULONG Base, _In_ ULONG RangeStart, _In_ ULONG RangeEnd, _Out_opt_ PUCHAR Information, _Out_opt_ PULONG Length)
BOOLEAN	FindIrqDescriptor (_In_ PISAPNP_LOGICAL_DEVICE LogDevice, _In_ ULONG Vector)
BOOLEAN	FindDmaDescriptor (_In_ PISAPNP_LOGICAL_DEVICE LogDevice, _In_ ULONG Channel)
BOOLEAN	FindMemoryDescriptor (_In_ PISAPNP_LOGICAL_DEVICE LogDevice, _In_ ULONG RangeStart, _In_ ULONG RangeEnd, _Out_opt_ PUCHAR Information)
static NTSTATUS	IsaPnpCreateLogicalDeviceResources (_In_ PISAPNP_PDO_EXTENSION PdoExt)
PIO_RESOURCE_REQUIREMENTS_LIST	IsaPnpCreateReadPortDORequirements (_In_opt_ ULONG SelectedReadPort)
PCM_RESOURCE_LIST	IsaPnpCreateReadPortDOResources (VOID)
static NTSTATUS	IsaPnpCreateReadPortDO (_In_ PISAPNP_FDO_EXTENSION FdoExt)
VOID	IsaPnpRemoveReadPortDO (_In_ PDEVICE_OBJECT Pdo)
NTSTATUS	IsaPnpFillDeviceRelations (_In_ PISAPNP_FDO_EXTENSION FdoExt, _Inout_ PIRP Irp, _In_ BOOLEAN IncludeDataPort)
static	CODE_SEG ("PAGE")
	_Dispatch_type_ (IRP_MJ_POWER)
	_Dispatch_type_ (IRP_MJ_PNP)
	_Dispatch_type_ (IRP_MJ_CREATE)
	_Dispatch_type_ (IRP_MJ_DEVICE_CONTROL)
NTSTATUS NTAPI	DriverEntry (_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)

Variables
KEVENT	BusSyncEvent

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 16 of file isapnp.c.

Function Documentation

_Dispatch_type_() [1/4]

_Dispatch_type_

(

IRP_MJ_CREATE

)

Definition at line 1353 of file isapnp.c.

{
    PAGED_CODE();
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
 
    DPRINT("%s(%p, %p)\n", __FUNCTION__, DeviceObject, Irp);
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}

_Dispatch_type_() [2/4]

_Dispatch_type_

(

IRP_MJ_DEVICE_CONTROL

)

Definition at line 1376 of file isapnp.c.

{
    PISAPNP_COMMON_EXTENSION CommonExt = DeviceObject->DeviceExtension;
 
    PAGED_CODE();
 
    DPRINT("%s(%p, %p) Minor - %X\n", __FUNCTION__, DeviceObject, Irp,
           IoGetCurrentIrpStackLocation(Irp)->MinorFunction);
 
    if (CommonExt->Signature == IsaPnpBus)
    {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(((PISAPNP_FDO_EXTENSION)CommonExt)->Ldo, Irp);
    }
    else
    {
        NTSTATUS Status = Irp->IoStatus.Status;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
}

_Dispatch_type_() [3/4]

_Dispatch_type_

(

IRP_MJ_PNP

)

Definition at line 1331 of file isapnp.c.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PISAPNP_COMMON_EXTENSION DevExt = DeviceObject->DeviceExtension;
 
    PAGED_CODE();
 
    if (DevExt->Signature == IsaPnpBus)
        return IsaFdoPnp((PISAPNP_FDO_EXTENSION)DevExt, Irp, IrpSp);
    else
        return IsaPdoPnp((PISAPNP_PDO_EXTENSION)DevExt, Irp, IrpSp);
}

_Dispatch_type_() [4/4]

_Dispatch_type_

(

IRP_MJ_POWER

)

Definition at line 1293 of file isapnp.c.

{
    PISAPNP_COMMON_EXTENSION DevExt = DeviceObject->DeviceExtension;
    NTSTATUS Status;
 
    if (DevExt->Signature != IsaPnpBus)
    {
        switch (IoGetCurrentIrpStackLocation(Irp)->MinorFunction)
        {
            case IRP_MN_SET_POWER:
            case IRP_MN_QUERY_POWER:
                Status = STATUS_SUCCESS;
                Irp->IoStatus.Status = Status;
                break;
 
            default:
                Status = Irp->IoStatus.Status;
                break;
        }
 
        PoStartNextPowerIrp(Irp);
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
 
    PoStartNextPowerIrp(Irp);
    IoSkipCurrentIrpStackLocation(Irp);
    return PoCallDriver(((PISAPNP_FDO_EXTENSION)DevExt)->Ldo, Irp);
}

_Guarded_by_()

_Guarded_by_

(

BusSyncEvent

)

Definition at line 23 of file isapnp.c.

{
    PAGED_CODE();
 
    Descriptor->Type = CmResourceTypePort;
    Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
    Descriptor->Flags = CM_RESOURCE_PORT_IO;
    if (Description->Information & 0x1)
        Descriptor->Flags |= CM_RESOURCE_PORT_16_BIT_DECODE;
    else
        Descriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
    Descriptor->u.Port.Length = Description->Length;
    Descriptor->u.Port.Alignment = Description->Alignment;
    Descriptor->u.Port.MinimumAddress.LowPart = Description->Minimum;
    Descriptor->u.Port.MaximumAddress.LowPart = Description->Maximum +
                                                Description->Length - 1;
}

CODE_SEG()

static CODE_SEG ( "PAGE"  )

static

Definition at line 1232 of file isapnp.c.

{
    PDEVICE_OBJECT Fdo;
    PISAPNP_FDO_EXTENSION FdoExt;
    NTSTATUS Status;
    static ULONG BusNumber = 0;
 
    PAGED_CODE();
 
    DPRINT("%s(%p, %p)\n", __FUNCTION__, DriverObject, PhysicalDeviceObject);
 
    Status = IoCreateDevice(DriverObject,
                            sizeof(*FdoExt),
                            NULL,
                            FILE_DEVICE_BUS_EXTENDER,
                            FILE_DEVICE_SECURE_OPEN,
                            FALSE,
                            &Fdo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create FDO (0x%08lx)\n", Status);
        return Status;
    }
 
    FdoExt = Fdo->DeviceExtension;
    RtlZeroMemory(FdoExt, sizeof(*FdoExt));
 
    FdoExt->Common.Self = Fdo;
    FdoExt->Common.Signature = IsaPnpBus;
    FdoExt->Common.State = dsStopped;
    FdoExt->DriverObject = DriverObject;
    FdoExt->BusNumber = BusNumber++;
    FdoExt->Pdo = PhysicalDeviceObject;
    FdoExt->Ldo = IoAttachDeviceToDeviceStack(Fdo,
                                              PhysicalDeviceObject);
    if (!FdoExt->Ldo)
    {
        IoDeleteDevice(Fdo);
        return STATUS_DEVICE_REMOVED;
    }
 
    InitializeListHead(&FdoExt->DeviceListHead);
    KeInitializeEvent(&FdoExt->DeviceSyncEvent, SynchronizationEvent, TRUE);
 
    IsaPnpAcquireBusDataLock();
    InsertTailList(&BusListHead, &FdoExt->BusLink);
    IsaPnpReleaseBusDataLock();
 
    Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
 
    return STATUS_SUCCESS;
}

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	_In_ PDRIVER_OBJECT	DriverObject,
		_In_ PUNICODE_STRING	RegistryPath
	)

Definition at line 1412 of file isapnp.c.

{
    DPRINT("%s(%p, %wZ)\n", __FUNCTION__, DriverObject, RegistryPath);
 
    if (IsNEC_98)
    {
        IsaConfigPorts[0] = ISAPNP_WRITE_DATA_PC98;
        IsaConfigPorts[1] = ISAPNP_ADDRESS_PC98;
    }
 
    DriverObject->MajorFunction[IRP_MJ_CREATE] = IsaCreateClose;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = IsaCreateClose;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = IsaForwardOrIgnore;
    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = IsaForwardOrIgnore;
    DriverObject->MajorFunction[IRP_MJ_PNP] = IsaPnp;
    DriverObject->MajorFunction[IRP_MJ_POWER] = IsaPower;
    DriverObject->DriverExtension->AddDevice = IsaAddDevice;
 
    /* FIXME: Fix SDK headers */
#if 0
    _No_competing_thread_begin_
#endif
 
    KeInitializeEvent(&BusSyncEvent, SynchronizationEvent, TRUE);
    InitializeListHead(&BusListHead);
 
    /* FIXME: Fix SDK headers */
#if 0
    _No_competing_thread_end_
#endif
 
    return STATUS_SUCCESS;
}

FindDmaDescriptor()

BOOLEAN FindDmaDescriptor	(	_In_ PISAPNP_LOGICAL_DEVICE	LogDevice,
		_In_ ULONG	Channel
	)

Definition at line 535 of file isapnp.c.

{
    PISAPNP_RESOURCE Resource;
 
    PAGED_CODE();
 
    Resource = LogDevice->Resources;
    while (Resource->Type != ISAPNP_RESOURCE_TYPE_END)
    {
        if (Resource->Type == ISAPNP_RESOURCE_TYPE_DMA)
        {
            PISAPNP_DMA_DESCRIPTION Description = &Resource->DmaDescription;
 
            if (Description->Mask & (1 << Channel))
                return TRUE;
        }
 
        ++Resource;
    }
 
    return FALSE;
}

FindIoDescriptor()

BOOLEAN FindIoDescriptor	(	_In_ PISAPNP_LOGICAL_DEVICE	LogDevice,
		_In_opt_ ULONG	Base,
		_In_ ULONG	RangeStart,
		_In_ ULONG	RangeEnd,
		_Out_opt_ PUCHAR	Information,
		_Out_opt_ PULONG	Length
	)

Definition at line 459 of file isapnp.c.

{
    PISAPNP_RESOURCE Resource;
 
    PAGED_CODE();
 
    Resource = LogDevice->Resources;
    while (Resource->Type != ISAPNP_RESOURCE_TYPE_END)
    {
        if (Resource->Type == ISAPNP_RESOURCE_TYPE_IO)
        {
            PISAPNP_IO_DESCRIPTION Description = &Resource->IoDescription;
            BOOLEAN Match;
 
            if (Base)
            {
                Match = (Base >= Description->Minimum) && (Base <= Description->Maximum);
            }
            else
            {
                Match = (RangeStart >= Description->Minimum) &&
                        (RangeEnd <= (ULONG)(Description->Maximum + Description->Length - 1));
            }
 
            if (Match)
            {
                if (Information)
                    *Information = Description->Information;
                if (Length)
                    *Length = Description->Length;
 
                return TRUE;
            }
        }
 
        ++Resource;
    }
 
    return FALSE;
}

Referenced by IsaPnpCreateLogicalDeviceResources().

FindIrqDescriptor()

BOOLEAN FindIrqDescriptor	(	_In_ PISAPNP_LOGICAL_DEVICE	LogDevice,
		_In_ ULONG	Vector
	)

Definition at line 508 of file isapnp.c.

{
    PISAPNP_RESOURCE Resource;
 
    PAGED_CODE();
 
    Resource = LogDevice->Resources;
    while (Resource->Type != ISAPNP_RESOURCE_TYPE_END)
    {
        if (Resource->Type == ISAPNP_RESOURCE_TYPE_IRQ)
        {
            PISAPNP_IRQ_DESCRIPTION Description = &Resource->IrqDescription;
 
            if (Description->Mask & (1 << Vector))
                return TRUE;
        }
 
        ++Resource;
    }
 
    return FALSE;
}

FindMemoryDescriptor()

BOOLEAN FindMemoryDescriptor	(	_In_ PISAPNP_LOGICAL_DEVICE	LogDevice,
		_In_ ULONG	RangeStart,
		_In_ ULONG	RangeEnd,
		_Out_opt_ PUCHAR	Information
	)

Definition at line 562 of file isapnp.c.

{
    PISAPNP_RESOURCE Resource;
 
    PAGED_CODE();
 
    Resource = LogDevice->Resources;
    while (Resource->Type != ISAPNP_RESOURCE_TYPE_END)
    {
        switch (Resource->Type)
        {
            case ISAPNP_RESOURCE_TYPE_MEMRANGE:
            {
                PISAPNP_MEMRANGE_DESCRIPTION Description;
 
                Description = &Resource->MemRangeDescription;
 
                if ((RangeStart >= (ULONG)(Description->Minimum << 8)) &&
                    (RangeEnd <= (ULONG)((Description->Maximum << 8) +
                                         (Description->Length << 8) - 1)))
                {
                    if (Information)
                        *Information = Description->Information;
 
                    return TRUE;
                }
                break;
            }
 
            case ISAPNP_RESOURCE_TYPE_MEMRANGE32:
            {
                PISAPNP_MEMRANGE32_DESCRIPTION Description32;
 
                Description32 = &Resource->MemRange32Description;
 
                if ((RangeStart >= Description32->Minimum) &&
                    (RangeEnd <= (Description32->Maximum + Description32->Length - 1)))
                {
                    if (Information)
                        *Information = Description32->Information;
 
                    return TRUE;
                }
                break;
            }
 
            default:
                break;
        }
 
        ++Resource;
    }
 
    return FALSE;
}

Referenced by IsaHwConfigureDevice(), and IsaPnpCreateLogicalDeviceResources().

IsaConvertDmaRequirement()

static VOID IsaConvertDmaRequirement ( _Out_ PIO_RESOURCE_DESCRIPTOR  Descriptor, _In_ PISAPNP_DMA_DESCRIPTION  Description, _In_ ULONG  Channel, _In_ BOOLEAN  FirstDescriptor  )

static

Definition at line 89 of file isapnp.c.

{
    UNREFERENCED_PARAMETER(Description);
 
    PAGED_CODE();
 
    if (!FirstDescriptor)
        Descriptor->Option = IO_RESOURCE_ALTERNATIVE;
    Descriptor->Type = CmResourceTypeDma;
    Descriptor->ShareDisposition = CmResourceShareUndetermined;
    Descriptor->Flags = CM_RESOURCE_DMA_8; /* Ignore information byte for compatibility */
    Descriptor->u.Dma.MinimumChannel =
    Descriptor->u.Dma.MaximumChannel = Channel;
}

IsaConvertIrqRequirement()

static VOID IsaConvertIrqRequirement ( _Out_ PIO_RESOURCE_DESCRIPTOR  Descriptor, _In_ PISAPNP_IRQ_DESCRIPTION  Description, _In_ ULONG  Vector, _In_ BOOLEAN  FirstDescriptor  )

static

Definition at line 61 of file isapnp.c.

{
    PAGED_CODE();
 
    if (!FirstDescriptor)
        Descriptor->Option = IO_RESOURCE_ALTERNATIVE;
    Descriptor->Type = CmResourceTypeInterrupt;
    if (Description->Information & 0xC)
    {
        Descriptor->Flags = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
        Descriptor->ShareDisposition = CmResourceShareShared;
    }
    else
    {
        Descriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
        Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
    }
    Descriptor->u.Interrupt.MinimumVector =
    Descriptor->u.Interrupt.MaximumVector = Vector;
}

IsaConvertMemRange32Requirement()

static VOID IsaConvertMemRange32Requirement ( _Out_ PIO_RESOURCE_DESCRIPTOR  Descriptor, _In_ PISAPNP_MEMRANGE32_DESCRIPTION  Description  )

static

Definition at line 137 of file isapnp.c.

{
    PAGED_CODE();
 
    Descriptor->Type = CmResourceTypeMemory;
    Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
    Descriptor->Flags = CM_RESOURCE_MEMORY_24;
    if ((Description->Information & 0x40) || !(Description->Information & 0x01))
        Descriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
    else
        Descriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
    Descriptor->u.Memory.Length = Description->Length;
    Descriptor->u.Memory.Alignment = Description->Alignment;
    Descriptor->u.Memory.MinimumAddress.LowPart = Description->Minimum;
    Descriptor->u.Memory.MaximumAddress.LowPart = Description->Maximum +
                                                  Description->Length - 1;
}

IsaConvertMemRangeRequirement()

static VOID IsaConvertMemRangeRequirement ( _Out_ PIO_RESOURCE_DESCRIPTOR  Descriptor, _In_ PISAPNP_MEMRANGE_DESCRIPTION  Description  )

static

Definition at line 111 of file isapnp.c.

{
    PAGED_CODE();
 
    Descriptor->Type = CmResourceTypeMemory;
    Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
    Descriptor->Flags = CM_RESOURCE_MEMORY_24;
    if ((Description->Information & 0x40) || !(Description->Information & 0x01))
        Descriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
    else
        Descriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
    Descriptor->u.Memory.Length = Description->Length << 8;
    if (Description->Alignment == 0)
        Descriptor->u.Memory.Alignment = 0x10000;
    else
        Descriptor->u.Memory.Alignment = Description->Alignment;
    Descriptor->u.Memory.MinimumAddress.LowPart = Description->Minimum << 8;
    Descriptor->u.Memory.MaximumAddress.LowPart = (Description->Maximum << 8) +
                                                  (Description->Length << 8) - 1;
}

IsaPnpCreateLogicalDeviceRequirements()

static NTSTATUS IsaPnpCreateLogicalDeviceRequirements ( _In_ PISAPNP_PDO_EXTENSION  PdoExt )

static

Definition at line 189 of file isapnp.c.

{
    PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList;
    PIO_RESOURCE_DESCRIPTOR Descriptor;
    ISAPNP_DEPENDENT_FUNCTION_STATE DfState;
    ULONG FirstFixedDescriptors, LastFixedDescriptors;
    ULONG ResourceCount, AltListCount, ListSize, i;
    BOOLEAN IsFirstAltList, IsFirstDescriptor;
    PIO_RESOURCE_LIST AltList;
    PISAPNP_RESOURCE Resource;
 
    PAGED_CODE();
 
    /* Count the number of requirements */
    DfState = dfNotStarted;
    FirstFixedDescriptors = 0;
    LastFixedDescriptors = 0;
    ResourceCount = 0;
    AltListCount = 1;
    Resource = PdoExt->IsaPnpDevice->Resources;
    while (Resource->Type != ISAPNP_RESOURCE_TYPE_END)
    {
        switch (Resource->Type)
        {
            case ISAPNP_RESOURCE_TYPE_START_DEPENDENT:
            {
                if (DfState == dfStarted)
                    ++AltListCount;
 
                DfState = dfStarted;
                break;
            }
 
            case ISAPNP_RESOURCE_TYPE_END_DEPENDENT:
            {
                DfState = dfDone;
                break;
            }
 
            case ISAPNP_RESOURCE_TYPE_IRQ:
            case ISAPNP_RESOURCE_TYPE_DMA:
            {
                RTL_BITMAP ResourceBitmap;
                ULONG BitmapSize, BitmapBuffer, BitCount;
 
                if (Resource->Type == ISAPNP_RESOURCE_TYPE_IRQ)
                {
                    BitmapSize = RTL_BITS_OF(Resource->IrqDescription.Mask);
                    BitmapBuffer = Resource->IrqDescription.Mask;
                }
                else
                {
                    BitmapSize = RTL_BITS_OF(Resource->DmaDescription.Mask);
                    BitmapBuffer = Resource->DmaDescription.Mask;
                }
                RtlInitializeBitMap(&ResourceBitmap, &BitmapBuffer, BitmapSize);
 
                BitCount = RtlNumberOfSetBits(&ResourceBitmap);
                switch (DfState)
                {
                    case dfNotStarted:
                        FirstFixedDescriptors += BitCount;
                        break;
 
                    case dfStarted:
                        ResourceCount += BitCount;
                        break;
 
                    case dfDone:
                        LastFixedDescriptors += BitCount;
                        break;
 
                    DEFAULT_UNREACHABLE;
                }
 
                break;
            }
 
            case ISAPNP_RESOURCE_TYPE_IO:
            case ISAPNP_RESOURCE_TYPE_MEMRANGE:
            case ISAPNP_RESOURCE_TYPE_MEMRANGE32:
            {
                switch (DfState)
                {
                    case dfNotStarted:
                        ++FirstFixedDescriptors;
                        break;
 
                    case dfStarted:
                        ++ResourceCount;
                        break;
 
                    case dfDone:
                        ++LastFixedDescriptors;
                        break;
 
                    DEFAULT_UNREACHABLE;
                }
                break;
            }
 
            default:
                ASSERT(FALSE);
                UNREACHABLE;
                break;
        }
 
        ++Resource;
    }
 
    /* This logical device has no resource requirements */
    if ((ResourceCount == 0) && (FirstFixedDescriptors == 0) && (LastFixedDescriptors == 0))
        return STATUS_SUCCESS;
 
    /* Allocate memory to store requirements */
    ListSize = FIELD_OFFSET(IO_RESOURCE_REQUIREMENTS_LIST, List) +
               FIELD_OFFSET(IO_RESOURCE_LIST, Descriptors) * AltListCount +
               sizeof(IO_RESOURCE_DESCRIPTOR) * ResourceCount +
               sizeof(IO_RESOURCE_DESCRIPTOR) * AltListCount *
               (FirstFixedDescriptors + LastFixedDescriptors);
    RequirementsList = ExAllocatePoolZero(PagedPool, ListSize, TAG_ISAPNP);
    if (!RequirementsList)
        return STATUS_NO_MEMORY;
 
    RequirementsList->ListSize = ListSize;
    RequirementsList->InterfaceType = Isa;
    RequirementsList->AlternativeLists = AltListCount;
 
    RequirementsList->List[0].Version = 1;
    RequirementsList->List[0].Revision = 1;
 
    /* Store requirements */
    IsFirstAltList = TRUE;
    AltList = &RequirementsList->List[0];
    Descriptor = &RequirementsList->List[0].Descriptors[0];
    Resource = PdoExt->IsaPnpDevice->Resources;
    while (Resource->Type != ISAPNP_RESOURCE_TYPE_END)
    {
        switch (Resource->Type)
        {
            case ISAPNP_RESOURCE_TYPE_START_DEPENDENT:
            {
                if (!IsFirstAltList)
                {
                    /* Add room for the fixed descriptors */
                    AltList->Count += LastFixedDescriptors;
 
                    /* Move on to the next list */
                    AltList = (PIO_RESOURCE_LIST)(AltList->Descriptors + AltList->Count);
                    AltList->Version = 1;
                    AltList->Revision = 1;
 
                    /* Propagate the fixed resources to our new list */
                    RtlCopyMemory(&AltList->Descriptors,
                                  RequirementsList->List[0].Descriptors,
                                  sizeof(IO_RESOURCE_DESCRIPTOR) * FirstFixedDescriptors);
                    AltList->Count += FirstFixedDescriptors;
 
                    Descriptor = &AltList->Descriptors[FirstFixedDescriptors];
                }
 
                IsFirstAltList = FALSE;
                break;
            }
 
            case ISAPNP_RESOURCE_TYPE_END_DEPENDENT:
                break;
 
            case ISAPNP_RESOURCE_TYPE_IO:
            {
                IsaConvertIoRequirement(Descriptor++, &Resource->IoDescription);
 
                ++AltList->Count;
                break;
            }
 
            case ISAPNP_RESOURCE_TYPE_IRQ:
            {
                IsFirstDescriptor = TRUE;
 
                for (i = 0; i < RTL_BITS_OF(Resource->IrqDescription.Mask); i++)
                {
                    if (!(Resource->IrqDescription.Mask & (1 << i)))
                        continue;
 
                    IsaConvertIrqRequirement(Descriptor++,
                                             &Resource->IrqDescription,
                                             i,
                                             IsFirstDescriptor);
                    ++AltList->Count;
 
                    IsFirstDescriptor = FALSE;
                }
 
                break;
            }
 
            case ISAPNP_RESOURCE_TYPE_DMA:
            {
                IsFirstDescriptor = TRUE;
 
                for (i = 0; i < RTL_BITS_OF(Resource->DmaDescription.Mask); i++)
                {
                    if (!(Resource->DmaDescription.Mask & (1 << i)))
                        continue;
 
                    IsaConvertDmaRequirement(Descriptor++,
                                             &Resource->DmaDescription,
                                             i,
                                             IsFirstDescriptor);
                    ++AltList->Count;
 
                    IsFirstDescriptor = FALSE;
                }
 
                break;
            }
 
            case ISAPNP_RESOURCE_TYPE_MEMRANGE:
            {
                IsaConvertMemRangeRequirement(Descriptor++, &Resource->MemRangeDescription);
 
                ++AltList->Count;
                break;
            }
 
            case ISAPNP_RESOURCE_TYPE_MEMRANGE32:
            {
                IsaConvertMemRange32Requirement(Descriptor++, &Resource->MemRange32Description);
 
                ++AltList->Count;
                break;
            }
 
            default:
                ASSERT(FALSE);
                UNREACHABLE;
                break;
        }
 
        ++Resource;
    }
 
    /* Append the fixed resources */
    if (LastFixedDescriptors)
    {
        PIO_RESOURCE_LIST NextList = &RequirementsList->List[0];
 
        /* Make the descriptor point to the fixed resources */
        Descriptor -= LastFixedDescriptors;
 
        /* Propagate the fixed resources onto previous lists */
        AltListCount = RequirementsList->AlternativeLists - 1;
        for (i = 0; i < AltListCount; i++)
        {
            RtlCopyMemory(&NextList->Descriptors[NextList->Count - LastFixedDescriptors],
                          Descriptor,
                          sizeof(IO_RESOURCE_DESCRIPTOR) * LastFixedDescriptors);
 
            NextList = (PIO_RESOURCE_LIST)(NextList->Descriptors + NextList->Count);
        }
    }
 
    PdoExt->RequirementsList = RequirementsList;
    return STATUS_SUCCESS;
}

Referenced by DrvTestResources(), and IsaPnpFillDeviceRelations().

IsaPnpCreateLogicalDeviceResources()

static NTSTATUS IsaPnpCreateLogicalDeviceResources ( _In_ PISAPNP_PDO_EXTENSION  PdoExt )

static

Definition at line 625 of file isapnp.c.

{
    PISAPNP_LOGICAL_DEVICE LogDev = PdoExt->IsaPnpDevice;
    ULONG ResourceCount = 0;
    UCHAR Information;
    ULONG ListSize, i;
    PCM_RESOURCE_LIST ResourceList;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
 
    PAGED_CODE();
 
    if (!(LogDev->Flags & ISAPNP_HAS_RESOURCES))
        return STATUS_SUCCESS;
 
    /* Count number of required resources */
    for (i = 0; i < RTL_NUMBER_OF(LogDev->Io); i++)
    {
        if (LogDev->Io[i].CurrentBase)
            ResourceCount++;
        else
            break;
    }
    for (i = 0; i < RTL_NUMBER_OF(LogDev->Irq); i++)
    {
        if (LogDev->Irq[i].CurrentNo)
            ResourceCount++;
        else
            break;
    }
    for (i = 0; i < RTL_NUMBER_OF(LogDev->Dma); i++)
    {
        if (LogDev->Dma[i].CurrentChannel != DMACHANNEL_NONE)
            ResourceCount++;
        else
            break;
    }
    for (i = 0; i < RTL_NUMBER_OF(LogDev->MemRange); i++)
    {
        if (LogDev->MemRange[i].CurrentBase)
            ResourceCount++;
        else
            break;
    }
    for (i = 0; i < RTL_NUMBER_OF(LogDev->MemRange32); i++)
    {
        if (LogDev->MemRange32[i].CurrentBase)
            ResourceCount++;
        else
            break;
    }
    if (ResourceCount == 0)
        return STATUS_SUCCESS;
 
    /* Allocate memory to store resources */
    ListSize = sizeof(CM_RESOURCE_LIST)
               + (ResourceCount - 1) * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
    ResourceList = ExAllocatePoolZero(PagedPool, ListSize, TAG_ISAPNP);
    if (!ResourceList)
        return STATUS_NO_MEMORY;
 
    ResourceList->Count = 1;
    ResourceList->List[0].InterfaceType = Isa;
    ResourceList->List[0].PartialResourceList.Version = 1;
    ResourceList->List[0].PartialResourceList.Revision = 1;
    ResourceList->List[0].PartialResourceList.Count = ResourceCount;
 
    /* Store resources */
    ResourceCount = 0;
    for (i = 0; i < RTL_NUMBER_OF(LogDev->Io); i++)
    {
        ULONG CurrentLength;
 
        if (!LogDev->Io[i].CurrentBase)
            break;
 
        if (!FindIoDescriptor(LogDev,
                              LogDev->Io[i].CurrentBase,
                              0,
                              0,
                              &Information,
                              &CurrentLength))
        {
            DPRINT1("I/O entry #%lu %x not found\n", i, LogDev->Io[i].CurrentBase);
            goto InvalidBiosResources;
        }
 
        Descriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[ResourceCount++];
        Descriptor->Type = CmResourceTypePort;
        Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
        Descriptor->Flags = CM_RESOURCE_PORT_IO;
        if (Information & 0x1)
            Descriptor->Flags |= CM_RESOURCE_PORT_16_BIT_DECODE;
        else
            Descriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
        Descriptor->u.Port.Length = CurrentLength;
        Descriptor->u.Port.Start.LowPart = LogDev->Io[i].CurrentBase;
    }
    for (i = 0; i < RTL_NUMBER_OF(LogDev->Irq); i++)
    {
        if (!LogDev->Irq[i].CurrentNo)
            break;
 
        Descriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[ResourceCount++];
        Descriptor->Type = CmResourceTypeInterrupt;
        Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
        if (LogDev->Irq[i].CurrentType & 0x01)
            Descriptor->Flags = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
        else
            Descriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
        Descriptor->u.Interrupt.Level = LogDev->Irq[i].CurrentNo;
        Descriptor->u.Interrupt.Vector = LogDev->Irq[i].CurrentNo;
        Descriptor->u.Interrupt.Affinity = (KAFFINITY)-1;
    }
    for (i = 0; i < RTL_NUMBER_OF(LogDev->Dma); i++)
    {
        if (LogDev->Dma[i].CurrentChannel == DMACHANNEL_NONE)
            break;
 
        Descriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[ResourceCount++];
        Descriptor->Type = CmResourceTypeDma;
        Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
        Descriptor->Flags = CM_RESOURCE_DMA_8; /* Ignore information byte for compatibility */
        Descriptor->u.Dma.Channel = LogDev->Dma[i].CurrentChannel;
    }
    for (i = 0; i < RTL_NUMBER_OF(LogDev->MemRange); i++)
    {
        if (!LogDev->MemRange[i].CurrentBase)
            break;
 
        if (!FindMemoryDescriptor(LogDev,
                                  LogDev->MemRange[i].CurrentBase,
                                  LogDev->MemRange[i].CurrentLength,
                                  &Information))
        {
            DPRINT1("MEM entry #%lu %lx %lx not found\n",
                    i,
                    LogDev->MemRange[i].CurrentBase,
                    LogDev->MemRange[i].CurrentLength);
            goto InvalidBiosResources;
        }
 
        Descriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[ResourceCount++];
        Descriptor->Type = CmResourceTypeMemory;
        Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
        Descriptor->Flags = CM_RESOURCE_MEMORY_24;
        if ((Information & 0x40) || !(Information & 0x01))
            Descriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
        else
            Descriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
        Descriptor->u.Memory.Length = LogDev->MemRange[i].CurrentLength;
        Descriptor->u.Memory.Start.QuadPart = LogDev->MemRange[i].CurrentBase;
    }
    for (i = 0; i < RTL_NUMBER_OF(LogDev->MemRange32); i++)
    {
        if (!LogDev->MemRange32[i].CurrentBase)
            break;
 
        if (!FindMemoryDescriptor(LogDev,
                                  LogDev->MemRange32[i].CurrentBase,
                                  LogDev->MemRange32[i].CurrentLength,
                                  &Information))
        {
            DPRINT1("MEM32 entry #%lu %lx %lx not found\n",
                    i,
                    LogDev->MemRange32[i].CurrentBase,
                    LogDev->MemRange32[i].CurrentLength);
            goto InvalidBiosResources;
        }
 
        Descriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[ResourceCount++];
        Descriptor->Type = CmResourceTypeMemory;
        Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
        Descriptor->Flags = CM_RESOURCE_MEMORY_24;
        if ((Information & 0x40) || !(Information & 0x01))
            Descriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
        else
            Descriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
        Descriptor->u.Memory.Length = LogDev->MemRange32[i].CurrentLength;
        Descriptor->u.Memory.Start.QuadPart = LogDev->MemRange32[i].CurrentBase;
    }
 
    PdoExt->ResourceList = ResourceList;
    PdoExt->ResourceListSize = ListSize;
    return STATUS_SUCCESS;
 
InvalidBiosResources:
    DPRINT1("Invalid boot resources! (CSN %u, LDN %u)\n", LogDev->CSN, LogDev->LDN);
 
    LogDev->Flags &= ~ISAPNP_HAS_RESOURCES;
    ExFreePoolWithTag(ResourceList, TAG_ISAPNP);
    return STATUS_SUCCESS;
}

Referenced by DrvTestResources(), and IsaPnpFillDeviceRelations().

IsaPnpCreateReadPortDO()

static NTSTATUS IsaPnpCreateReadPortDO ( _In_ PISAPNP_FDO_EXTENSION  FdoExt )

static

Definition at line 1007 of file isapnp.c.

{
    PISAPNP_PDO_EXTENSION PdoExt;
    NTSTATUS Status;
 
    PAGED_CODE();
    ASSERT(ReadPortCreated == FALSE);
 
    DPRINT("Creating Read Port\n");
 
    Status = IoCreateDevice(FdoExt->DriverObject,
                            sizeof(ISAPNP_PDO_EXTENSION),
                            NULL,
                            FILE_DEVICE_CONTROLLER,
                            FILE_DEVICE_SECURE_OPEN | FILE_AUTOGENERATED_DEVICE_NAME,
                            FALSE,
                            &FdoExt->ReadPortPdo);
    if (!NT_SUCCESS(Status))
        return Status;
 
    PdoExt = FdoExt->ReadPortPdo->DeviceExtension;
    RtlZeroMemory(PdoExt, sizeof(ISAPNP_PDO_EXTENSION));
    PdoExt->Common.Signature = IsaPnpReadDataPort;
    PdoExt->Common.Self = FdoExt->ReadPortPdo;
    PdoExt->Common.State = dsStopped;
    PdoExt->FdoExt = FdoExt;
 
    FdoExt->ReadPortPdo->Flags &= ~DO_DEVICE_INITIALIZING;
 
    return Status;
}

Referenced by IsaPnpFillDeviceRelations().

IsaPnpCreateReadPortDORequirements()

PIO_RESOURCE_REQUIREMENTS_LIST IsaPnpCreateReadPortDORequirements

(

_In_opt_ ULONG

SelectedReadPort

)

Definition at line 821 of file isapnp.c.

{
    ULONG ResourceCount, ListSize, i;
    PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList;
    PIO_RESOURCE_DESCRIPTOR Descriptor;
    const ULONG ReadPorts[] = { 0x274, 0x3E4, 0x204, 0x2E4, 0x354, 0x2F4 };
 
    PAGED_CODE();
 
    if (SelectedReadPort)
    {
        /*
         * [IO descriptor: ISAPNP_WRITE_DATA, required]
         * [IO descriptor: ISAPNP_WRITE_DATA, optional]
         * [IO descriptor: ISAPNP_ADDRESS, required]
         * [IO descriptor: ISAPNP_ADDRESS, optional]
         * [IO descriptor: Selected Read Port, required]
         * [IO descriptor: Read Port 1, optional]
         * [IO descriptor: Read Port 2, optional]
         * [...]
         * [IO descriptor: Read Port X - 1, optional]
         */
        ResourceCount = RTL_NUMBER_OF(IsaConfigPorts) * 2 + RTL_NUMBER_OF(ReadPorts);
    }
    else
    {
        /*
         * [IO descriptor: ISAPNP_WRITE_DATA, required]
         * [IO descriptor: ISAPNP_WRITE_DATA, optional]
         * [IO descriptor: ISAPNP_ADDRESS, required]
         * [IO descriptor: ISAPNP_ADDRESS, optional]
         * [IO descriptor: Read Port 1, required]
         * [IO descriptor: Read Port 1, optional]
         * [IO descriptor: Read Port 2, required]
         * [IO descriptor: Read Port 2, optional]
         * [...]
         * [IO descriptor: Read Port X, required]
         * [IO descriptor: Read Port X, optional]
         */
        ResourceCount = (RTL_NUMBER_OF(IsaConfigPorts) + RTL_NUMBER_OF(ReadPorts)) * 2;
    }
    ListSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST) +
               sizeof(IO_RESOURCE_DESCRIPTOR) * (ResourceCount - 1);
    RequirementsList = ExAllocatePoolZero(PagedPool, ListSize, TAG_ISAPNP);
    if (!RequirementsList)
        return NULL;
 
    RequirementsList->ListSize = ListSize;
    RequirementsList->AlternativeLists = 1;
 
    RequirementsList->List[0].Version = 1;
    RequirementsList->List[0].Revision = 1;
    RequirementsList->List[0].Count = ResourceCount;
 
    Descriptor = &RequirementsList->List[0].Descriptors[0];
 
    /* Store the Data port and the Address port */
    for (i = 0; i < RTL_NUMBER_OF(IsaConfigPorts) * 2; i++)
    {
        if ((i % 2) == 0)
        {
            /* Expected port */
            Descriptor->Type = CmResourceTypePort;
            Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
            Descriptor->Flags = CM_RESOURCE_PORT_16_BIT_DECODE;
            Descriptor->u.Port.Length = 0x01;
            Descriptor->u.Port.Alignment = 0x01;
            Descriptor->u.Port.MinimumAddress.LowPart =
            Descriptor->u.Port.MaximumAddress.LowPart = IsaConfigPorts[i / 2];
        }
        else
        {
            /* ... but mark it as optional */
            Descriptor->Option = IO_RESOURCE_ALTERNATIVE;
            Descriptor->Type = CmResourceTypePort;
            Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
            Descriptor->Flags = CM_RESOURCE_PORT_16_BIT_DECODE;
            Descriptor->u.Port.Alignment = 0x01;
        }
 
        Descriptor++;
    }
 
    /* Store the Read Ports */
    if (SelectedReadPort)
    {
        BOOLEAN Selected = FALSE;
 
        DBG_UNREFERENCED_LOCAL_VARIABLE(Selected);
 
        for (i = 0; i < RTL_NUMBER_OF(ReadPorts); i++)
        {
            if (ReadPorts[i] != SelectedReadPort)
                Descriptor->Option = IO_RESOURCE_ALTERNATIVE;
            else
                Selected = TRUE;
            Descriptor->Type = CmResourceTypePort;
            Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
            Descriptor->Flags = CM_RESOURCE_PORT_16_BIT_DECODE;
            Descriptor->u.Port.Length = 0x04;
            Descriptor->u.Port.Alignment = 0x01;
            Descriptor->u.Port.MinimumAddress.LowPart = ReadPorts[i];
            Descriptor->u.Port.MaximumAddress.LowPart = ReadPorts[i] +
                                                        Descriptor->u.Port.Length - 1;
 
            Descriptor++;
        }
 
        ASSERT(Selected == TRUE);
    }
    else
    {
        for (i = 0; i < RTL_NUMBER_OF(ReadPorts) * 2; i++)
        {
            if ((i % 2) == 0)
            {
                /* Expected port */
                Descriptor->Type = CmResourceTypePort;
                Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                Descriptor->Flags = CM_RESOURCE_PORT_16_BIT_DECODE;
                Descriptor->u.Port.Length = 0x04;
                Descriptor->u.Port.Alignment = 0x01;
                Descriptor->u.Port.MinimumAddress.LowPart = ReadPorts[i / 2];
                Descriptor->u.Port.MaximumAddress.LowPart = ReadPorts[i / 2] +
                                                            Descriptor->u.Port.Length - 1;
            }
            else
            {
                /* ... but mark it as optional */
                Descriptor->Option = IO_RESOURCE_ALTERNATIVE;
                Descriptor->Type = CmResourceTypePort;
                Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
                Descriptor->Flags = CM_RESOURCE_PORT_16_BIT_DECODE;
                Descriptor->u.Port.Alignment = 0x01;
            }
 
            Descriptor++;
        }
    }
 
    return RequirementsList;
}

Referenced by DrvTestReadDataPortQueryResourcesRequirementsForEnum(), DrvTestReadDataPortQueryResourcesRequirementsForRebalance(), and IsaPdoQueryResourceRequirements().

IsaPnpCreateReadPortDOResources()

PCM_RESOURCE_LIST IsaPnpCreateReadPortDOResources

(

VOID

)

Definition at line 967 of file isapnp.c.

{
    ULONG ListSize, i;
    PCM_RESOURCE_LIST ResourceList;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
 
    PAGED_CODE();
 
    ListSize = sizeof(CM_RESOURCE_LIST) +
               sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) * (RTL_NUMBER_OF(IsaConfigPorts) - 1);
    ResourceList = ExAllocatePoolZero(PagedPool, ListSize, TAG_ISAPNP);
    if (!ResourceList)
        return NULL;
 
    ResourceList->Count = 1;
    ResourceList->List[0].InterfaceType = Internal;
    ResourceList->List[0].PartialResourceList.Version = 1;
    ResourceList->List[0].PartialResourceList.Revision = 1;
    ResourceList->List[0].PartialResourceList.Count = RTL_NUMBER_OF(IsaConfigPorts);
 
    Descriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[0];
    for (i = 0; i < RTL_NUMBER_OF(IsaConfigPorts); i++)
    {
        Descriptor->Type = CmResourceTypePort;
        Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
        Descriptor->Flags = CM_RESOURCE_PORT_16_BIT_DECODE;
        Descriptor->u.Port.Length = 0x01;
        Descriptor->u.Port.Start.LowPart = IsaConfigPorts[i];
 
        Descriptor++;
    }
 
    return ResourceList;
}

Referenced by DrvTestReadDataPortQueryResources(), and IsaPdoQueryResources().

IsaPnpFillDeviceRelations()

NTSTATUS IsaPnpFillDeviceRelations	(	_In_ PISAPNP_FDO_EXTENSION	FdoExt,
		_Inout_ PIRP	Irp,
		_In_ BOOLEAN	IncludeDataPort
	)

Definition at line 1054 of file isapnp.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PLIST_ENTRY CurrentEntry;
    PISAPNP_LOGICAL_DEVICE IsaDevice;
    PDEVICE_RELATIONS DeviceRelations;
    ULONG PdoCount, i = 0;
 
    PAGED_CODE();
 
    IsaPnpAcquireBusDataLock();
 
    /* Try to claim the Read Port for our FDO */
    if (!ReadPortCreated)
    {
        Status = IsaPnpCreateReadPortDO(FdoExt);
        if (!NT_SUCCESS(Status))
            return Status;
 
        ReadPortCreated = TRUE;
    }
 
    IsaPnpReleaseBusDataLock();
 
    /* Inactive ISA bus */
    if (!FdoExt->ReadPortPdo)
        IncludeDataPort = FALSE;
 
    IsaPnpAcquireDeviceDataLock(FdoExt);
 
    /* If called from the FDO dispatch routine && Active bus */
    if (IncludeDataPort && FdoExt->ReadPortPdo)
    {
        PISAPNP_PDO_EXTENSION ReadPortExt = FdoExt->ReadPortPdo->DeviceExtension;
 
        if ((ReadPortExt->Flags & ISAPNP_READ_PORT_ALLOW_FDO_SCAN) &&
            !(ReadPortExt->Flags & ISAPNP_SCANNED_BY_READ_PORT))
        {
            DPRINT("Rescan ISA PnP bus\n");
 
            /* Run the isolation protocol */
            FdoExt->Cards = IsaHwTryReadDataPort(FdoExt->ReadDataPort);
 
            /* Card identification */
            if (FdoExt->Cards > 0)
                (VOID)IsaHwFillDeviceList(FdoExt);
 
            IsaHwWaitForKey();
        }
 
        ReadPortExt->Flags &= ~ISAPNP_SCANNED_BY_READ_PORT;
    }
 
    PdoCount = FdoExt->DeviceCount;
    if (IncludeDataPort)
        ++PdoCount;
 
    CurrentEntry = FdoExt->DeviceListHead.Flink;
    while (CurrentEntry != &FdoExt->DeviceListHead)
    {
        IsaDevice = CONTAINING_RECORD(CurrentEntry, ISAPNP_LOGICAL_DEVICE, DeviceLink);
 
        if (!(IsaDevice->Flags & ISAPNP_PRESENT))
            --PdoCount;
 
        CurrentEntry = CurrentEntry->Flink;
    }
 
    DeviceRelations = ExAllocatePoolWithTag(PagedPool,
                                            FIELD_OFFSET(DEVICE_RELATIONS, Objects[PdoCount]),
                                            TAG_ISAPNP);
    if (!DeviceRelations)
    {
        IsaPnpReleaseDeviceDataLock(FdoExt);
        return STATUS_NO_MEMORY;
    }
 
    if (IncludeDataPort)
    {
        PISAPNP_PDO_EXTENSION ReadPortExt = FdoExt->ReadPortPdo->DeviceExtension;
 
        DeviceRelations->Objects[i++] = FdoExt->ReadPortPdo;
        ObReferenceObject(FdoExt->ReadPortPdo);
 
        /* The Read Port PDO can only be removed by FDO */
        ReadPortExt->Flags |= ISAPNP_ENUMERATED;
    }
 
    CurrentEntry = FdoExt->DeviceListHead.Flink;
    while (CurrentEntry != &FdoExt->DeviceListHead)
    {
        PISAPNP_PDO_EXTENSION PdoExt;
 
        IsaDevice = CONTAINING_RECORD(CurrentEntry, ISAPNP_LOGICAL_DEVICE, DeviceLink);
 
        if (!(IsaDevice->Flags & ISAPNP_PRESENT))
            goto SkipPdo;
 
        if (!IsaDevice->Pdo)
        {
            Status = IoCreateDevice(FdoExt->DriverObject,
                                    sizeof(ISAPNP_PDO_EXTENSION),
                                    NULL,
                                    FILE_DEVICE_CONTROLLER,
                                    FILE_DEVICE_SECURE_OPEN | FILE_AUTOGENERATED_DEVICE_NAME,
                                    FALSE,
                                    &IsaDevice->Pdo);
            if (!NT_SUCCESS(Status))
                goto SkipPdo;
 
            IsaDevice->Pdo->Flags &= ~DO_DEVICE_INITIALIZING;
            /* The power pagable flag is always unset */
 
            PdoExt = IsaDevice->Pdo->DeviceExtension;
 
            RtlZeroMemory(PdoExt, sizeof(ISAPNP_PDO_EXTENSION));
            PdoExt->Common.Signature = IsaPnpLogicalDevice;
            PdoExt->Common.Self = IsaDevice->Pdo;
            PdoExt->Common.State = dsStopped;
            PdoExt->IsaPnpDevice = IsaDevice;
            PdoExt->FdoExt = FdoExt;
 
            if (!NT_SUCCESS(IsaPnpCreateLogicalDeviceRequirements(PdoExt)) ||
                !NT_SUCCESS(IsaPnpCreateLogicalDeviceResources(PdoExt)))
            {
                if (PdoExt->RequirementsList)
                {
                    ExFreePoolWithTag(PdoExt->RequirementsList, TAG_ISAPNP);
                    PdoExt->RequirementsList = NULL;
                }
 
                if (PdoExt->ResourceList)
                {
                    ExFreePoolWithTag(PdoExt->ResourceList, TAG_ISAPNP);
                    PdoExt->ResourceList = NULL;
                }
 
                IoDeleteDevice(IsaDevice->Pdo);
                IsaDevice->Pdo = NULL;
                goto SkipPdo;
            }
        }
        else
        {
            PdoExt = IsaDevice->Pdo->DeviceExtension;
        }
        DeviceRelations->Objects[i++] = IsaDevice->Pdo;
        ObReferenceObject(IsaDevice->Pdo);
 
        PdoExt->Flags |= ISAPNP_ENUMERATED;
 
        CurrentEntry = CurrentEntry->Flink;
        continue;
 
SkipPdo:
        if (IsaDevice->Pdo)
        {
            PdoExt = IsaDevice->Pdo->DeviceExtension;
 
            if (PdoExt)
                PdoExt->Flags &= ~ISAPNP_ENUMERATED;
        }
 
        CurrentEntry = CurrentEntry->Flink;
    }
 
    IsaPnpReleaseDeviceDataLock(FdoExt);
 
    DeviceRelations->Count = i;
 
    Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
 
    return Status;
}

Referenced by IsaFdoQueryBusRelations(), and IsaPdoQueryDeviceRelations().

IsaPnpRemoveReadPortDO()

VOID IsaPnpRemoveReadPortDO

(

_In_ PDEVICE_OBJECT

Pdo

)

Definition at line 1042 of file isapnp.c.

{
    PAGED_CODE();
 
    DPRINT("Removing Read Port\n");
 
    IoDeleteDevice(Pdo);
}

Referenced by IsaFdoRemoveDevice(), and IsaReadPortRemoveDevice().

Variable Documentation

BusSyncEvent

KEVENT BusSyncEvent

Definition at line 21 of file isapnp.c.

Referenced by _Releases_lock_(), _Requires_lock_not_held_(), and DriverEntry().