dobotmsclass.c

16位单片机H8的例子源代码

/*
****************************************************************************
					H I T A C H I    P R O P R I E T A R Y

	COPYRIGHT (c)	2001 BY Semiconductor & Integrated Circuits,Hitachi,Ltd.
						---  ALL RIGHTS RESERVED  ---

	File Name	:DoBOTMSClass.c
	Working		:Executing MassStorageClass Bulk-Only transfer
	Modified	:Rev 2001_10_15 {Author : T.Ishikawa}
	Modified	:Rev 2001_09_28 {Author : T.Ishikawa}
	Created		:Rev 1.0 {Author : T.Ishikawa[2001.Jan.10]}
****************************************************************************
*/

#ifndef SysMemMap
#include	"SysMemMap.h"
#endif	/*	SysMemMap	*/

#ifndef CatProType
#include	"CatProType.h"
#endif	/*	CatProType	*/

#include	"SetBOTInfo.h"



/*	Prototype	*/
void				ActBulkOnly(unsigned long ,unsigned char ,unsigned char );
void				ActBulkOnlyCommand(unsigned long ,unsigned char );
void				ActBulkOnlyIn(unsigned long ,unsigned char );
void				ActBulkOnlyOut(unsigned long ,unsigned char );



/*	Contents	*/
/***************************************************************************
Function Name	:ActBulkOnly(unsigned long ,unsigned char ,unsigned char )
Working			:Executing Bulk-Only Transport State
Return Value	:void
Modified		:{Author : T.Ishikawa[2001.Oct.15]}
Modified		:{Author : T.Ishikawa[2001.Aug.09]}
Created			:{Author : T.Ishikawa[2001.Jan.10]}
***************************************************************************/
void	ActBulkOnly(unsigned long interruptBitStreamLVar ,unsigned char epInfoNumberLVar ,unsigned char dataBuffNumberLVar) {

	if (EpInfo[SET_BOT_USE_OUT_EP].PresentState == TRANS_OUT) {
	/*	BOT's data stage is TRANS_OUT	*/
		ActBulkOnlyOut(interruptBitStreamLVar,SET_BOT_USE_OUT_EP);
	}
	else if (EpInfo[SET_BOT_USE_OUT_EP].PresentState == TRANS_IN) {
	/*	BOT's data stage is TRANS_IN	*/
		ActBulkOnlyIn(interruptBitStreamLVar,SET_BOT_USE_IN_EP);
	}
	else if ((EpInfo[SET_BOT_USE_OUT_EP].PresentState == WAIT) && (interruptBitStreamLVar & EP1_FULL_BIT)) {
	/*	BOT's data stage is WAIT and occurring EP1_FULL	interrupt */
		ActBulkOnlyCommand(interruptBitStreamLVar,SET_BOT_USE_OUT_EP);
	}
	else {
	/*	not apply	*/
		/*	clear EP2_TR flag	*/
		BULK_ITFF_CLEAR
	}
}



/***************************************************************************
Function Name	:ActBulkOnlyCommand(unsigned long ,unsigned char )
Working			:Executing Bulk-Only Transport CBW
Return Value	:void
Modified		:{Author : T.Ishikawa[2001.Aug.09]}
Created			:{Author : T.Ishikawa[2001.Jan.10]}
***************************************************************************/
void	ActBulkOnlyCommand(unsigned long interruptBitStreamLVar ,unsigned char epInfoNumberLVar) {

	short 			byteLVar = 0;	/*		*/
	
	/*	clear interrupt flag	*/
	BULK_OTSF_CLEAR
	
	/*	set up data buffer pointers	*/
	dataBuffGPtr[SET_BOT_CSWCBW_INFO].AccessDataType.WriteType.startPtr = &cbwDataGVar->byteVal[0];
	dataBuffGPtr[SET_BOT_CSWCBW_INFO].AccessDataType.WriteType.endPtr = &cbwDataGVar->byteVal[30] + 1;
	dataBuffGPtr[SET_BOT_CSWCBW_INFO].beginAriaPtr = &cbwDataGVar->byteVal[0];
	dataBuffGPtr[SET_BOT_CSWCBW_INFO].endAriaPtr = &cbwDataGVar->byteVal[30] + 1;
	
	/*	read CBW	*/
	byteLVar = ActBulkOut(interruptBitStreamLVar,epInfoNumberLVar,SET_BOT_CSWCBW_INFO);
	
	/*	check CBW	*/
	if ((byteLVar != 31) || (cbwDataGVar->cbwMeaningType.dCBWSignature != 0x55534243)) {
		BOT_IN_EP_STALL_ON
		return;
	}
	
	/*	make CSW	*/
	cswDataGVar->cswMeaningType.dCSWSignature = 0x55534253;
	cswDataGVar->cswMeaningType.dCSWTag = cbwDataGVar->cbwMeaningType.dCBWTag;
	cswDataGVar->cswMeaningType.bCSWStatus = 0x00;
	
	/*	change CBW data transfer length from little endian to big endian	*/
	/*	becouse of recognizing HOST expectant data length */
	cbwDataGVar->cbwMeaningType.dCBWDataTransferLength = ConvReflexn((unsigned char*)&cbwDataGVar->cbwMeaningType.dCBWDataTransferLength,4);
	
	/*	Control firmware state decoding CBW Data Transport direction	*/
	if (cbwDataGVar->cbwMeaningType.bmCBWFlags == 0) {
	/*	Data direction is HOST to Function	*/
		EpInfo[SET_BOT_USE_OUT_EP].PresentState = TRANS_OUT;
		/*	mask EP2_EMPTY interrupt */
		SET_BULK_IN_INTERRUPT2
		/*	enable EP2_TR interrupt */
		SET_BULK_IN_INTERRUPT3
	}
	else {
	/*	Data direction is Function to HOST	*/
		EpInfo[SET_BOT_USE_OUT_EP].PresentState = TRANS_IN;
		/*	enable EP2_EMPTY interrupt	*/
		SET_BULK_IN_INTERRUPT1
	}
	
	/*	read Interrupt enable flag	*/
	GET_INTERRUPT_ENABLE
	
	/*	decode to command and SCSI tansfer data length for HOST	*/
	cswDataGVar->cswMeaningType.dCSWDataResidue = DecBotCmd();
	
	if ((cbwDataGVar->cbwMeaningType.dCBWDataTransferLength == 0) && (cswDataGVar->cswMeaningType.dCSWDataResidue != 0)) {
	/*	HOST expectant data length = 0  and  Function expectant data length != 0	*/
		cswDataGVar->cswMeaningType.bCSWStatus = 0x02;
	}
	
	/*	clear EP2_TR interrupt flag	*/
	BULK_ITFF_CLEAR
}



/***************************************************************************
Function Name	:ActBulkOnlyIn(unsigned long ,unsigned char )
Working			:Executing Data Transport and Status Transport
				:in case data stage direction is IN
Return Value	:void
Modified		:{Author : T.Ishikawa[2001.Aug.09]}
Created			:{Author : T.Ishikawa[2001.Jan.10]}
***************************************************************************/
void	ActBulkOnlyIn(unsigned long interruptBitStreamLVar ,unsigned char epInfoNumberLVar) {

		short		byteLVar = 0;

	if (cbwDataGVar->cbwMeaningType.dCBWDataTransferLength != 0) {
	/*	exist transfer data		Data Transport	*/
		
		if ((cswDataGVar->cswMeaningType.bCSWStatus == 0x00) && (cswDataGVar->cswMeaningType.dCSWDataResidue >= EpInfo[epInfoNumberLVar].MaxPacketSize)) {
		/*	status is 0x00 and transfer data size is over MaxPacketSize	*/
			
			byteLVar = ActBulkIn(interruptBitStreamLVar,SET_BOT_USE_IN_EP,SET_BOT_DATA_INFO);
			
			/*	calculate data length	*/
			cbwDataGVar->cbwMeaningType.dCBWDataTransferLength -= byteLVar;
			cswDataGVar->cswMeaningType.dCSWDataResidue -= byteLVar;
		}
		
		else if (cswDataGVar->cswMeaningType.bCSWStatus != 0x00) {
		/*	there is not transfer data , Function transfers data all 0 value up to HOST expectant data length	*/
			
			/*	set up data buffer pointers	*/
			dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.startPtr = &returnData->byteVal[0];
			dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.endPtr = &returnData->byteVal[(cbwDataGVar->cbwMeaningType.dCBWDataTransferLength)];
			dataBuffGPtr[SET_BOT_DATA_INFO].beginAriaPtr = dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.startPtr;
			dataBuffGPtr[SET_BOT_DATA_INFO].endAriaPtr = &returnData->byteVal[64];	/*	data buffer size is 64byte	*/
			if (dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.endPtr < dataBuffGPtr[SET_BOT_DATA_INFO].endAriaPtr) {
				dataBuffGPtr[SET_BOT_DATA_INFO].endAriaPtr = dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.endPtr;
			}
			else {
			/*	HOST expectant data length > Function expectant data length	*/
				dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.endPtr = dataBuffGPtr[SET_BOT_DATA_INFO].endAriaPtr;
			}
			
			byteLVar = ActBulkIn(interruptBitStreamLVar,SET_BOT_USE_IN_EP,SET_BOT_DATA_INFO);
			
			/*	calculate data length	*/
			cbwDataGVar->cbwMeaningType.dCBWDataTransferLength -= byteLVar;
			cswDataGVar->cswMeaningType.dCSWDataResidue += byteLVar;
		}
		
		else {
		/*	another case	*/
			
			/*	copy transfer data to work area	*/
			while (byteLVar <= cswDataGVar->cswMeaningType.dCSWDataResidue) {
				returnData->byteVal[byteLVar] = *dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.startPtr;
				byteLVar++;
				dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.startPtr++;
			}
			
			/*	set up data buffer pointers	*/
			dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.startPtr = &returnData->byteVal[0];
			dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.endPtr = &returnData->byteVal[(cbwDataGVar->cbwMeaningType.dCBWDataTransferLength)];
			dataBuffGPtr[SET_BOT_DATA_INFO].beginAriaPtr = dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.startPtr;
			dataBuffGPtr[SET_BOT_DATA_INFO].endAriaPtr = &returnData->byteVal[64];	/*	data buffer size is 64byte	*/
			if (dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.endPtr < dataBuffGPtr[SET_BOT_DATA_INFO].endAriaPtr) {
				dataBuffGPtr[SET_BOT_DATA_INFO].endAriaPtr = dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.endPtr;
			}
			else {
			/*	HOST expectant data length > Function expectant data length	*/
				dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.ReadType.endPtr = dataBuffGPtr[SET_BOT_DATA_INFO].endAriaPtr;
			}
			
			byteLVar = ActBulkIn(interruptBitStreamLVar,SET_BOT_USE_IN_EP,SET_BOT_DATA_INFO);
			
			/*	calculate data length	*/
			cbwDataGVar->cbwMeaningType.dCBWDataTransferLength -= byteLVar;
			cswDataGVar->cswMeaningType.dCSWDataResidue = byteLVar - cswDataGVar->cswMeaningType.dCSWDataResidue;
			
			if (cswDataGVar->cswMeaningType.dCSWDataResidue != 0) {
			/*	Transfered data is over Function expectant data length	*/
				/*	Status is set 0x01	*/
				cswDataGVar->cswMeaningType.bCSWStatus = 0x01;
			}
			
			/*	clear work area	*/
			byteLVar = 16;
			while (byteLVar >= 0) {
				returnData->longVal[byteLVar] = 0x00000000;
				byteLVar--;
			}
		}
	}
	
	else {
	/*	not exist transfer data		Status Transport	*/
		/*	mask EP2_EMPTY interrupt */
		SET_BULK_IN_INTERRUPT2
		
		/*	get interrupt enable flag	*/
		GET_INTERRUPT_ENABLE
		
		/*	set up data buffer pointers	*/
		dataBuffGPtr[SET_BOT_CSWCBW_INFO].AccessDataType.ReadType.startPtr = &cswDataGVar->byteVal[0];
		dataBuffGPtr[SET_BOT_CSWCBW_INFO].AccessDataType.ReadType.endPtr = &cswDataGVar->byteVal[13];
		dataBuffGPtr[SET_BOT_CSWCBW_INFO].beginAriaPtr = &cswDataGVar->byteVal[0];
		dataBuffGPtr[SET_BOT_CSWCBW_INFO].endAriaPtr = &cswDataGVar->byteVal[13] + 1;
		
		/*	change CSWDataResidue to little endian	*/
		cswDataGVar->cswMeaningType.dCSWDataResidue = ConvReflexn((unsigned char*)&cswDataGVar->cswMeaningType.dCSWDataResidue,4);

		if ((cswDataGVar->cswMeaningType.bCSWStatus == 0x00) && (cswDataGVar->cswMeaningType.dCSWDataResidue != 0)){
		/*	Transfered data is over Function expectant data length	*/
			/*	Status is set 0x02	*/
			cswDataGVar->cswMeaningType.bCSWStatus = 0x02;
		}
		
		/*	transfer CSW and complete BOT	*/
		ActBulkIn(0,SET_BOT_USE_IN_EP,SET_BOT_CSWCBW_INFO);
		
		/*	state is set "WAIT"	*/
		EpInfo[SET_BOT_USE_OUT_EP].PresentState = WAIT;
	}
}



/***************************************************************************
Function Name	:ActBulkOnlyOut(unsigned long ,unsigned char )
Working			:Executing Data Transport and Status Transport
				:in case data stage direction is OUT
Return Value	:void
Modified		:{Author : T.Ishikawa[2001.Aug.09]}
Created			:{Author : T.Ishikawa[2001.Jan.10]}
***************************************************************************/
void	ActBulkOnlyOut(unsigned long interruptBitStreamLVar ,unsigned char epInfoNumberLVar) {

	if ((interruptBitStreamLVar & EP1_FULL_BIT) == EP1_FULL_BIT) {
	/*	EP1_FULL interrupt ?	Data Transport	*/
		
		/*	clear EP0o_TS interrupt flag	*/
		BULK_OTSF_CLEAR
		
		short		byteLVar = 0;
		short		receiveByteLVar = *EpInfo[epInfoNumberLVar].FifoSize;
		
		if (cswDataGVar->cswMeaningType.bCSWStatus == 0x00) {
		/*	can put away in data buffer ?	*/
			byteLVar = ActBulkOut(interruptBitStreamLVar,epInfoNumberLVar,SET_BOT_DATA_INFO);
			
			/*	calculate data length	*/
			cbwDataGVar->cbwMeaningType.dCBWDataTransferLength -= byteLVar;
			cswDataGVar->cswMeaningType.dCSWDataResidue -= byteLVar;
			
			if (byteLVar != receiveByteLVar) {
			/*	Transfered data is over Function expectant data length	*/
				/*	not put away in data buffer	*/
				cbwDataGVar->cbwMeaningType.dCBWDataTransferLength -= (receiveByteLVar - byteLVar);
				cswDataGVar->cswMeaningType.dCSWDataResidue = receiveByteLVar - byteLVar;
				cswDataGVar->cswMeaningType.bCSWStatus = 0x01;
				
				/*	set up data buffer pointers	*/
				dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.WriteType.startPtr = &returnData->byteVal[0];
				dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.WriteType.endPtr = &returnData->byteVal[63];
				dataBuffGPtr[SET_BOT_DATA_INFO].beginAriaPtr = dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.WriteType.startPtr;
				dataBuffGPtr[SET_BOT_DATA_INFO].endAriaPtr = &returnData->byteVal[64];	/*	data buffer size is 64byte	*/
				
				byteLVar = ActBulkOut(interruptBitStreamLVar,epInfoNumberLVar,SET_BOT_DATA_INFO);
			}
		}
		
		else {
		/*	not put away in data buffer	*/
			dataBuffGPtr[SET_BOT_DATA_INFO].AccessDataType.WriteType.startPtr = &returnData->byteVal[0];
			
			byteLVar = ActBulkOut(interruptBitStreamLVar,epInfoNumberLVar,SET_BOT_DATA_INFO);
			
			cbwDataGVar->cbwMeaningType.dCBWDataTransferLength -= byteLVar;
			cswDataGVar->cswMeaningType.dCSWDataResidue += byteLVar;
		}
	}
	
	else {
	/*	not EP1_FULL interrupt ?	Status Transport	*/
		/*	set up data buffer pointers	*/
		dataBuffGPtr[SET_BOT_CSWCBW_INFO].AccessDataType.ReadType.startPtr = &cswDataGVar->byteVal[0];
		dataBuffGPtr[SET_BOT_CSWCBW_INFO].AccessDataType.ReadType.endPtr = &cswDataGVar->byteVal[13];
		dataBuffGPtr[SET_BOT_CSWCBW_INFO].beginAriaPtr = &cswDataGVar->byteVal[0];
		dataBuffGPtr[SET_BOT_CSWCBW_INFO].endAriaPtr = &cswDataGVar->byteVal[13] + 1;
		
		if ((cswDataGVar->cswMeaningType.dCSWDataResidue != 0) && (cbwDataGVar->cbwMeaningType.dCBWDataTransferLength == 0)) {
		/*	Transfered data is under Function expectant data length	*/
			/*	Status is set 0x02	*/
			cswDataGVar->cswMeaningType.bCSWStatus = 0x02;
		}
		
		/*	change CSWDataResidue to little endian	*/
		cswDataGVar->cswMeaningType.dCSWDataResidue = ConvReflexn((unsigned char*)&cswDataGVar->cswMeaningType.dCSWDataResidue,4);
		
		ActBulkIn(0,SET_BOT_USE_IN_EP,SET_BOT_CSWCBW_INFO);
		
		/*	state is set "WAIT"	*/
		EpInfo[SET_BOT_USE_OUT_EP].PresentState = WAIT;
		
		/*	mask EP2_TR interrupt */
		SET_BULK_IN_INTERRUPT4
		
		/*	clear EP2_TR interrupt flag	*/
		BULK_ITFF_CLEAR
	}
}