atl_mix.c

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

/*
**  WASABI-Hot! version 1.2c   
**
**
**      -- 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                                             **
**
**      OKANO, Akifumi
**      
**		Application Laboratory, Mobile and Connectivity
**      Semiconductors Div, Philips Japan Ltd.
**      [e-mail]
**      [phone] 
**
*/

/****************************************************************************/
/*	includes																*/
/****************************************************************************/

#include		<string.h>
#include		<mem.h>
#include		<alloc.h>
#include		<dos.h>

#include		"_hc_core/atl_mix.h"
#include		"_hc_core/init.h"
#include		"_hc_core/isr.h"
#include		"_hc_hw/hc_comm.h"
#include		"_hc_hw/hw_acces.h"
#include		"ui.h"


/****************************************************************************/
/*	constants																*/
/****************************************************************************/

#define			TIMEOUT		InitVal_HcATLPTDDoneThresholdTimeOut

#define			AUTO_TRANSFER_RETRY_ENABLE
#define			TEST_VALUE		0


/****************************************************************************/
/*	global vars																*/
/****************************************************************************/

unsigned long			gp_cc_logger[ 16 ]	= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

transfer_instance		*g_atl_transfer_slot;
transfer_instance		*g_intl_transfer_slot;

unsigned char			g_atl_slot_number_by_block[ 32 ];
buffer_params			g_buffer_parameter[ NUMBER_OF_TRANSFER_TYPES + 1 ];
unsigned char			g_slot_index		= 0;

transfer_instance_ptr	g_processing_block;
unsigned char			g_pp_buffer_sw;
unsigned char			g_pp_pause		= False;
unsigned char			g_pp_block0		= 0xFF;
unsigned char			g_pp_block1		= 0xFF;
unsigned char			g_pp_active		= False;
unsigned long			g_previous_timeout_setting;
unsigned char			g_atl_flag_mask			= False;
unsigned long			g_atl_disabled_time		= 0;


/****************************************************************************/
/*	function prototypes														*/
/****************************************************************************/

void		free_transfer_block( transfer_instance_ptr tip );
void		ATL_IRQ_service( unsigned char dummy );
void		INTL_IRQ_service( unsigned char dummy );
void		atl_scheduler( unsigned char i );
void		intl_scheduler( unsigned char index, unsigned char polling_rate );

void		write_a_PTD_into_1362( transfer_instance_ptr tip );
void		polling_ATL_done_flag( void );
void		handle_transfer_done( transfer_instance_ptr tip );

static void	set_PTD_header( unsigned char *ph, PTD_header_param *php );
static void get_PTD_header( PTD_header_param *php, unsigned char *ph );
void		atlmix_show_all_ptd_header( void );
void		atlmix_show_ptd_header( unsigned char transfer_type, unsigned char index );


/****************************************************************************/
/*	function definitions													*/
/****************************************************************************/

/***************************************
 ***************************************
 **
 **		Paired-PTD
 **
 **       All functions those have name of "atlmix_pp_*" are made to control paired-PTD. 
 **       These are used to optimize the storage access performance
 **
 ***************************************
 ***************************************/

unsigned char atlmix_pp_which_buffer( void )
{
	g_pp_buffer_sw	= g_pp_buffer_sw ? 0 : 1;

	return ( g_pp_buffer_sw );

//	return ( (read_register16( Com16_HcBufferStatus  ) & 0x0400) >> 10 );
}


void atlmix_pp_link_indexes( unsigned char blk0, unsigned char blk1 )
{
	unsigned short	tmp;

	g_pp_pause		= True;
	
	tmp		 = read_register16( Com16_HcBufferStatus  );
	tmp		&= ~0x8;

	write_register16( Com16_HcBufferStatus,  tmp );
	write_register16( Com16_HcBufferStatus,  tmp | 0x0010 );
	write_register16( Com16_HcBufferStatus,  tmp );

	g_pp_buffer_sw	= 1;
	
	g_pp_block0		= blk0;
	g_pp_block1		= blk1;
	
	g_previous_timeout_setting	= read_register16( Com16_HcATLPTDDoneThresholdTimeOut );
//	write_register16( Com16_HcATLPTDDoneThresholdTimeOut, 0xFF );
	write_register16( Com16_HcATLPTDDoneThresholdTimeOut, 0 );
}


void atlmix_pp_start( void )
{
	g_pp_pause		= False;
	g_pp_active		= True;
	write_register16( Com16_HcBufferStatus,  read_register16( Com16_HcBufferStatus  ) | 0x8 );
}


unsigned short atlmix_atl_payload_size( void )
{
	return( read_register16( Com16_HcATLBlkSize ) );
}


void atlmix_pp_unlink_indexes( void )
{
	g_pp_block0		= 0xFF;
	g_pp_block1		= 0xFF;
	g_pp_active		= False;

	write_register16( Com16_HcATLPTDDoneThresholdTimeOut, g_previous_timeout_setting );
}


unsigned char atlmix_pp_atl_active( void )
{
	unsigned char	i;

	if ( !(read_register16( Com16_HcBufferStatus ) & 0x8) )
	{
		if ( (g_atl_disabled_time + 3000L) < gp_sof_counter )
		{
			for ( i = 1; i < g_buffer_parameter[ CTRL_BULK_TRANSFER ].number_of_blocks; i++ )
				if ( g_atl_transfer_slot[ i ].lock == LOCK )
					return ( True );
					
			return ( False );
		}
	}
	
	return ( True );
}


void atlmix_pp_atl_flag_mask( unsigned char flag )
{
	g_atl_flag_mask		= flag;
}


unsigned char atlmix_pp_operation_active( void )
{
	return ( g_pp_active );
}


/***************************************
 ***************************************
 **
 **		Buffer initializations
 **
 ***************************************
 ***************************************/

void atlmix_buffer_setting( unsigned short isochro_single_size, unsigned short interr_payload_size, unsigned short interr_block_size, unsigned short aperio_block_size )
{
	//	
	//	This function will be called at begining of the program.
	//	This function sets parameters for the buffer information.
	//

	buffer_info		bi;
	
	//	Buffer size setting
	
	bi.isochr.single_buffer_size	= isochro_single_size;
	
	bi.interr.payload_size			= interr_payload_size;
	bi.interr.n_of_blocks			= interr_block_size;
	
	bi.aperio.payload_size			= aperio_block_size;


	//	Uninstall interrupt service routines

	isr_install_ATL_IRQ_service_routine( NULL );
	isr_install_INTL_IRQ_service_routine( NULL );


	//	Buffer parameter setting and clear all contents

	hwacces_erase_all();
	atlmix_buffer_parameter_initialize( &bi );


	//	Install interrupt service routines

	isr_install_ATL_IRQ_service_routine( ATL_IRQ_service );
	isr_install_INTL_IRQ_service_routine( INTL_IRQ_service );
}


/***************************************
 ***************************************
 **
 **		Interface for transfers
 **
 ***************************************
 ***************************************/

unsigned char atlmix_get_open_transfer_index( unsigned char transfer_type )
{
	unsigned char	n_of_slots;
	unsigned char	i;
	
	if ( transfer_type == CONTROL_TRANSFER )
	{
		if ( g_atl_transfer_slot[ 0 ].lock != LOCK )
		{
			g_atl_transfer_slot[ 0 ].lock		= LOCK;
			free_transfer_block( &(g_atl_transfer_slot[ 0 ]) );
			return ( 0 );
		}
		else
		{
			return ( NO_OPEN_ATL_TRANSFER_SLOT );
		}
	}
	
	else if ( transfer_type == BULK_TRANSFER )
	{
		n_of_slots	= g_buffer_parameter[ CTRL_BULK_TRANSFER ].number_of_blocks;
	
		for ( i = 1; i < n_of_slots; i++ )
			if ( g_atl_transfer_slot[ i ].lock != LOCK )
			{
				g_atl_transfer_slot[ i ].lock		= LOCK;
				free_transfer_block( &(g_atl_transfer_slot[ i ]) );
				return ( i );
			}
		
		if ( i == n_of_slots )
			return ( NO_OPEN_ATL_TRANSFER_SLOT );
	}
	
	else if ( transfer_type == INTERRUPT_TRANSFER )
	{
		n_of_slots	= g_buffer_parameter[ INTERRUPT_TRANSFER ].number_of_blocks;

		for ( i = 0; i < n_of_slots; i++ )
			if ( g_intl_transfer_slot[ i ].lock != LOCK )
			{
				g_intl_transfer_slot[ i ].lock		= LOCK;
				free_transfer_block( &(g_intl_transfer_slot[ i ]) );
				return ( i );
			}
		
		if ( i == n_of_slots )
			return ( NO_OPEN_ATL_TRANSFER_SLOT );
	}
	
	else
	{
		mprintf( LIGHTRED, ABORT, "atlmix_get_open_transfer_index : Unsupported transfer type   transfer_type = %d   \r\n", transfer_type );
	}
	
	return ( NO_OPEN_ATL_TRANSFER_SLOT );
}


void atlmix_free_transfer_index( unsigned char transfer_type, unsigned char index )
{
	switch ( transfer_type )
	{
		case CONTROL_TRANSFER :
		case BULK_TRANSFER :
		case CTRL_BULK_TRANSFER :
			atlmix_free_transfer( &g_atl_transfer_slot[ index ] );
			break;
		case INTERRUPT_TRANSFER :
			atlmix_free_transfer( &g_intl_transfer_slot[ index ] );
			break;
		default :
			mprintf( LIGHTRED, ABORT, "atlmix_free_transfer_index : Unsupported transfer type   transfer_type = %d   \r\n", transfer_type );
			break;
	}
}


void free_transfer_block( transfer_instance_ptr tip )
{
	tip->target_block_index			= 0xFF;
}


void atlmix_free_transfer( transfer_instance_ptr tip )
{
	unsigned short	skipmap_register;

	disable_INT();	//	##	version1.2c

	skipmap_register	= (tip->transfer_type == INTERRUPT_TRANSFER) ? Com32_HcINTLPTDSkipMap : Com32_HcATLPTDSkipMap;

	write_register32( skipmap_register, read_register32( skipmap_register ) | (0x00000001L << tip->target_block_index) );
		
	if ( tip->epi_ptr )
		(tip->epi_ptr)->transfer_instance		= NULL;

	tip->lock					= UNLOCK;
	tip->data_ptr_base			= NULL;
	tip->data_ptr_start			= NULL;
	tip->data_ptr_end			= NULL;
	tip->epi_ptr				= NULL;
	tip->callback				= NULL;
	tip->transferred_size		= 0;
	tip->direction				= 0;
	tip->completion_code		= 0;
	tip->fatal_error			= 0;
	tip->target_address			= 0;
	tip->target_block_index		= 0xFF;
	tip->retry_count			= 0;
	tip->timeout				= 0xFFFFFFFF;