⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 mvialcommon.c

📁 此为marvell 6081芯片驱动源码
💻 C
📖 第 1 页 / 共 5 页
字号:
🔍
12345 
#endif
							  &queueDepth,
							  &numOfDrives) == MV_FALSE)
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: There is no queing mode supported.\n"
				 ,pSataAdapter->adapterId, channelIndex);
		isTCQSupported = MV_FALSE;
		isNCQSupported = MV_FALSE;
		queueDepth = 0;
	}
	else
	{

		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: Supported queing mode: TCQ = %s, "
				 "NCQ = %s.\n", pSataAdapter->adapterId, channelIndex,
				 (isTCQSupported == MV_TRUE) ? "Yes" : "No",
				 (isNCQSupported == MV_TRUE) ? "Yes" : "No");
	}
	if (isTCQSupported == MV_TRUE)
	{
		mode = MV_EDMA_MODE_QUEUED;
	}
#ifdef ALLOW_NCQ
	if (isNCQSupported == MV_TRUE)
	{
		if ((pSataAdapter->sataChannel[channelIndex] != NULL) &&
			(pSataAdapter->sataChannel[channelIndex]->deviceType ==
			 MV_SATA_DEVICE_TYPE_PM))
		{

			MV_SATA_PM_DEVICE_INFO PMDeviceInfo;
			if (mvGetPMDeviceInfo(pSataAdapter,
								  channelIndex,
								  &PMDeviceInfo) == MV_TRUE)
			{
				if (PMDeviceInfo.vendorId == 0x11AB)
				{
					mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: Marvell PM found, "
							 "NCQ lock is supported.\n",
							 pSataAdapter->adapterId, channelIndex);
				}
				else
				{
					mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: NCQ lock not supported by current "
							 "PM. Vendor Id = 0x%X\n",
							 pSataAdapter->adapterId,
							 channelIndex,
							 PMDeviceInfo.vendorId);
					if (numOfDrives > 1)
					{
						isNCQSupported = MV_FALSE;
					}
				}
				mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: Enable NCQ locking for PM.\n",
						 pSataAdapter->adapterId, channelIndex);
				if (mvPMEnableLocking(pSataAdapter, channelIndex) == MV_FALSE)
				{
					isNCQSupported = MV_FALSE;
				}
			}
			else
			{
				mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: unable to get PM info.\n",
						 pSataAdapter->adapterId, channelIndex);
				isNCQSupported = MV_FALSE;
			}

		}
		if (isNCQSupported == MV_TRUE)
		{
			mode = MV_EDMA_MODE_NATIVE_QUEUING;
		}
		else
		{
			mode = MV_EDMA_MODE_NOT_QUEUED;
			queueDepth = 0;
		}
	}
#else
	if (isTCQSupported != MV_TRUE)
	{
		queueDepth = 0;
	}
#endif

	mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: EDMA mode %d, queue depth = %d.\n",
			 pSataAdapter->adapterId, channelIndex, mode, queueDepth);
	IALConfigQueuingMode(pSataAdapter,
						 channelIndex,
						 mode,
						 queueDepth);
	return MV_TRUE;
}



/*Channel related functions*/

static void mvSetChannelState(MV_IAL_COMMON_ADAPTER_EXTENSION *ialExt,
							  MV_U8 channelIndex,
							  MV_CHANNEL_STATE state)
{
	if (ialExt->channelState[channelIndex] != state)
	{
		if ((state == CHANNEL_READY) || (state == CHANNEL_NOT_CONNECTED))
		{
			ialExt->IALChannelExt[channelIndex].SRSTTimerThreshold = 0;
			ialExt->IALChannelExt[channelIndex].SRSTTimerValue = 0;
		}
		if (state == CHANNEL_READY)
		{
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: CHANNEL_READY\n",
					 ialExt->pSataAdapter->adapterId,
					 channelIndex);
			ialExt->IALChannelExt[channelIndex].pmRegAccessInProgress
			= MV_FALSE;
			ialExt->IALChannelExt[channelIndex].completionError = MV_FALSE;
			ialExt->channelState[channelIndex] = state;
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d] flush pending queue\n",
					 ialExt->pSataAdapter->adapterId, channelIndex);
			/*Abort all pending commands in SW queue*/
			mvFlushSCSICommandQueue(ialExt, channelIndex);
		}
		else
		{
			ialExt->channelState[channelIndex] = state;
		}
	}
}


static MV_BOOLEAN mvStartChannelInit(MV_SATA_ADAPTER *pSataAdapter,
									 MV_U8 channelIndex,
									 MV_SAL_ADAPTER_EXTENSION *scsiAdapterExt,
									 MV_BOOLEAN* bIsChannelReady)
{
	*bIsChannelReady = MV_FALSE;

	if (mvSataConfigureChannel(pSataAdapter, channelIndex) == MV_FALSE)
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: configure channel failed\n",
				 pSataAdapter->adapterId,
				 channelIndex);
		return MV_FALSE;
	}

	mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: start channel\n",
			 pSataAdapter->adapterId,
			 channelIndex);

	/*Just check SStatus in case of SATA I adapter*/
	if (pSataAdapter->sataAdapterGeneration == MV_SATA_GEN_I)
	{
#if 0
		MV_SATA_SCSI_DRIVE_DATA *pDriveData;
		/*ATA_IDENTIFY_INFO IdentifyInfo;*/
		MV_STORAGE_DEVICE_REGISTERS mvStorageDevRegisters;

		MV_SATA_DEVICE_TYPE deviceType;
		if (mvStorageIsDeviceBsyBitOff(pSataAdapter,
									   channelIndex,
									   &mvStorageDevRegisters)
			== MV_FALSE)
		{
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: SATA I drive not ready yet\n",
					 pSataAdapter->adapterId,
					 channelIndex);
			return MV_TRUE;
		}
		deviceType = mvGetSataDeviceType(&mvStorageDevRegisters);
		if (deviceType != MV_SATA_DEVICE_TYPE_ATA_DISK)
		{
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: ERROR: unknown device type\n",
					 pSataAdapter->adapterId, channelIndex);
			return MV_FALSE;
		}
		pDriveData =
		&scsiAdapterExt->ataDriveData[channelIndex][0];
		if (mvInitSataDisk(pSataAdapter, channelIndex,
						   0,
						   &pDriveData->identifyInfo,
						   pDriveData->identifyBuffer) == MV_FALSE)
		{
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d %d]: Failed to Initialize Disk\n",
					 pSataAdapter->adapterId, channelIndex, 0);
			return MV_FALSE;
		}
		pDriveData->LBA48Supported = pDriveData->identifyInfo.LBA48Supported;
		pDriveData->readAheadSupported =
		pDriveData->identifyInfo.readAheadSupported;
		pDriveData->writeCacheSupported =
		pDriveData->identifyInfo.writeCacheSupported;
		pDriveData->ATADiskSize = pDriveData->identifyInfo.ATADiskSize;
		mvSataScsiSetDriveReady(scsiAdapterExt,
								channelIndex, 0, MV_TRUE);
		mvSataScsiNotifyUA(scsiAdapterExt,
						   channelIndex, 0);
		*bIsChannelReady = MV_TRUE;
#else
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: starting SATA I channel.\n",
				 pSataAdapter->adapterId, channelIndex);
#endif
	}
	else
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: starting SATA II channel.\n",
				 pSataAdapter->adapterId, channelIndex);
	}

	return mvStorageDevATAStartSoftResetDevice(pSataAdapter,
											   channelIndex,
											   MV_SATA_PM_CONTROL_PORT);
}

static MV_BOOLEAN mvChannelSRSTFinished(MV_SATA_ADAPTER *pSataAdapter,
										MV_SATA_CHANNEL *pSataChannel,
										MV_U8 channelIndex,
										MV_SAL_ADAPTER_EXTENSION *scsiAdapterExt,
										MV_BOOLEAN* bIsChannelReady,
										MV_BOOLEAN* bFatalError)
{
	MV_SATA_DEVICE_TYPE deviceType;
	MV_STORAGE_DEVICE_REGISTERS mvStorageDevRegisters;
	/*ATA_IDENTIFY_INFO IdentifyInfo;*/
	MV_SATA_SCSI_DRIVE_DATA *pDriveData;
	*bIsChannelReady = MV_FALSE;
	*bFatalError = MV_FALSE;
	if (pSataAdapter->sataAdapterGeneration != MV_SATA_GEN_I)
	{
		if (mvStorageIsDeviceBsyBitOff(pSataAdapter,
									   channelIndex,
									   &mvStorageDevRegisters)
			== MV_FALSE)
		{
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: soft Reset PM control port "
					 "in progress\n",
					 pSataAdapter->adapterId, channelIndex);
			printAtaDeviceRegisters(&mvStorageDevRegisters);
			return MV_FALSE;
		}
		deviceType = mvGetSataDeviceType(&mvStorageDevRegisters);
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: soft reset SATA II channel - "
				 "device ready.\n",
				 pSataAdapter->adapterId, channelIndex);
	}
	else
	{
		if (mvStorageIsDeviceBsyBitOff(pSataAdapter,
									   channelIndex,
									   &mvStorageDevRegisters)
			== MV_FALSE)
		{
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: soft reset of SATA I channel "
					 "in progress\n",
					 pSataAdapter->adapterId, channelIndex);
			printAtaDeviceRegisters(&mvStorageDevRegisters);
			return MV_FALSE;
		}
		deviceType = mvGetSataDeviceType(&mvStorageDevRegisters);
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: soft reset SATA I channel - "
				 "device ready.\n",
				 pSataAdapter->adapterId, channelIndex);
		deviceType = mvGetSataDeviceType(&mvStorageDevRegisters);
		if (deviceType != MV_SATA_DEVICE_TYPE_ATA_DISK)
		{
			deviceType = MV_SATA_DEVICE_TYPE_UNKNOWN;
		}

	}
	switch (deviceType)
	{
	case MV_SATA_DEVICE_TYPE_ATA_DISK:
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: ATA disk found\n",
				 pSataAdapter->adapterId, channelIndex);
		if (mvStorageDevSetDeviceType(pSataAdapter,channelIndex, deviceType) == MV_FALSE)
		{
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: Failed to initialize disk\n",
					 pSataAdapter->adapterId, channelIndex);
			*bFatalError = MV_TRUE;
			return MV_FALSE;

		}
		pDriveData = &scsiAdapterExt->ataDriveData[channelIndex][0];
		if (mvInitSataDisk(pSataAdapter,
						   channelIndex,
						   0,
						   &pDriveData->identifyInfo,
						   pDriveData->identifyBuffer) == MV_FALSE)
		{
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: Failed to initialize disk\n",
					 pSataAdapter->adapterId, channelIndex);
			*bFatalError = MV_TRUE;
			return MV_FALSE;
		}
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: Disk ready\n",
				 pSataAdapter->adapterId, channelIndex);
		mvSataScsiSetDriveReady(scsiAdapterExt,
								channelIndex,
								0,
								MV_TRUE);
		mvSataScsiNotifyUA(scsiAdapterExt, channelIndex, 0);
		*bIsChannelReady = MV_TRUE;
		return MV_TRUE;
		break;
	case MV_SATA_DEVICE_TYPE_PM:
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: PortMultiplier device found\n",
				 pSataAdapter->adapterId, channelIndex);
		if (mvStorageDevSetDeviceType(pSataAdapter,channelIndex, deviceType) == MV_FALSE)
		{
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: Failed to initialize PM\n",
					 pSataAdapter->adapterId, channelIndex);
			*bFatalError = MV_TRUE;
			return MV_FALSE;

		}
		break;
	case MV_SATA_DEVICE_TYPE_ATAPI_DISK:
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR, "[%d %d]: ERROR: ATAPI device was found!!! "
				 "(not supported)\n", pSataAdapter->adapterId,
				 channelIndex);
		*bFatalError = MV_TRUE;
		return MV_FALSE;
		break;
	default:
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: ERROR: unknown device type\n",
				 pSataAdapter->adapterId, channelIndex);
		*bFatalError = MV_TRUE;
		return MV_FALSE;
	}
	return MV_TRUE;
}



static MV_BOOLEAN mvConfigChannelDMA(
									MV_IAL_COMMON_ADAPTER_EXTENSION* ialExt,
									MV_U8 channelIndex,
									MV_SAL_ADAPTER_EXTENSION *scsiAdapterExt)
{
	MV_SATA_ADAPTER *pSataAdapter = ialExt->pSataAdapter;
	mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d] config queueing mode\n",
			 pSataAdapter->adapterId, channelIndex);


	if (mvConfigChannelQueuingMode(ialExt,
								   channelIndex,
								   scsiAdapterExt)
		== MV_FALSE)
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d] Failed to config DMA queuing\n",
				 pSataAdapter->adapterId, channelIndex);
		return MV_FALSE;
	}
	/* Enable EDMA */
	if (mvSataEnableChannelDma(pSataAdapter, channelIndex) == MV_FALSE)
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d] Failed to enable DMA, channel=%d\n",
				 pSataAdapter->adapterId, channelIndex);
		return MV_FALSE;
	}
	mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: channel started successfully\n",
			 pSataAdapter->adapterId, channelIndex);
	return MV_TRUE;
}





static void mvSetChannelTimer(MV_IAL_COMMON_ADAPTER_EXTENSION *ialExt,
							  MV_U8 channelIndex,
							  MV_U32 timeout)
{
	ialExt->IALChannelExt[channelIndex].SRSTTimerThreshold = timeout;
	ialExt->IALChannelExt[channelIndex].SRSTTimerValue = 1;
}

static void mvDecrementChannelTimer(MV_IAL_COMMON_ADAPTER_EXTENSION *ialExt,
									MV_U8 channelIndex)
{
	if (ialExt->IALChannelExt[channelIndex].SRSTTimerThreshold > 0)
	{
		ialExt->IALChannelExt[channelIndex].SRSTTimerValue +=
		MV_IAL_ASYNC_TIMER_PERIOD;
	}
}

static MV_BOOLEAN mvIsChannelTimerExpired(
										 MV_IAL_COMMON_ADAPTER_EXTENSION *ialExt,
										 MV_U8 channelIndex)
{
	if (ialExt->IALChannelExt[channelIndex].SRSTTimerValue >
		ialExt->IALChannelExt[channelIndex].SRSTTimerThreshold)
	{
		return MV_TRUE;
	}
	else
	{
		return MV_FALSE;
	}
}

/*******************************************************************************
*State Machine related functions:
*  Return MV_TRUE to proceed to the next channel
*  Return MV_FALSE to proceed to the next state on current channel
*******************************************************************************/

static MV_BOOLEAN mvChannelNotConnected
12345

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -