idetask.c

epson usb2.0 控制芯片 S1R72V05 固件程序。

			DeviceType = IDE_DEV_ATA;
		} else if( ( DeviceType == IDE_FUNC_CD ) || ( DeviceType == IDE_FUNC_MO ) ) {
			DeviceType = IDE_DEV_ATAPI;
		} else {
			DeviceType = IDE_DEV_NOT;
		}
	}

	/*----------------------------------------------------------------------*/
	/* When at DirectCopy,USB task waiting for that IDE joined to Channel FIFO */
	/*----------------------------------------------------------------------*/
	if(IdeTsk_CmdPara.xferMode == IDE_XFER_DIRECT) {
		joinFlag = 0;
		while(1) {
			for(i = CHA_NUM; i <= CHE_NUM; i++) {
				// Get the address of register
				REG_H_CHX_WINDOW_ADDR( prsH_CHxWindow, i );
				prxH_CHxWindow = (volatile REG_rxH_CHxWindow *)prsH_CHxWindow;
				joinFlag |= ( prxH_CHxWindow->rcH_CHxJoin & MASK_JoinIDE );
			}
			if(joinFlag) break;
			/* Interval to do polling */
			OS_DlyTsk(WAIT_JOIN);
		}
	}

	/*----------------------------------------------------------------------*/
	/* Process command													*/
	/*----------------------------------------------------------------------*/
	if( DeviceType == IDE_DEV_ATA ){	/* Check connected device		*/
		/*------------------------------------------------------------------*/
		/* The connected device is ATA									*/
		/*------------------------------------------------------------------*/
		if( IdeTsk_CmdPara.cmdType == IDE_CMD_ATAPI ){

			/* Because the received command is ATAPI, when the connected
			device is ATA, determine the process mode of conver command that
			convert APAPI command to the ATA command 						*/
			result = ATAPICommandCheck( DeviceType, &IdeTsk_CmdPara,
										&IdeTsk_CmdError[DeviceNo],&errInfo );
			if( result != STATUS_SUCCESS ){
				// Mod for USBCV MSC Test
				SendMessageNTFY_IDE_CMD( errInfo, 0 );
				// End of USBCV MSC Test
				return STATUS_SUCCESS;
			}
										/* Save the total transfer size */
			IdeTsk_CmdPara.allSize = IdeTsk_CmdPara.dataSize;
			/*--------------------------------------------------------------*/
			/* Check the type of the connected ATA device 				*/
			/*--------------------------------------------------------------*/
			if( DeviceList.bigDrive[DeviceNo] != IDE_FUNC_HDD_BIG ){
										/* Whether the command is divided is judged, except for Big Drive.	*/
				/*--------------------------------------------------------------*/
				/* Whether the command is divided is judged */
				/*--------------------------------------------------------------*/
				if( IdeTsk_CmdPara.dataSize >= (IDE_ATA_SECTOR * 256) ){
											/* When necessary, modify the number of sectors in the command.
											  Change to Maximum 256 sectors command */
					CommandLengthMake( &IdeTsk_CmdPara.deviceCmdBlock[0], 0 );
											/* Set the process size again	*/
					IdeTsk_CmdPara.dataSize = (IDE_ATA_SECTOR * 256);
				}
			}

			else if( IdeTsk_CmdPara.dataSize >= 0x1000000 ) {
											/* It is necessary to divide when the setting number of IDE Counter above (0x1000000).	 */
											/* Change to the maximum 0xFFFFFF Byte command */
					CommandLengthMake( &IdeTsk_CmdPara.deviceCmdBlock[0], (0xFFFFFF / IDE_ATA_SECTOR) );
											/* Set the process size again	*/
					IdeTsk_CmdPara.dataSize = ( (0xFFFFFF / IDE_ATA_SECTOR) * IDE_ATA_SECTOR );
			}

			/*--------------------------------------------------------------*/
										/* It receives the ATAPI command though the device is ATA.
 */
			IdeCmdPara.commandMode = IDE_FUNC_ATAPI;
		}
		else if( IdeTsk_CmdPara.cmdType == IDE_CMD_ATA ){
										/* Determine the command processing mode */
			ATACommandCheck( DeviceType, &IdeTsk_CmdPara );
			IdeTsk_CmdPara.dataMode = GetDataProtocol( IdeTsk_CmdPara.cmdBlock[6] /*[6] is Cmd Reg */);
										/* Save the total transfer size  */
			IdeTsk_CmdPara.allSize = IdeTsk_CmdPara.dataSize;

			IdeCmdPara.commandMode = IDE_FUNC_ATA;/* ATA command 		*/
		}

		StatusChange( IDE_MSTS_CMDEXEC );/* Executing command state 		*/
										/* ATA command protocol 		*/
		ATACmd_Main( IDE_TASK_EVT_MSG_CMD );
	}
	else if( DeviceType == IDE_DEV_ATAPI ){
		/*------------------------------------------------------------------*/
		/* The connected device is ATAPI 								*/
		/*------------------------------------------------------------------*/

		result = ATAPICommandCheck( DeviceType, &IdeTsk_CmdPara,
												&IdeTsk_CmdError[DeviceNo],&errInfo);
		if( result != STATUS_SUCCESS ){
			IDESetSenseKey( SENSE_HARDWARE_ERROR, &IdeTsk_CmdError[DeviceNo] );
			// Mod for USBCV MSC Test
			SendMessageNTFY_IDE_CMD( errInfo, 0 );
			// End of USBCV MSC Test
			return STATUS_SUCCESS;
		}
		IdeTsk_CmdPara.allSize = IdeTsk_CmdPara.dataSize;

		/* The reception command is output as it is.  */
		if( IdeTsk_CmdPara.cmdType == IDE_CMD_ATAPI ){
			IdeCmdPara.commandMode = IDE_FUNC_ATAPI;/* ATAPI command 	*/
		}
		else if( IdeTsk_CmdPara.cmdType == IDE_CMD_ATA ){
			IdeCmdPara.commandMode = IDE_FUNC_ATA;/* ATA command 		*/
		}

		StatusChange( IDE_MSTS_CMDEXEC );/* Executing command state 		*/
										/* ATA command protocol 		*/
		ATAPICmd_Main( IDE_TASK_EVT_MSG_CMD );
	}
	else{
		/*------------------------------------------------------------------*/
		/* The connected device is not clear							*/
		/*------------------------------------------------------------------*/
		result = ATAPICommandCheck( DeviceType, &IdeTsk_CmdPara,
												&IdeTsk_CmdError[DeviceNo],&errInfo);
		if( result != STATUS_SUCCESS ){
			IDESetSenseKey( SENSE_HARDWARE_ERROR, &IdeTsk_CmdError[DeviceNo] );
			// Mod for USBCV MSC Test
			SendMessageNTFY_IDE_CMD( errInfo, 0 );
			// End of USBCV MSC Test
			return STATUS_SUCCESS;
		}
										/* Save the total transfer size */
		IdeTsk_CmdPara.allSize = IdeTsk_CmdPara.dataSize;

		StatusChange( IDE_MSTS_CMDEXEC );/* Executing command state 		*/
										/* ATA command protocol 		*/
		ATACmd_Main( IDE_TASK_EVT_MSG_CMD );
	}

	return STATUS_SUCCESS;
}

/*
//=============================================================================
// Function_Name: IDE_CmdExec_Proc
// description	:
// argument		:
// return		:
// flag			:
// global		:
//=============================================================================
*/
static LONG IDE_CmdExec_Proc( PMSGIDE pMsg )
{
LONG	result;
PARAM_MSG_NTFY_IDE_XFER_CMP		xferData;
PARAM_MSG_REQ_IDE_XFER_START	*msg;


	switch ( pMsg->msgHead.msgNo )		/* Judgement on the receive message number */
	{
		case MSG_REQ_IDE_XFER_START:	/* IDE data transfer request	*/
			/*--------------------------------------------------------------*/
			/* Check the parameter of the received message				*/
			/*--------------------------------------------------------------*/
										/* The Data field of the received message */
			msg = (PARAM_MSG_REQ_IDE_XFER_START *)pMsg->msgData;

			result = XferStart_ParaCheck( msg );
			if( result == STATUS_SUCCESS ){
				IdeTsk_CmdPara.bufferPtr = msg->bufferPtr;

				if( DeviceType == IDE_DEV_ATA ){/* Check the connected device */
					ATACmd_Main( IDE_TASK_EVT_MSG_START );/* Processing of ATA command */
				}
				else if( DeviceType == IDE_DEV_ATAPI ){
					ATAPICmd_Main( IDE_TASK_EVT_MSG_START );/* Processing of ATAPI command */
				}
				else{
					ATACmd_Main( IDE_TASK_EVT_MSG_START );/* Processing of ATA command */
				}
			}
			else{
				xferData.result = IDE_REQ_NG;
										/* Send message 				*/
				if( RegRead( REG08_HostDeviceSel ) & BIT_HOSTxDEVICE_HOST ){
					SendMessage( MBXID_USBH_SAMPLE, MSG_NTFY_IDE_XFER_CMP,
								sizeof(PARAM_MSG_NTFY_IDE_XFER_CMP), &xferData );
				} else {
					SendMessage( MBXID_DEVICE, MSG_NTFY_IDE_XFER_CMP,
								sizeof(PARAM_MSG_NTFY_IDE_XFER_CMP), &xferData );
				}
			}
			break;

		default:						/* Can not occur	 			*/
			break;
	}

	return STATUS_SUCCESS;
}

/*
//=============================================================================
// Function_Name: IDECmd_ParaCheck
// description	:
// argument		:
// return		:
// flag			:
// global		:
//=============================================================================
*/
static LONG IDECmd_ParaCheck( PARAM_MSG_REQ_IDE_CMD *msg )
{
	switch( msg->cmdType )				/* Command type  				*/
	{
		case IDE_CMD_ATAPI:
		case IDE_CMD_ATA:
			break;
		default:
			return STATUS_INVALID_PARAMETER;
	}
	if( msg->LUN >= MAX_DEVICE ){		/* Logical unit Number			*/
		return STATUS_INVALID_PARAMETER;
	}
	switch( msg->opeMode )
	{
		case IDE_CMD_AUTO:
			switch( msg->xferMode )		/* Transfer mode				*/
			{
				case IDE_XFER_DMA:		/* DMA transfer					*/
				case IDE_XFER_HPIO:		/* Byte PIO transfer			*/
				case IDE_XFER_DIRECT:	/* DirectCopy transfer 			*/
					break;
				case IDE_XFER_SPIO:		/* Soft POI  transfer 			*/
					if( msg->bufferPtr == NULL ){/* pointer of the transfer memory */
						return STATUS_INVALID_PARAMETER;
					}
					break;
				default:
					return STATUS_INVALID_PARAMETER;
			}
			break;
		case IDE_CMD_MANUAL:
			switch( msg->xferMode )		/* Transfer mode				*/
			{
				case IDE_XFER_DMA:		/* DMA transfer					*/
				case IDE_XFER_HPIO:		/* Byte PIO transfer			*/
				case IDE_XFER_SPIO:		/* DirectCopy transfer 			*/
				case IDE_XFER_DIRECT:	/* DirectCopy transfer 			*/
					break;
				default:
					return STATUS_INVALID_PARAMETER;
			}
			break;
		default:
			return STATUS_INVALID_PARAMETER;
	}
	return STATUS_SUCCESS;
}

/*
//=============================================================================
// Function_Name:
// description	:
// argument		:
// return		:
// flag			:
// global		:
//=============================================================================
*/
static LONG IDECmd_ParaSave( PARAM_MSG_REQ_IDE_CMD *msg )
{
	memcpy( IdeTsk_CmdPara.cmdBlock, msg->IDECmd, sizeof(IdeTsk_CmdPara.cmdBlock) );
	IdeTsk_CmdPara.cmdType		= msg->cmdType;
	IdeTsk_CmdPara.LUN			= msg->LUN;
	IdeTsk_CmdPara.opeMode		= msg->opeMode;
	IdeTsk_CmdPara.xferMode 	= msg->xferMode;
	IdeTsk_CmdPara.reqDataLen	= msg->reqDataLen;
	IdeTsk_CmdPara.bufferPtr	= msg->bufferPtr;
	IdeTsk_CmdPara.pfnCallback	= msg->pfnCallback;
	IdeTsk_CmdPara.xferDir      = msg->xferDir;
	return STATUS_SUCCESS;
}

/*
//=============================================================================
// Function_Name: ATACmd_Main
// description	:
// argument		:
// return		:
// flag			:
// global		:
//=============================================================================
*/
LONG ATACmd_Main( UCHAR event )
{

	switch( IdeTsk_Inf.sState )
	{
		/*------------------------------------------------------------------*/
		/* Idle Phase 													*/
		/*------------------------------------------------------------------*/
		case IDE_SSTS_IDLE:
			switch( event )
			{
				case IDE_TASK_EVT_MSG_CMD:
										/* Judgment on the command processing mode	*/
					if( IdeTsk_CmdPara.opeMode == IDE_CMD_AUTO ){
						ATACmd_Auto();	/* Process auto mode */
										/* All auto modes are processed here.  */
					}
					else{
						ATACmd_OutManual();/* Process manual mode 		*/
					}
					break;
				default:
					break;
			}
			break;
		/*------------------------------------------------------------------*/
		/* Command Phase												*/
		/*------------------------------------------------------------------*/
		case IDE_SSTS_COMMAND:
			switch( event )
			{
				case IDE_TASK_EVT_INT:	/* Interrupt event(INTRQ) 		*/
					ATACmd_OutINTRQWait();
					break;
				default:
					break;
			}
			break;
		/*------------------------------------------------------------------*/
		/* Data Transfer Phase											*/
		/*------------------------------------------------------------------*/
		case IDE_SSTS_XFER:
			switch( event )
			{
				case IDE_TASK_EVT_MSG_START:
					ATACmd_XferStart();
					break;
				default:
					break;
			}
			break;
		/*------------------------------------------------------------------*/
		/* Stattus Phase												*/
		/*------------------------------------------------------------------*/
		case IDE_SSTS_STATUS:
			switch( event )
			{
				case IDE_TASK_EVT_INT:	/* Interrupt event(INTRQ) 		*/
					ATACmd_StatusINTRQWait();
					break;
				default:
					break;
			}
			break;
		default:
			break;
	}

	return STATUS_SUCCESS;
}

/*
//=============================================================================
// Function_Name: ATACmd_OutManual
// description	:
// argument		:
// return		:
// flag			:
// global		:
//=============================================================================
*/
LONG ATACmd_OutManual( void )
{

PARAM_MSG_NTFY_IDE_CMP_XFER_READY		rdyData;
UCHAR		i;