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
 611     PHYSICAL_ADDRESS TranslatedAddress;
 612     PVOID MappedAddress;
 613     NTSTATUS Status;
 614
 615     DPRINT1("StorPortGetDeviceBase(%p %lu %lu 0x%I64x %lu %u)\n",
 616             HwDeviceExtension, BusType, SystemIoBusNumber, IoAddress.QuadPart, NumberOfBytes, InIoSpace);
 617
 618     /* Get the miniport extension */
 619     MiniportExtension = CONTAINING_RECORD(HwDeviceExtension,
 620                                           MINIPORT_DEVICE_EXTENSION,
 621                                           HwDeviceExtension);
 622     DPRINT1("HwDeviceExtension %p  MiniportExtension %p\n",
 623             HwDeviceExtension, MiniportExtension);
 624
 625     if (!TranslateResourceListAddress(MiniportExtension->Miniport->DeviceExtension,
 626                                       BusType,
 627                                       SystemIoBusNumber,
 628                                       IoAddress,
 629                                       NumberOfBytes,
 630                                       InIoSpace,
 631                                       &TranslatedAddress))
 632     {
 633         DPRINT1("Checkpoint!\n");
 634         return NULL;
 635     }
 636
 637     DPRINT1("Translated Address: 0x%I64x\n", TranslatedAddress.QuadPart);
 638
 639     /* In I/O space */
 640     if (InIoSpace)
 641     {
 642         DPRINT1("Translated Address: %p\n", (PVOID)(ULONG_PTR)TranslatedAddress.QuadPart);
 643         return (PVOID)(ULONG_PTR)TranslatedAddress.QuadPart;
 644     }
 645
 646     /* In memory space */
 647     MappedAddress = MmMapIoSpace(TranslatedAddress,
 648                                  NumberOfBytes,
 649                                  FALSE);
 650     DPRINT1("Mapped Address: %p\n", MappedAddress);
 651
 652     Status = AllocateAddressMapping(&MiniportExtension->Miniport->DeviceExtension->MappedAddressList,
 653                                     IoAddress,
 654                                     MappedAddress,
 655                                     NumberOfBytes,
 656                                     SystemIoBusNumber);
 657     if (!NT_SUCCESS(Status))
 658     {
 659         DPRINT1("Checkpoint!\n");
 660         MappedAddress = NULL;
 661     }
 662
 663     DPRINT1("Mapped Address: %p\n", MappedAddress);
 664     return MappedAddress;
 665 }
 666
 667
 668 /*
 669  * @unimplemented
 670  */
 671 STORPORT_API
 672 PVOID
 673 NTAPI
 674 StorPortGetLogicalUnit(
 675     _In_ PVOID HwDeviceExtension,
 676     _In_ UCHAR PathId,
 677     _In_ UCHAR TargetId,
 678     _In_ UCHAR Lun)
 679 {
 680     DPRINT1("StorPortGetLogicalUnit()\n");
 681     UNIMPLEMENTED;
 682     return NULL;
 683 }
 684
 685
 686 /*
 687  * @unimplemented
 688  */
 689 STORPORT_API
 690 STOR_PHYSICAL_ADDRESS
 691 NTAPI
 692 StorPortGetPhysicalAddress(
 693     _In_ PVOID HwDeviceExtension,
 694     _In_opt_ PSCSI_REQUEST_BLOCK Srb,
 695     _In_ PVOID VirtualAddress,
 696     _Out_ ULONG *Length)
 697 {
 698     STOR_PHYSICAL_ADDRESS PhysicalAddress;
 699
 700     DPRINT1("StorPortGetPhysicalAddress(%p %p %p %p)\n",
 701             HwDeviceExtension, Srb, VirtualAddress, Length);
 702     UNIMPLEMENTED;
 703
 704     *Length = 0;
 705     PhysicalAddress.QuadPart = (LONGLONG)0;
 706
 707     return PhysicalAddress;
 708 }
 709
 710
 711 /*
 712  * @unimplemented
 713  */
 714 STORPORT_API
 715 PSTOR_SCATTER_GATHER_LIST
 716 NTAPI
 717 StorPortGetScatterGatherList(
 718     _In_ PVOID DeviceExtension,
 719     _In_ PSCSI_REQUEST_BLOCK Srb)
 720 {
 721     DPRINT1("StorPortGetScatterGatherList()\n");
 722     UNIMPLEMENTED;
 723     return NULL;
 724 }
 725
 726
 727 /*
 728  * @implemented
 729  */
 730 STORPORT_API
 731 PSCSI_REQUEST_BLOCK
 732 NTAPI
 733 StorPortGetSrb(
 734     _In_ PVOID DeviceExtension,
 735     _In_ UCHAR PathId,
 736     _In_ UCHAR TargetId,
 737     _In_ UCHAR Lun,
 738     _In_ LONG QueueTag)
 739 {
 740     DPRINT("StorPortGetSrb()\n");
 741     return NULL;
 742 }
 743
 744
 745 /*
 746  * @unimplemented
 747  */
 748 STORPORT_API
 749 PVOID
 750 NTAPI
 751 StorPortGetUncachedExtension(
 752     _In_ PVOID HwDeviceExtension,
 753     _In_ PPORT_CONFIGURATION_INFORMATION ConfigInfo,
 754     _In_ ULONG NumberOfBytes)
 755 {
 756     DPRINT1("StorPortGetUncachedExtension(%p %p %lu)\n",
 757             HwDeviceExtension, ConfigInfo, NumberOfBytes);
 758     UNIMPLEMENTED;
 759     return NULL;
 760 }
 761
 762
 763 /*
 764  * @unimplemented
 765  */
 766 STORPORT_API
 767 PVOID
 768 NTAPI
 769 StorPortGetVirtualAddress(
 770     _In_ PVOID HwDeviceExtension,
 771     _In_ STOR_PHYSICAL_ADDRESS PhysicalAddress)
 772 {
 773     DPRINT1("StorPortGetVirtualAddress(%p %I64x)\n",
 774             HwDeviceExtension, PhysicalAddress.QuadPart);
 775     UNIMPLEMENTED;
 776     return NULL;
 777 }
 778
 779
 780 /*
 781  * @implemented
 782  */
 783 STORPORT_API
 784 ULONG
 785 NTAPI
 786 StorPortInitialize(
 787     _In_ PVOID Argument1,
 788     _In_ PVOID Argument2,
 789     _In_ struct _HW_INITIALIZATION_DATA *HwInitializationData,
 790     _In_opt_ PVOID HwContext)
 791 {
 792     PDRIVER_OBJECT DriverObject = (PDRIVER_OBJECT)Argument1;
 793     PUNICODE_STRING RegistryPath = (PUNICODE_STRING)Argument2;
 794     PDRIVER_OBJECT_EXTENSION DriverObjectExtension;
 795     NTSTATUS Status = STATUS_SUCCESS;
 796
 797     DPRINT1("StorPortInitialize(%p %p %p %p)\n",
 798             Argument1, Argument2, HwInitializationData, HwContext);
 799
 800     DPRINT1("HwInitializationDataSize: %lu\n", HwInitializationData->HwInitializationDataSize);
 801     DPRINT1("AdapterInterfaceType: %u\n", HwInitializationData->AdapterInterfaceType);
 802     DPRINT1("HwInitialize: %p\n", HwInitializationData->HwInitialize);
 803     DPRINT1("HwStartIo: %p\n", HwInitializationData->HwStartIo);
 804     DPRINT1("HwInterrupt: %p\n", HwInitializationData->HwInterrupt);
 805     DPRINT1("HwFindAdapter: %p\n", HwInitializationData->HwFindAdapter);
 806     DPRINT1("HwResetBus: %p\n", HwInitializationData->HwResetBus);
 807     DPRINT1("HwDmaStarted: %p\n", HwInitializationData->HwDmaStarted);
 808     DPRINT1("HwAdapterState: %p\n", HwInitializationData->HwAdapterState);
 809     DPRINT1("DeviceExtensionSize: %lu\n", HwInitializationData->DeviceExtensionSize);
 810     DPRINT1("SpecificLuExtensionSize: %lu\n", HwInitializationData->SpecificLuExtensionSize);
 811     DPRINT1("SrbExtensionSize: %lu\n", HwInitializationData->SrbExtensionSize);
 812     DPRINT1("NumberOfAccessRanges: %lu\n", HwInitializationData->NumberOfAccessRanges);
 813
 814     /* Check parameters */
 815     if ((DriverObject == NULL) ||
 816         (RegistryPath == NULL) ||
 817         (HwInitializationData == NULL))
 818     {
 819         DPRINT1("Invalid parameter!\n");
 820         return STATUS_INVALID_PARAMETER;
 821     }
 822
 823     /* Check initialization data */
 824     if ((HwInitializationData->HwInitializationDataSize < sizeof(HW_INITIALIZATION_DATA)) ||
 825         (HwInitializationData->HwInitialize == NULL) ||
 826         (HwInitializationData->HwStartIo == NULL) ||
 827         (HwInitializationData->HwFindAdapter == NULL) ||
 828         (HwInitializationData->HwResetBus == NULL))
 829     {
 830         DPRINT1("Revision mismatch!\n");
 831         return STATUS_REVISION_MISMATCH;
 832     }
 833
 834     DriverObjectExtension = IoGetDriverObjectExtension(DriverObject,
 835                                                        (PVOID)DriverEntry);
 836     if (DriverObjectExtension == NULL)
 837     {
 838         DPRINT1("No driver object extension!\n");
 839
 840         Status = IoAllocateDriverObjectExtension(DriverObject,
 841                                                  (PVOID)DriverEntry,
 842                                                  sizeof(DRIVER_OBJECT_EXTENSION),
 843                                                  (PVOID *)&DriverObjectExtension);
 844         if (!NT_SUCCESS(Status))
 845         {
 846             DPRINT1("IoAllocateDriverObjectExtension() failed (Status 0x%08lx)\n", Status);
 847             return Status;
 848         }
 849
 850         DPRINT1("Driver object extension created!\n");
 851
 852         /* Initialize the driver object extension */
 853         RtlZeroMemory(DriverObjectExtension,
 854                       sizeof(DRIVER_OBJECT_EXTENSION));
 855
 856         DriverObjectExtension->ExtensionType = DriverExtension;
 857         DriverObjectExtension->DriverObject = DriverObject;
 858
 859         InitializeListHead(&DriverObjectExtension->AdapterListHead);
 860         KeInitializeSpinLock(&DriverObjectExtension->AdapterListLock);
 861
 862         InitializeListHead(&DriverObjectExtension->InitDataListHead);
 863
 864         /* Set handlers */
 865         DriverObject->DriverExtension->AddDevice = PortAddDevice;
 866 //        DriverObject->DriverStartIo = PortStartIo;
 867         DriverObject->DriverUnload = PortUnload;
 868         DriverObject->MajorFunction[IRP_MJ_CREATE] = PortDispatchCreate;
 869         DriverObject->MajorFunction[IRP_MJ_CLOSE] = PortDispatchClose;
 870         DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PortDispatchDeviceControl;
 871         DriverObject->MajorFunction[IRP_MJ_SCSI] = PortDispatchScsi;
 872         DriverObject->MajorFunction[IRP_MJ_POWER] = PortDispatchPower;
 873         DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = PortDispatchSystemControl;
 874         DriverObject->MajorFunction[IRP_MJ_PNP] = PortDispatchPnp;
 875     }
 876
 877     /* Add the initialzation data to the driver extension */
 878     Status = PortAddDriverInitData(DriverObjectExtension,
 879                                    HwInitializationData);
 880
 881     DPRINT1("StorPortInitialize() done (Status 0x%08lx)\n", Status);
 882
 883     return Status;
 884 }
 885
 886
 887 /*
 888  * @unimplemented
 889  */
 890 STORPORT_API
 891 VOID
 892 NTAPI
 893 StorPortLogError(
 894     _In_ PVOID HwDeviceExtension,
 895     _In_opt_ PSCSI_REQUEST_BLOCK Srb,
 896     _In_ UCHAR PathId,
 897     _In_ UCHAR TargetId,
 898     _In_ UCHAR Lun,
 899     _In_ ULONG ErrorCode,
 900     _In_ ULONG UniqueId)
 901 {
 902     DPRINT1("ScsiPortLogError() called\n");
 903     DPRINT1("PathId: 0x%02x  TargetId: 0x%02x  Lun: 0x%02x  ErrorCode: 0x%08lx  UniqueId: 0x%08lx\n",
 904             PathId, TargetId, Lun, ErrorCode, UniqueId);
 905
 906     DPRINT1("ScsiPortLogError() done\n");
 907 }
 908
 909
 910 /*
 911  * @implemented
 912  */
 913 STORPORT_API
 914 VOID
 915 NTAPI
 916 StorPortMoveMemory(
 917     _Out_writes_bytes_(Length) PVOID Destination,
 918     _In_reads_bytes_(Length) PVOID Source,
 919     _In_ ULONG Length)
 920 {
 921     RtlMoveMemory(Destination, Source, Length);
 922 }
 923
 924
 925 /*
 926  * @unimplemented
 927  */
 928 STORPORT_API
 929 VOID
 930 StorPortNotification(
 931     _In_ SCSI_NOTIFICATION_TYPE NotificationType,
 932     _In_ PVOID HwDeviceExtension,
 933     ...)
 934 {
 935     DPRINT1("StorPortNotification()\n");
 936 }
 937
 938
 939 /*
 940  * @unimplemented
 941  */
 942 STORPORT_API
 943 BOOLEAN
 944 NTAPI
 945 StorPortPause(
 946     _In_ PVOID HwDeviceExtension,
 947     _In_ ULONG TimeOut)
 948 {
 949     DPRINT1("StorPortPause()\n");
 950     UNIMPLEMENTED;
 951     return FALSE;
 952 }
 953
 954
 955 /*
 956  * @unimplemented
 957  */
 958 STORPORT_API
 959 BOOLEAN
 960 NTAPI
 961 StorPortPauseDevice(
 962     _In_ PVOID HwDeviceExtension,
 963     _In_ UCHAR PathId,
 964     _In_ UCHAR TargetId,
 965     _In_ UCHAR Lun,
 966     _In_ ULONG TimeOut)
 967 {
 968     DPRINT1("StorPortPauseDevice()\n");
 969     UNIMPLEMENTED;
 970     return FALSE;
 971 }
 972
 973
 974 /*
 975  * @unimplemented
 976  */
 977 STORPORT_API
 978 BOOLEAN
 979 NTAPI
 980 StorPortReady(
 981     _In_ PVOID HwDeviceExtension)
 982 {
 983     DPRINT1("StorPortReady()\n");
 984     UNIMPLEMENTED;
 985     return FALSE;
 986 }
 987
 988
 989 /*
 990  * @unimplemented
 991  */
 992 STORPORT_API
 993 BOOLEAN
 994 NTAPI
 995 StorPortRegistryRead(
 996     _In_ PVOID HwDeviceExtension,
 997     _In_ PUCHAR ValueName,
 998     _In_ ULONG Global,
 999     _In_ ULONG Type,
1000     _In_ PUCHAR Buffer,
1001     _In_ PULONG BufferLength)
1002 {
1003     DPRINT1("StorPortRegistryRead()\n");
1004     UNIMPLEMENTED;
1005     return FALSE;
1006 }
1007
1008
1009 /*
1010  * @unimplemented
1011  */
1012 STORPORT_API
1013 BOOLEAN
1014 NTAPI
1015 StorPortRegistryWrite(
1016     _In_ PVOID HwDeviceExtension,
1017     _In_ PUCHAR ValueName,
1018     _In_ ULONG Global,
1019     _In_ ULONG Type,
1020     _In_ PUCHAR Buffer,
1021     _In_ ULONG BufferLength)
1022 {
1023     DPRINT1("StorPortRegistryWrite()\n");
1024     UNIMPLEMENTED;
1025     return FALSE;
1026 }
1027
1028
1029 /*
1030  * @unimplemented
1031  */
1032 STORPORT_API
1033 BOOLEAN
1034 NTAPI
1035 StorPortResume(
1036     _In_ PVOID HwDeviceExtension)
1037 {
1038     DPRINT1("StorPortResume()\n");
1039     UNIMPLEMENTED;
1040     return FALSE;
1041 }
1042
1043
1044 /*
1045  * @unimplemented
1046  */
1047 STORPORT_API
1048 BOOLEAN
1049 NTAPI
1050 StorPortResumeDevice(
1051     _In_ PVOID HwDeviceExtension,
1052     _In_ UCHAR PathId,
1053     _In_ UCHAR TargetId,
1054     _In_ UCHAR Lun)
1055 {
1056     DPRINT1("StorPortResumeDevice()\n");
1057     UNIMPLEMENTED;
1058     return FALSE;
1059 }
1060
1061
1062 /*
1063  * @implemented
1064  */
1065 STORPORT_API
1066 ULONG
1067 NTAPI
1068 StorPortSetBusDataByOffset(
1069     _In_ PVOID DeviceExtension,
1070     _In_ ULONG BusDataType,
1071     _In_ ULONG SystemIoBusNumber,
1072     _In_ ULONG SlotNumber,
1073     _In_reads_bytes_(Length) PVOID Buffer,
1074     _In_ ULONG Offset,
1075     _In_ ULONG Length)
1076 {
1077     PMINIPORT_DEVICE_EXTENSION MiniportExtension;
1078     PBUS_INTERFACE_STANDARD Interface;
1079     ULONG ReturnLength;
1080
1081     DPRINT1("StorPortSetBusData(%p %lu %lu %lu %p %lu %lu)\n",
1082             DeviceExtension, BusDataType, SystemIoBusNumber, SlotNumber, Buffer, Offset, Length);
1083
1084     MiniportExtension = CONTAINING_RECORD(DeviceExtension,
1085                                           MINIPORT_DEVICE_EXTENSION,
1086                                           HwDeviceExtension);
1087     DPRINT1("DeviceExtension %p  MiniportExtension %p\n",
1088             DeviceExtension, MiniportExtension);
1089
1090     Interface = &MiniportExtension->Miniport->DeviceExtension->BusInterface;
1091
1092     ReturnLength = Interface->SetBusData(Interface->Context,
1093                                          BusDataType,
1094                                          Buffer,
1095                                          Offset,
1096                                          Length);
1097     DPRINT1("ReturnLength: %lu\n", ReturnLength);
1098
1099     return ReturnLength;
1100 }
1101
1102
1103 /*
1104  * @unimplemented
1105  */
1106 STORPORT_API
1107 BOOLEAN
1108 NTAPI
1109 StorPortSetDeviceQueueDepth(
1110     _In_ PVOID HwDeviceExtension,
1111     _In_ UCHAR PathId,
1112     _In_ UCHAR TargetId,
1113     _In_ UCHAR Lun,
1114     _In_ ULONG Depth)
1115 {
1116     DPRINT1("StorPortSetDeviceQueueDepth()\n");
1117     UNIMPLEMENTED;
1118     return FALSE;
1119 }
1120
1121
1122 /*
1123  * @implemented
1124  */
1125 STORPORT_API
1126 VOID
1127 NTAPI
1128 StorPortStallExecution(
1129     _In_ ULONG Delay)
1130 {
1131     KeStallExecutionProcessor(Delay);
1132 }
1133
1134
1135 /*
1136  * @unimplemented
1137  */
1138 STORPORT_API
1139 VOID
1140 NTAPI
1141 StorPortSynchronizeAccess(
1142     _In_ PVOID HwDeviceExtension,
1143     _In_ PSTOR_SYNCHRONIZED_ACCESS SynchronizedAccessRoutine,
1144     _In_opt_ PVOID Context)
1145 {
1146     DPRINT1("StorPortSynchronizeAccess()\n");
1147     UNIMPLEMENTED;
1148 }
1149
1150
1151 /*
1152  * @implemented
1153  */
1154 STORPORT_API
1155 BOOLEAN
1156 NTAPI
1157 StorPortValidateRange(
1158     _In_ PVOID HwDeviceExtension,
1159     _In_ INTERFACE_TYPE BusType,
1160     _In_ ULONG SystemIoBusNumber,
1161     _In_ STOR_PHYSICAL_ADDRESS IoAddress,
1162     _In_ ULONG NumberOfBytes,
1163     _In_ BOOLEAN InIoSpace)
1164 {
1165     DPRINT1("StorPortValidateRange()\n");
1166     return TRUE;
1167 }
1168
1169 /* EOF */