otgsvc.c

使用ISP1362芯片的USB_OTG参考设计源代码比较新的版本

/*
   //*************************************************************************
   //
   //                  P H I L I P S   P R O P R I E T A R Y
   //
   //           COPYRIGHT (c)   2000-2002 BY PHILIPS SINGAPORE.
   //                     --  ALL RIGHTS RESERVED  --
   //
   // File Name:	OTGSVC.C
   // Created:		Feb. 1, 2000
   // Modified:		Jun. 6, 2002 by [e-mail]
   // Revision:		1.0
   //
   //*************************************************************************
   // Abstract:
   //
 //*************************************************************************
*/

/*
**  WASABI-Hot! version 1.2c    (OTG sub-unit)
**
**      ** This code has been made to check/learn                          ** 
**      **                             the ISP1362/ISP1363 functionalities **
**      ** Release 06-Aug-2004                                             **
**
*/

#include <stdio.h>
#include <string.h>
#include <bios.h>
#include <dos.h>
#include <malloc.h>

#include		"general.h"


#ifdef WASABI


#include		"_hc_hw/hc_comm.h"
#include		"_hc_hw/hw_acces.h"

#include 		"_otg/HAL4OTG.h"
#include 		"_otg/OTGSvc.h"
#include 		"_otg/otg.h"

#include		"_dc/dc_flags.h"
#include		"_dc/dc_isr.h"

#include		"ui.h"


#else


#include "BasicTyp.h"
#include "common.h"
#include "SysCnfg.h"


#include "HAL4Sys.h"
#include "HAL4ISA.h"
#include "HAL4IKit.h"
#include "HAL4D13.h"
#include "HAL4HC.h"

#include "D13_Reg.h"
#include "D13_Dcs.h"
#include "DcCommon.h"
#include "DCISR.h"

#include "PHC_Reg.h"

#include "USB100.h"
#include "USBstd.h"

#include "Hal4OTG.h"
#include "OTGSvc.h"

#endif


//*************************************************************************
//  Public/Global static data
//*************************************************************************

extern OTG_REG	OtgReg;
OTG_TCB			OtgTcb;


//*************************************************************************
//  OTG Functions
//*************************************************************************

void OTGCtrl_LocalVBus(BOOL bOn)
{
	if(1 == OtgTcb.id)
		Hal4OTG_VBUS_SessionReq(bOn);
	else
		Hal4OTG_VBUS_PowerUp(bOn);
}

void OTGCtrl_LocalPullup(BOOL bOn)
{
	Hal4OTG_PULLUP_CTRL(bOn);
}

void OTGCtrl_LocalPulldown(BOOL bOn)
{
	Hal4OTG_PULLDOWN_CTRL(bOn);
}



#ifdef		WASABI
void OTGCtrl_LocalSOF(BOOL dummy)
{
	dummy	= dummy;
//	portctl_OTG_port_enable_disable( (unsigned char)bOn );
}
#else
void OTGCtrl_LocalSOF(BOOL bOn)
{
#if 1
	if(bOn)
	{
		PHC_Control(0x00000080);	// HOST Controller in Operation Mode
	}
	else
	{
		PHC_Control(0x000000C0);    // HOST Controller in Suspend Mode
	}
#else
	Hal4OTG_SuspendOTGPort(bOn);
#endif
}
#endif






void OTGStatus_Probe(void)
{

#ifndef		WASABI
	SLH_REG_ULONG	SlhReg;
#endif

	ULONG			IR;

	Hal4OTG_Status();
//	printf("Debug: OTG status/int reigsters are: %x / %x\n", OtgReg.StatusPort.Word, OtgReg.StatusChangePort.Word);

	OtgTcb.id = OtgReg.StatusPort.bitmap.ID;
	OtgTcb.a_vbus_vld = OtgReg.StatusPort.bitmap.a_vbus_vld;
	OtgTcb.a_sess_vld = OtgReg.StatusPort.bitmap.a_sess_vld;
	OtgTcb.b_sess_end = OtgReg.StatusPort.bitmap.b_sess_end;
	OtgTcb.b_sess_vld = OtgReg.StatusPort.bitmap.b_sess_vld;
	OtgTcb.b_se0_srp = OtgReg.StatusPort.bitmap.b_se0_srp;

	if(OtgReg.StatusChangePort.bitmap.otg_tmr_tmout)
		OtgTcb.TimeOut = 1;

	if(OtgTcb.id == 0)  	//A-device
	{
		OtgTcb.b_conn = OtgReg.StatusPort.bitmap.rmt_conn;
		if(OtgReg.StatusChangePort.bitmap.bus_resume)
			OtgTcb.b_bus_resume = 1;

		if(OtgReg.StatusChangePort.bitmap.a_srp_det)
			OtgTcb.a_srp_det = 1;
	}
	else         			//B-device
	{
		OtgTcb.a_conn = OtgReg.StatusPort.bitmap.rmt_conn;

		if(OtgReg.StatusChangePort.bitmap.bus_resume)
			OtgTcb.a_bus_resume = 1;
	}
}

void OTG_StartTimer(ULONG	uTime, USHORT uTimerID )
{
	OtgTcb.TimerID = uTimerID;
	OtgTcb.TimeOut = 0;
	Hal4OTG_StartTimer(uTime*100);	//OTG HW timer base is 0.01ms
}

void OTG_StopTimer(void)
{
	OtgTcb.TimeOut = 0;
	Hal4OTG_StopTimer();
//	OtgTcb.TimerRunning = FALSE;
}

void OTG_FSM4DeviceB()
{
	switch (OtgTcb.FSM)
	{
		// B StateMachine
		case B_IDLE:

			OTGCtrl_LocalVBus(FALSE);
			OTGCtrl_LocalPullup(FALSE);
			OTGCtrl_LocalPulldown(TRUE);
			OTGCtrl_LocalSOF(FALSE);
			Hal4OTG_HC_DC_Sel(TRUE);	//default is DC

			if(	0 == OtgTcb.id )
			{
				OTGsup_SetVarible();
				OtgTcb.err_code = OTG_ERR_PLUGA_INSERTED;
				Hal4OTG_SRP_Det_En(TRUE);	//enable SRP detection
				OtgTcb.FSM = A_IDLE;
			}
			else if ( 1 == OtgTcb.bus_req && \
					  1 == OtgTcb.b_sess_end && \
					  1 == OtgTcb.b_se0_srp && \
					  0 == OtgTcb.b_srp_done) \
			{
				OtgTcb.FSM = B_SRP_INIT;
						
#ifdef	WASABI
				if ( gp_emulate_peripheral_only )
					OtgTcb.bus_req	= 0;
#endif
				
			}
			else if ( 1 == OtgTcb.b_sess_vld )
			{
#ifdef	WASABI
#else
				DcS_EnableIRQ();
#endif
				OtgTcb.FSM = B_PERIPHERAL;
			}
			else if ( 1 == OtgTcb.TimeOut )
			{
				OtgTcb.TimeOut = 0;
				OtgTcb.err_code = OTG_ERR_SRP_FAIL;
			}
			break;

		case B_SRP_INIT:

			if(	0 == OtgTcb.id || 1 == OtgTcb.b_srp_done )
			{
				if(1==OtgTcb.b_srp_done )
					OTG_StartTimer(B_BUS_REQ_TIMER,B_BUS_REQ_TIMER_ID);	//Allow 5s for A-device responding SRP
				OtgTcb.FSM = B_IDLE;
			}
			break;

		case B_PERIPHERAL:

			OTGCtrl_LocalPullup(TRUE);
			OTGCtrl_LocalSOF(FALSE);
			Hal4OTG_HC_DC_Sel(TRUE);

			if( 0 == OtgTcb.b_sess_vld \
				|| 0 == OtgTcb.id ) \
			{
#ifdef	WASABI
				OTG_exit_from_peripheral_state();
#else
				DcS_DisableIRQ();
#endif
				OTGsup_SetVarible();
				OtgTcb.FSM = B_IDLE;
			}
			else if ( 1 == OtgTcb.bus_req \
					&& 1 == OtgTcb.b_hnp_en \
					&& (1 == OtgTcb.a_bus_suspend) \
			)
			{
#ifdef	WASABI
				OTG_exit_from_peripheral_state();
#else
				DcS_DisableIRQ();
#endif
				Hal4OTG_RconLse0_En(TRUE);	//to meet the 1ms tight requirement
				OTGCtrl_LocalPullup(FALSE);
				Hal4Sys_WaitinUS(100);
				Hal4OTG_HC_DC_Sel(FALSE);
				OTG_StartTimer(B_ASE0_BRST_TIMER,B_ASE0_BRST_TIMER_ID);
				OtgTcb.FSM = B_WAIT_ACON;
			}
			break;

		case B_WAIT_ACON:

			OTGCtrl_LocalPullup(FALSE);
			OTGCtrl_LocalSOF(FALSE);
			Hal4OTG_HC_DC_Sel(FALSE);

			if(	0 == OtgTcb.b_sess_vld || 0 == OtgTcb.id )
			{
				OTG_StopTimer();
				Hal4OTG_RconLse0_En(FALSE);
				OTGsup_SetVarible();
				OtgTcb.FSM = B_IDLE;
			}
			else if( 1 == OtgTcb.a_conn )
			{
				OTG_StopTimer();
				Hal4OTG_RconLse0_En(FALSE);
				OtgTcb.FSM = B_HOST;
			}
			else if( 1 == OtgTcb.TimeOut || 1 == OtgTcb.a_bus_resume/* || 1 == OtgTcb.a_bus_reset*/ )
			{
				if( 1 == OtgTcb.TimeOut)
				{
					OtgTcb.TimeOut = 0;
					OtgTcb.a_bus_reset = 1;	//SE0 >3.125ms should be taken as bus reset
					OtgTcb.a_alt_hnp_support = 0;
					OtgTcb.a_hnp_support = 0;
					OtgTcb.b_hnp_en = 0;
					OtgTcb.err_code = OTG_ERR_B_ASE0_BRST_TMOUT;
				}
				else
				{
					OtgTcb.a_bus_resume = 0;
				}
				Hal4OTG_RconLse0_En(FALSE);
#ifdef	WASABI
#else
				DcS_EnableIRQ();
#endif
				OtgTcb.FSM = B_PERIPHERAL;
			}
			break;

		case B_HOST:

			OTGCtrl_LocalPullup(FALSE);
			OTGCtrl_LocalSOF(TRUE);
			Hal4OTG_HC_DC_Sel(FALSE);

			if(	0 == OtgTcb.b_sess_vld || 0 == OtgTcb.id )
			{
#ifdef WASABI
				OTG_exit_from_host_state();
#endif
				OTGsup_SetVarible();
				OtgTcb.FSM = B_IDLE;
			}
			else if( (0 == OtgTcb.a_conn || 0 == OtgTcb.bus_req))
			{
#ifdef WASABI
				OTG_exit_from_host_state();
#else
				DcS_EnableIRQ();
#endif
				OtgTcb.FSM = B_PERIPHERAL;
			}
			break;

		default:
			break;
	}
}


void OTG_FSM4DeviceA()
{
	USHORT wTemp;

	switch (OtgTcb.FSM)
	{
		// A_device statemachine
		case A_IDLE:

			OTGCtrl_LocalVBus(FALSE);
			OTGCtrl_LocalPullup(FALSE);
			OTGCtrl_LocalPulldown(TRUE);
			OTGCtrl_LocalSOF(FALSE);
			Hal4OTG_HC_DC_Sel(FALSE);     	//default HC

#ifdef WASABI

			if ( gp_emulate_peripheral_only )
			{
				ui_soft_blink( "ERROR : Emulating PERIPHERAL ONLY. REMOVE A-PULG!", 200, 1 );
			}


			if ( OtgTcb.bus_drop )
			{
				OtgTcb.bus_drop		= 0;	//	Clear Vbus drop flag, now it is done
				mprintf( LIGHTRED, CONTINUE, "   ...Vbus drop command completed.\r\n" );
			}
			
#endif


			if( 1 == OtgTcb.id )
			{
				Hal4OTG_SRP_Det_En(FALSE);  //Disable SRP detection
				OTGsup_SetVarible();
				OtgTcb.err_code = OTG_ERR_PLUGA_REMOVED;
				OtgTcb.FSM = B_IDLE;
			}

			else if( (1 == OtgTcb.bus_req || 1 == OtgTcb.a_srp_det) \
					&& 0 == OtgTcb.bus_drop )
			{
				Hal4OTG_SRP_Det_En(FALSE);
				if(1 == OtgTcb.a_srp_det)
				{
					OtgTcb.a_srp_det = 0;
					Hal4Sys_WaitinMS(100);	//don't respond to SRP too fast
				}
				OTG_StartTimer(A_WAIT_VRISE_TIMER,A_WAIT_VRISE_TIMER_ID);
				OtgTcb.FSM = A_WAIT_VRISE;
			}
			break;

		case A_WAIT_VRISE:

			OTGCtrl_LocalVBus(TRUE);
			OTGCtrl_LocalPullup(FALSE);
			OTGCtrl_LocalSOF(FALSE);
			Hal4OTG_HC_DC_Sel(FALSE);

			if ( (1 == OtgTcb.a_vbus_vld && 1 == OtgTcb.b_sess_vld) \
				|| (1 == OtgTcb.TimeOut && A_WAIT_VRISE_TIMER_ID == OtgTcb.TimerID) \
			)
			{
				OtgTcb.TimeOut = 0;
				Hal4Sys_WaitinMS(3);
				OTG_StartTimer(A_WAIT_BCON_TIMER,A_WAIT_BCON_TIMER_ID);
				OtgTcb.FSM = A_WAIT_BCON;
			}
			break;

		case A_WAIT_BCON:

			OTGCtrl_LocalVBus(TRUE);
			OTGCtrl_LocalPullup(FALSE);
			OTGCtrl_LocalSOF(FALSE);
			Hal4OTG_HC_DC_Sel(FALSE);

			if( 1 == OtgTcb.id || \
				1 == OtgTcb.bus_drop || \
				(1 == OtgTcb.TimeOut && A_WAIT_BCON_TIMER_ID == OtgTcb.TimerID))
			{
				if ( 1 == OtgTcb.TimeOut)
				{