data_tr.c

isp1161驱动代码是我下载并该动后而成,还有点缺点,但对你可能有点帮助

/*
**  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] 
**
**		function name changed :
**			setup_one_transfer() --> do_one_transfer(), 06-Aug
**
*/


//	06Nov2001  ATL_SHORT_WRITE / ATL_SHORT_READ feature added to make the bus traffic light



#include	<stdio.h>
#include	<stdlib.h>
#include		<alloc.h>
#include	<dos.h>

#include	"data_tr.h"
#include	"hw_acces.h"
#include	"hc_comm.h"
#include	"ui.h"
#include	"dma.h"
#include	"isr.h"
#include	"general.h"

#define		DATASIZE				8
#define		MAXPACKETSIZE			8


#define		TRUE					1
#define		FALSE					0


int				transferEnable		= 0;
ATLD			*ATLDbasePtr		= NULL;
ATLD			*currentATLDPtr		= NULL;

unsigned char	errorFlag			= 0;		/*	error code : see completion_check_ATLD()  */



static void 			PTD_image_create( PTD_header_param *php, unsigned char *data, unsigned char *atl_buffer );
static void				set_PTD_header( unsigned char *ph, PTD_header_param *php );
static void 			get_PTD_header( PTD_header_param *php, unsigned char *ph );
static void 			debug_ATLD_param_monitor( char *str, ATLD *p );


/*	Asynchronus processes  */
/*	Asynchronus processes  */
/*	Asynchronus processes  */


ATLD *open_single_PTD_ATLD( PTD_header_param *ptd_param_ptr, unsigned char *data )
{
	ATLD				*atldPtr;
	unsigned char		*ATLbufferPtr;
	unsigned short		ATL_image_size;

	ATL_image_size	= ptd_param_ptr->TotalBytes + 8;
	
	if ( NULL == (atldPtr	= (ATLD *)malloc( sizeof( ATLD ) )) )
	{
		mprintf( RED, CONTINUE, "malloc failed asigning %d bytes\r\n", sizeof( ATLD ) );
		return ( NULL );
	}
		
	if ( NULL == (ATLbufferPtr	= (unsigned char *)malloc( sizeof( unsigned char ) * ATL_image_size )) )
	{
		mprintf( RED, CONTINUE, "malloc failed asigning %d bytes\r\n", sizeof(  sizeof( unsigned char ) * ATL_image_size  ) );
		return ( NULL );
	}
		
	PTD_image_create( ptd_param_ptr, data, ATLbufferPtr );

	atldPtr->atl_buffer_ptr		= ATLbufferPtr;
	atldPtr->size				= ATL_image_size;
	atldPtr->busy_flag			= ATL_ready;
	atldPtr->next				= NULL;
	
	if ( ptd_param_ptr->DirectionPID == IN )			//	This process can be used single PTD ATLD only
		atldPtr->short_rw		= ATL_SHORT_WRITE;
	else
		atldPtr->short_rw		= ATL_SHORT_READ;
	
//	debug_ATLD_param_monitor( "made", atldPtr );
//	mprintf( LIGHTGRAY, CONTINUE, "open_single_PTD_ATLD flag-set OK\r\n" );

	return ( atldPtr );
}


void readout_ATLD( unsigned char *data, unsigned short length, ATLD *atldPtr )
{
	unsigned char	*p;
	int				i;
	
	p		= (atldPtr->atl_buffer_ptr) + 8;
	
	for ( i = 0; i < length; i++ )
		*data++		= *p++;	
}


int close_ATLD( ATLD *atldPtr )
{
	ATLDbasePtr		= atldPtr->next;	/*  update the ATLD_base  */
	
	free( atldPtr->atl_buffer_ptr );
	free( atldPtr );
	
	if ( ATLDbasePtr == NULL )
	{
		transferEnable		= FALSE;	/*	All transfer finished  */
		return ( 0 );
	}
	
	return ( 1 );
}


void link_ATLDs( ATLD *previousATLD, ATLD *currentATLD )
{
	previousATLD->next	= currentATLD;
}


unsigned short ATL_buffer_state_FULL( void )
{
	return ( read_register16( Com16_HcBufferStatus ) & 0x04 );
}


unsigned short ATL_buffer_state_DONE( void )
{
	return ( read_register16( Com16_HcBufferStatus ) & 0x20 );
}


unsigned char completion_check_ATLD( PTD_header_param *ptd_param_ptr, ATLD *atldPtr )
{
	/*
	**	This function can be used to check ATLD busy
	**	and result of completion
	**	
	**	
	**	If this function returns 0xFFFF, it means the ATLD busy
	**	If it is 0, the ATLD completed with no error and no warning
	**	If it is in other value...
	**		bit7 means PTD active bit
	**		bit3-0 has copied value from CompletionCode in PTD
	*/

	get_PTD_header( ptd_param_ptr, atldPtr->atl_buffer_ptr );
	
	return ( (ptd_param_ptr->Active << 7) | ptd_param_ptr->CompletionCode );
}


int wait_ATLD_done( ATLD *atldPtr, int timeout )
{
	unsigned long	timelimit;
	
	timelimit	= g_sof_counter + (unsigned long)timeout;

	while ( !is_ATLD_done( atldPtr ) )
		if ( timelimit < g_sof_counter )
			return ( 1 );
		
	return ( 0 );
}


/*	private var access  */
/*	private var access  */
/*	private var access  */


void enable_transfer( void )
{
	transferEnable	= TRUE;
}


void abort_transfer( void )
{
	transferEnable	= FALSE;
}


int is_transfer_enabled( void )
{
	return ( transferEnable );
}


void set_ATLD_base_ptr( ATLD *atldPtr )
{
	ATLDbasePtr		= atldPtr;
	currentATLDPtr	= atldPtr;
}


ATLD *get_current_ATLD_ptr( void )
{
	return ( currentATLDPtr );
}


int is_DMA_enabled( void )
{
#ifdef Use_DMA
	return ( 1 );
#else
	return ( 0 );
#endif
}


/*	Synchronus processes  */
/*	Synchronus processes  */
/*	Synchronus processes  */


void write_ATL_buffer( ATLD *atldPtr )
{
	unsigned short		write_size;

	//	ATL_SHORT_WRITE means it will write PTD header only for single PTD ATL image IN transfer

	write_size		= (atldPtr->short_rw & ATL_SHORT_WRITE) ? 8 : atldPtr->size;

	if ( atldPtr->busy_flag != ATL_ready )
	{
		errorFlag	= 0xFFFF;
		transferEnable	= FALSE;		
	}

#ifdef Use_DMA

	dma_start( DMA_write, BUFFER_SELECT_ATL, atldPtr->atl_buffer_ptr, write_size );

#else

	write_register16( Com16_HcTransferCounter, write_size );
	write_register_burst_char( Com16_HcATLBufferPort, atldPtr->atl_buffer_ptr, write_size );

#endif

	atldPtr->busy_flag		= ATL_busy;
}


void read_ATL_buffer( ATLD *atldPtr )
{
	PTD_header_param	dummy;
	unsigned short		read_size;

	read_size		= (atldPtr->short_rw & ATL_SHORT_READ) ? 8 : atldPtr->size;

#ifdef Use_DMA

	dma_start( DMA_read, BUFFER_SELECT_ATL, atldPtr->atl_buffer_ptr, read_size );

#else

	write_register16( Com16_HcTransferCounter, read_size );
	read_register_burst_char( Com16_HcATLBufferPort, atldPtr->atl_buffer_ptr, read_size );

#endif

	if ( 0 != (errorFlag	= completion_check_ATLD( &dummy, atldPtr )) )
		transferEnable	= FALSE;		

	atldPtr->busy_flag	= ATL_done;
	
	currentATLDPtr		= atldPtr->next;
	
	if ( currentATLDPtr == NULL )
		transferEnable	= FALSE;
}


/*  private functions  */

static void PTD_image_create( PTD_header_param *php, unsigned char *data, unsigned char *atl_buffer )
{

	int		i;

	set_PTD_header( atl_buffer, php );
	
	atl_buffer		+= 8;
	
	for ( i = 0; i < php->TotalBytes; i++ )
		*atl_buffer++	= *data++;
}


static void set_PTD_header( unsigned char *ph, PTD_header_param *php )
{
	*(ph + 0)	= php->ActualBytes & 0x0FF;
	
	*(ph + 1)	= (php->CompletionCode << 4)
					| (php->Active << 3) 		
					| (php->Toggle << 2) 
					| (php->ActualBytes >> 8);
	
	*(ph + 2)	= php->MaxPacketSize & 0xFF;
	
	*(ph + 3)	= 	  (php->EndpointNumber << 4)
					| (php->Last << 3) 		
					| (php->Speed << 2) 
					| (php->MaxPacketSize >> 8);
					
	*(ph + 4)	= php->TotalBytes & 0xFF;

	*(ph + 5)	= 	  (php->DirectionPID << 2)
					| (php->TotalBytes >> 8);
	
	*(ph + 6)	= 	  (php->Format << 7)
					| (php->FunctionAddress & 0x7F);
}


static void get_PTD_header( PTD_header_param *php, unsigned char *ph )
{
	php->ActualBytes		=  *(ph + 0) | ((*(ph + 1) & 0x3) << 8);
	php->CompletionCode		=  *(ph + 1) >> 4;
	php->Active				= (*(ph + 1) >> 3) & 0x01;
	php->Toggle				= (*(ph + 1) >> 2) & 0x01;
	php->MaxPacketSize		=  *(ph + 2) | ((*(ph + 3) & 0x3) << 8);
	php->EndpointNumber		=  *(ph + 3) >> 4;
	php->Last				= (*(ph + 3) >> 3) & 0x01;
	php->Speed				= (*(ph + 3) >> 2) & 0x01;
	php->TotalBytes			=  *(ph + 4) | ((*(ph + 5) & 0x3) << 8);
	php->DirectionPID		= (*(ph + 5) >> 2) & 0x03;
	php->Format				=  *(ph + 6) >> 7;
	php->FunctionAddress	=  *(ph + 6) & 0x7F;
}


static void debug_ATLD_param_monitor( char *str, ATLD *p )
{
	mprintf( LIGHTGREEN, CONTINUE, "    " );
	mprintf( LIGHTGREEN, CONTINUE, str );
	mprintf( LIGHTGREEN, CONTINUE, "\r\n" );

	mprintf( LIGHTGREEN, CONTINUE, "      atldPtr->atl_buffer_ptr 0x%08lX\r\n",      p->atl_buffer_ptr );
	mprintf( LIGHTGREEN, CONTINUE, "      atldPtr->size               0x%04X\r\n",   p->size );
	mprintf( LIGHTGREEN, CONTINUE, "      atldPtr->busy_flag            0x%02X\r\n", p->busy_flag );
}