u_idle.c

The combined demo is dedicated for S1C33L05, so DMT33L05 should be used to load and run the demo. F

/******************************************************************************
 * File name   : idle.c
 * Module name : main polling loop module
 * Author	   : Hiromichi.Kondo
 *-----------------------------------------------------------------------------
 * $Id: idle.c,v 1.2 2003/04/16 10:16:33 9551619 Exp $
 *****************************************************************************/

//---------------------------------------------------------------------------------
// Include files (#include)
//---------------------------------------------------------------------------------
#include "u_value.h"
#include "u_ram_data.h"
#include "u_rom_data.h"
#include "u_c33cpu.h"
#include "u_regNikka.h"
#include "u_usb_fp.h"
#include "u_dev_fp.h"
#include "u_com_fp.h"

#include "usbfw_if.h"
#include "comFS.h"

//---------------------------------------------------------------------------------
// Marco definition
//---------------------------------------------------------------------------------
#define TRUE    	1
#define FALSE    	0

/*--- Function Prototype ---------------------------------------------------*/
void USB_MON_Proc(void);
void Attach_ev(void);
void Detach_ev(void);
void SpecialProc(void);
void IntStatusCheck(void);
void EPrIntStatusCheck(void);

//---------------------------------------------------------------------------------
// Global & static variables
//---------------------------------------------------------------------------------
unsigned int		alrdy_attach ;	


//---------------------------------------------------------------------------------
//  Function name	 		:USB_MON_Proc	
// 	Function description	:USB monitor process
//		 
//      Parameters
//         Input  			:void  
//         Output 			:void
//         I/O    			:void
//      
//      Return value 		:void 	
//
//	Global variable 		:void	
//---------------------------------------------------------------------------------
void USB_MON_Proc(void)
{
	unsigned char vbus_state,line_state;
	
 	*(volatile unsigned char*)REG_TM8_4_IFLAG |= 0x01;		/* 8-bit timer 4 clr intflg	*/

	vbus_state = VBUSCheck();					/* Check vbus status	*/
	if( vbus_state == VBUS_CONNECT ){/* ?start vbus_state ==... */
		
		if(vbus_on_1st == FALSE){
			g_UsbIFAns.ubAnsCmplt = FALSE;
			g_UsbIFAns.ubAnsCmd = 0xff;
			Attach_ev();
		}

		if(g_UsbIFAns.ubAnsCmplt == TRUE){/* ?start g_UsbIFAns.ubAnsCmplt == ...*/
			if(g_UsbIFAns.ubAnsCmd == USBFW_CMD_ATTACH){/* ?start g_UsbIFAns.ubAnsCmd == ...*/
				if(g_UsbIFAns.ubAnsAttchOK == TRUE){/* ? start g_UsbIFAns.ubAnsAttchOK == ...*/
					g_UsbIFAns.ubAnsCmplt = FALSE ;
					g_UsbIFAns.ubAnsCmd = 0xff ;
						
					// Disk Info setup
					last_lba = g_StgMediaInfo.secPerDrv ;
					sram_start_addr = (unsigned int)&usb_wk_buf[0];
					
					AttachProc();			/* USB attach process	*/
					alrdy_attach = TRUE;
				}/* ? end g_UsbIFAns.ubAnsAttchOK == ...*/
			}/* ?end g_UsbIFAns.ubAnsCmd == ...*/
		}/* ?end g_UsbIFAns.ubAnsCmplt == ...*/
		
		if(alrdy_attach == TRUE){
			// USB monitor & process
			SpecialProc();					/* Special process	*/
			USBProc();						/* USB process		*/
			DeviceProc();					/* Device process	*/
			IntStatusCheck();				/* Int status check */
		}
		
	}else{/* ?else vbus_state ==... */
		if(alrdy_attach == TRUE){
			g_UsbIFAns.ubAnsCmplt = FALSE ;
			g_UsbIFAns.ubAnsCmd = 0xff ;
			DetachProc();					/* Detach */
			vbus_on_1st = FALSE;
			Detach_ev();
		}

		if(g_UsbIFAns.ubAnsCmplt == TRUE){
			if(g_UsbIFAns.ubAnsCmd == USBFW_CMD_DETACH){
				g_UsbIFAns.ubAnsCmplt = FALSE ;
				g_UsbIFAns.ubAnsCmd = 0xff ;
			}
		}
	}/* ?end vbus_state ==... */
}

//---------------------------------------------------------------------------------
//  Function name	 		:Attach_ev	
// 	Function description	:Attach event process
//		 
//      Parameters
//         Input  			:void  
//         Output 			:void
//         I/O    			:void
//      
//      Return value 		:void 	
//
//	Global variable 		:void	
//---------------------------------------------------------------------------------

void Attach_ev(void)
{
	if(g_UsbIFReq.ubReqFlg == USBFW_FLAG_OFF ){
		g_UsbIFReq.ubReqCmd = USBFW_CMD_ATTACH;
		vbus_on_1st = TRUE;
		*(volatile unsigned char*)REG_TM8_4_LDAT = TM8_4_VALUE/5; /* 1ms */
		g_UsbIFReq.ubReqFlg = USBFW_FLAG_ON;
	}
}

//---------------------------------------------------------------------------------
//  Function name	 		:Detach_ev	
// 	Function description	:Detach event process
//		 
//      Parameters
//         Input  			:void  
//         Output 			:void
//         I/O    			:void
//      
//      Return value 		:void 	
//
//	Global variable 		:void	
//---------------------------------------------------------------------------------
void Detach_ev(void)
{
	if(g_UsbIFReq.ubReqFlg == USBFW_FLAG_OFF ){
		g_UsbIFReq.ubReqCmd = USBFW_CMD_DETACH;
		alrdy_attach = FALSE;
		vbus_on_1st = FALSE;
		*(volatile unsigned char*)REG_TM8_4_LDAT = TM8_4_VALUE;	  /*5ms */
		g_UsbIFReq.ubReqFlg = USBFW_FLAG_ON;
	}
}

//---------------------------------------------------------------------------------
//  Function name	 		:SpecialProc	
// 	Function description	:Special event process
//		 
//      Parameters
//         Input  			:void  
//         Output 			:void
//         I/O    			:void
//      
//      Return value 		:void 	
//
//	Global variable 		:void	
//---------------------------------------------------------------------------------
void SpecialProc(void)
{
	if( DIRECT_B(special_flag) ){

		if( special_flag.Reset )	/* Reset	*/	
			USBResetProc();
		
		if( special_flag.Suspend )	/* Suspend	*/
			SuspendResumeProc();
	}
}

//---------------------------------------------------------------------------------
//  Function name	 		:IntStatusCheck	
// 	Function description	:int status process
//		 
//      Parameters
//         Input  			:void  
//         Output 			:void
//         I/O    			:void
//      
//      Return value 		:void 	
//
//	Global variable 		:void	
//---------------------------------------------------------------------------------
void IntStatusCheck(void)
{
	BYTE vbus_state;
	
	di();								/* CPU */
	if( main_int_stat.SIE_IntStat ){
		/* SIE */

		if( sie_int_stat.VBUS_Changed ){

			/* VBUS  */
			vbus_state = VBUSCheck();
			if(vbus_state == VBUS_NOT_CONNECT){
				/* Detach  */
				special_flag.Detach = 1;
				DIRECT_B(main_int_stat) = 0x00;	/* Main */
			}
		}else{
			if( sie_int_stat.DetectRESET ){
				/* USB Reset  */
				special_flag.Reset = 1;
				DIRECT_B(main_int_stat) = 0x00;	/* Main */

			}else{
				if( sie_int_stat.DetectSUSPEND ){
					/*  */
					special_flag.Suspend = 1;
					DIRECT_B(main_int_stat) = 0x00;	/* Main */
				}
			}
		}
		if( sie_int_stat.SetAddressCmp ){
			/* SetAddressCmp */

			if( rUSB_Address_BP.USB_Address == 0x00 ){
				/* Default State */

				usb_state = DEFAULT_STATE;
			}else{
				/* Address State */

				usb_state = ADDRESS_STATE;
			}
		}
		DIRECT_B(sie_int_stat) = 0x00;
	}

	if( main_int_stat.FIFO_IntStat ){
		/* FIFO */
		if( fifo_int_stat.DescriptorCmp ){
			/* DescriptorCmp */
			control_result = DESCRIPTOR_CMP;
		}

		if( fifo_int_stat.FIFO_IN_Cmp ){
			/* FIFO_IN_Cmp */

			bulk_in_result = FIFO_IN_CMP;
		}

		if( fifo_int_stat.FIFO_OUT_Cmp ){
			/* FIFO_OUT_Cmp */

			bulk_out_result = FIFO_OUT_CMP;
		}
	}

	if( main_int_stat.EP0IntStat ){
		/* EP0 */

		DIRECT_B(ep0_int_stat) = DIRECT_B(ep0_int_stat) & rEP0IntEnb;

		if( ep0_int_stat.IN_TranErr ){
			control_result = EP0_IN_ERR;
		}
		if( ep0_int_stat.OUT_TranErr ){
			control_result = EP0_OUT_ERR;
		}
		if( ep0_int_stat.IN_TranACK ){
			control_result = EP0_IN_ACK;
		}
		if( ep0_int_stat.OUT_TranACK ){
			control_result = EP0_OUT_ACK;
		}
		DIRECT_B(ep0_int_stat) = 0x00;			/* EP0 */
	}
	if( main_int_stat.EPrIntStat ){
		/* EPr */

		EPrIntStatusCheck();			/* EPr */
	}

	if(rMainIntStat_BP.RcvEP0SETUP){
		/* SETUP  */

		usb_flag.USBReqRcvd = 1;
	}
	DIRECT_B(main_int_stat) = 0x00;
	ei();								/* CPU */
}

//---------------------------------------------------------------------------------
//  Function name	 		:EPrIntStatusCheck	
// 	Function description	:int EPr status process
//		 
//      Parameters
//         Input  			:void  
//         Output 			:void
//         I/O    			:void
//      
//      Return value 		:void 	
//
//	Global variable 		:void	
//---------------------------------------------------------------------------------
void EPrIntStatusCheck(void)
{
	if( epr_int_stat.EPaIntStat ){
		/* EPa */

		if( bulk_in_result != FIFO_IN_CMP ){

			DIRECT_B(epa_int_stat) = DIRECT_B(epa_int_stat) & rEPaIntEnb;

			if( epa_int_stat.IN_TranErr ){
				bulk_in_result = EPX_IN_ERR;
			}
			if( epa_int_stat.OUT_TranErr ){
				bulk_in_result = EPX_OUT_ERR;
			}
			if( epa_int_stat.IN_TranACK ){
				bulk_in_result = EPX_IN_ACK;
			}
			if( epa_int_stat.OUT_TranACK ){
				bulk_in_result = EPX_OUT_ACK;
			}
		}
		DIRECT_B(epa_int_stat) = 0x00;			/* EPa */
	}
	if( epr_int_stat.EPbIntStat ){
		/* EPb */

		if( bulk_out_result != FIFO_OUT_CMP ){
			DIRECT_B(epb_int_stat) = DIRECT_B(epb_int_stat) & rEPbIntEnb;

			if( epb_int_stat.IN_TranErr ){
				bulk_out_result = EPX_IN_ERR;
			}
			if( epb_int_stat.OUT_TranErr ){
				bulk_out_result = EPX_OUT_ERR;
			}
			if( epb_int_stat.IN_TranACK ){
				bulk_out_result = EPX_IN_ACK;
			}
			if( epb_int_stat.OUT_TranACK ){
				bulk_out_result = EPX_OUT_ACK;
			}
		}
		DIRECT_B(epb_int_stat) = 0x00;			/* EPb */
	}
	if( epr_int_stat.EPcIntStat ){
		/* EPc */

		DIRECT_B(epc_int_stat) = DIRECT_B(epc_int_stat) & rEPcIntEnb;

		if( epc_int_stat.IN_TranErr ){
			int_in_result = EPX_IN_ERR;
		}
		if( epc_int_stat.OUT_TranErr ){
			int_in_result = EPX_OUT_ERR;
		}
		if( epc_int_stat.IN_TranACK ){
			int_in_result = EPX_IN_ACK;
		}
		if( epc_int_stat.OUT_TranACK ){
			int_in_result = EPX_OUT_ACK;
		}
		DIRECT_B(epc_int_stat) = 0x00;			/* EPc */
	}
	DIRECT_B(epr_int_stat) = 0x00;
}

/**** End of file ***********************************************************/