precomp.h File Reference

#include <wdm.h>
#include <ntddk.h>
#include <stdio.h>
#include <memory.h>
#include <storport.h>
#include <ntddscsi.h>
#include <ntdddisk.h>
#include <mountdev.h>
#include <wdmguid.h>

Include dependency graph for precomp.h:

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

Go to the source code of this file.

Classes
struct	_DRIVER_INIT_DATA
struct	_DRIVER_OBJECT_EXTENSION
struct	_MINIPORT_DEVICE_EXTENSION
struct	_MINIPORT
struct	_UNIT_DATA
struct	_FDO_DEVICE_EXTENSION
struct	_PDO_DEVICE_EXTENSION

Macros
#define	_STORPORT_
#define	TAG_GLOBAL_DATA   'DGtS'
#define	TAG_INIT_DATA   'DItS'
#define	TAG_MINIPORT_DATA   'DMtS'
#define	TAG_ACCRESS_RANGE   'RAtS'
#define	TAG_RESOURCE_LIST   'LRtS'
#define	TAG_ADDRESS_MAPPING   'MAtS'
#define	TAG_INQUIRY_DATA   'QItS'
#define	TAG_SENSE_DATA   'NStS'

Typedefs
typedef struct _DRIVER_INIT_DATA	DRIVER_INIT_DATA
typedef struct _DRIVER_INIT_DATA *	PDRIVER_INIT_DATA
typedef struct _DRIVER_OBJECT_EXTENSION	DRIVER_OBJECT_EXTENSION
typedef struct _DRIVER_OBJECT_EXTENSION *	PDRIVER_OBJECT_EXTENSION
typedef struct _MINIPORT_DEVICE_EXTENSION	MINIPORT_DEVICE_EXTENSION
typedef struct _MINIPORT_DEVICE_EXTENSION *	PMINIPORT_DEVICE_EXTENSION
typedef struct _MINIPORT	MINIPORT
typedef struct _MINIPORT *	PMINIPORT
typedef struct _UNIT_DATA	UNIT_DATA
typedef struct _UNIT_DATA *	PUNIT_DATA
typedef struct _FDO_DEVICE_EXTENSION	FDO_DEVICE_EXTENSION
typedef struct _FDO_DEVICE_EXTENSION *	PFDO_DEVICE_EXTENSION
typedef struct _PDO_DEVICE_EXTENSION	PDO_DEVICE_EXTENSION
typedef struct _PDO_DEVICE_EXTENSION *	PPDO_DEVICE_EXTENSION

Enumerations
enum	DEVICE_STATE {   dsStopped, dsStarted, dsPaused, dsRemoved,   dsSurpriseRemoved, NotStarted = 0, Started, StopPending,   Stopped, RemovePending, SurpriseRemovePending, Deleted,   dsStopped, dsStarted, dsPaused, dsRemoved,   dsSurpriseRemoved, dsStopped, dsStarted, dsPaused,   dsRemoved, dsSurpriseRemoved }
enum	EXTENSION_TYPE { InvalidExtension = 0, DriverExtension, FdoExtension, PdoExtension }

Functions
NTSTATUS NTAPI	PortFdoScsi (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
NTSTATUS NTAPI	PortFdoPnp (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
NTSTATUS	MiniportInitialize (_In_ PMINIPORT Miniport, _In_ PFDO_DEVICE_EXTENSION DeviceExtension, _In_ PHW_INITIALIZATION_DATA HwInitializationData)
NTSTATUS	MiniportFindAdapter (_In_ PMINIPORT Miniport)
NTSTATUS	MiniportHwInitialize (_In_ PMINIPORT Miniport)
BOOLEAN	MiniportHwInterrupt (_In_ PMINIPORT Miniport)
BOOLEAN	MiniportStartIo (_In_ PMINIPORT Miniport, _In_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ForwardIrpAndWait (_In_ PDEVICE_OBJECT LowerDevice, _In_ PIRP Irp)
NTSTATUS NTAPI	ForwardIrpAndForget (_In_ PDEVICE_OBJECT LowerDevice, _In_ PIRP Irp)
INTERFACE_TYPE	GetBusInterface (PDEVICE_OBJECT DeviceObject)
PCM_RESOURCE_LIST	CopyResourceList (POOL_TYPE PoolType, PCM_RESOURCE_LIST Source)
NTSTATUS	QueryBusInterface (PDEVICE_OBJECT DeviceObject, PGUID Guid, USHORT Size, USHORT Version, PBUS_INTERFACE_STANDARD Interface, PVOID InterfaceSpecificData)
BOOLEAN	TranslateResourceListAddress (PFDO_DEVICE_EXTENSION DeviceExtension, INTERFACE_TYPE BusType, ULONG SystemIoBusNumber, STOR_PHYSICAL_ADDRESS IoAddress, ULONG NumberOfBytes, BOOLEAN InIoSpace, PPHYSICAL_ADDRESS TranslatedAddress)
NTSTATUS	GetResourceListInterrupt (PFDO_DEVICE_EXTENSION DeviceExtension, PULONG Vector, PKIRQL Irql, KINTERRUPT_MODE *InterruptMode, PBOOLEAN ShareVector, PKAFFINITY Affinity)
NTSTATUS	AllocateAddressMapping (PMAPPED_ADDRESS *MappedAddressList, STOR_PHYSICAL_ADDRESS IoAddress, PVOID MappedAddress, ULONG NumberOfBytes, ULONG BusNumber)
NTSTATUS	PortCreatePdo (_In_ PFDO_DEVICE_EXTENSION FdoExtension, _In_ ULONG Bus, _In_ ULONG Target, _In_ ULONG Lun, _Out_ PPDO_DEVICE_EXTENSION *PdoExtension)
NTSTATUS	PortDeletePdo (_In_ PPDO_DEVICE_EXTENSION PdoExtension)
NTSTATUS NTAPI	PortPdoScsi (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
NTSTATUS NTAPI	PortPdoPnp (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
PHW_INITIALIZATION_DATA	PortGetDriverInitData (PDRIVER_OBJECT_EXTENSION DriverExtension, INTERFACE_TYPE InterfaceType)
NTSTATUS NTAPI	DriverEntry (_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)

Macro Definition Documentation

_STORPORT_

#define _STORPORT_

Definition at line 17 of file precomp.h.

TAG_ACCRESS_RANGE

#define TAG_ACCRESS_RANGE   'RAtS'

Definition at line 29 of file precomp.h.

TAG_ADDRESS_MAPPING

#define TAG_ADDRESS_MAPPING   'MAtS'

Definition at line 31 of file precomp.h.

TAG_GLOBAL_DATA

#define TAG_GLOBAL_DATA   'DGtS'

Definition at line 26 of file precomp.h.

TAG_INIT_DATA

#define TAG_INIT_DATA   'DItS'

Definition at line 27 of file precomp.h.

TAG_INQUIRY_DATA

#define TAG_INQUIRY_DATA   'QItS'

Definition at line 32 of file precomp.h.

TAG_MINIPORT_DATA

#define TAG_MINIPORT_DATA   'DMtS'

Definition at line 28 of file precomp.h.

TAG_RESOURCE_LIST

#define TAG_RESOURCE_LIST   'LRtS'

Definition at line 30 of file precomp.h.

TAG_SENSE_DATA

#define TAG_SENSE_DATA   'NStS'

Definition at line 33 of file precomp.h.

Typedef Documentation

DRIVER_INIT_DATA

typedef struct _DRIVER_INIT_DATA DRIVER_INIT_DATA

DRIVER_OBJECT_EXTENSION

typedef struct _DRIVER_OBJECT_EXTENSION DRIVER_OBJECT_EXTENSION

FDO_DEVICE_EXTENSION

typedef struct _FDO_DEVICE_EXTENSION FDO_DEVICE_EXTENSION

MINIPORT

typedef struct _MINIPORT MINIPORT

MINIPORT_DEVICE_EXTENSION

typedef struct _MINIPORT_DEVICE_EXTENSION MINIPORT_DEVICE_EXTENSION

PDO_DEVICE_EXTENSION

typedef struct _PDO_DEVICE_EXTENSION PDO_DEVICE_EXTENSION

PDRIVER_INIT_DATA

typedef struct _DRIVER_INIT_DATA * PDRIVER_INIT_DATA

PDRIVER_OBJECT_EXTENSION

typedef struct _DRIVER_OBJECT_EXTENSION * PDRIVER_OBJECT_EXTENSION

PFDO_DEVICE_EXTENSION

typedef struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION

PMINIPORT

typedef struct _MINIPORT * PMINIPORT

PMINIPORT_DEVICE_EXTENSION

typedef struct _MINIPORT_DEVICE_EXTENSION * PMINIPORT_DEVICE_EXTENSION

PPDO_DEVICE_EXTENSION

typedef struct _PDO_DEVICE_EXTENSION * PPDO_DEVICE_EXTENSION

PUNIT_DATA

typedef struct _UNIT_DATA * PUNIT_DATA

UNIT_DATA

typedef struct _UNIT_DATA UNIT_DATA

Enumeration Type Documentation

DEVICE_STATE

enum DEVICE_STATE

Enumerator
dsStopped
dsStarted
dsPaused
dsRemoved
dsSurpriseRemoved
NotStarted
Started
StopPending
Stopped
RemovePending
SurpriseRemovePending
Deleted
dsStopped
dsStarted
dsPaused
dsRemoved
dsSurpriseRemoved
dsStopped
dsStarted
dsPaused
dsRemoved
dsSurpriseRemoved

Definition at line 35 of file precomp.h.

{
    dsStopped,
    dsStarted,
    dsPaused,
    dsRemoved,
    dsSurpriseRemoved
} DEVICE_STATE;

EXTENSION_TYPE

enum EXTENSION_TYPE

Enumerator
InvalidExtension
DriverExtension
FdoExtension
PdoExtension

Definition at line 44 of file precomp.h.

{
    InvalidExtension = 0,
    DriverExtension,
    FdoExtension,
    PdoExtension
} EXTENSION_TYPE;

Function Documentation

AllocateAddressMapping()

NTSTATUS AllocateAddressMapping	(	PMAPPED_ADDRESS *	MappedAddressList,
		STOR_PHYSICAL_ADDRESS	IoAddress,
		PVOID	MappedAddress,
		ULONG	NumberOfBytes,
		ULONG	BusNumber
	)

Definition at line 331 of file misc.c.

{
    PMAPPED_ADDRESS Mapping;

    DPRINT1("AllocateAddressMapping()\n");

    Mapping = ExAllocatePoolWithTag(NonPagedPool,
                                    sizeof(MAPPED_ADDRESS),
                                    TAG_ADDRESS_MAPPING);
    if (Mapping == NULL)
    {
        DPRINT1("No memory!\n");
        return STATUS_NO_MEMORY;
    }

    RtlZeroMemory(Mapping, sizeof(MAPPED_ADDRESS));

    Mapping->NextMappedAddress = *MappedAddressList;
    *MappedAddressList = Mapping;

    Mapping->IoAddress = IoAddress;
    Mapping->MappedAddress = MappedAddress;
    Mapping->NumberOfBytes = NumberOfBytes;
    Mapping->BusNumber = BusNumber;

    return STATUS_SUCCESS;
}

Referenced by StorPortGetDeviceBase().

CopyResourceList()

PCM_RESOURCE_LIST CopyResourceList	(	POOL_TYPE	PoolType,
		PCM_RESOURCE_LIST	Source
	)

Definition at line 132 of file misc.c.

{
    PCM_RESOURCE_LIST Destination;
    ULONG Size;

    DPRINT1("CopyResourceList(%lu %p)\n",
            PoolType, Source);

    /* Get the size of the resource list */
    Size = GetResourceListSize(Source);

    /* Allocate a new buffer */
    Destination = ExAllocatePoolWithTag(PoolType,
                                        Size,
                                        TAG_RESOURCE_LIST);
    if (Destination == NULL)
        return NULL;

    /* Copy the resource list */
    RtlCopyMemory(Destination,
                  Source,
                  Size);

    return Destination;
}

Referenced by PortFdoStartDevice().

DriverEntry()

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

Definition at line 25 of file ksecdd.c.

{
    UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\KsecDD");
    NTSTATUS Status;

    /* Create the KsecDD device */
    Status = IoCreateDevice(DriverObject,
                            0,
                            &DeviceName,
                            FILE_DEVICE_KSEC,
                            0x100u,
                            FALSE,
                            &KsecDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create KsecDD device: 0x%lx\n", Status);
        return Status;
    }

    /* Set up dispatch table */
    DriverObject->MajorFunction[IRP_MJ_CREATE] = KsecDdDispatch;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = KsecDdDispatch;
    DriverObject->MajorFunction[IRP_MJ_READ] = KsecDdDispatch;
    DriverObject->MajorFunction[IRP_MJ_WRITE] = KsecDdDispatch;
    DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = KsecDdDispatch;
    DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = KsecDdDispatch;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = KsecDdDispatch;

    /* Initialize */
    KsecInitializeEncryptionSupport();

    return STATUS_SUCCESS;
}

ForwardIrpAndForget()

NTSTATUS NTAPI ForwardIrpAndForget	(	_In_ PDEVICE_OBJECT	LowerDevice,
		_In_ PIRP	Irp
	)

Definition at line 5 of file utils.c.

{
    // this part of a structure is identical in both FDO and PDO
    PDEVICE_OBJECT LowerDevice = ((PFDO_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice;

    ASSERT(LowerDevice);

    IoSkipCurrentIrpStackLocation(Irp);
    return IoCallDriver(LowerDevice, Irp);
}

ForwardIrpAndWait()

NTSTATUS ForwardIrpAndWait	(	_In_ PDEVICE_OBJECT	LowerDevice,
		_In_ PIRP	Irp
	)

Definition at line 33 of file misc.c.

{
    KEVENT Event;
    NTSTATUS Status;

    ASSERT(LowerDevice);

    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    IoCopyCurrentIrpStackLocationToNext(Irp);

    IoSetCompletionRoutine(Irp, ForwardIrpAndWaitCompletion, &Event, TRUE, TRUE, TRUE);

    Status = IoCallDriver(LowerDevice, Irp);
    if (Status == STATUS_PENDING)
    {
        Status = KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
        if (NT_SUCCESS(Status))
            Status = Irp->IoStatus.Status;
    }

    return Status;
}

GetBusInterface()

INTERFACE_TYPE GetBusInterface

(

PDEVICE_OBJECT

DeviceObject

)

Definition at line 73 of file misc.c.

{
    GUID Guid;
    ULONG Length;
    NTSTATUS Status;

    Status = IoGetDeviceProperty(DeviceObject,
                                 DevicePropertyBusTypeGuid,
                                 sizeof(Guid),
                                 &Guid,
                                 &Length);
    if (!NT_SUCCESS(Status))
        return InterfaceTypeUndefined;

    if (RtlCompareMemory(&Guid, &GUID_BUS_TYPE_PCMCIA, sizeof(GUID)) == sizeof(GUID))
        return PCMCIABus;
    else if (RtlCompareMemory(&Guid, &GUID_BUS_TYPE_PCI, sizeof(GUID)) == sizeof(GUID))
        return PCIBus;
    else if (RtlCompareMemory(&Guid, &GUID_BUS_TYPE_ISAPNP, sizeof(GUID)) == sizeof(GUID))
        return PNPISABus;

    return InterfaceTypeUndefined;
}

GetResourceListInterrupt()

NTSTATUS GetResourceListInterrupt	(	PFDO_DEVICE_EXTENSION	DeviceExtension,
		PULONG	Vector,
		PKIRQL	Irql,
		KINTERRUPT_MODE *	InterruptMode,
		PBOOLEAN	ShareVector,
		PKAFFINITY	Affinity
	)

Definition at line 282 of file misc.c.

{
    PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptor;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
    INT i, j;

    DPRINT1("GetResourceListInterrupt(%p)\n",
            DeviceExtension);

    FullDescriptor = DeviceExtension->TranslatedResources->List;
    for (i = 0; i < DeviceExtension->TranslatedResources->Count; i++)
    {
        for (j = 0; j < FullDescriptor->PartialResourceList.Count; j++)
        {
            PartialDescriptor = FullDescriptor->PartialResourceList.PartialDescriptors + j;

            switch (PartialDescriptor->Type)
            {
                case CmResourceTypeInterrupt:
                    DPRINT1("Interrupt: Level %lu  Vector %lu\n",
                            PartialDescriptor->u.Interrupt.Level,
                            PartialDescriptor->u.Interrupt.Vector);

                    *Vector = PartialDescriptor->u.Interrupt.Vector;
                    *Irql = (KIRQL)PartialDescriptor->u.Interrupt.Level;
                    *InterruptMode = (PartialDescriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED) ? Latched : LevelSensitive;
                    *ShareVector = (PartialDescriptor->ShareDisposition == CmResourceShareShared) ? TRUE : FALSE;
                    *Affinity = PartialDescriptor->u.Interrupt.Affinity;

                    return STATUS_SUCCESS;
            }
        }

        /* Advance to next CM_FULL_RESOURCE_DESCRIPTOR block in memory. */
        FullDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR)(FullDescriptor->PartialResourceList.PartialDescriptors + 
                                                        FullDescriptor->PartialResourceList.Count);
    }

    return STATUS_NOT_FOUND;
}

Referenced by PortFdoConnectInterrupt().

MiniportFindAdapter()

NTSTATUS MiniportFindAdapter

(

_In_ PMINIPORT

Miniport

)

Definition at line 283 of file miniport.c.

{
    BOOLEAN Reserved = FALSE;
    ULONG Result;
    NTSTATUS Status;

    DPRINT1("MiniportFindAdapter(%p)\n", Miniport);

    /* Call the miniport HwFindAdapter routine */
    Result = Miniport->InitData->HwFindAdapter(&Miniport->MiniportExtension->HwDeviceExtension,
                                               NULL,
                                               NULL,
                                               NULL,
                                               &Miniport->PortConfig,
                                               &Reserved);
    DPRINT1("HwFindAdapter() returned %lu\n", Result);

    /* Convert the result to a status code */
    switch (Result)
    {
        case SP_RETURN_NOT_FOUND:
            DPRINT1("SP_RETURN_NOT_FOUND\n");
            Status = STATUS_NOT_FOUND;
            break;

        case SP_RETURN_FOUND:
            DPRINT1("SP_RETURN_FOUND\n");
            Status = STATUS_SUCCESS;
            break;

        case SP_RETURN_ERROR:
            DPRINT1("SP_RETURN_ERROR\n");
            Status = STATUS_ADAPTER_HARDWARE_ERROR;
            break;

        case SP_RETURN_BAD_CONFIG:
            DPRINT1("SP_RETURN_BAD_CONFIG\n");
            Status = STATUS_DEVICE_CONFIGURATION_ERROR;
            break;

        default:
            DPRINT1("Unknown result: %lu\n", Result);
            Status = STATUS_INTERNAL_ERROR;
            break;
    }

    return Status;
}

Referenced by PortFdoStartMiniport().

MiniportHwInitialize()

NTSTATUS MiniportHwInitialize

(

_In_ PMINIPORT

Miniport

)

Definition at line 335 of file miniport.c.

{
    BOOLEAN Result;

    DPRINT1("MiniportHwInitialize(%p)\n", Miniport);

    /* Call the miniport HwInitialize routine */
    Result = Miniport->InitData->HwInitialize(&Miniport->MiniportExtension->HwDeviceExtension);
    DPRINT1("HwInitialize() returned %u\n", Result);

    return Result ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
}

Referenced by PortFdoStartMiniport().

MiniportHwInterrupt()

BOOLEAN MiniportHwInterrupt

(

_In_ PMINIPORT

Miniport

)

Definition at line 351 of file miniport.c.

{
    BOOLEAN Result;

    DPRINT1("MiniportHwInterrupt(%p)\n",
            Miniport);

    Result = Miniport->InitData->HwInterrupt(&Miniport->MiniportExtension->HwDeviceExtension);
    DPRINT1("HwInterrupt() returned %u\n", Result);

    return Result;
}

Referenced by PortFdoInterruptRoutine().

MiniportInitialize()

NTSTATUS MiniportInitialize	(	_In_ PMINIPORT	Miniport,
		_In_ PFDO_DEVICE_EXTENSION	DeviceExtension,
		_In_ PHW_INITIALIZATION_DATA	HwInitializationData
	)

Definition at line 234 of file miniport.c.

{
    PMINIPORT_DEVICE_EXTENSION MiniportExtension;
    ULONG Size;
    NTSTATUS Status;

    DPRINT1("MiniportInitialize(%p %p %p)\n",
            Miniport, DeviceExtension, InitData);

    Miniport->DeviceExtension = DeviceExtension;
    Miniport->InitData = InitData;

    /* Calculate the miniport device extension size */
    Size = sizeof(MINIPORT_DEVICE_EXTENSION) +
           Miniport->InitData->DeviceExtensionSize;

    /* Allocate and initialize the miniport device extension */
    MiniportExtension = ExAllocatePoolWithTag(NonPagedPool,
                                              Size,
                                              TAG_MINIPORT_DATA);
    if (MiniportExtension == NULL)
        return STATUS_NO_MEMORY;

    RtlZeroMemory(MiniportExtension, Size);

    MiniportExtension->Miniport = Miniport;
    Miniport->MiniportExtension = MiniportExtension;

    /* Initialize the port configuration */
    Status = InitializeConfiguration(&Miniport->PortConfig,
                                     InitData,
                                     DeviceExtension->BusNumber,
                                     DeviceExtension->SlotNumber);
    if (!NT_SUCCESS(Status))
        return Status;

    /* Assign the resources to the port configuration */
    AssignResourcesToConfiguration(&Miniport->PortConfig,
                                   DeviceExtension->AllocatedResources,
                                   InitData->NumberOfAccessRanges);

    return STATUS_SUCCESS;
}

MiniportStartIo()

BOOLEAN MiniportStartIo	(	_In_ PMINIPORT	Miniport,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 367 of file miniport.c.

{
    BOOLEAN Result;

    DPRINT1("MiniportHwStartIo(%p %p)\n",
            Miniport, Srb);

    Result = Miniport->InitData->HwStartIo(&Miniport->MiniportExtension->HwDeviceExtension, Srb);
    DPRINT1("HwStartIo() returned %u\n", Result);

    return Result;
}

PortCreatePdo()

NTSTATUS PortCreatePdo	(	_In_ PFDO_DEVICE_EXTENSION	FdoExtension,
		_In_ ULONG	Bus,
		_In_ ULONG	Target,
		_In_ ULONG	Lun,
		_Out_ PPDO_DEVICE_EXTENSION *	PdoExtension
	)

Definition at line 19 of file pdo.c.

{
    PPDO_DEVICE_EXTENSION DeviceExtension = NULL;
    PDEVICE_OBJECT Pdo = NULL;
    KLOCK_QUEUE_HANDLE LockHandle;
    NTSTATUS Status;

    DPRINT("PortCreatePdo(%p %p)\n",
           FdoDeviceExtension, PdoDeviceExtension);

    /* Create the port device */
    Status = IoCreateDevice(FdoDeviceExtension->Device->DriverObject,
                            sizeof(PDO_DEVICE_EXTENSION),
                            NULL,
                            FILE_DEVICE_MASS_STORAGE,
                            FILE_DEVICE_SECURE_OPEN | FILE_AUTOGENERATED_DEVICE_NAME,
                            FALSE,
                            &Pdo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IoCreateDevice() failed (Status 0x%lX)\n", Status);
        return Status;
    }

    /* Initialize the device */
    Pdo->Flags |= DO_DIRECT_IO;
    Pdo->Flags |= DO_POWER_PAGABLE;

    DeviceExtension = (PPDO_DEVICE_EXTENSION)Pdo->DeviceExtension;
    RtlZeroMemory(DeviceExtension, sizeof(PDO_DEVICE_EXTENSION));

    DeviceExtension->ExtensionType = PdoExtension;

    DeviceExtension->Device = Pdo;
    DeviceExtension->FdoExtension = FdoDeviceExtension;
    DeviceExtension->PnpState = dsStopped;

    /* Add the PDO to the PDO list*/
    KeAcquireInStackQueuedSpinLock(&FdoDeviceExtension->PdoListLock,
                                   &LockHandle);
    InsertHeadList(&FdoDeviceExtension->PdoListHead,
                   &DeviceExtension->PdoListEntry);
    FdoDeviceExtension->PdoCount++;
    KeReleaseInStackQueuedSpinLock(&LockHandle);

    DeviceExtension->Bus = Bus;
    DeviceExtension->Target = Target;
    DeviceExtension->Lun = Lun;


    // FIXME: More initialization


    /* The device has been initialized */
    Pdo->Flags &= ~DO_DEVICE_INITIALIZING;

    *PdoDeviceExtension = DeviceExtension;

    return STATUS_SUCCESS;
}

Referenced by PortFdoScanBus().

PortDeletePdo()

NTSTATUS PortDeletePdo

(

_In_ PPDO_DEVICE_EXTENSION

PdoExtension

)

Definition at line 87 of file pdo.c.

{
    KLOCK_QUEUE_HANDLE LockHandle;

    DPRINT("PortDeletePdo(%p)\n", PdoExtension);

    /* Remove the PDO from the PDO list*/
    KeAcquireInStackQueuedSpinLock(&PdoExtension->FdoExtension->PdoListLock,
                                   &LockHandle);
    RemoveEntryList(&PdoExtension->PdoListEntry);
    PdoExtension->FdoExtension->PdoCount--;
    KeReleaseInStackQueuedSpinLock(&LockHandle);

    if (PdoExtension->InquiryBuffer)
    {
        ExFreePoolWithTag(PdoExtension->InquiryBuffer, TAG_INQUIRY_DATA);
        PdoExtension->InquiryBuffer = NULL;
    }


    // FIXME: More uninitialization


    /* Delete the PDO */
    IoDeleteDevice(PdoExtension->Device);

    return STATUS_SUCCESS;
}

Referenced by PortFdoScanBus().

PortFdoPnp()

NTSTATUS NTAPI PortFdoPnp	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 588 of file fdo.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension;
    PIO_STACK_LOCATION Stack;
    ULONG_PTR Information = 0;
    NTSTATUS Status = STATUS_NOT_SUPPORTED;

    DPRINT1("PortFdoPnp(%p %p)\n",
            DeviceObject, Irp);

    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension);
    ASSERT(DeviceExtension->ExtensionType == FdoExtension);

    Stack = IoGetCurrentIrpStackLocation(Irp);

    switch (Stack->MinorFunction)
    {
        case IRP_MN_START_DEVICE: /* 0x00 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
            Status = PortFdoStartDevice(DeviceExtension, Irp);
            break;

        case IRP_MN_QUERY_REMOVE_DEVICE: /* 0x01 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_REMOVE_DEVICE\n");
            break;

        case IRP_MN_REMOVE_DEVICE: /* 0x02 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_REMOVE_DEVICE\n");
            break;

        case IRP_MN_CANCEL_REMOVE_DEVICE: /* 0x03 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_CANCEL_REMOVE_DEVICE\n");
            break;

        case IRP_MN_STOP_DEVICE: /* 0x04 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_STOP_DEVICE\n");
            break;

        case IRP_MN_QUERY_STOP_DEVICE: /* 0x05 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_STOP_DEVICE\n");
            break;

        case IRP_MN_CANCEL_STOP_DEVICE: /* 0x06 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_CANCEL_STOP_DEVICE\n");
            break;

        case IRP_MN_QUERY_DEVICE_RELATIONS: /* 0x07 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS\n");
            switch (Stack->Parameters.QueryDeviceRelations.Type)
            {
                case BusRelations:
                    DPRINT1("    IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations\n");
                    Status = PortFdoQueryBusRelations(DeviceExtension, &Information);
                    break;

                case RemovalRelations:
                    DPRINT1("    IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations\n");
                    return ForwardIrpAndForget(DeviceExtension->LowerDevice, Irp);

                default:
                    DPRINT1("    IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
                            Stack->Parameters.QueryDeviceRelations.Type);
                    return ForwardIrpAndForget(DeviceExtension->LowerDevice, Irp);
            }
            break;

        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS: /* 0x0d */
            DPRINT1("IRP_MJ_PNP / IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
            PortFdoFilterRequirements(DeviceExtension, Irp);
            return ForwardIrpAndForget(DeviceExtension->LowerDevice, Irp);

        case IRP_MN_QUERY_PNP_DEVICE_STATE: /* 0x14 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_PNP_DEVICE_STATE\n");
            break;

        case IRP_MN_DEVICE_USAGE_NOTIFICATION: /* 0x16 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_DEVICE_USAGE_NOTIFICATION\n");
            break;

        case IRP_MN_SURPRISE_REMOVAL: /* 0x17 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_SURPRISE_REMOVAL\n");
            break;

        default:
            DPRINT1("IRP_MJ_PNP / Unknown IOCTL 0x%lx\n", Stack->MinorFunction);
            return ForwardIrpAndForget(DeviceExtension->LowerDevice, Irp);
    }

    Irp->IoStatus.Information = Information;
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    return Status;
}

Referenced by PortDispatchPnp().

PortFdoScsi()

NTSTATUS NTAPI PortFdoScsi	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 560 of file fdo.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension;
//    PIO_STACK_LOCATION Stack;
    ULONG_PTR Information = 0;
    NTSTATUS Status = STATUS_NOT_SUPPORTED;

    DPRINT("PortFdoScsi(%p %p)\n", DeviceObject, Irp);

    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension);
    ASSERT(DeviceExtension->ExtensionType == FdoExtension);

//    Stack = IoGetCurrentIrpStackLocation(Irp);


    Irp->IoStatus.Information = Information;
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    return Status;
}

Referenced by PortDispatchScsi().

PortGetDriverInitData()

PHW_INITIALIZATION_DATA PortGetDriverInitData	(	PDRIVER_OBJECT_EXTENSION	DriverExtension,
		INTERFACE_TYPE	InterfaceType
	)

Definition at line 78 of file storport.c.

{
    PDRIVER_INIT_DATA InitData;
    PLIST_ENTRY ListEntry;

    DPRINT1("PortGetDriverInitData()\n");

    ListEntry = DriverExtension->InitDataListHead.Flink;
    while (ListEntry != &DriverExtension->InitDataListHead)
    {
        InitData = CONTAINING_RECORD(ListEntry,
                                     DRIVER_INIT_DATA,
                                     Entry);
        if (InitData->HwInitData.AdapterInterfaceType == InterfaceType)
            return &InitData->HwInitData;

        ListEntry = ListEntry->Flink;
    }

    return NULL;
}

Referenced by PortFdoStartMiniport().

PortPdoPnp()

NTSTATUS NTAPI PortPdoPnp	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 135 of file pdo.c.

{
    DPRINT1("PortPdoPnp(%p %p)\n", DeviceObject, Irp);

    Irp->IoStatus.Information = 0;
    Irp->IoStatus.Status = STATUS_SUCCESS;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

Referenced by PortDispatchPnp().

PortPdoScsi()

NTSTATUS NTAPI PortPdoScsi	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 120 of file pdo.c.

{
    DPRINT1("PortPdoScsi(%p %p)\n", DeviceObject, Irp);

    Irp->IoStatus.Information = 0;
    Irp->IoStatus.Status = STATUS_SUCCESS;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

Referenced by PortDispatchScsi().

QueryBusInterface()

NTSTATUS QueryBusInterface	(	PDEVICE_OBJECT	DeviceObject,
		PGUID	Guid,
		USHORT	Size,
		USHORT	Version,
		PBUS_INTERFACE_STANDARD	Interface,
		PVOID	InterfaceSpecificData
	)

Definition at line 162 of file misc.c.

{
    KEVENT Event;
    NTSTATUS Status;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatus;
    PIO_STACK_LOCATION Stack;

    KeInitializeEvent(&Event, NotificationEvent, FALSE);

    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
                                       DeviceObject,
                                       NULL,
                                       0,
                                       NULL,
                                       &Event,
                                       &IoStatus);
    if (Irp == NULL)
        return STATUS_INSUFFICIENT_RESOURCES;

    Stack = IoGetNextIrpStackLocation(Irp);

    Stack->MajorFunction = IRP_MJ_PNP;
    Stack->MinorFunction = IRP_MN_QUERY_INTERFACE;
    Stack->Parameters.QueryInterface.InterfaceType = Guid;
    Stack->Parameters.QueryInterface.Size = Size;
    Stack->Parameters.QueryInterface.Version = Version;
    Stack->Parameters.QueryInterface.Interface = (PINTERFACE)Interface;
    Stack->Parameters.QueryInterface.InterfaceSpecificData = InterfaceSpecificData;

    Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;

    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);

        Status=IoStatus.Status;
    }

    return Status;
}

Referenced by PortFdoStartDevice().

TranslateResourceListAddress()

BOOLEAN TranslateResourceListAddress	(	PFDO_DEVICE_EXTENSION	DeviceExtension,
		INTERFACE_TYPE	BusType,
		ULONG	SystemIoBusNumber,
		STOR_PHYSICAL_ADDRESS	IoAddress,
		ULONG	NumberOfBytes,
		BOOLEAN	InIoSpace,
		PPHYSICAL_ADDRESS	TranslatedAddress
	)

Definition at line 213 of file misc.c.

{
    PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptorA, FullDescriptorT;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptorA, PartialDescriptorT;
    INT i, j;

    DPRINT1("TranslateResourceListAddress(%p)\n", DeviceExtension);

    FullDescriptorA = DeviceExtension->AllocatedResources->List;
    FullDescriptorT = DeviceExtension->TranslatedResources->List;
    for (i = 0; i < DeviceExtension->AllocatedResources->Count; i++)
    {
        for (j = 0; j < FullDescriptorA->PartialResourceList.Count; j++)
        {
            PartialDescriptorA = FullDescriptorA->PartialResourceList.PartialDescriptors + j;
            PartialDescriptorT = FullDescriptorT->PartialResourceList.PartialDescriptors + j;

            switch (PartialDescriptorA->Type)
            {
                case CmResourceTypePort:
                    DPRINT1("Port: 0x%I64x (0x%lx)\n",
                            PartialDescriptorA->u.Port.Start.QuadPart,
                            PartialDescriptorA->u.Port.Length);
                    if (InIoSpace &&
                        IoAddress.QuadPart >= PartialDescriptorA->u.Port.Start.QuadPart &&
                        IoAddress.QuadPart + NumberOfBytes <= PartialDescriptorA->u.Port.Start.QuadPart + PartialDescriptorA->u.Port.Length)
                    {
                        TranslatedAddress->QuadPart = PartialDescriptorT->u.Port.Start.QuadPart + 
                                                      (IoAddress.QuadPart - PartialDescriptorA->u.Port.Start.QuadPart);
                        return TRUE;
                    }
                    break;

                case CmResourceTypeMemory:
                    DPRINT1("Memory: 0x%I64x (0x%lx)\n",
                            PartialDescriptorA->u.Memory.Start.QuadPart,
                            PartialDescriptorA->u.Memory.Length);
                    if (!InIoSpace &&
                        IoAddress.QuadPart >= PartialDescriptorA->u.Memory.Start.QuadPart &&
                        IoAddress.QuadPart + NumberOfBytes <= PartialDescriptorA->u.Memory.Start.QuadPart + PartialDescriptorA->u.Memory.Length)
                    {
                        TranslatedAddress->QuadPart = PartialDescriptorT->u.Memory.Start.QuadPart + 
                                                      (IoAddress.QuadPart - PartialDescriptorA->u.Memory.Start.QuadPart);
                        return TRUE;
                    }
                    break;
            }
        }

        /* Advance to next CM_FULL_RESOURCE_DESCRIPTOR block in memory. */
        FullDescriptorA = (PCM_FULL_RESOURCE_DESCRIPTOR)(FullDescriptorA->PartialResourceList.PartialDescriptors + 
                                                         FullDescriptorA->PartialResourceList.Count);

        FullDescriptorT = (PCM_FULL_RESOURCE_DESCRIPTOR)(FullDescriptorT->PartialResourceList.PartialDescriptors + 
                                                         FullDescriptorT->PartialResourceList.Count);
    }

    return FALSE;
}

Referenced by StorPortGetDeviceBase().