ReactOS  0.4.13-dev-39-g8b6696f
storport.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS Storport Driver
3  * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4  * PURPOSE: Storport driver main file
5  * COPYRIGHT: Copyright 2017 Eric Kohl (eric.kohl@reactos.org)
6  */
7 
8 /* INCLUDES *******************************************************************/
9 
10 #include "precomp.h"
11 
12 #define NDEBUG
13 #include <debug.h>
14 
15 
16 /* GLOBALS ********************************************************************/
17 
19 
20 
21 /* FUNCTIONS ******************************************************************/
22 
23 static
28 {
29  PDRIVER_INIT_DATA InitData;
30 
31  DPRINT1("PortAddDriverInitData()\n");
32 
34  sizeof(DRIVER_INIT_DATA),
36  if (InitData == NULL)
37  return STATUS_NO_MEMORY;
38 
39  RtlCopyMemory(&InitData->HwInitData,
41  sizeof(HW_INITIALIZATION_DATA));
42 
43  InsertHeadList(&DriverExtension->InitDataListHead,
44  &InitData->Entry);
45 
46  return STATUS_SUCCESS;
47 }
48 
49 
50 static
51 VOID
54 {
55  PDRIVER_INIT_DATA InitData;
56  PLIST_ENTRY ListEntry;
57 
58  DPRINT1("PortDeleteDriverInitData()\n");
59 
60  ListEntry = DriverExtension->InitDataListHead.Flink;
61  while (ListEntry != &DriverExtension->InitDataListHead)
62  {
63  InitData = CONTAINING_RECORD(ListEntry,
65  Entry);
66 
67  RemoveEntryList(&InitData->Entry);
68 
69  ExFreePoolWithTag(InitData,
71 
72  ListEntry = DriverExtension->InitDataListHead.Flink;
73  }
74 }
75 
76 
80  INTERFACE_TYPE InterfaceType)
81 {
82  PDRIVER_INIT_DATA InitData;
83  PLIST_ENTRY ListEntry;
84 
85  DPRINT1("PortGetDriverInitData()\n");
86 
87  ListEntry = DriverExtension->InitDataListHead.Flink;
88  while (ListEntry != &DriverExtension->InitDataListHead)
89  {
90  InitData = CONTAINING_RECORD(ListEntry,
92  Entry);
93  if (InitData->HwInitData.AdapterInterfaceType == InterfaceType)
94  return &InitData->HwInitData;
95 
96  ListEntry = ListEntry->Flink;
97  }
98 
99  return NULL;
100 }
101 
102 
103 static
104 VOID
106  PFDO_DEVICE_EXTENSION DeviceExtension,
108  PVOID LockContext,
110 {
111  DPRINT1("PortAcquireSpinLock(%p %lu %p %p)\n",
112  DeviceExtension, SpinLock, LockContext, LockHandle);
113 
114  LockHandle->Lock = SpinLock;
115 
116  switch (SpinLock)
117  {
118  case DpcLock: /* 1, */
119  DPRINT1("DpcLock\n");
120  break;
121 
122  case StartIoLock: /* 2 */
123  DPRINT1("StartIoLock\n");
124  break;
125 
126  case InterruptLock: /* 3 */
127  DPRINT1("InterruptLock\n");
128  if (DeviceExtension->Interrupt == NULL)
129  LockHandle->Context.OldIrql = 0;
130  else
131  LockHandle->Context.OldIrql = KeAcquireInterruptSpinLock(DeviceExtension->Interrupt);
132  break;
133  }
134 }
135 
136 
137 static
138 VOID
140  PFDO_DEVICE_EXTENSION DeviceExtension,
142 {
143  DPRINT1("PortReleaseSpinLock(%p %p)\n",
144  DeviceExtension, LockHandle);
145 
146  switch (LockHandle->Lock)
147  {
148  case DpcLock: /* 1, */
149  DPRINT1("DpcLock\n");
150  break;
151 
152  case StartIoLock: /* 2 */
153  DPRINT1("StartIoLock\n");
154  break;
155 
156  case InterruptLock: /* 3 */
157  DPRINT1("InterruptLock\n");
158  if (DeviceExtension->Interrupt != NULL)
159  KeReleaseInterruptSpinLock(DeviceExtension->Interrupt,
160  LockHandle->Context.OldIrql);
161  break;
162  }
163 }
164 
165 
166 static
167 NTSTATUS
168 NTAPI
172 {
173  PDRIVER_OBJECT_EXTENSION DriverObjectExtension;
174  PFDO_DEVICE_EXTENSION DeviceExtension = NULL;
175  WCHAR NameBuffer[80];
177  PDEVICE_OBJECT Fdo = NULL;
180 
181  DPRINT1("PortAddDevice(%p %p)\n",
183 
186 
187  swprintf(NameBuffer,
188  L"\\Device\\RaidPort%lu",
189  PortNumber);
190  RtlInitUnicodeString(&DeviceName, NameBuffer);
191  PortNumber++;
192 
193  DPRINT1("Creating device: %wZ\n", &DeviceName);
194 
195  /* Create the port device */
197  sizeof(FDO_DEVICE_EXTENSION),
198  &DeviceName,
201  FALSE,
202  &Fdo);
203  if (!NT_SUCCESS(Status))
204  {
205  DPRINT1("IoCreateDevice() failed (Status 0x%08lx)\n", Status);
206  return Status;
207  }
208 
209  DPRINT1("Created device: %wZ (%p)\n", &DeviceName, Fdo);
210 
211  /* Initialize the device */
212  Fdo->Flags |= DO_DIRECT_IO;
213  Fdo->Flags |= DO_POWER_PAGABLE;
214 
215  /* Initialize the device extension */
216  DeviceExtension = (PFDO_DEVICE_EXTENSION)Fdo->DeviceExtension;
217  RtlZeroMemory(DeviceExtension, sizeof(FDO_DEVICE_EXTENSION));
218 
219  DeviceExtension->ExtensionType = FdoExtension;
220 
221  DeviceExtension->Device = Fdo;
222  DeviceExtension->PhysicalDevice = PhysicalDeviceObject;
223 
224  DeviceExtension->PnpState = dsStopped;
225 
226  /* Attach the FDO to the device stack */
229  &DeviceExtension->LowerDevice);
230  if (!NT_SUCCESS(Status))
231  {
232  DPRINT1("IoAttachDeviceToDeviceStackSafe() failed (Status 0x%08lx)\n", Status);
233  IoDeleteDevice(Fdo);
234  return Status;
235  }
236 
237  /* Insert the FDO to the drivers FDO list */
238  DriverObjectExtension = IoGetDriverObjectExtension(DriverObject,
239  (PVOID)DriverEntry);
240  ASSERT(DriverObjectExtension->ExtensionType == DriverExtension);
241 
242  DeviceExtension->DriverExtension = DriverObjectExtension;
243 
244  KeAcquireInStackQueuedSpinLock(&DriverObjectExtension->AdapterListLock,
245  &LockHandle);
246 
247  InsertHeadList(&DriverObjectExtension->AdapterListHead,
248  &DeviceExtension->AdapterListEntry);
249  DriverObjectExtension->AdapterCount++;
250 
252 
253  /* The device has been initialized */
254  Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
255 
256  DPRINT1("PortAddDevice() done (Status 0x%08lx)\n", Status);
257 
258  return Status;
259 }
260 
261 
262 static
263 VOID
264 NTAPI
267 {
269 
270  DPRINT1("PortUnload(%p)\n",
271  DriverObject);
272 
274  (PVOID)DriverEntry);
275  if (DriverExtension != NULL)
276  {
278  }
279 }
280 
281 
282 static
283 NTSTATUS
284 NTAPI
287  IN PIRP Irp)
288 {
289  DPRINT1("PortDispatchCreate(%p %p)\n",
290  DeviceObject, Irp);
291 
292  Irp->IoStatus.Status = STATUS_SUCCESS;
293  Irp->IoStatus.Information = FILE_OPENED;
294 
296 
297  return STATUS_SUCCESS;
298 }
299 
300 
301 static
302 NTSTATUS
303 NTAPI
306  IN PIRP Irp)
307 {
308  DPRINT1("PortDispatchClose(%p %p)\n",
309  DeviceObject, Irp);
310 
311  Irp->IoStatus.Status = STATUS_SUCCESS;
312  Irp->IoStatus.Information = 0;
313 
315 
316  return STATUS_SUCCESS;
317 }
318 
319 
320 static
321 NTSTATUS
322 NTAPI
325  IN PIRP Irp)
326 {
327  DPRINT1("PortDispatchDeviceControl(%p %p)\n",
328  DeviceObject, Irp);
329 
330  Irp->IoStatus.Status = STATUS_SUCCESS;
331  Irp->IoStatus.Information = 0;
332 
334 
335  return STATUS_SUCCESS;
336 }
337 
338 
339 static
340 NTSTATUS
341 NTAPI
344  IN PIRP Irp)
345 {
346  PFDO_DEVICE_EXTENSION DeviceExtension;
347 
348  DPRINT1("PortDispatchScsi(%p %p)\n",
349  DeviceObject, Irp);
350 
352  DPRINT1("ExtensionType: %u\n", DeviceExtension->ExtensionType);
353 
354  switch (DeviceExtension->ExtensionType)
355  {
356  case FdoExtension:
357  return PortFdoScsi(DeviceObject,
358  Irp);
359 
360  case PdoExtension:
361  return PortPdoScsi(DeviceObject,
362  Irp);
363 
364  default:
365  Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
366  Irp->IoStatus.Information = 0;
368  return STATUS_UNSUCCESSFUL;
369  }
370 
371  return STATUS_SUCCESS;
372 }
373 
374 
375 static
376 NTSTATUS
377 NTAPI
380  IN PIRP Irp)
381 {
382  DPRINT1("PortDispatchSystemControl(%p %p)\n",
383  DeviceObject, Irp);
384 
385  Irp->IoStatus.Status = STATUS_SUCCESS;
386  Irp->IoStatus.Information = 0;
387 
389 
390  return STATUS_SUCCESS;
391 }
392 
393 
394 static
395 NTSTATUS
396 NTAPI
399  IN PIRP Irp)
400 {
401  PFDO_DEVICE_EXTENSION DeviceExtension;
402 
403  DPRINT1("PortDispatchPnp(%p %p)\n",
404  DeviceObject, Irp);
405 
407  DPRINT1("ExtensionType: %u\n", DeviceExtension->ExtensionType);
408 
409  switch (DeviceExtension->ExtensionType)
410  {
411  case FdoExtension:
412  return PortFdoPnp(DeviceObject,
413  Irp);
414 
415  case PdoExtension:
416  return PortPdoPnp(DeviceObject,
417  Irp);
418 
419  default:
420  Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
421  Irp->IoStatus.Information = 0;
423  return STATUS_UNSUCCESSFUL;
424  }
425 }
426 
427 
428 static
429 NTSTATUS
430 NTAPI
433  IN PIRP Irp)
434 {
435  DPRINT1("PortDispatchPower(%p %p)\n",
436  DeviceObject, Irp);
437 
438  Irp->IoStatus.Status = STATUS_SUCCESS;
439  Irp->IoStatus.Information = 0;
440 
442 
443  return STATUS_SUCCESS;
444 }
445 
446 
447 /* PUBLIC FUNCTIONS ***********************************************************/
448 
449 /*
450  * @implemented
451  */
452 NTSTATUS
453 NTAPI
457 {
458  DPRINT1("DriverEntry(%p %p)\n", DriverObject, RegistryPath);
459  return STATUS_SUCCESS;
460 }
461 
462 
463 /*
464  * @unimplemented
465  */
467 PUCHAR
468 NTAPI
470  _In_ PVOID HwDeviceExtension,
472 {
473  DPRINT1("StorPortAllocateRegistryBuffer()\n");
475  return NULL;
476 }
477 
478 
479 /*
480  * @unimplemented
481  */
483 BOOLEAN
484 NTAPI
486  _In_ PVOID HwDeviceExtension,
487  _In_ ULONG RequestsToComplete)
488 {
489  DPRINT1("StorPortBuzy()\n");
491  return FALSE;
492 }
493 
494 
495 /*
496  * @unimplemented
497  */
499 VOID
500 NTAPI
502  _In_ PVOID HwDeviceExtension,
503  _In_ UCHAR PathId,
505  _In_ UCHAR Lun,
506  _In_ UCHAR SrbStatus)
507 {
508  DPRINT1("StorPortCompleteRequest()\n");
510 }
511 
512 
513 /*
514  * @implemented
515  */
517 ULONG
518 NTAPI
521 {
522  DPRINT1("StorPortConvertPhysicalAddressToUlong()\n");
523 
524  return Address.u.LowPart;
525 }
526 
527 
528 /*
529  * @implemented
530  */
533 NTAPI
535  _In_ ULONG_PTR UlongAddress)
536 {
538 
539  DPRINT1("StorPortConvertUlongToPhysicalAddress()\n");
540 
541  Address.QuadPart = UlongAddress;
542  return Address;
543 }
544 
545 
546 /*
547  * @implemented
548  */
550 VOID
552  _In_ ULONG DebugPrintLevel,
553  _In_ PCHAR DebugMessage,
554  ...)
555 {
556  va_list ap;
557 
558  va_start(ap, DebugMessage);
559  vDbgPrintExWithPrefix("STORMINI: ", 0x58, DebugPrintLevel, DebugMessage, ap);
560  va_end(ap);
561 }
562 
563 
564 /*
565  * @unimplemented
566  */
568 BOOLEAN
569 NTAPI
571  _In_ PVOID HwDeviceExtension,
572  _In_ UCHAR PathId,
574  _In_ UCHAR Lun,
575  _In_ ULONG RequestsToComplete)
576 {
577  DPRINT1("StorPortDeviceBusy()\n");
579  return FALSE;
580 }
581 
582 
583 /*
584  * @unimplemented
585  */
587 BOOLEAN
588 NTAPI
590  _In_ PVOID HwDeviceExtension,
591  _In_ UCHAR PathId,
593  _In_ UCHAR Lun)
594 {
595  DPRINT1("StorPortDeviceReady()\n");
597  return FALSE;
598 }
599 
600 
601 /*
602  * @unimplemented
603  */
605 ULONG
607  _In_ STORPORT_FUNCTION_CODE FunctionCode,
608  _In_ PVOID HwDeviceExtension,
609  ...)
610 {
611  DPRINT1("StorPortExtendedFunction(%d %p ...)\n",
612  FunctionCode, HwDeviceExtension);
614  return STATUS_NOT_IMPLEMENTED;
615 }
616 
617 
618 /*
619  * @implemented
620  */
622 VOID
623 NTAPI
625  _In_ PVOID HwDeviceExtension,
626  _In_ PVOID MappedAddress)
627 {
628  DPRINT1("StorPortFreeDeviceBase(%p %p)\n",
629  HwDeviceExtension, MappedAddress);
630 }
631 
632 
633 /*
634  * @unimplemented
635  */
637 VOID
638 NTAPI
640  _In_ PVOID HwDeviceExtension,
642 {
643  DPRINT1("StorPortFreeRegistryBuffer()\n");
645 }
646 
647 
648 /*
649  * @implemented
650  */
652 ULONG
653 NTAPI
655  _In_ PVOID DeviceExtension,
656  _In_ ULONG BusDataType,
657  _In_ ULONG SystemIoBusNumber,
660  _In_ ULONG Length)
661 {
662  PMINIPORT_DEVICE_EXTENSION MiniportExtension;
665 
666  DPRINT1("StorPortGetBusData(%p %lu %lu %lu %p %lu)\n",
667  DeviceExtension, BusDataType, SystemIoBusNumber, SlotNumber, Buffer, Length);
668 
669  /* Get the miniport extension */
670  MiniportExtension = CONTAINING_RECORD(DeviceExtension,
672  HwDeviceExtension);
673  DPRINT1("DeviceExtension %p MiniportExtension %p\n",
674  DeviceExtension, MiniportExtension);
675 
676  Interface = &MiniportExtension->Miniport->DeviceExtension->BusInterface;
677 
678  if (BusDataType == 4)
679  BusDataType = 0;
680 
681  ReturnLength = Interface->GetBusData(Interface->Context,
682  BusDataType,
683  Buffer,
684  0,
685  Length);
686  DPRINT1("ReturnLength: %lu\n", ReturnLength);
687 
688  return ReturnLength;
689 }
690 
691 
692 /*
693  * @implemented
694  */
696 PVOID
697 NTAPI
699  _In_ PVOID HwDeviceExtension,
701  _In_ ULONG SystemIoBusNumber,
702  _In_ STOR_PHYSICAL_ADDRESS IoAddress,
704  _In_ BOOLEAN InIoSpace)
705 {
706  PMINIPORT_DEVICE_EXTENSION MiniportExtension;
708  PVOID MappedAddress;
710 
711  DPRINT1("StorPortGetDeviceBase(%p %lu %lu 0x%I64x %lu %u)\n",
712  HwDeviceExtension, BusType, SystemIoBusNumber, IoAddress.QuadPart, NumberOfBytes, InIoSpace);
713 
714  /* Get the miniport extension */
715  MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
717  HwDeviceExtension);
718  DPRINT1("HwDeviceExtension %p MiniportExtension %p\n",
719  HwDeviceExtension, MiniportExtension);
720 
721  if (!TranslateResourceListAddress(MiniportExtension->Miniport->DeviceExtension,
722  BusType,
723  SystemIoBusNumber,
724  IoAddress,
726  InIoSpace,
728  {
729  DPRINT1("Checkpoint!\n");
730  return NULL;
731  }
732 
733  DPRINT1("Translated Address: 0x%I64x\n", TranslatedAddress.QuadPart);
734 
735  /* In I/O space */
736  if (InIoSpace)
737  {
738  DPRINT1("Translated Address: %p\n", (PVOID)(ULONG_PTR)TranslatedAddress.QuadPart);
740  }
741 
742  /* In memory space */
743  MappedAddress = MmMapIoSpace(TranslatedAddress,
745  FALSE);
746  DPRINT1("Mapped Address: %p\n", MappedAddress);
747 
748  Status = AllocateAddressMapping(&MiniportExtension->Miniport->DeviceExtension->MappedAddressList,
749  IoAddress,
750  MappedAddress,
752  SystemIoBusNumber);
753  if (!NT_SUCCESS(Status))
754  {
755  DPRINT1("Checkpoint!\n");
756  MappedAddress = NULL;
757  }
758 
759  DPRINT1("Mapped Address: %p\n", MappedAddress);
760  return MappedAddress;
761 }
762 
763 
764 /*
765  * @unimplemented
766  */
768 PVOID
769 NTAPI
771  _In_ PVOID HwDeviceExtension,
772  _In_ UCHAR PathId,
774  _In_ UCHAR Lun)
775 {
776  DPRINT1("StorPortGetLogicalUnit()\n");
778  return NULL;
779 }
780 
781 
782 /*
783  * @implemented
784  */
787 NTAPI
789  _In_ PVOID HwDeviceExtension,
792  _Out_ ULONG *Length)
793 {
794  PMINIPORT_DEVICE_EXTENSION MiniportExtension;
795  PFDO_DEVICE_EXTENSION DeviceExtension;
798 
799  DPRINT1("StorPortGetPhysicalAddress(%p %p %p %p)\n",
800  HwDeviceExtension, Srb, VirtualAddress, Length);
801 
802  /* Get the miniport extension */
803  MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
805  HwDeviceExtension);
806  DPRINT1("HwDeviceExtension %p MiniportExtension %p\n",
807  HwDeviceExtension, MiniportExtension);
808 
809  DeviceExtension = MiniportExtension->Miniport->DeviceExtension;
810 
811  /* Inside of the uncached extension? */
812  if (((ULONG_PTR)VirtualAddress >= (ULONG_PTR)DeviceExtension->UncachedExtensionVirtualBase) &&
813  ((ULONG_PTR)VirtualAddress <= (ULONG_PTR)DeviceExtension->UncachedExtensionVirtualBase + DeviceExtension->UncachedExtensionSize))
814  {
816 
818  *Length = DeviceExtension->UncachedExtensionSize - Offset;
819 
820  return PhysicalAddress;
821  }
822 
823  // FIXME
824 
825 
827  *Length = 1;
828 // UNIMPLEMENTED;
829 
830 // *Length = 0;
831 // PhysicalAddress.QuadPart = (LONGLONG)0;
832 
833  return PhysicalAddress;
834 }
835 
836 
837 /*
838  * @unimplemented
839  */
842 NTAPI
844  _In_ PVOID DeviceExtension,
846 {
847  DPRINT1("StorPortGetScatterGatherList()\n");
849  return NULL;
850 }
851 
852 
853 /*
854  * @implemented
855  */
858 NTAPI
860  _In_ PVOID DeviceExtension,
861  _In_ UCHAR PathId,
863  _In_ UCHAR Lun,
864  _In_ LONG QueueTag)
865 {
866  DPRINT("StorPortGetSrb()\n");
867  return NULL;
868 }
869 
870 
871 /*
872  * @implemented
873  */
875 PVOID
876 NTAPI
878  _In_ PVOID HwDeviceExtension,
881 {
882  PMINIPORT_DEVICE_EXTENSION MiniportExtension;
883  PFDO_DEVICE_EXTENSION DeviceExtension;
884  PHYSICAL_ADDRESS LowestAddress, HighestAddress, Alignment;
885 
886  DPRINT1("StorPortGetUncachedExtension(%p %p %lu)\n",
887  HwDeviceExtension, ConfigInfo, NumberOfBytes);
888 
889  /* Get the miniport extension */
890  MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
892  HwDeviceExtension);
893  DPRINT1("HwDeviceExtension %p MiniportExtension %p\n",
894  HwDeviceExtension, MiniportExtension);
895 
896  DeviceExtension = MiniportExtension->Miniport->DeviceExtension;
897 
898  /* Return the uncached extension base address if we already have one */
899  if (DeviceExtension->UncachedExtensionVirtualBase != NULL)
900  return DeviceExtension->UncachedExtensionVirtualBase;
901 
902  // FIXME: Set DMA stuff here?
903 
904  /* Allocate the uncached extension */
905  Alignment.QuadPart = 0;
906  LowestAddress.QuadPart = 0;
907  HighestAddress.QuadPart = 0x00000000FFFFFFFF;
909  LowestAddress,
910  HighestAddress,
911  Alignment,
912  MmCached);
913  if (DeviceExtension->UncachedExtensionVirtualBase == NULL)
914  return NULL;
915 
917  DeviceExtension->UncachedExtensionSize = NumberOfBytes;
918 
919  return DeviceExtension->UncachedExtensionVirtualBase;
920 }
921 
922 
923 /*
924  * @unimplemented
925  */
927 PVOID
928 NTAPI
930  _In_ PVOID HwDeviceExtension,
932 {
933  DPRINT1("StorPortGetVirtualAddress(%p %I64x)\n",
934  HwDeviceExtension, PhysicalAddress.QuadPart);
936  return NULL;
937 }
938 
939 
940 /*
941  * @implemented
942  */
944 ULONG
945 NTAPI
951 {
954  PDRIVER_OBJECT_EXTENSION DriverObjectExtension;
956 
957  DPRINT1("StorPortInitialize(%p %p %p %p)\n",
959 
960  DPRINT1("HwInitializationDataSize: %lu\n", HwInitializationData->HwInitializationDataSize);
961  DPRINT1("AdapterInterfaceType: %u\n", HwInitializationData->AdapterInterfaceType);
962  DPRINT1("HwInitialize: %p\n", HwInitializationData->HwInitialize);
963  DPRINT1("HwStartIo: %p\n", HwInitializationData->HwStartIo);
964  DPRINT1("HwInterrupt: %p\n", HwInitializationData->HwInterrupt);
965  DPRINT1("HwFindAdapter: %p\n", HwInitializationData->HwFindAdapter);
966  DPRINT1("HwResetBus: %p\n", HwInitializationData->HwResetBus);
967  DPRINT1("HwDmaStarted: %p\n", HwInitializationData->HwDmaStarted);
968  DPRINT1("HwAdapterState: %p\n", HwInitializationData->HwAdapterState);
969  DPRINT1("DeviceExtensionSize: %lu\n", HwInitializationData->DeviceExtensionSize);
970  DPRINT1("SpecificLuExtensionSize: %lu\n", HwInitializationData->SpecificLuExtensionSize);
971  DPRINT1("SrbExtensionSize: %lu\n", HwInitializationData->SrbExtensionSize);
972  DPRINT1("NumberOfAccessRanges: %lu\n", HwInitializationData->NumberOfAccessRanges);
973 
974  /* Check parameters */
975  if ((DriverObject == NULL) ||
976  (RegistryPath == NULL) ||
978  {
979  DPRINT1("Invalid parameter!\n");
981  }
982 
983  /* Check initialization data */
984  if ((HwInitializationData->HwInitializationDataSize < sizeof(HW_INITIALIZATION_DATA)) ||
985  (HwInitializationData->HwInitialize == NULL) ||
986  (HwInitializationData->HwStartIo == NULL) ||
987  (HwInitializationData->HwFindAdapter == NULL) ||
988  (HwInitializationData->HwResetBus == NULL))
989  {
990  DPRINT1("Revision mismatch!\n");
992  }
993 
994  DriverObjectExtension = IoGetDriverObjectExtension(DriverObject,
995  (PVOID)DriverEntry);
996  if (DriverObjectExtension == NULL)
997  {
998  DPRINT1("No driver object extension!\n");
999 
1001  (PVOID)DriverEntry,
1002  sizeof(DRIVER_OBJECT_EXTENSION),
1003  (PVOID *)&DriverObjectExtension);
1004  if (!NT_SUCCESS(Status))
1005  {
1006  DPRINT1("IoAllocateDriverObjectExtension() failed (Status 0x%08lx)\n", Status);
1007  return Status;
1008  }
1009 
1010  DPRINT1("Driver object extension created!\n");
1011 
1012  /* Initialize the driver object extension */
1013  RtlZeroMemory(DriverObjectExtension,
1014  sizeof(DRIVER_OBJECT_EXTENSION));
1015 
1016  DriverObjectExtension->ExtensionType = DriverExtension;
1017  DriverObjectExtension->DriverObject = DriverObject;
1018 
1019  InitializeListHead(&DriverObjectExtension->AdapterListHead);
1020  KeInitializeSpinLock(&DriverObjectExtension->AdapterListLock);
1021 
1022  InitializeListHead(&DriverObjectExtension->InitDataListHead);
1023 
1024  /* Set handlers */
1026 // DriverObject->DriverStartIo = PortStartIo;
1035  }
1036 
1037  /* Add the initialzation data to the driver extension */
1038  Status = PortAddDriverInitData(DriverObjectExtension,
1040 
1041  DPRINT1("StorPortInitialize() done (Status 0x%08lx)\n", Status);
1042 
1043  return Status;
1044 }
1045 
1046 
1047 /*
1048  * @unimplemented
1049  */
1051 VOID
1052 NTAPI
1054  _In_ PVOID HwDeviceExtension,
1056  _In_ UCHAR PathId,
1058  _In_ UCHAR Lun,
1060  _In_ ULONG UniqueId)
1061 {
1062  DPRINT1("ScsiPortLogError() called\n");
1063  DPRINT1("PathId: 0x%02x TargetId: 0x%02x Lun: 0x%02x ErrorCode: 0x%08lx UniqueId: 0x%08lx\n",
1064  PathId, TargetId, Lun, ErrorCode, UniqueId);
1065 
1066  DPRINT1("ScsiPortLogError() done\n");
1067 }
1068 
1069 
1070 /*
1071  * @implemented
1072  */
1074 VOID
1075 NTAPI
1079  _In_ ULONG Length)
1080 {
1082 }
1083 
1084 
1085 /*
1086  * @unimplemented
1087  */
1089 VOID
1091  _In_ SCSI_NOTIFICATION_TYPE NotificationType,
1092  _In_ PVOID HwDeviceExtension,
1093  ...)
1094 {
1095  PMINIPORT_DEVICE_EXTENSION MiniportExtension = NULL;
1096  PFDO_DEVICE_EXTENSION DeviceExtension = NULL;
1097  PHW_PASSIVE_INITIALIZE_ROUTINE HwPassiveInitRoutine;
1098  PSTORPORT_EXTENDED_FUNCTIONS *ppExtendedFunctions;
1099  PBOOLEAN Result;
1100  PSTOR_DPC Dpc;
1101  PHW_DPC_ROUTINE HwDpcRoutine;
1102  va_list ap;
1103 
1105  PVOID LockContext;
1107 
1108  DPRINT1("StorPortNotification(%x %p)\n",
1109  NotificationType, HwDeviceExtension);
1110 
1111  /* Get the miniport extension */
1112  if (HwDeviceExtension != NULL)
1113  {
1114  MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
1116  HwDeviceExtension);
1117  DPRINT1("HwDeviceExtension %p MiniportExtension %p\n",
1118  HwDeviceExtension, MiniportExtension);
1119 
1120  DeviceExtension = MiniportExtension->Miniport->DeviceExtension;
1121  }
1122 
1123  va_start(ap, HwDeviceExtension);
1124 
1125  switch (NotificationType)
1126  {
1128  DPRINT1("GetExtendedFunctionTable\n");
1130  if (ppExtendedFunctions != NULL)
1131  *ppExtendedFunctions = NULL; /* FIXME */
1132  break;
1133 
1135  DPRINT1("EnablePassiveInitialization\n");
1137  DPRINT1("HwPassiveInitRoutine %p\n", HwPassiveInitRoutine);
1139 
1140  *Result = FALSE;
1141 
1142  if ((DeviceExtension != NULL) &&
1143  (DeviceExtension->HwPassiveInitRoutine == NULL))
1144  {
1145  DeviceExtension->HwPassiveInitRoutine = HwPassiveInitRoutine;
1146  *Result = TRUE;
1147  }
1148  break;
1149 
1150  case InitializeDpc:
1151  DPRINT1("InitializeDpc\n");
1153  DPRINT1("Dpc %p\n", Dpc);
1154  HwDpcRoutine = (PHW_DPC_ROUTINE)va_arg(ap, PHW_DPC_ROUTINE);
1155  DPRINT1("HwDpcRoutine %p\n", HwDpcRoutine);
1156 
1157  KeInitializeDpc((PRKDPC)&Dpc->Dpc,
1158  (PKDEFERRED_ROUTINE)HwDpcRoutine,
1159  (PVOID)DeviceExtension);
1160  KeInitializeSpinLock(&Dpc->Lock);
1161  break;
1162 
1163  case AcquireSpinLock:
1164  DPRINT1("AcquireSpinLock\n");
1166  DPRINT1("SpinLock %lu\n", SpinLock);
1167  LockContext = (PVOID)va_arg(ap, PVOID);
1168  DPRINT1("LockContext %p\n", LockContext);
1170  DPRINT1("LockHandle %p\n", LockHandle);
1171  PortAcquireSpinLock(DeviceExtension,
1172  SpinLock,
1173  LockContext,
1174  LockHandle);
1175  break;
1176 
1177  case ReleaseSpinLock:
1178  DPRINT1("ReleaseSpinLock\n");
1180  DPRINT1("LockHandle %p\n", LockHandle);
1181  PortReleaseSpinLock(DeviceExtension,
1182  LockHandle);
1183  break;
1184 
1185  default:
1186  DPRINT1("Unsupported Notification %lx\n", NotificationType);
1187  break;
1188  }
1189 
1190  va_end(ap);
1191 }
1192 
1193 
1194 /*
1195  * @unimplemented
1196  */
1198 BOOLEAN
1199 NTAPI
1201  _In_ PVOID HwDeviceExtension,
1202  _In_ ULONG TimeOut)
1203 {
1204  DPRINT1("StorPortPause()\n");
1205  UNIMPLEMENTED;
1206  return FALSE;
1207 }
1208 
1209 
1210 /*
1211  * @unimplemented
1212  */
1214 BOOLEAN
1215 NTAPI
1217  _In_ PVOID HwDeviceExtension,
1218  _In_ UCHAR PathId,
1220  _In_ UCHAR Lun,
1221  _In_ ULONG TimeOut)
1222 {
1223  DPRINT1("StorPortPauseDevice()\n");
1224  UNIMPLEMENTED;
1225  return FALSE;
1226 }
1227 
1228 
1229 #if defined(_M_AMD64)
1230 /*
1231  * @implemented
1232  */
1233 /* KeQuerySystemTime is an inline function,
1234  so we cannot forward the export to ntoskrnl */
1236 VOID
1237 NTAPI
1239  _Out_ PLARGE_INTEGER CurrentTime)
1240 {
1241  DPRINT1("StorPortQuerySystemTime(%p)\n", CurrentTime);
1242 
1243  KeQuerySystemTime(CurrentTime);
1244 }
1245 #endif /* defined(_M_AMD64) */
1246 
1247 
1248 /*
1249  * @unimplemented
1250  */
1252 BOOLEAN
1253 NTAPI
1255  _In_ PVOID HwDeviceExtension)
1256 {
1257  DPRINT1("StorPortReady()\n");
1258  UNIMPLEMENTED;
1259  return FALSE;
1260 }
1261 
1262 
1263 /*
1264  * @unimplemented
1265  */
1267 BOOLEAN
1268 NTAPI
1270  _In_ PVOID HwDeviceExtension,
1272  _In_ ULONG Global,
1273  _In_ ULONG Type,
1274  _In_ PUCHAR Buffer,
1276 {
1277  DPRINT1("StorPortRegistryRead()\n");
1278  UNIMPLEMENTED;
1279  return FALSE;
1280 }
1281 
1282 
1283 /*
1284  * @unimplemented
1285  */
1287 BOOLEAN
1288 NTAPI
1290  _In_ PVOID HwDeviceExtension,
1292  _In_ ULONG Global,
1293  _In_ ULONG Type,
1294  _In_ PUCHAR Buffer,
1296 {
1297  DPRINT1("StorPortRegistryWrite()\n");
1298  UNIMPLEMENTED;
1299  return FALSE;
1300 }
1301 
1302 
1303 /*
1304  * @unimplemented
1305  */
1307 BOOLEAN
1308 NTAPI
1310  _In_ PVOID HwDeviceExtension)
1311 {
1312  DPRINT1("StorPortResume()\n");
1313  UNIMPLEMENTED;
1314  return FALSE;
1315 }
1316 
1317 
1318 /*
1319  * @unimplemented
1320  */
1322 BOOLEAN
1323 NTAPI
1325  _In_ PVOID HwDeviceExtension,
1326  _In_ UCHAR PathId,
1328  _In_ UCHAR Lun)
1329 {
1330  DPRINT1("StorPortResumeDevice()\n");
1331  UNIMPLEMENTED;
1332  return FALSE;
1333 }
1334 
1335 
1336 /*
1337  * @implemented
1338  */
1340 ULONG
1341 NTAPI
1343  _In_ PVOID DeviceExtension,
1344  _In_ ULONG BusDataType,
1345  _In_ ULONG SystemIoBusNumber,
1348  _In_ ULONG Offset,
1349  _In_ ULONG Length)
1350 {
1351  PMINIPORT_DEVICE_EXTENSION MiniportExtension;
1354 
1355  DPRINT1("StorPortSetBusData(%p %lu %lu %lu %p %lu %lu)\n",
1356  DeviceExtension, BusDataType, SystemIoBusNumber, SlotNumber, Buffer, Offset, Length);
1357 
1358  MiniportExtension = CONTAINING_RECORD(DeviceExtension,
1360  HwDeviceExtension);
1361  DPRINT1("DeviceExtension %p MiniportExtension %p\n",
1362  DeviceExtension, MiniportExtension);
1363 
1364  Interface = &MiniportExtension->Miniport->DeviceExtension->BusInterface;
1365 
1366  ReturnLength = Interface->SetBusData(Interface->Context,
1367  BusDataType,
1368  Buffer,
1369  Offset,
1370  Length);
1371  DPRINT1("ReturnLength: %lu\n", ReturnLength);
1372 
1373  return ReturnLength;
1374 }
1375 
1376 
1377 /*
1378  * @unimplemented
1379  */
1381 BOOLEAN
1382 NTAPI
1384  _In_ PVOID HwDeviceExtension,
1385  _In_ UCHAR PathId,
1387  _In_ UCHAR Lun,
1388  _In_ ULONG Depth)
1389 {
1390  DPRINT1("StorPortSetDeviceQueueDepth()\n");
1391  UNIMPLEMENTED;
1392  return FALSE;
1393 }
1394 
1395 
1396 /*
1397  * @implemented
1398  */
1400 VOID
1401 NTAPI
1403  _In_ ULONG Delay)
1404 {
1406 }
1407 
1408 
1409 /*
1410  * @unimplemented
1411  */
1413 VOID
1414 NTAPI
1416  _In_ PVOID HwDeviceExtension,
1417  _In_ PSTOR_SYNCHRONIZED_ACCESS SynchronizedAccessRoutine,
1419 {
1420  DPRINT1("StorPortSynchronizeAccess()\n");
1421  UNIMPLEMENTED;
1422 }
1423 
1424 
1425 /*
1426  * @implemented
1427  */
1429 BOOLEAN
1430 NTAPI
1432  _In_ PVOID HwDeviceExtension,
1434  _In_ ULONG SystemIoBusNumber,
1435  _In_ STOR_PHYSICAL_ADDRESS IoAddress,
1437  _In_ BOOLEAN InIoSpace)
1438 {
1439  DPRINT1("StorPortValidateRange()\n");
1440  return TRUE;
1441 }
1442 
1443 /* EOF */
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
#define DO_DEVICE_INITIALIZING
Definition: env_spec_w32.h:399
#define STATUS_REVISION_MISMATCH
Definition: ntstatus.h:311
signed char * PCHAR
Definition: retypes.h:7
NTSTATUS NTAPI PortFdoScsi(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
Definition: fdo.c:572
#define DO_POWER_PAGABLE
STORPORT_API ULONG NTAPI StorPortConvertPhysicalAddressToUlong(_In_ STOR_PHYSICAL_ADDRESS Address)
Definition: storport.c:519
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
static VOID PortReleaseSpinLock(PFDO_DEVICE_EXTENSION DeviceExtension, PSTOR_LOCK_HANDLE LockHandle)
Definition: storport.c:139
#define IN
Definition: typedefs.h:38
_In_opt_ PALLOCATE_FUNCTION _In_opt_ PFREE_FUNCTION _In_ ULONG _In_ SIZE_T _In_ ULONG _In_ USHORT Depth
Definition: exfuncs.h:656
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
PKINTERRUPT Interrupt
Definition: parport.h:51
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
PHYSICAL_ADDRESS UncachedExtensionPhysicalBase
Definition: precomp.h:103
_In_ NDIS_ERROR_CODE ErrorCode
Definition: ndis.h:4418
PVOID UncachedExtensionVirtualBase
Definition: precomp.h:102
enum _INTERFACE_TYPE INTERFACE_TYPE
_In_ ULONG _In_ BOOLEAN _In_ ULONG _In_ UCHAR _In_ UCHAR _In_ UCHAR Lun
Definition: classpnp.h:1117
_IRQL_requires_same_ _In_opt_ PVOID Argument1
Definition: cmtypes.h:694
Type
Definition: Type.h:6
STORPORT_API VOID NTAPI StorPortMoveMemory(_Out_writes_bytes_(Length) PVOID Destination, _In_reads_bytes_(Length) PVOID Source, _In_ ULONG Length)
Definition: storport.c:1076
NTSTATUS NTAPI IoAllocateDriverObjectExtension(IN PDRIVER_OBJECT DriverObject, IN PVOID ClientIdentificationAddress, IN ULONG DriverObjectExtensionSize, OUT PVOID *DriverObjectExtension)
Definition: driver.c:1755
STORPORT_API STOR_PHYSICAL_ADDRESS NTAPI StorPortGetPhysicalAddress(_In_ PVOID HwDeviceExtension, _In_opt_ PSCSI_REQUEST_BLOCK Srb, _In_ PVOID VirtualAddress, _Out_ ULONG *Length)
Definition: storport.c:788
enum _STORPORT_FUNCTION_CODE STORPORT_FUNCTION_CODE
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
static NTSTATUS NTAPI PortDispatchPnp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:397
STORPORT_API VOID NTAPI StorPortStallExecution(_In_ ULONG Delay)
Definition: storport.c:1402
enum _SCSI_NOTIFICATION_TYPE SCSI_NOTIFICATION_TYPE
PDEVICE_OBJECT Device
Definition: precomp.h:88
_In_opt_ PUNICODE_STRING _In_ PDRIVER_OBJECT _In_ PDEVICE_OBJECT _In_ INTERFACE_TYPE BusType
Definition: halfuncs.h:156
_In_ ULONG _In_ BOOLEAN _In_ ULONG _In_ UCHAR PathId
Definition: classpnp.h:1117
static VOID PortDeleteDriverInitData(PDRIVER_OBJECT_EXTENSION DriverExtension)
Definition: storport.c:52
_In_ PIRP Irp
Definition: csq.h:116
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
NTSTATUS NTAPI PortPdoPnp(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
Definition: pdo.c:35
FORCEINLINE VOID InsertHeadList(_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
Definition: rtlfuncs.h:201
_In_ ULONG _In_ BOOLEAN _In_ ULONG _In_ UCHAR _In_ UCHAR TargetId
Definition: classpnp.h:1117
unsigned char * PUCHAR
Definition: retypes.h:3
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
LONG NTSTATUS
Definition: precomp.h:26
_Must_inspect_result_ _In_ PVOID _In_ struct _HW_INITIALIZATION_DATA _In_ PVOID HwContext
Definition: srb.h:664
#define FILE_OPENED
Definition: nt_native.h:769
static NTSTATUS NTAPI PortAddDevice(_In_ PDRIVER_OBJECT DriverObject, _In_ PDEVICE_OBJECT PhysicalDeviceObject)
Definition: storport.c:169
STORPORT_API BOOLEAN NTAPI StorPortPause(_In_ PVOID HwDeviceExtension, _In_ ULONG TimeOut)
Definition: storport.c:1200
static NTSTATUS PortAddDriverInitData(PDRIVER_OBJECT_EXTENSION DriverExtension, PHW_INITIALIZATION_DATA HwInitializationData)
Definition: storport.c:25
static NTSTATUS NTAPI PortDispatchScsi(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:342
PHW_INITIALIZATION_DATA PortGetDriverInitData(PDRIVER_OBJECT_EXTENSION DriverExtension, INTERFACE_TYPE InterfaceType)
Definition: storport.c:78
STOR_SYNCHRONIZED_ACCESS * PSTOR_SYNCHRONIZED_ACCESS
Definition: storport.h:2188
#define TAG_INIT_DATA
Definition: precomp.h:27
EXTENSION_TYPE ExtensionType
Definition: precomp.h:86
enum _STOR_SPINLOCK STOR_SPINLOCK
PVOID NTAPI MmMapIoSpace(IN PHYSICAL_ADDRESS PhysicalAddress, IN SIZE_T NumberOfBytes, IN MEMORY_CACHING_TYPE CacheType)
Definition: iosup.c:47
WCHAR DeviceName[]
Definition: adapter.cpp:21
VOID FASTCALL KeAcquireInStackQueuedSpinLock(IN PKSPIN_LOCK SpinLock, IN PKLOCK_QUEUE_HANDLE LockHandle)
Definition: spinlock.c:130
STORPORT_API PSCSI_REQUEST_BLOCK NTAPI StorPortGetSrb(_In_ PVOID DeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun, _In_ LONG QueueTag)
Definition: storport.c:859
_In_ ULONG _In_ PHYSICAL_ADDRESS _Inout_ PULONG _Out_ PPHYSICAL_ADDRESS TranslatedAddress
Definition: iofuncs.h:2268
NTSTATUS AllocateAddressMapping(PMAPPED_ADDRESS *MappedAddressList, STOR_PHYSICAL_ADDRESS IoAddress, PVOID MappedAddress, ULONG NumberOfBytes, ULONG BusNumber)
Definition: misc.c:340
STORPORT_API BOOLEAN NTAPI StorPortReady(_In_ PVOID HwDeviceExtension)
Definition: storport.c:1254
UNICODE_STRING Global
Definition: symlink.c:37
EXTENSION_TYPE ExtensionType
Definition: precomp.h:60
STORPORT_API VOID NTAPI StorPortFreeRegistryBuffer(_In_ PVOID HwDeviceExtension, _In_ PUCHAR Buffer)
Definition: storport.c:639
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
#define _In_opt_
Definition: no_sal2.h:213
#define DO_DIRECT_IO
Definition: env_spec_w32.h:396
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
_In_ PKSERVICE_ROUTINE _In_opt_ PVOID _In_opt_ PKSPIN_LOCK SpinLock
Definition: iofuncs.h:798
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define IRP_MJ_SCSI
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
STORPORT_API VOID NTAPI StorPortSynchronizeAccess(_In_ PVOID HwDeviceExtension, _In_ PSTOR_SYNCHRONIZED_ACCESS SynchronizedAccessRoutine, _In_opt_ PVOID Context)
Definition: storport.c:1415
STORPORT_API BOOLEAN NTAPI StorPortSetDeviceQueueDepth(_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun, _In_ ULONG Depth)
Definition: storport.c:1383
_In_ PUNICODE_STRING ValueName
Definition: cmfuncs.h:264
LIST_ENTRY AdapterListEntry
Definition: precomp.h:93
STORPORT_API STOR_PHYSICAL_ADDRESS NTAPI StorPortConvertUlongToPhysicalAddress(_In_ ULONG_PTR UlongAddress)
Definition: storport.c:534
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define FILE_DEVICE_CONTROLLER
Definition: winioctl.h:109
#define va_end(ap)
Definition: acmsvcex.h:90
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
long LONG
Definition: pedump.c:60
_In_ ULONG BufferLength
Definition: usbdlib.h:225
PDRIVER_EXTENSION DriverExtension
Definition: iotypes.h:2173
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:222
union Alignment_ Alignment
VOID NTAPI KeReleaseInterruptSpinLock(IN PKINTERRUPT Interrupt, IN KIRQL OldIrql)
Definition: spinlock.c:165
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:251
ULONG PortNumber
Definition: storport.c:18
PVOID DeviceExtension
Definition: env_spec_w32.h:418
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
PDRIVER_OBJECT_EXTENSION DriverExtension
Definition: precomp.h:91
static WCHAR Address[46]
Definition: ping.c:68
#define _Out_writes_bytes_(size)
Definition: no_sal2.h:370
_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:426
#define _Out_
Definition: no_sal2.h:323
static PDRIVER_OBJECT DriverObject
Definition: template.c:42
#define IoCompleteRequest
Definition: irp.c:1240
char * va_list
Definition: acmsvcex.h:78
void DPRINT(...)
Definition: polytest.cpp:61
Definition: bufpool.h:45
void * PVOID
Definition: retypes.h:9
static NTSTATUS NTAPI PortDispatchSystemControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:378
struct _STOR_LOCK_HANDLE * PSTOR_LOCK_HANDLE
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
_In_ PVOID Argument2
Definition: classpnp.h:680
#define STORPORT_API
Definition: storport.h:33
KSPIN_LOCK AdapterListLock
Definition: precomp.h:63
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: storport.c:1053
ULONG UncachedExtensionSize
Definition: precomp.h:104
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
IN PVOID IN PVOID IN USHORT IN USHORT IN PINTERFACE Interface
Definition: pci.h:359
VOID FASTCALL KeReleaseInStackQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle)
Definition: spinlock.c:166
STORPORT_API PVOID NTAPI StorPortGetLogicalUnit(_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun)
Definition: storport.c:770
STORPORT_API ULONG StorPortExtendedFunction(_In_ STORPORT_FUNCTION_CODE FunctionCode, _In_ PVOID HwDeviceExtension,...)
Definition: storport.c:606
_In_ LARGE_INTEGER _In_opt_ PKDPC Dpc
Definition: kefuncs.h:524
STORPORT_API VOID StorPortDebugPrint(_In_ ULONG DebugPrintLevel, _In_ PCHAR DebugMessage,...)
Definition: storport.c:551
__wchar_t WCHAR
Definition: xmlstorage.h:180
NTSTATUS NTAPI IoAttachDeviceToDeviceStackSafe(IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice, IN OUT PDEVICE_OBJECT *AttachedToDeviceObject)
Definition: device.c:980
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSTATUS NTAPI PortPdoScsi(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
Definition: pdo.c:20
#define swprintf(buf, format,...)
Definition: sprintf.c:56
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:2875
NTSTATUS NTAPI PortFdoPnp(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
Definition: fdo.c:601
STORPORT_API BOOLEAN NTAPI StorPortResumeDevice(_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun)
Definition: storport.c:1324
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
KIRQL NTAPI KeAcquireInterruptSpinLock(IN PKINTERRUPT Interrupt)
Definition: spinlock.c:148
struct _MINIPORT * Miniport
Definition: precomp.h:72
PHW_PASSIVE_INITIALIZE_ROUTINE HwPassiveInitRoutine
Definition: precomp.h:105
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
_In_opt_ PUNICODE_STRING _In_ PDRIVER_OBJECT _In_ PDEVICE_OBJECT _In_ INTERFACE_TYPE _In_ ULONG _In_ ULONG SlotNumber
Definition: halfuncs.h:156
static VOID NTAPI PortUnload(_In_ PDRIVER_OBJECT DriverObject)
Definition: storport.c:265
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS PhysicalAddress
Definition: iotypes.h:1060
unsigned char UCHAR
Definition: xmlstorage.h:181
static NTSTATUS NTAPI PortDispatchPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:431
PDEVICE_OBJECT PhysicalDevice
Definition: precomp.h:90
char * PBOOLEAN
Definition: retypes.h:11
#define IRP_MJ_POWER
STORPORT_API BOOLEAN NTAPI StorPortResume(_In_ PVOID HwDeviceExtension)
Definition: storport.c:1309
#define IRP_MJ_CLOSE
Definition: rdpdr.c:45
STORPORT_API PSTOR_SCATTER_GATHER_LIST NTAPI StorPortGetScatterGatherList(_In_ PVOID DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb)
Definition: storport.c:843
static const WCHAR L[]
Definition: oid.c:1250
static NTSTATUS NTAPI PortDispatchClose(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:304
Definition: ketypes.h:687
KDEFERRED_ROUTINE * PKDEFERRED_ROUTINE
Definition: ketypes.h:678
PDRIVER_UNLOAD DriverUnload
Definition: iotypes.h:2179
PVOID NTAPI IoGetDriverObjectExtension(IN PDRIVER_OBJECT DriverObject, IN PVOID ClientIdentificationAddress)
Definition: driver.c:1833
Definition: typedefs.h:117
_In_ ULONG _In_ BOOLEAN _Must_inspect_result_ PVOID * VirtualAddress
Definition: ndis.h:3773
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: storport.c:654
PPCI_DRIVER_EXTENSION DriverExtension
Definition: pci.c:41
STORPORT_API BOOLEAN NTAPI StorPortRegistryWrite(_In_ PVOID HwDeviceExtension, _In_ PUCHAR ValueName, _In_ ULONG Global, _In_ ULONG Type, _In_ PUCHAR Buffer, _In_ ULONG BufferLength)
Definition: storport.c:1289
#define _In_reads_bytes_(size)
Definition: no_sal2.h:229
#define IRP_MJ_SYSTEM_CONTROL
VOID(* PHW_DPC_ROUTINE)(_In_ PSTOR_DPC Dpc, _In_ PVOID HwDeviceExtension, _In_ PVOID SystemArgument1, _In_ PVOID SystemArgument2)
Definition: storport.h:2176
Status
Definition: gdiplustypes.h:24
STORPORT_API BOOLEAN NTAPI StorPortDeviceReady(_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun)
Definition: storport.c:589
LIST_ENTRY Entry
Definition: precomp.h:54
#define _In_
Definition: no_sal2.h:204
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1250
PDRIVER_ADD_DEVICE AddDevice
Definition: iotypes.h:2111
#define va_arg(ap, T)
Definition: acmsvcex.h:89
STORPORT_API BOOLEAN NTAPI StorPortBusy(_In_ PVOID HwDeviceExtension, _In_ ULONG RequestsToComplete)
Definition: storport.c:485
static NTSTATUS NTAPI PortDispatchCreate(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:285
static VOID PortAcquireSpinLock(PFDO_DEVICE_EXTENSION DeviceExtension, STOR_SPINLOCK SpinLock, PVOID LockContext, PSTOR_LOCK_HANDLE LockHandle)
Definition: storport.c:105
STORPORT_API BOOLEAN NTAPI StorPortRegistryRead(_In_ PVOID HwDeviceExtension, _In_ PUCHAR ValueName, _In_ ULONG Global, _In_ ULONG Type, _In_ PUCHAR Buffer, _In_ PULONG BufferLength)
Definition: storport.c:1269
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
STORPORT_API BOOLEAN NTAPI StorPortPauseDevice(_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun, _In_ ULONG TimeOut)
Definition: storport.c:1216
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
STORPORT_API VOID NTAPI StorPortFreeDeviceBase(_In_ PVOID HwDeviceExtension, _In_ PVOID MappedAddress)
Definition: storport.c:624
unsigned int * PULONG
Definition: retypes.h:1
#define va_start(ap, A)
Definition: acmsvcex.h:91
NTSYSAPI NTSTATUS WINAPI vDbgPrintExWithPrefix(LPCSTR, ULONG, ULONG, LPCSTR, __ms_va_list)
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: storport.c:1342
#define _When_(expr, annos)
Definition: no_sal2.h:639
LIST_ENTRY AdapterListHead
Definition: precomp.h:64
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
#define DPRINT1
Definition: precomp.h:8
DEVICE_STATE PnpState
Definition: i8042prt.h:132
STORPORT_API ULONG NTAPI StorPortInitialize(_In_ PVOID Argument1, _In_ PVOID Argument2, _In_ struct _HW_INITIALIZATION_DATA *HwInitializationData, _In_opt_ PVOID HwContext)
Definition: storport.c:946
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: storport.c:698
void int int ULONGLONG int va_list * ap
Definition: winesup.h:32
PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION+1]
Definition: iotypes.h:2180
struct _STOR_DPC * PSTOR_DPC
INTERFACE_TYPE AdapterInterfaceType
Definition: srb.h:557
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _Inout_ PLARGE_INTEGER NumberOfBytes
Definition: iotypes.h:997
NTSTATUS NTAPI DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)
Definition: storport.c:454
STORPORT_API VOID NTAPI StorPortCompleteRequest(_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun, _In_ UCHAR SrbStatus)
Definition: storport.c:501
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:565
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:1031
BOOLEAN(* PHW_PASSIVE_INITIALIZE_ROUTINE)(_In_ PVOID DeviceExtension)
Definition: storport.h:2171
static NTSTATUS NTAPI PortDispatchDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: storport.c:323
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define UNIMPLEMENTED
Definition: debug.h:114
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
STORPORT_API PVOID NTAPI StorPortGetVirtualAddress(_In_ PVOID HwDeviceExtension, _In_ STOR_PHYSICAL_ADDRESS PhysicalAddress)
Definition: storport.c:929
#define ULONG_PTR
Definition: config.h:101
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: storport.c:1431
PHYSICAL_ADDRESS NTAPI MmGetPhysicalAddress(IN PVOID Address)
Definition: stubs.c:682
_In_ PUNICODE_STRING RegistryPath
Definition: wmip.h:27
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3149
#define FILE_DEVICE_SECURE_OPEN
Definition: cdrw_usr.h:46
*LockHandle LockHandle _Out_ PKLOCK_QUEUE_HANDLE LockHandle
Definition: kefuncs.h:742
PDEVICE_OBJECT LowerDevice
Definition: i8042prt.h:130
STORPORT_API VOID NTAPI StorPortQuerySystemTime(_Out_ PLARGE_INTEGER CurrentTime)
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
IN PSCSI_REQUEST_BLOCK Srb
Definition: class2.h:49
VOID NTAPI KeInitializeDpc(IN PKDPC Dpc, IN PKDEFERRED_ROUTINE DeferredRoutine, IN PVOID DeferredContext)
Definition: dpc.c:711
return STATUS_SUCCESS
Definition: btrfs.c:2725
STORPORT_API VOID StorPortNotification(_In_ SCSI_NOTIFICATION_TYPE NotificationType, _In_ PVOID HwDeviceExtension,...)
Definition: storport.c:1090
STORPORT_API BOOLEAN NTAPI StorPortDeviceBusy(_In_ PVOID HwDeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun, _In_ ULONG RequestsToComplete)
Definition: storport.c:570
VOID NTAPI KeStallExecutionProcessor(IN ULONG MicroSeconds)
Definition: ntoskrnl.c:99
base of all file and directory entries
Definition: entries.h:82
struct _DRIVER_OBJECT * PDRIVER_OBJECT
_Must_inspect_result_ _In_ PVOID _In_ struct _HW_INITIALIZATION_DATA * HwInitializationData
Definition: srb.h:664
STORPORT_API PVOID NTAPI StorPortGetUncachedExtension(_In_ PVOID HwDeviceExtension, _In_ PPORT_CONFIGURATION_INFORMATION ConfigInfo, _In_ ULONG NumberOfBytes)
Definition: storport.c:877
STORPORT_API PUCHAR NTAPI StorPortAllocateRegistryBuffer(_In_ PVOID HwDeviceExtension, _In_ PULONG Length)
Definition: storport.c:469
LONGLONG QuadPart
Definition: typedefs.h:112
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
HW_INITIALIZATION_DATA HwInitData
Definition: precomp.h:55
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:569