ReactOS 0.4.17-dev-1190-g4c812f4
Macros | Functions | Variables
storport.c File Reference
#include "precomp.h"
#include "inline.h"
#include "wdm.h"
#include <debug.h>
#include <stdarg.h>
Include dependency graph for storport.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Functions

static NTSTATUS PortAddDriverInitData (PDRIVER_OBJECT_EXTENSION DriverExtension, PHW_INITIALIZATION_DATA HwInitializationData)
 
static VOID PortDeleteDriverInitData (PDRIVER_OBJECT_EXTENSION DriverExtension)
 
PHW_INITIALIZATION_DATA PortGetDriverInitData (PDRIVER_OBJECT_EXTENSION DriverExtension, INTERFACE_TYPE InterfaceType)
 
static VOID PortAcquireSpinLock (PFDO_DEVICE_EXTENSION DeviceExtension, STOR_SPINLOCK SpinLock, PVOID LockContext, PSTOR_LOCK_HANDLE LockHandle)
 
static VOID PortReleaseSpinLock (PFDO_DEVICE_EXTENSION DeviceExtension, PSTOR_LOCK_HANDLE LockHandle)
 
static NTSTATUS NTAPI PortAddDevice (_In_ PDRIVER_OBJECT DriverObject, _In_ PDEVICE_OBJECT PhysicalDeviceObject)
 
static VOID NTAPI PortUnload (_In_ PDRIVER_OBJECT DriverObject)
 
static NTSTATUS NTAPI PortDispatchCreate (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
static NTSTATUS NTAPI PortDispatchClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
static NTSTATUS NTAPI PortDispatchDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
static NTSTATUS NTAPI PortDispatchScsi (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
static NTSTATUS NTAPI PortDispatchSystemControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
static NTSTATUS NTAPI PortDispatchPnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
static NTSTATUS NTAPI PortDispatchPower (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS NTAPI DriverEntry (_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)
 
STORPORT_API PUCHAR NTAPI StorPortAllocateRegistryBuffer (_In_ PVOID HwDeviceExtension, _In_ PULONG Length)
 
STORPORT_API BOOLEAN NTAPI StorPortBusy (_In_ PVOID HwDeviceExtension, _In_ ULONG RequestsToComplete)
 
STORPORT_API VOID NTAPI StorPortCompleteRequest (_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun, _In_ UCHAR SrbStatus)
 
STORPORT_API ULONG NTAPI StorPortConvertPhysicalAddressToUlong (_In_ STOR_PHYSICAL_ADDRESS Address)
 
STORPORT_API STOR_PHYSICAL_ADDRESS NTAPI StorPortConvertUlongToPhysicalAddress (_In_ ULONG_PTR UlongAddress)
 
STORPORT_API VOID StorPortDebugPrint (_In_ ULONG DebugPrintLevel, _In_ PCHAR DebugMessage,...)
 
STORPORT_API BOOLEAN NTAPI StorPortDeviceBusy (_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun, _In_ ULONG RequestsToComplete)
 
STORPORT_API BOOLEAN NTAPI StorPortDeviceReady (_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun)
 
STORPORT_API ULONG StorPortExtendedFunction (_In_ STORPORT_FUNCTION_CODE FunctionCode, _In_ PVOID HwDeviceExtension,...)
 
STORPORT_API VOID NTAPI StorPortFreeDeviceBase (_In_ PVOID HwDeviceExtension, _In_ PVOID MappedAddress)
 
STORPORT_API VOID NTAPI StorPortFreeRegistryBuffer (_In_ PVOID HwDeviceExtension, _In_ PUCHAR Buffer)
 
STORPORT_API ULONG NTAPI StorPortGetBusData (_In_ PVOID DeviceExtension, _In_ ULONG BusDataType, _In_ ULONG SystemIoBusNumber, _In_ ULONG SlotNumber, _Out_ _When_(Length !=0, _Out_writes_bytes_(Length)) PVOID Buffer, _In_ ULONG Length)
 
STORPORT_API PVOID NTAPI StorPortGetDeviceBase (_In_ PVOID HwDeviceExtension, _In_ INTERFACE_TYPE BusType, _In_ ULONG SystemIoBusNumber, _In_ STOR_PHYSICAL_ADDRESS IoAddress, _In_ ULONG NumberOfBytes, _In_ BOOLEAN InIoSpace)
 
STORPORT_API PVOID NTAPI StorPortGetLogicalUnit (_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun)
 
STORPORT_API STOR_PHYSICAL_ADDRESS NTAPI StorPortGetPhysicalAddress (_In_ PVOID HwDeviceExtension, _In_opt_ PSCSI_REQUEST_BLOCK Srb, _In_ PVOID VirtualAddress, _Out_ ULONG *Length)
 
STORPORT_API PSTOR_SCATTER_GATHER_LIST NTAPI StorPortGetScatterGatherList (_In_ PVOID HwDeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb)
 
STORPORT_API PSCSI_REQUEST_BLOCK NTAPI StorPortGetSrb (_In_ PVOID DeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun, _In_ LONG QueueTag)
 
STORPORT_API PVOID NTAPI StorPortGetUncachedExtension (_In_ PVOID HwDeviceExtension, _In_ PPORT_CONFIGURATION_INFORMATION ConfigInfo, _In_ ULONG NumberOfBytes)
 
STORPORT_API PVOID NTAPI StorPortGetVirtualAddress (_In_ PVOID HwDeviceExtension, _In_ STOR_PHYSICAL_ADDRESS PhysicalAddress)
 
STORPORT_API ULONG NTAPI StorPortInitialize (_In_ PVOID Argument1, _In_ PVOID Argument2, _In_ struct _HW_INITIALIZATION_DATA *HwInitializationData, _In_opt_ PVOID HwContext)
 
STORPORT_API VOID NTAPI StorPortLogError (_In_ PVOID HwDeviceExtension, _In_opt_ PSCSI_REQUEST_BLOCK Srb, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun, _In_ ULONG ErrorCode, _In_ ULONG UniqueId)
 
STORPORT_API VOID NTAPI StorPortMoveMemory (_Out_writes_bytes_(Length) PVOID Destination, _In_reads_bytes_(Length) PVOID Source, _In_ ULONG Length)
 
STORPORT_API VOID StorPortNotification (_In_ SCSI_NOTIFICATION_TYPE NotificationType, _In_ PVOID HwDeviceExtension,...)
 
STORPORT_API BOOLEAN NTAPI StorPortPause (_In_ PVOID HwDeviceExtension, _In_ ULONG TimeOut)
 
STORPORT_API BOOLEAN NTAPI StorPortPauseDevice (_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun, _In_ ULONG TimeOut)
 
STORPORT_API BOOLEAN NTAPI StorPortReady (_In_ PVOID HwDeviceExtension)
 
STORPORT_API BOOLEAN NTAPI StorPortRegistryRead (_In_ PVOID HwDeviceExtension, _In_ PUCHAR ValueName, _In_ ULONG Global, _In_ ULONG Type, _In_ PUCHAR Buffer, _In_ PULONG BufferLength)
 
STORPORT_API BOOLEAN NTAPI StorPortRegistryWrite (_In_ PVOID HwDeviceExtension, _In_ PUCHAR ValueName, _In_ ULONG Global, _In_ ULONG Type, _In_ PUCHAR Buffer, _In_ ULONG BufferLength)
 
STORPORT_API BOOLEAN NTAPI StorPortResume (_In_ PVOID HwDeviceExtension)
 
STORPORT_API BOOLEAN NTAPI StorPortResumeDevice (_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun)
 
STORPORT_API ULONG NTAPI StorPortSetBusDataByOffset (_In_ PVOID DeviceExtension, _In_ ULONG BusDataType, _In_ ULONG SystemIoBusNumber, _In_ ULONG SlotNumber, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Offset, _In_ ULONG Length)
 
STORPORT_API BOOLEAN NTAPI StorPortSetDeviceQueueDepth (_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun, _In_ ULONG Depth)
 
STORPORT_API VOID NTAPI StorPortStallExecution (_In_ ULONG Delay)
 
STORPORT_API VOID NTAPI StorPortSynchronizeAccess (_In_ PVOID HwDeviceExtension, _In_ PSTOR_SYNCHRONIZED_ACCESS SynchronizedAccessRoutine, _In_opt_ PVOID Context)
 
STORPORT_API BOOLEAN NTAPI StorPortValidateRange (_In_ PVOID HwDeviceExtension, _In_ INTERFACE_TYPE BusType, _In_ ULONG SystemIoBusNumber, _In_ STOR_PHYSICAL_ADDRESS IoAddress, _In_ ULONG NumberOfBytes, _In_ BOOLEAN InIoSpace)
 

Variables

ULONG PortNumber = 0
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 14 of file storport.c.

Function Documentation

◆ DriverEntry()

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

Definition at line 510 of file storport.c.

513{
514 DPRINT1("DriverEntry(%p %p)\n", DriverObject, RegistryPath);
515 return STATUS_SUCCESS;
516}
DPRINT1
#define DPRINT1
Definition: precomp.h:8
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
RegistryPath
_Must_inspect_result_ _In_ PDRIVER_OBJECT _In_ PCUNICODE_STRING RegistryPath
Definition: wdfdriver.h:215
DriverObject
_Must_inspect_result_ _In_ PDRIVER_OBJECT DriverObject
Definition: wdfdriver.h:213

◆ PortAcquireSpinLock()

static VOID PortAcquireSpinLock ( PFDO_DEVICE_EXTENSION  DeviceExtension,
STOR_SPINLOCK  SpinLock,
PVOID  LockContext,
PSTOR_LOCK_HANDLE  LockHandle 
)
static

Definition at line 108 of file storport.c.

113{
114 DPRINT("PortAcquireSpinLock(%p %lu %p %p)\n",
115 DeviceExtension, SpinLock, LockContext, LockHandle);
116
117 LockHandle->Lock = SpinLock;
118
119 switch (SpinLock)
120 {
121 case DpcLock: /* 1, */
122 DPRINT("DpcLock\n");
123 break;
124
125 case StartIoLock: /* 2 */
126 DPRINT("StartIoLock\n");
127 break;
128
129 case InterruptLock: /* 3 */
130 DPRINT("InterruptLock\n");
131 if (DeviceExtension->Interrupt == NULL)
132 LockHandle->Context.OldIrql = 0;
133 else
134 LockHandle->Context.OldIrql = KeAcquireInterruptSpinLock(DeviceExtension->Interrupt);
135 break;
136 }
137}
NULL
#define NULL
Definition: types.h:112
KeAcquireInterruptSpinLock
KIRQL NTAPI KeAcquireInterruptSpinLock(IN PKINTERRUPT Interrupt)
Definition: spinlock.c:154
DPRINT
#define DPRINT
Definition: sndvol32.h:73
StartIoLock
@ StartIoLock
Definition: storport.h:508
InterruptLock
@ InterruptLock
Definition: storport.h:509
DpcLock
@ DpcLock
Definition: storport.h:507
_FDO_DEVICE_EXTENSION::Interrupt
PKINTERRUPT Interrupt
Definition: parport.h:48
_KLOCK_QUEUE_HANDLE::OldIrql
KIRQL OldIrql
Definition: ketypes.h:696
SpinLock
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFSPINLOCK * SpinLock
Definition: wdfsync.h:228
LockHandle
*LockHandle LockHandle _Out_ PKLOCK_QUEUE_HANDLE LockHandle
Definition: kefuncs.h:717

Referenced by StorPortNotification().

◆ PortAddDevice()

static NTSTATUS NTAPI PortAddDevice ( _In_ PDRIVER_OBJECT  DriverObject,
_In_ PDEVICE_OBJECT  PhysicalDeviceObject 
)
static

Definition at line 172 of file storport.c.

175{
176 PDRIVER_OBJECT_EXTENSION DriverObjectExtension;
177 PFDO_DEVICE_EXTENSION DeviceExtension = NULL;
178 WCHAR NameBuffer[sizeof("\\Device\\RaidPort4294967295")];
179 UNICODE_STRING DeviceName;
180 PDEVICE_OBJECT Fdo = NULL;
181 NTSTATUS Status;
182
183 DPRINT1("PortAddDevice(%p %p)\n",
184 DriverObject, PhysicalDeviceObject);
185
186 ASSERT(DriverObject);
187 ASSERT(PhysicalDeviceObject);
188
189 Status = RtlStringCbPrintfW(NameBuffer,
190 sizeof(NameBuffer),
191 L"\\Device\\RaidPort%lu",
192 PortNumber);
193 ASSERT(NT_SUCCESS(Status));
194 RtlInitUnicodeString(&DeviceName, NameBuffer);
195 PortNumber++;
196
197 DPRINT1("Creating device: %wZ\n", &DeviceName);
198
199 /* Create the port device */
200 Status = IoCreateDevice(DriverObject,
201 sizeof(FDO_DEVICE_EXTENSION),
202 &DeviceName,
203 FILE_DEVICE_CONTROLLER,
204 FILE_DEVICE_SECURE_OPEN,
205 FALSE,
206 &Fdo);
207 if (!NT_SUCCESS(Status))
208 {
209 DPRINT1("IoCreateDevice() failed (Status 0x%08lx)\n", Status);
210 return Status;
211 }
212
213 DPRINT1("Created device: %wZ (%p)\n", &DeviceName, Fdo);
214
215 /* Initialize the device */
216 Fdo->Flags |= DO_DIRECT_IO;
217 Fdo->Flags |= DO_POWER_PAGABLE;
218
219 /* Initialize the device extension */
220 DeviceExtension = (PFDO_DEVICE_EXTENSION)Fdo->DeviceExtension;
221 RtlZeroMemory(DeviceExtension, sizeof(FDO_DEVICE_EXTENSION));
222
223 DeviceExtension->ExtensionType = FdoExtension;
224
225 DeviceExtension->Device = Fdo;
226 DeviceExtension->PhysicalDevice = PhysicalDeviceObject;
227
228 DeviceExtension->PnpState = dsStopped;
229
230 DeviceExtension->ScsiPortNumber = -1;
231
232 KeInitializeSpinLock(&DeviceExtension->PdoListLock);
233 InitializeListHead(&DeviceExtension->PdoListHead);
234
235 KeInitializeSpinLock(&DeviceExtension->TimerListLock);
236 InitializeListHead(&DeviceExtension->TimerListHead);
237
238 /* Initialize simple timer for StorPortNotification */
239 KeInitializeTimer(&DeviceExtension->Timer);
240 KeInitializeDpc(&DeviceExtension->TimerDpc, SimpleTimerCallbackDpcRoutine, DeviceExtension);
241
242 /* Initialize FDO Device DPC for delayed completion */
243 KeInitializeDpc(&Fdo->Dpc, PortCompletionDpc, DeviceExtension);
244
245 /* Initialize completion list header */
246 InitializeSListHead(&DeviceExtension->CompletionList);
247
248 /* Initialize the request reference lookaside list */
249 ExInitializeNPagedLookasideList(&DeviceExtension->RequestReferenceLookaside,
250 NULL,
251 NULL,
252 0,
253 sizeof(QUEUED_REQUEST_REFERENCE),
254 TAG_QUEUED_REQUEST,
255 0);
256
257 /* Initialize the queue for requests waiting on memory */
258 PortInitializeStarvedRequestQueue(&DeviceExtension->StarvedRequests);
259
260 /* Initialize FDO flow control structure */
261 KeInitializeSpinLock(&DeviceExtension->FlowControl.Lock);
262 DeviceExtension->FlowControl.IsBusy = FALSE;
263 DeviceExtension->FlowControl.IsPaused = FALSE;
264 DeviceExtension->FlowControl.RemainingBusyRequests = 0;
265 DeviceExtension->FlowControl.RemainingPauseTime = 0;
266 DeviceExtension->FlowControl.OutstandingRequestCount = 0;
267 InitializeListHead(&DeviceExtension->FlowControl.FdoBlockedRequestsListHead);
268
269 /* Attach the FDO to the device stack */
270 Status = IoAttachDeviceToDeviceStackSafe(Fdo,
271 PhysicalDeviceObject,
272 &DeviceExtension->LowerDevice);
273 if (!NT_SUCCESS(Status))
274 {
275 DPRINT1("IoAttachDeviceToDeviceStackSafe() failed (Status 0x%08lx)\n", Status);
276 IoDeleteDevice(Fdo);
277 return Status;
278 }
279
280 /* Insert the FDO to the drivers FDO list */
281 DriverObjectExtension = IoGetDriverObjectExtension(DriverObject,
282 (PVOID)DriverEntry);
283 ASSERT(DriverObjectExtension->ExtensionType == DriverExtension);
284
285 DeviceExtension->DriverExtension = DriverObjectExtension;
286
287 StorpInterlockedInsertHeadListCounted(&DriverObjectExtension->AdapterListLock,
288 &DriverObjectExtension->AdapterListHead,
289 &DeviceExtension->AdapterListEntry,
290 &DriverObjectExtension->AdapterCount);
291
292 /* The device has been initialized */
293 Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
294
295 DPRINT1("PortAddDevice() done (Status 0x%08lx)\n", Status);
296
297 return Status;
298}
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
PhysicalDeviceObject
PDEVICE_OBJECT PhysicalDeviceObject
Definition: btrfs_drv.h:1157
FILE_DEVICE_SECURE_OPEN
#define FILE_DEVICE_SECURE_OPEN
Definition: cdrw_usr.h:46
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
KeInitializeDpc
VOID NTAPI KeInitializeDpc(IN PKDPC Dpc, IN PKDEFERRED_ROUTINE DeferredRoutine, IN PVOID DeferredContext)
Definition: dpc.c:712
DriverEntry
DRIVER_INITIALIZE DriverEntry
Definition: condrv.c:21
L
#define L(x)
Definition: resources.c:13
PFDO_DEVICE_EXTENSION
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
SimpleTimerCallbackDpcRoutine
VOID NTAPI SimpleTimerCallbackDpcRoutine(PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
Definition: misc.c:327
TAG_QUEUED_REQUEST
#define TAG_QUEUED_REQUEST
Definition: precomp.h:40
FdoExtension
@ FdoExtension
Definition: precomp.h:60
PortCompletionDpc
VOID NTAPI PortCompletionDpc(_In_ PKDPC Dpc, _In_ PVOID Context, _In_ PVOID SystemArgument1, _In_ PVOID SystemArgument2)
Definition: srb.c:894
DO_DIRECT_IO
#define DO_DIRECT_IO
Definition: env_spec_w32.h:396
InitializeListHead
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
KeInitializeSpinLock
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
Status
Status
Definition: gdiplustypes.h:24
PortNumber
_In_ ULONG PortNumber
Definition: hubucx.h:272
StorpInterlockedInsertHeadListCounted
FORCEINLINE ULONG StorpInterlockedInsertHeadListCounted(_In_ PKSPIN_LOCK SpinLock, _In_ PLIST_ENTRY ListHead, _In_ PLIST_ENTRY Entry, _In_ PULONG Counter)
InsertHeadList and increment element counter with a corresponding spin lock held.
Definition: inline.h:71
dsStopped
@ dsStopped
Definition: isapnp.h:30
ExInitializeNPagedLookasideList
VOID NTAPI ExInitializeNPagedLookasideList(IN PNPAGED_LOOKASIDE_LIST Lookaside, IN PALLOCATE_FUNCTION Allocate OPTIONAL, IN PFREE_FUNCTION Free OPTIONAL, IN ULONG Flags, IN SIZE_T Size, IN ULONG Tag, IN USHORT Depth)
Definition: lookas.c:218
ASSERT
#define ASSERT(a)
Definition: mode.c:44
RtlInitUnicodeString
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
IoCreateDevice
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1038
IoAttachDeviceToDeviceStackSafe
NTSTATUS NTAPI IoAttachDeviceToDeviceStackSafe(IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice, IN OUT PDEVICE_OBJECT *AttachedToDeviceObject)
Definition: device.c:987
IoDeleteDevice
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1261
IoGetDriverObjectExtension
PVOID NTAPI IoGetDriverObjectExtension(IN PDRIVER_OBJECT DriverObject, IN PVOID ClientIdentificationAddress)
Definition: driver.c:1925
RtlStringCbPrintfW
NTSTRSAFEVAPI RtlStringCbPrintfW(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1173
DriverExtension
PPCI_DRIVER_EXTENSION DriverExtension
Definition: pci.c:31
WCHAR
short WCHAR
Definition: pedump.c:58
FILE_DEVICE_CONTROLLER
#define FILE_DEVICE_CONTROLLER
Definition: winioctl.h:49
PortInitializeStarvedRequestQueue
NTSTATUS PortInitializeStarvedRequestQueue(_In_ PSTARVED_REQUEST_QUEUE Queue)
Definition: fdo.c:105
FDO_DEVICE_EXTENSION
Definition: usbccgp.h:18
_DEVICE_OBJECT
Definition: env_spec_w32.h:413
_DRIVER_OBJECT_EXTENSION
Definition: precomp.h:71
_DRIVER_OBJECT_EXTENSION::AdapterListHead
LIST_ENTRY AdapterListHead
Definition: precomp.h:76
_DRIVER_OBJECT_EXTENSION::AdapterCount
ULONG AdapterCount
Definition: precomp.h:77
_DRIVER_OBJECT_EXTENSION::AdapterListLock
KSPIN_LOCK AdapterListLock
Definition: precomp.h:75
_DRIVER_OBJECT_EXTENSION::ExtensionType
EXTENSION_TYPE ExtensionType
Definition: precomp.h:72
_FDO_DEVICE_EXTENSION
Definition: pci.h:82
_FDO_DEVICE_EXTENSION::LowerDevice
PDEVICE_OBJECT LowerDevice
Definition: i8042prt.h:130
_FDO_DEVICE_EXTENSION::PhysicalDevice
PDEVICE_OBJECT PhysicalDevice
Definition: precomp.h:234
_FDO_DEVICE_EXTENSION::PdoListHead
LIST_ENTRY PdoListHead
Definition: precomp.h:256
_FDO_DEVICE_EXTENSION::Timer
KTIMER Timer
Definition: precomp.h:264
_FDO_DEVICE_EXTENSION::PdoListLock
KSPIN_LOCK PdoListLock
Definition: precomp.h:255
_FDO_DEVICE_EXTENSION::TimerListHead
LIST_ENTRY TimerListHead
Definition: precomp.h:268
_FDO_DEVICE_EXTENSION::RequestReferenceLookaside
NPAGED_LOOKASIDE_LIST RequestReferenceLookaside
Definition: precomp.h:281
_FDO_DEVICE_EXTENSION::PnpState
DEVICE_STATE PnpState
Definition: i8042prt.h:132
_FDO_DEVICE_EXTENSION::TimerDpc
KDPC TimerDpc
Definition: precomp.h:265
_FDO_DEVICE_EXTENSION::ScsiPortNumber
LONG ScsiPortNumber
Definition: precomp.h:241
_FDO_DEVICE_EXTENSION::ExtensionType
EXTENSION_TYPE ExtensionType
Definition: precomp.h:230
_FDO_DEVICE_EXTENSION::Device
PDEVICE_OBJECT Device
Definition: precomp.h:232
_FDO_DEVICE_EXTENSION::FlowControl
FDO_IO_FLOW_CONTROL FlowControl
Definition: precomp.h:272
_FDO_DEVICE_EXTENSION::AdapterListEntry
LIST_ENTRY AdapterListEntry
Definition: precomp.h:237
_FDO_DEVICE_EXTENSION::DriverExtension
PDRIVER_OBJECT_EXTENSION DriverExtension
Definition: precomp.h:235
_FDO_DEVICE_EXTENSION::TimerListLock
KSPIN_LOCK TimerListLock
Definition: precomp.h:267
_FDO_DEVICE_EXTENSION::CompletionList
SLIST_HEADER CompletionList
Definition: precomp.h:278
_FDO_DEVICE_EXTENSION::StarvedRequests
STARVED_REQUEST_QUEUE StarvedRequests
Definition: precomp.h:287
_FDO_IO_FLOW_CONTROL::FdoBlockedRequestsListHead
LIST_ENTRY FdoBlockedRequestsListHead
Definition: precomp.h:217
_FDO_IO_FLOW_CONTROL::OutstandingRequestCount
ULONG OutstandingRequestCount
Definition: precomp.h:208
_FDO_IO_FLOW_CONTROL::IsPaused
BOOLEAN IsPaused
Definition: precomp.h:205
_FDO_IO_FLOW_CONTROL::Lock
KSPIN_LOCK Lock
Definition: precomp.h:202
_FDO_IO_FLOW_CONTROL::IsBusy
BOOLEAN IsBusy
Definition: precomp.h:204
_FDO_IO_FLOW_CONTROL::RemainingBusyRequests
ULONG RemainingBusyRequests
Definition: precomp.h:210
_FDO_IO_FLOW_CONTROL::RemainingPauseTime
ULONG RemainingPauseTime
Definition: precomp.h:211
_QUEUED_REQUEST_REFERENCE
Definition: precomp.h:338
_UNICODE_STRING
Definition: env_spec_w32.h:368
KeInitializeTimer
VOID NTAPI KeInitializeTimer(OUT PKTIMER Timer)
Definition: timerobj.c:233
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
DeviceName
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3281
Fdo
_Must_inspect_result_ _In_ WDFDEVICE Fdo
Definition: wdffdo.h:461
DO_POWER_PAGABLE
#define DO_POWER_PAGABLE
InitializeSListHead
FORCEINLINE VOID InitializeSListHead(_Out_ PSLIST_HEADER SListHead)
Definition: rtlfuncs.h:3375

Referenced by StorPortInitialize().

◆ PortAddDriverInitData()

static NTSTATUS PortAddDriverInitData ( PDRIVER_OBJECT_EXTENSION  DriverExtension,
PHW_INITIALIZATION_DATA  HwInitializationData 
)
static

Definition at line 28 of file storport.c.

31{
32 PDRIVER_INIT_DATA InitData;
33
34 DPRINT1("PortAddDriverInitData()\n");
35
36 InitData = ExAllocatePoolWithTag(NonPagedPool,
37 sizeof(DRIVER_INIT_DATA),
38 TAG_INIT_DATA);
39 if (InitData == NULL)
40 return STATUS_NO_MEMORY;
41
42 RtlCopyMemory(&InitData->HwInitData,
43 HwInitializationData,
44 sizeof(HW_INITIALIZATION_DATA));
45
46 InsertHeadList(&DriverExtension->InitDataListHead,
47 &InitData->Entry);
48
49 return STATUS_SUCCESS;
50}
STATUS_NO_MEMORY
#define STATUS_NO_MEMORY
Definition: d3dkmdt.h:51
TAG_INIT_DATA
#define TAG_INIT_DATA
Definition: precomp.h:29
InsertHeadList
#define InsertHeadList(ListHead, Entry)
Definition: env_spec_w32.h:1022
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
NonPagedPool
#define NonPagedPool
Definition: env_spec_w32.h:307
HwInitializationData
_Must_inspect_result_ _In_ PVOID _In_ struct _HW_INITIALIZATION_DATA * HwInitializationData
Definition: srb.h:906
_DRIVER_INIT_DATA
Definition: precomp.h:65
_DRIVER_INIT_DATA::HwInitData
HW_INITIALIZATION_DATA HwInitData
Definition: precomp.h:67
_DRIVER_INIT_DATA::Entry
LIST_ENTRY Entry
Definition: precomp.h:66
_HW_INITIALIZATION_DATA
Definition: srb.h:548
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263

Referenced by StorPortInitialize().

◆ PortDeleteDriverInitData()

static VOID PortDeleteDriverInitData ( PDRIVER_OBJECT_EXTENSION  DriverExtension)
static

Definition at line 55 of file storport.c.

57{
58 PDRIVER_INIT_DATA InitData;
59 PLIST_ENTRY ListEntry;
60
61 DPRINT1("PortDeleteDriverInitData()\n");
62
63 ListEntry = DriverExtension->InitDataListHead.Flink;
64 while (ListEntry != &DriverExtension->InitDataListHead)
65 {
66 InitData = CONTAINING_RECORD(ListEntry,
67 DRIVER_INIT_DATA,
68 Entry);
69
70 RemoveEntryList(&InitData->Entry);
71
72 ExFreePoolWithTag(InitData,
73 TAG_INIT_DATA);
74
75 ListEntry = DriverExtension->InitDataListHead.Flink;
76 }
77}
RemoveEntryList
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
ExFreePoolWithTag
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
Entry
Entry
Definition: section.c:5216
_LIST_ENTRY
Definition: typedefs.h:120
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by PortUnload().

◆ PortDispatchClose()

static NTSTATUS NTAPI PortDispatchClose ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)
static

Definition at line 343 of file storport.c.

346{
347 DPRINT("PortDispatchClose(%p %p)\n",
348 DeviceObject, Irp);
349
350 Irp->IoStatus.Status = STATUS_SUCCESS;
351 Irp->IoStatus.Information = 0;
352
353 IoCompleteRequest(Irp, IO_NO_INCREMENT);
354
355 return STATUS_SUCCESS;
356}
Irp
_In_ PIRP Irp
Definition: kse.h:79
IoCompleteRequest
#define IoCompleteRequest
Definition: irp.c:1272
DeviceObject
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2061
IO_NO_INCREMENT
#define IO_NO_INCREMENT
Definition: iotypes.h:598

Referenced by StorPortInitialize().

◆ PortDispatchCreate()

static NTSTATUS NTAPI PortDispatchCreate ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)
static

Definition at line 324 of file storport.c.

327{
328 DPRINT("PortDispatchCreate(%p %p)\n",
329 DeviceObject, Irp);
330
331 Irp->IoStatus.Status = STATUS_SUCCESS;
332 Irp->IoStatus.Information = FILE_OPENED;
333
334 IoCompleteRequest(Irp, IO_NO_INCREMENT);
335
336 return STATUS_SUCCESS;
337}
FILE_OPENED
#define FILE_OPENED
Definition: nt_native.h:769

Referenced by StorPortInitialize().

◆ PortDispatchDeviceControl()

static NTSTATUS NTAPI PortDispatchDeviceControl ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)
static

Definition at line 362 of file storport.c.

365{
366 PFDO_DEVICE_EXTENSION DeviceExtension;
367
368 DPRINT("PortDispatchDeviceControl(%p %p)\n",
369 DeviceObject, Irp);
370
371 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
372 DPRINT("ExtensionType: %u\n", DeviceExtension->ExtensionType);
373
374 switch (DeviceExtension->ExtensionType)
375 {
376 case FdoExtension:
377 return PortFdoDeviceControl(DeviceObject,
378 Irp);
379
380 case PdoExtension:
381 return PortPdoDeviceControl(DeviceObject,
382 Irp);
383
384 default:
385 Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
386 Irp->IoStatus.Information = 0;
387 IoCompleteRequest(Irp, IO_NO_INCREMENT);
388 return STATUS_UNSUCCESSFUL;
389 }
390
391 return STATUS_SUCCESS;
392}
PortPdoDeviceControl
NTSTATUS NTAPI PortPdoDeviceControl(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
Definition: ioctl.c:378
PortFdoDeviceControl
NTSTATUS NTAPI PortFdoDeviceControl(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
Definition: ioctl.c:146
PdoExtension
@ PdoExtension
Definition: precomp.h:61
STATUS_UNSUCCESSFUL
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132

Referenced by StorPortInitialize().

◆ PortDispatchPnp()

static NTSTATUS NTAPI PortDispatchPnp ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)
static

Definition at line 453 of file storport.c.

456{
457 PFDO_DEVICE_EXTENSION DeviceExtension;
458
459 DPRINT1("PortDispatchPnp(%p %p)\n",
460 DeviceObject, Irp);
461
462 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
463 DPRINT("ExtensionType: %u\n", DeviceExtension->ExtensionType);
464
465 switch (DeviceExtension->ExtensionType)
466 {
467 case FdoExtension:
468 return PortFdoPnp(DeviceObject,
469 Irp);
470
471 case PdoExtension:
472 return PortPdoPnp(DeviceObject,
473 Irp);
474
475 default:
476 Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
477 Irp->IoStatus.Information = 0;
478 IoCompleteRequest(Irp, IO_NO_INCREMENT);
479 return STATUS_UNSUCCESSFUL;
480 }
481}
PortFdoPnp
NTSTATUS NTAPI PortFdoPnp(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
Definition: fdo.c:1139
PortPdoPnp
NTSTATUS NTAPI PortPdoPnp(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
Definition: pdo.c:681

Referenced by StorPortInitialize().

◆ PortDispatchPower()

static NTSTATUS NTAPI PortDispatchPower ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)
static

Definition at line 487 of file storport.c.

490{
491 DPRINT1("PortDispatchPower(%p %p)\n",
492 DeviceObject, Irp);
493
494 Irp->IoStatus.Status = STATUS_SUCCESS;
495 Irp->IoStatus.Information = 0;
496
497 IoCompleteRequest(Irp, IO_NO_INCREMENT);
498
499 return STATUS_SUCCESS;
500}

Referenced by StorPortInitialize().

◆ PortDispatchScsi()

static NTSTATUS NTAPI PortDispatchScsi ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)
static

Definition at line 398 of file storport.c.

401{
402 PFDO_DEVICE_EXTENSION DeviceExtension;
403
404 DPRINT("PortDispatchScsi(%p %p)\n",
405 DeviceObject, Irp);
406
407 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
408 DPRINT("ExtensionType: %u\n", DeviceExtension->ExtensionType);
409
410 switch (DeviceExtension->ExtensionType)
411 {
412 case FdoExtension:
413 return PortFdoScsi(DeviceObject,
414 Irp);
415
416 case PdoExtension:
417 return PortPdoScsi(DeviceObject,
418 Irp);
419
420 default:
421 Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
422 Irp->IoStatus.Information = 0;
423 IoCompleteRequest(Irp, IO_NO_INCREMENT);
424 return STATUS_UNSUCCESSFUL;
425 }
426
427 return STATUS_SUCCESS;
428}
PortPdoScsi
NTSTATUS NTAPI PortPdoScsi(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
Definition: srb.c:516
PortFdoScsi
NTSTATUS NTAPI PortFdoScsi(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
Definition: fdo.c:1111

Referenced by StorPortInitialize().

◆ PortDispatchSystemControl()

static NTSTATUS NTAPI PortDispatchSystemControl ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)
static

Definition at line 434 of file storport.c.

437{
438 DPRINT1("PortDispatchSystemControl(%p %p)\n",
439 DeviceObject, Irp);
440
441 Irp->IoStatus.Status = STATUS_SUCCESS;
442 Irp->IoStatus.Information = 0;
443
444 IoCompleteRequest(Irp, IO_NO_INCREMENT);
445
446 return STATUS_SUCCESS;
447}

Referenced by StorPortInitialize().

◆ PortGetDriverInitData()

PHW_INITIALIZATION_DATA PortGetDriverInitData ( PDRIVER_OBJECT_EXTENSION  DriverExtension,
INTERFACE_TYPE  InterfaceType 
)

Definition at line 81 of file storport.c.

84{
85 PDRIVER_INIT_DATA InitData;
86 PLIST_ENTRY ListEntry;
87
88 DPRINT1("PortGetDriverInitData()\n");
89
90 ListEntry = DriverExtension->InitDataListHead.Flink;
91 while (ListEntry != &DriverExtension->InitDataListHead)
92 {
93 InitData = CONTAINING_RECORD(ListEntry,
94 DRIVER_INIT_DATA,
95 Entry);
96 if (InitData->HwInitData.AdapterInterfaceType == InterfaceType)
97 return &InitData->HwInitData;
98
99 ListEntry = ListEntry->Flink;
100 }
101
102 return NULL;
103}
_HW_INITIALIZATION_DATA::AdapterInterfaceType
INTERFACE_TYPE AdapterInterfaceType
Definition: srb.h:565
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
InterfaceType
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID InterfaceType
Definition: wdffdo.h:463

Referenced by PortFdoStartMiniport(), and StorPortGetUncachedExtension().

◆ PortReleaseSpinLock()

static VOID PortReleaseSpinLock ( PFDO_DEVICE_EXTENSION  DeviceExtension,
PSTOR_LOCK_HANDLE  LockHandle 
)
static

Definition at line 142 of file storport.c.

145{
146 DPRINT("PortReleaseSpinLock(%p %p)\n",
147 DeviceExtension, LockHandle);
148
149 switch (LockHandle->Lock)
150 {
151 case DpcLock: /* 1, */
152 DPRINT("DpcLock\n");
153 break;
154
155 case StartIoLock: /* 2 */
156 DPRINT("StartIoLock\n");
157 break;
158
159 case InterruptLock: /* 3 */
160 DPRINT("InterruptLock\n");
161 if (DeviceExtension->Interrupt != NULL)
162 KeReleaseInterruptSpinLock(DeviceExtension->Interrupt,
163 LockHandle->Context.OldIrql);
164 break;
165 }
166}
KeReleaseInterruptSpinLock
VOID NTAPI KeReleaseInterruptSpinLock(IN PKINTERRUPT Interrupt, IN KIRQL OldIrql)
Definition: spinlock.c:171

Referenced by StorPortNotification().

◆ PortUnload()

static VOID NTAPI PortUnload ( _In_ PDRIVER_OBJECT  DriverObject)
static

Definition at line 304 of file storport.c.

306{
307 PDRIVER_OBJECT_EXTENSION DriverExtension;
308
309 DPRINT1("PortUnload(%p)\n",
310 DriverObject);
311
312 DriverExtension = IoGetDriverObjectExtension(DriverObject,
313 (PVOID)DriverEntry);
314 if (DriverExtension != NULL)
315 {
316 PortDeleteDriverInitData(DriverExtension);
317 }
318}
PortDeleteDriverInitData
static VOID PortDeleteDriverInitData(PDRIVER_OBJECT_EXTENSION DriverExtension)
Definition: storport.c:55

Referenced by StorPortInitialize().

◆ StorPortAllocateRegistryBuffer()

STORPORT_API PUCHAR NTAPI StorPortAllocateRegistryBuffer ( _In_ PVOID  HwDeviceExtension,
_In_ PULONG  Length 
)

Definition at line 525 of file storport.c.

528{
529 DPRINT1("StorPortAllocateRegistryBuffer()\n");
530 UNIMPLEMENTED;
531 return NULL;
532}
UNIMPLEMENTED
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15

◆ StorPortBusy()

STORPORT_API BOOLEAN NTAPI StorPortBusy ( _In_ PVOID  HwDeviceExtension,
_In_ ULONG  RequestsToComplete 
)

Definition at line 541 of file storport.c.

544{
545 DPRINT1("StorPortBuzy()\n");
546 UNIMPLEMENTED;
547 return FALSE;
548}

◆ StorPortCompleteRequest()

STORPORT_API VOID NTAPI StorPortCompleteRequest ( _In_ PVOID  HwDeviceExtension,
_In_ UCHAR  PathId,
_In_ UCHAR  TargetId,
_In_ UCHAR  Lun,
_In_ UCHAR  SrbStatus 
)

Definition at line 557 of file storport.c.

563{
564 DPRINT1("StorPortCompleteRequest()\n");
565 UNIMPLEMENTED;
566}

◆ StorPortConvertPhysicalAddressToUlong()

STORPORT_API ULONG NTAPI StorPortConvertPhysicalAddressToUlong ( _In_ STOR_PHYSICAL_ADDRESS  Address)

Definition at line 575 of file storport.c.

577{
578 DPRINT("StorPortConvertPhysicalAddressToUlong()\n");
579
580 return Address.u.LowPart;
581}
Address
static WCHAR Address[46]
Definition: ping.c:68

◆ StorPortConvertUlongToPhysicalAddress()

STORPORT_API STOR_PHYSICAL_ADDRESS NTAPI StorPortConvertUlongToPhysicalAddress ( _In_ ULONG_PTR  UlongAddress)

Definition at line 590 of file storport.c.

592{
593 STOR_PHYSICAL_ADDRESS Address;
594
595 DPRINT("StorPortConvertUlongToPhysicalAddress()\n");
596
597 Address.QuadPart = UlongAddress;
598 return Address;
599}
_LARGE_INTEGER
Definition: typedefs.h:103

◆ StorPortDebugPrint()

STORPORT_API VOID StorPortDebugPrint ( _In_ ULONG  DebugPrintLevel,
_In_ PCHAR  DebugMessage,
  ... 
)

Definition at line 607 of file storport.c.

611{
612 va_list ap;
613
614 va_start(ap, DebugMessage);
615 vDbgPrintExWithPrefix("STORMINI: ",
616 -1,
617 DPFLTR_ERROR_LEVEL,
618 DebugMessage,
619 ap);
620 va_end(ap);
621}
DPFLTR_ERROR_LEVEL
#define DPFLTR_ERROR_LEVEL
Definition: main.cpp:32
va_end
#define va_end(v)
Definition: stdarg.h:28
va_start
#define va_start(v, l)
Definition: stdarg.h:26
va_list
char * va_list
Definition: vadefs.h:50
vDbgPrintExWithPrefix
ULONG NTAPI vDbgPrintExWithPrefix(IN PCCH Prefix, IN ULONG ComponentId, IN ULONG Level, IN PCCH Format, IN va_list ap)
Definition: debug.c:167
ap
void int int ULONGLONG int va_list * ap
Definition: winesup.h:36

◆ StorPortDeviceBusy()

STORPORT_API BOOLEAN NTAPI StorPortDeviceBusy ( _In_ PVOID  HwDeviceExtension,
_In_ UCHAR  PathId,
_In_ UCHAR  TargetId,
_In_ UCHAR  Lun,
_In_ ULONG  RequestsToComplete 
)

Definition at line 630 of file storport.c.

636{
637 /* TODO: Need coverage test */
638 PFDO_DEVICE_EXTENSION FdoExtension;
639 PPDO_DEVICE_EXTENSION PdoExtension;
640 KLOCK_QUEUE_HANDLE LockHandle;
641
642 DPRINT1("StorPortDeviceBusy(%p %d %d %d %d)\n",
643 HwDeviceExtension, PathId, TargetId, Lun, RequestsToComplete);
644
645 FdoExtension = StorpGetMiniportFdo(HwDeviceExtension);
646 PdoExtension = FdoFindLun(FdoExtension, PathId, TargetId, Lun);
647
648 KeAcquireInStackQueuedSpinLock(&FdoExtension->FlowControl.Lock, &LockHandle);
649 NT_ASSERT(!PdoExtension->FlowControl.IsBusy);
650 PdoExtension->FlowControl.IsBusy = TRUE;
651 PdoExtension->FlowControl.RemainingBusyRequests = RequestsToComplete;
652 KeReleaseInStackQueuedSpinLock(&LockHandle);
653
654 return FALSE;
655}
Lun
_In_ ULONG _In_ BOOLEAN _In_ ULONG _In_ UCHAR _In_ UCHAR _In_ UCHAR Lun
Definition: classpnp.h:1315
PathId
_In_ ULONG _In_ BOOLEAN _In_ ULONG _In_ UCHAR PathId
Definition: classpnp.h:1313
TargetId
_In_ DXGK_MIRACAST_DISPLAY_CALLBACKS _Out_ PVOID _Out_ ULONG * TargetId
Definition: dispmprt.h:650
TRUE
#define TRUE
Definition: types.h:120
KeAcquireInStackQueuedSpinLock
VOID FASTCALL KeAcquireInStackQueuedSpinLock(IN PKSPIN_LOCK SpinLock, IN PKLOCK_QUEUE_HANDLE LockHandle)
Definition: spinlock.c:130
KeReleaseInStackQueuedSpinLock
VOID FASTCALL KeReleaseInStackQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle)
Definition: spinlock.c:166
StorpGetMiniportFdo
FORCEINLINE PFDO_DEVICE_EXTENSION StorpGetMiniportFdo(_In_ PVOID HwDeviceExtension)
For use in Storport API exposed to miniports; gets FDO extension with HwDeviceExtension.
Definition: inline.h:39
FdoFindLun
PPDO_DEVICE_EXTENSION FdoFindLun(_In_ PFDO_DEVICE_EXTENSION FdoExtension, _In_ ULONG Bus, _In_ ULONG Target, _In_ ULONG Lun)
Definition: fdo.c:1078
_KLOCK_QUEUE_HANDLE
Definition: ketypes.h:694
_PDO_DEVICE_EXTENSION
Definition: pci.h:57
NT_ASSERT
#define NT_ASSERT
Definition: rtlfuncs.h:3334

◆ StorPortDeviceReady()

STORPORT_API BOOLEAN NTAPI StorPortDeviceReady ( _In_ PVOID  HwDeviceExtension,
_In_ UCHAR  PathId,
_In_ UCHAR  TargetId,
_In_ UCHAR  Lun 
)

Definition at line 664 of file storport.c.

669{
670 /* TODO: Need coverage test */
671 PFDO_DEVICE_EXTENSION FdoExtension;
672 PPDO_DEVICE_EXTENSION PdoExtension;
673 KLOCK_QUEUE_HANDLE LockHandle;
674
675 DPRINT1("StorPortDeviceReady(%p %d %d %d %d)\n",
676 HwDeviceExtension, PathId, TargetId, Lun);
677
678 FdoExtension = StorpGetMiniportFdo(HwDeviceExtension);
679 PdoExtension = FdoFindLun(FdoExtension, PathId, TargetId, Lun);
680
681 KeAcquireInStackQueuedSpinLock(&FdoExtension->FlowControl.Lock, &LockHandle);
682 NT_ASSERT(!PdoExtension->FlowControl.IsBusy);
683 PdoExtension->FlowControl.IsBusy = FALSE;
684 KeReleaseInStackQueuedSpinLock(&LockHandle);
685
686 return FALSE;
687}

◆ StorPortExtendedFunction()

STORPORT_API ULONG StorPortExtendedFunction ( _In_ STORPORT_FUNCTION_CODE  FunctionCode,
_In_ PVOID  HwDeviceExtension,
  ... 
)

Definition at line 695 of file storport.c.

699{
700 va_list va;
701 ULONG Status = STATUS_NOT_IMPLEMENTED;
702 PMINIPORT_DEVICE_EXTENSION MiniportExtension = NULL;
703 PFDO_DEVICE_EXTENSION DeviceExtension = NULL;
704 ULONG AllocatePoolSize;
705 ULONG PoolTag;
706 PVOID* AllocatedPoolPointer;
707 PVOID PoolPointer;
708
709 DPRINT1("StorPortExtendedFunction(%d %p ...)\n",
710 FunctionCode, HwDeviceExtension);
711
712 va_start(va, HwDeviceExtension);
713
714 switch (FunctionCode) {
715 case ExtFunctionAllocatePool:
716 {
717 /* Allocate a non paged pool for miniport */
718 AllocatePoolSize = va_arg(va, ULONG);
719 PoolTag = va_arg(va, ULONG);
720 AllocatedPoolPointer = va_arg(va, PVOID*);
721
722 if (AllocatedPoolPointer == NULL) {
723 Status = STOR_STATUS_INVALID_PARAMETER;
724 break;
725 }
726
727 PoolPointer = ExAllocatePoolWithTag(NonPagedPool, AllocatePoolSize, PoolTag);
728
729 if (PoolPointer == NULL) {
730 *AllocatedPoolPointer = NULL;
731 Status = STOR_STATUS_INSUFFICIENT_RESOURCES;
732 break;
733 }
734
735 *AllocatedPoolPointer = PoolPointer;
736 Status = STOR_STATUS_SUCCESS;
737 break;
738 }
739
740 case ExtFunctionFreePool:
741 {
742 /* Free a pool allocated with ExtFunctionAllocatePool */
743 PoolPointer = va_arg(va, PVOID);
744
745 if (PoolPointer == NULL) {
746 Status = STOR_STATUS_INVALID_PARAMETER;
747 break;
748 }
749
750 ExFreePool(PoolPointer);
751 Status = STOR_STATUS_SUCCESS;
752 break;
753 }
754
755 case ExtFunctionInitializeTimer:
756 {
757 /* Allocate a timer for an HBA */
758 PTIMER_ENTRY TimerEntry;
759 PVOID* TimerHandle = va_arg(va, PVOID*);
760
761 if (TimerHandle == NULL) {
762 Status = STOR_STATUS_INVALID_PARAMETER;
763 break;
764 }
765
766 TimerEntry = (PTIMER_ENTRY)ExAllocatePoolWithTag(NonPagedPool,
767 sizeof(TIMER_ENTRY),
768 TAG_MINIPORT_DATA);
769 RtlZeroMemory(TimerEntry, sizeof(TIMER_ENTRY));
770
771 if (TimerEntry == NULL) {
772 Status = STOR_STATUS_INSUFFICIENT_RESOURCES;
773 break;
774 }
775
776 /* Initialize internal timer object; Win8.1+ EX_TIMER may be used too if we had it */
777 /* FIXME: IRQL > DISPATCH_LEVEL will bugcheck; queue a DPC to do this */
778 KeInitializeTimer(&TimerEntry->Timer);
779
780 MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
781 MINIPORT_DEVICE_EXTENSION,
782 HwDeviceExtension);
783 DeviceExtension = MiniportExtension->Miniport->DeviceExtension;
784
785 /* Insert into timer list and increment counter */
786 StorpInterlockedInsertHeadListCounted(&DeviceExtension->TimerListLock,
787 &DeviceExtension->TimerListHead,
788 &TimerEntry->ListEntry,
789 &DeviceExtension->TimerCount);
790
791 /* Return list entry of the timer as its handle */
792 *TimerHandle = (PVOID)&TimerEntry->ListEntry;
793 Status = STOR_STATUS_SUCCESS;
794
795 break;
796 }
797
798 case ExtFunctionRequestTimer:
799 {
800 /* Schedule a single shot timer event */
801 PVOID TimerHandle = va_arg(va, PVOID);
802 PHW_TIMER_EX TimerCallback = va_arg(va, PHW_TIMER_EX);
803 PVOID CallbackContext = va_arg(va, PVOID);
804 ULONGLONG TimerValue = va_arg(va, ULONGLONG);
805 ULONGLONG TolerableDelay = va_arg(va, ULONGLONG);
806 PTIMER_ENTRY TimerEntry;
807 ULONG IsTimerAlreadySet;
808 LARGE_INTEGER TimerDueTime;
809 NTSTATUS MultiplyResult;
810
811 /* FIXME: I actually don't know how to deal with tolerable delay */
812 UNREFERENCED_PARAMETER(TolerableDelay);
813
814 if (HwDeviceExtension == NULL || TimerHandle == NULL || TimerCallback == NULL) {
815 Status = STOR_STATUS_INVALID_PARAMETER;
816 break;
817 }
818
819 TimerEntry = CONTAINING_RECORD(TimerHandle, TIMER_ENTRY, ListEntry);
820
821 /* Check if timer is already set. If so, don't try to reactivate timer. */
822 IsTimerAlreadySet = InterlockedCompareExchange(&TimerEntry->TimerAlreadySet, 1, 0);
823 if (IsTimerAlreadySet == 1) {
824 Status = STOR_STATUS_BUSY;
825 break;
826 }
827
828 /* If timeout is zero, cancel the timer */
829 if (TimerValue == 0ull) {
830 KeCancelTimer(&TimerEntry->Timer);
831 Status = STOR_STATUS_SUCCESS;
832 break;
833 }
834
835 /* This API uses microseconds, KTIMER operate on 100 nanoseconds, multiply by 10
836 to get the correct timer due time */
837 MultiplyResult = RtlULongLongMult(TimerValue, 10ull, (PULONGLONG)&TimerDueTime.QuadPart);
838 if (!NT_SUCCESS(MultiplyResult)) {
839 Status = STOR_STATUS_INVALID_PARAMETER;
840 break;
841 }
842
843 /* Initialize the DPC, context and set timer accordingly */
844 TimerEntry->HwDeviceExtension = HwDeviceExtension;
845 TimerEntry->TimerCallback = TimerCallback;
846 TimerEntry->Context = CallbackContext;
847 KeInitializeDpc(&TimerEntry->TimerCallbackDpc,
848 TimerCallbackDpcRoutine,
849 (PVOID)TimerEntry);
850 KeSetTimer(&TimerEntry->Timer,
851 TimerDueTime,
852 &TimerEntry->TimerCallbackDpc);
853 Status = STOR_STATUS_SUCCESS;
854 break;
855 }
856
857 default:
858 {
859 UNIMPLEMENTED;
860 // __debugbreak();
861 }
862 }
863
864 va_end(va);
865
866 return Status;
867}
STATUS_NOT_IMPLEMENTED
#define STATUS_NOT_IMPLEMENTED
Definition: d3dkmdt.h:42
CallbackContext
_In_ ULONG _In_ ULONG _In_opt_ DXGKCB_MIRACAST_SEND_MESSAGE_CALLBACK _In_opt_ PVOID CallbackContext
Definition: dispmprt.h:622
va_arg
#define va_arg(v, l)
Definition: stdarg.h:27
TimerCallbackDpcRoutine
VOID NTAPI TimerCallbackDpcRoutine(PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
Definition: misc.c:348
TAG_MINIPORT_DATA
#define TAG_MINIPORT_DATA
Definition: precomp.h:33
PTIMER_ENTRY
struct _TIMER_ENTRY * PTIMER_ENTRY
ExFreePool
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
InterlockedCompareExchange
#define InterlockedCompareExchange
Definition: interlocked.h:119
PULONGLONG
__GNU_EXTENSION typedef unsigned __int64 * PULONGLONG
Definition: ntbasedef.h:395
UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:329
PHW_TIMER_EX
VOID(NTAPI * PHW_TIMER_EX)(_In_ PVOID DeviceExtension, _In_opt_ PVOID Context)
Definition: storport.h:2269
ExtFunctionInitializeTimer
@ ExtFunctionInitializeTimer
Definition: storport.h:654
ExtFunctionRequestTimer
@ ExtFunctionRequestTimer
Definition: storport.h:655
ExtFunctionFreePool
@ ExtFunctionFreePool
Definition: storport.h:620
ExtFunctionAllocatePool
@ ExtFunctionAllocatePool
Definition: storport.h:619
STOR_STATUS_INSUFFICIENT_RESOURCES
#define STOR_STATUS_INSUFFICIENT_RESOURCES
Definition: storport.h:446
STOR_STATUS_SUCCESS
#define STOR_STATUS_SUCCESS
Definition: storport.h:443
STOR_STATUS_INVALID_PARAMETER
#define STOR_STATUS_INVALID_PARAMETER
Definition: storport.h:449
STOR_STATUS_BUSY
#define STOR_STATUS_BUSY
Definition: storport.h:455
_FDO_DEVICE_EXTENSION::TimerCount
ULONG TimerCount
Definition: precomp.h:269
_MINIPORT_DEVICE_EXTENSION
Definition: precomp.h:83
_MINIPORT_DEVICE_EXTENSION::Miniport
struct _MINIPORT * Miniport
Definition: precomp.h:84
_TIMER_ENTRY
Definition: precomp.h:103
_TIMER_ENTRY::Timer
KTIMER Timer
Definition: precomp.h:105
_TIMER_ENTRY::Context
PVOID Context
Definition: precomp.h:110
_TIMER_ENTRY::TimerAlreadySet
LONG TimerAlreadySet
Definition: precomp.h:107
_TIMER_ENTRY::TimerCallback
PHW_TIMER_EX TimerCallback
Definition: precomp.h:109
_TIMER_ENTRY::ListEntry
LIST_ENTRY ListEntry
Definition: precomp.h:104
_TIMER_ENTRY::TimerCallbackDpc
KDPC TimerCallbackDpc
Definition: precomp.h:106
_TIMER_ENTRY::HwDeviceExtension
PVOID HwDeviceExtension
Definition: precomp.h:108
KeSetTimer
BOOLEAN NTAPI KeSetTimer(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:282
KeCancelTimer
BOOLEAN NTAPI KeCancelTimer(IN OUT PKTIMER Timer)
Definition: timerobj.c:206
PVOID
void * PVOID
Definition: typedefs.h:50
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67
ULONG
uint32_t ULONG
Definition: typedefs.h:59
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:114
PoolTag
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _In_ _Strict_type_match_ POOL_TYPE _In_opt_ ULONG PoolTag
Definition: wdfmemory.h:164
TolerableDelay
_In_ LARGE_INTEGER _In_ ULONG _In_ ULONG TolerableDelay
Definition: kefuncs.h:1305

Referenced by StorPortAcquireMSISpinLock(), StorPortAllocateMdl(), StorPortAllocatePool(), StorPortBuildMdlForNonPagedPool(), StorPortBuildScatterGatherList(), StorPortCompleteServiceIrp(), StorPortFreeMdl(), StorPortFreePool(), StorPortGetDeviceObjects(), StorPortGetMSIInfo(), StorPortGetOriginalMdl(), StorPortGetStartIoPerfParams(), StorPortGetSystemAddress(), StorPortInitializePerfOpts(), StorPortLogSystemEvent(), StorPortPutScatterGatherList(), and StorPortReleaseMSISpinLock().

◆ StorPortFreeDeviceBase()

STORPORT_API VOID NTAPI StorPortFreeDeviceBase ( _In_ PVOID  HwDeviceExtension,
_In_ PVOID  MappedAddress 
)

Definition at line 876 of file storport.c.

879{
880 DPRINT1("StorPortFreeDeviceBase(%p %p)\n",
881 HwDeviceExtension, MappedAddress);
882}

◆ StorPortFreeRegistryBuffer()

STORPORT_API VOID NTAPI StorPortFreeRegistryBuffer ( _In_ PVOID  HwDeviceExtension,
_In_ PUCHAR  Buffer 
)

Definition at line 891 of file storport.c.

894{
895 DPRINT1("StorPortFreeRegistryBuffer()\n");
896 UNIMPLEMENTED;
897}

◆ StorPortGetBusData()

STORPORT_API ULONG NTAPI StorPortGetBusData ( _In_ PVOID  DeviceExtension,
_In_ ULONG  BusDataType,
_In_ ULONG  SystemIoBusNumber,
_In_ ULONG  SlotNumber,
_Out_ _When_(Length !=0, _Out_writes_bytes_(Length)) PVOID  Buffer,
_In_ ULONG  Length 
)

Definition at line 906 of file storport.c.

913{
914 PMINIPORT_DEVICE_EXTENSION MiniportExtension;
915 PBUS_INTERFACE_STANDARD Interface;
916 ULONG ReturnLength;
917
918 DPRINT1("StorPortGetBusData(%p %lu %lu %lu %p %lu)\n",
919 DeviceExtension, BusDataType, SystemIoBusNumber, SlotNumber, Buffer, Length);
920
921 /* Get the miniport extension */
922 MiniportExtension = CONTAINING_RECORD(DeviceExtension,
923 MINIPORT_DEVICE_EXTENSION,
924 HwDeviceExtension);
925 DPRINT1("DeviceExtension %p MiniportExtension %p\n",
926 DeviceExtension, MiniportExtension);
927
928 Interface = &MiniportExtension->Miniport->DeviceExtension->BusInterface;
929
930 ReturnLength = Interface->GetBusData(Interface->Context,
931 BusDataType,
932 Buffer,
933 0,
934 Length);
935 DPRINT1("ReturnLength: %lu\n", ReturnLength);
936
937 return ReturnLength;
938}
ReturnLength
_In_ PVOID _In_ ULONG _Out_ PVOID _In_ ULONG _Inout_ PULONG ReturnLength
Definition: KdSystemDebugControl.c:34
Buffer
Definition: bufpool.h:45
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
_BUS_INTERFACE_STANDARD
Definition: iotypes.h:907
Interface
_In_ UCXUSBDEVICE _In_ ULONG Interface
Definition: ucxusbdevice.h:428
SlotNumber
_In_ WDFIORESREQLIST _In_ ULONG SlotNumber
Definition: wdfresource.h:68

Referenced by AhciHwFindAdapter().

◆ StorPortGetDeviceBase()

STORPORT_API PVOID NTAPI StorPortGetDeviceBase ( _In_ PVOID  HwDeviceExtension,
_In_ INTERFACE_TYPE  BusType,
_In_ ULONG  SystemIoBusNumber,
_In_ STOR_PHYSICAL_ADDRESS  IoAddress,
_In_ ULONG  NumberOfBytes,
_In_ BOOLEAN  InIoSpace 
)

Definition at line 947 of file storport.c.

954{
955 PMINIPORT_DEVICE_EXTENSION MiniportExtension;
956 PHYSICAL_ADDRESS TranslatedAddress;
957 PVOID MappedAddress;
958 NTSTATUS Status;
959
960 DPRINT1("StorPortGetDeviceBase(%p %lu %lu 0x%I64x %lu %u)\n",
961 HwDeviceExtension, BusType, SystemIoBusNumber, IoAddress.QuadPart, NumberOfBytes, InIoSpace);
962
963 /* Get the miniport extension */
964 MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
965 MINIPORT_DEVICE_EXTENSION,
966 HwDeviceExtension);
967 DPRINT1("HwDeviceExtension %p MiniportExtension %p\n",
968 HwDeviceExtension, MiniportExtension);
969
970 if (!TranslateResourceListAddress(MiniportExtension->Miniport->DeviceExtension,
971 BusType,
972 SystemIoBusNumber,
973 IoAddress,
974 NumberOfBytes,
975 InIoSpace,
976 &TranslatedAddress))
977 {
978 DPRINT1("Checkpoint!\n");
979 return NULL;
980 }
981
982 DPRINT1("Translated Address: 0x%I64x\n", TranslatedAddress.QuadPart);
983
984 /* In I/O space */
985 if (InIoSpace)
986 {
987 DPRINT1("Translated Address: %p\n", (PVOID)(ULONG_PTR)TranslatedAddress.QuadPart);
988 return (PVOID)(ULONG_PTR)TranslatedAddress.QuadPart;
989 }
990
991 /* In memory space */
992 MappedAddress = MmMapIoSpace(TranslatedAddress,
993 NumberOfBytes,
994 FALSE);
995 DPRINT1("Mapped Address: %p\n", MappedAddress);
996
997 Status = AllocateAddressMapping(&MiniportExtension->Miniport->DeviceExtension->MappedAddressList,
998 IoAddress,
999 MappedAddress,
1000 NumberOfBytes,
1001 SystemIoBusNumber);
1002 if (!NT_SUCCESS(Status))
1003 {
1004 DPRINT1("Checkpoint!\n");
1005 MappedAddress = NULL;
1006 }
1007
1008 DPRINT1("Mapped Address: %p\n", MappedAddress);
1009 return MappedAddress;
1010}
ULONG_PTR
#define ULONG_PTR
Definition: config.h:101
AllocateAddressMapping
NTSTATUS AllocateAddressMapping(PMAPPED_ADDRESS *MappedAddressList, STOR_PHYSICAL_ADDRESS IoAddress, PVOID MappedAddress, ULONG NumberOfBytes, ULONG BusNumber)
Definition: misc.c:291
TranslateResourceListAddress
BOOLEAN TranslateResourceListAddress(PFDO_DEVICE_EXTENSION DeviceExtension, INTERFACE_TYPE BusType, ULONG SystemIoBusNumber, STOR_PHYSICAL_ADDRESS IoAddress, ULONG NumberOfBytes, BOOLEAN InIoSpace, PPHYSICAL_ADDRESS TranslatedAddress)
Definition: misc.c:173
MmMapIoSpace
PVOID NTAPI MmMapIoSpace(IN PHYSICAL_ADDRESS PhysicalAddress, IN SIZE_T NumberOfBytes, IN MEMORY_CACHING_TYPE CacheType)
Definition: iosup.c:47
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
BusType
_In_opt_ PUNICODE_STRING _In_ PDRIVER_OBJECT _In_ PDEVICE_OBJECT _In_ INTERFACE_TYPE BusType
Definition: halfuncs.h:159
TranslatedAddress
_In_ ULONG _In_ PHYSICAL_ADDRESS _Inout_ PULONG _Out_ PPHYSICAL_ADDRESS TranslatedAddress
Definition: iofuncs.h:2275
NumberOfBytes
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _Inout_ PLARGE_INTEGER NumberOfBytes
Definition: iotypes.h:1036

Referenced by AhciHwFindAdapter().

◆ StorPortGetLogicalUnit()

STORPORT_API PVOID NTAPI StorPortGetLogicalUnit ( _In_ PVOID  HwDeviceExtension,
_In_ UCHAR  PathId,
_In_ UCHAR  TargetId,
_In_ UCHAR  Lun 
)

Definition at line 1019 of file storport.c.

1024{
1025 DPRINT1("StorPortGetLogicalUnit()\n");
1026 UNIMPLEMENTED;
1027 return NULL;
1028}

◆ StorPortGetPhysicalAddress()

STORPORT_API STOR_PHYSICAL_ADDRESS NTAPI StorPortGetPhysicalAddress ( _In_ PVOID  HwDeviceExtension,
_In_opt_ PSCSI_REQUEST_BLOCK  Srb,
_In_ PVOID  VirtualAddress,
_Out_ ULONG *  Length 
)

Definition at line 1037 of file storport.c.

1042{
1043 PMINIPORT_DEVICE_EXTENSION MiniportExtension;
1044 PFDO_DEVICE_EXTENSION DeviceExtension;
1045 STOR_PHYSICAL_ADDRESS PhysicalAddress;
1046 ULONG_PTR Offset;
1047
1048 DPRINT("StorPortGetPhysicalAddress(%p %p %p %p)\n",
1049 HwDeviceExtension, Srb, VirtualAddress, Length);
1050
1051 /* Get the miniport extension */
1052 MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
1053 MINIPORT_DEVICE_EXTENSION,
1054 HwDeviceExtension);
1055 DPRINT("HwDeviceExtension %p MiniportExtension %p\n",
1056 HwDeviceExtension, MiniportExtension);
1057
1058 DeviceExtension = MiniportExtension->Miniport->DeviceExtension;
1059
1060 /* Inside of the uncached extension? */
1061 if (((ULONG_PTR)VirtualAddress >= (ULONG_PTR)DeviceExtension->UncachedExtensionVirtualBase) &&
1062 ((ULONG_PTR)VirtualAddress <= (ULONG_PTR)DeviceExtension->UncachedExtensionVirtualBase + DeviceExtension->UncachedExtensionSize))
1063 {
1064 Offset = (ULONG_PTR)VirtualAddress - (ULONG_PTR)DeviceExtension->UncachedExtensionVirtualBase;
1065
1066 PhysicalAddress.QuadPart = DeviceExtension->UncachedExtensionPhysicalBase.QuadPart + Offset;
1067 *Length = DeviceExtension->UncachedExtensionSize - Offset;
1068
1069 return PhysicalAddress;
1070 }
1071
1072 // FIXME
1073
1074
1075 PhysicalAddress = MmGetPhysicalAddress(VirtualAddress);
1076 *Length = 1;
1077// UNIMPLEMENTED;
1078
1079// *Length = 0;
1080// PhysicalAddress.QuadPart = (LONGLONG)0;
1081
1082 return PhysicalAddress;
1083}
Srb
_In_ PSCSI_REQUEST_BLOCK Srb
Definition: cdrom.h:989
PhysicalAddress
_In_ ULONG _In_ MEMORY_CACHING_TYPE _Out_ PPHYSICAL_ADDRESS PhysicalAddress
Definition: dispmprt.h:714
VirtualAddress
_In_ ULONG _In_ MEMORY_CACHING_TYPE _Out_ PPHYSICAL_ADDRESS _Out_ PVOID * VirtualAddress
Definition: dispmprt.h:716
Offset
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
MmGetPhysicalAddress
PHYSICAL_ADDRESS NTAPI MmGetPhysicalAddress(IN PVOID Address)
Definition: stubs.c:663
_FDO_DEVICE_EXTENSION::UncachedExtensionVirtualBase
PVOID UncachedExtensionVirtualBase
Definition: precomp.h:247
_FDO_DEVICE_EXTENSION::UncachedExtensionSize
ULONG UncachedExtensionSize
Definition: precomp.h:249
_FDO_DEVICE_EXTENSION::UncachedExtensionPhysicalBase
PHYSICAL_ADDRESS UncachedExtensionPhysicalBase
Definition: precomp.h:248

Referenced by AhciPortInitialize(), and AhciProcessSrb().

◆ StorPortGetScatterGatherList()

STORPORT_API PSTOR_SCATTER_GATHER_LIST NTAPI StorPortGetScatterGatherList ( _In_ PVOID  HwDeviceExtension,
_In_ PSCSI_REQUEST_BLOCK  Srb 
)

Definition at line 1092 of file storport.c.

1095{
1096 UNREFERENCED_PARAMETER(HwDeviceExtension);
1097 PQUEUED_REQUEST_REFERENCE RequestReference;
1098
1099 DPRINT("StorPortGetScatterGatherList(%p %p)\n", HwDeviceExtension, Srb);
1100 RequestReference = (PQUEUED_REQUEST_REFERENCE)Srb->OriginalRequest;
1101
1102 return RequestReference->ScatterGatherList;
1103}
PQUEUED_REQUEST_REFERENCE
struct _QUEUED_REQUEST_REFERENCE * PQUEUED_REQUEST_REFERENCE
_QUEUED_REQUEST_REFERENCE::ScatterGatherList
PSTOR_SCATTER_GATHER_LIST ScatterGatherList
Definition: precomp.h:345
_SCSI_REQUEST_BLOCK::OriginalRequest
PVOID OriginalRequest
Definition: srb.h:266

Referenced by AhciATAPICommand(), and DeviceRequestReadWrite().

◆ StorPortGetSrb()

STORPORT_API PSCSI_REQUEST_BLOCK NTAPI StorPortGetSrb ( _In_ PVOID  DeviceExtension,
_In_ UCHAR  PathId,
_In_ UCHAR  TargetId,
_In_ UCHAR  Lun,
_In_ LONG  QueueTag 
)

Definition at line 1112 of file storport.c.

1118{
1119 DPRINT("StorPortGetSrb()\n");
1120 return NULL;
1121}

◆ StorPortGetUncachedExtension()

STORPORT_API PVOID NTAPI StorPortGetUncachedExtension ( _In_ PVOID  HwDeviceExtension,
_In_ PPORT_CONFIGURATION_INFORMATION  ConfigInfo,
_In_ ULONG  NumberOfBytes 
)

Definition at line 1130 of file storport.c.

1134{
1135 PMINIPORT_DEVICE_EXTENSION MiniportExtension;
1136 PFDO_DEVICE_EXTENSION DeviceExtension;
1137 PHYSICAL_ADDRESS LowestAddress, HighestAddress, Alignment;
1138 DEVICE_DESCRIPTION DeviceDescription;
1139 ULONG NumberOfMapRegisters;
1140
1141 DPRINT1("StorPortGetUncachedExtension(%p %p %lu)\n",
1142 HwDeviceExtension, ConfigInfo, NumberOfBytes);
1143
1144 /* Get the miniport extension */
1145 MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
1146 MINIPORT_DEVICE_EXTENSION,
1147 HwDeviceExtension);
1148 DPRINT1("HwDeviceExtension %p MiniportExtension %p\n",
1149 HwDeviceExtension, MiniportExtension);
1150
1151 DeviceExtension = MiniportExtension->Miniport->DeviceExtension;
1152
1153 /* Return the uncached extension base address if we already have one */
1154 if (DeviceExtension->UncachedExtensionVirtualBase != NULL)
1155 return DeviceExtension->UncachedExtensionVirtualBase;
1156
1157 // FIXME: Set DMA stuff here?
1158 DeviceDescription.Version = DEVICE_DESCRIPTION_VERSION;
1159 DeviceDescription.Master = ConfigInfo->Master;
1160 DeviceDescription.ScatterGather = ConfigInfo->ScatterGather;
1161 DeviceDescription.DemandMode = ConfigInfo->DemandMode;
1162 DeviceDescription.Dma32BitAddresses = ConfigInfo->Dma32BitAddresses;
1163 DeviceDescription.BusNumber = ConfigInfo->SystemIoBusNumber;
1164 DeviceDescription.DmaChannel = ConfigInfo->DmaChannel;
1165 DeviceDescription.InterfaceType = ConfigInfo->AdapterInterfaceType;
1166 DeviceDescription.DmaWidth = ConfigInfo->DmaWidth;
1167 DeviceDescription.DmaSpeed = ConfigInfo->DmaSpeed;
1168 DeviceDescription.MaximumLength = ConfigInfo->MaximumTransferLength;
1169 DeviceDescription.DmaPort = ConfigInfo->DmaPort;
1170
1171 DeviceExtension->DmaAdapter =
1172 IoGetDmaAdapter(DeviceExtension->PhysicalDevice, &DeviceDescription, &NumberOfMapRegisters);
1173
1174 NT_ASSERT(DeviceExtension->DmaAdapter);
1175
1176 /* FIXME: AdapterInterfaceType is exposed here and I think it's convenient to initialize
1177 HwInitData in FDO extension right here. Needs review. */
1178 DeviceExtension->HwInitData = PortGetDriverInitData(DeviceExtension->DriverExtension,
1179 DeviceDescription.InterfaceType);
1180 NT_ASSERT(DeviceExtension->HwInitData);
1181
1182 /* Allocate the uncached extension */
1183 Alignment.QuadPart = 0;
1184 LowestAddress.QuadPart = 0;
1185 HighestAddress.QuadPart = 0x00000000FFFFFFFF;
1186 DeviceExtension->UncachedExtensionVirtualBase = MmAllocateContiguousMemorySpecifyCache(NumberOfBytes,
1187 LowestAddress,
1188 HighestAddress,
1189 Alignment,
1190 MmCached);
1191 if (DeviceExtension->UncachedExtensionVirtualBase == NULL)
1192 return NULL;
1193
1194 DeviceExtension->UncachedExtensionPhysicalBase = MmGetPhysicalAddress(DeviceExtension->UncachedExtensionVirtualBase);
1195 DeviceExtension->UncachedExtensionSize = NumberOfBytes;
1196
1197 return DeviceExtension->UncachedExtensionVirtualBase;
1198}
MmAllocateContiguousMemorySpecifyCache
PVOID NTAPI MmAllocateContiguousMemorySpecifyCache(IN SIZE_T NumberOfBytes, IN PHYSICAL_ADDRESS LowestAcceptableAddress OPTIONAL, IN PHYSICAL_ADDRESS HighestAcceptableAddress, IN PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL, IN MEMORY_CACHING_TYPE CacheType OPTIONAL)
Definition: contmem.c:574
Alignment
union Alignment_ Alignment
Definition: RtlMemIoResource.c:38
IoGetDmaAdapter
PDMA_ADAPTER NTAPI IoGetDmaAdapter(IN PDEVICE_OBJECT PhysicalDeviceObject, IN PDEVICE_DESCRIPTION DeviceDescription, IN OUT PULONG NumberOfMapRegisters)
Definition: pnpdma.c:23
PortGetDriverInitData
PHW_INITIALIZATION_DATA PortGetDriverInitData(PDRIVER_OBJECT_EXTENSION DriverExtension, INTERFACE_TYPE InterfaceType)
Definition: storport.c:81
_DEVICE_DESCRIPTION
Definition: iotypes.h:2068
_FDO_DEVICE_EXTENSION::HwInitData
PHW_INITIALIZATION_DATA HwInitData
Definition: precomp.h:293
_FDO_DEVICE_EXTENSION::DmaAdapter
PDMA_ADAPTER DmaAdapter
Definition: precomp.h:250
Alignment_
Definition: ftraster.c:319
DeviceDescription
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_ PCUNICODE_STRING DeviceDescription
Definition: wdfpdo.h:432
NumberOfMapRegisters
_Out_ PULONG NumberOfMapRegisters
Definition: halfuncs.h:209
DEVICE_DESCRIPTION_VERSION
#define DEVICE_DESCRIPTION_VERSION
Definition: iotypes.h:2063
MmCached
@ MmCached
Definition: mmtypes.h:130

Referenced by AhciAllocateResourceForAdapter().

◆ StorPortGetVirtualAddress()

STORPORT_API PVOID NTAPI StorPortGetVirtualAddress ( _In_ PVOID  HwDeviceExtension,
_In_ STOR_PHYSICAL_ADDRESS  PhysicalAddress 
)

Definition at line 1207 of file storport.c.

1210{
1211 DPRINT1("StorPortGetVirtualAddress(%p %I64x)\n",
1212 HwDeviceExtension, PhysicalAddress.QuadPart);
1213 UNIMPLEMENTED;
1214 return NULL;
1215}

◆ StorPortInitialize()

STORPORT_API ULONG NTAPI StorPortInitialize ( _In_ PVOID  Argument1,
_In_ PVOID  Argument2,
_In_ struct _HW_INITIALIZATION_DATA *  HwInitializationData,
_In_opt_ PVOID  HwContext 
)

Definition at line 1224 of file storport.c.

1229{
1230 PDRIVER_OBJECT DriverObject = (PDRIVER_OBJECT)Argument1;
1231 PUNICODE_STRING RegistryPath = (PUNICODE_STRING)Argument2;
1232 PDRIVER_OBJECT_EXTENSION DriverObjectExtension;
1233 NTSTATUS Status = STATUS_SUCCESS;
1234
1235 DPRINT1("StorPortInitialize(%p %p %p %p)\n",
1236 Argument1, Argument2, HwInitializationData, HwContext);
1237
1238 DPRINT1("HwInitializationDataSize: %lu\n", HwInitializationData->HwInitializationDataSize);
1239 DPRINT1("AdapterInterfaceType: %u\n", HwInitializationData->AdapterInterfaceType);
1240 DPRINT1("HwInitialize: %p\n", HwInitializationData->HwInitialize);
1241 DPRINT1("HwStartIo: %p\n", HwInitializationData->HwStartIo);
1242 DPRINT1("HwInterrupt: %p\n", HwInitializationData->HwInterrupt);
1243 DPRINT1("HwFindAdapter: %p\n", HwInitializationData->HwFindAdapter);
1244 DPRINT1("HwResetBus: %p\n", HwInitializationData->HwResetBus);
1245 DPRINT1("HwDmaStarted: %p\n", HwInitializationData->HwDmaStarted);
1246 DPRINT1("HwAdapterState: %p\n", HwInitializationData->HwAdapterState);
1247 DPRINT1("DeviceExtensionSize: %lu\n", HwInitializationData->DeviceExtensionSize);
1248 DPRINT1("SpecificLuExtensionSize: %lu\n", HwInitializationData->SpecificLuExtensionSize);
1249 DPRINT1("SrbExtensionSize: %lu\n", HwInitializationData->SrbExtensionSize);
1250 DPRINT1("NumberOfAccessRanges: %lu\n", HwInitializationData->NumberOfAccessRanges);
1251
1252 /* Check parameters */
1253 if ((DriverObject == NULL) ||
1254 (RegistryPath == NULL) ||
1255 (HwInitializationData == NULL))
1256 {
1257 DPRINT1("Invalid parameter!\n");
1258 return STATUS_INVALID_PARAMETER;
1259 }
1260
1261 /* Check initialization data */
1262 if ((HwInitializationData->HwInitializationDataSize < sizeof(HW_INITIALIZATION_DATA)) ||
1263 (HwInitializationData->HwInitialize == NULL) ||
1264 (HwInitializationData->HwStartIo == NULL) ||
1265 (HwInitializationData->HwFindAdapter == NULL) ||
1266 (HwInitializationData->HwResetBus == NULL))
1267 {
1268 DPRINT1("Revision mismatch!\n");
1269 return STATUS_REVISION_MISMATCH;
1270 }
1271
1272 DriverObjectExtension = IoGetDriverObjectExtension(DriverObject,
1273 (PVOID)DriverEntry);
1274 if (DriverObjectExtension == NULL)
1275 {
1276 DPRINT1("No driver object extension!\n");
1277
1278 Status = IoAllocateDriverObjectExtension(DriverObject,
1279 (PVOID)DriverEntry,
1280 sizeof(DRIVER_OBJECT_EXTENSION),
1281 (PVOID *)&DriverObjectExtension);
1282 if (!NT_SUCCESS(Status))
1283 {
1284 DPRINT1("IoAllocateDriverObjectExtension() failed (Status 0x%08lx)\n", Status);
1285 return Status;
1286 }
1287
1288 DPRINT1("Driver object extension created!\n");
1289
1290 /* Initialize the driver object extension */
1291 RtlZeroMemory(DriverObjectExtension,
1292 sizeof(DRIVER_OBJECT_EXTENSION));
1293
1294 DriverObjectExtension->ExtensionType = DriverExtension;
1295 DriverObjectExtension->DriverObject = DriverObject;
1296
1297 InitializeListHead(&DriverObjectExtension->AdapterListHead);
1298 KeInitializeSpinLock(&DriverObjectExtension->AdapterListLock);
1299
1300 InitializeListHead(&DriverObjectExtension->InitDataListHead);
1301
1302 /* Set handlers */
1303 DriverObject->DriverExtension->AddDevice = PortAddDevice;
1304// DriverObject->DriverStartIo = PortStartIo;
1305 DriverObject->DriverUnload = PortUnload;
1306 DriverObject->MajorFunction[IRP_MJ_CREATE] = PortDispatchCreate;
1307 DriverObject->MajorFunction[IRP_MJ_CLOSE] = PortDispatchClose;
1308 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PortDispatchDeviceControl;
1309 DriverObject->MajorFunction[IRP_MJ_SCSI] = PortDispatchScsi;
1310 DriverObject->MajorFunction[IRP_MJ_POWER] = PortDispatchPower;
1311 DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = PortDispatchSystemControl;
1312 DriverObject->MajorFunction[IRP_MJ_PNP] = PortDispatchPnp;
1313 }
1314
1315 /* Add the initialzation data to the driver extension */
1316 Status = PortAddDriverInitData(DriverObjectExtension,
1317 HwInitializationData);
1318
1319 DPRINT1("StorPortInitialize() done (Status 0x%08lx)\n", Status);
1320
1321 return Status;
1322}
IRP_MJ_PNP
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
Argument2
_In_ PVOID Argument2
Definition: classpnp.h:721
PUNICODE_STRING
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
IoAllocateDriverObjectExtension
NTSTATUS NTAPI IoAllocateDriverObjectExtension(IN PDRIVER_OBJECT DriverObject, IN PVOID ClientIdentificationAddress, IN ULONG DriverObjectExtensionSize, OUT PVOID *DriverObjectExtension)
Definition: driver.c:1847
STATUS_REVISION_MISMATCH
#define STATUS_REVISION_MISMATCH
Definition: ntstatus.h:419
IRP_MJ_CLOSE
#define IRP_MJ_CLOSE
Definition: rdpdr.c:45
IRP_MJ_DEVICE_CONTROL
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
IRP_MJ_CREATE
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
HwContext
_Must_inspect_result_ _In_ PVOID _In_ struct _HW_INITIALIZATION_DATA _In_ PVOID HwContext
Definition: srb.h:907
PortDispatchSystemControl
static NTSTATUS NTAPI PortDispatchSystemControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:434
PortDispatchClose
static NTSTATUS NTAPI PortDispatchClose(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:343
PortDispatchPower
static NTSTATUS NTAPI PortDispatchPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:487
PortDispatchDeviceControl
static NTSTATUS NTAPI PortDispatchDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:362
PortAddDriverInitData
static NTSTATUS PortAddDriverInitData(PDRIVER_OBJECT_EXTENSION DriverExtension, PHW_INITIALIZATION_DATA HwInitializationData)
Definition: storport.c:28
PortDispatchPnp
static NTSTATUS NTAPI PortDispatchPnp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:453
PortDispatchScsi
static NTSTATUS NTAPI PortDispatchScsi(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:398
PortDispatchCreate
static NTSTATUS NTAPI PortDispatchCreate(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:324
PortUnload
static VOID NTAPI PortUnload(_In_ PDRIVER_OBJECT DriverObject)
Definition: storport.c:304
PortAddDevice
static NTSTATUS NTAPI PortAddDevice(_In_ PDRIVER_OBJECT DriverObject, _In_ PDEVICE_OBJECT PhysicalDeviceObject)
Definition: storport.c:172
_DRIVER_OBJECT_EXTENSION::InitDataListHead
LIST_ENTRY InitDataListHead
Definition: precomp.h:79
_DRIVER_OBJECT_EXTENSION::DriverObject
PDRIVER_OBJECT DriverObject
Definition: precomp.h:73
_DRIVER_OBJECT
Definition: iotypes.h:2289
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
Argument1
_IRQL_requires_same_ _In_opt_ PVOID Argument1
Definition: cmtypes.h:697
IRP_MJ_SCSI
#define IRP_MJ_SCSI
PDRIVER_OBJECT
struct _DRIVER_OBJECT * PDRIVER_OBJECT
IRP_MJ_SYSTEM_CONTROL
#define IRP_MJ_SYSTEM_CONTROL
IRP_MJ_POWER
#define IRP_MJ_POWER

Referenced by DriverEntry().

◆ StorPortLogError()

STORPORT_API VOID NTAPI StorPortLogError ( _In_ PVOID  HwDeviceExtension,
_In_opt_ PSCSI_REQUEST_BLOCK  Srb,
_In_ UCHAR  PathId,
_In_ UCHAR  TargetId,
_In_ UCHAR  Lun,
_In_ ULONG  ErrorCode,
_In_ ULONG  UniqueId 
)

Definition at line 1331 of file storport.c.

1339{
1340 DPRINT1("ScsiPortLogError() called\n");
1341 DPRINT1("PathId: 0x%02x TargetId: 0x%02x Lun: 0x%02x ErrorCode: 0x%08lx UniqueId: 0x%08lx\n",
1342 PathId, TargetId, Lun, ErrorCode, UniqueId);
1343
1344 DPRINT1("ScsiPortLogError() done\n");
1345}
ErrorCode
_In_ NDIS_ERROR_CODE ErrorCode
Definition: ndis.h:4436

◆ StorPortMoveMemory()

STORPORT_API VOID NTAPI StorPortMoveMemory ( _Out_writes_bytes_(Length) PVOID  Destination,
_In_reads_bytes_(Length) PVOID  Source,
_In_ ULONG  Length 
)

Definition at line 1354 of file storport.c.

1358{
1359 RtlMoveMemory(Destination, Source, Length);
1360}
Source
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3169
Destination
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:3051
RtlMoveMemory
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264

◆ StorPortNotification()

STORPORT_API VOID StorPortNotification ( _In_ SCSI_NOTIFICATION_TYPE  NotificationType,
_In_ PVOID  HwDeviceExtension,
  ... 
)

Definition at line 1368 of file storport.c.

1372{
1373 PMINIPORT_DEVICE_EXTENSION MiniportExtension = NULL;
1374 PFDO_DEVICE_EXTENSION FdoExtension = NULL;
1375 PHW_PASSIVE_INITIALIZE_ROUTINE HwPassiveInitRoutine;
1376 PSTORPORT_EXTENDED_FUNCTIONS *ppExtendedFunctions;
1377 PQUEUED_REQUEST_REFERENCE RequestReference;
1378 PBOOLEAN Result;
1379 PSTOR_DPC Dpc;
1380 PHW_DPC_ROUTINE HwDpcRoutine;
1381 PVOID DpcArgument1;
1382 PVOID DpcArgument2;
1383
1384 STOR_SPINLOCK SpinLock;
1385 PVOID LockContext;
1386 PSTOR_LOCK_HANDLE LockHandle;
1387 PSCSI_REQUEST_BLOCK Srb;
1388
1389 va_list ap;
1390
1391 DPRINT("StorPortNotification(%x %p)\n",
1392 NotificationType, HwDeviceExtension);
1393
1394 /* Get the miniport extension */
1395 if (HwDeviceExtension != NULL)
1396 {
1397 MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
1398 MINIPORT_DEVICE_EXTENSION,
1399 HwDeviceExtension);
1400 DPRINT("HwDeviceExtension %p MiniportExtension %p\n",
1401 HwDeviceExtension, MiniportExtension);
1402
1403 FdoExtension = MiniportExtension->Miniport->DeviceExtension;
1404 }
1405
1406 va_start(ap, HwDeviceExtension);
1407
1408 switch (NotificationType)
1409 {
1410 case RequestComplete:
1411 DPRINT("RequestComplete\n");
1412 Srb = (PSCSI_REQUEST_BLOCK)va_arg(ap, PSCSI_REQUEST_BLOCK);
1413 DPRINT("Complete Notify - (%d:%d:%d) ReqRef %p Srb %p Irp %p Tag %x\n",
1414 Srb->PathId, Srb->TargetId, Srb->Lun,
1415 Srb->OriginalRequest, Srb,
1416 ((PQUEUED_REQUEST_REFERENCE)Srb->OriginalRequest)->Irp,
1417 Srb->QueueTag);
1418 // if (Srb->OriginalRequest != NULL)
1419 // {
1420 // // DPRINT1("Need to complete the IRP!\n");
1421 // PortCompleteRequest(HwDeviceExtension, Srb);
1422 // }
1423 NT_ASSERT(Srb->OriginalRequest);
1424 RequestReference = (PQUEUED_REQUEST_REFERENCE)Srb->OriginalRequest;
1425 // if (RequestReference->SpecialRequestId) {
1426 // /* FIXME: DELETE AFTER DEBUG */
1427 // DPRINT1("STORPORT SPECIAL REQUEST %d Queuing for completion\n", RequestReference->SpecialRequestId);
1428 // }
1429
1430 /* Queue for completion */
1431 InterlockedPushEntrySList(&FdoExtension->CompletionList,
1432 &RequestReference->CompletionEntry);
1433
1434 /* Insert DPC for delayed completion */
1435 KeInsertQueueDpc(&FdoExtension->Device->Dpc, NULL, NULL);
1436
1437 break;
1438
1439 case GetExtendedFunctionTable:
1440 DPRINT1("GetExtendedFunctionTable\n");
1441 ppExtendedFunctions = (PSTORPORT_EXTENDED_FUNCTIONS*)va_arg(ap, PSTORPORT_EXTENDED_FUNCTIONS*);
1442 if (ppExtendedFunctions != NULL)
1443 *ppExtendedFunctions = NULL; /* FIXME: */
1444 break;
1445
1446 case EnablePassiveInitialization:
1447 DPRINT1("EnablePassiveInitialization\n");
1448 HwPassiveInitRoutine = (PHW_PASSIVE_INITIALIZE_ROUTINE)va_arg(ap, PHW_PASSIVE_INITIALIZE_ROUTINE);
1449 DPRINT1("HwPassiveInitRoutine %p\n", HwPassiveInitRoutine);
1450 Result = (PBOOLEAN)va_arg(ap, PBOOLEAN);
1451
1452 // FIXME: It is not guaranteed that enabling passive initialization will fail and return
1453 // FALSE when not called in driver's HwStorInitialize routine.
1454 // Docs: Remarks of https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/storport/nf-storport-storportenablepassiveinitialization
1455 *Result = FALSE;
1456
1457 if ((FdoExtension != NULL) &&
1458 (FdoExtension->HwPassiveInitRoutine == NULL))
1459 {
1460 FdoExtension->HwPassiveInitRoutine = HwPassiveInitRoutine;
1461 *Result = TRUE;
1462 }
1463 break;
1464
1465 case InitializeDpc:
1466 DPRINT("InitializeDpc\n");
1467 Dpc = (PSTOR_DPC)va_arg(ap, PSTOR_DPC);
1468 DPRINT("Dpc %p\n", Dpc);
1469 HwDpcRoutine = (PHW_DPC_ROUTINE)va_arg(ap, PHW_DPC_ROUTINE);
1470 DPRINT("HwDpcRoutine %p\n", HwDpcRoutine);
1471
1472 KeInitializeDpc((PRKDPC)&Dpc->Dpc,
1473 (PKDEFERRED_ROUTINE)HwDpcRoutine,
1474 (PVOID)(FdoExtension->Miniport.MiniportExtension->HwDeviceExtension));
1475 KeInitializeSpinLock(&Dpc->Lock);
1476 break;
1477
1478 case IssueDpc:
1479 DPRINT("IssueDpc\n");
1480 Dpc = (PSTOR_DPC)va_arg(ap, PSTOR_DPC);
1481 DpcArgument1 = (PVOID)va_arg(ap, PVOID);
1482 DpcArgument2 = (PVOID)va_arg(ap, PVOID);
1483 DPRINT("Dpc %p Arg1 %p Arg2 %p\n", Dpc, DpcArgument1, DpcArgument2);
1484 Result = (PBOOLEAN)va_arg(ap, PBOOLEAN);
1485
1486 *Result = KeInsertQueueDpc((PKDPC)Dpc, DpcArgument1, DpcArgument2);
1487 break;
1488
1489 case AcquireSpinLock:
1490 DPRINT("AcquireSpinLock\n");
1491 SpinLock = (STOR_SPINLOCK)va_arg(ap, STOR_SPINLOCK);
1492 DPRINT("SpinLock %lu\n", SpinLock);
1493 LockContext = (PVOID)va_arg(ap, PVOID);
1494 DPRINT("LockContext %p\n", LockContext);
1495 LockHandle = (PSTOR_LOCK_HANDLE)va_arg(ap, PSTOR_LOCK_HANDLE);
1496 DPRINT("LockHandle %p\n", LockHandle);
1497 PortAcquireSpinLock(FdoExtension,
1498 SpinLock,
1499 LockContext,
1500 LockHandle);
1501 break;
1502
1503 case ReleaseSpinLock:
1504 DPRINT("ReleaseSpinLock\n");
1505 LockHandle = (PSTOR_LOCK_HANDLE)va_arg(ap, PSTOR_LOCK_HANDLE);
1506 DPRINT("LockHandle %p\n", LockHandle);
1507 PortReleaseSpinLock(FdoExtension,
1508 LockHandle);
1509 break;
1510
1511 case RequestTimerCall:
1512 {
1513 PHW_TIMER TimerRoutine;
1514 ULONG TimerValue;
1515 LARGE_INTEGER TimerDueTime;
1516 NTSTATUS MultiplyResult;
1517
1518 TimerRoutine = (PHW_TIMER)va_arg(ap, PHW_TIMER);
1519 TimerValue = (ULONG)va_arg(ap, ULONG);
1520 NT_ASSERT(TimerRoutine != NULL);
1521
1522 /* Set timer if timer value != 0. Logic is exactly same as StorPortRequestTimer */
1523 if (TimerValue != 0)
1524 {
1525 MultiplyResult = RtlULongLongMult(TimerValue, 10ull, (PULONGLONG)&TimerDueTime.QuadPart);
1526 if (!NT_SUCCESS(MultiplyResult)) {
1527 break;
1528 }
1529
1530 FdoExtension->TimerCallback = TimerRoutine;
1531 KeSetTimer(&FdoExtension->Timer, TimerDueTime, &FdoExtension->TimerDpc);
1532 }
1533 else
1534 {
1535 /* Otherwise cancel the timer. */
1536 KeCancelTimer(&FdoExtension->Timer);
1537 }
1538 break;
1539 }
1540
1541 default:
1542 DPRINT1("Unsupported Notification %lx\n", NotificationType);
1543 break;
1544 }
1545
1546 va_end(ap);
1547}
KeInsertQueueDpc
BOOLEAN NTAPI KeInsertQueueDpc(IN PKDPC Dpc, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
Definition: dpc.c:725
PHW_TIMER
VOID(NTAPI * PHW_TIMER)(IN PVOID DeviceExtension)
Definition: srb.h:456
PSCSI_REQUEST_BLOCK
struct _SCSI_REQUEST_BLOCK * PSCSI_REQUEST_BLOCK
RequestTimerCall
@ RequestTimerCall
Definition: srb.h:537
RequestComplete
@ RequestComplete
Definition: srb.h:531
PortReleaseSpinLock
static VOID PortReleaseSpinLock(PFDO_DEVICE_EXTENSION DeviceExtension, PSTOR_LOCK_HANDLE LockHandle)
Definition: storport.c:142
PortAcquireSpinLock
static VOID PortAcquireSpinLock(PFDO_DEVICE_EXTENSION DeviceExtension, STOR_SPINLOCK SpinLock, PVOID LockContext, PSTOR_LOCK_HANDLE LockHandle)
Definition: storport.c:108
STOR_SPINLOCK
enum _STOR_SPINLOCK STOR_SPINLOCK
PHW_PASSIVE_INITIALIZE_ROUTINE
BOOLEAN(* PHW_PASSIVE_INITIALIZE_ROUTINE)(_In_ PVOID DeviceExtension)
Definition: storport.h:2310
PHW_DPC_ROUTINE
VOID(* PHW_DPC_ROUTINE)(_In_ PSTOR_DPC Dpc, _In_ PVOID HwDeviceExtension, _In_ PVOID SystemArgument1, _In_ PVOID SystemArgument2)
Definition: storport.h:2315
PSTOR_LOCK_HANDLE
struct _STOR_LOCK_HANDLE * PSTOR_LOCK_HANDLE
InitializeDpc
@ InitializeDpc
Definition: storport.h:548
AcquireSpinLock
@ AcquireSpinLock
Definition: storport.h:550
IssueDpc
@ IssueDpc
Definition: storport.h:549
ReleaseSpinLock
@ ReleaseSpinLock
Definition: storport.h:551
GetExtendedFunctionTable
@ GetExtendedFunctionTable
Definition: storport.h:546
EnablePassiveInitialization
@ EnablePassiveInitialization
Definition: storport.h:547
PSTOR_DPC
struct _STOR_DPC * PSTOR_DPC
_KDPC
Definition: ketypes.h:767
_QUEUED_REQUEST_REFERENCE::CompletionEntry
SLIST_ENTRY CompletionEntry
Definition: precomp.h:339
_SCSI_REQUEST_BLOCK
Definition: srb.h:248
_SCSI_REQUEST_BLOCK::QueueTag
UCHAR QueueTag
Definition: srb.h:256
_SCSI_REQUEST_BLOCK::TargetId
UCHAR TargetId
Definition: srb.h:254
_SCSI_REQUEST_BLOCK::PathId
UCHAR PathId
Definition: srb.h:253
_SCSI_REQUEST_BLOCK::Lun
UCHAR Lun
Definition: srb.h:255
_STORPORT_EXTENDED_FUNCTIONS
Definition: storport.h:2385
_STOR_DPC
Definition: storport.h:2172
_STOR_LOCK_HANDLE
Definition: storport.h:2178
PBOOLEAN
unsigned char * PBOOLEAN
Definition: typedefs.h:53
NotificationType
_In_ WDF_SPECIAL_FILE_TYPE NotificationType
Definition: wdfdevice.h:1024
Dpc
_Must_inspect_result_ _In_ PWDF_DPC_CONFIG _In_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFDPC * Dpc
Definition: wdfdpc.h:112
Result
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
TimerRoutine
_In_ PIO_TIMER_ROUTINE TimerRoutine
Definition: iofuncs.h:1078
PKDEFERRED_ROUTINE
KDEFERRED_ROUTINE * PKDEFERRED_ROUTINE
Definition: ketypes.h:758
InterlockedPushEntrySList
#define InterlockedPushEntrySList(SListHead, SListEntry)
Definition: rtlfuncs.h:3413

Referenced by AhciCommandCompletionDpcRoutine(), AhciCompleteIssuedSrb(), AhciHwStartIo(), StorPortAcquireSpinLock(), StorPortEnablePassiveInitialization(), StorPortInitializeDpc(), StorPortIssueDpc(), and StorPortReleaseSpinLock().

◆ StorPortPause()

STORPORT_API BOOLEAN NTAPI StorPortPause ( _In_ PVOID  HwDeviceExtension,
_In_ ULONG  TimeOut 
)

Definition at line 1556 of file storport.c.

1559{
1560 DPRINT1("StorPortPause()\n");
1561 UNIMPLEMENTED;
1562 return FALSE;
1563}

◆ StorPortPauseDevice()

STORPORT_API BOOLEAN NTAPI StorPortPauseDevice ( _In_ PVOID  HwDeviceExtension,
_In_ UCHAR  PathId,
_In_ UCHAR  TargetId,
_In_ UCHAR  Lun,
_In_ ULONG  TimeOut 
)

Definition at line 1572 of file storport.c.

1578{
1579 DPRINT1("StorPortPauseDevice()\n");
1580 UNIMPLEMENTED;
1581 return FALSE;
1582}

◆ StorPortReady()

STORPORT_API BOOLEAN NTAPI StorPortReady ( _In_ PVOID  HwDeviceExtension)

Definition at line 1610 of file storport.c.

1612{
1613 DPRINT1("StorPortReady()\n");
1614 UNIMPLEMENTED;
1615 return FALSE;
1616}

◆ StorPortRegistryRead()

STORPORT_API BOOLEAN NTAPI StorPortRegistryRead ( _In_ PVOID  HwDeviceExtension,
_In_ PUCHAR  ValueName,
_In_ ULONG  Global,
_In_ ULONG  Type,
_In_ PUCHAR  Buffer,
_In_ PULONG  BufferLength 
)

Definition at line 1625 of file storport.c.

1632{
1633 DPRINT1("StorPortRegistryRead()\n");
1634 UNIMPLEMENTED;
1635 return FALSE;
1636}

◆ StorPortRegistryWrite()

STORPORT_API BOOLEAN NTAPI StorPortRegistryWrite ( _In_ PVOID  HwDeviceExtension,
_In_ PUCHAR  ValueName,
_In_ ULONG  Global,
_In_ ULONG  Type,
_In_ PUCHAR  Buffer,
_In_ ULONG  BufferLength 
)

Definition at line 1645 of file storport.c.

1652{
1653 DPRINT1("StorPortRegistryWrite()\n");
1654 UNIMPLEMENTED;
1655 return FALSE;
1656}

◆ StorPortResume()

STORPORT_API BOOLEAN NTAPI StorPortResume ( _In_ PVOID  HwDeviceExtension)

Definition at line 1665 of file storport.c.

1667{
1668 DPRINT1("StorPortResume()\n");
1669 UNIMPLEMENTED;
1670 return FALSE;
1671}

◆ StorPortResumeDevice()

STORPORT_API BOOLEAN NTAPI StorPortResumeDevice ( _In_ PVOID  HwDeviceExtension,
_In_ UCHAR  PathId,
_In_ UCHAR  TargetId,
_In_ UCHAR  Lun 
)

Definition at line 1680 of file storport.c.

1685{
1686 DPRINT1("StorPortResumeDevice()\n");
1687 UNIMPLEMENTED;
1688 return FALSE;
1689}

◆ StorPortSetBusDataByOffset()

STORPORT_API ULONG NTAPI StorPortSetBusDataByOffset ( _In_ PVOID  DeviceExtension,
_In_ ULONG  BusDataType,
_In_ ULONG  SystemIoBusNumber,
_In_ ULONG  SlotNumber,
_In_reads_bytes_(Length) PVOID  Buffer,
_In_ ULONG  Offset,
_In_ ULONG  Length 
)

Definition at line 1698 of file storport.c.

1706{
1707 PMINIPORT_DEVICE_EXTENSION MiniportExtension;
1708 PBUS_INTERFACE_STANDARD Interface;
1709 ULONG ReturnLength;
1710
1711 DPRINT1("StorPortSetBusData(%p %lu %lu %lu %p %lu %lu)\n",
1712 DeviceExtension, BusDataType, SystemIoBusNumber, SlotNumber, Buffer, Offset, Length);
1713
1714 MiniportExtension = CONTAINING_RECORD(DeviceExtension,
1715 MINIPORT_DEVICE_EXTENSION,
1716 HwDeviceExtension);
1717 DPRINT1("DeviceExtension %p MiniportExtension %p\n",
1718 DeviceExtension, MiniportExtension);
1719
1720 Interface = &MiniportExtension->Miniport->DeviceExtension->BusInterface;
1721
1722 ReturnLength = Interface->SetBusData(Interface->Context,
1723 BusDataType,
1724 Buffer,
1725 Offset,
1726 Length);
1727 DPRINT1("ReturnLength: %lu\n", ReturnLength);
1728
1729 return ReturnLength;
1730}

◆ StorPortSetDeviceQueueDepth()

STORPORT_API BOOLEAN NTAPI StorPortSetDeviceQueueDepth ( _In_ PVOID  HwDeviceExtension,
_In_ UCHAR  PathId,
_In_ UCHAR  TargetId,
_In_ UCHAR  Lun,
_In_ ULONG  Depth 
)

Definition at line 1739 of file storport.c.

1745{
1746 PFDO_DEVICE_EXTENSION FdoExtension;
1747 PPDO_DEVICE_EXTENSION PdoExtension;
1748 KLOCK_QUEUE_HANDLE LockHandle;
1749
1750 DPRINT1("StorPortSetDeviceQueueDepth(%p %d %d %d %d)\n",
1751 HwDeviceExtension, PathId, TargetId, Lun, Depth);
1752
1753 FdoExtension = StorpGetMiniportFdo(HwDeviceExtension);
1754 PdoExtension = FdoFindLun(FdoExtension, PathId, TargetId, Lun);
1755
1756 /* 254 is pre-Windows-8 per LUN queue limit */
1757 if (PdoExtension == NULL || Depth > 254)
1758 {
1759 return FALSE;
1760 }
1761
1762 KeAcquireInStackQueuedSpinLock(&FdoExtension->FlowControl.Lock, &LockHandle);
1763 PdoExtension->OutstandingRequestMax = Depth;
1764 KeReleaseInStackQueuedSpinLock(&LockHandle);
1765
1766 DPRINT("Set Path %d Target %d Lun %d Queue depth to %d\n", PathId, TargetId, Lun, Depth);
1767
1768 return FALSE;
1769}
Depth
UINT Depth
Definition: d3d12.idl:4644

Referenced by AtapiInquiryCompletion(), and InquiryCompletion().

◆ StorPortStallExecution()

STORPORT_API VOID NTAPI StorPortStallExecution ( _In_ ULONG  Delay)

Definition at line 1778 of file storport.c.

1780{
1781 KeStallExecutionProcessor(Delay);
1782}
KeStallExecutionProcessor
#define KeStallExecutionProcessor(MicroSeconds)
Definition: precomp.h:27

Referenced by AhciAdapterReset(), AhciPortInitialize(), and AhciStartPort().

◆ StorPortSynchronizeAccess()

STORPORT_API VOID NTAPI StorPortSynchronizeAccess ( _In_ PVOID  HwDeviceExtension,
_In_ PSTOR_SYNCHRONIZED_ACCESS  SynchronizedAccessRoutine,
_In_opt_ PVOID  Context 
)

Definition at line 1791 of file storport.c.

1795{
1796 DPRINT1("StorPortSynchronizeAccess()\n");
1797 UNIMPLEMENTED;
1798}

◆ StorPortValidateRange()

STORPORT_API BOOLEAN NTAPI StorPortValidateRange ( _In_ PVOID  HwDeviceExtension,
_In_ INTERFACE_TYPE  BusType,
_In_ ULONG  SystemIoBusNumber,
_In_ STOR_PHYSICAL_ADDRESS  IoAddress,
_In_ ULONG  NumberOfBytes,
_In_ BOOLEAN  InIoSpace 
)

Definition at line 1807 of file storport.c.

1814{
1815 DPRINT1("StorPortValidateRange()\n");
1816 return TRUE;
1817}

Variable Documentation

◆ PortNumber

ULONG PortNumber = 0

Definition at line 21 of file storport.c.