dev_ep.c

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

/****************************************Copyright (c)**************************************************
**                               Guangzou ZLG-MCU Development Co.,LTD.
**                                     graduate school
**                                 http://www.zlgmcu.com
**
**--------------File Info-------------------------------------------------------------------------------
** File Name:
** Last modified Date: 2005-04-22
** Last Version: V1.0 
** Description: 
**
**------------------------------------------------------------------------------------------------------
** Created By: Lishan Zhou
** Created date: 2005-04-22
** Version: V1.0 
** Description:
**
**------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
** Version:
** Description:
**
********************************************************************************************************/

#include "HostStack.h"

#ifndef		MAX_DEV_INF_MEMRY
#define 	MAX_DEV_INF_MEMRY 	10		
#endif
#ifndef		MAX_ENDP_INF_MEMRY
#define 	MAX_ENDP_INF_MEMRY 	60  		
#endif

device_instance		*device_list[ MAX_DEVICE_NUM ];


endpoint_info	*create_endpoint( device_instance *dvi_ptr, unsigned short index, unsigned short direction, unsigned short transfer_type, unsigned short max_packet_size );
unsigned short	get_string_descriptor_LANG_code( unsigned short *code, device_instance *dvi_ptr );
unsigned char	get_string_descriptor( unsigned short **unicode_str_ptr_ptr, device_instance *dvi_ptr, unsigned char index, unsigned short language_ID );
unsigned char	set_config_descriptors( device_instance	*dvi_ptr, unsigned char *buf, unsigned short length );
void			dispose_endpoint( device_instance *dvi_ptr, unsigned short index );
void			device_list_linitialize( void );
unsigned char	device_new_address( void );



unsigned char	DevInfMemIndex[MAX_DEV_INF_MEMRY];
device_instance device_infomation[MAX_DEV_INF_MEMRY] ;

void ini_device_instance(void)
{
	unsigned short i;
	for(i=0;i<MAX_DEV_INF_MEMRY;i++)	//
		 device_infomation[i].address = 0xff;
}

device_instance * malloc_device_instance(void)
{
	unsigned short i;
	for(i=0;i<MAX_DEV_INF_MEMRY;i++)	
		if( device_infomation[i].address == 0xff)
		{
			device_infomation[i].address=0;
			return &device_infomation[i];	
		}
	
	return (NULL);
}

void	free_device_instance(device_instance * dvi_ptr)
{
	unsigned short i;
	for(i=0;i<MAX_DEV_INF_MEMRY;i++)	//
		if((&device_infomation[i])==dvi_ptr)
		{
			device_infomation[i].address = 0xff;
			break;
		}
}

unsigned char	EndpInfMemIndex[MAX_ENDP_INF_MEMRY];
endpoint_info endpoint_infomation[MAX_ENDP_INF_MEMRY] ;
void ini_endpoint_info(void)
{
	unsigned short i;
	for(i=0;i<MAX_ENDP_INF_MEMRY;i++)	
	{
		endpoint_infomation[i].ep_num = ENDPOINT_BE_FREE;
		endpoint_infomation[i].tr_instance_ptr = NULL;
	}
}

endpoint_info * malloc_endpoint_info(void)
{
	unsigned short i;

	for(i=0;i<MAX_ENDP_INF_MEMRY;i++)	//
		if(endpoint_infomation[i].ep_num == ENDPOINT_BE_FREE)
		{
			endpoint_infomation[i].ep_num = 0 ;
			return &(endpoint_infomation[i]);
		}
	
	return (NULL);
}

void	free_endpoint_info(  endpoint_info * epi_ptr)
{
	epi_ptr->ep_num = ENDPOINT_BE_FREE;
	epi_ptr->tr_instance_ptr = NULL;
}

device_instance *create_device( unsigned char speed, unsigned char topology_layer )
{
	device_instance	*dvi_ptr;
	unsigned char buffer[64];
	unsigned char	*config_desc_buffer = NULL;
	unsigned short	rx_size;
	unsigned char 	i;
	unsigned char 	reserved_address;
#ifdef STRING_DESCRIPTOR	
	unsigned short		language_ID;
#endif
	if ( (0 == (reserved_address	= device_new_address())) )		
		return ( NULL );

	if ( NULL == (dvi_ptr= malloc_device_instance( ) )) 			
		return ( NULL );
	
	
	dvi_ptr->address	= 0;
	dvi_ptr->speed	= speed;
	for ( i = 0; i < MAX_ENDPOINT_NUM; i++ )	 	 			
		dvi_ptr->epi_ptr[ i ]		= NULL;
	
#ifdef STRING_DESCRIPTOR
	dvi_ptr->string_manufacturer	= NULL;
	dvi_ptr->string_product		= NULL;
	dvi_ptr->string_serialNum	= NULL;
	dvi_ptr->class_instance_ptr	= NULL;
#endif

	dvi_ptr->topology_layer		= topology_layer;
	dvi_ptr->epi_ptr[ 0 ] = create_endpoint( dvi_ptr, 0, 
									   Ep_Direction_CONTROL_ENDPOINT, 
									   Ep_TransferType_Control, 
									   DEFAULT_BUFFER_SIZE );
	if(dvi_ptr->epi_ptr[ 0 ]==NULL)
	{
		dispose_device( &dvi_ptr );
		return ( NULL );
	}
	dvi_ptr->epi_ptr[ 1 ] = create_endpoint( dvi_ptr, 1, 
									   Ep_Direction_CONTROL_ENDPOINT, 
									   Ep_TransferType_Control, 
									   DEFAULT_BUFFER_SIZE );
	if(dvi_ptr->epi_ptr[ 1 ]==NULL)
	{
		dispose_device( &dvi_ptr );
		return ( NULL );
	}

	
	rx_size = 8;
	if ( std_request( buffer, dvi_ptr, std_Dv_request_GET_DESCRIPTOR, descriptor_type_DEVICE, 0x0000, &rx_size ) )
	{
		dispose_device( &dvi_ptr );
		return ( NULL );
	}
	dvi_ptr->epi_ptr[ 0 ]->max_packet_size	= ((std_dev_descriptor *)buffer)->bMaxPacketSize0;
	dvi_ptr->epi_ptr[ 1 ]->max_packet_size	= ((std_dev_descriptor *)buffer)->bMaxPacketSize0;


	dvi_ptr->address	= reserved_address;
	rx_size				= 0;
	if ( std_request( buffer, dvi_ptr, std_Dv_request_SET_ADDRESS, (unsigned char)(dvi_ptr->address), 0x0000, &rx_size ) )
	{
		dispose_device( &dvi_ptr );
		return ( NULL );
	}
	
	dvi_ptr->epi_ptr[ 0 ]->dev_addr	= dvi_ptr->address;
	dvi_ptr->epi_ptr[ 1 ]->dev_addr	= dvi_ptr->address;

	rx_size = 18;
	if ( std_request( buffer, dvi_ptr, 
				    std_Dv_request_GET_DESCRIPTOR, 
				    descriptor_type_DEVICE, 
				    0x0000, &rx_size ) )
	{
		dispose_device( &dvi_ptr );
		return ( NULL );
	}
	memcpy( (unsigned char *)(&(dvi_ptr->dev_descriptor)), buffer, sizeof( std_dev_descriptor ) );

#ifdef STRING_DESCRIPTOR


	if (  (dvi_ptr->dev_descriptor).iManufacturer |
		(dvi_ptr->dev_descriptor).iProduct | 
		(dvi_ptr->dev_descriptor).iSerialNumber )
	{
		if ( get_string_descriptor_LANG_code( &language_ID, dvi_ptr ) )
			return ( NULL );
		if ( get_string_descriptor( &(dvi_ptr->string_manufacturer), dvi_ptr, 
							     (dvi_ptr->dev_descriptor).iManufacturer, language_ID ) )
			return ( NULL );
		if ( get_string_descriptor( &(dvi_ptr->string_product     ), dvi_ptr, 
							     (dvi_ptr->dev_descriptor).iProduct, language_ID ) )
			return ( NULL );
		if ( get_string_descriptor( &(dvi_ptr->string_serialNum   ), dvi_ptr, 
							     (dvi_ptr->dev_descriptor).iSerialNumber, language_ID ) )
			return ( NULL );
	}
#endif	
	
	
	rx_size = 4;
	if ( std_request( buffer, dvi_ptr, 
				    std_Dv_request_GET_DESCRIPTOR, 
				    descriptor_type_CONFIGURATION, 
				    0x0000, &rx_size ) )
	{
		dispose_device( &dvi_ptr );
		return ( NULL );
	}


	rx_size = 	((std_conf_descriptor *)buffer)->wTotalLength;
	if ( NULL == (config_desc_buffer	= (unsigned char *)malloc( sizeof( unsigned char ) * rx_size )) )
		return ( NULL );
	if ( std_request( config_desc_buffer, dvi_ptr, 
				    std_Dv_request_GET_DESCRIPTOR, 
				    descriptor_type_CONFIGURATION, 
				    0x0000, &rx_size ) )
	{
		free( config_desc_buffer );
		dispose_device( &dvi_ptr );
		return ( NULL );
	}
	if(set_config_descriptors( dvi_ptr, config_desc_buffer, rx_size ))
	{
		free( config_desc_buffer );
		dispose_device( &dvi_ptr );
		return ( NULL );
	}
	free( config_desc_buffer );



	rx_size = 0;
	if ( std_request( buffer, dvi_ptr, 
				     std_Dv_request_SET_CONFIGURATION, 
				     ((dvi_ptr->conf_descriptor).bConfigurationValue), 
				     0x0000, &rx_size ) )
	{
		dispose_device( &dvi_ptr );
		return ( NULL );
	}

#ifdef CLASS_DRIVE

	if ( class_driver_install( dvi_ptr ) )		
	{
		dispose_device( &dvi_ptr );
		return ( NULL );
	}
#endif

	device_list[ reserved_address ] = dvi_ptr;
	
	return ( dvi_ptr );
}



#ifdef STRING_DESCRIPTOR

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

	if ( 0 != (err	= 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 );
}
#endif

#ifdef STRING_DESCRIPTOR

unsigned char get_string_descriptor( unsigned short **unicode_str_ptr_ptr, 
									  device_instance *dvi_ptr, 
									  unsigned char index, 
									  unsigned short language_ID )
{
	unsigned 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	= 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 )) )		
		return 0xff;
	if ( 0 != (err= std_request( (unsigned char *)(*unicode_str_ptr_ptr), dvi_ptr, 
							std_Dv_request_GET_DESCRIPTOR, 
							descriptor_type_STRING | index, 
							language_ID, &rx_size )) )
		return ( err );
	return ( 0 );
}
#endif




unsigned short 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	= control_transfer( &req, dvi_ptr, buff_ptr );	
	if ( err )
	{	if ( err & 0x8000 )							
		{	*wLength = err & 0x7FFF;				
			err 		= 0;							
		}
	}
	return ( err );
}





#define		descriptor_length( x )			*( x )
#define		descriptor_type( x )			*( (x) + 1 )
unsigned char set_config_descriptors( device_instance *dvi_ptr, 
									    unsigned char *buf, 
									    unsigned short length )
{
	unsigned char			*buf_end;
	unsigned char			desc_length;
	unsigned short			desc_type;
	std_endpoint_descriptor	tmp_ep_desc;
	endpoint_info			*epi_ptr;
	unsigned char			get_just_one_interface_descripter= 1;