isr.c

isp1160_isa_evel_codeUSB主机软件

/*
**  Kenobi2          version 1.3
**
**      ** This code has been made to check/learn the 1161 functionalities ** 
**      ** Release 25-Feb-2002                                             **
**
**      OKANO, Akifumi 
**      
**		Computing Segment, Semisonductors Div, Philips Japan Ltd.
**      [e-mail]
**      [phone] 
*/

//	08-Nov-2001   No static call for SOF service routine


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

#include		"stdio.h"
#include		"isr.h"
#include		"hc_comm.h"
#include		"hw_acces.h"
#include		"data_tr.h"
#include		"ui.h"
#include		"sing.h"


unsigned long	g_sof_counter			= 0;
unsigned long	g_sof_counter_prev		= 0;

unsigned long	g_operation_time		= 0;


unsigned short	g_isr_flag;
unsigned short	rhsc_event_counter		= 0;
unsigned short	g_event_counter			= 0;

funcPtr			g_SOF_service_routine[ MAXMUM_NUMBER_OF_SOF_SERVICE_ROUTINE_METHOD ]
										= SOF_SERVICE_ROUTINE_INITIALIZE;
										

unsigned short	hardware_configuration_setting;

unsigned short	level			= 0;  //	ebnable/disable control

unsigned short	g_previous_Hc_interrupt_enable_state;


void	interrupt_handler_USB_Hc( unsigned short intr );
void	clear_HcuPInterrupt_bit( unsigned short flag );
void	HcuInterrupt_OPR_Reg_handler( unsigned long intr_stat );
void	atl_buff_handler( void );
void	clear_HcInterruptStatus_bit( unsigned long flag );
int		get_int_num( int irq_num );
void	get_PIC_masks( int *m_lower , int *m_higher, int irq_num );


//char	vital_sign[]	=	{ '*', '+', 'X', 'O' };


void interrupt isr_USB_Hc( void )
{
	unsigned short	intr;
	unsigned short	inter_en;
	
	disable();
//	disable_Dc();
	inter_en	= disable_Hc();
	
//	inter_en	= read_register16( Com16_HcuPInterruptEnable );
//	write_register16( Com16_HcuPInterruptEnable, 0x0000 );
	
	intr		= read_register16( Com16_HcuPInterrupt );
	clear_HcuPInterrupt_bit( intr );

	interrupt_handler_USB_Hc( intr & inter_en );
	
	outportb( 0xA0, 0x20 );
	outportb( 0x20, 0x20 );

	enable_Hc();
//	enable_Dc();

//	write_register16( Com16_HcuPInterruptEnable, inter_en );

	enable();
}

unsigned short disable_Hc( void )
{
	g_previous_Hc_interrupt_enable_state	= read_register16( Com16_HcuPInterruptEnable );
	write_register16( Com16_HcuPInterruptEnable, 0x0000 );
	
	return ( g_previous_Hc_interrupt_enable_state );
}

void enable_Hc( void )
{
	write_register16( Com16_HcuPInterruptEnable, g_previous_Hc_interrupt_enable_state );
}


void interrupt_handler_USB_Hc( unsigned short intr )
{
	static unsigned int		key_polling_timer		= 0;
	int						i;

	if ( intr & HcuInterrupt_SOFITInt )
	{
		if ( !(key_polling_timer++ & GENERAL_KEY_POLLING_RATE) )
			key_polling_flag	= 1;
		
		for ( i = 0; i < MAXMUM_NUMBER_OF_SOF_SERVICE_ROUTINE_METHOD; i++ )
			if ( g_SOF_service_routine[ i ] )
				(*g_SOF_service_routine[ i ])();

		if ( ATL_buffer_state_DONE() && !(intr & HcuInterrupt_ATLInt) )
			read_ATL_buffer( get_current_ATLD_ptr() );

		if ( is_transfer_enabled() && is_ATLD_ready( get_current_ATLD_ptr() ) )
			if ( !ATL_buffer_state_FULL() )
				write_ATL_buffer( get_current_ATLD_ptr() );

		g_sof_counter		= (g_sof_counter & 0xFFFF0000) | (read_register32( Com32_HcFmNumber ) & 0x0000FFFF);
 	}
	
	if ( intr & HcuInterrupt_ATLInt )
	{
		if ( ATL_buffer_state_DONE() )
			read_ATL_buffer( get_current_ATLD_ptr() );

		if ( is_transfer_enabled() )
			write_ATL_buffer( get_current_ATLD_ptr() );
	}
	
	if ( intr & HcuInterrupt_AllEOTInterrupt )
		;
			
	if ( intr & HcuInterrupt_OPR_Reg )
	{
		unsigned short	intr32;

		intr32	= read_register32( Com32_HcInterruptStatus );
		clear_HcInterruptStatus_bit( intr32 );

		HcuInterrupt_OPR_Reg_handler( intr32 );
	}
	
	if ( intr & HcuInterrupt_HCSuspend )
		;
	
	if ( intr & HcuInterrupt_ClkReady )
		;

		
//	if ( (g_sof_counter - g_sof_counter_prev) >= 10 )
//		mprintf( RED, CONTINUE, "SOFITLInt service slip detected (%ldms)   \r\n", g_sof_counter - g_sof_counter_prev );

	if ( !(g_sof_counter % 1000) )
	{
//		mprintf( WHITE, CONTINUE, "1 second                      \r\n" );
		g_operation_time++;
	}

	g_sof_counter_prev	= g_sof_counter;
}

void clear_HcuPInterrupt_bit( unsigned short flag )
{
	g_isr_flag		|= flag;
	
	write_register16( Com16_HcuPInterrupt, flag );
}


void HcuInterrupt_OPR_Reg_handler( unsigned long cause )
{
	unsigned long	intr_stat;

	intr_stat	= cause & read_register32( Com32_HcInterruptEnable );

	if ( intr_stat & HcInterruptStatus_SO )
		;
		
	if ( intr_stat & HcInterruptStatus_SF )
		;

	if ( intr_stat & HcInterruptStatus_RD )
		;

	if ( intr_stat & HcInterruptStatus_UE )
		;

	if ( intr_stat & HcInterruptStatus_FNO )
		g_sof_counter	+= (g_sof_counter & 0x00008000) ? 0 : (1L << 16);

	if ( intr_stat & HcInterruptStatus_RHSC )
		rhsc_event_counter++;

	if ( intr_stat & HcInterruptStatus_ATD )
		;
}


void clear_HcInterruptStatus_bit( unsigned long flag )
{
	g_isr_flag		|= flag << 8;

	write_register32( Com32_HcInterruptStatus, flag );
}


funcPtr install_SOF_service_routine( unsigned char number, funcPtr function_ptr )
{
	funcPtr		tmp;

	tmp									= g_SOF_service_routine[ number ];
	g_SOF_service_routine[ number ]		= function_ptr;
	
	return ( tmp );
}


/*
**	THESE FOLLOWING FUNCTION HAS BEEN TESTED WITH "IRQ10" ONLY
*/

/*
**	Reference : 
**	
**		http://www.jkmicro.com/c.html	(English)
**		http://www.asahi-net.or.jp/~WR7S-NKMR/BeOS/Documents/IRQ.html
*/


isrPtr install_isr( int irq_num, isrPtr new_vector )
{
	int			int_num;
	int			PIC_mask1,
				PIC_mask2;
	isrPtr		old_vector;

	outportb(0xA0, 0x20);
	outportb(0x20, 0x20);
	
	int_num		= get_int_num( irq_num );
	get_PIC_masks( &PIC_mask1, &PIC_mask2, irq_num );
	
	old_vector	= getvect( int_num );
	setvect( int_num, new_vector );
	
	outportb( 0x21, inportb( 0x21 ) & ~PIC_mask1 );
	outportb( 0xA1, inportb( 0xA1 ) & ~PIC_mask2 );

	return ( old_vector );
}



void restore_isr(  int irq_num, isrPtr old_vector )
{
	int		int_num;
	int		PIC_mask1,
			PIC_mask2;

	int_num		= get_int_num( irq_num );
	get_PIC_masks( &PIC_mask1, &PIC_mask2, irq_num );

	setvect( int_num, old_vector );

	outportb( 0x21, inportb( 0x21 ) | PIC_mask1 );
	outportb( 0xA1, inportb( 0xA1 ) | PIC_mask2 );
}


int get_int_num( int irq_num )
{
#define		LowerINTOffset		0x08
#define		HigherINTOffset		0x68

	return ( ( irq_num < 8 ) ? irq_num + LowerINTOffset : irq_num + HigherINTOffset );
}


void get_PIC_masks( int *m_lower , int *m_higher, int irq_num )
{
	if ( irq_num < 8 )
	{
		*m_lower	= 0x01 << irq_num;
		*m_higher	= 0x00;
	}
	else
	{
		*m_lower	= 0x04;		/*	for cascaded IRQ(IRQ2)  */
		*m_higher	= 0x01 << (irq_num - 8);
	}
}