u_main.c

EPSON USB DEVICE MASS-STORAGE CLASS driver, BULK ONLY on Ram disk

/******************************************************************************
 * File name   : main.c
 * Module name : main module
 * Author	   : Hiromichi.Kondo
 *-----------------------------------------------------------------------------
 * $Id: main.c,v 1.6 2003/05/26 02:34:45 9551619 Exp $
 *****************************************************************************/

/*--- Include ---------------------------------------------------------------*/
#include "u_value.h"
#include "u_macro.h"
#include "u_regNikka.h"

#include "u_ram_data.h"
#include "u_rom_data.h"

/*--- Function Prototype ---------------------------------------------------*/
void PowerOnProc(void);
static void InitTargetIC(void);
static int	Diagnostic(int loop);
static void SetReplyDescriptorData(void);
void InitWorkArea(void);

void InterruptProc(void);
void Timer0IntProc(void);

/* Global Variable */
S_rMainIntStat	main_int_stat_sv;	/* Main */
S_rSIE_IntStat	sie_int_stat_sv;	/* SIE */
S_rEPrIntStat	epr_int_stat_sv;	/* EPr */
S_rDMA_IntStat	dma_int_stat_sv;	/* DMA */
S_rFIFO_IntStat	fifo_int_stat_sv;	/* FIFO */
S_rEP0IntStat	ep0_int_stat_sv;	/* EP0 */
S_rEPaIntStat	epa_int_stat_sv;	/* EPa */
S_rEPbIntStat	epb_int_stat_sv;	/* EPb */
S_rEPcIntStat	epc_int_stat_sv;	/* EPc */

/*****************************************************************************
 *	PowerOnProc
 *****************************************************************************/
void PowerOnProc(void)
{
	InitWorkArea();
	InitTargetIC();

	special_flag.Attach = 1 ;
}

/*****************************************************************************
 * InitTargetIC
 *****************************************************************************/
void InitTargetIC(void)
{
	if (Diagnostic(0) == FALSE_U)
		panic(2);
	
	rEP0IntStat = 0xFF;
	rEPaIntStat = 0xFF;
	rEPbIntStat = 0xFF;
	rEPcIntStat = 0xFF;
	rEPrIntStat = 0xFF;
	rDMA_IntStat = 0xFF;
	rFIFO_IntStat = 0xFF;
	rSIE_IntStat = 0xFF;
	rMainIntStat = 0xFF;

	rMainIntEnb_BP.EnSIE_IntStat = 1;
	rMainIntEnb_BP.EnEPrIntStat = 1;
	rMainIntEnb_BP.EnDMA_IntStat = 1;
	rMainIntEnb_BP.EnFIFO_IntStat = 1;
	rMainIntEnb_BP.EnEP0IntStat = 1;

	rSIE_IntEnb_BP.EnVBUS_Changed = 1;
	rSIE_IntEnb_BP.EnSetAddressCmp = 1;

	rEPrIntEnb_BP.EnEPaIntStat = 1;
	rEPrIntEnb_BP.EnEPbIntStat = 1;
	rEPrIntEnb_BP.EnEPcIntStat = 1;

	rFIFO_IntEnb_BP.EnFIFO_IN_Cmp = 1;
	rFIFO_IntEnb_BP.EnFIFO_OUT_Cmp = 1;
	rFIFO_IntEnb_BP.EnDescriptorCmp = 1;

	/* USB Configuration */
	rUSB_Control = 0x00;
	rXcvrControl = 0x01;
	rUSB_Test = 0x00;

	/* Bus Configuration */
	rDMA_Config_0_BP.PDREQ_Level = 0;			/* Active-High  */
	rDMA_Config_0_BP.PDACK_Level = 0;			/* Active-High  */
	rDMA_Config_0_BP.PDRDWR_Level = 0;			/* Active-Low  */
	rDMA_Config_0_BP.ActivePort = 1;
	rDMA_Config_1_BP.SingleWord = 1;
	rDMA_Config_1_BP.CountMode = 1;				/* CountMode */
//	rDMA_Latency = 0xf;

	SetReplyDescriptorData();

	/* FIFO */
	rEPaStartAdrs_H = 0x02;						/* EPa = 0x200-0x27F(128Byte) */
	rEPaStartAdrs_L = 0x00;
	rEPbStartAdrs_H = 0x02;						/* EPb = 0x280-0x2FF(128Byte) */
	rEPbStartAdrs_L = 0x80;
	
	rEPcStartAdrs_H = 0x03;						/* EPc = 0x300-0x300(0Byte) */
	rEPcStartAdrs_L = 0x00;
	rEPdStartAdrs_H = 0x03;						/* EPd = 0x300-0x300(0Byte) */
	rEPdStartAdrs_L = 0x00;
	rEPeStartAdrs_H = 0x03;						/* EPe = 0x300-0x300(0Byte) */
	rEPeStartAdrs_L = 0x00;
	rEPfStartAdrs_H = 0x03;						/* EPf = 0x300-0x300(0Byte) */
	rEPfStartAdrs_L = 0x00;
	rEPgStartAdrs_H = 0x03;						/* EPg = 0x300-0x300(0Byte) */
	rEPgStartAdrs_L = 0x00;
	rEPhStartAdrs_H = 0x03;						/* EPh = 0x300-0x300(0Byte) */
	rEPhStartAdrs_L = 0x00;
}

/*****************************************************************************
 * Diagnostic
 *****************************************************************************/
int Diagnostic(int loop)
{
	int fifo_remain;
	int RegErr,FIFOErr;

	do
	{
		rEPnControl_BP.AllFIFO_Clr = 1;			/* All FIFO Clear */

		rDMA_Control_BP.DMA_Stop = 1;			/* DMA Stop */
		while(rDMA_Control_BP.DMA_Running == 1);

		RegErr	= 1;
		FIFOErr = 1;

		do
		{
			rEPaIntEnb = 0x7F; if( rEPaIntEnb != 0x7F ) break;
			rEPaIntEnb = 0x55; if( rEPaIntEnb != 0x55 ) break;
			rEPaIntEnb = 0x2A; if( rEPaIntEnb != 0x2A ) break;
			rEPaIntEnb = 0x00; if( rEPaIntEnb != 0x00 ) break;

			rUSB_Address = 0x7F; if( rUSB_Address != 0x7F ) break;
			rUSB_Address = 0x55; if( rUSB_Address != 0x55 ) break;
			rUSB_Address = 0x2A; if( rUSB_Address != 0x2A ) break;
			rUSB_Address = 0x00; if( rUSB_Address != 0x00 ) break;

			rDMA_Count_HH = 0xFF; if( rDMA_Count_HH != 0xFF ) break;
			rDMA_Count_HH = 0x55; if( rDMA_Count_HH != 0x55 ) break;
			rDMA_Count_HH = 0xAA; if( rDMA_Count_HH != 0xAA ) break;
			rDMA_Count_HH = 0x00; if( rDMA_Count_HH != 0x00 ) break;

			rDMA_Latency = 0x0F; if( rDMA_Latency != 0x0F ) break;
			rDMA_Latency = 0x05; if( rDMA_Latency != 0x05 ) break;
			rDMA_Latency = 0x0A; if( rDMA_Latency != 0x0A ) break;
			rDMA_Latency = 0x00; if( rDMA_Latency != 0x00 ) break;

			rEPaMaxSize_L = 0xFF; if( rEPaMaxSize_L != 0xFF ) break;
			rEPaMaxSize_L = 0x55; if( rEPaMaxSize_L != 0x55 ) break;
			rEPaMaxSize_L = 0xAA; if( rEPaMaxSize_L != 0xAA ) break;
			rEPaMaxSize_L = 0x00; if( rEPaMaxSize_L != 0x00 ) break;

			RegErr = 0;
			
			/* FIFO  */
			rEP0MaxSize = 0x08;							/* EP0 MaxPacketSize = 8Byte */
			rEPnControl_BP.AllFIFO_Clr = 1;				/* All FIFO Clear */

			rCPU_JoinRd = 0x00;
			rCPU_JoinWr = 0x00;
			rEnEPnFIFO_Access_BP.EnEPnFIFO_Wr = 1;

			rEPnFIFOforCPU = 0x00;
			rEPnFIFOforCPU = 0xFF;
			rEPnFIFOforCPU = 0x55;
			rEPnFIFOforCPU = 0xAA;
			rEnEPnFIFO_Access_BP.EnEPnFIFO_Wr = 0;

			fifo_remain = MKWORD( rEPnRdRemain_H,rEPnRdRemain_L );
			if( fifo_remain != 0x04 ) break;
			
			fifo_remain = MKWORD( rEPnRdRemain_H,rEPnRdRemain_L );
			if( fifo_remain != 0x04 ) break;
			
			rEnEPnFIFO_Access_BP.EnEPnFIFO_Rd = 1;
			if( rEPnFIFOforCPU != 0x00 ) break;
			if( rEPnFIFOforCPU != 0xFF ) break;
			if( rEPnFIFOforCPU != 0x55 ) break;
			if( rEPnFIFOforCPU != 0xAA ) break;
			rEnEPnFIFO_Access_BP.EnEPnFIFO_Rd = 0;

			fifo_remain = MKWORD( rEPnRdRemain_H,rEPnRdRemain_L );
			
			if( fifo_remain != 0x00 ) break;
			
			FIFOErr = 0;

		} while (0);
		
		if (RegErr)
			DiagRegErrorCount++;

		if (FIFOErr)
			DiagFIFOErrorCount++;

	} while (loop);
	
	if( RegErr == 0 && FIFOErr == 0 )
		return TRUE_U;
	else
		return FALSE_U;
}

/*****************************************************************************
 *	SetReplyDescriptorData
 *****************************************************************************/
void SetReplyDescriptorData(void)
{
	BYTE *temp_ptr, num_alt_set;
	WORD i, j, k, l, len;
	ConfigDesc *p_c_desc;
	InterfaceDesc *p_i_desc;
	
	rDescAdrs_H = 0x00;
	rDescAdrs_L = 0x40;

	/* FSDevice Descriptor */
	desc_addr_fs_device = MKWORD( rDescAdrs_H,rDescAdrs_L );

	/* FSDevice Descriptor */
	temp_ptr = (BYTE *)&fs_device_desc;
	for( i=0; i<fs_device_desc.bLength; i++)
		rDescDoor = temp_ptr[i];

	/* FSConfiguration Descriptor */
	desc_addr_fs_config = MKWORD( rDescAdrs_H,rDescAdrs_L );

	p_c_desc = &fs_config_desc;
	p_i_desc = &fs_interface_desc[0];
	num_alt_set = NUM_FS_ALT_SET;

	len = p_c_desc->bLength;

	/* Configuration Descriptor */
	temp_ptr = (BYTE *)p_c_desc;
	for( j=0; j<len; j++ )
		rDescDoor = temp_ptr[j];

	for( j=0; ; j++ )
	{
		len = p_i_desc->bLength;

		/* Interface Descriptor */
		temp_ptr = (BYTE *)&p_i_desc[j];
		for( k=0; k<len; k++ )
			rDescDoor = temp_ptr[k];
		
		for( k=0; k<p_i_desc[j].bNumEndpoints; k++ )
		{
			len = p_i_desc[j].p_e_desc[k].bLength;
			temp_ptr = (BYTE *)&(p_i_desc[j].p_e_desc[k]);
			for( l=0; l<len; l++ )
				rDescDoor = temp_ptr[l];
		}
		if( j >= num_alt_set )
			break;
	}

	for( i=0; i<NUM_STRING; i++ )
	{
		/* String Descriptor */
		desc_addr_string[i] = MKWORD( rDescAdrs_H, rDescAdrs_L );

		temp_ptr = (BYTE *)string_table[i];
		len = temp_ptr[0];
		for( j=0; j<len; j++ )
			rDescDoor = temp_ptr[j];
	}
}

/*****************************************************************************
 *	InitWorkArea
 *****************************************************************************/
void InitWorkArea(void)
{
	DIRECT_B(main_int_stat) = 0x00;		/* main_int_stat  */
	DIRECT_B(sie_int_stat)	= 0x00;		/* sie_int_stat  */
	DIRECT_B(epr_int_stat)	= 0x00;		/* epr_int_stat  */
	DIRECT_B(dma_int_stat)	= 0x00;		/* dma_int_stat  */
	DIRECT_B(fifo_int_stat)	= 0x00;		/* fifo_int_stat  */
	DIRECT_B(ep0_int_stat)	= 0x00;		/* ep0_int_stat  */
	DIRECT_B(epa_int_stat)	= 0x00;		/* epa_int_stat  */
	DIRECT_B(epb_int_stat)	= 0x00;		/* epb_int_stat  */
	DIRECT_B(epc_int_stat)	= 0x00;		/* epc_int_stat  */

	/* Timer */
	timer0_cnt = timer1_cnt = 0x00;

	cmd_status = 0x00;
	DIRECT_B(device_flag)	= 0x00;
	wk_lba = wk_cnt = 0x00;
	wk_ptr = 0x00;

	control_state  = CTRL_IDLE;
	bulk_in_state  = BULK_IN_IDLE;
	bulk_out_state = BULK_OUT_IDLE;
	int_in_state   = INT_IN_IDLE;
	device_state   = DEV_WAIT_RCV_CMD;

	protocol_phase = COMMAND_PHASE;

	DiagRegErrorCount  = 0;
	DiagFIFOErrorCount = 0;

	/* USB */
	InitUSBWorkArea();
	/* Device */
	InitDeviceWorkArea();
}

/*****************************************************************************
 *	InterruptProc
 *****************************************************************************/
void InterruptProc(void)
{
	DIRECT_B(main_int_stat_sv) = rMainIntStat;
	DIRECT_B(main_int_stat) |= DIRECT_B(main_int_stat_sv);

	if(main_int_stat_sv.SIE_IntStat)
	{
		/* SIE */
		DIRECT_B(sie_int_stat_sv) = rSIE_IntStat;
#ifdef DIS_AUTONEGO
		if(sie_int_stat_sv.DetectJ)
		{
			rSIE_IntEnb_BP.EnDetectJ = 0;	/* DetectJ */
			rUSB_Control_BP.StartDetectJ = 0;	/* J */
			rUSB_Control_BP.DisBusDetect = 0;	/* ResetSuspend */
		}
#endif /* DIS_AUTONEGO */

		if(sie_int_stat_sv.NonJ)
		{
			rSIE_IntEnb_BP.EnNonJ = 0;		/* NonJ */
		}

#ifdef DIS_AUTONEGO
		if(sie_int_stat_sv.DetectRESET)
		{
			rUSB_Control_BP.DisBusDetect = 1;		/*  ->  */
		}
#endif /* DIS_AUTONEGO */

		DIRECT_B(sie_int_stat) |= DIRECT_B(sie_int_stat_sv);
		rSIE_IntStat = DIRECT_B(sie_int_stat_sv);
	}
	
	if(main_int_stat_sv.EPrIntStat)
	{
		/* EPr */
		DIRECT_B(epr_int_stat_sv) = rEPrIntStat;	/* EPx */
		rEPrIntStat = DIRECT_B(epr_int_stat_sv);
		DIRECT_B(epr_int_stat) |= DIRECT_B(epr_int_stat_sv);

		if(epr_int_stat_sv.EPaIntStat)
		{
			/* EPa */
			DIRECT_B(epa_int_stat_sv) = rEPaIntStat;
			rEPaIntStat = DIRECT_B(epa_int_stat_sv);
			DIRECT_B(epa_int_stat) |= DIRECT_B(epa_int_stat_sv);
		}
		if(epr_int_stat_sv.EPbIntStat)
		{
			/* EPb */
			DIRECT_B(epb_int_stat_sv) = rEPbIntStat;
			rEPbIntStat = DIRECT_B(epb_int_stat_sv);
			DIRECT_B(epb_int_stat) |= DIRECT_B(epb_int_stat_sv);
		}
		if(epr_int_stat_sv.EPcIntStat)
		{
			/* EPc */
			DIRECT_B(epc_int_stat_sv) = rEPcIntStat;
			rEPcIntStat = DIRECT_B(epc_int_stat_sv);
			DIRECT_B(epc_int_stat) |= DIRECT_B(epc_int_stat_sv);
		}
	}
	
	if( main_int_stat_sv.DMA_IntStat )
	{
		DIRECT_B(dma_int_stat_sv) = rDMA_IntStat;	/* DMA */
		rDMA_IntStat = DIRECT_B(dma_int_stat_sv);
		DIRECT_B(dma_int_stat) |= DIRECT_B(dma_int_stat_sv);
	}
	
	if( main_int_stat_sv.FIFO_IntStat )
	{
		DIRECT_B(fifo_int_stat_sv) = rFIFO_IntStat;	/* FIFO */
		rFIFO_IntStat = DIRECT_B(fifo_int_stat_sv);
		DIRECT_B(fifo_int_stat) |= DIRECT_B(fifo_int_stat_sv);
	}
	
	if( main_int_stat_sv.EP0IntStat )
	{
		/* EP0 */
		DIRECT_B(ep0_int_stat_sv) = rEP0IntStat;
		DIRECT_B(ep0_int_stat) |= DIRECT_B(ep0_int_stat_sv);
		rEP0IntStat = DIRECT_B(ep0_int_stat_sv);
	}
	rMainIntStat = DIRECT_B(main_int_stat_sv) & 0xFE;
}

/*****************************************************************************
 * Timer0IntProc
 *****************************************************************************/
void Timer0IntProc(void)
{
	timer0_cnt++;
}