BOOLEAN
DeviceReset(
IN PVOID DeviceExtension
)
{
PADAPTER_EXTENSION adaptExt = (PADAPTER_EXTENSION)DeviceExtension;
PSCSI_REQUEST_BLOCK Srb = &adaptExt->tmf_cmd.Srb;
PSRB_EXTENSION srbExt = adaptExt->tmf_cmd.SrbExtension;
VirtIOSCSICmd *cmd = &srbExt->cmd;
ULONG fragLen;
ULONG sgElement;
ENTER_FN();
if (adaptExt->dump_mode) {
return TRUE;
}
ASSERT(adaptExt->tmf_infly == FALSE);
memset((PVOID)cmd, 0, sizeof(VirtIOSCSICmd));
cmd->sc = Srb;
cmd->req.tmf.lun[0] = 1;
cmd->req.tmf.lun[1] = 0;
cmd->req.tmf.lun[2] = 0;
cmd->req.tmf.lun[3] = 0;
cmd->req.tmf.type = VIRTIO_SCSI_T_TMF;
cmd->req.tmf.subtype = VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET;
sgElement = 0;
srbExt->sg[sgElement].physAddr = StorPortGetPhysicalAddress(DeviceExtension, NULL, &cmd->req.tmf, &fragLen);
srbExt->sg[sgElement].ulSize = sizeof(cmd->req.tmf);
sgElement++;
srbExt->out = sgElement;
srbExt->sg[sgElement].physAddr = StorPortGetPhysicalAddress(DeviceExtension, NULL, &cmd->resp.tmf, &fragLen);
srbExt->sg[sgElement].ulSize = sizeof(cmd->resp.tmf);
sgElement++;
srbExt->in = sgElement - srbExt->out;
StorPortPause(DeviceExtension, 60);
if (!SendTMF(DeviceExtension, Srb)) {
StorPortResume(DeviceExtension);
return FALSE;
}
adaptExt->tmf_infly = TRUE;
return TRUE;
}
BOOLEAN
VioScsiStartIo(
IN PVOID DeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
)
{
ENTER_FN();
if (PreProcessRequest(DeviceExtension, Srb) ||
!SendSRB(DeviceExtension, Srb))
{
if(Srb->SrbStatus == SRB_STATUS_PENDING)
{
Srb->SrbStatus = SRB_STATUS_ERROR;
}
CompleteRequest(DeviceExtension, Srb);
}
EXIT_FN();
return TRUE;
}
VOID
ShutDown(
IN PVOID DeviceExtension
)
{
ULONG index;
PADAPTER_EXTENSION adaptExt = (PADAPTER_EXTENSION)DeviceExtension;
ENTER_FN();
VirtIODeviceReset(adaptExt->pvdev);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_GUEST_FEATURES), 0);
for (index = VIRTIO_SCSI_CONTROL_QUEUE; index < adaptExt->num_queues + VIRTIO_SCSI_REQUEST_QUEUE_0; ++index) {
if (adaptExt->vq[index]) {
virtqueue_shutdown(adaptExt->vq[index]);
VirtIODeviceDeleteQueue(adaptExt->vq[index], NULL);
adaptExt->vq[index] = NULL;
}
}
EXIT_FN();
}
BOOLEAN
SynchronizedKickEventRoutine(
IN PVOID DeviceExtension,
IN PVOID Context
)
{
PADAPTER_EXTENSION adaptExt = (PADAPTER_EXTENSION)DeviceExtension;
PVirtIOSCSIEventNode eventNode = (PVirtIOSCSIEventNode) Context;
PVOID va = NULL;
ULONGLONG pa = 0;
ENTER_FN();
if (virtqueue_add_buf(adaptExt->vq[VIRTIO_SCSI_EVENTS_QUEUE],
&eventNode->sg,
0, 1,
eventNode, va, pa) >= 0){
virtqueue_kick(adaptExt->vq[VIRTIO_SCSI_EVENTS_QUEUE]);
return TRUE;
}
EXIT_ERR();
return FALSE;
}
ULONG
VioScsiReleaseSpinLock(
IN PVOID DeviceExtension,
IN ULONG MessageID,
IN PSTOR_LOCK_HANDLE LockHandle
)
{
PADAPTER_EXTENSION adaptExt;
ULONG status = STOR_STATUS_SUCCESS;
ENTER_FN();
adaptExt = (PADAPTER_EXTENSION)DeviceExtension;
if (adaptExt->num_queues > 1) {
status = StorPortReleaseMSISpinLock(DeviceExtension, MessageID, LockHandle->Context.OldIrql);
if (status != STOR_STATUS_SUCCESS) {
RhelDbgPrint(TRACE_LEVEL_ERROR, ("%s StorPortAcquireMSISpinLock returned status 0x%x\n", __FUNCTION__, status));
}
}
else {
StorPortReleaseSpinLock(DeviceExtension, LockHandle);
}
return status;
EXIT_FN();
}
BOOLEAN
FORCEINLINE
PreProcessRequest(
IN PVOID DeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
)
{
PADAPTER_EXTENSION adaptExt;
ENTER_FN();
adaptExt = (PADAPTER_EXTENSION)DeviceExtension;
switch (Srb->Function) {
case SRB_FUNCTION_PNP:
case SRB_FUNCTION_POWER:
case SRB_FUNCTION_RESET_DEVICE:
case SRB_FUNCTION_RESET_LOGICAL_UNIT: {
Srb->SrbStatus = SRB_STATUS_SUCCESS;
return TRUE;
}
}
EXIT_FN();
return FALSE;
}
BOOLEAN
SendSRB(
IN PVOID DeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
)
{
PADAPTER_EXTENSION adaptExt = (PADAPTER_EXTENSION)DeviceExtension;
PSRB_EXTENSION srbExt = (PSRB_EXTENSION)Srb->SrbExtension;
PVOID va = NULL;
ULONGLONG pa = 0;
ULONG QueueNumber = 0;
ULONG OldIrql = 0;
ULONG MessageId = 0;
BOOLEAN kick = FALSE;
STOR_LOCK_HANDLE LockHandle = { 0 };
ULONG status = STOR_STATUS_SUCCESS;
ENTER_FN();
SET_VA_PA();
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("Srb %p issued on %d::%d QueueNumber %d\n",
Srb, srbExt->procNum.Group, srbExt->procNum.Number, QueueNumber));
if (adaptExt->num_queues > 1) {
QueueNumber = adaptExt->cpu_to_vq_map[srbExt->procNum.Number];
MessageId = QueueNumber + 1;
if (CHECKFLAG(adaptExt->perfFlags, STOR_PERF_OPTIMIZE_FOR_COMPLETION_DURING_STARTIO)) {
ProcessQueue(DeviceExtension, MessageId, FALSE);
}
// status = StorPortAcquireMSISpinLock(DeviceExtension, MessageId, &OldIrql);
if (status != STOR_STATUS_SUCCESS) {
RhelDbgPrint(TRACE_LEVEL_ERROR, ("%s StorPortAcquireMSISpinLock returned status 0x%x\n", __FUNCTION__, status));
}
}
else {
QueueNumber = VIRTIO_SCSI_REQUEST_QUEUE_0;
StorPortAcquireSpinLock(DeviceExtension, InterruptLock, NULL, &LockHandle);
}
if (virtqueue_add_buf(adaptExt->vq[QueueNumber],
&srbExt->sg[0],
srbExt->out, srbExt->in,
&srbExt->cmd, va, pa) >= 0){
kick = TRUE;
}
else {
RhelDbgPrint(TRACE_LEVEL_WARNING, ("%s Cant add packet to queue.\n", __FUNCTION__));
//FIXME
}
if (adaptExt->num_queues > 1) {
// status = StorPortReleaseMSISpinLock(DeviceExtension, MessageId, OldIrql);
if (status != STOR_STATUS_SUCCESS) {
RhelDbgPrint(TRACE_LEVEL_ERROR, ("%s StorPortReleaseMSISpinLock returned status 0x%x\n", __FUNCTION__, status));
}
}
else {
StorPortReleaseSpinLock(DeviceExtension, &LockHandle);
}
if (kick == TRUE) {
virtqueue_kick(adaptExt->vq[QueueNumber]);
}
return kick;
EXIT_FN();
}
BOOLEAN
VioScsiBuildIo(
IN PVOID DeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
)
{
PCDB cdb;
ULONG i;
ULONG fragLen;
ULONG sgElement;
ULONG sgMaxElements;
PADAPTER_EXTENSION adaptExt;
PSRB_EXTENSION srbExt;
PSTOR_SCATTER_GATHER_LIST sgList;
VirtIOSCSICmd *cmd;
ENTER_FN();
cdb = (PCDB)&Srb->Cdb[0];
srbExt = (PSRB_EXTENSION)Srb->SrbExtension;
adaptExt = (PADAPTER_EXTENSION)DeviceExtension;
if( (Srb->PathId > 0) ||
(Srb->TargetId >= adaptExt->scsi_config.max_target) ||
(Srb->Lun >= adaptExt->scsi_config.max_lun) ) {
Srb->SrbStatus = SRB_STATUS_NO_DEVICE;
StorPortNotification(RequestComplete,
DeviceExtension,
Srb);
return FALSE;
}
RhelDbgPrint(TRACE_LEVEL_VERBOSE, ("<-->%s (%d::%d::%d)\n", DbgGetScsiOpStr(Srb), Srb->PathId, Srb->TargetId, Srb->Lun));
memset(srbExt, 0, sizeof(*srbExt));
cmd = &srbExt->cmd;
cmd->sc = Srb;
cmd->req.cmd.lun[0] = 1;
cmd->req.cmd.lun[1] = Srb->TargetId;
cmd->req.cmd.lun[2] = 0;
cmd->req.cmd.lun[3] = Srb->Lun;
cmd->req.cmd.tag = (unsigned long)Srb;
cmd->req.cmd.task_attr = VIRTIO_SCSI_S_SIMPLE;
cmd->req.cmd.prio = 0;
cmd->req.cmd.crn = 0;
memcpy(cmd->req.cmd.cdb, cdb, min(VIRTIO_SCSI_CDB_SIZE, Srb->CdbLength));
sgElement = 0;
srbExt->sg[sgElement].physAddr = StorPortGetPhysicalAddress(DeviceExtension, NULL, &cmd->req.cmd, &fragLen);
srbExt->sg[sgElement].ulSize = sizeof(cmd->req.cmd);
sgElement++;
sgList = StorPortGetScatterGatherList(DeviceExtension, Srb);
if (sgList)
{
sgMaxElements = sgList->NumberOfElements;
if((Srb->SrbFlags & SRB_FLAGS_DATA_OUT) == SRB_FLAGS_DATA_OUT) {
for (i = 0; i < sgMaxElements; i++, sgElement++) {
srbExt->sg[sgElement].physAddr = sgList->List[i].PhysicalAddress;
srbExt->sg[sgElement].ulSize = sgList->List[i].Length;
srbExt->Xfer += sgList->List[i].Length;
}
}
}
srbExt->out = sgElement;
srbExt->sg[sgElement].physAddr = StorPortGetPhysicalAddress(DeviceExtension, NULL, &cmd->resp.cmd, &fragLen);
srbExt->sg[sgElement].ulSize = sizeof(cmd->resp.cmd);
sgElement++;
if (sgList)
{
sgMaxElements = sgList->NumberOfElements;
if((Srb->SrbFlags & SRB_FLAGS_DATA_OUT) != SRB_FLAGS_DATA_OUT) {
for (i = 0; i < sgMaxElements; i++, sgElement++) {
srbExt->sg[sgElement].physAddr = sgList->List[i].PhysicalAddress;
srbExt->sg[sgElement].ulSize = sgList->List[i].Length;
srbExt->Xfer += sgList->List[i].Length;
}
}
}
srbExt->in = sgElement - srbExt->out;
EXIT_FN();
return TRUE;
}
SCSI_ADAPTER_CONTROL_STATUS
VioScsiAdapterControl(
IN PVOID DeviceExtension,
IN SCSI_ADAPTER_CONTROL_TYPE ControlType,
IN PVOID Parameters
)
{
PSCSI_SUPPORTED_CONTROL_TYPE_LIST ControlTypeList;
ULONG AdjustedMaxControlType;
ULONG Index;
PADAPTER_EXTENSION adaptExt;
SCSI_ADAPTER_CONTROL_STATUS status = ScsiAdapterControlUnsuccessful;
BOOLEAN SupportedConrolTypes[5] = {TRUE, TRUE, TRUE, FALSE, FALSE};
adaptExt = (PADAPTER_EXTENSION)DeviceExtension;
ENTER_FN();
RhelDbgPrint(TRACE_LEVEL_VERBOSE, ("%s %d\n", __FUNCTION__, ControlType));
switch (ControlType) {
case ScsiQuerySupportedControlTypes: {
RhelDbgPrint(TRACE_LEVEL_VERBOSE, ("ScsiQuerySupportedControlTypes\n"));
ControlTypeList = (PSCSI_SUPPORTED_CONTROL_TYPE_LIST)Parameters;
AdjustedMaxControlType =
(ControlTypeList->MaxControlType < 5) ?
ControlTypeList->MaxControlType :
5;
for (Index = 0; Index < AdjustedMaxControlType; Index++) {
ControlTypeList->SupportedTypeList[Index] =
SupportedConrolTypes[Index];
}
status = ScsiAdapterControlSuccess;
break;
}
case ScsiStopAdapter: {
RhelDbgPrint(TRACE_LEVEL_VERBOSE, ("ScsiStopAdapter\n"));
ShutDown(DeviceExtension);
status = ScsiAdapterControlSuccess;
break;
}
case ScsiRestartAdapter: {
RhelDbgPrint(TRACE_LEVEL_VERBOSE, ("ScsiRestartAdapter\n"));
VirtIODeviceReset(&adaptExt->vdev);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_SEL), (USHORT)0);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_PFN),(USHORT)0);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_SEL), (USHORT)1);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_PFN),(USHORT)0);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_SEL), (USHORT)2);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_PFN),(USHORT)0);
adaptExt->vq[0] = NULL;
adaptExt->vq[1] = NULL;
adaptExt->vq[2] = NULL;
if (!VioScsiHwInitialize(DeviceExtension))
{
RhelDbgPrint(TRACE_LEVEL_FATAL, ("Cannot Initialize HW\n"));
break;
}
status = ScsiAdapterControlSuccess;
break;
}
default:
break;
}
EXIT_FN();
return status;
}
BOOLEAN
VioScsiHwInitialize(
IN PVOID DeviceExtension
)
{
PADAPTER_EXTENSION adaptExt = (PADAPTER_EXTENSION)DeviceExtension;
PVOID ptr = adaptExt->uncachedExtensionVa;
ULONG i;
#if (MSI_SUPPORTED == 1)
MESSAGE_INTERRUPT_INFORMATION msi_info;
#endif
ENTER_FN();
adaptExt->msix_vectors = 0;
#if (MSI_SUPPORTED == 1)
while(StorPortGetMSIInfo(DeviceExtension, adaptExt->msix_vectors, &msi_info) == STOR_STATUS_SUCCESS) {
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("MessageId = %x\n", msi_info.MessageId));
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("MessageData = %x\n", msi_info.MessageData));
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("InterruptVector = %x\n", msi_info.InterruptVector));
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("InterruptLevel = %x\n", msi_info.InterruptLevel));
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("InterruptMode = %s\n", msi_info.InterruptMode == LevelSensitive ? "LevelSensitive" : "Latched"));
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("MessageAddress = %p\n\n", msi_info.MessageAddress));
++adaptExt->msix_vectors;
}
if(!adaptExt->dump_mode && (adaptExt->msix_vectors > 1)) {
adaptExt->vq[0] = FindVirtualQueue(adaptExt, 0, 1);
}
if(!adaptExt->dump_mode && (adaptExt->msix_vectors > 2)) {
adaptExt->vq[1] = FindVirtualQueue(adaptExt, 1, 2);
}
if(!adaptExt->dump_mode && (adaptExt->msix_vectors > 3)) {
adaptExt->vq[2] = FindVirtualQueue(adaptExt, 2, 3);
}
#endif
if (!adaptExt->vq[0]) {
adaptExt->vq[0] = FindVirtualQueue(adaptExt, 0, 0);
}
if (!adaptExt->vq[0]) {
RhelDbgPrint(TRACE_LEVEL_FATAL, ("Cannot find virtual queue 0\n"));
return FALSE;
}
if (!adaptExt->vq[1]) {
adaptExt->vq[1] = FindVirtualQueue(adaptExt, 1, 0);
}
if (!adaptExt->vq[1]) {
RhelDbgPrint(TRACE_LEVEL_FATAL, ("Cannot find virtual queue 1\n"));
return FALSE;
}
if (!adaptExt->vq[2]) {
adaptExt->vq[2] = FindVirtualQueue(adaptExt, 2, 0);
}
if (!adaptExt->vq[2]) {
RhelDbgPrint(TRACE_LEVEL_FATAL, ("Cannot find virtual queue 2\n"));
return FALSE;
}
adaptExt->tmf_cmd.SrbExtension = (PSRB_EXTENSION)((ULONG_PTR)adaptExt->uncachedExtensionVa + adaptExt->offset[3]);
adaptExt->events = (PVirtIOSCSIEventNode)((ULONG_PTR)adaptExt->uncachedExtensionVa + adaptExt->offset[4]);
if (!adaptExt->dump_mode && CHECKBIT(adaptExt->features, VIRTIO_SCSI_F_HOTPLUG)) {
PVirtIOSCSIEventNode events = adaptExt->events;
for (i = 0; i < 8; i++) {
if (!KickEvent(DeviceExtension, (PVOID)(&events[i]))) {
RhelDbgPrint(TRACE_LEVEL_FATAL, ("Can't add event %d\n", i));
}
}
}
StorPortWritePortUshort(DeviceExtension,
(PUSHORT)(adaptExt->device_base + VIRTIO_PCI_GUEST_FEATURES),
(USHORT)((1 << VIRTIO_SCSI_F_HOTPLUG) | (1 << VIRTIO_SCSI_F_CHANGE)));
StorPortWritePortUchar(DeviceExtension,
(PUCHAR)(adaptExt->device_base + VIRTIO_PCI_STATUS),
(UCHAR)VIRTIO_CONFIG_S_DRIVER_OK);
EXIT_FN();
return TRUE;
}
ULONG
VioScsiFindAdapter(
IN PVOID DeviceExtension,
IN PVOID HwContext,
IN PVOID BusInformation,
IN PCHAR ArgumentString,
IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
IN PBOOLEAN Again
)
{
PADAPTER_EXTENSION adaptExt;
ULONG allocationSize;
ULONG pageNum;
ULONG dummy;
ULONG Size;
#if (MSI_SUPPORTED == 1)
PPCI_COMMON_CONFIG pPciConf = NULL;
UCHAR pci_cfg_buf[256];
ULONG pci_cfg_len;
#endif
UNREFERENCED_PARAMETER( HwContext );
UNREFERENCED_PARAMETER( BusInformation );
UNREFERENCED_PARAMETER( ArgumentString );
UNREFERENCED_PARAMETER( Again );
ENTER_FN();
adaptExt = (PADAPTER_EXTENSION)DeviceExtension;
memset(adaptExt, 0, sizeof(ADAPTER_EXTENSION));
adaptExt->dump_mode = IsCrashDumpMode;
ConfigInfo->Master = TRUE;
ConfigInfo->ScatterGather = TRUE;
ConfigInfo->DmaWidth = Width32Bits;
ConfigInfo->Dma32BitAddresses = TRUE;
ConfigInfo->Dma64BitAddresses = TRUE;
ConfigInfo->WmiDataProvider = FALSE;
ConfigInfo->AlignmentMask = 0x3;
ConfigInfo->MapBuffers = STOR_MAP_NON_READ_WRITE_BUFFERS;
ConfigInfo->SynchronizationModel = StorSynchronizeFullDuplex;
#if (MSI_SUPPORTED == 1)
ConfigInfo->HwMSInterruptRoutine = VioScsiMSInterrupt;
ConfigInfo->InterruptSynchronizationMode=InterruptSynchronizePerMessage;
#endif
if (!InitHW(DeviceExtension, ConfigInfo)) {
RhelDbgPrint(TRACE_LEVEL_ERROR, ("Cannot initialize HardWare\n"));
return SP_RETURN_NOT_FOUND;
}
#if (MSI_SUPPORTED == 1)
pci_cfg_len = StorPortGetBusData (DeviceExtension,
PCIConfiguration,
ConfigInfo->SystemIoBusNumber,
(ULONG)ConfigInfo->SlotNumber,
(PVOID)pci_cfg_buf,
(ULONG)256);
if (pci_cfg_len == 256)
{
UCHAR CapOffset;
PPCI_MSIX_CAPABILITY pMsixCapOffset;
pPciConf = (PPCI_COMMON_CONFIG)pci_cfg_buf;
if ( (pPciConf->Status & PCI_STATUS_CAPABILITIES_LIST) == 0)
{
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("NO CAPABILITIES_LIST\n"));
}
else
{
if ( (pPciConf->HeaderType & (~PCI_MULTIFUNCTION)) == PCI_DEVICE_TYPE )
{
CapOffset = pPciConf->u.type0.CapabilitiesPtr;
while (CapOffset != 0)
{
pMsixCapOffset = (PPCI_MSIX_CAPABILITY)(pci_cfg_buf + CapOffset);
if ( pMsixCapOffset->Header.CapabilityID == PCI_CAPABILITY_ID_MSIX )
{
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("MessageControl.TableSize = %d\n", pMsixCapOffset->MessageControl.TableSize));
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("MessageControl.FunctionMask = %d\n", pMsixCapOffset->MessageControl.FunctionMask));
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("MessageControl.MSIXEnable = %d\n", pMsixCapOffset->MessageControl.MSIXEnable));
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("MessageTable = %p\n", pMsixCapOffset->MessageTable));
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("PBATable = %d\n", pMsixCapOffset->PBATable));
adaptExt->msix_enabled = (pMsixCapOffset->MessageControl.MSIXEnable == 1);
}
else
{
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("CapabilityID = %x, Next CapOffset = %x\n", pMsixCapOffset->Header.CapabilityID, CapOffset));
}
CapOffset = pMsixCapOffset->Header.Next;
}
RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("msix_enabled = %d\n", adaptExt->msix_enabled));
VirtIODeviceSetMSIXUsed(&adaptExt->vdev, adaptExt->msix_enabled);
}
else
{
RhelDbgPrint(TRACE_LEVEL_FATAL, ("NOT A PCI_DEVICE_TYPE\n"));
}
}
}
else
{
RhelDbgPrint(TRACE_LEVEL_FATAL, ("CANNOT READ PCI CONFIGURATION SPACE %d\n", pci_cfg_len));
}
#endif
GetScsiConfig(DeviceExtension);
ConfigInfo->NumberOfBuses = 1;
ConfigInfo->MaximumNumberOfTargets = (UCHAR)adaptExt->scsi_config.max_target;
ConfigInfo->MaximumNumberOfLogicalUnits = (UCHAR)adaptExt->scsi_config.max_lun;
if(adaptExt->dump_mode) {
ConfigInfo->NumberOfPhysicalBreaks = 8;
} else {
ConfigInfo->NumberOfPhysicalBreaks = min((MAX_PHYS_SEGMENTS + 1), adaptExt->scsi_config.seg_max);
}
ConfigInfo->MaximumTransferLength = 0x00FFFFFF;
VirtIODeviceReset(&adaptExt->vdev);
if (adaptExt->dump_mode) {
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_SEL), (USHORT)0);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_PFN),(USHORT)0);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_SEL), (USHORT)1);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_PFN),(USHORT)0);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_SEL), (USHORT)2);
StorPortWritePortUshort(DeviceExtension, (PUSHORT)(adaptExt->device_base + VIRTIO_PCI_QUEUE_PFN),(USHORT)0);
}
adaptExt->features = StorPortReadPortUlong(DeviceExtension, (PULONG)(adaptExt->device_base + VIRTIO_PCI_HOST_FEATURES));
allocationSize = 0;
adaptExt->offset[0] = 0;
VirtIODeviceQueryQueueAllocation(&adaptExt->vdev, 0, &pageNum, &Size);
allocationSize += ROUND_TO_PAGES(Size);
adaptExt->offset[1] = ROUND_TO_PAGES(Size);
VirtIODeviceQueryQueueAllocation(&adaptExt->vdev, 1, &dummy, &Size);
allocationSize += ROUND_TO_PAGES(Size);
adaptExt->offset[2] = adaptExt->offset[1] + ROUND_TO_PAGES(Size);
VirtIODeviceQueryQueueAllocation(&adaptExt->vdev, 2, &dummy, &Size);
allocationSize += ROUND_TO_PAGES(Size);
adaptExt->offset[3] = adaptExt->offset[2] + ROUND_TO_PAGES(Size);
allocationSize += ROUND_TO_PAGES(sizeof(SRB_EXTENSION));
adaptExt->offset[4] = adaptExt->offset[3] + ROUND_TO_PAGES(sizeof(SRB_EXTENSION));
allocationSize += ROUND_TO_PAGES(sizeof(VirtIOSCSIEventNode) * 8);
#if (INDIRECT_SUPPORTED == 1)
if(!adaptExt->dump_mode) {
adaptExt->indirect = CHECKBIT(adaptExt->features, VIRTIO_RING_F_INDIRECT_DESC);
}
#else
adaptExt->indirect = 0;
#endif
if(adaptExt->indirect) {
adaptExt->queue_depth = max(2, (pageNum / 4));
} else {
adaptExt->queue_depth = pageNum / ConfigInfo->NumberOfPhysicalBreaks - 1;
}
RhelDbgPrint(TRACE_LEVEL_ERROR, ("breaks_number = %x queue_depth = %x\n",
ConfigInfo->NumberOfPhysicalBreaks,
adaptExt->queue_depth));
adaptExt->uncachedExtensionVa = StorPortGetUncachedExtension(DeviceExtension, ConfigInfo, allocationSize);
if (!adaptExt->uncachedExtensionVa) {
LogError(DeviceExtension,
SP_INTERNAL_ADAPTER_ERROR,
__LINE__);
RhelDbgPrint(TRACE_LEVEL_FATAL, ("Can't get uncached extension\n"));
return SP_RETURN_ERROR;
}
return SP_RETURN_FOUND;
}