VOID
GetScsiConfig(
IN PVOID DeviceExtension
)
{
PADAPTER_EXTENSION adaptExt = (PADAPTER_EXTENSION)DeviceExtension;
ENTER_FN();
adaptExt->features = StorPortReadPortUlong(DeviceExtension, (PULONG)(adaptExt->device_base + VIRTIO_PCI_HOST_FEATURES));
VirtIODeviceGet( &adaptExt->vdev, FIELD_OFFSET(VirtIOSCSIConfig, seg_max),
&adaptExt->scsi_config.seg_max, sizeof(adaptExt->scsi_config.seg_max));
VirtIODeviceGet( &adaptExt->vdev, FIELD_OFFSET(VirtIOSCSIConfig, num_queues),
&adaptExt->scsi_config.num_queues, sizeof(adaptExt->scsi_config.num_queues));
VirtIODeviceGet( &adaptExt->vdev, FIELD_OFFSET(VirtIOSCSIConfig, max_sectors),
&adaptExt->scsi_config.max_sectors, sizeof(adaptExt->scsi_config.max_sectors));
VirtIODeviceGet( &adaptExt->vdev, FIELD_OFFSET(VirtIOSCSIConfig, cmd_per_lun),
&adaptExt->scsi_config.cmd_per_lun, sizeof(adaptExt->scsi_config.cmd_per_lun));
VirtIODeviceGet( &adaptExt->vdev, FIELD_OFFSET(VirtIOSCSIConfig, event_info_size),
&adaptExt->scsi_config.event_info_size, sizeof(adaptExt->scsi_config.event_info_size));
VirtIODeviceGet( &adaptExt->vdev, FIELD_OFFSET(VirtIOSCSIConfig, sense_size),
&adaptExt->scsi_config.sense_size, sizeof(adaptExt->scsi_config.sense_size));
VirtIODeviceGet( &adaptExt->vdev, FIELD_OFFSET(VirtIOSCSIConfig, cdb_size),
&adaptExt->scsi_config.cdb_size, sizeof(adaptExt->scsi_config.cdb_size));
VirtIODeviceGet( &adaptExt->vdev, FIELD_OFFSET(VirtIOSCSIConfig, max_channel),
&adaptExt->scsi_config.max_channel, sizeof(adaptExt->scsi_config.max_channel));
VirtIODeviceGet( &adaptExt->vdev, FIELD_OFFSET(VirtIOSCSIConfig, max_target),
&adaptExt->scsi_config.max_target, sizeof(adaptExt->scsi_config.max_target));
VirtIODeviceGet( &adaptExt->vdev, FIELD_OFFSET(VirtIOSCSIConfig, max_lun),
&adaptExt->scsi_config.max_lun, sizeof(adaptExt->scsi_config.max_lun));
EXIT_FN();
}
static u32 ReadVirtIODeviceRegister(ULONG_PTR ulRegister)
{
if (ulRegister & ~PORT_MASK) {
return StorPortReadRegisterUlong(NULL, (PULONG)(ulRegister));
} else {
return StorPortReadPortUlong(NULL, (PULONG)(ulRegister));
}
}
u32 ReadVirtIODeviceRegister(ULONG_PTR ulRegister)
{
return StorPortReadPortUlong(NULL, (PULONG)(ulRegister));
}
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;
}
