dev_ep.c

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

													
					}
				}
				
				break;
				
			case descriptor_type_OTG :
				
				if ( get_if_descriptors )
				{
					otg_handle_OTG_descriptor( (unsigned char *)(buf) );
				}
				
				break;
				
			default :
				break;
		}
		
		buf		+= desc_length;
	}
	
	
	return ( 0 );
}


/*************************************************
**
**  Get device instance pointer and setup EP0 connection
**
*************************************************/


device_instance *devep_make_device_and_setup_ep0_connection( unsigned char speed, unsigned char topology_layer )
{
	device_instance		*dvi_ptr;
	unsigned char		i;

	/*	Memory allocate for new device instance		*/

	if ( NULL == (dvi_ptr		= (device_instance *)malloc( sizeof( device_instance ) )) )
		return ( NULL );
	
	/*	Initialize members		*/
	
	dvi_ptr->address				= 0;
	dvi_ptr->speed					= speed;
	
	for ( i = 0; i < MAX_ENDPOINT_NUM; i++ )
		dvi_ptr->epi_ptr[ EpOUT ][ i ]	= NULL;

	for ( i = 0; i < MAX_ENDPOINT_NUM; i++ )
		dvi_ptr->epi_ptr[ EpIN  ][ i ]	= NULL;

	dvi_ptr->string_manufacturer	= NULL;
	dvi_ptr->string_product			= NULL;
	dvi_ptr->string_serialNum		= NULL;
	dvi_ptr->class_instance_ptr		= NULL;
	dvi_ptr->topology_layer			= topology_layer;

	dvi_ptr->epi_ptr[ EpOUT ][ 0 ]	= create_endpoint( dvi_ptr, 0, Ep_Direction_CONTROL_ENDPOINT, Ep_TransferType_Control, DEFAULT_BUFFER_SIZE );
	dvi_ptr->epi_ptr[ EpIN  ][ 0 ]	= dvi_ptr->epi_ptr[ EpOUT ][ 0 ];

	return ( dvi_ptr );
}


/*************************************************
**
**  Check a LANGUAGE code
**
*************************************************/



unsigned short get_string_descriptor_LANG_code( unsigned short *code, device_instance *dvi_ptr )
{
#define		LANG_code_request		0x00
	char				tmp_str[ 4 ];
	unsigned short		rx_size;
	unsigned short		err;
	
	rx_size		= 4;

	if ( 0 != (err	= devep_std_request( tmp_str, dvi_ptr, std_Dv_request_GET_DESCRIPTOR, descriptor_type_STRING | LANG_code_request, 0x0000, &rx_size )) )
		return ( err );
	
	 *code	= *(((unsigned short *)tmp_str) + 1);
	
	return ( 0 );
}



/*************************************************
**
**  Get a string descpiptor
**
*************************************************/


unsigned short get_string_descriptor( unsigned short **unicode_str_ptr_ptr, device_instance *dvi_ptr, unsigned char index, unsigned short language_ID )
{
	char				tmp_str[ 2 ];
	unsigned short		rx_size;
	unsigned short		err;

	if ( index == 0 )
	{
		*unicode_str_ptr_ptr	= NULL;
		return( 0 );
	}
	
	rx_size		= 2;

	if ( 0 != (err	= devep_std_request( tmp_str, dvi_ptr, std_Dv_request_GET_DESCRIPTOR, descriptor_type_STRING | index, language_ID, &rx_size )) )
		return ( err );
		
	rx_size		= ((std_string_descriptor *)tmp_str)->bLength;
	
	if ( NULL == (*unicode_str_ptr_ptr	= (unsigned short *)malloc( sizeof( unsigned char ) * rx_size )) )		//	Because the "rx_size" is given as a number of bytes.
		mprintf( LIGHTRED, ABORT, "error @ get_string_descriptor, malloc failed\r\n" );

	if ( 0 != (err	= devep_std_request( (unsigned char *)(*unicode_str_ptr_ptr), dvi_ptr, std_Dv_request_GET_DESCRIPTOR, descriptor_type_STRING | index, 0x0409, &rx_size )) )
		return ( err );

#if 0
{
unsigned char	*s;
int				i;

mprintf( LIGHTGREEN, CONTINUE, "str >> " );

for ( i = 1; i < rx_size>>1; i ++ )
mprintf( LIGHTGREEN, CONTINUE, "%c", *((*unicode_str_ptr_ptr) + i) & 0xFF );

mprintf( LIGHTGREEN, CONTINUE, " <<\r\n" );
}
#endif

	return ( 0 );
}



/*************************************************
**
**  Send/Receive standard request
**
*************************************************/


unsigned short devep_std_request( unsigned char *buff_ptr, device_instance *dvi_ptr, unsigned short request, unsigned short wValue, unsigned short wIndex, unsigned short *wLength )
{
	USB_Device_Request	req;
	unsigned short		err;

	req.bmRequestType			= reqtype( request );
	req.bRequest				= request( request );
	req.wValue					= wValue;
	req.wIndex					= wIndex;
	req.wLength					= *wLength;

	err			= transfer_control_transfer( &req, dvi_ptr, buff_ptr );

	if ( err & 0x8000 )						//	short data received
	{
		*wLength		= err & 0x7FFF;		//	In the case of no error, value is not updated.
		err 			= 0;				//	Clear error flag
	}
	
	return ( err );
}



/*************************************************
**
**  Dispose device instance
**
*************************************************/


void devep_dispose_device( device_instance **dvi_ptr_ptr )
{
	device_instance		*downstream_device_ptr;
	int					i;

	if ( (*dvi_ptr_ptr) == NULL )
		return;

	if ( NULL != ((*dvi_ptr_ptr)->class_instance_ptr) )
		clshndl_dispose_method( *dvi_ptr_ptr );
			
	device_list[ (*dvi_ptr_ptr)->address ]		= NULL;

	for ( i = 0; i < MAX_ENDPOINT_NUM; i++ )
		if ( NULL != (*dvi_ptr_ptr)->epi_ptr[ EpOUT ][ i ] )
			dispose_endpoint( *dvi_ptr_ptr, i, EpOUT );

	for ( i = 1; i < MAX_ENDPOINT_NUM; i++ )
		if ( NULL != (*dvi_ptr_ptr)->epi_ptr[ EpIN  ][ i ] )
			dispose_endpoint( *dvi_ptr_ptr, i, EpIN );

	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 );

	free( *dvi_ptr_ptr );

	*dvi_ptr_ptr		= NULL;
}



/*************************************************
**
**  Cleate endpoint instance
**
*************************************************/


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;
	unsigned char	ep_direction;
	
	if ( NULL == (epi_ptr	= (endpoint_info *)malloc( sizeof( endpoint_info ) )) )
		mprintf( LIGHTRED, ABORT, "malloc failed @ epi_ptr malloc err\r\n" );

	if ( direction == Ep_Direction_CONTROL_ENDPOINT )	//	Endpoint instance slot 0-OUT is used for Control-EP
		direction	= EpOUT;

	dvi_ptr->epi_ptr[ direction ][ index ]	= epi_ptr;
	
	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;
	
	if ( transfer_type == Ep_TransferType_Isochronous )
		epi_ptr->tr_type		= Format_Iso;
	else
		epi_ptr->tr_type		= Format_Async;
	
	epi_ptr->transfer_instance	= NULL;

	return ( epi_ptr );
}


/*************************************************
**
**  Dispose endpoint instance
**
*************************************************/


void dispose_endpoint( device_instance *dvi_ptr, unsigned short index, unsigned char direction )
{
	endpoint_info_ptr	temp_epi_ptr;

	temp_epi_ptr	= dvi_ptr->epi_ptr[ direction ][ index ];

	if ( temp_epi_ptr->transfer_instance )
		atlmix_free_transfer( temp_epi_ptr->transfer_instance );
	
	free( temp_epi_ptr );

	temp_epi_ptr	= NULL;
}


void devep_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 *devep_find_device( unsigned char address )
{
	return ( device_list[ address ] );
}


device_instance *devep_find_class_interface( unsigned char InterfaceClassID, 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	= devep_find_device( i )) )
			continue;

		if ( devep_check_interface_class_ID( dviPtr, InterfaceClassID ) )
			return ( dviPtr );
	}
	
	return ( NULL );
}


unsigned char devep_check_interface_class_ID( device_instance *dviPtr, unsigned char InterfaceClassID )
{
	if ( InterfaceClassID == devep_get_interface_class_ID( dviPtr ) )
		return ( 1 );
	else
		return ( 0 );
}


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


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


/* Modification by hara from here.*/

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	= devep_find_device( i )) )
			continue;

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


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


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



/* Modification by hara to here.*/