* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id$
- *
+/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Storage Stack
* FILE: drivers/storage/scsiport/scsiport.c
#include "scsiport_int.h"
-#ifdef _MSC_VER
- #define STDCALL
- #define DDKAPI
-#endif
-
ULONG InternalDebugLevel = 0x00;
/* TYPES *********************************************************************/
IN ULONG BusNumber,
IN OUT PPCI_SLOT_NUMBER NextSlotNumber);
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
ScsiPortCreateClose(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
static DRIVER_DISPATCH ScsiPortDispatchScsi;
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
ScsiPortDispatchScsi(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
ScsiPortDeviceControl(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
static DRIVER_STARTIO ScsiPortStartIo;
-static VOID STDCALL
+static VOID NTAPI
ScsiPortStartIo(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
-static BOOLEAN STDCALL
+static BOOLEAN NTAPI
ScsiPortStartPacket(IN OUT PVOID Context);
IO_ALLOCATION_ACTION
-STDCALL
+NTAPI
SpiAdapterControl(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PVOID MapRegisterBase, PVOID Context);
IN UCHAR Lun,
IN UCHAR QueueTag);
-static KSERVICE_ROUTINE ScsiPortIsr;
-static BOOLEAN STDCALL
+static BOOLEAN NTAPI
ScsiPortIsr(IN PKINTERRUPT Interrupt,
IN PVOID ServiceContext);
-static VOID STDCALL
+static VOID NTAPI
ScsiPortDpcForIsr(IN PKDPC Dpc,
IN PDEVICE_OBJECT DpcDeviceObject,
IN PIRP DpcIrp,
IN PVOID DpcContext);
-static VOID STDCALL
+static VOID NTAPI
ScsiPortIoTimer(PDEVICE_OBJECT DeviceObject,
PVOID Context);
+IO_ALLOCATION_ACTION
+NTAPI
+ScsiPortAllocateAdapterChannel(IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ IN PVOID MapRegisterBase,
+ IN PVOID Context);
+
static NTSTATUS
SpiBuildDeviceMap (PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
PUNICODE_STRING RegistryPath);
IN PSCSI_REQUEST_BLOCK Srb);
static IO_COMPLETION_ROUTINE SpiCompletionRoutine;
-NTSTATUS STDCALL
+NTSTATUS NTAPI
SpiCompletionRoutine(PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID Context);
static VOID
-STDCALL
+NTAPI
SpiProcessCompletedRequest(IN PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
IN PSCSI_REQUEST_BLOCK_INFO SrbInfo,
OUT PBOOLEAN NeedToCallStartIo);
-VOID STDCALL
+VOID NTAPI
SpiGetNextRequestFromLun(IN PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
IN PSCSI_PORT_LUN_EXTENSION LunExtension);
-VOID STDCALL
+VOID NTAPI
SpiMiniportTimerDpc(IN struct _KDPC *Dpc,
IN PVOID DeviceObject,
IN PVOID SystemArgument1,
PPORT_CONFIGURATION_INFORMATION ConfigInfo,
BOOLEAN FirstCall);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
SpQueryDeviceCallout(IN PVOID Context,
IN PUNICODE_STRING PathName,
IN INTERFACE_TYPE BusType,
* Status.
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
DbgPrint(Buffer);
}
+/* An internal helper function for ScsiPortCompleteRequest */
+VOID
+NTAPI
+SpiCompleteRequest(IN PVOID HwDeviceExtension,
+ IN PSCSI_REQUEST_BLOCK_INFO SrbInfo,
+ IN UCHAR SrbStatus)
+{
+ PSCSI_REQUEST_BLOCK Srb;
+
+ /* Get current SRB */
+ Srb = SrbInfo->Srb;
+
+ /* Return if there is no SRB or it is not active */
+ if (!Srb || !(Srb->SrbFlags & SRB_FLAGS_IS_ACTIVE)) return;
+
+ /* Set status */
+ Srb->SrbStatus = SrbStatus;
+
+ /* Set data transfered to 0 */
+ Srb->DataTransferLength = 0;
+
+ /* Notify */
+ ScsiPortNotification(RequestComplete,
+ HwDeviceExtension,
+ Srb);
+}
/*
* @unimplemented
*/
-VOID STDCALL
+VOID NTAPI
ScsiPortCompleteRequest(IN PVOID HwDeviceExtension,
- IN UCHAR PathId,
- IN UCHAR TargetId,
- IN UCHAR Lun,
- IN UCHAR SrbStatus)
+ IN UCHAR PathId,
+ IN UCHAR TargetId,
+ IN UCHAR Lun,
+ IN UCHAR SrbStatus)
{
- DPRINT("ScsiPortCompleteRequest()\n");
- UNIMPLEMENTED;
+ PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
+ PSCSI_PORT_LUN_EXTENSION LunExtension;
+ PSCSI_REQUEST_BLOCK_INFO SrbInfo;
+ PLIST_ENTRY ListEntry;
+ ULONG BusNumber;
+ ULONG Target;
+
+ DPRINT("ScsiPortCompleteRequest() called\n");
+
+ DeviceExtension = CONTAINING_RECORD(HwDeviceExtension,
+ SCSI_PORT_DEVICE_EXTENSION,
+ MiniPortDeviceExtension);
+
+ /* Go through all buses */
+ for (BusNumber = 0; BusNumber < 8; BusNumber++)
+ {
+ /* Go through all targets */
+ for (Target = 0; Target < DeviceExtension->MaxTargedIds; Target++)
+ {
+ /* Get logical unit list head */
+ LunExtension = DeviceExtension->LunExtensionList[Target % 8];
+
+ /* Go through all logical units */
+ while (LunExtension)
+ {
+ /* Now match what caller asked with what we are at now */
+ if ((PathId == SP_UNTAGGED || PathId == LunExtension->PathId) &&
+ (TargetId == SP_UNTAGGED || TargetId == LunExtension->TargetId) &&
+ (Lun == SP_UNTAGGED || Lun == LunExtension->Lun))
+ {
+ /* Yes, that's what caller asked for. Complete abort requests */
+ if (LunExtension->CompletedAbortRequests)
+ {
+ /* TODO: Save SrbStatus in this request */
+ DPRINT1("Completing abort request without setting SrbStatus!\n");
+
+ /* Issue a notification request */
+ ScsiPortNotification(RequestComplete,
+ HwDeviceExtension,
+ LunExtension->CompletedAbortRequests);
+ }
+
+ /* Complete the request using our helper */
+ SpiCompleteRequest(HwDeviceExtension,
+ &LunExtension->SrbInfo,
+ SrbStatus);
+
+ /* Go through the queue and complete everything there too */
+ ListEntry = LunExtension->SrbInfo.Requests.Flink;
+ while (ListEntry != &LunExtension->SrbInfo.Requests)
+ {
+ /* Get the actual SRB info entry */
+ SrbInfo = CONTAINING_RECORD(ListEntry,
+ SCSI_REQUEST_BLOCK_INFO,
+ Requests);
+
+ /* Complete it */
+ SpiCompleteRequest(HwDeviceExtension,
+ SrbInfo,
+ SrbStatus);
+
+ /* Advance to the next request in queue */
+ ListEntry = SrbInfo->Requests.Flink;
+ }
+ }
+
+ /* Advance to the next one */
+ LunExtension = LunExtension->Next;
+ }
+ }
+ }
}
/*
* @unimplemented
*/
-VOID STDCALL
+VOID NTAPI
ScsiPortFlushDma(IN PVOID HwDeviceExtension)
{
DPRINT("ScsiPortFlushDma()\n");
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
ScsiPortFreeDeviceBase(IN PVOID HwDeviceExtension,
IN PVOID MappedAddress)
{
SCSI_PORT_DEVICE_EXTENSION,
MiniPortDeviceExtension);
-
/* Initialize our pointers */
NextMa = DeviceExtension->MappedAddressList;
LastMa = NextMa;
/*
* @implemented
*/
-ULONG STDCALL
+ULONG NTAPI
ScsiPortGetBusData(IN PVOID DeviceExtension,
IN ULONG BusDataType,
IN ULONG SystemIoBusNumber,
IN PVOID Buffer,
IN ULONG Length)
{
- return(HalGetBusData(BusDataType,
- SystemIoBusNumber,
- SlotNumber,
- Buffer,
- Length));
+ DPRINT("ScsiPortGetBusData()\n");
+
+ if (Length)
+ {
+ /* If Length is non-zero, just forward the call to
+ HalGetBusData() function */
+ return HalGetBusData(BusDataType,
+ SystemIoBusNumber,
+ SlotNumber,
+ Buffer,
+ Length);
+ }
+
+ /* We have a more complex case here */
+ UNIMPLEMENTED;
+ return 0;
}
+/*
+ * @implemented
+ */
+ULONG NTAPI
+ScsiPortSetBusDataByOffset(IN PVOID DeviceExtension,
+ IN ULONG BusDataType,
+ IN ULONG SystemIoBusNumber,
+ IN ULONG SlotNumber,
+ IN PVOID Buffer,
+ IN ULONG Offset,
+ IN ULONG Length)
+{
+ DPRINT("ScsiPortSetBusDataByOffset()\n");
+ return HalSetBusDataByOffset(BusDataType,
+ SystemIoBusNumber,
+ SlotNumber,
+ Buffer,
+ Offset,
+ Length);
+}
/*
* @implemented
*/
-PVOID STDCALL
+PVOID NTAPI
ScsiPortGetDeviceBase(IN PVOID HwDeviceExtension,
IN INTERFACE_TYPE BusType,
IN ULONG SystemIoBusNumber,
/* i/o space */
if (AddressSpace != 0)
- return((PVOID)TranslatedAddress.u.LowPart);
+ return((PVOID)(ULONG_PTR)TranslatedAddress.QuadPart);
MappedAddress = MmMapIoSpace(TranslatedAddress,
NumberOfBytes,
}
/*
- * @implemented
+ * @unimplemented
*/
-PVOID STDCALL
+PVOID NTAPI
ScsiPortGetLogicalUnit(IN PVOID HwDeviceExtension,
IN UCHAR PathId,
IN UCHAR TargetId,
/*
- * @unimplemented
+ * @implemented
*/
-SCSI_PHYSICAL_ADDRESS STDCALL
+SCSI_PHYSICAL_ADDRESS NTAPI
ScsiPortGetPhysicalAddress(IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb OPTIONAL,
IN PVOID VirtualAddress,
/*
* @unimplemented
*/
-PSCSI_REQUEST_BLOCK STDCALL
+PSCSI_REQUEST_BLOCK NTAPI
ScsiPortGetSrb(IN PVOID DeviceExtension,
IN UCHAR PathId,
IN UCHAR TargetId,
/*
* @implemented
*/
-PVOID STDCALL
+PVOID NTAPI
ScsiPortGetUncachedExtension(IN PVOID HwDeviceExtension,
IN PPORT_CONFIGURATION_INFORMATION ConfigInfo,
IN ULONG NumberOfBytes)
/*
* @implemented
*/
-PVOID STDCALL
+PVOID NTAPI
ScsiPortGetVirtualAddress(IN PVOID HwDeviceExtension,
IN SCSI_PHYSICAL_ADDRESS PhysicalAddress)
{
* @implemented
*/
-ULONG STDCALL
+ULONG NTAPI
ScsiPortInitialize(IN PVOID Argument1,
IN PVOID Argument2,
IN struct _HW_INITIALIZATION_DATA *HwInitializationData,
FirstConfigCall);
if (!NT_SUCCESS(Status))
+ {
+ DPRINT("SpiCreatePortConfig() failed with Status 0x%08X\n", Status);
break;
+ }
/* Allocate and initialize port configuration info */
PortConfigSize = (sizeof(PORT_CONFIGURATION_INFORMATION) +
PortConfig->AccessRanges = (PVOID)(PortConfig+1);
/* Align to LONGLONG */
- PortConfig->AccessRanges = (PVOID)((ULONG)(PortConfig->AccessRanges) + 7);
- PortConfig->AccessRanges = (PVOID)((ULONG)(PortConfig->AccessRanges) & ~7);
+ PortConfig->AccessRanges = (PVOID)((ULONG_PTR)(PortConfig->AccessRanges) + 7);
+ PortConfig->AccessRanges = (PVOID)((ULONG_PTR)(PortConfig->AccessRanges) & ~7);
/* Copy the data */
RtlCopyMemory(PortConfig->AccessRanges,
LunInfo = DeviceExtension->BusesConfig->BusScanInfo[Bus]->LunInfo;
- while (!LunInfo)
+ while (LunInfo)
{
/* Free current, but save pointer to the next one */
Ptr = LunInfo->Next;
}
else
{
-#if 0
HalFreeCommonBuffer(DeviceExtension->AdapterObject,
DeviceExtension->CommonBufferLength,
- DeviceExtension->PhysicalCommonBuffer,
+ DeviceExtension->PhysicalAddress,
DeviceExtension->SrbExtensionBuffer,
FALSE);
-#endif
}
}
IoDeleteDevice(DeviceExtension->DeviceObject);
}
-
-
/*
* @unimplemented
*/
-VOID STDCALL
+VOID NTAPI
ScsiPortIoMapTransfer(IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb,
IN PVOID LogicalAddress,
UNIMPLEMENTED;
}
-
/*
* @unimplemented
*/
-VOID STDCALL
+VOID NTAPI
ScsiPortLogError(IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb OPTIONAL,
IN UCHAR PathId,
DPRINT("ScsiPortLogError() done\n");
}
-
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
ScsiPortMoveMemory(OUT PVOID Destination,
IN PVOID Source,
IN ULONG Length)
DeviceExtension->InterruptData.Flags |= SCSI_PORT_NEXT_REQUEST_READY;
break;
- case NextLuRequest:
- {
- UCHAR PathId;
- UCHAR TargetId;
- UCHAR Lun;
+ case NextLuRequest:
+ {
+ UCHAR PathId;
+ UCHAR TargetId;
+ UCHAR Lun;
+ PSCSI_PORT_LUN_EXTENSION LunExtension;
- PathId = (UCHAR) va_arg (ap, int);
- TargetId = (UCHAR) va_arg (ap, int);
- Lun = (UCHAR) va_arg (ap, int);
+ PathId = (UCHAR) va_arg (ap, int);
+ TargetId = (UCHAR) va_arg (ap, int);
+ Lun = (UCHAR) va_arg (ap, int);
- DPRINT1 ("Notify: NextLuRequest(PathId %u TargetId %u Lun %u)\n",
- PathId, TargetId, Lun);
- /* FIXME: Implement it! */
- ASSERT(FALSE);
+ DPRINT("Notify: NextLuRequest(PathId %u TargetId %u Lun %u)\n",
+ PathId, TargetId, Lun);
-// DeviceExtension->IrpFlags |= IRP_FLAG_NEXT;
-// DeviceExtension->IrpFlags |= IRP_FLAG_NEXT_LU;
+ /* Mark it in the flags field */
+ DeviceExtension->InterruptData.Flags |= SCSI_PORT_NEXT_REQUEST_READY;
- /* Hack! */
-// DeviceExtension->IrpFlags |= IRP_FLAG_NEXT;
- }
- break;
+ /* Get the LUN extension */
+ LunExtension = SpiGetLunExtension(DeviceExtension,
+ PathId,
+ TargetId,
+ Lun);
+
+ /* If returned LunExtension is NULL, break out */
+ if (!LunExtension) break;
+
+ /* This request should not be processed if */
+ if ((LunExtension->ReadyLun) ||
+ (LunExtension->SrbInfo.Srb))
+ {
+ /* Nothing to do here */
+ break;
+ }
+
+ /* Add this LUN to the list */
+ LunExtension->ReadyLun = DeviceExtension->InterruptData.ReadyLun;
+ DeviceExtension->InterruptData.ReadyLun = LunExtension;
+ }
+ break;
case ResetDetected:
- DPRINT1("Notify: ResetDetected\n");
- /* FIXME: ??? */
- break;
+ DPRINT("Notify: ResetDetected\n");
+ /* Add RESET flags */
+ DeviceExtension->InterruptData.Flags |=
+ SCSI_PORT_RESET | SCSI_PORT_RESET_REPORTED;
+ break;
default:
DPRINT1 ("Unsupported notification %lu\n", NotificationType);
break;
}
- va_end(ap);
+ va_end(ap);
/* Request a DPC after we're done with the interrupt */
DeviceExtension->InterruptData.Flags |= SCSI_PORT_NOTIFICATION_NEEDED;
}
-
-/*
- * @implemented
- */
-ULONG STDCALL
-ScsiPortSetBusDataByOffset(IN PVOID DeviceExtension,
- IN ULONG BusDataType,
- IN ULONG SystemIoBusNumber,
- IN ULONG SlotNumber,
- IN PVOID Buffer,
- IN ULONG Offset,
- IN ULONG Length)
-{
- DPRINT("ScsiPortSetBusDataByOffset()\n");
- return(HalSetBusDataByOffset(BusDataType,
- SystemIoBusNumber,
- SlotNumber,
- Buffer,
- Offset,
- Length));
-}
-
-
/*
* @implemented
*/
-BOOLEAN STDCALL
+BOOLEAN NTAPI
ScsiPortValidateRange(IN PVOID HwDeviceExtension,
IN INTERFACE_TYPE BusType,
IN ULONG SystemIoBusNumber,
* Status.
*/
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
ScsiPortCreateClose(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
* NTSTATUS
*/
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
ScsiPortDispatchScsi(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
* NTSTATUS
*/
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
ScsiPortDeviceControl(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
DPRINT(" IOCTL_SCSI_GET_DUMP_POINTERS\n");
DumpPointers = (PDUMP_POINTERS)Irp->AssociatedIrp.SystemBuffer;
DumpPointers->DeviceObject = DeviceObject;
-
+
Irp->IoStatus.Information = sizeof(DUMP_POINTERS);
}
break;
}
-static VOID STDCALL
+static VOID NTAPI
ScsiPortStartIo(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
// Store the MDL virtual address in SrbInfo structure
SrbInfo->DataOffset = MmGetMdlVirtualAddress(Irp->MdlAddress);
- if (DeviceExtension->MapBuffers && Irp->MdlAddress)
+ if (DeviceExtension->MapBuffers)
{
/* Calculate offset within DataBuffer */
SrbInfo->DataOffset = MmGetSystemAddressForMdl(Irp->MdlAddress);
DeviceExtension->AdapterObject != NULL &&
!DeviceExtension->MapRegisters)
{
-#if 0
IoAllocateAdapterChannel(
DeviceExtension->AdapterObject,
DeviceObject,
DeviceExtension->PortCapabilities.MaximumPhysicalPages,
- ScsiPortAllocationRoutine,
+ ScsiPortAllocateAdapterChannel,
LunExtension
);
return;
-#else
- /* TODO: DMA is not implemented yet */
- ASSERT(FALSE);
-#endif
}
-
KeAcquireSpinLockAtDpcLevel(&DeviceExtension->SpinLock);
if (!KeSynchronizeExecution(DeviceExtension->Interrupt,
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
+ else
+ {
+ /* Release the spinlock only */
+ KeReleaseSpinLockFromDpcLevel(&DeviceExtension->SpinLock);
+ }
- KeReleaseSpinLockFromDpcLevel(&DeviceExtension->SpinLock);
DPRINT("ScsiPortStartIo() done\n");
}
-static BOOLEAN STDCALL
+static BOOLEAN NTAPI
ScsiPortStartPacket(IN OUT PVOID Context)
{
PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
}
IO_ALLOCATION_ACTION
-STDCALL
+NTAPI
SpiAdapterControl(PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID MapRegisterBase,
IrpStack = IoGetCurrentIrpStackLocation(Irp);
Srb = (PSCSI_REQUEST_BLOCK)IrpStack->Parameters.Others.Argument1;
- /* Depending on the map registers number, we allocate
+ /* Depending on the map registers number, we allocate
either from NonPagedPool, or from our static list */
if (SrbInfo->NumberOfMapRegisters > MAX_SG_LIST)
{
break;
ScatterGatherList->Length = Srb->DataTransferLength - TotalLength;
- ScatterGatherList->PhysicalAddress = IoMapTransfer(DeviceExtension->AdapterObject,
+ ScatterGatherList->PhysicalAddress = IoMapTransfer(NULL,
Irp->MdlAddress,
MapRegisterBase,
DataVA + TotalLength,
/* Check if this device is unsupported */
if (InquiryData->DeviceTypeQualifier == DEVICE_QUALIFIER_NOT_SUPPORTED)
{
- DeviceExtension->LunExtensionList[Hint] =
+ DeviceExtension->LunExtensionList[Hint] =
DeviceExtension->LunExtensionList[Hint]->Next;
continue;
else
{
/* Remove this LUN from the list */
- DeviceExtension->LunExtensionList[Hint] =
+ DeviceExtension->LunExtensionList[Hint] =
DeviceExtension->LunExtensionList[Hint]->Next;
/* Decide whether we are continuing or not */
/* Calculate data size */
Length = sizeof(SCSI_ADAPTER_BUS_INFO) + (BusCount - 1) *
sizeof(SCSI_BUS_DATA);
-
+
Length += InquiryDataSize * LunCount;
/* Check, if all data is going to fit into provided buffer */
static
VOID
-STDCALL
+NTAPI
SpiProcessCompletedRequest(IN PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
IN PSCSI_REQUEST_BLOCK_INFO SrbInfo,
OUT PBOOLEAN NeedToCallStartIo)
}
}
-
/* Flush adapter if needed */
if (SrbInfo->BaseOfMapRegister)
{
}
NTSTATUS
-STDCALL
+NTAPI
SpiCompletionRoutine(PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID Context)
if (Irp->MdlAddress != NULL)
{
- MmUnlockPages(Irp->MdlAddress);
+ MmUnlockPages(Irp->MdlAddress);
IoFreeMdl(Irp->MdlAddress);
Irp->MdlAddress = NULL;
}
return STATUS_MORE_PROCESSING_REQUIRED;
}
-
-
-static BOOLEAN STDCALL
+static BOOLEAN NTAPI
ScsiPortIsr(IN PKINTERRUPT Interrupt,
IN PVOID ServiceContext)
{
}
BOOLEAN
-STDCALL
+NTAPI
SpiSaveInterruptData(IN PVOID Context)
{
PSCSI_PORT_SAVE_INTERRUPT InterruptContext = Context;
}
VOID
-STDCALL
+NTAPI
SpiGetNextRequestFromLun(IN PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
IN PSCSI_PORT_LUN_EXTENSION LunExtension)
{
// IN PIRP DpcIrp
// IN PVOID DpcContext
//
-static VOID STDCALL
+static VOID NTAPI
ScsiPortDpcForIsr(IN PKDPC Dpc,
IN PDEVICE_OBJECT DpcDeviceObject,
IN PIRP DpcIrp,
}
BOOLEAN
-STDCALL
+NTAPI
SpiProcessTimeout(PVOID ServiceContext)
{
PDEVICE_OBJECT DeviceObject = (PDEVICE_OBJECT)ServiceContext;
BOOLEAN
-STDCALL
+NTAPI
SpiResetBus(PVOID ServiceContext)
{
PRESETBUS_PARAMS ResetParams = (PRESETBUS_PARAMS)ServiceContext;
// IN PVOID Context the Controller extension for the
// controller the device is on
//
-static VOID STDCALL
+static VOID NTAPI
ScsiPortIoTimer(PDEVICE_OBJECT DeviceObject,
PVOID Context)
{
}
VOID
-STDCALL
+NTAPI
SpiMiniportTimerDpc(IN struct _KDPC *Dpc,
IN PVOID DeviceObject,
IN PVOID SystemArgument1,
IN PVOID SystemArgument2)
{
DPRINT1("Miniport timer DPC\n");
+ ASSERT(FALSE);
}
static NTSTATUS
else
{
/* Info was not found, exit */
+ DPRINT1("ZwOpenKey() failed with Status=0x%08X\n", Status);
return STATUS_DEVICE_DOES_NOT_EXIST;
}
}
+ else
+ {
+ DPRINT1("ZwOpenKey() failed with Status=0x%08X\n", Status);
+ }
}
-
/* Look at device params */
Key = NULL;
if (InternalConfigInfo->Parameter)
ANSI_STRING AnsiString;
NTSTATUS Status = STATUS_SUCCESS;
-
KeyValueInformation = (PKEY_VALUE_FULL_INFORMATION) Buffer;
/* Loop through all values in the device node */
}
}
-
NTSTATUS
-STDCALL
+NTAPI
SpQueryDeviceCallout(IN PVOID Context,
IN PUNICODE_STRING PathName,
IN INTERFACE_TYPE BusType,
return STATUS_SUCCESS;
}
+IO_ALLOCATION_ACTION
+NTAPI
+ScsiPortAllocateAdapterChannel(IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ IN PVOID MapRegisterBase,
+ IN PVOID Context)
+{
+ KIRQL Irql;
+ PSCSI_PORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
+
+ /* Guard access with the spinlock */
+ KeAcquireSpinLock(&DeviceExtension->SpinLock, &Irql);
+ /* Save MapRegisterBase we've got here */
+ DeviceExtension->MapRegisterBase = MapRegisterBase;
+
+ /* Start pending request */
+ KeSynchronizeExecution(DeviceExtension->Interrupt,
+ ScsiPortStartPacket, DeviceObject);
+
+ /* Release spinlock we took */
+ KeReleaseSpinLock(&DeviceExtension->SpinLock, Irql);
+
+ return KeepObject;
+}
static
NTSTATUS
case SRB_STATUS_TIMEOUT:
case SRB_STATUS_COMMAND_TIMEOUT:
return STATUS_IO_TIMEOUT;
-
+
case SRB_STATUS_BAD_SRB_BLOCK_LENGTH:
case SRB_STATUS_BAD_FUNCTION:
return STATUS_INVALID_DEVICE_REQUEST;
/*
* @implemented
*/
-ULONG STDCALL
+ULONG NTAPI
ScsiPortConvertPhysicalAddressToUlong(IN SCSI_PHYSICAL_ADDRESS Address)
{
DPRINT("ScsiPortConvertPhysicalAddressToUlong()\n");