handler.c

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

/*
 * description: Interrupt Handler
 * Maker	  : Shuichi.Yanagihara
 * Copyright  : (C)2004,SEIKO EPSON Corp. All Rights Reserved.
 */

#include "SPRDEF.h"
#include "SPRSTS.h"
#include "OSCall.h"

#include "Reg72V05.h"
#include "Handler.h"
#include "usbh_SampleTask.h"
#include "IDETask.h"
#include <usbh_hcd.h>
#include <DeviceTask.h>
#include <USBDTask.h>

#ifdef TOYA2_C
#include "reg_mx21.h"
#endif	// TOYA2_C

/*****************************************
 * Define definition
 *****************************************/
#define DEVICE_MODE			(0)				/* HOSTxDEVICE bit Device Mode */
#define HOST_MODE			(1)				/* HOSTxDEVICE bit Host Mode */


/*----------------------------------------------------------------------*/
/* Interrupt factor enable setting variable							*/
/* ( Bit which interrupt handler prohibited Enb register become 1.	*/
/* Please carry out Enb register operation by referring this variable*/
/* after interrupt process in each task. and, clear this variable after process finishing */
/*----------------------------------------------------------------------*/

/* Host Sample use */
UCHAR						main_int_enb_usbh_sample;
UCHAR						device_int_enb_usbh_sample;
UCHAR						host_int_enb_usbh_sample;
UCHAR						cpu_int_enb_usbh_sample;
UCHAR						ide_int_enb_usbh_sample;
UCHAR						mediafifo_int_enb_usbh_sample;

/* Host USB use */
UCHAR						main_int_enb_usbh_usb;
UCHAR						device_int_enb_usbh_usb;
UCHAR						host_int_enb_usbh_usb;
UCHAR						cpu_int_enb_usbh_usb;
UCHAR						ide_int_enb_usbh_usb;
UCHAR						mediafifo_int_enb_usbh_usb;

/* Device Task use */
UCHAR						device_int_enb_usb;
UCHAR						sie_int_enb_usb;
UCHAR						fifo_int_enb_usb;

UCHAR						main_int_enb_device_task;
UCHAR						cpu_int_enb_device_task;
UCHAR						fifo_int_enb_device_task;

UCHAR						mediafifo_int_enb_device_task;

/* IDE use */
UCHAR						main_int_enb_ide;
UCHAR						device_int_enb_ide;
UCHAR						host_int_enb_ide;
UCHAR						cpu_int_enb_ide;
UCHAR						ide_int_enb_ide;
UCHAR						mediafifo_int_enb_ide;

/*----------------------------------------------------------------------*/
/* Variable with handler												*/
/*----------------------------------------------------------------------*/

static UCHAR main_int_stat_sv;
static UCHAR device_int_stat_sv;
static UCHAR cpu_int_stat_sv;
static UCHAR mediafifo_int_stat_sv;
static UCHAR device_int_stat_sv;
static UCHAR sie_int_stat_sv;
static UCHAR fifo_int_stat_sv;

#ifdef DEBUG_C
extern ULONG	USBResetCount;
extern ULONG	EP0InErrorCount;
extern ULONG	EP0OutErrorCount;
extern ULONG	BulkInErrorCount;
extern ULONG	BulkOutErrorCount;
extern ULONG	CBWErrorCount;
extern ULONG	CSWErrorCount;
#endif

/*
//=============================================================================
// Function_Name: handler1
// description	: Interrupt handler
// argument		:
// return		:
// flag			:
// global		:
//=============================================================================
*/
void handler1( void )
{
	main_int_stat_sv = RegRead(REG08_MainIntStat);		/* Save main interrupt status*/

	/*----------------------------------------------------------------------*/
	/* Host Mode															*/
	/*----------------------------------------------------------------------*/
	if((RegRead(REG08_HostDeviceSel) & MASK_HOSTxDEVICE) == BIT_HOSTxDEVICE_HOST) {

		/*------------------------------------------------------------------*/
		/* HostSample Task related										*/
		/*------------------------------------------------------------------*/
		/* Interrupt of mediaFIFO related */
		if((main_int_stat_sv & MASK_MediaFIFO_IntStat)) {
			main_int_enb_usbh_sample |= BIT_EnMediaFIFO_IntStat;
			/* Event notification to HostSample Task */
			OS_ISetFlg( FLGID_USBH_SAMPLE, FLG_EVENT_INT_USBH_SAMPLE );
		}

		/*------------------------------------------------------------------*/
		/* Host USB Task related											*/
		/*------------------------------------------------------------------*/

		USBH_HCD_Interrupt();

		/*------------------------------------------------------------------*/
		/* IDE Task related												*/
		/*------------------------------------------------------------------*/
		if((main_int_stat_sv & MASK_IDE_IntStat)){
			main_int_enb_ide |= BIT_EnIDE_IntStat;

			/* Event notification to IDETask */
			OS_ISetFlg( FLGID_IDE, FLG_EVENT_INT_IDE );
		}

		/* Prohibit interrupt signal assert of MainIntStat interrupt factor	*/
		RegClear(REG08_MainIntEnb,( main_int_enb_ide | main_int_enb_usbh_sample) );

	} else {
	/*----------------------------------------------------------------------*/
	/* Device Mode															*/
	/*----------------------------------------------------------------------*/

#ifdef DEBUG_C
		if ((RegRead(REG08_D_EP0IntStat) & MASK_IN_TranErr)) {
			RegWrite(REG08_D_EP0IntStat,BIT_IN_TranErr);
			if ((RegRead(REG08_D_EP0ControlIN) & MASK_ForceSTALL) != BIT_ForceSTALL) {
				EP0InErrorCount++;
			}
		}
		if ((RegRead(REG08_D_EP0IntStat) & MASK_OUT_TranErr)) {
			RegWrite(REG08_D_EP0IntStat,BIT_OUT_TranErr);
			if ((RegRead(REG08_D_EP0ControlOUT) & MASK_ForceSTALL) != BIT_ForceSTALL) {
				EP0OutErrorCount++;
			}
		}
		if ((RegRead(REG08_D_EPbIntStat) & MASK_IN_TranErr)) {
			RegWrite(REG08_D_EPbIntStat,BIT_IN_TranErr);
			if ((RegRead(REG08_D_EPbControl) & MASK_ForceSTALL) != BIT_ForceSTALL) {
				BulkInErrorCount++;
			}
		}
		if ((RegRead(REG08_D_EPbIntStat) & MASK_OUT_TranErr)) {
			RegWrite(REG08_D_EPbIntStat,BIT_OUT_TranErr);
			if ((RegRead(REG08_D_EPbControl) & MASK_ForceSTALL) != BIT_ForceSTALL) {
				BulkOutErrorCount++;
			}
		}
		if ((RegRead(REG08_D_EPcIntStat) & MASK_IN_TranErr)) {
			RegWrite(REG08_D_EPcIntStat,BIT_IN_TranErr);
			if ((RegRead(REG08_D_EPcControl) & MASK_ForceSTALL) != BIT_ForceSTALL) {
				BulkInErrorCount++;
			}
		}
		if ((RegRead(REG08_D_EPcIntStat) & MASK_OUT_TranErr)) {
			RegWrite(REG08_D_EPcIntStat,BIT_OUT_TranErr);
			if ((RegRead(REG08_D_EPcControl) & MASK_ForceSTALL) != BIT_ForceSTALL) {
				BulkOutErrorCount++;
			}
		}
		if ((RegRead(REG08_D_BulkIntStat) & MASK_CBW_Err)) {
			RegWrite(REG08_D_BulkIntStat,BIT_CBW_Err);
			if ((RegRead(REG08_D_EPbControl) & MASK_ForceSTALL) != BIT_ForceSTALL
				&& (RegRead(REG08_D_EPcControl) & MASK_ForceSTALL) != BIT_ForceSTALL) {
				CBWErrorCount++;
			}
		}
		if ((RegRead(REG08_D_BulkIntStat) & MASK_CSW_Err)) {
			RegWrite(REG08_D_BulkIntStat,BIT_CSW_Err);
			if ((RegRead(REG08_D_EPbControl) & MASK_ForceSTALL) != BIT_ForceSTALL
				&& (RegRead(REG08_D_EPcControl) & MASK_ForceSTALL) != BIT_ForceSTALL) {
				CSWErrorCount++;
			}
		}
#endif
		device_int_stat_sv = RegRead(REG08_DeviceIntStat);	/* Save Device interrupt status*/
		cpu_int_stat_sv    = RegRead(REG08_CPU_IntStat);	/* Save interrupt status of CPU related */
		sie_int_stat_sv    = RegRead(REG08_D_SIE_IntStat);	/* Save interrupt status of SIE related */
		fifo_int_stat_sv   = RegRead(REG08_D_FIFO_IntStat);	/* Save interrupt status of FIFO related */
		mediafifo_int_stat_sv = RegRead(REG08_MediaFIFO_IntStat);	/* Save interrupt status of FIFO related */
		/*----------------------------------------------------------------------*/
		/* USBTask related													*/
		/*----------------------------------------------------------------------*/
		/* Interrupt of SIE related */
		if ((main_int_stat_sv & MASK_DeviceIntStat)) {                    /*if device interrupt*/
			if((device_int_stat_sv & MASK_VBUS_Changed)){          /*if bus power is changed*/
				device_int_enb_usb |= BIT_EnVBUS_Changed;      /*set the flag of bus power interrupt*/
			}
			if((device_int_stat_sv & MASK_D_SIE_IntStat)) {         /*if serial interface engine  interrupt*/
				if((sie_int_stat_sv & MASK_NonJ)){                      /* interrupt of not attack?*/
					sie_int_enb_usb |= BIT_EnNonJ;
				}
				if((sie_int_stat_sv & MASK_DetectRESET)){         /* detect reset*/
					sie_int_enb_usb |= BIT_EnDetectRESET;
				}
				if((sie_int_stat_sv & MASK_DetectSUSPEND)){    /*suspend*/
					sie_int_enb_usb |= BIT_EnDetectSUSPEND;
				}
				if((sie_int_stat_sv & MASK_ChirpCmp)){            /* handshake with host computer interrupt*/
					sie_int_enb_usb |= BIT_EnChirpCmp;
				}
				if((sie_int_stat_sv & MASK_RestoreCmp)){
					sie_int_enb_usb |= BIT_EnRestoreCmp;      /*restore by host computer interrupt*/
				}
				if((sie_int_stat_sv & MASK_SetAddressCmp)){   /*set address by host computer*/
					sie_int_enb_usb |= BIT_EnSetAddressCmp;
				}
			}

			/* Interrupt of endpoint EPr */
			if((device_int_stat_sv & MASK_D_EPrIntStat)){
				device_int_enb_usb |= BIT_EnD_EPrIntStat;
			}

			/* Interrupt of FIFO related */
			if((device_int_stat_sv & MASK_D_FIFO_IntStat)){
				if((fifo_int_stat_sv & MASK_DescriptorCmp)){
					fifo_int_enb_usb |= BIT_EnDescriptorCmp;
				}
			}

			/* Interrupt of Bulk transfer function related */
			if((device_int_stat_sv & MASK_D_BulkIntStat)){
				device_int_enb_usb |= BIT_EnD_BulkIntStat;
			}

			/* Interrupt of endpoint EP0 */
			if((device_int_stat_sv & MASK_D_EP0IntStat)){
				device_int_enb_usb |= BIT_EnD_EP0IntStat;
			}

			/* Interrupt of setup stage of control transfer */
			if((device_int_stat_sv & MASK_RcvEP0SETUP)){
				device_int_enb_usb |= BIT_EnRcvEP0SETUP;
			}

		}

		if( device_int_enb_usb || sie_int_enb_usb || fifo_int_enb_usb ){
			/* Event notification to USBTask */
			OS_ISetFlg( FLGID_USBD, FLG_EVENT_INT_USBD );     /*set flag to the system to call application*/ 
		}

		/*----------------------------------------------------------------------*/
		/* DeviceTask related												*/
		/*----------------------------------------------------------------------*/
		/* Interrupt of SIE related */
		if((main_int_stat_sv & MASK_FinishedPM))
		{
			main_int_enb_device_task |= BIT_EnFinishedPM;
		}

// Judge position change
		/* Interrupt of FIFO related */
		if((main_int_stat_sv & MASK_MediaFIFO_IntStat)) {
			if((mediafifo_int_stat_sv & MASK_MediaIDE_Cmp)){
				mediafifo_int_enb_device_task |= BIT_EnMediaIDE_Cmp;
			}
			if((mediafifo_int_stat_sv & MASK_FIFO_Full)){
				mediafifo_int_enb_device_task |= BIT_EnFIFO_Full;
			}
			if((mediafifo_int_stat_sv & MASK_FIFO_Empty)){
				mediafifo_int_enb_device_task |= BIT_EnFIFO_Empty;
			}
		}

		/* Interrupt of CPU interface related */
		if((main_int_stat_sv & MASK_CPU_IntStat)){
			if((cpu_int_stat_sv & MASK_DMA1_CountUp)){
				cpu_int_enb_device_task |= BIT_EnDMA1_CountUp;
			}
			if((cpu_int_stat_sv & MASK_DMA1_Cmp)){
				cpu_int_enb_device_task |= BIT_EnDMA1_Cmp;
			}
			if((cpu_int_stat_sv & MASK_DMA0_CountUp)){
				cpu_int_enb_device_task |= BIT_EnDMA0_CountUp;
			}
			if((cpu_int_stat_sv & MASK_DMA0_Cmp)){
				cpu_int_enb_device_task |= BIT_EnDMA0_Cmp;
			}
		}

		/* Interrupt of FIFO related */
		if((main_int_stat_sv & MASK_DeviceIntStat)) {
			if((device_int_stat_sv & MASK_D_FIFO_IntStat)){
				if((fifo_int_stat_sv & MASK_FIFO_IDE_Cmp)){
					fifo_int_enb_device_task |= BIT_EnFIFO_IDE_Cmp;
				}
				if(( fifo_int_stat_sv & MASK_FIFO1_Cmp)){
					fifo_int_enb_device_task |= BIT_EnFIFO1_Cmp;
				}
				if(( fifo_int_stat_sv & MASK_FIFO_Full)){
					fifo_int_enb_device_task |= BIT_EnFIFO_Full;
				}
				if(( fifo_int_stat_sv & MASK_FIFO_Empty)){
					fifo_int_enb_device_task |= BIT_EnFIFO_Empty;
				}
				if((fifo_int_stat_sv & MASK_FIFO0_Cmp)){
					fifo_int_enb_device_task |= BIT_EnFIFO0_Cmp;
				}
			}
		}

// Judge position change
		if( main_int_enb_device_task || cpu_int_enb_device_task || fifo_int_enb_device_task || mediafifo_int_enb_device_task ){
			/* Event notification to DeviceTask */
			OS_ISetFlg( FLGID_DEVICE, FLG_EVENT_INT_DEVICE );
		}

		/*----------------------------------------------------------------------*/
		/* IDETask related															*/
		/*----------------------------------------------------------------------*/
		/* Interrupt of IDE related */
		if((main_int_stat_sv & MASK_IDE_IntStat)){
			main_int_enb_ide |= BIT_EnIDE_IntStat;

			/* Event notification to IDETask */
			OS_ISetFlg( FLGID_IDE, FLG_EVENT_INT_IDE );
		}

		/* Prohibit interrupt signal assert of MainIntStat interrupt factor	*/
		RegClear(REG08_MainIntEnb,(main_int_enb_device_task | main_int_enb_ide));

		/* Prohibit interrupt signal assert of DeviceIntStat interrupt factor	*/
		RegClear(REG08_DeviceIntEnb,device_int_enb_usb);

		/* Prohibit interrupt signal assert of SIE_IntStat interrupt factor	*/
		RegClear(REG08_D_SIE_IntEnb,sie_int_enb_usb);

		/* Prohibit interrupt signal assert of CPU_IntStat interrupt factor	*/
		RegClear(REG08_CPU_IntEnb,cpu_int_enb_device_task);

		/* Prohibit interrupt signal assert of FIFO_IntStat interrupt factor	*/
		RegClear(REG08_D_FIFO_IntEnb,(fifo_int_enb_usb | fifo_int_enb_device_task));

		/* Prohibit interrupt signal assert of FIFO_IntStat interrupt factor	*/
		RegClear(REG08_MediaFIFO_IntEnb,mediafifo_int_enb_device_task);

	}

#ifdef TOYA2_C
	rlMX21_PTA_ISR		|= 0x00800000;	/* PTA23 Interrupt Clear */
#endif	// TOYA2_C

}