usbmain.c

瑞萨单片机开发软代码.非常实用小巧的平台,很多应用都可以在上面实现.

/*
****************************************************************************
					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	:UsbMain.c
	Working		:Judging interrupt flag and Controlling FIFO data
	Modified	:Rev 2001_11_28 {Author : T.Ishikawa}
	Modified	:Rev 2001_10_05 {Author : T.Ishikawa}
	Modified	:Rev 2001_09_28 {Author : T.Ishikawa}
	Created		:Rev 1.0 {Author : T.Ishikawa[2001.Jan.10]}
****************************************************************************
*/

#include	<stdio.h>   
#include    <machine.h>
#include	"CatProType.h"
#include    "flashdisk.h"

/* ---------------------- data area ------------------------------ */

#pragma interrupt	(BranchOfInt)

/*	Prototype	*/
void					BranchOfInt(void);
short					GetPacket(EpInfoType*,BuffType*);
short					PutPacket(EpInfoType*,BuffType*);
short					GetPacket4S(EpInfoType*,BuffType*);
short					PutPacket4S(EpInfoType*,BuffType*);
enum SetCompleteType	SetControlOutContents(ControlType*,BuffType*);
void					SetUsbModule(unsigned long ,unsigned char ,unsigned char );
void					ActBusReset(unsigned long ,unsigned char ,unsigned char );
void					ActBusVcc(unsigned long ,unsigned char ,unsigned char );
unsigned long			ConvRealn(unsigned char* ,unsigned char );
unsigned long			ConvReflexn(unsigned char* ,unsigned char );

extern volatile unsigned char testcode;  
extern LinkType *jump_ptr[];    
extern EpInfoType *epinfo_ptr[];                                                                       

/*	Contents	*/
/***************************************************************************
Function Name	:BranchOfInt(void)
Working			:Judging interrupt flag and calling interrupt each function
Return Value	:void
Modified		:{Author : T.Ishikawa[2001.Nov.28]}
Modified		:{Author : T.Ishikawa[2001.Aug.09]}
Modified		:{Author : T.Ishikawa[2001.Jan.10]}
Created			:{Author : T.Ishikawa[2000.Jun.09]}
***************************************************************************/
void	BranchOfInt(void) 
{
	register unsigned char	counterLVar;							/*	branch table counter	*/
	register unsigned long	deviceSideLVar = USBFM.UIFR.LONG;		/*	get interrupt flag pattern	*/          

//	GET_INTERRUPT_REGISTER	/*	get interrupt flag	*/
//	deviceSideLVar.INTERRUPT.LONG &= interruptEnableBitsGVar.INTERRUPT.LONG;	/*	filtering interrupt flag	*/
	
	deviceSideLVar &= interruptEnableBitsGVar.INTERRUPT.LONG;	/*	filtering interrupt flag	*/
	
	for (counterLVar = 0;jump[counterLVar].EpInfoNum != 255;counterLVar++) {
		if ((deviceSideLVar & jump[counterLVar].InterruptBitStream) != 0) {
			//jump[counterLVar].CallOn(deviceSideLVar.INTERRUPT.LONG,jump[counterLVar].EpInfoNum,jump[counterLVar].DataBuffNum);
			jump[counterLVar].CallOn(deviceSideLVar,jump[counterLVar].EpInfoNum,jump[counterLVar].DataBuffNum);
			break;
		}
	}
	IRQ_CLEAR
}

/***************************************************************************
Function Name	:GetPacket(EpInfoType*,BuffType*)
Working			:Transfering data from FIFO to RAM
Return Value	:short
Modified		:{Author : T.Ishikawa & E.Ondou[2001.Nov.28]}
Modified		:{Author : T.Ishikawa[2001.Aug.09]}
Modified		:{Author : T.Ishikawa[2001.Jan.10]}
Modified		:{Author : T.Ishikawa[1999.Jan.21]}
Modified		:{Author : T.Ishikawa[1998.Oct.15]}
Created			:{Author : T.Ishikawa[1997.Des.01]}
***************************************************************************/
short	GetPacket(EpInfoType*	epInfoPtr,BuffType*	memoryLPtr) 
{

	/*	receiving data size in FIFO	*/
	short	readArea = *epInfoPtr->FifoSize;
	/*	transfered data size	*/
	short 			getByteLVar = readArea;

	unsigned char*	usbDataRegPtr = epInfoPtr->epdrPtr;
	unsigned char*	memoryWriteLPtr = memoryLPtr->sPtr;
	
	while ((readArea != 0) && (memoryWriteLPtr != memoryLPtr->ePtr)) 
	{                                 
		*memoryWriteLPtr = *usbDataRegPtr;
		memoryWriteLPtr++;
		readArea--;
	}
	if (readArea == 0) {
		/*	set Read_Finish flag	*/
		READ_FINISH 
	}
	
	memoryLPtr->sPtr = memoryWriteLPtr;

	return (getByteLVar - readArea);
}


/***************************************************************************
Function Name	:GetPacket4S(EpInfoLongType*,BuffType*)
Working			:Transfering data from FIFO to RAM in 4 byte units
Return Value	:short
Created			:{Author : T.Ishikawa & E.Ondou[2001.Nov.28]}
***************************************************************************/
short	GetPacket4S(EpInfoType*	epInfoPtr,BuffType*	memoryLPtr) 
{
	register unsigned char c;
	/*	receiving data size in FIFO	*/
	short	readArea = *epInfoPtr->FifoSize;
	/*	transfered data size	*/
	short 			getByteLVar = readArea;
	unsigned long*	usbDataRegLPtr = epInfoPtr->epdrLPtr;
	unsigned long*	memoryWriteLongLPtr = (unsigned long*)memoryLPtr->sPtr;

	while ((readArea != 0) && (memoryWriteLongLPtr != (unsigned long*)memoryLPtr->ePtr)) 
//    for (c=0;c<16;c++)
	{
		/*	transfer data from FIFO to ring buffer RAM	*/
		*memoryWriteLongLPtr = *usbDataRegLPtr;
		memoryWriteLongLPtr++;
		readArea -= 4;
	}
	
	if (readArea == 0) {
		/*	set Read_Finish flag	*/
		READ_FINISH
	}
	
	memoryLPtr->sPtr = (unsigned char*)memoryWriteLongLPtr;
	
	return (getByteLVar - readArea);
//	return (*epInfoPtr->FifoSize);
}



/***************************************************************************
Function Name	:PutPacket(EpInfoType*,BuffType*)
Working			:Transfering data from RAM to FIFO
Return Value	:short
Modified		:{Author : T.Ishikawa & E.Ondou[2001.Nov.28]}
Modified		:{Author : T.Ishikawa[2001.Jan.10]}
Modified		:{Author : T.Ishikawa[1999.Jan.21]}
Modified		:{Author : T.Ishikawa[1998.Oct.15]}
Modified		:{Author : T.Ishikawa[1998.Mar.11]}
Created			:{Author : T.Ishikawa[1997.Des.01]}
***************************************************************************/
short	PutPacket(EpInfoType*	epInfoPtr,BuffType*	memoryLPtr) 
{

	/*	FIFO size	*/
	short 	writeArea = *epInfoPtr->FifoSize;

	unsigned char*	usbDataRegPtr = epInfoPtr->epdrPtr;
	unsigned char*	memoryReadLPtr = memoryLPtr->sPtr;


	if(memoryLPtr->sPtr == memoryLPtr->ePtr)
	{
		//SCI_Str("PE");
	}
	while ((writeArea != 0) && (memoryReadLPtr != memoryLPtr->ePtr)) 
	{
		*usbDataRegPtr = *memoryReadLPtr;
		memoryReadLPtr++;
		writeArea--;
	}
	/*	enable transfer data in FIFO	*/
	WRITE_FINISH
	
	memoryLPtr->sPtr = memoryReadLPtr;

	return ((short)*epInfoPtr->FifoSize - writeArea);
}


/***************************************************************************
Function Name	:PutPacket4S(EpInfoType*,BuffType*)
Working			:Transfering data from RAM to FIFO in 4 byte units
Return Value	:short
Created			:{Author : T.Ishikawa & E.Ondou[2001.Nov.28]}
***************************************************************************/
short	PutPacket4S(EpInfoType*	epInfoPtr,BuffType*	memoryLPtr) 
{
	/*	FIFO size	*/
	//unsigned short 	writeArea = *epInfoPtr->FifoSize;
	/*	ring buffer RAM pointer address	*/
//	unsigned long	returnAddLVar = (unsigned long)memoryLPtr->endAriaPtr & 0xFFFFFFFC;

//    register unsigned char c;

#if 1
	register unsigned long*	usbDataRegLPtr = epInfoPtr->epdrLPtr;
	register unsigned long*	memoryReadLongLPtr = (unsigned long*)memoryLPtr->sPtr;

    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
    *usbDataRegLPtr = *memoryReadLongLPtr++;
#else
	register unsigned long*	usbDataRegLPtr = epInfoPtr->epdrLPtr;
	register unsigned long*	memoryReadLongLPtr = (unsigned long*)memoryLPtr->sPtr;
//	while ((writeArea != 0) && (memoryReadLongLPtr != (unsigned long*)memoryLPtr->ePtr)) 
    for (c=0;c<16;c++)
	{
		/*	transfer data from ring buffer RAM to FIFO	*/
		*usbDataRegLPtr = *memoryReadLongLPtr++;
//		memoryReadLongLPtr++;
//		writeArea -= 4;
	}
#endif

	/*	enable transfer data in FIFO	*/ 
	WRITE_FINISH
	memoryLPtr->sPtr = (unsigned char*)memoryReadLongLPtr;

//	return (*epInfoPtr->FifoSize - writeArea);
	return ((short)*epInfoPtr->FifoSize);
}



/***************************************************************************
Function Name	:SetControlOutContents(ControlType*,BuffType*)
Working			:Changing transfered data from Host
Return Value	:enum SetCompleteType (COMPLETE or INCOMPLETE) 
Modified		:{Author : A.Ikeya	[2002.May.28]}
Created			:{Author : S.Suzuki[1998.Nov.6]}
***************************************************************************/
enum SetCompleteType SetControlOutContents(ControlType* addLPtr,BuffType*	memoryLPtr) 
{
	/*	(no data residue in FIFO)  &&  (transfered datasize <= data area)	*/
	if ((*EpInfo[2].FifoSize == 0x00) && ((memoryLPtr->ePtr - memoryLPtr->sPtr) <= (addLPtr->endPtr - addLPtr->beginPtr))) {
		
		/*	set read start pointer to start of area 	*/
		//memoryLPtr->sPtr = memoryLPtr->beginPtr;
		
		/*	change data	*/
		for (;((memoryLPtr->sPtr != memoryLPtr->ePtr) && (addLPtr->beginPtr != addLPtr->endPtr));
		addLPtr->beginPtr++,memoryLPtr->sPtr++) {
			*addLPtr->beginPtr = *memoryLPtr->sPtr;
		}
		return COMPLETE;
	}
	return INCOMPLETE;
}


/***************************************************************************
Function Name	:SetUsbModule(unsigned long ,unsigned char ,unsigned char)
Working			:Intializing USB Module
Return Value	:void
Modified		:{Author : A.Ikeya	[2002.May.28]}
Modified		:{Author : T.Ishikawa[2001.Nov.28]}
Modified		:{Author : T.Ishikawa[2001.Nov.14]}
Created			:{Author : T.Ishikawa[2000.Jun.23]}
***************************************************************************/
void	SetUsbModule(unsigned long interruptBitStreamLVar ,unsigned char epInfoNumberLVar, unsigned char dataBuffNumberLVar) {

    testcode = 4;  // debugging
	RUN_USB_MODULE_2
	
	F_CLEAR_PLLREADY
	
	/*	Set USB Information Register	*/
	SET_USB_EPINFO
	
	/*	set USB interrupt and DMA	*/
	SET_USB_INTERRUPT
	
	/*	get interrupt enable flag	*/
	GET_INTERRUPT_ENABLE
	
	SET_USB_INTERRUPT_SELECT       
    
}



/***************************************************************************
Function Name	:ActBusReset(unsigned long ,unsigned char , unsinged char ,unsigned char)
Working			:Clear FIFO in USB Bus Reset
Return Value	:void
Modified		:{Author : A.Ikeya	[2002.May.28]}
Modified		:{Author : T.Ishikawa[2001.Aug.09]}
Modified		:{Author : T.Ishikawa[2001.Jan.10]}
Created			:{Author : T.Ishikawa[2000.Jun.23]}
***************************************************************************/
void	ActBusReset(unsigned long interruptBitStreamLVar ,unsigned char epInfoNumberLVar, unsigned char dataBuffNumberLVar) {

    testcode = 3;  // debugging

	/*	clear interrupt flag	*/
	F_CLEAR_BUSRESET
	
	/*	clear all FIFO	*/
	CLEAR_ALL_FIFO
	
	/*	clear STALL	*/
	EP_STALL_ALL_OFF    
	
	//	clear setting etc.
	CLEAR_SETTING

    // enable IRQ6 for Suspend/Resume Operation
    INTC.ISR.BYTE = 0x00;             // Clear interrupt Request
    INTC.IER.BYTE |= BIT6;	          // Enable IRQ6
    USBFM.UIER.BYTE.LL |= BIT2;       // enable suspend/resume interrupt (IRQ6)
}



/************************************************************************
Function Name	:ActBusVcc(unsigned long ,unsigned char ,unsinged char)
Working			:Handling VBUS interrupt
Return Value	:void
Modified		:{Author : A.Ikeya	[2002.May.28]}
Modified		:{Author : T.Ishikawa[2001.Nov.28]}
Modified		:{Author : T.Sekine[2001.Nov.09]}
Created			:{Author : T.Ishikawa[2000..]}
************************************************************************/
void	ActBusVcc(unsigned long interruptBitStreamLVar ,unsigned char EpInfoNumberLVar ,unsigned char dataBuffNumberLVar) 
{
	
	InterruptType	deviceSideLVar;					/*	For stored present value of interrupt flag resisters	*/
	
	F_CLEAR_BUSVCC									/*	Clear VBUSi flag	*/
	GET_INTERRUPT_REGISTER							/*	For renewal deviceSideLVar (Re-get the value of interrupt flag registers)	*/
	
	CHECK_CABLE_STATE
		CLEAR_ALL_FIFO								/*	Clear all FIFO	*/
		ENABLE_DPLUS_PULLUP							/*	Enable D+ Pullup	*/
		RUN_USB_MODULE_3							/*	Disable UDC core reset	*/
        testcode = 1;  // debugging                     
	}
	else {											/*	USB cable is disconnecteed	*/
		STOP_USB_MODULE_3							/*	Enable UDC core reset	*/
		DISABLE_DPLUS_PULLUP						/*	Disable D+ Pullup	*/
        testcode = 2;  // debugging
	}
}



/***************************************************************************
Function Name	:ConvRealn(unsigned char* ,unsigned char )
Working			:Reading data in specified address
Return Value	:unsigned long
Created			:{Author : T.Ishikawa[2001.Jan.10]}
***************************************************************************/
unsigned long	ConvRealn(unsigned char*	sourceLPtr ,unsigned char	counterVer) 
{

	unsigned char				counterLVer = 0;
	register unsigned long	workLVer = (unsigned char)*(sourceLPtr);

	counterVer -= 1;
	
	while (counterLVer < counterVer) {
		counterLVer++;
		workLVer <<= 8;
		++sourceLPtr;
		workLVer |= (unsigned char)*(sourceLPtr);
	}
	return workLVer;
}



/***************************************************************************
Function Name	:ConvReflexn(unsigned char* ,unsigned char )
Working			:Changing row of data in specified address
Return Value	:unsigned long
Created			:{Author : T.Ishikawa[2001.Jan.10]}
***************************************************************************/
unsigned long	ConvReflexn(unsigned char*	sourceLPtr ,unsigned char	counterVer) 
{
	register unsigned long	workLVer = 0;

	while (counterVer != 0) {
		counterVer--;
		workLVer <<= 8;
		workLVer |= (unsigned char)*(sourceLPtr + counterVer);
	}
	return workLVer;
}