usbh_ide_if.c

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

	if(USBH_IDE_IFIntrqCompCBR[deviceNo] != NULL){
		/* CALLBACK had benn registrated */
		return STATUS_UNABLE_TO_REGISTER;
	}

	/* Register CALLBACK */
	USBH_IDE_IFIntrqCompCBR[deviceNo] = pfnNotifyIntrqComp;

	return STATUS_SUCCESS;
}

/*=============================================================================================
// Function_Name: USBH_IDE_IFUnregisterCBRIntrqComp
//
// description	: Delete the command completion callback function
//
//				  When the asynchronous command completed,delete the callback fucntiont that used for notification.
//
// argument 	: deviceNo							(in)Device No.
//				  pfnNotifyDMAComp					(in)Pointer of the callback function
//
// return		: STATUS_SUCCESS					Complete the process normally
//				  STATUS_UNSUCCESSFUL				Error occured during the process
//				  STATUS_UNREGISTERED				It is not registered.
===============================================================================================*/
LONG USBH_IDE_IFUnregisterCBRIntrqComp( USHORT deviceNo, CALLBACK_PROC pfnNotifyIntrqComp )
{
	/* Check callback registration */
	if(USBH_IDE_IFIntrqCompCBR[deviceNo] != pfnNotifyIntrqComp){
		/* CALLBACK had not been registered */
		return STATUS_UNREGISTERED;
	}

	/* Delete CALLBACK */
	USBH_IDE_IFIntrqCompCBR[deviceNo] = NULL;

	return STATUS_SUCCESS;
}

/*=============================================================================================
// Function_Name: USBH_IDE_MakeIdeCmd
//
// description	: Generate the command data that send to IDE Task
//
//				  Generate the command data,when transfer data,does not set the send pointer.
// argument 	: deviceNo							(in)Device No.
//				  opeCode							(in)IDE Command OPE Code
//				  *pIdeCmd							(in)Pointer to IDE Task command structure
//
// return		: STATUS_SUCCESS					Complete the process normally
//				  STATUS_UNSUCCESSFUL				Error occured during the process
===============================================================================================*/
LONG USBH_IDE_MakeIdeCmd( USHORT deviceNo, UCHAR opeCode, PARAM_MSG_REQ_IDE_CMD *pIdeCmd)
{

	switch(opeCode) {
		case TEST_UNIT_READY:
			pIdeCmd->IDECmd[0] = TEST_UNIT_READY;
			pIdeCmd->IDECmd[1] = deviceNo << 5;
			break;
		case REQUEST_SENSE:
			pIdeCmd->IDECmd[0] = REQUEST_SENSE;
			pIdeCmd->IDECmd[1] = deviceNo << 5;
			pIdeCmd->IDECmd[4] = REQSENSE_LENGTH;			/* Get Sense Data,18Bytes */
			pIdeCmd->opeMode = IDE_CMD_AUTO;				/* Command Auto Mode */
			break;
		case INQUIRY:
			pIdeCmd->IDECmd[0] = INQUIRY;
			pIdeCmd->IDECmd[1] = deviceNo << 5;
			pIdeCmd->IDECmd[4] = INQUIRY_LENGTH;			/* Get Inquiry Data,36Bytes */
			pIdeCmd->opeMode = IDE_CMD_AUTO;				/* Command Auto Mode */
			break;
		case READ_FORMAT_CAPACITY:
			pIdeCmd->IDECmd[0] = READ_FORMAT_CAPACITY;
			pIdeCmd->IDECmd[1] = deviceNo << 5;
			pIdeCmd->IDECmd[4] = RDFORMCAPA_LENGTH;
			pIdeCmd->opeMode = IDE_CMD_AUTO;				/* Command Auto Mode */
			break;
		case READ_CAPACITY:
			pIdeCmd->IDECmd[0] = READ_CAPACITY;
			pIdeCmd->IDECmd[1] = deviceNo << 5;
			pIdeCmd->opeMode = IDE_CMD_AUTO;				/* Command Auto Mode */
			break;
		case READ10:
			pIdeCmd->IDECmd[0] = READ10;
			pIdeCmd->IDECmd[1] = deviceNo << 5;
			pIdeCmd->opeMode = IDE_CMD_MANUAL;				/* Command MANUAL Mode */
			break;
		case WRITE10:
			pIdeCmd->IDECmd[0] = WRITE10;
			pIdeCmd->IDECmd[1] = deviceNo << 5;
			pIdeCmd->opeMode = IDE_CMD_MANUAL;				/* Command MANUAL Mode */
			break;
		default:
			/* It doesn't come.  */
			break;
	}

	/* Common settings */
	pIdeCmd->LUN = deviceNo;
	pIdeCmd->cmdType = IDE_CMD_ATAPI;				/* Command Type ATAPI */

	return STATUS_SUCCESS;

}

/*
//=============================================================================
// Function_Name: USBH_IDE_SendMessage
// description	: Refer to V03 software basic specification P10 "Figure 3-4 Basic flow when sending event".
// argument		: OS_ID mbxId
//				: USHORT msgCode
//				: USHORT size
//				: const VOID* buffer
// return		: none
//=============================================================================
*/
Inline void USBH_IDE_SendMessage ( OS_ID mbxId, USHORT msgCode, USHORT size, const VOID* buffer )
{
	USBH_SAMPLE_MSG* pMsg;

	OS_GetMpf( MPFID_USBH_SAMPLE_MSG, (VP *)&pMsg );			// Get the message buffer

	//========================================================================
	// initialize the message header section
	//========================================================================
	pMsg->msgHead.msgSndTskId = TSKID_USBH_SAMPLE;
	pMsg->msgHead.useMpfId = MPFID_USBH_SAMPLE_MSG;
	pMsg->msgHead.msgNo = msgCode;
	pMsg->msgHead.msgLength = size;
	memcpy( pMsg->msgData, buffer, size );

	OS_SndMbx( mbxId, (OS_T_MSG *)pMsg );			// Send message


	OS_SetFlg( FLGID_IDE, FLG_EVENT_MSG_IDE );
}

/*=============================================================================================
// Function_Name: ReadMediaFIFOData
//
// description	: Read the data from MediaFIFO
//
//				  Read the data from MediaFIFO,Copy to the specified buffer
//
// argument 	: *pBufAdrs					pointer of the buffer
//
// return		: Number of bytes actually read
===============================================================================================*/
unsigned long ReadMediaFIFOData( unsigned char *pBufAdrs )
{
	unsigned long copyCount;
	unsigned short fifoCount, readData;
	unsigned char fraction;
	unsigned int i;
	unsigned short *pTempBufAdrs;

	RegSet( REG08_MediaFIFO_Join, BIT_JoinCPU_Rd );

	do{
		fifoCount = RegRead( REG16_FIFO_RdRemain );
	}while((fifoCount & MASK_RD_REMAIN_VALID) == 0 );
	fifoCount &= ~MASK_RD_REMAIN_VALID;

	if( fifoCount != 0 ){
		/* There is data in the FIFO */

		fraction = fifoCount & MASK_FRACTION;
		if( ((unsigned long)pBufAdrs & MASK_FRACTION) == 0 ){
			/* Buffer pointer is even address */

			pTempBufAdrs = (unsigned short *)pBufAdrs;
			for( i = (fifoCount / 2); i > 0; i-- ){
				readData = RegRead( REG16_FIFO_Rd );
				*(pTempBufAdrs++) = readData;
			}
			pBufAdrs = (unsigned char *)pTempBufAdrs;
		} else {
			/* Buffer pointer is odd address */

			for( i = (fifoCount / 2); i > 0; i-- ){
				*(pBufAdrs++) = RegRead( REG08_FIFO_ByteRd );
				*(pBufAdrs++) = RegRead( REG08_FIFO_ByteRd );
			}
		}
		if( fraction != 0 ){
			/*There is a fraction at the end*/

			*(pBufAdrs++) = RegRead( REG08_FIFO_ByteRd );
		}
	}
	RegClear( REG08_MediaFIFO_Join, BIT_JoinCPU_Rd );

	copyCount = (unsigned long)fifoCount;
	return copyCount;
}

/*=============================================================================================
// Function_Name: WriteMediaFIFOData
//
// description	: Write data to the FIFO
//
//				  Write the data from the specified buffer to the FIFO.
//
// argument 	: *pBufAdrs					Pointer of the buffer
//				  dataSize					Write data size
//
// return		: The number of bytes that actually wrote
===============================================================================================*/
unsigned long WriteMediaFIFOData( unsigned char *pBufAdrs, unsigned long dataSize )
{
	unsigned long copyCount;
	unsigned short fifoCount, writeData;
	unsigned char fraction;
	unsigned int i;
	unsigned short *pTempBufAdrs;


	if( dataSize == 0 ){
		fifoCount = 0;
	} else {
		RegSet( REG08_MediaFIFO_Join, BIT_JoinCPU_Wr );
		fifoCount = RegRead( REG16_FIFO_WrRemain );
		if( fifoCount != 0 ){
			/* There is room in FIFO */

			fraction = fifoCount & MASK_FRACTION;
			if( ((unsigned long)pBufAdrs & MASK_FRACTION) == 0 ){
				/* Buffer pointer is even address */

				pTempBufAdrs = (unsigned short *)pBufAdrs;
				for( i = (fifoCount / 2); i > 0; i-- ){
					writeData = *(pTempBufAdrs++);
					RegWrite( REG16_FIFO_Wr, writeData );
				}
				pBufAdrs = (unsigned char *)pTempBufAdrs;
			} else {
				/* Buffer pointer is odd address */

				for( i = (fifoCount / 2); i > 0; i-- ){
					RegWrite( REG08_FIFO_Wr_0, *(pBufAdrs++) );
					RegWrite( REG08_FIFO_Wr_1, *(pBufAdrs++) );
				}
			}
			if( fraction != 0 ){
				/* There is a fraction at the end. */

				RegWrite( REG08_FIFO_Wr_0, *(pBufAdrs++) );
			}
		}
		RegClear( REG08_MediaFIFO_Join, BIT_JoinCPU_Wr );
	}
	copyCount = (unsigned long)fifoCount;
	return copyCount;
}

/*=============================================================================================
// Function_Name: USBH_IDE_DirecCopyCallback
//
// description	: DirectCopy callback function
//
//				  Execute DirectCopy completion process.
//
// argument 	: deviceNo							(in)device No.
//				  tranTotalSize						(in)Real transfer size
//				  *pParam							Reserved
//
// return		: None
===============================================================================================*/
LONG USBH_IDE_DirectCopyCallback( ULONG deviceNo, ULONG tranTotalSize, void *pParam )
{
	USBH_IDE_IFIntrqCompCBR[deviceNo] (deviceNo, 0x00, 0x00);
	USBH_IDE_IFDMACompCBR[deviceNo] (deviceNo, 0x00, 0x00);

	devicePara[deviceNo].deviceStatus = DRV_FUNC_CMD_COMP;
	devicePara[deviceNo].commandStatus = NO_OP;
	devicePara[deviceNo].transferSize = tranTotalSize;

#ifdef USBH_IDE_IF_COMMAND_PRINT
	DBG_FlowStrPrint("[Status[IDE(DirectCopy)]:", 1);
	DBG_FlowValPrint(PRINT_HEXA_MODE, DBG_STORE_BYTE, (UCHAR)deviceNo, 1);
	DBG_FlowStrPrint("]\r\n", 1);
#endif

	return STATUS_SUCCESS;
}


/*=============================================================================================
// Function_Name: USBH_IDE_FinishPMCallback
//
// description	: PowerManagement completion callback
//
//				  Carry out the PowerManagement completion process
//
// argument 	: event								(in)Message
//				  param1							Reserved
//				  *pParam							Reserved
//
// return		: STATUS_SUCCESS					Complete the process normally
//				  STATUS_UNSUCCESSFUL				Error occured during the process
===============================================================================================*/

LONG USBH_IDE_FinishPMCallback( ULONG event, ULONG param1, void *pParam )
{
	if(event == USBH_HCDS_HC_PM_STATE_ACTIVE60) {
		/* Set the PM State transfer completion flag  */
		OS_SetFlg(FLGID_USBH_SAMPLE, FLG_EVENT_FINISH_PM_USBH_SAMPLE);
		return STATUS_SUCCESS;

	} else {
		return STATUS_UNSUCCESSFUL;
	}
}

/*=============================================================================
// Function_Name: MsgIdeXferReady
//
// description	: Process the IDE data transfer is ready nofication from the IDE task.
//
// argument		: USBH_SAMPLE_MSG pMsg
//
// return		: none
//=============================================================================
*/
void MsgIdeXferReady ( UCHAR deviceNo, USBH_SAMPLE_MSG *pMsg )
{
	unsigned char				*pSrcAdrs, *pDesAdrs;
	ULONG						dataCount;
	CALLBACK_PROC				pfnCPUDMACallback;
	volatile REG_rxDMAxWindow	*prxDMAxWindow;
	volatile unsigned short 	*prsDMAxWindow;
	PARAM_MSG_NTFY_IDE_CMP_XFER_READY	*pXferReady;

	pXferReady = (PARAM_MSG_NTFY_IDE_CMP_XFER_READY *)pMsg->msgData;

	//========================================================================
	// Confirm number of data transfers.
	//========================================================================
	if( pXferReady->xferCount == 1 ) {