dev_ep.c

ARM读写U盘驱动软件包源程序

	unsigned char			pip_index;
	
	buf_end		= buf + length;
	while ( buf < buf_end )
	{
		desc_length	= descriptor_length( buf );		
		desc_type	= descriptor_type( buf ) << 8;	
		switch ( desc_type )
		{
			case descriptor_type_CONFIGURATION :		
				memcpy( (unsigned char *)(&(dvi_ptr->conf_descriptor)), (unsigned char *)(buf), sizeof( std_conf_descriptor ) );
				break;
			case descriptor_type_INTERFACE :			
				if ( get_just_one_interface_descripter )	
				{
					memcpy( (unsigned char *)(&(dvi_ptr->interfacef_descriptor)), (unsigned char *)(buf), sizeof( std_interface_descriptor ) );
					get_just_one_interface_descripter	= 0;
				}
				break;
			case descriptor_type_ENDPOINT :			
				memcpy( (unsigned char *)(&(tmp_ep_desc)), (unsigned char *)(buf), sizeof( std_endpoint_descriptor ) );
				pip_index =  EpNum_bEndAdd( tmp_ep_desc.bEndpointAddress ) * 2
						    +EpDir_bEndAdd( tmp_ep_desc.bEndpointAddress )	;
				if ( !(dvi_ptr->epi_ptr[ pip_index ]) )
				{	epi_ptr = create_endpoint(	dvi_ptr, 			
											EpNum_bEndAdd( tmp_ep_desc.bEndpointAddress ),
											EpDir_bEndAdd( tmp_ep_desc.bEndpointAddress ),
											Ep_TranType_bmAttr( tmp_ep_desc.bmAttributes ), 
											tmp_ep_desc.wMaxPacketSize );
					if ( NULL == epi_ptr )
						return  FALSE ;
					epi_ptr->endpoint_descriptor	= tmp_ep_desc;	
					dvi_ptr->epi_ptr[ pip_index ] = epi_ptr;		
				}
				else							
					return TRUE;
				break;
			default :
				break;
		}
		buf	+= desc_length;		
	}
	return  FALSE;
}


void dispose_device( device_instance **dvi_ptr_ptr )
{
	unsigned char		i;
	
	if ( (*dvi_ptr_ptr) == NULL )
		return;

	disable();

#ifdef CLASS_DRIVE
	if ( NULL != ((*dvi_ptr_ptr)->class_instance_ptr) )	
		class_drive_dispose( *dvi_ptr_ptr );		
#endif

	if((*dvi_ptr_ptr)->address >1)	  
		device_list[ (*dvi_ptr_ptr)->address ]	= NULL;
	
	for ( i = 0; i < MAX_ENDPOINT_NUM; i++ )			
		if ( (*dvi_ptr_ptr)->epi_ptr[ i ] != NULL )
			dispose_endpoint( *dvi_ptr_ptr, i );
		
#ifdef STRING_DESCRIPTOR
	
	if ( NULL != (*dvi_ptr_ptr)->string_manufacturer )
		free( (*dvi_ptr_ptr)->string_manufacturer );
	if ( NULL != (*dvi_ptr_ptr)->string_product )
		free( (*dvi_ptr_ptr)->string_product );
	if ( NULL != (*dvi_ptr_ptr)->string_serialNum )
		free( (*dvi_ptr_ptr)->string_serialNum );
	if ( NULL != (*dvi_ptr_ptr)->class_instance_ptr )
		free( (*dvi_ptr_ptr)->class_instance_ptr );
#endif

	free_device_instance( *dvi_ptr_ptr );				
	*dvi_ptr_ptr	= NULL;
	enable();
}


endpoint_info *create_endpoint( device_instance *dvi_ptr, 
								unsigned short index, 
								unsigned short direction, 
								unsigned short transfer_type, 
								unsigned short max_packet_size )
{
	endpoint_info	*epi_ptr;
	if ( NULL == (epi_ptr= malloc_endpoint_info( ) ))	
		return ( NULL );
	
	epi_ptr->max_packet_size	= max_packet_size;
	epi_ptr->dev_addr			= dvi_ptr->address;
	epi_ptr->ep_num			= index;
	epi_ptr->toggle			= 0;
	epi_ptr->speed			= dvi_ptr->speed;		
	epi_ptr->direction			= direction;			
	epi_ptr->transfer_type		= transfer_type|ENDPOINT_SHARE;	
	
	if ( transfer_type == Ep_TransferType_Isochronous )
		epi_ptr->tr_type		= Format_Iso;			
	else
		epi_ptr->tr_type		= Format_Async;		

	//-----------------------------------------
		epi_ptr->endpoint_create_id = g_sof_counter;
	return  epi_ptr ;
}



void dispose_endpoint( device_instance *dvi_ptr, unsigned short index )
{
	transfer_instance  *tr_inst_ptr;	
	disable();
	tr_inst_ptr = dvi_ptr->epi_ptr[ index ]->tr_instance_ptr;

	 if(dvi_ptr->epi_ptr[ index ]->ep_num==0x2)
		dvi_ptr = dvi_ptr;
	while(tr_inst_ptr !=NULL)		
	{
		atl_close_transfer_instance(tr_inst_ptr);
		tr_inst_ptr = tr_inst_ptr->tr_list_for_ep.Blink;						
	}
	free_endpoint_info( dvi_ptr->epi_ptr[ index ] );			
	dvi_ptr->epi_ptr[ index ] = NULL;
	enable();
}


void device_list_linitialize( void )
{
	int		i;
	
	device_list[ 0 ] = (device_instance *)1;
	device_list[ 1 ] = (device_instance *)1;
	
	for ( i = 2; i < MAX_DEVICE_NUM; i++ )
		device_list[ i ]	= NULL;

}


unsigned char device_new_address( void )
{
	int		i;

	for ( i = 2; i < MAX_DEVICE_NUM; i++ )
		if ( !device_list[ i ] )
			return ( i );
	return ( 0 );
}



device_instance *find_device( unsigned char address )
{
	return ( device_list[ address ] );
}


unsigned char get_interface_class_ID( device_instance *dviPtr )
{
	if ( 0x00 == get_device_class_ID( dviPtr ) )
		return ( (dviPtr->interfacef_descriptor).bInterfaceClass );
	else
		return ( 0xFF );
}


unsigned char get_device_class_ID( device_instance *dviPtr )
{
	return ( (dviPtr->dev_descriptor).bDeviceClass );
}




device_instance *find_class_interface( unsigned char InterfaceClassID,  unsigned char DeviceIndex )
{
	device_instance		*dviPtr;
	int					i;
	
	for ( i = 2; i <( MAX_DEVICE_NUM); i++ )
	{	
		if ( NULL == (dviPtr = find_device( i )) )
			continue;

		if ( check_interface_class_ID( dviPtr, InterfaceClassID ) )
		{
			if(DeviceIndex== 0x00)
				return ( dviPtr );
			else
				DeviceIndex --;
		}
	}
	
	return ( NULL );
}


unsigned char check_interface_class_ID( device_instance *dviPtr, unsigned char InterfaceClassID )
{
	if ( (dviPtr->dev_descriptor).bDeviceClass == 0x00 )
		if ( (dviPtr->interfacef_descriptor).bInterfaceClass == InterfaceClassID )
			return ( 1 );

	return ( 0 );
}



unsigned char check_pid_vid( device_instance *dviPtr, unsigned short VID,unsigned short  PID)
{
	if ( (dviPtr->dev_descriptor).idVendor== VID )
		if ( (dviPtr->dev_descriptor).idProduct== PID )
			return ( 1 );
 
	return ( 0 );
}


device_instance *find_pid_vid( unsigned short VID,unsigned short PID )
{
	device_instance		*dviPtr;
	int					i;
	
	for ( i = 2; i <( MAX_DEVICE_NUM); i++ )
	{	
		if ( NULL == (dviPtr = find_device( i )) )
			continue;
		if ( check_pid_vid( dviPtr, VID , PID) )
			return ( dviPtr );
	}
	
	return ( NULL );
}


endpoint_info  * find_endport_type(device_instance *dviPtr, unsigned char endport_type,unsigned char endport_direction,unsigned char index)
{
	unsigned char i;
	endpoint_info	*epi_ptr;
	for( i=0; i<MAX_ENDPOINT_NUM; i++)
	{
		epi_ptr=dviPtr->epi_ptr[i];
		if ( NULL!=epi_ptr )
		{
			if((epi_ptr->transfer_type&0x03) == (endport_type&0x03))
				if( epi_ptr->direction == endport_direction)
				{
					index--;
					if(index==0)
						return epi_ptr;			
				}
		}

	}
	return NULL;
}


endpoint_info * find_endport_number(  device_instance *dviPtr, 
                                   	  unsigned char endport_number,
                                   	  unsigned char endport_direction)
{
	endpoint_info	*epi_ptr;
	epi_ptr =	dviPtr->epi_ptr[endport_number*2 + endport_direction];
	return epi_ptr;	
}



device_instance *find_protocol_interface( unsigned char InterfaceProtocolID, unsigned char search_start_address )
{
	device_instance		*dviPtr;
	int					i;
	
	if ( search_start_address < 2 )
		search_start_address	= 2;
	
	for ( i = search_start_address; i < 128; i++ )
	{	
		if ( NULL == (dviPtr	= find_device( i )) )
			continue;

		if ( check_interface_protocol_ID( dviPtr, InterfaceProtocolID ) )
			return ( dviPtr );
	}
	
	return ( NULL );
}


unsigned char check_interface_protocol_ID( device_instance *dviPtr, unsigned char InterfaceProtocolID )
{
	if (InterfaceProtocolID == get_interface_protocol_ID( dviPtr ) )
		return ( 1 );
	else
		return ( 0 );
}


unsigned char get_interface_protocol_ID( device_instance *dviPtr )
{
	if ( 0x03 ==  get_interface_class_ID( dviPtr ) )
		return ( (dviPtr->interfacef_descriptor).bInterfaceProtocol );
	else
		return ( 0xFF );
}




device_instance *find_subclass_interface( unsigned char InterfaceSubclassID, unsigned char search_start_address )
{
	device_instance		*dviPtr;
	int					i;
	
	if ( search_start_address < 2 )
		search_start_address	= 2;
	
	for ( i = search_start_address; i < 128; i++ )
	{	
		if ( NULL == (dviPtr	= find_device( i )) )
			continue;

		if ( check_interface_subclass_ID( dviPtr, InterfaceSubclassID ) )
			return ( dviPtr );
	}
	
	return ( NULL );
}


unsigned char check_interface_subclass_ID( device_instance *dviPtr, unsigned char InterfaceSubclassID )
{
	if (InterfaceSubclassID == get_interface_subclass_ID( dviPtr ) )
		return ( 1 );
	else
		return ( 0 );
}


unsigned char get_interface_subclass_ID( device_instance *dviPtr )
{
	if ( 0x08 ==  get_interface_class_ID( dviPtr ) )
		return ( (dviPtr->interfacef_descriptor).bInterfaceSubClass );
	else
		return ( 0xFF );
}


unsigned char ClearEndpointSTALL(device_instance *dvi_ptr, endpoint_info *epi_ptr)
{
	unsigned short 	wIndex;
	unsigned short	wLength = 0;
	unsigned char  	buff_ptr;
	unsigned short 	CompletionCode;
	
	wIndex =  epi_ptr->endpoint_descriptor.bEndpointAddress;			
	CompletionCode = std_request(&buff_ptr, dvi_ptr, 
		             					std_Dv_request_CLEAR_FEATURE_Ep, 
		             					0x0000, wIndex, &wLength );	
	epi_ptr->toggle = 0;											
	return 	( CompletionCode? FALSE: TRUE );
}