mvialcommon.c

此为marvell 6081芯片驱动源码

		}
		return MV_FALSE;
	}
	if ((regVal & 0xf) != 0x3)
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d %d]: No reconnected device found\n",
				 pSataAdapter->adapterId, channelIndex, PMPort);
		*connectStatus = 1;
	}
	return MV_TRUE;
}

static MV_BOOLEAN mvInitPMDevice(MV_IAL_COMMON_ADAPTER_EXTENSION *ialExt,
								 MV_U8 channelIndex,
								 MV_SAL_ADAPTER_EXTENSION *scsiAdapterExt,
								 MV_BOOLEAN* bIsChannelReady,
								 MV_BOOLEAN* isDeviceReconnected,
								 MV_BOOLEAN* bPMErrorDetected)
{
	MV_SATA_ADAPTER *pSataAdapter = ialExt->pSataAdapter;
	MV_U8 PMPort = ialExt->IALChannelExt[channelIndex].devInSRST;
	MV_SATA_SCSI_DRIVE_DATA *pDriveData;
	MV_STORAGE_DEVICE_REGISTERS mvStorageDevRegisters;
	MV_U32 deviceConnectionStatus = 0;
	MV_IAL_COMMON_CHANNEL_EXTENSION *channelExt =
	&ialExt->IALChannelExt[channelIndex];
	*bIsChannelReady = MV_FALSE;
	*isDeviceReconnected = MV_FALSE;
	*bPMErrorDetected = MV_FALSE;
	if (PMPort == MV_SATA_PM_CONTROL_PORT+1)
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: Buggy call fo InitPMDevice()\n",
				 pSataAdapter->adapterId, channelIndex);
		return MV_FALSE;
	}
	PMPort = channelExt->devInSRST;

	if (mvStorageIsDeviceBsyBitOff(pSataAdapter,
								   channelIndex,
								   &mvStorageDevRegisters)
		== MV_FALSE)
	{
		if (mvIsChannelTimerExpired(ialExt, channelIndex) !=
			MV_TRUE)
		{
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d %d] - disk not ready: wait a "
					 "little more\n",
					 pSataAdapter->adapterId,
					 channelIndex, PMPort);
			printAtaDeviceRegisters(&mvStorageDevRegisters);
			return MV_FALSE;
		}
		/*Skip current PM port*/
		channelExt->PMdevsToInit &= ~(1 << PMPort);
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d %d]: failed to Soft Reset PM port\n",
				 pSataAdapter->adapterId, channelIndex, PMPort);
		/*Try do do synchronous software reset tp PM*/
		mvStorageDevATASoftResetDevice(pSataAdapter,
									   channelIndex,
									   MV_SATA_PM_CONTROL_PORT,
									   NULL);
	}
	else
	{
		printAtaDeviceRegisters(&mvStorageDevRegisters);
		channelExt->PMdevsToInit &= ~(1 << PMPort);
		if (hasSataLinkStatusChanged(pSataAdapter,
									 channelIndex,
									 PMPort,
									 &deviceConnectionStatus) == MV_TRUE)
		{
			switch (deviceConnectionStatus)
			{
			case 1:
				/*Skip current PM port*/
				channelExt->PMdevsToInit &= ~(1 << PMPort);
				mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d %d]: "
						 "PM port unexpected disconnection detected\n",
						 pSataAdapter->adapterId, channelIndex, PMPort);
				break;
			case 2:
				*isDeviceReconnected = MV_TRUE;
				return MV_TRUE;
				break;
			}
		}
		else
		{
			*bPMErrorDetected = MV_TRUE;
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d %d]: failed to check SATA link "
					 "status\n",
					 pSataAdapter->adapterId, channelIndex, PMPort);
			return MV_FALSE;
		}
		if (deviceConnectionStatus == 0)
		{
			channelExt->PMdevsToInit &= ~(1 << PMPort);
			pDriveData = &scsiAdapterExt->ataDriveData[channelIndex][PMPort];
			if (mvInitSataDisk(pSataAdapter,
							   channelIndex ,
							   PMPort, &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, PMPort);
			}
			else
			{
				mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "[%d %d %d]: Disk ready\n",
						 pSataAdapter->adapterId, channelIndex, PMPort);
				mvSataScsiSetDriveReady(scsiAdapterExt, channelIndex, PMPort,
										MV_TRUE);
				mvSataScsiNotifyUA(scsiAdapterExt, channelIndex, PMPort);
			}
		}
	}
	if (!channelExt->PMdevsToInit)
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: "
				 "No more devices connected to PM.\n",
				 pSataAdapter->adapterId, channelIndex);
		if (mvPMEnableCommStatusChangeBits(ialExt,
										   channelIndex,
										   MV_TRUE) != MV_TRUE)
		{
			return MV_FALSE;
		}

		*bIsChannelReady = MV_TRUE;
		return MV_TRUE;
	}
	for (PMPort = channelExt->devInSRST;
		PMPort < channelExt->PMnumberOfPorts;
		PMPort++)
	{
		if (channelExt->PMdevsToInit & (1 << PMPort))
		{
			channelExt->devInSRST = PMPort;
			/*Clear SError on PM port*/
			if (mvPMDevWriteReg(pSataAdapter, channelIndex, PMPort,
								MV_SATA_PSCR_SERROR_REG_NUM, 0xffffffff, NULL) ==
				MV_FALSE)
			{
				*bPMErrorDetected = MV_TRUE;
				if (mvStorageDevATASoftResetDevice(pSataAdapter, channelIndex,
												   MV_SATA_PM_CONTROL_PORT, NULL) == MV_FALSE)
				{
					mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR, "[%d %d]: failed to Soft Reset PM control"
							 " port\n", pSataAdapter->adapterId, channelIndex);
				}
				return MV_FALSE;
			}

			if (mvStorageDevATAStartSoftResetDevice(pSataAdapter,
													channelIndex,
													PMPort)
				== MV_FALSE)
			{
				mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d %d]: failed to Soft Reset "
						 "PM port\n",
						 pSataAdapter->adapterId, channelIndex, PMPort);
				channelExt->PMdevsToInit &= ~(1 << PMPort);
				continue;
			}
			else
			{
				break;
			}
		}
	}
	if (PMPort == channelExt->PMnumberOfPorts)
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: "
				 "SRST failed for some PM connected devices.\n",
				 pSataAdapter->adapterId, channelIndex);
		if (mvPMEnableCommStatusChangeBits(ialExt,
										   channelIndex,
										   MV_TRUE) != MV_TRUE)
		{
			return MV_FALSE;
		}
		*bIsChannelReady = MV_TRUE;
	}
	return MV_TRUE;
}


static void mvCheckPMForError(MV_IAL_COMMON_ADAPTER_EXTENSION *ialExt,
							  MV_U8 channelIndex)
{
	MV_SATA_ADAPTER *pSataAdapter = ialExt->pSataAdapter;
	if (ialExt->IALChannelExt[channelIndex].pmAsyncNotifyEnabled == MV_TRUE)
	{
		ialExt->IALChannelExt[channelIndex].completionError = MV_FALSE;
		return;
	}
	if (pSataAdapter->sataChannel[channelIndex] == NULL)
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: "
				 "Invalid channel data structure pointer.\n",
				 pSataAdapter->adapterId, channelIndex);
		return;
	}
	if (ialExt->IALChannelExt[channelIndex].completionError == MV_TRUE)
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: "
				 "Set completion error to MV_FALSE.\n",
				 pSataAdapter->adapterId, channelIndex);
		ialExt->IALChannelExt[channelIndex].completionError = MV_FALSE;

		if (mvStorageDevGetDeviceType(pSataAdapter,channelIndex)
			== MV_SATA_DEVICE_TYPE_PM)
		{
			MV_U32 value;

			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: "
					 "Probe PM GSCR[32] register to detect possible device"
					 " hot plug.\n",
					 pSataAdapter->adapterId, channelIndex);

			mvSataDisableChannelDma(pSataAdapter, channelIndex);
			if (mvPMDevReadReg(pSataAdapter, channelIndex,
							   MV_SATA_PM_CONTROL_PORT,
							   MV_SATA_GSCR_ERROR_REG_NUM,
							   &value ,NULL) == MV_FALSE)
			{
				mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: "
						 "Failed to read GSCR register value.\n",
						 pSataAdapter->adapterId, channelIndex);
				mvSataEnableChannelDma(pSataAdapter, channelIndex);
				return;
				/*Do nothing*/
			}
			mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: "
					 "PM error information GSCR[32] register value = 0x%X\n",
					 pSataAdapter->adapterId, channelIndex, value);

			if (value != 0)
			{
				ialExt->IALChannelExt[channelIndex].PMdevsToInit =
				(MV_U16)(value & 0x7FFF);
				mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: PM Hot plug detected "
						 "Bitmask = 0x%X\n",
						 pSataAdapter->adapterId, channelIndex,
						 ialExt->IALChannelExt[channelIndex].PMdevsToInit);
				mvSetChannelState(ialExt, channelIndex,
								  CHANNEL_PM_HOT_PLUG);
			}
			else
			{
				mvSataEnableChannelDma(pSataAdapter, channelIndex);
			}
		}
	}
}

#ifdef ALLOW_NCQ
MV_BOOLEAN mvPMEnableLocking(MV_SATA_ADAPTER *pSataAdapter, MV_U8 channelIndex)
{
	MV_STORAGE_DEVICE_REGISTERS regs;
	if (mvPMDevWriteReg(pSataAdapter, channelIndex,
						MV_SATA_PM_CONTROL_PORT,
						0x89,
						0x8000003F,
						&regs) == MV_TRUE)
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: NCQ lock is enabled for PM.\n",
				 pSataAdapter->adapterId, channelIndex);
		return MV_TRUE;
	}
	else
	{
		mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG_ERROR,"[%d %d]: cannot enable NCQ lock for PM.\n",
				 pSataAdapter->adapterId, channelIndex);
		return MV_FALSE;
	}
	return MV_TRUE;
}
#endif

#ifdef DISABLE_PM_SCC
MV_BOOLEAN mvPMDisableSSC(MV_SATA_ADAPTER *pSataAdapter, MV_U8 channelIndex)
{
	MV_STORAGE_DEVICE_REGISTERS regs;
	MV_U32 regVal = 0;

	mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG,"[%d %d]: "
			 "Disable SSC for all PM ports.\n",
			 pSataAdapter->adapterId, channelIndex);

	if (mvPMDevReadReg(pSataAdapter,channelIndex, MV_SATA_PM_CONTROL_PORT,
					   MV_SATA_GSCR_FEATURES_ENABLE_REG_NUM,
					   &regVal,
					   &regs) != MV_TRUE)
	{
		return MV_FALSE;
	}

	/*Host SSC disable*/
	regVal &= ~MV_BIT2;
	if (mvPMDevWriteReg(pSataAdapter,channelIndex, MV_SATA_PM_CONTROL_PORT,
						MV_SATA_GSCR_FEATURES_ENABLE_REG_NUM,
						regVal,
						&regs) != MV_TRUE)
	{
		return MV_FALSE;
	}

	/* disable ssc for port 0*/
	if (mvPMDevWriteReg(pSataAdapter, channelIndex, MV_SATA_PM_CONTROL_PORT,
						0x8C,
						0,
						&regs) != MV_TRUE)
	{
		return MV_FALSE;
	}
	if (mvPMDevWriteReg(pSataAdapter, channelIndex, MV_SATA_PM_CONTROL_PORT,
						0x92,
						0xb02a402a,
						&regs) != MV_TRUE)
	{
		return MV_FALSE;
	}
	/* disable ssc for port 1*/
	if (mvPMDevWriteReg(pSataAdapter, channelIndex, MV_SATA_PM_CONTROL_PORT,
						0x8C,
						1,
						&regs) != MV_TRUE)
	{
		return MV_FALSE;
	}
	if (mvPMDevWriteReg(pSataAdapter, channelIndex, MV_SATA_PM_CONTROL_PORT,
						0x92,
						0xb02a402a,
						&regs) != MV_TRUE)
	{
		return MV_FALSE;
	}
	/* disable ssc for port 2*/
	if (mvPMDevWriteReg(pSataAdapter, channelIndex, MV_SATA_PM_CONTROL_PORT,
						0x8C,
						2,
						&regs) != MV_TRUE)
	{
		return MV_FALSE;
	}
	if (mvPMDevWriteReg(pSataAdapter, channelIndex, MV_SATA_PM_CONTROL_PORT,
						0x92,
						0xb02a402a,
						&regs) != MV_TRUE)
	{
		return MV_FALSE;
	}

	/* disable ssc for port 3*/
	if (mvPMDevWriteReg(pSataAdapter, channelIndex, MV_SATA_PM_CONTROL_PORT,
						0x8C,
						3,
						&regs) != MV_TRUE)
	{
		return MV_FALSE;
	}
	if (mvPMDevWriteReg(pSataAdapter, channelIndex, MV_SATA_PM_CONTROL_PORT,
						0x92,
						0xb02a402a,
						&regs) != MV_TRUE)
	{
		return MV_FALSE;
	}

	/* disable ssc for port 15*/
	if (mvPMDevWriteReg(pSataAdapter, channelIndex, MV_SATA_PM_CONTROL_PORT,
						0x8C,
						MV_SATA_PM_CONTROL_PORT,
						&regs) != MV_TRUE)
	{
		return MV_FALSE;
	}
	if (mvPMDevWriteReg(pSataAdapter, channelIndex, MV_SATA_PM_CONTROL_PORT,
						0x92,
						0xb02a402a,
						&regs) != MV_TRUE)
	{
		return MV_FALSE;
	}
	return MV_TRUE;
}
#endif

static MV_BOOLEAN mvConfigChannelQueuingMode(
											MV_IAL_COMMON_ADAPTER_EXTENSION* ialExt,
											MV_U8 channelIndex,
											MV_SAL_ADAPTER_EXTENSION *scsiAdapterExt)
{
	MV_SATA_ADAPTER *pSataAdapter = ialExt->pSataAdapter;
	MV_EDMA_MODE mode = MV_EDMA_MODE_NOT_QUEUED;
	MV_BOOLEAN isTCQSupported = MV_FALSE;
	MV_BOOLEAN isNCQSupported = MV_FALSE;
	MV_U8    queueDepth = 0;
	MV_U8    numOfDrives = 0;

	if (mvGetEDMAAllowedModes(ialExt,
							  scsiAdapterExt,
							  channelIndex,
							  &isTCQSupported,
#ifdef ALLOW_NCQ
							  &isNCQSupported,
#else
							  NULL,