miniport.c File Reference

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

Include dependency graph for miniport.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
static NTSTATUS	InitializeConfiguration (_In_ PPORT_CONFIGURATION_INFORMATION PortConfig, _In_ PHW_INITIALIZATION_DATA InitData, _In_ ULONG BusNumber, _In_ ULONG SlotNumber)
static VOID	AssignResourcesToConfiguration (_In_ PPORT_CONFIGURATION_INFORMATION PortConfiguration, _In_ PCM_RESOURCE_LIST ResourceList, _In_ ULONG NumberOfAccessRanges)
NTSTATUS	MiniportInitialize (_In_ PMINIPORT Miniport, _In_ PFDO_DEVICE_EXTENSION DeviceExtension, _In_ PHW_INITIALIZATION_DATA InitData)
NTSTATUS	MiniportFindAdapter (_In_ PMINIPORT Miniport)
NTSTATUS	MiniportHwInitialize (_In_ PMINIPORT Miniport)
VOID NTAPI	MiniportFreeAdapterResources (_In_ PMINIPORT Miniport)
	Tells the miniport the adapter is going away.
BOOLEAN	MiniportHwInterrupt (_In_ PMINIPORT Miniport)
VOID NTAPI	MiniportQueryAdapterControl (_In_ PMINIPORT Miniport)
	Asks the miniport which adapter control requests it handles.
SCSI_ADAPTER_CONTROL_STATUS NTAPI	MiniportAdapterControl (_In_ PMINIPORT Miniport, _In_ SCSI_ADAPTER_CONTROL_TYPE ControlType, _In_opt_ PVOID Parameters)
	Sends one adapter control request, if the miniport claimed it.
VOID NTAPI	MiniportQueryUnitControl (_In_ PMINIPORT Miniport)
	Asks the miniport which unit control requests it handles.
SCSI_UNIT_CONTROL_STATUS NTAPI	MiniportUnitControl (_In_ PMINIPORT Miniport, _In_ SCSI_UNIT_CONTROL_TYPE ControlType, _In_opt_ PVOID Parameters)
	Sends one unit control request, if the miniport claimed it.
BOOLEAN NTAPI	MiniportHwMSInterrupt (_In_ PMINIPORT Miniport, _In_ ULONG MessageId)
BOOLEAN	MiniportStartIo (_In_ PMINIPORT Miniport, _In_ PSCSI_REQUEST_BLOCK Srb)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file miniport.c.

Function Documentation

AssignResourcesToConfiguration()

static VOID AssignResourcesToConfiguration ( _In_ PPORT_CONFIGURATION_INFORMATION  PortConfiguration, _In_ PCM_RESOURCE_LIST  ResourceList, _In_ ULONG  NumberOfAccessRanges  )

static

Definition at line 113 of file miniport.c.

{
    PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptor;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
    PCM_PARTIAL_RESOURCE_LIST PartialResourceList;
    PACCESS_RANGE AccessRange;
    INT i, j;
    ULONG RangeNumber = 0, Interrupt = 0, Dma = 0;
 
    DPRINT1("AssignResourceToConfiguration(%p %p %lu)\n",
            PortConfiguration, ResourceList, NumberOfAccessRanges);
 
    /* A virtual miniport sits on a bus that hands out no resources at all */
    if (ResourceList == NULL)
        return;
 
    FullDescriptor = &ResourceList->List[0];
    for (i = 0; i < ResourceList->Count; i++)
    {
        PartialResourceList = &FullDescriptor->PartialResourceList;
 
        for (j = 0; j < PartialResourceList->Count; j++)
        {
            PartialDescriptor = &PartialResourceList->PartialDescriptors[j];
 
            switch (PartialDescriptor->Type)
            {
                case CmResourceTypePort:
                    DPRINT1("Port: 0x%I64x (0x%lx)\n",
                            PartialDescriptor->u.Port.Start.QuadPart,
                            PartialDescriptor->u.Port.Length);
                    if (RangeNumber < NumberOfAccessRanges)
                    {
                        AccessRange = &((*(PortConfiguration->AccessRanges))[RangeNumber]);
                        AccessRange->RangeStart = PartialDescriptor->u.Port.Start;
                        AccessRange->RangeLength = PartialDescriptor->u.Port.Length;
                        AccessRange->RangeInMemory = FALSE;
                        RangeNumber++;
                    }
                    break;
 
                case CmResourceTypeMemory:
                    DPRINT1("Memory: 0x%I64x (0x%lx)\n",
                            PartialDescriptor->u.Memory.Start.QuadPart,
                            PartialDescriptor->u.Memory.Length);
                    if (RangeNumber < NumberOfAccessRanges)
                    {
                        AccessRange = &((*(PortConfiguration->AccessRanges))[RangeNumber]);
                        AccessRange->RangeStart = PartialDescriptor->u.Memory.Start;
                        AccessRange->RangeLength = PartialDescriptor->u.Memory.Length;
                        AccessRange->RangeInMemory = TRUE;
                        RangeNumber++;
                    }
                    break;
 
                case CmResourceTypeInterrupt:
                {
                    KINTERRUPT_MODE Mode;
                    ULONG Level;
                    ULONG Vector;
 
                    /* A message interrupt is always edge triggered and has no line */
                    if (TEST_FLAG(PartialDescriptor->Flags, CM_RESOURCE_INTERRUPT_MESSAGE))
                    {
                        Mode = Latched;
                        Level = 0;
                        Vector = PartialDescriptor->u.MessageInterrupt.Raw.Vector;
 
                        DPRINT1("Message interrupt: %u messages  Vector %lu\n",
                                PartialDescriptor->u.MessageInterrupt.Raw.MessageCount,
                                Vector);
                    }
                    else
                    {
                        if (TEST_FLAG(PartialDescriptor->Flags, CM_RESOURCE_INTERRUPT_LATCHED))
                            Mode = Latched;
                        else
                            Mode = LevelSensitive;
 
                        Level = PartialDescriptor->u.Interrupt.Level;
                        Vector = PartialDescriptor->u.Interrupt.Vector;
 
                        DPRINT1("Interrupt: Level %lu  Vector %lu\n", Level, Vector);
                    }
 
                    if (Interrupt == 0)
                    {
                        PortConfiguration->BusInterruptLevel = Level;
                        PortConfiguration->BusInterruptVector = Vector;
                        PortConfiguration->InterruptMode = Mode;
                    }
                    else if (Interrupt == 1)
                    {
                        PortConfiguration->BusInterruptLevel2 = Level;
                        PortConfiguration->BusInterruptVector2 = Vector;
                        PortConfiguration->InterruptMode2 = Mode;
                    }
                    Interrupt++;
                    break;
                }
 
                case CmResourceTypeDma:
                    DPRINT1("Dma: Channel: %lu  Port: %lu\n",
                            PartialDescriptor->u.Dma.Channel,
                            PartialDescriptor->u.Dma.Port);
                    if (Dma == 0)
                    {
                        PortConfiguration->DmaChannel = PartialDescriptor->u.Dma.Channel;
                        PortConfiguration->DmaPort = PartialDescriptor->u.Dma.Port;
 
                        if (PartialDescriptor->Flags & CM_RESOURCE_DMA_8)
                            PortConfiguration->DmaWidth = Width8Bits;
                        else if ((PartialDescriptor->Flags & CM_RESOURCE_DMA_16) ||
                                 (PartialDescriptor->Flags & CM_RESOURCE_DMA_8_AND_16))
                            PortConfiguration->DmaWidth = Width16Bits;
                        else if (PartialDescriptor->Flags & CM_RESOURCE_DMA_32)
                            PortConfiguration->DmaWidth = Width32Bits;
                    }
                    else if (Dma == 1)
                    {
                        PortConfiguration->DmaChannel2 = PartialDescriptor->u.Dma.Channel;
                        PortConfiguration->DmaPort2 = PartialDescriptor->u.Dma.Port;
 
                        if (PartialDescriptor->Flags & CM_RESOURCE_DMA_8)
                            PortConfiguration->DmaWidth2 = Width8Bits;
                        else if ((PartialDescriptor->Flags & CM_RESOURCE_DMA_16) ||
                                 (PartialDescriptor->Flags & CM_RESOURCE_DMA_8_AND_16))
                            PortConfiguration->DmaWidth2 = Width16Bits;
                        else if (PartialDescriptor->Flags & CM_RESOURCE_DMA_32)
                            PortConfiguration->DmaWidth2 = Width32Bits;
                    }
                    Dma++;
                    break;
 
                default:
                    DPRINT1("Other: %u\n", PartialDescriptor->Type);
                    break;
            }
        }
 
        /* Advance to next CM_FULL_RESOURCE_DESCRIPTOR block in memory. */
        FullDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR)(FullDescriptor->PartialResourceList.PartialDescriptors +
                                                        FullDescriptor->PartialResourceList.Count);
    }
}

Referenced by MiniportInitialize().

InitializeConfiguration()

static NTSTATUS InitializeConfiguration ( _In_ PPORT_CONFIGURATION_INFORMATION  PortConfig, _In_ PHW_INITIALIZATION_DATA  InitData, _In_ ULONG  BusNumber, _In_ ULONG  SlotNumber  )

static

Definition at line 20 of file miniport.c.

{
    PCONFIGURATION_INFORMATION ConfigInfo;
    ULONG i;
 
    DPRINT1("InitializeConfiguration(%p %p %lu %lu)\n",
            PortConfig, InitData, BusNumber, SlotNumber);
 
    /* Get the configurration information */
    ConfigInfo = IoGetConfigurationInformation();
 
    /* Initialize the port configuration */
    RtlZeroMemory(PortConfig,
                  sizeof(PORT_CONFIGURATION_INFORMATION));
 
    PortConfig->Length = sizeof(PORT_CONFIGURATION_INFORMATION);
    PortConfig->SystemIoBusNumber = BusNumber;
    PortConfig->SlotNumber = SlotNumber;
    PortConfig->AdapterInterfaceType = InitData->AdapterInterfaceType;
 
    PortConfig->MaximumTransferLength = SP_UNINITIALIZED_VALUE;
    PortConfig->DmaChannel = SP_UNINITIALIZED_VALUE;
    PortConfig->DmaPort = SP_UNINITIALIZED_VALUE;
 
    PortConfig->InterruptMode = LevelSensitive;
 
    PortConfig->Master = TRUE;
    PortConfig->AtdiskPrimaryClaimed = ConfigInfo->AtDiskPrimaryAddressClaimed;
    PortConfig->AtdiskSecondaryClaimed = ConfigInfo->AtDiskSecondaryAddressClaimed;
    PortConfig->Dma32BitAddresses = TRUE;
    PortConfig->DemandMode = FALSE;
    PortConfig->MapBuffers = InitData->MapBuffers;
 
    PortConfig->NeedPhysicalAddresses = TRUE;
    PortConfig->TaggedQueuing = TRUE;
    PortConfig->AutoRequestSense = TRUE;
    PortConfig->MultipleRequestPerLu = TRUE;
    PortConfig->ReceiveEvent = InitData->ReceiveEvent;
    PortConfig->RealModeInitialized = FALSE;
    PortConfig->BufferAccessScsiPortControlled = TRUE;
    PortConfig->MaximumNumberOfTargets = SCSI_MAXIMUM_TARGETS_PER_BUS;
 
    PortConfig->SpecificLuExtensionSize = InitData->SpecificLuExtensionSize;
    PortConfig->SrbExtensionSize = InitData->SrbExtensionSize;
    PortConfig->MaximumNumberOfLogicalUnits = SCSI_MAXIMUM_LOGICAL_UNITS;
    PortConfig->WmiDataProvider = TRUE;
 
    PortConfig->NumberOfAccessRanges = InitData->NumberOfAccessRanges;
    DPRINT1("NumberOfAccessRanges: %lu\n", PortConfig->NumberOfAccessRanges);
    if (PortConfig->NumberOfAccessRanges != 0)
    {
        PortConfig->AccessRanges = ExAllocatePoolWithTag(NonPagedPool,
                                                         PortConfig->NumberOfAccessRanges * sizeof(ACCESS_RANGE),
                                                         TAG_ACCRESS_RANGE);
        if (PortConfig->AccessRanges == NULL)
            return STATUS_NO_MEMORY;
 
        RtlZeroMemory(PortConfig->AccessRanges,
                      PortConfig->NumberOfAccessRanges * sizeof(ACCESS_RANGE));
    }
 
    for (i = 0; i < RTL_NUMBER_OF(PortConfig->InitiatorBusId); i++)
    {
        PortConfig->InitiatorBusId[i] = (CCHAR)SP_UNINITIALIZED_VALUE;
    }
 
    /* Default per-adapter outstanding IO limit, as per storport documentation. */
    PortConfig->MaxNumberOfIO = 1000;
 
    /* Only a Win8 or later init data block carries the request format flags */
    PortConfig->SrbType = SRB_TYPE_SCSI_REQUEST_BLOCK;
    if (InitData->HwInitializationDataSize >=
        RTL_SIZEOF_THROUGH_FIELD(HW_INITIALIZATION_DATA, SrbTypeFlags) &&
        TEST_FLAG(InitData->SrbTypeFlags, SRB_TYPE_FLAG_STORAGE_REQUEST_BLOCK))
    {
        PortConfig->SrbType = SRB_TYPE_STORAGE_REQUEST_BLOCK;
    }
 
    /* Bus, target and LUN is the only addressing we hand out */
    PortConfig->AddressType = STORAGE_ADDRESS_TYPE_BTL8;
 
    DPRINT1("SrbType: %u\n", PortConfig->SrbType);
 
    return STATUS_SUCCESS;
}

Referenced by MiniportInitialize().

MiniportAdapterControl()

SCSI_ADAPTER_CONTROL_STATUS NTAPI MiniportAdapterControl	(	_In_ PMINIPORT	Miniport,
		_In_ SCSI_ADAPTER_CONTROL_TYPE	ControlType,
		_In_opt_ PVOID	Parameters
	)

Sends one adapter control request, if the miniport claimed it.

Definition at line 504 of file miniport.c.

{
    DPRINT("MiniportAdapterControl(%p %u %p)\n",
            Miniport, ControlType, Parameters);
 
    ASSERT(ControlType < ScsiAdapterControlMax);
    if (!(Miniport->AdapterControlSupportedBitmap & (1 << ControlType)))
    {
        return ScsiAdapterControlUnsuccessful;
    }
 
    return Miniport->InitData->HwAdapterControl(&Miniport->MiniportExtension->HwDeviceExtension,
                                                ControlType,
                                                Parameters);
}

Referenced by PortFdoStopAdapter().

MiniportFindAdapter()

NTSTATUS MiniportFindAdapter

(

_In_ PMINIPORT

Miniport

)

Definition at line 325 of file miniport.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension = Miniport->DeviceExtension;
    BOOLEAN Reserved = FALSE;
    ULONG Result;
    NTSTATUS Status;
 
    DPRINT1("MiniportFindAdapter(%p)\n", Miniport);
 
    /* HwFindAdapter is typeless since Win8, a virtual miniport puts a PVIRTUAL_HW_FIND_ADAPTER there */
    if (Miniport->IsVirtual)
    {
        PVIRTUAL_HW_FIND_ADAPTER FindAdapter;
 
        FindAdapter = (PVIRTUAL_HW_FIND_ADAPTER)Miniport->InitData->HwFindAdapter;
 
        Result = FindAdapter(&Miniport->MiniportExtension->HwDeviceExtension,
                             DeviceExtension->PhysicalDevice,
                             DeviceExtension->Device,
                             DeviceExtension->LowerDevice,
                             NULL,
                             &Miniport->PortConfig,
                             &Reserved);
    }
    else
    {
        PHW_FIND_ADAPTER FindAdapter;
 
        FindAdapter = (PHW_FIND_ADAPTER)Miniport->InitData->HwFindAdapter;
 
        Result = FindAdapter(&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().

MiniportFreeAdapterResources()

VOID NTAPI MiniportFreeAdapterResources

(

_In_ PMINIPORT

Miniport

)

Tells the miniport the adapter is going away.

Definition at line 419 of file miniport.c.

{
    if (Miniport->MiniportExtension == NULL ||
        Miniport->InitData->HwInitializationDataSize != sizeof(*Miniport->InitData) ||
        Miniport->InitData->HwFreeAdapterResources == NULL)
    {
        return;
    }
 
    DPRINT1("MiniportFreeAdapterResources(%p)\n", Miniport);
 
    Miniport->InitData->HwFreeAdapterResources(&Miniport->MiniportExtension->HwDeviceExtension);
}

Referenced by PortFdoPnp().

MiniportHwInitialize()

NTSTATUS MiniportHwInitialize

(

_In_ PMINIPORT

Miniport

)

Definition at line 399 of file miniport.c.

{
    BOOLEAN Result;
 
    DPRINT("MiniportHwInitialize(%p)\n", Miniport);
 
    /* Call the miniport HwInitialize routine */
    Result = Miniport->InitData->HwInitialize(&Miniport->MiniportExtension->HwDeviceExtension);
    DPRINT("HwInitialize() returned %u\n", Result);
 
    return Result ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
}

Referenced by PortFdoStartMiniport().

MiniportHwInterrupt()

BOOLEAN MiniportHwInterrupt

(

_In_ PMINIPORT

Miniport

)

Definition at line 436 of file miniport.c.

{
    BOOLEAN Result;
 
    DPRINT("MiniportHwInterrupt(%p)\n",
            Miniport);
 
    Result = Miniport->InitData->HwInterrupt(&Miniport->MiniportExtension->HwDeviceExtension);
    DPRINT("HwInterrupt() returned %u\n", Result);
 
    return Result;
}

Referenced by PortFdoInterruptRoutine().

MiniportHwMSInterrupt()

BOOLEAN NTAPI MiniportHwMSInterrupt	(	_In_ PMINIPORT	Miniport,
		_In_ ULONG	MessageId
	)

Definition at line 603 of file miniport.c.

{
    BOOLEAN Result;
 
    DPRINT("MiniportHwMSInterrupt(%p %lu)\n",
            Miniport, MessageId);
 
    Result = Miniport->PortConfig.HwMSInterruptRoutine(&Miniport->MiniportExtension->HwDeviceExtension,
                                                       MessageId);
    DPRINT("HwMSInterruptRoutine() returned %u\n", Result);
 
    return Result;
}

Referenced by PortFdoMessageInterruptRoutine().

MiniportInitialize()

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

Definition at line 264 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;
 
    /* Win7 virtual miniports used a shorter structure, Win8 ones set a feature flag */
    Miniport->IsVirtual = (InitData->HwInitializationDataSize == HW_INIT_DATA_SIZE_VIRTUAL_LEGACY) ||
                          ((InitData->HwInitializationDataSize == sizeof(*InitData)) &&
                           (InitData->FeatureSupport & STOR_FEATURE_VIRTUAL_MINIPORT));
    DPRINT1("Miniport is %s\n", Miniport->IsVirtual ? "virtual" : "physical");
 
    /* Calculate the miniport device extension size */
    Status = RtlULongAdd(sizeof(*MiniportExtension),
                         Miniport->InitData->DeviceExtensionSize,
                         &Size);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Invalid miniport extension size %lx\n", Miniport->InitData->DeviceExtensionSize);
        return Status;
    }
 
    /* 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;
}

MiniportQueryAdapterControl()

VOID NTAPI MiniportQueryAdapterControl

(

_In_ PMINIPORT

Miniport

)

Asks the miniport which adapter control requests it handles.

Definition at line 456 of file miniport.c.

{
    PSCSI_SUPPORTED_CONTROL_TYPE_LIST List;
    SCSI_ADAPTER_CONTROL_STATUS Result;
    ULONG Length;
    ULONG Type;
 
    Miniport->AdapterControlSupportedBitmap = 0;
 
    if (Miniport->InitData->HwAdapterControl == NULL)
        return;
 
    Length = sizeof(*List) +
             (ScsiAdapterControlMax * sizeof(List->SupportedTypeList[0]));
 
    List = ExAllocatePoolZero(NonPagedPool, Length, TAG_MINIPORT_DATA);
    if (List == NULL)
        return;
 
    List->MaxControlType = ScsiAdapterControlMax;
 
    Result = Miniport->InitData->HwAdapterControl(&Miniport->MiniportExtension->HwDeviceExtension,
                                                  ScsiQuerySupportedControlTypes,
                                                  List);
    if (Result == ScsiAdapterControlSuccess)
    {
        for (Type = 0; Type < ScsiAdapterControlMax; Type++)
        {
            C_ASSERT(ScsiAdapterControlMax <= RTL_BITS_OF(Miniport->AdapterControlSupportedBitmap));
 
            if (List->SupportedTypeList[Type])
            {
                DPRINT1("Adapter control %lu supported\n", Type);
                Miniport->AdapterControlSupportedBitmap |= 1 << Type;
            }
        }
    }
 
    ExFreePoolWithTag(List, TAG_MINIPORT_DATA);
}

Referenced by PortFdoStartMiniport().

MiniportQueryUnitControl()

VOID NTAPI MiniportQueryUnitControl

(

_In_ PMINIPORT

Miniport

)

Asks the miniport which unit control requests it handles.

Definition at line 529 of file miniport.c.

{
    PSCSI_SUPPORTED_CONTROL_TYPE_LIST List;
    SCSI_UNIT_CONTROL_STATUS Result;
    ULONG Length;
    ULONG Type;
 
    Miniport->UnitControlSupportedBitmap = 0;
 
    if (Miniport->InitData->HwInitializationDataSize <
        RTL_SIZEOF_THROUGH_FIELD(HW_INITIALIZATION_DATA, HwUnitControl) ||
        Miniport->InitData->HwUnitControl == NULL)
    {
        return;
    }
 
    Length = sizeof(*List) +
             (ScsiUnitControlMax * sizeof(List->SupportedTypeList[0]));
 
    List = ExAllocatePoolZero(NonPagedPool, Length, TAG_MINIPORT_DATA);
    if (List == NULL)
        return;
 
    List->MaxControlType = ScsiUnitControlMax;
 
    Result = Miniport->InitData->HwUnitControl(&Miniport->MiniportExtension->HwDeviceExtension,
                                               ScsiQuerySupportedUnitControlTypes,
                                               List);
    if (Result == ScsiUnitControlSuccess)
    {
        for (Type = 0; Type < ScsiUnitControlMax; Type++)
        {
            C_ASSERT(ScsiUnitControlMax <= RTL_BITS_OF(Miniport->UnitControlSupportedBitmap));
 
            if (List->SupportedTypeList[Type])
            {
                DPRINT1("Unit control %lu supported\n", Type);
                Miniport->UnitControlSupportedBitmap |= 1 << Type;
            }
        }
    }
 
    ExFreePoolWithTag(List, TAG_MINIPORT_DATA);
}

Referenced by PortFdoStartMiniport().

MiniportStartIo()

BOOLEAN MiniportStartIo	(	_In_ PMINIPORT	Miniport,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 621 of file miniport.c.

{
    BOOLEAN Result;
 
    DPRINT("MiniportHwStartIo(%p %p)\n",
            Miniport, Srb);
 
    Result = Miniport->InitData->HwStartIo(&Miniport->MiniportExtension->HwDeviceExtension, Srb);
    DPRINT("HwStartIo() returned %u\n", Result);
 
    return Result;
}

MiniportUnitControl()

SCSI_UNIT_CONTROL_STATUS NTAPI MiniportUnitControl	(	_In_ PMINIPORT	Miniport,
		_In_ SCSI_UNIT_CONTROL_TYPE	ControlType,
		_In_opt_ PVOID	Parameters
	)

Sends one unit control request, if the miniport claimed it.

Definition at line 581 of file miniport.c.

{
    DPRINT("MiniportUnitControl(%p %u %p)\n",
            Miniport, ControlType, Parameters);
 
    ASSERT(ControlType < ScsiUnitControlMax);
    if (!(Miniport->UnitControlSupportedBitmap & (1 << ControlType)))
    {
        return ScsiUnitControlNotSupported;
    }
 
    return Miniport->InitData->HwUnitControl(&Miniport->MiniportExtension->HwDeviceExtension,
                                             ControlType,
                                             Parameters);
}

Referenced by PortCreatePdo(), and PortDeletePdo().