isapnp.h File Reference

#include <ntddk.h>
#include <ntstrsafe.h>
#include <section_attribs.h>
#include "isapnphw.h"
#include "isapnpres.h"
#include <initguid.h>
#include <wdmguid.h>

Include dependency graph for isapnp.h:

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

Go to the source code of this file.

Classes
struct	_ISAPNP_COMMON_EXTENSION
struct	_ISAPNP_FDO_EXTENSION
struct	_ISAPNP_PDO_EXTENSION

Macros
#define	TAG_ISAPNP   'pasI'
#define	ISAPNP_ENUMERATED   0x00000001
	Whether the device has been reported to the PnP manager.
#define	ISAPNP_SCANNED_BY_READ_PORT   0x00000002
	The bus has been scanned by Read Port PDO.
#define	ISAPNP_READ_PORT_ALLOW_FDO_SCAN   0x00000004
	Allows the active FDO to scan the bus.
#define	ISAPNP_READ_PORT_NEED_REBALANCE   0x00000008
	The I/O resource requirements have changed.

Typedefs
typedef enum _ISAPNP_SIGNATURE	ISAPNP_SIGNATURE
typedef struct _ISAPNP_COMMON_EXTENSION	ISAPNP_COMMON_EXTENSION
typedef struct _ISAPNP_COMMON_EXTENSION *	PISAPNP_COMMON_EXTENSION
typedef struct _ISAPNP_FDO_EXTENSION	ISAPNP_FDO_EXTENSION
typedef struct _ISAPNP_FDO_EXTENSION *	PISAPNP_FDO_EXTENSION
typedef struct _ISAPNP_PDO_EXTENSION	ISAPNP_PDO_EXTENSION
typedef struct _ISAPNP_PDO_EXTENSION *	PISAPNP_PDO_EXTENSION

Enumerations
enum	ISAPNP_DEVICE_STATE { dsStopped , dsStarted }
enum	_ISAPNP_SIGNATURE { IsaPnpBus = 'odFI' , IsaPnpLogicalDevice = 'veDI' , IsaPnpReadDataPort = 'pdRI' }

Functions
	_Guarded_by_ (BusSyncEvent) extern BOOLEAN ReadPortCreated
	_Requires_lock_not_held_ (BusSyncEvent) _Acquires_lock_(BusSyncEvent) FORCEINLINE VOID IsaPnpAcquireBusDataLock(VOID)
	_Releases_lock_ (BusSyncEvent) FORCEINLINE VOID IsaPnpReleaseBusDataLock(VOID)
	_Requires_lock_not_held_ (FdoExt->DeviceSyncEvent) _Acquires_lock_(FdoExt -> DeviceSyncEvent) FORCEINLINE VOID IsaPnpAcquireDeviceDataLock(_In_ PISAPNP_FDO_EXTENSION FdoExt)
	_Releases_lock_ (FdoExt->DeviceSyncEvent) FORCEINLINE VOID IsaPnpReleaseDeviceDataLock(_In_ PISAPNP_FDO_EXTENSION FdoExt)
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)
PIO_RESOURCE_REQUIREMENTS_LIST	IsaPnpCreateReadPortDORequirements (_In_opt_ ULONG SelectedReadPort)
PCM_RESOURCE_LIST	IsaPnpCreateReadPortDOResources (VOID)
VOID	IsaPnpRemoveReadPortDO (_In_ PDEVICE_OBJECT Pdo)
NTSTATUS	IsaPnpFillDeviceRelations (_In_ PISAPNP_FDO_EXTENSION FdoExt, _Inout_ PIRP Irp, _In_ BOOLEAN IncludeDataPort)
NTSTATUS	IsaFdoPnp (_In_ PISAPNP_FDO_EXTENSION FdoExt, _Inout_ PIRP Irp, _In_ PIO_STACK_LOCATION IrpSp)
NTSTATUS	IsaFdoQueryInterface (_In_ PISAPNP_FDO_EXTENSION FdoExt, _In_ PIO_STACK_LOCATION IrpSp)
NTSTATUS	IsaPdoPnp (_In_ PISAPNP_PDO_EXTENSION PdoDeviceExtension, _Inout_ PIRP Irp, _In_ PIO_STACK_LOCATION IrpSp)
VOID	IsaPnpRemoveLogicalDeviceDO (_In_ PDEVICE_OBJECT Pdo)
UCHAR	IsaHwTryReadDataPort (_In_ PUCHAR ReadDataPort)
	_Requires_lock_held_ (FdoExt->DeviceSyncEvent) NTSTATUS IsaHwFillDeviceList(_In_ PISAPNP_FDO_EXTENSION FdoExt)
NTSTATUS	IsaHwConfigureDevice (_In_ PISAPNP_FDO_EXTENSION FdoExt, _In_ PISAPNP_LOGICAL_DEVICE LogicalDevice, _In_ PCM_RESOURCE_LIST Resources)
VOID	IsaHwWakeDevice (_In_ PISAPNP_LOGICAL_DEVICE LogicalDevice)
VOID	IsaHwDeactivateDevice (_In_ PISAPNP_LOGICAL_DEVICE LogicalDevice)
VOID	IsaHwActivateDevice (_In_ PISAPNP_FDO_EXTENSION FdoExt, _In_ PISAPNP_LOGICAL_DEVICE LogicalDevice)
VOID	IsaHwWaitForKey (VOID)

Variables
KEVENT	BusSyncEvent
DRIVER_INITIALIZE	DriverEntry

Macro Definition Documentation

ISAPNP_ENUMERATED

#define ISAPNP_ENUMERATED   0x00000001

Whether the device has been reported to the PnP manager.

Definition at line 75 of file isapnp.h.

ISAPNP_READ_PORT_ALLOW_FDO_SCAN

#define ISAPNP_READ_PORT_ALLOW_FDO_SCAN   0x00000004

Allows the active FDO to scan the bus.

Definition at line 77 of file isapnp.h.

ISAPNP_READ_PORT_NEED_REBALANCE

#define ISAPNP_READ_PORT_NEED_REBALANCE   0x00000008

The I/O resource requirements have changed.

Definition at line 78 of file isapnp.h.

ISAPNP_SCANNED_BY_READ_PORT

#define ISAPNP_SCANNED_BY_READ_PORT   0x00000002

The bus has been scanned by Read Port PDO.

Definition at line 76 of file isapnp.h.

TAG_ISAPNP

#define TAG_ISAPNP   'pasI'

Definition at line 26 of file isapnp.h.

Typedef Documentation

ISAPNP_COMMON_EXTENSION

typedef struct _ISAPNP_COMMON_EXTENSION ISAPNP_COMMON_EXTENSION

ISAPNP_FDO_EXTENSION

typedef struct _ISAPNP_FDO_EXTENSION ISAPNP_FDO_EXTENSION

ISAPNP_PDO_EXTENSION

typedef struct _ISAPNP_PDO_EXTENSION ISAPNP_PDO_EXTENSION

ISAPNP_SIGNATURE

typedef enum _ISAPNP_SIGNATURE ISAPNP_SIGNATURE

PISAPNP_COMMON_EXTENSION

typedef struct _ISAPNP_COMMON_EXTENSION * PISAPNP_COMMON_EXTENSION

PISAPNP_FDO_EXTENSION

typedef struct _ISAPNP_FDO_EXTENSION * PISAPNP_FDO_EXTENSION

PISAPNP_PDO_EXTENSION

typedef struct _ISAPNP_PDO_EXTENSION * PISAPNP_PDO_EXTENSION

Enumeration Type Documentation

_ISAPNP_SIGNATURE

enum _ISAPNP_SIGNATURE

Enumerator
IsaPnpBus
IsaPnpLogicalDevice
IsaPnpReadDataPort

Definition at line 34 of file isapnp.h.

{
    IsaPnpBus = 'odFI',
    IsaPnpLogicalDevice = 'veDI',
    IsaPnpReadDataPort = 'pdRI'
} ISAPNP_SIGNATURE;

ISAPNP_DEVICE_STATE

enum ISAPNP_DEVICE_STATE

Enumerator
dsStopped
dsStarted

Definition at line 28 of file isapnp.h.

{
    dsStopped,
    dsStarted
} ISAPNP_DEVICE_STATE;

Function Documentation

_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;
}

_Releases_lock_() [1/2]

_Releases_lock_

(

BusSyncEvent

)

Definition at line 119 of file isapnp.h.

{
    KeSetEvent(&BusSyncEvent, IO_NO_INCREMENT, FALSE);
}

_Releases_lock_() [2/2]

_Releases_lock_

(

FdoExt->

DeviceSyncEvent

)

Definition at line 139 of file isapnp.h.

{
    KeSetEvent(&FdoExt->DeviceSyncEvent, IO_NO_INCREMENT, FALSE);
}

_Requires_lock_held_()

_Requires_lock_held_

(

FdoExt->

DeviceSyncEvent

)

Definition at line 1351 of file hardware.c.

{
    PISAPNP_LOGICAL_DEVICE LogDevice;
    UCHAR Csn;
    PLIST_ENTRY Entry;
    PUCHAR ResourceData;
 
    PAGED_CODE();
    ASSERT(FdoExt->ReadDataPort);
 
    DPRINT("%s for read port 0x%p\n", __FUNCTION__, FdoExt->ReadDataPort);
 
    ResourceData = ExAllocatePoolWithTag(PagedPool, ISAPNP_MAX_RESOURCEDATA, TAG_ISAPNP);
    if (!ResourceData)
    {
        DPRINT1("Failed to allocate memory for cache data\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    for (Entry = FdoExt->DeviceListHead.Flink;
         Entry != &FdoExt->DeviceListHead;
         Entry = Entry->Flink)
    {
        LogDevice = CONTAINING_RECORD(Entry, ISAPNP_LOGICAL_DEVICE, DeviceLink);
 
        LogDevice->Flags &= ~ISAPNP_PRESENT;
    }
 
    for (Csn = 1; Csn <= FdoExt->Cards; Csn++)
    {
        NTSTATUS Status;
        UCHAR TempId[3], LogDev;
        ISAPNP_IDENTIFIER Identifier;
        ULONG MaxTagsPerDevice;
        USHORT MaxLogDev;
 
        Wake(Csn);
 
        Peek(FdoExt->ReadDataPort, &Identifier, sizeof(Identifier));
 
        IsaPnpExtractAscii(TempId, Identifier.VendorId);
        Identifier.ProdId = RtlUshortByteSwap(Identifier.ProdId);
 
        Status = ReadTags(FdoExt->ReadDataPort,
                          ResourceData,
                          ISAPNP_MAX_RESOURCEDATA,
                          &MaxLogDev,
                          &MaxTagsPerDevice);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to read tags with status 0x%08lx, CSN %u\n", Status, Csn);
            continue;
        }
 
        DPRINT("Detected ISA PnP device - VID: '%.3s' PID: 0x%04x SN: 0x%08lX\n",
               TempId, Identifier.ProdId, Identifier.Serial);
 
        for (LogDev = 0; LogDev < MaxLogDev; LogDev++)
        {
            BOOLEAN IsAlreadyEnumerated = FALSE;
 
#ifndef UNIT_TEST
            for (Entry = FdoExt->DeviceListHead.Flink;
                 Entry != &FdoExt->DeviceListHead;
                 Entry = Entry->Flink)
            {
                LogDevice = CONTAINING_RECORD(Entry, ISAPNP_LOGICAL_DEVICE, DeviceLink);
 
                /* This logical device has already been enumerated */
                if ((LogDevice->SerialNumber == Identifier.Serial) &&
                    (RtlCompareMemory(LogDevice->VendorId, TempId, 3) == 3) &&
                    (LogDevice->ProdId == Identifier.ProdId) &&
                    (LogDevice->LDN == LogDev))
                {
                    LogDevice->Flags |= ISAPNP_PRESENT;
 
                    /* Assign a new CSN */
                    LogDevice->CSN = Csn;
 
                    if (LogDevice->Pdo)
                    {
                        PISAPNP_PDO_EXTENSION PdoExt = LogDevice->Pdo->DeviceExtension;
 
                        if (PdoExt->Common.State == dsStarted)
                            ActivateDevice(FdoExt->ReadDataPort, LogDev);
                    }
 
                    DPRINT("Skip CSN %u, LDN %u\n", LogDevice->CSN, LogDevice->LDN);
                    IsAlreadyEnumerated = TRUE;
                    break;
                }
            }
#endif /* UNIT_TEST */
 
            if (IsAlreadyEnumerated)
                continue;
 
            LogDevice = ExAllocatePoolZero(NonPagedPool, sizeof(ISAPNP_LOGICAL_DEVICE), TAG_ISAPNP);
            if (!LogDevice)
            {
                DPRINT1("Failed to allocate logical device!\n");
                goto Deactivate;
            }
 
            InitializeListHead(&LogDevice->CompatibleIdList);
 
            LogDevice->CSN = Csn;
            LogDevice->LDN = LogDev;
 
            LogDevice->Resources = ExAllocatePoolWithTag(PagedPool,
                                                         MaxTagsPerDevice * sizeof(ISAPNP_RESOURCE),
                                                         TAG_ISAPNP);
            if (!LogDevice->Resources)
            {
                DPRINT1("Failed to allocate the resources array\n");
                FreeLogicalDevice(LogDevice);
                goto Deactivate;
            }
 
            Status = ParseTags(ResourceData, LogDev, LogDevice);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Failed to parse tags with status 0x%08lx, CSN %u, LDN %u\n",
                        Status, LogDevice->CSN, LogDevice->LDN);
                FreeLogicalDevice(LogDevice);
                goto Deactivate;
            }
 
            if (!ReadCurrentResources(FdoExt->ReadDataPort, LogDevice))
                DPRINT("Unable to read boot resources\n");
 
            IsaPnpExtractAscii(LogDevice->VendorId, Identifier.VendorId);
            LogDevice->ProdId = Identifier.ProdId;
            LogDevice->SerialNumber = Identifier.Serial;
 
            if (MaxLogDev > 1)
                LogDevice->Flags |= ISAPNP_HAS_MULTIPLE_LOGDEVS;
 
            LogDevice->Flags |= ISAPNP_PRESENT;
 
            InsertTailList(&FdoExt->DeviceListHead, &LogDevice->DeviceLink);
            FdoExt->DeviceCount++;
 
            /* Now we wait for the start device IRP */
Deactivate:
            DeactivateDevice(LogDev);
        }
    }
 
    ExFreePoolWithTag(ResourceData, TAG_ISAPNP);
 
    return STATUS_SUCCESS;
}

_Requires_lock_not_held_() [1/2]

_Requires_lock_not_held_

(

BusSyncEvent

)

Definition at line 108 of file isapnp.h.

{
    ASSERT(PsGetCurrentProcess() == PsInitialSystemProcess);
 
    KeWaitForSingleObject(&BusSyncEvent, Executive, KernelMode, FALSE, NULL);
}

_Requires_lock_not_held_() [2/2]

_Requires_lock_not_held_

(

FdoExt->

DeviceSyncEvent

)

-> DeviceSyncEvent) FORCEINLINE VOID IsaPnpAcquireDeviceDataLock( _In_ PISAPNP_FDO_EXTENSION FdoExt)

Definition at line 127 of file isapnp.h.

{
    ASSERT(PsGetCurrentProcess() == PsInitialSystemProcess);
 
    KeWaitForSingleObject(&FdoExt->DeviceSyncEvent, Executive, KernelMode, FALSE, NULL);
}

FindDmaDescriptor()

BOOLEAN FindDmaDescriptor	(	_In_ PISAPNP_LOGICAL_DEVICE	LogDevice,
		_In_ ULONG	Channel
	)

Definition at line 533 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 457 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 506 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 560 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().

IsaFdoPnp()

NTSTATUS IsaFdoPnp	(	_In_ PISAPNP_FDO_EXTENSION	FdoExt,
		_Inout_ PIRP	Irp,
		_In_ PIO_STACK_LOCATION	IrpSp
	)

Definition at line 123 of file fdo.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    DPRINT("%s(%p, %p) FDO %lu, Minor - %X\n",
           __FUNCTION__,
           FdoExt,
           Irp,
           FdoExt->BusNumber,
           IrpSp->MinorFunction);
 
    switch (IrpSp->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
            Status = IsaFdoStartDevice(FdoExt, Irp);
 
            Irp->IoStatus.Status = Status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return Status;
 
        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
            if (IrpSp->Parameters.QueryDeviceRelations.Type != BusRelations)
                break;
 
            Status = IsaFdoQueryBusRelations(FdoExt, Irp);
            if (!NT_SUCCESS(Status))
            {
                Irp->IoStatus.Status = Status;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
                return Status;
            }
 
            Irp->IoStatus.Status = Status;
            break;
        }
 
        case IRP_MN_REMOVE_DEVICE:
            return IsaFdoRemoveDevice(FdoExt, Irp);
 
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            Irp->IoStatus.Information |= PNP_DEVICE_NOT_DISABLEABLE;
            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_QUERY_INTERFACE:
        {
            Status = IsaFdoQueryInterface(FdoExt, IrpSp);
            if (Status == STATUS_NOT_SUPPORTED)
            {
                break;
            }
            else if (!NT_SUCCESS(Status))
            {
                Irp->IoStatus.Status = Status;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
                return Status;
            }
 
            Irp->IoStatus.Status = Status;
            break;
        }
 
        case IRP_MN_SURPRISE_REMOVAL:
        case IRP_MN_QUERY_STOP_DEVICE:
        case IRP_MN_QUERY_REMOVE_DEVICE:
        case IRP_MN_CANCEL_STOP_DEVICE:
        case IRP_MN_CANCEL_REMOVE_DEVICE:
        case IRP_MN_STOP_DEVICE:
            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
 
        default:
            DPRINT("Unknown PnP code: %X\n", IrpSp->MinorFunction);
            break;
    }
 
    IoSkipCurrentIrpStackLocation(Irp);
 
    return IoCallDriver(FdoExt->Ldo, Irp);
}

Referenced by _Dispatch_type_().

IsaFdoQueryInterface()

NTSTATUS IsaFdoQueryInterface	(	_In_ PISAPNP_FDO_EXTENSION	FdoExt,
		_In_ PIO_STACK_LOCATION	IrpSp
	)

Definition at line 19 of file interface.c.

{
    PAGED_CODE();
 
    if (IsEqualGUIDAligned(IrpSp->Parameters.QueryInterface.InterfaceType,
                           &GUID_TRANSLATOR_INTERFACE_STANDARD))
    {
        NTSTATUS Status;
        CM_RESOURCE_TYPE ResourceType;
        ULONG ParentBusType, ParentBusNumber, Dummy;
 
        ResourceType = PtrToUlong(IrpSp->Parameters.QueryInterface.InterfaceSpecificData);
 
        if (IrpSp->Parameters.QueryInterface.Size < sizeof(TRANSLATOR_INTERFACE) ||
            ResourceType != CmResourceTypeInterrupt)
        {
            return STATUS_NOT_SUPPORTED;
        }
 
        Status = IoGetDeviceProperty(FdoExt->Pdo,
                                     DevicePropertyLegacyBusType,
                                     sizeof(ParentBusType),
                                     &ParentBusType,
                                     &Dummy);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("BusType request failed with status 0x%08lx\n", Status);
            return Status;
        }
 
        Status = IoGetDeviceProperty(FdoExt->Pdo,
                                     DevicePropertyBusNumber,
                                     sizeof(ParentBusNumber),
                                     &ParentBusNumber,
                                     &Dummy);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("BusNumber request failed with status 0x%08lx\n", Status);
            return Status;
        }
 
        return HalGetInterruptTranslator(ParentBusType,
                                         ParentBusNumber,
                                         Isa,
                                         IrpSp->Parameters.QueryInterface.Size,
                                         IrpSp->Parameters.QueryInterface.Version,
                                         (PTRANSLATOR_INTERFACE)IrpSp->
                                         Parameters.QueryInterface.Interface,
                                         &ParentBusNumber);
    }
 
    return STATUS_NOT_SUPPORTED;
}

Referenced by _Dispatch_type_(), and IsaFdoPnp().

IsaHwActivateDevice()

VOID IsaHwActivateDevice	(	_In_ PISAPNP_FDO_EXTENSION	FdoExt,
		_In_ PISAPNP_LOGICAL_DEVICE	LogicalDevice
	)

Definition at line 1655 of file hardware.c.

{
    PAGED_CODE();
 
    ActivateDevice(FdoExt->ReadDataPort, LogicalDevice->LDN);
}

Referenced by DrvTestResources(), and IsaPdoPnp().

IsaHwConfigureDevice()

NTSTATUS IsaHwConfigureDevice	(	_In_ PISAPNP_FDO_EXTENSION	FdoExt,
		_In_ PISAPNP_LOGICAL_DEVICE	LogicalDevice,
		_In_ PCM_RESOURCE_LIST	Resources
	)

Definition at line 1511 of file hardware.c.

{
    ULONG i;
    UCHAR NumberOfIo = 0,
          NumberOfIrq = 0,
          NumberOfDma = 0,
          NumberOfMemory = 0,
          NumberOfMemory32 = 0;
 
    PAGED_CODE();
 
    if (!Resources)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    WriteLogicalDeviceNumber(LogicalDevice->LDN);
 
    for (i = 0; i < Resources->List[0].PartialResourceList.Count; i++)
    {
        PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor =
            &Resources->List[0].PartialResourceList.PartialDescriptors[i];
 
        switch (Descriptor->Type)
        {
            case CmResourceTypePort:
            {
                if (NumberOfIo >= RTL_NUMBER_OF(LogicalDevice->Io))
                    return STATUS_INVALID_PARAMETER_1;
 
                IsaProgramIoDecoder(Descriptor, NumberOfIo++);
                break;
            }
 
            case CmResourceTypeInterrupt:
            {
                if (NumberOfIrq >= RTL_NUMBER_OF(LogicalDevice->Irq))
                    return STATUS_INVALID_PARAMETER_2;
 
                IsaProgramIrqSelect(Descriptor, NumberOfIrq++);
                break;
            }
 
            case CmResourceTypeDma:
            {
                if (NumberOfDma >= RTL_NUMBER_OF(LogicalDevice->Dma))
                    return STATUS_INVALID_PARAMETER_3;
 
                IsaProgramDmaSelect(Descriptor, NumberOfDma++);
                break;
            }
 
            case CmResourceTypeMemory:
            {
                BOOLEAN IsMemory32;
                UCHAR Index, Information;
                NTSTATUS Status;
 
                if ((NumberOfMemory + NumberOfMemory32) >= RTL_NUMBER_OF(LogicalDevice->MemRange))
                    return STATUS_INVALID_PARAMETER_4;
 
                /*
                 * The PNP ROM provides an information byte for each memory descriptor
                 * which is then used to program the memory control register.
                 */
                if (!FindMemoryDescriptor(LogicalDevice,
                                          Descriptor->u.Memory.Start.LowPart,
                                          Descriptor->u.Memory.Start.LowPart +
                                          Descriptor->u.Memory.Length - 1,
                                          &Information))
                {
                    return STATUS_RESOURCE_DATA_NOT_FOUND;
                }
 
                /* We can have a 24- or 32-bit memory decoder, but not both */
                IsMemory32 = !!(LogicalDevice->Flags & ISAPNP_HAS_MEM32_DECODER);
 
                if (IsMemory32)
                    Index = NumberOfMemory32++;
                else
                    Index = NumberOfMemory++;
 
                Status = IsaProgramMemoryDecoder(FdoExt->ReadDataPort,
                                                 Descriptor,
                                                 IsMemory32,
                                                 Information,
                                                 Index);
                if (!NT_SUCCESS(Status))
                    return Status;
 
                break;
            }
 
            default:
                break;
        }
    }
 
    /* Disable the unclaimed device resources */
    for (i = NumberOfIo; i < RTL_NUMBER_OF(LogicalDevice->Io); i++)
    {
        WriteWord(ISAPNP_IOBASE(i), 0);
    }
    for (i = NumberOfIrq; i < RTL_NUMBER_OF(LogicalDevice->Irq); i++)
    {
        WriteByte(ISAPNP_IRQNO(i), 0);
        WriteByte(ISAPNP_IRQTYPE(i), 0);
    }
    for (i = NumberOfDma; i < RTL_NUMBER_OF(LogicalDevice->Dma); i++)
    {
        WriteByte(ISAPNP_DMACHANNEL(i), DMACHANNEL_NONE);
    }
    for (i = NumberOfMemory; i < RTL_NUMBER_OF(LogicalDevice->MemRange); i++)
    {
        WriteWord(ISAPNP_MEMBASE(i), 0);
        WriteByte(ISAPNP_MEMCONTROL(i), 0);
        WriteWord(ISAPNP_MEMLIMIT(i), 0);
    }
    for (i = NumberOfMemory32; i < RTL_NUMBER_OF(LogicalDevice->MemRange32); i++)
    {
        WriteDoubleWord(ISAPNP_MEMBASE32(i), 0);
        WriteByte(ISAPNP_MEMCONTROL32(i), 0);
        WriteDoubleWord(ISAPNP_MEMLIMIT32(i), 0);
    }
 
    KeStallExecutionProcessor(10000);
 
    return STATUS_SUCCESS;
}

Referenced by DrvTestResources(), and IsaPdoPnp().

IsaHwDeactivateDevice()

VOID IsaHwDeactivateDevice

(

_In_ PISAPNP_LOGICAL_DEVICE

LogicalDevice

)

Definition at line 1667 of file hardware.c.

{
    PAGED_CODE();
 
    DeactivateDevice(LogicalDevice->LDN);
}

Referenced by IsaPdoPnp(), and IsaPdoRemoveDevice().

IsaHwTryReadDataPort()

UCHAR IsaHwTryReadDataPort

(

_In_ PUCHAR

ReadDataPort

)

Definition at line 1253 of file hardware.c.

{
    ULONG NumberOfRead = 0;
    UCHAR Csn = 0;
 
    PAGED_CODE();
 
    DPRINT("Setting read data port: 0x%p\n", ReadDataPort);
 
    SendKey();
 
    WriteByte(ISAPNP_CONFIGCONTROL,
              ISAPNP_CONFIG_RESET_CSN | ISAPNP_CONFIG_WAIT_FOR_KEY);
    KeStallExecutionProcessor(2000);
 
    SendKey();
 
    Wake(0x00);
    KeStallExecutionProcessor(1000);
 
    SetReadDataPort(ReadDataPort);
 
    Wake(0x00);
 
    while (TRUE)
    {
        ISAPNP_IDENTIFIER Identifier;
        UCHAR i, j;
        BOOLEAN Seen55aa = FALSE;
 
        EnterIsolationState();
        KeStallExecutionProcessor(1000);
 
        RtlZeroMemory(&Identifier, sizeof(Identifier));
 
        for (i = 0; i < sizeof(Identifier); i++)
        {
            UCHAR Byte = 0;
 
            for (j = 0; j < RTL_BITS_OF(Byte); j++)
            {
                USHORT Data;
 
                Data = ReadData(ReadDataPort) << 8;
                KeStallExecutionProcessor(250);
                Data |= ReadData(ReadDataPort);
                KeStallExecutionProcessor(250);
 
                Byte >>= 1;
 
                if (Data == 0x55AA)
                {
                    Byte |= 0x80;
                    Seen55aa = TRUE;
                }
            }
 
            ((PUCHAR)&Identifier)[i] = Byte;
        }
 
        ++NumberOfRead;
 
        if (Identifier.Checksum != 0x00 &&
            Identifier.Checksum != IsaPnpChecksum(&Identifier))
        {
            DPRINT("Bad checksum\n");
            break;
        }
 
        if (!Seen55aa)
        {
            DPRINT("Saw no sign of life\n");
            break;
        }
 
        Csn++;
 
        WriteCsn(Csn);
        KeStallExecutionProcessor(1000);
 
        Wake(0x00);
    }
 
    Wake(0x00);
 
    if (NumberOfRead == 1)
    {
        DPRINT("Trying next read data port\n");
        return 0;
    }
    else
    {
        DPRINT("Found %u cards at read port 0x%p\n", Csn, ReadDataPort);
        return Csn;
    }
}

Referenced by DrvTestIsolation(), IsaPdoStartReadPort(), and IsaPnpFillDeviceRelations().

IsaHwWaitForKey()

VOID IsaHwWaitForKey

(

VOID

)

Definition at line 1678 of file hardware.c.

{
    PAGED_CODE();
 
    WaitForKey();
}

Referenced by DrvTestIsolation(), DrvTestResources(), IsaPdoPnp(), IsaPdoRemoveDevice(), IsaPdoStartReadPort(), and IsaPnpFillDeviceRelations().

IsaHwWakeDevice()

VOID IsaHwWakeDevice

(

_In_ PISAPNP_LOGICAL_DEVICE

LogicalDevice

)

Definition at line 1644 of file hardware.c.

{
    PAGED_CODE();
 
    SendKey();
    Wake(LogicalDevice->CSN);
}

Referenced by DrvTestResources(), IsaPdoPnp(), and IsaPdoRemoveDevice().

IsaPdoPnp()

NTSTATUS IsaPdoPnp	(	_In_ PISAPNP_PDO_EXTENSION	PdoDeviceExtension,
		_Inout_ PIRP	Irp,
		_In_ PIO_STACK_LOCATION	IrpSp
	)

Definition at line 867 of file pdo.c.

{
    NTSTATUS Status = Irp->IoStatus.Status;
 
    PAGED_CODE();
 
    if (PdoExt->Common.Signature == IsaPnpLogicalDevice)
    {
        DPRINT("%s(%p, %p) CSN %u, LDN %u, Minor - %X\n",
               __FUNCTION__,
               PdoExt,
               Irp,
               PdoExt->IsaPnpDevice->CSN,
               PdoExt->IsaPnpDevice->LDN,
               IrpSp->MinorFunction);
    }
    else
    {
        DPRINT("%s(%p, %p) ReadPort, Minor - %X\n",
               __FUNCTION__,
               PdoExt,
               Irp,
               IrpSp->MinorFunction);
    }
 
    switch (IrpSp->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
        {
            if (PdoExt->Common.Signature == IsaPnpLogicalDevice)
            {
                IsaHwWakeDevice(PdoExt->IsaPnpDevice);
 
                Status = IsaHwConfigureDevice(PdoExt->FdoExt,
                                              PdoExt->IsaPnpDevice,
                                              IrpSp->Parameters.StartDevice.AllocatedResources);
                if (NT_SUCCESS(Status))
                {
                    IsaHwActivateDevice(PdoExt->FdoExt, PdoExt->IsaPnpDevice);
                }
                else
                {
                    DPRINT1("Failed to configure CSN %u, LDN %u with status 0x%08lx\n",
                            PdoExt->IsaPnpDevice->CSN, PdoExt->IsaPnpDevice->LDN, Status);
                }
 
                IsaHwWaitForKey();
            }
            else
            {
                Status = IsaPdoStartReadPort(PdoExt,
                                             IrpSp->Parameters.StartDevice.AllocatedResources);
            }
 
            if (NT_SUCCESS(Status))
                PdoExt->Common.State = dsStarted;
            break;
        }
 
        case IRP_MN_STOP_DEVICE:
        {
            if (PdoExt->Common.Signature == IsaPnpLogicalDevice)
            {
                IsaHwWakeDevice(PdoExt->IsaPnpDevice);
                IsaHwDeactivateDevice(PdoExt->IsaPnpDevice);
 
                IsaHwWaitForKey();
            }
            else
            {
                PdoExt->Flags &= ~ISAPNP_READ_PORT_ALLOW_FDO_SCAN;
            }
 
            Status = STATUS_SUCCESS;
 
            if (NT_SUCCESS(Status))
                PdoExt->Common.State = dsStopped;
            break;
        }
 
        case IRP_MN_QUERY_STOP_DEVICE:
        {
            if (PdoExt->SpecialFiles > 0)
                Status = STATUS_DEVICE_BUSY;
            else if (PdoExt->Flags & ISAPNP_READ_PORT_NEED_REBALANCE)
                Status = STATUS_RESOURCE_REQUIREMENTS_CHANGED;
            else
                Status = STATUS_SUCCESS;
 
            break;
        }
 
        case IRP_MN_QUERY_REMOVE_DEVICE:
        {
            if (PdoExt->SpecialFiles > 0)
                Status = STATUS_DEVICE_BUSY;
            else
                Status = STATUS_SUCCESS;
            break;
        }
 
        case IRP_MN_QUERY_DEVICE_RELATIONS:
            Status = IsaPdoQueryDeviceRelations(PdoExt, Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_CAPABILITIES:
            Status = IsaPdoQueryCapabilities(PdoExt, Irp, IrpSp);
            break;
 
        case IRP_MN_SURPRISE_REMOVAL:
        case IRP_MN_REMOVE_DEVICE:
        {
            BOOLEAN FinalRemove = (IrpSp->MinorFunction == IRP_MN_REMOVE_DEVICE);
 
            if (PdoExt->Common.Signature == IsaPnpLogicalDevice)
                Status = IsaPdoRemoveDevice(PdoExt, FinalRemove);
            else
                Status = IsaReadPortRemoveDevice(PdoExt, FinalRemove);
            break;
        }
 
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            Status = IsaPdoQueryPnpDeviceState(PdoExt, Irp);
            break;
 
        case IRP_MN_QUERY_RESOURCES:
            Status = IsaPdoQueryResources(PdoExt, Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
            Status = IsaPdoQueryResourceRequirements(PdoExt, Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_ID:
            if (PdoExt->Common.Signature == IsaPnpLogicalDevice)
                Status = IsaPdoQueryId(PdoExt, Irp, IrpSp);
            else
                Status = IsaReadPortQueryId(Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_DEVICE_TEXT:
            if (PdoExt->Common.Signature == IsaPnpLogicalDevice)
                Status = IsaPdoQueryDeviceText(PdoExt, Irp, IrpSp);
            break;
 
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
            Status = IsaPdoFilterResourceRequirements(PdoExt, Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_BUS_INFORMATION:
            Status = IsaPdoQueryBusInformation(PdoExt, Irp);
            break;
 
        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
            Status = IsaPdoQueryDeviceUsageNotification(PdoExt, Irp, IrpSp);
            break;
 
        case IRP_MN_CANCEL_REMOVE_DEVICE:
        case IRP_MN_CANCEL_STOP_DEVICE:
            Status = STATUS_SUCCESS;
            break;
 
        default:
            DPRINT("Unknown PnP code: %X\n", IrpSp->MinorFunction);
            break;
    }
 
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by _Dispatch_type_().

IsaPnpCreateReadPortDORequirements()

PIO_RESOURCE_REQUIREMENTS_LIST IsaPnpCreateReadPortDORequirements

(

_In_opt_ ULONG

SelectedReadPort

)

Definition at line 819 of file isapnp.c.

{
    ULONG ResourceCount, ListSize, i;
    PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList;
    PIO_RESOURCE_DESCRIPTOR Descriptor;
    const ULONG Ports[] = { ISAPNP_WRITE_DATA, ISAPNP_ADDRESS };
    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(Ports) * 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(Ports) + 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(Ports) * 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 = Ports[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 966 of file isapnp.c.

{
    const USHORT Ports[] = { ISAPNP_WRITE_DATA, ISAPNP_ADDRESS };
    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(Ports) - 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(Ports);
 
    Descriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[0];
    for (i = 0; i < RTL_NUMBER_OF(Ports); 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 = Ports[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().

IsaPnpRemoveLogicalDeviceDO()

VOID IsaPnpRemoveLogicalDeviceDO

(

_In_ PDEVICE_OBJECT

Pdo

)

Definition at line 823 of file pdo.c.

{
    PISAPNP_PDO_EXTENSION PdoExt = Pdo->DeviceExtension;
    PISAPNP_LOGICAL_DEVICE LogDev = PdoExt->IsaPnpDevice;
    PLIST_ENTRY Entry;
 
    PAGED_CODE();
    ASSERT(LogDev);
 
    DPRINT("Removing CSN %u, LDN %u\n", LogDev->CSN, LogDev->LDN);
 
    if (PdoExt->RequirementsList)
        ExFreePoolWithTag(PdoExt->RequirementsList, TAG_ISAPNP);
 
    if (PdoExt->ResourceList)
        ExFreePoolWithTag(PdoExt->ResourceList, TAG_ISAPNP);
 
    if (LogDev->FriendlyName)
        ExFreePoolWithTag(LogDev->FriendlyName, TAG_ISAPNP);
 
    if (LogDev->Resources)
        ExFreePoolWithTag(LogDev->Resources, TAG_ISAPNP);
 
    Entry = LogDev->CompatibleIdList.Flink;
    while (Entry != &LogDev->CompatibleIdList)
    {
        PISAPNP_COMPATIBLE_ID_ENTRY CompatibleId =
            CONTAINING_RECORD(Entry, ISAPNP_COMPATIBLE_ID_ENTRY, IdLink);
 
        RemoveEntryList(&CompatibleId->IdLink);
 
        Entry = Entry->Flink;
 
        ExFreePoolWithTag(CompatibleId, TAG_ISAPNP);
    }
 
    ExFreePoolWithTag(LogDev, TAG_ISAPNP);
 
    IoDeleteDevice(PdoExt->Common.Self);
}

Referenced by IsaFdoRemoveDevice(), and IsaPdoRemoveDevice().

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

extern

Definition at line 21 of file isapnp.c.

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

DriverEntry

DRIVER_INITIALIZE DriverEntry

Definition at line 202 of file isapnp.h.