dc_isr.c

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

/*
**  WASABI-Hot! version 1.2c    (DeviceController sub-unit)
**
**
**      -- copyright (c) 2001-2004 by Philips Japan, Ltd. -- All rights reserved --
**
**
**      ** This code has been made to check/learn                          ** 
**      **                             the ISP1362/ISP1363 functionalities **
**      ** Release 06-Aug-2004                                             **
**
**     HIGASHIYAMA, Ken 
**      
**		Application Laboratory, Mobile and Connectivity
**      Semiconductors Div, Philips Japan Ltd.
**      [e-mail]
**      [phone] 
**
**
*/

#include <stdio.h>
#include <dos.h>
#include <conio.h>
#include <string.h>

#include		"general.h"
//#include		"ui.h"

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

#include "_dc/dc_main.h"
#include "_dc/dc_hal.h"
#include "_dc/dc_comm.h"
#include "_dc/dc_isr.h"
#include "_dc/dc_flags.h"
#include "_dc/dc_chap9.h"
#include "_dc/dc_spcfc.h"

#include "ui.h"
//#include "_hc_hw/dma.h"

#include 		"_otg/otg_demo.h"


//#define			DC_EVENT_LOG

#ifdef DC_EVENT_LOG
dc_event		dc_event_logger[ 4 ]	=	{
												{ 0, 0 },
												{ 0, 0 },
												{ 0, 0 },
												{ 0, 0 }
											};
unsigned char	dc_event_log_pointer	= 0;
#endif


unsigned short	setup_buf[4];
unsigned short	ctrl_out_buf[32];
unsigned short	ctrl_in_buf[32];
unsigned short	tmp_buf[32];



unsigned char	g_service_done	= True;

void dc_isr( unsigned long interrupt_reg );

void ep0out();
void ep0in();
void bus_reset();
void suspend();
void resume();
void end_of_transfer();
void start_of_frame();
void pseudo_sof();
void ep1();
void ep2();
void ep3();
void ep4();
void ep5();
void ep6();
void ep7();
void ep8();
void ep9();
void ep10();
void ep11();
void ep12();
void ep13();
void ep14();




void disable_Dc( void )
{
//	Comm_w32( W_Int_Enable, 0 );		// DC Interrupt Disable
//	Comm_w16( W_Mode_Register, Comm_r16( R_Mode_Register ) & ~INTENA );
}

void enable_Dc( void )
{
//	Comm_w32( W_Int_Enable, Int_Enable_Value );		// DC Interrupt Enable
//	Comm_w16( W_Mode_Register, Comm_r16( R_Mode_Register ) | INTENA );
}


void interrupt usb_isr( void )
{
//// mprintf( YELLOW, CONTINUE, "&" );

	disable_INT();

	Comm_w16( Unlock_Device, 0xAA37);		// Unlock suspend --> resume

//	disable_Dc();

	dc_isr( Comm_r32(R_Interrupt_Reg) );

	end_of_isr();

//	enable_Dc();

	enable_INT();
}


void usb_Dc_isr( void )
{
	dc_isr( Comm_r32( R_Interrupt_Reg ) & Comm_r32( R_Int_Enable ) );
}


#if 0
void usb_Dc_isr_old( void )
{
	interrupt_reg = Comm_r32(R_Interrupt_Reg);
//	disable_Dc();
	interrupt_reg |= Comm_r32(R_Interrupt_Reg);
	dc_isr();
//	enable_Dc();
}
#endif


void dc_isr( unsigned long interrupt_reg )
{


	if ( !interrupt_reg )
		return;
	
#ifdef DC_EVENT_LOG
	
	if ( dc_event_log_pointer < 4 )
	{
		dc_event_logger[ dc_event_log_pointer ].frame_number	= read_register32( Com32_HcFmNumber );
		dc_event_logger[ dc_event_log_pointer ].cause			= interrupt_reg;
		dc_event_log_pointer++;
	}
	
#endif
	
	
	
//	mprintf( LIGHTGREEN, CONTINUE, "dc_isr=0x%08X\r\n", interrupt_reg );


	if (interrupt_reg & EP0OUT)
		ep0out();
	if (interrupt_reg & EP0IN)
		ep0in();
	if (interrupt_reg & RST)
	{
		bus_reset();
//		Dc_printf( RED, CONTINUE, "BusReset %08lX\r\n", interrupt_reg );
	}
	if (interrupt_reg & SUSP)
		suspend();
	if (interrupt_reg & RESM)
		resume();
	if (interrupt_reg & EOT)
		end_of_transfer();
	if (interrupt_reg & SOF)
		start_of_frame();
	if (interrupt_reg & PSOF)
		pseudo_sof();
	if (interrupt_reg & EP1)
		ep1();
	if (interrupt_reg & EP2)
		ep2();
	if (interrupt_reg & EP3)
		ep3();
	if (interrupt_reg & EP4)
		ep4();
	if (interrupt_reg & EP5)
		ep5();
	if (interrupt_reg & EP6)
		ep6();
	if (interrupt_reg & EP7)
		ep7();
	if (interrupt_reg & EP8)
		ep8();
	if (interrupt_reg & EP9)
		ep9();
	if (interrupt_reg & EP10)
		ep10();
	if (interrupt_reg & EP11)
		ep11();
	if (interrupt_reg & EP12)
		ep12();
	if (interrupt_reg & EP13)
		ep13();
	if (interrupt_reg & EP14)
		ep14();
}

void ep0out( void )
{
	unsigned short len;
	// mprintf( LIGHTGREEN, CONTINUE, "ep0out()\r\n" );

	if ( Comm_r16(R_Ctrl_Out_Status) & SETUPT)	// check if received packet is Setup, Clear Interrupt
	{
		ctrl.setup=1;
		Comm_r(R_Ctrl_Out_Buf, setup_buf);	// store setup data into setup_buf[]
		Comm(Ack_Setup);				// Acknowledge Setup for re-enabling Clear & Validate for endpoint0
		Comm(Clear_Ctrl_Out);				// Clear Buffer
	}
	else
	{
	
//		ctrl.setup=0;
		len = Comm_r(R_Ctrl_Out_Buf, ctrl_out_buf); 
		Comm(Clear_Ctrl_Out);				// Clear Buffer

		if ( len )
		{
//			zero_packet();
			vendor_specific.data=1;
		}
	}
	
}

void ep0in( void )
{
	// mprintf( LIGHTGREEN, CONTINUE, "ep0in()\r\n" );

	Comm_r16(R_Ctrl_In_Status);			// Clear Interrupt
	
	if ( ctrl.read )
	{
		if ( ( wLength - wCount ) > MAX_PACKET_SIZE0 )
		{
			Comm_w( W_Ctrl_In_Buf, MAX_PACKET_SIZE0, (unsigned short *)(((unsigned char *)pControlData) + wCount) );
			Comm( Valid_Ctrl_In );
			wCount+=MAX_PACKET_SIZE0;
		}
		else
		{
			Comm_w( W_Ctrl_In_Buf, wLength - wCount, (unsigned short *)(((unsigned char *)pControlData) + wCount) );
			Comm( Valid_Ctrl_In );
			ctrl.read=0;					// end of data stage
			wCount=0;
		}
	}
}

void bus_reset( void )
{
//	Dc_printf( RED, CONTINUE, "bus_reset()\r\n"  );
	intr_1.busreset=1;	
/*	
	vendor_specific.data=0;
	vendor_specific.wait=0;
	vendor_specific.data=0;
	intr_1.configured=0;
	dc_config_value=0;
	dc_alt_setting_value=0;
*/		
}

void suspend( void )
{
//	Comm_w16(W_Mode_Register, (Mode_Value | GOSUSP) );
//	Comm_w16(W_Mode_Register, Mode_Value );	

//	mprintf( LIGHTGREEN, CONTINUE, "suspend()\r\n" );

	intr_1.suspend=1;
	intr_2.suspend=1;
}

void resume( void )
{
//	Dc_printf( RED, CONTINUE, "resume()\r\n" );
	intr_1.resume=1;
	Comm_w16( Unlock_Device, 0xAA37);	
}

void end_of_transfer( void )
{
//	dc_dma_start( 3, dc_dma_buff, 0x0280 );	// DMA test ep=3, dir=out,
//	Dc_printf( WHITE, CONTINUE, "DMA enabled!!\r\n" );
}

void start_of_frame()
{
}

void pseudo_sof()
{
}

void ep1()
{
}

void ep2()
{
}

void ep3()
{
	Comm_r16( R_Ep_Status + 3 );			// Clear Interrupt
	Comm_r( R_Ep_Buf + 3, tmp_buf );
	Comm( Clear_Ep + 3 );
}




void ep4()
{
	Comm_r16( R_Ep_Status + 4 );			// Clear Interrupt

	ep4in();
}

void ep5()
{
}

void ep6()
{
}

void ep7()
{
}

void ep8()
{
}

void ep9()
{
}

void ep10()
{
}

void ep11()
{
}

void ep12()
{
}

void ep13()
{
}

void ep14()
{
}


#ifdef DC_EVENT_LOG
void show_dc_event_log( void )
{
	unsigned char	i;

	mprintf( YELLOW, CONTINUE, "\r\ndisplaying dc event log\r\n" );
	
	for ( i = 0; i < dc_event_log_pointer; i++ )
		mprintf( YELLOW, CONTINUE, "[%d]  fm#=%08lu  cause (copy of intrr-reg)=0x%08lX\r\n", i, dc_event_logger[ i ].frame_number, dc_event_logger[ i ].cause );

	mprintf( YELLOW, CONTINUE, "\r\n" );
	
	dc_event_log_pointer	= 0;
}
#endif