usbmain.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	: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]}
****************************************************************************
*/

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

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

#include	<stdio.h>
#include	"SetUsbInfo.h"



#ifdef HEARD_VECTOR
#pragma interrupt	(BranchOfInt)
#endif	/*	HEARD_VECTOR	*/



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



/*	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) {

	unsigned char	counterLVar = 0;		/*	branch table counter	*/
	InterruptType	deviceSideLVar;		/*	interrupt flag pattern	*/

	GET_INTERRUPT_REGISTER	/*	get interrupt flag	*/
	
	if (deviceSideLVar.INTERRUPT.BYTE.InterruptRegister0 == 0x00) {
		counterLVar = 4;
	}
	
	deviceSideLVar.INTERRUPT.LONG &= interruptEnableBitsGVar.INTERRUPT.LONG;	/*	filtering interrupt flag	*/
	
	for (;jump[counterLVar].EpInfoNum != 255;counterLVar++) {
		if ((deviceSideLVar.INTERRUPT.LONG & jump[counterLVar].InterruptBitStream) != 0) {
			if ((EpInfo[(jump[counterLVar].EpInfoNum)].transMode == CONTROL) && (EpInfo[0].PresentState == TRANS_OUT)) {
				counterLVar++;
			}
			jump[counterLVar].CallOn(deviceSideLVar.INTERRUPT.LONG,jump[counterLVar].EpInfoNum,jump[counterLVar].DataBuffNum);
			break;
		}
	}
}



/***************************************************************************
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	*/
	unsigned short	readArea = *epInfoPtr->FifoSize;
	/*	transfered data size	*/
	short 			getByteLVar = readArea;

	unsigned char*	usbDataRegPtr = epInfoPtr->epdrPtr;
	unsigned char*	memoryWriteLPtr = memoryLPtr->AccessDataType.WriteType.startPtr;

	while ((readArea != 0) && (memoryWriteLPtr != memoryLPtr->AccessDataType.WriteType.endPtr)) {
		/*	transfer data from FIFO to ring buffer RAM	*/
		*memoryWriteLPtr = *usbDataRegPtr;
		
		if (memoryWriteLPtr >= memoryLPtr->endAriaPtr) {
			/*	reset ring buffer RAM pointer	*/
			memoryWriteLPtr = memoryLPtr->beginAriaPtr;
		}
		else {
			/*	Normal	*/
			memoryWriteLPtr++;
		}
		
		readArea--;
	}
	
	if (readArea == 0) {
		/*	set Read_Finish flag	*/
		READ_FINISH
	}
	
	memoryLPtr->AccessDataType.WriteType.startPtr = memoryWriteLPtr;
	return (getByteLVar - readArea);
}



/***************************************************************************
Function Name	:GetPacket4(EpInfoLongType*,BuffType*)
Working			:Transfering data from FIFO to RAM in 4 byte units
Return Value	:short
Modified		:{Author : T.Ishikawa & E.Ondou[2001.Nov.28]}
Modified		:{Author : T.Ishikawa[2001.Aug.09]}
Created			:{Author : T.Ishikawa[2001.Jan.10]}
***************************************************************************/
short	GetPacket4(EpInfoType*	epInfoPtr,BuffType*	memoryLPtr) {

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

	unsigned long*	usbDataRegLPtr = epInfoPtr->epdrLPtr;
	unsigned long*	memoryWriteLongLPtr = memoryLPtr->AccessDataType.WriteType4.startPtr;

	/*	ring buffer RAM pointer address	*/
	unsigned long	returnAddLVar = (unsigned long)memoryLPtr->endAriaPtr & 0xFFFFFFFC;

	while ((readArea != 0) && (memoryWriteLongLPtr != memoryLPtr->AccessDataType.WriteType4.endPtr)) {
		/*	transfer data from FIFO to ring buffer RAM	*/
		*memoryWriteLongLPtr = *usbDataRegLPtr;
		
		if (memoryWriteLongLPtr >= (unsigned long*)returnAddLVar) {
			/*	reset ring buffer RAM pointer	*/
			memoryWriteLongLPtr = (unsigned long*)memoryLPtr->beginAriaPtr;
		}
		else {
			/*	Normal	*/
			memoryWriteLongLPtr++;
		}
		
		readArea -= 4;
	}
	
	if (readArea == 0) {
		/*	set Read_Finish flag	*/
		READ_FINISH
	}
	
	memoryLPtr->AccessDataType.WriteType4.startPtr = memoryWriteLongLPtr;
	
	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) {

	/*	receiving data size in FIFO	*/
	unsigned short	readArea = *epInfoPtr->FifoSize;
	/*	transfered data size	*/
	short 			getByteLVar = readArea;
	/*	ring buffer RAM pointer address	*/
	unsigned long	returnAddLVar = (unsigned long)memoryLPtr->endAriaPtr & 0xFFFFFFFC;

	unsigned long*	usbDataRegLPtr = epInfoPtr->epdrLPtr;
	unsigned long*	memoryWriteLongLPtr = memoryLPtr->AccessDataType.WriteType4.startPtr;

	while ((readArea != 0) && (memoryWriteLongLPtr != memoryLPtr->AccessDataType.WriteType4.endPtr)) {
		/*	transfer data from FIFO to ring buffer RAM	*/
		*memoryWriteLongLPtr = *usbDataRegLPtr;
		
		memoryWriteLongLPtr++;
		readArea -= 4;
	}
	
	if (readArea == 0) {
		/*	set Read_Finish flag	*/
		READ_FINISH
	}
	
	memoryLPtr->AccessDataType.WriteType4.startPtr = memoryWriteLongLPtr;
	
	return (getByteLVar - readArea);
}



/***************************************************************************
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	*/
	unsigned short 	writeArea = *epInfoPtr->FifoSize;

	unsigned char*	usbDataRegPtr = epInfoPtr->epdrPtr;
	unsigned char*	memoryReadLPtr = memoryLPtr->AccessDataType.ReadType.startPtr;

	/*	ring buffer RAM pointer address	*/
	unsigned long	returnAddLVar = (unsigned long)memoryLPtr->endAriaPtr;