drivers/storage/port/storport/storport.c

   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
  18 ULONG PortNumber = 0;
  19
  20
  21 /* FUNCTIONS ******************************************************************/
  22
  23 static
  24 NTSTATUS
  25 PortAddDriverInitData(
  26     PDRIVER_OBJECT_EXTENSION DriverExtension,
  27     PHW_INITIALIZATION_DATA HwInitializationData)
  28 {
  29     PDRIVER_INIT_DATA InitData;
  30
  31     DPRINT1("PortAddDriverInitData()\n");
  32
  33     InitData = ExAllocatePoolWithTag(NonPagedPool,
  34                                      sizeof(DRIVER_INIT_DATA),
  35                                      TAG_INIT_DATA);
  36     if (InitData == NULL)
  37         return STATUS_NO_MEMORY;
  38
  39     RtlCopyMemory(&InitData->HwInitData,
  40                   HwInitializationData,
  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
  52 PortDeleteDriverInitData(
  53     PDRIVER_OBJECT_EXTENSION DriverExtension)
  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,
  64                                      DRIVER_INIT_DATA,
  65                                      Entry);
  66
  67         RemoveEntryList(&InitData->Entry);
  68
  69         ExFreePoolWithTag(InitData,
  70                           TAG_INIT_DATA);
  71
  72         ListEntry = DriverExtension->InitDataListHead.Flink;
  73     }
  74 }
  75
  76
  77 PHW_INITIALIZATION_DATA
  78 PortGetDriverInitData(
  79     PDRIVER_OBJECT_EXTENSION DriverExtension,
  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,
  91                                      DRIVER_INIT_DATA,
  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 NTSTATUS
 105 NTAPI
 106 PortAddDevice(
 107     _In_ PDRIVER_OBJECT DriverObject,
 108     _In_ PDEVICE_OBJECT PhysicalDeviceObject)
 109 {
 110     PDRIVER_OBJECT_EXTENSION DriverObjectExtension;
 111     PFDO_DEVICE_EXTENSION DeviceExtension = NULL;
 112     WCHAR NameBuffer[80];
 113     UNICODE_STRING DeviceName;
 114     PDEVICE_OBJECT Fdo = NULL;
 115     KLOCK_QUEUE_HANDLE LockHandle;
 116     NTSTATUS Status;
 117
 118     DPRINT1("PortAddDevice(%p %p)\n",
 119             DriverObject, PhysicalDeviceObject);
 120
 121     ASSERT(DriverObject);
 122     ASSERT(PhysicalDeviceObject);
 123
 124     swprintf(NameBuffer,
 125              L"\\Device\\RaidPort%lu",
 126              PortNumber);
 127     RtlInitUnicodeString(&DeviceName, NameBuffer);
 128     PortNumber++;
 129
 130     DPRINT1("Creating device: %wZ\n", &DeviceName);
 131
 132     /* Create the port device */
 133     Status = IoCreateDevice(DriverObject,
 134                             sizeof(FDO_DEVICE_EXTENSION),
 135                             &DeviceName,
 136                             FILE_DEVICE_CONTROLLER,
 137                             FILE_DEVICE_SECURE_OPEN,
 138                             FALSE,
 139                             &Fdo);
 140     if (!NT_SUCCESS(Status))
 141     {
 142         DPRINT1("IoCreateDevice() failed (Status 0x%08lx)\n", Status);
 143         return Status;
 144     }
 145
 146     DPRINT1("Created device: %wZ (%p)\n", &DeviceName, Fdo);
 147
 148     /* Initialize the device */
 149     Fdo->Flags |= DO_DIRECT_IO;
 150     Fdo->Flags |= DO_POWER_PAGABLE;
 151
 152     /* Initialize the device extension */
 153     DeviceExtension = (PFDO_DEVICE_EXTENSION)Fdo->DeviceExtension;
 154     RtlZeroMemory(DeviceExtension, sizeof(FDO_DEVICE_EXTENSION));
 155
 156     DeviceExtension->ExtensionType = FdoExtension;
 157
 158     DeviceExtension->Device = Fdo;
 159     DeviceExtension->PhysicalDevice = PhysicalDeviceObject;
 160
 161     DeviceExtension->PnpState = dsStopped;
 162
 163     /* Attach the FDO to the device stack */
 164     Status = IoAttachDeviceToDeviceStackSafe(Fdo,
 165                                              PhysicalDeviceObject,
 166                                              &DeviceExtension->LowerDevice);
 167     if (!NT_SUCCESS(Status))
 168     {
 169         DPRINT1("IoAttachDeviceToDeviceStackSafe() failed (Status 0x%08lx)\n", Status);
 170         IoDeleteDevice(Fdo);
 171         return Status;
 172     }
 173
 174     /* Insert the FDO to the drivers FDO list */
 175     DriverObjectExtension = IoGetDriverObjectExtension(DriverObject,
 176                                                        (PVOID)DriverEntry);
 177     ASSERT(DriverObjectExtension->ExtensionType == DriverExtension);
 178
 179     DeviceExtension->DriverExtension = DriverObjectExtension;
 180
 181     KeAcquireInStackQueuedSpinLock(&DriverObjectExtension->AdapterListLock,
 182                                    &LockHandle);
 183
 184     InsertHeadList(&DriverObjectExtension->AdapterListHead,
 185                    &DeviceExtension->AdapterListEntry);
 186     DriverObjectExtension->AdapterCount++;
 187
 188     KeReleaseInStackQueuedSpinLock(&LockHandle);
 189
 190     /* The device has been initialized */
 191     Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
 192
 193     DPRINT1("PortAddDevice() done (Status 0x%08lx)\n", Status);
 194
 195     return Status;
 196 }
 197
 198
 199 static
 200 VOID
 201 NTAPI
 202 PortUnload(
 203     _In_ PDRIVER_OBJECT DriverObject)
 204 {
 205     PDRIVER_OBJECT_EXTENSION DriverExtension;
 206
 207     DPRINT1("PortUnload(%p)\n",
 208             DriverObject);
 209
 210     DriverExtension = IoGetDriverObjectExtension(DriverObject,
 211                                                  (PVOID)DriverEntry);
 212     if (DriverExtension != NULL)
 213     {
 214         PortDeleteDriverInitData(DriverExtension);
 215     }
 216 }
 217
 218
 219 static
 220 NTSTATUS
 221 NTAPI
 222 PortDispatchCreate(
 223     IN PDEVICE_OBJECT DeviceObject,
 224     IN PIRP Irp)
 225 {
 226     DPRINT1("PortDispatchCreate(%p %p)\n",
 227             DeviceObject, Irp);
 228
 229     Irp->IoStatus.Status = STATUS_SUCCESS;
 230     Irp->IoStatus.Information = FILE_OPENED;
 231
 232     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 233
 234     return STATUS_SUCCESS;
 235 }
 236
 237
 238 static
 239 NTSTATUS
 240 NTAPI
 241 PortDispatchClose(
 242     IN PDEVICE_OBJECT DeviceObject,
 243     IN PIRP Irp)
 244 {
 245     DPRINT1("PortDispatchClose(%p %p)\n",
 246             DeviceObject, Irp);
 247
 248     Irp->IoStatus.Status = STATUS_SUCCESS;
 249     Irp->IoStatus.Information = 0;
 250
 251     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 252
 253     return STATUS_SUCCESS;
 254 }
 255
 256
 257 static
 258 NTSTATUS
 259 NTAPI
 260 PortDispatchDeviceControl(
 261     IN PDEVICE_OBJECT DeviceObject,
 262     IN PIRP Irp)
 263 {
 264     DPRINT1("PortDispatchDeviceControl(%p %p)\n",
 265             DeviceObject, Irp);
 266
 267     Irp->IoStatus.Status = STATUS_SUCCESS;
 268     Irp->IoStatus.Information = 0;
 269
 270     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 271
 272     return STATUS_SUCCESS;
 273 }
 274
 275
 276 static
 277 NTSTATUS
 278 NTAPI
 279 PortDispatchScsi(
 280     IN PDEVICE_OBJECT DeviceObject,
 281     IN PIRP Irp)
 282 {
 283     DPRINT1("PortDispatchScsi(%p %p)\n",
 284             DeviceObject, Irp);
 285
 286     Irp->IoStatus.Status = STATUS_SUCCESS;
 287     Irp->IoStatus.Information = 0;
 288
 289     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 290
 291     return STATUS_SUCCESS;
 292 }
 293
 294
 295 static
 296 NTSTATUS
 297 NTAPI
 298 PortDispatchSystemControl(
 299     IN PDEVICE_OBJECT DeviceObject,
 300     IN PIRP Irp)
 301 {
 302     DPRINT1("PortDispatchSystemControl(%p %p)\n",
 303             DeviceObject, Irp);
 304
 305     Irp->IoStatus.Status = STATUS_SUCCESS;
 306     Irp->IoStatus.Information = 0;
 307
 308     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 309
 310     return STATUS_SUCCESS;
 311 }
 312
 313
 314 static
 315 NTSTATUS
 316 NTAPI
 317 PortDispatchPnp(
 318     IN PDEVICE_OBJECT DeviceObject,
 319     IN PIRP Irp)
 320 {
 321     PFDO_DEVICE_EXTENSION DeviceExtension;
 322
 323     DPRINT1("PortDispatchPnp(%p %p)\n",
 324             DeviceObject, Irp);
 325
 326     DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 327     DPRINT1("ExtensionType: %u\n", DeviceExtension->ExtensionType);
 328
 329     switch (DeviceExtension->ExtensionType)
 330     {
 331         case FdoExtension:
 332             return PortFdoPnp(DeviceObject,
 333                               Irp);
 334
 335         case PdoExtension:
 336             return PortPdoPnp(DeviceObject,
 337                               Irp);
 338
 339         default:
 340             Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
 341             Irp->IoStatus.Information = 0;
 342             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 343             return STATUS_UNSUCCESSFUL;
 344     }
 345 }
 346
 347
 348 static
 349 NTSTATUS
 350 NTAPI
 351 PortDispatchPower(
 352     IN PDEVICE_OBJECT DeviceObject,
 353     IN PIRP Irp)
 354 {
 355     DPRINT1("PortDispatchPower(%p %p)\n",
 356             DeviceObject, Irp);
 357
 358     Irp->IoStatus.Status = STATUS_SUCCESS;
 359     Irp->IoStatus.Information = 0;
 360
 361     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 362
 363     return STATUS_SUCCESS;
 364 }
 365
 366
 367 /* PUBLIC FUNCTIONS ***********************************************************/
 368
 369 /*
 370  * @implemented
 371  */
 372 NTSTATUS
 373 NTAPI
 374 DriverEntry(
 375     _In_ PDRIVER_OBJECT DriverObject,
 376     _In_ PUNICODE_STRING RegistryPath)
 377 {
 378     DPRINT1("DriverEntry(%p %p)\n", DriverObject, RegistryPath);
 379     return STATUS_SUCCESS;
 380 }
 381
 382
 383 /*
 384  * @unimplemented
 385  */
 386 STORPORT_API
 387 PUCHAR
 388 NTAPI
 389 StorPortAllocateRegistryBuffer(
 390     _In_ PVOID HwDeviceExtension,
 391     _In_ PULONG Length)
 392 {
 393     DPRINT1("StorPortAllocateRegistryBuffer()\n");
 394     UNIMPLEMENTED;
 395     return NULL;
 396 }
 397
 398
 399 /*
 400  * @unimplemented
 401  */
 402 STORPORT_API
 403 BOOLEAN
 404 NTAPI
 405 StorPortBusy(
 406     _In_ PVOID HwDeviceExtension,
 407     _In_ ULONG RequestsToComplete)
 408 {
 409     DPRINT1("StorPortBuzy()\n");
 410     UNIMPLEMENTED;
 411     return FALSE;
 412 }
 413
 414
 415 /*
 416  * @unimplemented
 417  */
 418 STORPORT_API
 419 VOID
 420 NTAPI
 421 StorPortCompleteRequest(
 422     _In_ PVOID HwDeviceExtension,
 423     _In_ UCHAR PathId,
 424     _In_ UCHAR TargetId,
 425     _In_ UCHAR Lun,
 426     _In_ UCHAR SrbStatus)
 427 {
 428     DPRINT1("StorPortCompleteRequest()\n");
 429     UNIMPLEMENTED;
 430 }
 431
 432
 433 /*
 434  * @implemented
 435  */
 436 STORPORT_API
 437 ULONG
 438 NTAPI
 439 StorPortConvertPhysicalAddressToUlong(
 440     _In_ STOR_PHYSICAL_ADDRESS Address)
 441 {
 442     DPRINT1("StorPortConvertPhysicalAddressToUlong()\n");
 443
 444     return Address.u.LowPart;
 445 }
 446
 447
 448 /*
 449  * @implemented
 450  */
 451 STORPORT_API
 452 STOR_PHYSICAL_ADDRESS
 453 NTAPI
 454 StorPortConvertUlongToPhysicalAddress(
 455     _In_ ULONG_PTR UlongAddress)
 456 {
 457     STOR_PHYSICAL_ADDRESS Address;
 458
 459     DPRINT1("StorPortConvertUlongToPhysicalAddress()\n");
 460
 461     Address.QuadPart = UlongAddress;
 462     return Address;
 463 }
 464
 465
 466 /*
 467  * @implemented
 468  */
 469 STORPORT_API
 470 VOID
 471 StorPortDebugPrint(
 472     _In_ ULONG DebugPrintLevel,
 473     _In_ PCHAR DebugMessage,
 474     ...)
 475 {
 476     va_list ap;
 477
 478     va_start(ap, DebugMessage);
 479     vDbgPrintExWithPrefix("STORMINI: ", 0x58, DebugPrintLevel, DebugMessage, ap);
 480     va_end(ap);
 481 }
 482
 483
 484 /*
 485  * @unimplemented
 486  */
 487 STORPORT_API
 488 BOOLEAN
 489 NTAPI
 490 StorPortDeviceBusy(
 491     _In_ PVOID HwDeviceExtension,
 492     _In_ UCHAR PathId,
 493     _In_ UCHAR TargetId,
 494     _In_ UCHAR Lun,
 495     _In_ ULONG RequestsToComplete)
 496 {
 497     DPRINT1("StorPortDeviceBusy()\n");
 498     UNIMPLEMENTED;
 499     return FALSE;
 500 }
 501
 502
 503 /*
 504  * @unimplemented
 505  */
 506 STORPORT_API
 507 BOOLEAN
 508 NTAPI
 509 StorPortDeviceReady(
 510     _In_ PVOID HwDeviceExtension,
 511     _In_ UCHAR PathId,
 512     _In_ UCHAR TargetId,
 513     _In_ UCHAR Lun)
 514 {
 515     DPRINT1("StorPortDeviceReady()\n");
 516     UNIMPLEMENTED;
 517     return FALSE;
 518 }
 519
 520
 521 /*
 522  * @implemented
 523  */
 524 STORPORT_API
 525 VOID
 526 NTAPI
 527 StorPortFreeDeviceBase(
 528     _In_ PVOID HwDeviceExtension,
 529     _In_ PVOID MappedAddress)
 530 {
 531     DPRINT1("StorPortFreeDeviceBase(%p %p)\n",
 532             HwDeviceExtension, MappedAddress);
 533 }
 534
 535
 536 /*
 537  * @unimplemented
 538  */
 539 STORPORT_API
 540 VOID
 541 NTAPI
 542 StorPortFreeRegistryBuffer(
 543     _In_ PVOID HwDeviceExtension,
 544     _In_ PUCHAR Buffer)
 545 {
 546     DPRINT1("StorPortFreeRegistryBuffer()\n");
 547     UNIMPLEMENTED;
 548 }
 549
 550
 551 /*
 552  * @implemented
 553  */
 554 STORPORT_API
 555 ULONG
 556 NTAPI
 557 StorPortGetBusData(
 558     _In_ PVOID DeviceExtension,
 559     _In_ ULONG BusDataType,
 560     _In_ ULONG SystemIoBusNumber,
 561     _In_ ULONG SlotNumber,
 562     _Out_ _When_(Length != 0, _Out_writes_bytes_(Length)) PVOID Buffer,
 563     _In_ ULONG Length)
 564 {
 565     PMINIPORT_DEVICE_EXTENSION MiniportExtension;
 566     PBUS_INTERFACE_STANDARD Interface;
 567     ULONG ReturnLength;
 568
 569     DPRINT1("StorPortGetBusData(%p %lu %lu %lu %p %lu)\n",
 570             DeviceExtension, BusDataType, SystemIoBusNumber, SlotNumber, Buffer, Length);
 571
 572     /* Get the miniport extension */
 573     MiniportExtension = CONTAINING_RECORD(DeviceExtension,
 574                                           MINIPORT_DEVICE_EXTENSION,
 575                                           HwDeviceExtension);
 576     DPRINT1("DeviceExtension %p  MiniportExtension %p\n",
 577             DeviceExtension, MiniportExtension);
 578
 579     Interface = &MiniportExtension->Miniport->DeviceExtension->BusInterface;
 580
 581     if (BusDataType == 4)
 582         BusDataType = 0;
 583
 584     ReturnLength = Interface->GetBusData(Interface->Context,
 585                                          BusDataType,
 586                                          Buffer,
 587                                          0,
 588                                          Length);
 589     DPRINT1("ReturnLength: %lu\n", ReturnLength);
 590
 591     return ReturnLength;
 592 }
 593
 594
 595 /*
 596  * @implemented
 597  */
 598 STORPORT_API
 599 PVOID
 600 NTAPI
 601 StorPortGetDeviceBase(
 602     _In_ PVOID HwDeviceExtension,
 603     _In_ INTERFACE_TYPE BusType,
 604     _In_ ULONG SystemIoBusNumber,
 605     _In_ STOR_PHYSICAL_ADDRESS IoAddress,
 606     _In_ ULONG NumberOfBytes,
 607     _In_ BOOLEAN InIoSpace)
 608 {
 609     PMINIPORT_DEVICE_EXTENSION MiniportExtension;
 610     PHYSICAL_ADDRESS TranslatedAddress;
 611     PVOID MappedAddress;
 612     NTSTATUS Status;
 613
 614     DPRINT1("StorPortGetDeviceBase(%p %lu %lu 0x%I64x %lu %u)\n",
 615             HwDeviceExtension, BusType, SystemIoBusNumber, IoAddress.QuadPart, NumberOfBytes, InIoSpace);
 616
 617     /* Get the miniport extension */
 618     MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
 619                                           MINIPORT_DEVICE_EXTENSION,
 620                                           HwDeviceExtension);
 621     DPRINT1("HwDeviceExtension %p  MiniportExtension %p\n",
 622             HwDeviceExtension, MiniportExtension);
 623
 624     if (!TranslateResourceListAddress(MiniportExtension->Miniport->DeviceExtension,
 625                                       BusType,
 626                                       SystemIoBusNumber,
 627                                       IoAddress,
 628                                       NumberOfBytes,
 629                                       InIoSpace,
 630                                       &TranslatedAddress))
 631     {
 632         DPRINT1("Checkpoint!\n");
 633         return NULL;
 634     }
 635
 636     DPRINT1("Translated Address: 0x%I64x\n", TranslatedAddress.QuadPart);
 637
 638     /* In I/O space */
 639     if (InIoSpace)
 640     {
 641         DPRINT1("Translated Address: %p\n", (PVOID)(ULONG_PTR)TranslatedAddress.QuadPart);
 642         return (PVOID)(ULONG_PTR)TranslatedAddress.QuadPart;
 643     }
 644
 645     /* In memory space */
 646     MappedAddress = MmMapIoSpace(TranslatedAddress,
 647                                  NumberOfBytes,
 648                                  FALSE);
 649     DPRINT1("Mapped Address: %p\n", MappedAddress);
 650
 651     Status = AllocateAddressMapping(&MiniportExtension->Miniport->DeviceExtension->MappedAddressList,
 652                                     IoAddress,
 653                                     MappedAddress,
 654                                     NumberOfBytes,
 655                                     SystemIoBusNumber);
 656     if (!NT_SUCCESS(Status))
 657     {
 658         DPRINT1("Checkpoint!\n");
 659         MappedAddress = NULL;
 660     }
 661
 662     DPRINT1("Mapped Address: %p\n", MappedAddress);
 663     return MappedAddress;
 664 }
 665
 666
 667 /*
 668  * @unimplemented
 669  */
 670 STORPORT_API
 671 PVOID
 672 NTAPI
 673 StorPortGetLogicalUnit(
 674     _In_ PVOID HwDeviceExtension,
 675     _In_ UCHAR PathId,
 676     _In_ UCHAR TargetId,
 677     _In_ UCHAR Lun)
 678 {
 679     DPRINT1("StorPortGetLogicalUnit()\n");
 680     UNIMPLEMENTED;
 681     return NULL;
 682 }
 683
 684
 685 /*
 686  * @unimplemented
 687  */
 688 STORPORT_API
 689 STOR_PHYSICAL_ADDRESS
 690 NTAPI
 691 StorPortGetPhysicalAddress(
 692     _In_ PVOID HwDeviceExtension,
 693     _In_opt_ PSCSI_REQUEST_BLOCK Srb,
 694     _In_ PVOID VirtualAddress,
 695     _Out_ ULONG *Length)
 696 {
 697     STOR_PHYSICAL_ADDRESS PhysicalAddress;
 698
 699     DPRINT1("StorPortGetPhysicalAddress(%p %p %p %p)\n",
 700             HwDeviceExtension, Srb, VirtualAddress, Length);
 701     UNIMPLEMENTED;
 702
 703     *Length = 0;
 704     PhysicalAddress.QuadPart = (LONGLONG)0;
 705
 706     return PhysicalAddress;
 707 }
 708
 709
 710 /*
 711  * @unimplemented
 712  */
 713 STORPORT_API
 714 PSTOR_SCATTER_GATHER_LIST
 715 NTAPI
 716 StorPortGetScatterGatherList(
 717     _In_ PVOID DeviceExtension,
 718     _In_ PSCSI_REQUEST_BLOCK Srb)
 719 {
 720     DPRINT1("StorPortGetScatterGatherList()\n");
 721     UNIMPLEMENTED;
 722     return NULL;
 723 }
 724
 725
 726 /*
 727  * @implemented
 728  */
 729 STORPORT_API
 730 PSCSI_REQUEST_BLOCK
 731 NTAPI
 732 StorPortGetSrb(
 733     _In_ PVOID DeviceExtension,
 734     _In_ UCHAR PathId,
 735     _In_ UCHAR TargetId,
 736     _In_ UCHAR Lun,
 737     _In_ LONG QueueTag)
 738 {
 739     DPRINT("StorPortGetSrb()\n");
 740     return NULL;
 741 }
 742
 743
 744 /*
 745  * @implemented
 746  */
 747 STORPORT_API
 748 PVOID
 749 NTAPI
 750 StorPortGetUncachedExtension(
 751     _In_ PVOID HwDeviceExtension,
 752     _In_ PPORT_CONFIGURATION_INFORMATION ConfigInfo,
 753     _In_ ULONG NumberOfBytes)
 754 {
 755     PMINIPORT_DEVICE_EXTENSION MiniportExtension;
 756     PFDO_DEVICE_EXTENSION DeviceExtension;
 757     PHYSICAL_ADDRESS LowestAddress, HighestAddress, Alignment;
 758
 759     DPRINT1("StorPortGetUncachedExtension(%p %p %lu)\n",
 760             HwDeviceExtension, ConfigInfo, NumberOfBytes);
 761
 762     /* Get the miniport extension */
 763     MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
 764                                           MINIPORT_DEVICE_EXTENSION,
 765                                           HwDeviceExtension);
 766     DPRINT1("HwDeviceExtension %p  MiniportExtension %p\n",
 767             HwDeviceExtension, MiniportExtension);
 768
 769     DeviceExtension = MiniportExtension->Miniport->DeviceExtension;
 770
 771     /* Return the uncached extension base address if we already have one */
 772     if (DeviceExtension->UncachedExtensionBase != NULL)
 773         return DeviceExtension->UncachedExtensionBase;
 774
 775     // FIXME: Set DMA stuff here?
 776
 777     /* Allocate the uncached extension */
 778     Alignment.QuadPart = 0;
 779     LowestAddress.QuadPart = 0;
 780     HighestAddress.QuadPart = 0x00000000FFFFFFFF;
 781     DeviceExtension->UncachedExtensionBase = MmAllocateContiguousMemorySpecifyCache(NumberOfBytes,
 782                                                                                     LowestAddress,
 783                                                                                     HighestAddress,
 784                                                                                     Alignment,
 785                                                                                     MmCached);
 786     if (DeviceExtension->UncachedExtensionBase == NULL)
 787         return NULL;
 788
 789     DeviceExtension->UncachedExtensionSize = NumberOfBytes;
 790
 791     return DeviceExtension->UncachedExtensionBase;
 792 }
 793
 794
 795 /*
 796  * @unimplemented
 797  */
 798 STORPORT_API
 799 PVOID
 800 NTAPI
 801 StorPortGetVirtualAddress(
 802     _In_ PVOID HwDeviceExtension,
 803     _In_ STOR_PHYSICAL_ADDRESS PhysicalAddress)
 804 {
 805     DPRINT1("StorPortGetVirtualAddress(%p %I64x)\n",
 806             HwDeviceExtension, PhysicalAddress.QuadPart);
 807     UNIMPLEMENTED;
 808     return NULL;
 809 }
 810
 811
 812 /*
 813  * @implemented
 814  */
 815 STORPORT_API
 816 ULONG
 817 NTAPI
 818 StorPortInitialize(
 819     _In_ PVOID Argument1,
 820     _In_ PVOID Argument2,
 821     _In_ struct _HW_INITIALIZATION_DATA *HwInitializationData,
 822     _In_opt_ PVOID HwContext)
 823 {
 824     PDRIVER_OBJECT DriverObject = (PDRIVER_OBJECT)Argument1;
 825     PUNICODE_STRING RegistryPath = (PUNICODE_STRING)Argument2;
 826     PDRIVER_OBJECT_EXTENSION DriverObjectExtension;
 827     NTSTATUS Status = STATUS_SUCCESS;
 828
 829     DPRINT1("StorPortInitialize(%p %p %p %p)\n",
 830             Argument1, Argument2, HwInitializationData, HwContext);
 831
 832     DPRINT1("HwInitializationDataSize: %lu\n", HwInitializationData->HwInitializationDataSize);
 833     DPRINT1("AdapterInterfaceType: %u\n", HwInitializationData->AdapterInterfaceType);
 834     DPRINT1("HwInitialize: %p\n", HwInitializationData->HwInitialize);
 835     DPRINT1("HwStartIo: %p\n", HwInitializationData->HwStartIo);
 836     DPRINT1("HwInterrupt: %p\n", HwInitializationData->HwInterrupt);
 837     DPRINT1("HwFindAdapter: %p\n", HwInitializationData->HwFindAdapter);
 838     DPRINT1("HwResetBus: %p\n", HwInitializationData->HwResetBus);
 839     DPRINT1("HwDmaStarted: %p\n", HwInitializationData->HwDmaStarted);
 840     DPRINT1("HwAdapterState: %p\n", HwInitializationData->HwAdapterState);
 841     DPRINT1("DeviceExtensionSize: %lu\n", HwInitializationData->DeviceExtensionSize);
 842     DPRINT1("SpecificLuExtensionSize: %lu\n", HwInitializationData->SpecificLuExtensionSize);
 843     DPRINT1("SrbExtensionSize: %lu\n", HwInitializationData->SrbExtensionSize);
 844     DPRINT1("NumberOfAccessRanges: %lu\n", HwInitializationData->NumberOfAccessRanges);
 845
 846     /* Check parameters */
 847     if ((DriverObject == NULL) ||
 848         (RegistryPath == NULL) ||
 849         (HwInitializationData == NULL))
 850     {
 851         DPRINT1("Invalid parameter!\n");
 852         return STATUS_INVALID_PARAMETER;
 853     }
 854
 855     /* Check initialization data */
 856     if ((HwInitializationData->HwInitializationDataSize < sizeof(HW_INITIALIZATION_DATA)) ||
 857         (HwInitializationData->HwInitialize == NULL) ||
 858         (HwInitializationData->HwStartIo == NULL) ||
 859         (HwInitializationData->HwFindAdapter == NULL) ||
 860         (HwInitializationData->HwResetBus == NULL))
 861     {
 862         DPRINT1("Revision mismatch!\n");
 863         return STATUS_REVISION_MISMATCH;
 864     }
 865
 866     DriverObjectExtension = IoGetDriverObjectExtension(DriverObject,
 867                                                        (PVOID)DriverEntry);
 868     if (DriverObjectExtension == NULL)
 869     {
 870         DPRINT1("No driver object extension!\n");
 871
 872         Status = IoAllocateDriverObjectExtension(DriverObject,
 873                                                  (PVOID)DriverEntry,
 874                                                  sizeof(DRIVER_OBJECT_EXTENSION),
 875                                                  (PVOID *)&DriverObjectExtension);
 876         if (!NT_SUCCESS(Status))
 877         {
 878             DPRINT1("IoAllocateDriverObjectExtension() failed (Status 0x%08lx)\n", Status);
 879             return Status;
 880         }
 881
 882         DPRINT1("Driver object extension created!\n");
 883
 884         /* Initialize the driver object extension */
 885         RtlZeroMemory(DriverObjectExtension,
 886                       sizeof(DRIVER_OBJECT_EXTENSION));
 887
 888         DriverObjectExtension->ExtensionType = DriverExtension;
 889         DriverObjectExtension->DriverObject = DriverObject;
 890
 891         InitializeListHead(&DriverObjectExtension->AdapterListHead);
 892         KeInitializeSpinLock(&DriverObjectExtension->AdapterListLock);
 893
 894         InitializeListHead(&DriverObjectExtension->InitDataListHead);
 895
 896         /* Set handlers */
 897         DriverObject->DriverExtension->AddDevice = PortAddDevice;
 898 //        DriverObject->DriverStartIo = PortStartIo;
 899         DriverObject->DriverUnload = PortUnload;
 900         DriverObject->MajorFunction[IRP_MJ_CREATE] = PortDispatchCreate;
 901         DriverObject->MajorFunction[IRP_MJ_CLOSE] = PortDispatchClose;
 902         DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PortDispatchDeviceControl;
 903         DriverObject->MajorFunction[IRP_MJ_SCSI] = PortDispatchScsi;
 904         DriverObject->MajorFunction[IRP_MJ_POWER] = PortDispatchPower;
 905         DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = PortDispatchSystemControl;
 906         DriverObject->MajorFunction[IRP_MJ_PNP] = PortDispatchPnp;
 907     }
 908
 909     /* Add the initialzation data to the driver extension */
 910     Status = PortAddDriverInitData(DriverObjectExtension,
 911                                    HwInitializationData);
 912
 913     DPRINT1("StorPortInitialize() done (Status 0x%08lx)\n", Status);
 914
 915     return Status;
 916 }
 917
 918
 919 /*
 920  * @unimplemented
 921  */
 922 STORPORT_API
 923 VOID
 924 NTAPI
 925 StorPortLogError(
 926     _In_ PVOID HwDeviceExtension,
 927     _In_opt_ PSCSI_REQUEST_BLOCK Srb,
 928     _In_ UCHAR PathId,
 929     _In_ UCHAR TargetId,
 930     _In_ UCHAR Lun,
 931     _In_ ULONG ErrorCode,
 932     _In_ ULONG UniqueId)
 933 {
 934     DPRINT1("ScsiPortLogError() called\n");
 935     DPRINT1("PathId: 0x%02x  TargetId: 0x%02x  Lun: 0x%02x  ErrorCode: 0x%08lx  UniqueId: 0x%08lx\n",
 936             PathId, TargetId, Lun, ErrorCode, UniqueId);
 937
 938     DPRINT1("ScsiPortLogError() done\n");
 939 }
 940
 941
 942 /*
 943  * @implemented
 944  */
 945 STORPORT_API
 946 VOID
 947 NTAPI
 948 StorPortMoveMemory(
 949     _Out_writes_bytes_(Length) PVOID Destination,
 950     _In_reads_bytes_(Length) PVOID Source,
 951     _In_ ULONG Length)
 952 {
 953     RtlMoveMemory(Destination, Source, Length);
 954 }
 955
 956
 957 /*
 958  * @unimplemented
 959  */
 960 STORPORT_API
 961 VOID
 962 StorPortNotification(
 963     _In_ SCSI_NOTIFICATION_TYPE NotificationType,
 964     _In_ PVOID HwDeviceExtension,
 965     ...)
 966 {
 967     DPRINT1("StorPortNotification()\n");
 968 }
 969
 970
 971 /*
 972  * @unimplemented
 973  */
 974 STORPORT_API
 975 BOOLEAN
 976 NTAPI
 977 StorPortPause(
 978     _In_ PVOID HwDeviceExtension,
 979     _In_ ULONG TimeOut)
 980 {
 981     DPRINT1("StorPortPause()\n");
 982     UNIMPLEMENTED;
 983     return FALSE;
 984 }
 985
 986
 987 /*
 988  * @unimplemented
 989  */
 990 STORPORT_API
 991 BOOLEAN
 992 NTAPI
 993 StorPortPauseDevice(
 994     _In_ PVOID HwDeviceExtension,
 995     _In_ UCHAR PathId,
 996     _In_ UCHAR TargetId,
 997     _In_ UCHAR Lun,
 998     _In_ ULONG TimeOut)
 999 {
1000     DPRINT1("StorPortPauseDevice()\n");
1001     UNIMPLEMENTED;
1002     return FALSE;
1003 }
1004
1005
1006 /*
1007  * @unimplemented
1008  */
1009 STORPORT_API
1010 BOOLEAN
1011 NTAPI
1012 StorPortReady(
1013     _In_ PVOID HwDeviceExtension)
1014 {
1015     DPRINT1("StorPortReady()\n");
1016     UNIMPLEMENTED;
1017     return FALSE;
1018 }
1019
1020
1021 /*
1022  * @unimplemented
1023  */
1024 STORPORT_API
1025 BOOLEAN
1026 NTAPI
1027 StorPortRegistryRead(
1028     _In_ PVOID HwDeviceExtension,
1029     _In_ PUCHAR ValueName,
1030     _In_ ULONG Global,
1031     _In_ ULONG Type,
1032     _In_ PUCHAR Buffer,
1033     _In_ PULONG BufferLength)
1034 {
1035     DPRINT1("StorPortRegistryRead()\n");
1036     UNIMPLEMENTED;
1037     return FALSE;
1038 }
1039
1040
1041 /*
1042  * @unimplemented
1043  */
1044 STORPORT_API
1045 BOOLEAN
1046 NTAPI
1047 StorPortRegistryWrite(
1048     _In_ PVOID HwDeviceExtension,
1049     _In_ PUCHAR ValueName,
1050     _In_ ULONG Global,
1051     _In_ ULONG Type,
1052     _In_ PUCHAR Buffer,
1053     _In_ ULONG BufferLength)
1054 {
1055     DPRINT1("StorPortRegistryWrite()\n");
1056     UNIMPLEMENTED;
1057     return FALSE;
1058 }
1059
1060
1061 /*
1062  * @unimplemented
1063  */
1064 STORPORT_API
1065 BOOLEAN
1066 NTAPI
1067 StorPortResume(
1068     _In_ PVOID HwDeviceExtension)
1069 {
1070     DPRINT1("StorPortResume()\n");
1071     UNIMPLEMENTED;
1072     return FALSE;
1073 }
1074
1075
1076 /*
1077  * @unimplemented
1078  */
1079 STORPORT_API
1080 BOOLEAN
1081 NTAPI
1082 StorPortResumeDevice(
1083     _In_ PVOID HwDeviceExtension,
1084     _In_ UCHAR PathId,
1085     _In_ UCHAR TargetId,
1086     _In_ UCHAR Lun)
1087 {
1088     DPRINT1("StorPortResumeDevice()\n");
1089     UNIMPLEMENTED;
1090     return FALSE;
1091 }
1092
1093
1094 /*
1095  * @implemented
1096  */
1097 STORPORT_API
1098 ULONG
1099 NTAPI
1100 StorPortSetBusDataByOffset(
1101     _In_ PVOID DeviceExtension,
1102     _In_ ULONG BusDataType,
1103     _In_ ULONG SystemIoBusNumber,
1104     _In_ ULONG SlotNumber,
1105     _In_reads_bytes_(Length) PVOID Buffer,
1106     _In_ ULONG Offset,
1107     _In_ ULONG Length)
1108 {
1109     PMINIPORT_DEVICE_EXTENSION MiniportExtension;
1110     PBUS_INTERFACE_STANDARD Interface;
1111     ULONG ReturnLength;
1112
1113     DPRINT1("StorPortSetBusData(%p %lu %lu %lu %p %lu %lu)\n",
1114             DeviceExtension, BusDataType, SystemIoBusNumber, SlotNumber, Buffer, Offset, Length);
1115
1116     MiniportExtension = CONTAINING_RECORD(DeviceExtension,
1117                                           MINIPORT_DEVICE_EXTENSION,
1118                                           HwDeviceExtension);
1119     DPRINT1("DeviceExtension %p  MiniportExtension %p\n",
1120             DeviceExtension, MiniportExtension);
1121
1122     Interface = &MiniportExtension->Miniport->DeviceExtension->BusInterface;
1123
1124     ReturnLength = Interface->SetBusData(Interface->Context,
1125                                          BusDataType,
1126                                          Buffer,
1127                                          Offset,
1128                                          Length);
1129     DPRINT1("ReturnLength: %lu\n", ReturnLength);
1130
1131     return ReturnLength;
1132 }
1133
1134
1135 /*
1136  * @unimplemented
1137  */
1138 STORPORT_API
1139 BOOLEAN
1140 NTAPI
1141 StorPortSetDeviceQueueDepth(
1142     _In_ PVOID HwDeviceExtension,
1143     _In_ UCHAR PathId,
1144     _In_ UCHAR TargetId,
1145     _In_ UCHAR Lun,
1146     _In_ ULONG Depth)
1147 {
1148     DPRINT1("StorPortSetDeviceQueueDepth()\n");
1149     UNIMPLEMENTED;
1150     return FALSE;
1151 }
1152
1153
1154 /*
1155  * @implemented
1156  */
1157 STORPORT_API
1158 VOID
1159 NTAPI
1160 StorPortStallExecution(
1161     _In_ ULONG Delay)
1162 {
1163     KeStallExecutionProcessor(Delay);
1164 }
1165
1166
1167 /*
1168  * @unimplemented
1169  */
1170 STORPORT_API
1171 VOID
1172 NTAPI
1173 StorPortSynchronizeAccess(
1174     _In_ PVOID HwDeviceExtension,
1175     _In_ PSTOR_SYNCHRONIZED_ACCESS SynchronizedAccessRoutine,
1176     _In_opt_ PVOID Context)
1177 {
1178     DPRINT1("StorPortSynchronizeAccess()\n");
1179     UNIMPLEMENTED;
1180 }
1181
1182
1183 /*
1184  * @implemented
1185  */
1186 STORPORT_API
1187 BOOLEAN
1188 NTAPI
1189 StorPortValidateRange(
1190     _In_ PVOID HwDeviceExtension,
1191     _In_ INTERFACE_TYPE BusType,
1192     _In_ ULONG SystemIoBusNumber,
1193     _In_ STOR_PHYSICAL_ADDRESS IoAddress,
1194     _In_ ULONG NumberOfBytes,
1195     _In_ BOOLEAN InIoSpace)
1196 {
1197     DPRINT1("StorPortValidateRange()\n");
1198     return TRUE;
1199 }
1200
1201 /* EOF */