scsi2sata.c

来自「6440linuxDriver的源代码」· C语言 代码 · 共 1,717 行 · 第 1/4 页

	)
{
	if( (pReq->Cdb[4]&0xF0) != 0 )
	{
		SCSI_ATA_CheckCondition( pReq, SCSI_SK_ILLEGAL_REQUEST, 
				SCSI_ASC_INVALID_FEILD_IN_CDB );
		return;
	}

}

/***************************************************************************
* SCSI_ATA_TestUnitReadyTranslation
* Purpose: Test Unit Ready cmd translation
*
***************************************************************************/
void SCSI_ATA_TestUnitReadyTranslationCallback(
	IN MV_PVOID This,
	IN PMV_Request pReq
	)
{
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)This;
	PSATA_FIS_REG_H2D pFIS = (PSATA_FIS_REG_H2D)pCore->RX_FIS;

	// 6th byte
	if(pFIS->LBA_High & 0x1)
	{
		SCSI_ATA_CheckCondition(pReq, SCSI_SK_NOT_READY, 
				SCSI_ASC_LOGICAL_UNIT_NOT_RESP_TO_SEL );
	}
	pReq->Scsi_Status = SCSI_STATUS_GOOD;
}

/***************************************************************************
* SCSI_ATA_TestUnitReadyTranslation
* Purpose: Test Unit Ready cmd translation
*
***************************************************************************/
void SCSI_ATA_TestUnitReadyTranslation(
	IN PDomain_Device pDevice,
	IN PMV_Request pReq, 
	OUT PATA_TaskFile pTaskFile
	)
{
	if( pDevice->State == DEVICE_STATE_FORMAT_WRITE || 
		pDevice->State == DEVICE_STATE_FORMAT_VERIFY )
	{
		SCSI_ATA_CheckCondition( pReq, SCSI_SK_NOT_READY, 
				SCSI_ASC_LUN_NOT_READY );
		return;
	}

	pReq->Completion = SCSI_ATA_TestUnitReadyTranslationCallback;
	pTaskFile->Command = ATA_CMD_PM_CHECK;
}

/***************************************************************************
* SCSI_ATA_RequestSenseTranslation
* Purpose: Request sense translation
*
***************************************************************************/
void SCSI_ATA_RequestSenseTranslation(
	IN PDomain_Device pDevice,
	IN PMV_Request pReq, 
	OUT PATA_TaskFile pTaskFile
	)
{
	if( pDevice->State == DEVICE_STATE_FORMAT_WRITE || 
		pDevice->State == DEVICE_STATE_FORMAT_VERIFY )
	{
		SCSI_ATA_CheckCondition( pReq, SCSI_SK_NOT_READY, 
				SCSI_ASC_LUN_NOT_READY );
		return;
	}

	if( pDevice->Capacity & DEVICE_SETTING_SMART_ENABLED )
	{
		// MRIE is set to 6h
		// DExcpt bit is set to 0
		SCSI_ATA_CheckCondition( pReq, 
				SCSI_ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED, 
				SCSI_ASCQ_HIF_GENERAL_HD_FAILURE );
	}

	pTaskFile->Command	= 0xB0;
	pTaskFile->Features = ATA_CMD_SMART_RETURN_STATUS;
	
}

/***************************************************************************
* ATA_CDB2TaskFile
* Purpose: Convert Cdb SCSI to ATA taskfile 
*
***************************************************************************/
MV_BOOLEAN ATA_CDB2TaskFile(
	IN PDomain_Device pDevice,
	IN PMV_Request pReq, 
	IN MV_U8 tag,
	OUT PATA_TaskFile pTaskFile
	)
{
	//ATA_TaskFile TaskFiletemp;
	//MV_BOOLEAN status = MV_TRUE;
	MV_ZeroMemory(pTaskFile, sizeof(ATA_TaskFile));
	//MV_ZeroMemory(&TaskFiletemp, sizeof(ATA_TaskFile));
    switch ( pReq->Cdb[0] )
	{
		case SCSI_CMD_FORMAT_UNIT:
			if(FirstRun)
			{
				pDevice->State = DEVICE_STATE_FORMAT_WRITE;
				FirstRun = MV_FALSE;
			}
			SCSI_ATA_FormatUnitTranslation(pDevice, pReq, pTaskFile);
			break;
		case SCSI_CMD_INQUIRY:
			SCSI_ATA_InquiryTranslation( pReq, pTaskFile );
			break;
		case SCSI_CMD_LOG_SENSE:
			SCSI_ATA_LogSenseTranslation( pDevice, pReq, pTaskFile );
			break;
		case SCSI_CMD_MODE_SELECT_6:
		case SCSI_CMD_MODE_SELECT_10:
			SCSI_ATA_ModeSelectTranslation( pDevice, pReq, pTaskFile);
			break;
		case SCSI_CMD_MODE_SENSE_6:
		case SCSI_CMD_MODE_SENSE_10:
			SCSI_ATA_ModeSenseTranslation( pDevice, pReq, pTaskFile );
			break;
		case SCSI_CMD_READ_10:
		case SCSI_CMD_WRITE_10:
		case SCSI_CMD_READ_16:
		case SCSI_CMD_WRITE_16:
			SCSI_ATA_ReadWriteTranslation( pReq, tag, pTaskFile );
			break;
		case SCSI_CMD_READ_CAPACITY_10:
		case SCSI_CMD_READ_CAPACITY_16:
			SCSI_ATA_ReadCapacityTranslation( pReq, pTaskFile );
			break;
		case SCSI_CMD_VERIFY_10:
		case SCSI_CMD_VERIFY_16:
			SCSI_ATA_VerifyTranslation( pReq, pTaskFile );
			break;
		case SCSI_CMD_SYNCHRONIZE_CACHE_10:
		case SCSI_CMD_SYNCHRONIZE_CACHE_16:
			SCSI_ATA_SyncCacheTranslation(pDevice, pReq, pTaskFile);
			break;
		case SCSI_CMD_SND_DIAG:
			SCSI_ATA_SendDiagTranslation( pReq, pTaskFile );
			break;
		case SCSI_CMD_START_STOP_UNIT:
			//SCSI_ATA_StartStopTranslation(pReq, pTaskFile );
			if (pReq->Cdb[4] & MV_BIT(0))
			{
				pTaskFile->Command = ATA_CMD_SEEK;
				pTaskFile->Device = MV_BIT(6);
			}
			else
			{
				pTaskFile->Command = ATA_CMD_STANDBY_IMMEDIATE;
			}
			break;
		case SCSI_CMD_TEST_UNIT_READY:
			SCSI_ATA_TestUnitReadyTranslation( pDevice, pReq, pTaskFile );
			break;
		case SCSI_CMD_REQUEST_SENSE:
			SCSI_ATA_RequestSenseTranslation( pDevice, pReq, pTaskFile );
			break;
		case SCSI_CMD_MARVELL_SPECIFIC:
			{
				/* This request should be for core module */
				if ( pReq->Cdb[1]!=CDB_CORE_MODULE )
					return MV_FALSE;
				switch ( pReq->Cdb[2] )
				{
					case CDB_CORE_SOFT_RESET_1:
						pTaskFile->Control = MV_BIT(2);
						break;

					case CDB_CORE_SOFT_RESET_0:
						pTaskFile->Control = 0;
						break;

					case CDB_CORE_IDENTIFY:
						pTaskFile->Command = ATA_CMD_IDENTIFY_ATA;
						break;
					
					case CDB_CORE_SET_UDMA_MODE:
						pTaskFile->Command = ATA_CMD_SET_FEATURES;
						pTaskFile->Features = ATA_CMD_SET_TRANSFER_MODE;
						pTaskFile->Sector_Count = 0x40 | pReq->Cdb[3];
						MV_DASSERT( pReq->Cdb[4]==MV_FALSE );	/* Use UDMA mode */
						//TBD: Check the 80-conductor cable in order to enable UDMA greater than 2.
						break;

					case CDB_CORE_SET_PIO_MODE:
						pTaskFile->Command = ATA_CMD_SET_FEATURES;
						pTaskFile->Features = ATA_CMD_SET_TRANSFER_MODE;
						pTaskFile->Sector_Count = 0x08 | pReq->Cdb[3];
						break;

					case CDB_CORE_ENABLE_WRITE_CACHE:
						pTaskFile->Command = ATA_CMD_SET_FEATURES;
						pTaskFile->Features = ATA_CMD_ENABLE_WRITE_CACHE;
						break;
			
					case CDB_CORE_DISABLE_WRITE_CACHE:
						pTaskFile->Command = ATA_CMD_SET_FEATURES;
						pTaskFile->Features = ATA_CMD_DISABLE_WRITE_CACHE;
						break;

					case CDB_CORE_ENABLE_SMART:
						pTaskFile->Command = ATA_CMD_SMART;
						pTaskFile->Features = ATA_CMD_ENABLE_SMART;
						pTaskFile->LBA_Mid = 0x4F;
						pTaskFile->LBA_High = 0xC2;
						break;

					case CDB_CORE_DISABLE_SMART:
						pTaskFile->Command = ATA_CMD_SMART;
						pTaskFile->Features = ATA_CMD_DISABLE_SMART;
						pTaskFile->LBA_Mid = 0x4F;
						pTaskFile->LBA_High = 0xC2;
						break;

					case CDB_CORE_SMART_RETURN_STATUS:
						pTaskFile->Command = ATA_CMD_SMART;
						pTaskFile->Features = ATA_CMD_SMART_RETURN_STATUS;
						pTaskFile->LBA_Mid = 0x4F;
						pTaskFile->LBA_High = 0xC2;
						break;

					case CDB_CORE_SHUTDOWN:
						if ( pDevice->Capacity&DEVICE_CAPACITY_48BIT_SUPPORTED )
							pTaskFile->Command = ATA_CMD_FLUSH_EXT;
						else
							pTaskFile->Command = ATA_CMD_FLUSH;
						break;

					case CDB_CORE_ENABLE_READ_AHEAD:	
						pTaskFile->Command = ATA_CMD_SET_FEATURES;
						pTaskFile->Features = ATA_CMD_ENABLE_READ_LOOK_AHEAD;
						break;

					case CDB_CORE_DISABLE_READ_AHEAD:
						pTaskFile->Command = ATA_CMD_SET_FEATURES;
						pTaskFile->Features = ATA_CMD_DISABLE_READ_LOOK_AHEAD;
						break;
					
					case CDB_CORE_READ_LOG_EXT:
						pTaskFile->Command = ATA_CMD_READ_LOG_EXT;
						pTaskFile->Sector_Count = 1;	/* Read one sector */
						pTaskFile->LBA_Low = 0x10;		/* Page 10h */
						break;

					case CDB_CORE_PM_READ_REG:
						pTaskFile->Command = ATA_CMD_PM_READ;
						pTaskFile->Features = pReq->Cdb[4];
						pTaskFile->Device = pReq->Cdb[3];
						break;

					case CDB_CORE_OS_SMART_CMD:
						{
						    pTaskFile->Command = pReq->Cdb[3];
						    pTaskFile->Features = pReq->Cdb[4];
						    pTaskFile->LBA_Low = pReq->Cdb[5];
						    pTaskFile->LBA_Mid  = pReq->Cdb[6];
						    pTaskFile->LBA_High = pReq->Cdb[7];
						    pTaskFile->LBA_Low_Exp = pReq->Cdb[9];
						    pTaskFile->Sector_Count = pReq->Cdb[8];
						    break;
						}

					case CDB_CORE_PM_WRITE_REG:
						pTaskFile->Command = ATA_CMD_PM_WRITE;
						pTaskFile->Features = pReq->Cdb[4];
						pTaskFile->Device = pReq->Cdb[3];
						pTaskFile->LBA_Low = pReq->Cdb[5];
						pTaskFile->LBA_Mid = pReq->Cdb[6];
						pTaskFile->LBA_High = pReq->Cdb[7];
						pTaskFile->Sector_Count = pReq->Cdb[8];
						break;

					default:
						return MV_FALSE;
				}
				break;
			}
		#ifndef _OS_BIOS	
			MV_DPRINT(("Error: Unknown request: 0x%x.\n", pReq->Cdb[0]));
		#endif

		default:
			return MV_FALSE;
	}

	return MV_TRUE;
}

MV_BOOLEAN ATAPI_CDB2TaskFile(
	IN PDomain_Device pDevice,
	IN PMV_Request pReq, 
	OUT PATA_TaskFile pTaskFile
	)
{
	MV_ZeroMemory(pTaskFile, sizeof(ATA_TaskFile));

	/* At the same time, set the command category as well. */
    switch ( pReq->Cdb[0] )
	{
		case SCSI_CMD_MARVELL_SPECIFIC:
			/* This request should be for core module */
			if ( pReq->Cdb[1]!=CDB_CORE_MODULE )
				return MV_FALSE;

			switch ( pReq->Cdb[2] )
			{
				case CDB_CORE_SOFT_RESET_1:
					pTaskFile->Control = MV_BIT(2);
					break;

				case CDB_CORE_SOFT_RESET_0:
					pTaskFile->Control = 0;
					break;

				case CDB_CORE_IDENTIFY:
					pTaskFile->Command = ATA_CMD_IDENTIY_ATAPI;
					break;
							
				case CDB_CORE_SET_UDMA_MODE:
					pTaskFile->Command = ATA_CMD_SET_FEATURES;
					pTaskFile->Features = ATA_CMD_SET_TRANSFER_MODE;
					if ( pReq->Cdb[4]==MV_TRUE )
						pTaskFile->Sector_Count = 0x20 | pReq->Cdb[3];	/* MDMA mode */
					else
						pTaskFile->Sector_Count = 0x40 | pReq->Cdb[3];	/* UDMA mode*/

					//TBD: Check the 80-conductor cable in order to enable UDMA greater than 2.
					break;
							
				case CDB_CORE_SET_PIO_MODE:
					pTaskFile->Command = ATA_CMD_SET_FEATURES;
					pTaskFile->Features = ATA_CMD_SET_TRANSFER_MODE;
					pTaskFile->Sector_Count = 0x08 | pReq->Cdb[3];
					break;

				case CDB_CORE_PM_READ_REG:
					pTaskFile->Command = ATA_CMD_PM_READ;
					pTaskFile->Features = pReq->Cdb[4];
					pTaskFile->Device = pReq->Cdb[3];
					break;

				case CDB_CORE_PM_WRITE_REG:
					pTaskFile->Command = ATA_CMD_PM_WRITE;
					pTaskFile->Features = pReq->Cdb[4];
					pTaskFile->Device = pReq->Cdb[3];
					pTaskFile->LBA_Low = pReq->Cdb[5];
					pTaskFile->LBA_Mid = pReq->Cdb[6];
					pTaskFile->LBA_High = pReq->Cdb[7];
					pTaskFile->Sector_Count = pReq->Cdb[8];
					break;
		                case CDB_CORE_OS_SMART_CMD:
		                //Now we don't support SMART on ATAPI device.
				default:
					return MV_FALSE;
			}
			break;

		case SCSI_CMD_READ_10:
		case SCSI_CMD_WRITE_10:
		case SCSI_CMD_VERIFY_10:
		case SCSI_CMD_INQUIRY:
		case SCSI_CMD_READ_CAPACITY_10:
		case SCSI_CMD_TEST_UNIT_READY:
		case SCSI_CMD_MODE_SENSE_10:
		case SCSI_CMD_MODE_SELECT_10:
		case SCSI_CMD_PREVENT_MEDIUM_REMOVAL:
		case SCSI_CMD_READ_TOC:
		case SCSI_CMD_BLANK:
		case SCSI_CMD_READ_DISC_INFO:
		case SCSI_CMD_START_STOP_UNIT:
		case SCSI_CMD_SYNCHRONIZE_CACHE_10:
		case SCSI_CMD_REQUEST_SENSE:
		default:
		/* 
		 * Use packet command 
		 */
		/* Features: DMA, OVL, DMADIR */
#if defined(USE_DMA_FOR_ALL_PACKET_COMMAND)
			if ( !(pReq->Cmd_Flag&CMD_FLAG_NON_DATA) )
			{
				//if ( pReq->Cdb[0]!=SCSI_CMD_INQUIRY ) //ATAPI???
				pTaskFile->Features |= MV_BIT(0);
			}
#elif defined(USE_PIO_FOR_ALL_PACKET_COMMAND)
			/* do nothing */
#else
			if ( pReq->Cmd_Flag&CMD_FLAG_DMA )
				//if ( SCSI_IS_READ(pReq->Cdb[0]) || 
				//   SCSI_IS_WRITE(pReq->Cdb[0]) )
				pTaskFile->Features |= MV_BIT(0);
#endif
			//TBD: OVL: overlapped.
			//TBD: DMADIR in IDENTIFY PACKET DEVICE word 62

			//TBD: Sector Count: Tag

			/* Byte count low and byte count high */
			if ( pReq->Data_Transfer_Length>0xFFFF )
			{
				pTaskFile->LBA_Mid = 0xFF;
				pTaskFile->LBA_High = 0xFF;
			}
			else
			{
				pTaskFile->LBA_Mid = (MV_U8)pReq->Data_Transfer_Length;
				pTaskFile->LBA_High = (MV_U8)(pReq->Data_Transfer_Length>>8);
			}

			pTaskFile->Command = ATA_CMD_PACKET;

		break;
	}

	return MV_TRUE;
}