dev_ep.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] 
*/

/*
**	HID-Keyboard/Mouse handling framework has been written by Hisashige Harashima
**		04-Mar-2002
*/



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

#include		<stdio.h>
#include		<stdlib.h>
#include		<alloc.h>
#include		<limits.h>
#include		<mem.h>

#include		"_hc_core/atl_mix.h"
#include		"_hc_core/chap9.h"
#include		"_hc_core/dev_ep.h"
#include		"_hc_core/transfer.h"
#include		"_hc_core/dev_ep.h"

#include		"_hc_cls/cls_hndl.h"

#include 		"_otg/otg.h"

#include		"ui.h"
#include		"general.h"


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

//	#define		Use_DESCROPTOR_SAVER		//	To use this option, make a folder named "log" in application folder
//	#define		Warn_unknown_DESCROPTOR

#define		BUFF_SIZE		UCHAR_MAX


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

device_instance		*device_list[ MAX_DEVICE_NUM ];
unsigned char		*g_config_desc_buffer_ptr		= NULL;
unsigned short		g_config_desc_buffer_length		= 0;


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

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 short	get_string_descriptor( unsigned short **unicode_str_ptr_ptr, device_instance *dvi_ptr, unsigned char index, unsigned short language_ID );
void			dispose_endpoint( device_instance *dvi_ptr, unsigned short index, unsigned char direction );
void			devep_device_list_linitialize( void );
unsigned char	device_new_address( void );


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



/*************************************************
**
**  Create a device instance
**
*************************************************/

device_instance *devep_create_device( unsigned char speed, unsigned char topology_layer )
{
	device_instance		*dvi_ptr;
	unsigned char		buffer[ BUFF_SIZE ];
	unsigned short		rx_size;
	unsigned short		language_ID;
	int					i;
	unsigned char 		reserved_address;

//	mprintf( WHITE, CONTINUE, "creating device instance.\r\n" );
	
	/*	Check : Is new address available?  */
	
	if ( (0 == (reserved_address	= device_new_address())) )
	{
		mprintf( LIGHTRED, CONTINUE, "no available device address\r\n" );
		return ( NULL );
	}

	dvi_ptr		= devep_make_device_and_setup_ep0_connection( speed, topology_layer );

	if ( NULL == dvi_ptr )
	{
		mprintf( LIGHTRED, CONTINUE, "malloc failed @ newing device instance\r\n" );
		return ( NULL );
	}

	/*	Communication (enumeration) starts  */
	
	/********************************************/	
	/*	Get Descriptor [Device] 8 bytes			*/
	/*		to get MaxPacketSize of Endpoint 0	*/
	/********************************************/	
	//mprintf( WHITE, CONTINUE, "\r\nGet Descriptor [Device] 8 bytes    \r\n" );
	
	rx_size		= 8;
	
	if ( devep_std_request( buffer, dvi_ptr, std_Dv_request_GET_DESCRIPTOR, descriptor_type_DEVICE, 0x0000, &rx_size ) )
	{
		devep_dispose_device( &dvi_ptr );
		return ( NULL );
	}
	
	(dvi_ptr->epi_ptr[ EpOUT ][ 0 ])->max_packet_size	= ((std_dev_descriptor *)buffer)->bMaxPacketSize0;

	/********************************************/	
	/*	Set Address								*/
	/*		set new device address				*/
	/********************************************/	
	//mprintf( WHITE, CONTINUE, "\r\nSet Address    \r\n" );	
		
	dvi_ptr->address	= reserved_address;
	rx_size				= 0;
	
	if ( devep_std_request( buffer, dvi_ptr, std_Dv_request_SET_ADDRESS, (unsigned char)(dvi_ptr->address), 0x0000, &rx_size ) )
	{
		devep_dispose_device( &dvi_ptr );
		return ( NULL );
	}
	
	(dvi_ptr->epi_ptr[ EpOUT ][ 0 ])->dev_addr	= dvi_ptr->address;

	/********************************************/	
	/*	Get Descriptor [Device] 18 bytes		*/
	/*		to get full device descriptor		*/
	/********************************************/	
	//mprintf( WHITE, CONTINUE, "\r\nGet Descriptor [Device] 18 bytes    \r\n" );	
	
	rx_size				= 18;

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


	/********************************************/	
	/*	Get Descriptor [String]					*/
	/*		If failed, returns a NULL			*/
	/********************************************/	
	//mprintf( WHITE, CONTINUE, "\r\nGet Descriptor [String]    \r\n" );


	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 ) )
		{
			devep_dispose_device( &dvi_ptr );
			return ( NULL );
		}

		if ( get_string_descriptor( &(dvi_ptr->string_manufacturer), dvi_ptr, (dvi_ptr->dev_descriptor).iManufacturer, language_ID ) )
		{
			devep_dispose_device( &dvi_ptr );
			return ( NULL );
		}
		
		if ( get_string_descriptor( &(dvi_ptr->string_product     ), dvi_ptr, (dvi_ptr->dev_descriptor).iProduct,      language_ID ) )
		{
			devep_dispose_device( &dvi_ptr );
			return ( NULL );
		}

		if ( get_string_descriptor( &(dvi_ptr->string_serialNum   ), dvi_ptr, (dvi_ptr->dev_descriptor).iSerialNumber, language_ID ) )
		{
			devep_dispose_device( &dvi_ptr );
			return ( NULL );
		}
	}

	
	/********************************************/	
	/*	Class procedure							*/
	/*		--------------------				*/
	/********************************************/	
	//mprintf( WHITE, CONTINUE, "\r\nClass procedure    \r\n" );	

	if ( NULL == (g_config_desc_buffer_ptr	= devep_get_configuration_and_interface( dvi_ptr )) )
	{
		devep_dispose_device( &dvi_ptr );
		return ( NULL );
	}

	if ( clshndl_initialization_method( dvi_ptr ) )
	{
		devep_dispose_device( &dvi_ptr );
		return ( NULL );
	}

	if ( NULL == dvi_ptr->class_instance_ptr )
	{
		//	This will set the device in default setting : Configuration=1, Interface=0 
	
		/********************************************/	
		/*	Get Descriptor [Cnfg] 					*/
		/*		--------------------				*/
		/********************************************/	

		if ( devep_regist_config_descriptors( dvi_ptr, 1, 0 ) )
		{
			devep_dispose_device( &dvi_ptr );
			return ( NULL );
		}
	}
	
	free( g_config_desc_buffer_ptr );
	
	g_config_desc_buffer_ptr		= NULL;
	g_config_desc_buffer_length		= 0;

	
	device_list[ reserved_address ]		= dvi_ptr;

//	ui_device_infomation_viewer( dvi_ptr );


	return ( dvi_ptr );
}


unsigned char *devep_get_configuration_and_interface( device_instance *dvi_ptr )
{
	unsigned char		*big_buffer_ptr;
	unsigned char		buffer[ 4 ];
	unsigned short		rx_size;


	/********************************************/	
	/*	Get Descriptor [Cnfg] 4 bytes			*/
	/*		to get the size of cnfg descriptor	*/
	/********************************************/	
	//mprintf( WHITE, CONTINUE, "\r\nGet Descriptor [Cnfg] 4 bytes    \r\n" );	
			
	rx_size				= 4;

	if ( devep_std_request( buffer, dvi_ptr, std_Dv_request_GET_DESCRIPTOR, descriptor_type_CONFIGURATION, 0x0000, &rx_size ) )
		return ( big_buffer_ptr );

	/********************************************/	
	/*	Get Descriptor [Cnfg] full size			*/
	/*		to get full cnfg... descriptor		*/
	/********************************************/	
	//mprintf( WHITE, CONTINUE, "\r\nGet Descriptor [Cnfg] full size    \r\n" );	
	
	rx_size				= 	((std_conf_descriptor *)buffer)->wTotalLength;

	if ( NULL == (big_buffer_ptr	= (unsigned char *)malloc( sizeof( unsigned char ) * rx_size )) )
		mprintf( LIGHTRED, ABORT, "malloc failed @ newing device instance (more size temp. buffer.\r\n" );

	if ( devep_std_request( big_buffer_ptr, dvi_ptr, std_Dv_request_GET_DESCRIPTOR, descriptor_type_CONFIGURATION, 0x0000, &rx_size ) )
	{
		free( big_buffer_ptr );
		big_buffer_ptr	= NULL;
		
		return ( big_buffer_ptr );
	}
	
	g_config_desc_buffer_length		= rx_size;
	
	/*	NOTE :	The CONFIGURATION descriptor is just 9 byte descriptor.	 */
	/*			INTERFACE, ENDPOINT descriptors will follow after this	 */

	/*	Set first config and IF descriptor for temporary use	*/

	memcpy( (unsigned char *)(&(dvi_ptr->conf_descriptor)),       (unsigned char *)(big_buffer_ptr + 0), sizeof( std_conf_descriptor )      );
	memcpy( (unsigned char *)(&(dvi_ptr->interfacef_descriptor)), (unsigned char *)(big_buffer_ptr + 9), sizeof( std_interface_descriptor ) );

	return ( big_buffer_ptr );
}





/*************************************************
**
**  Parse descriptors which was obtained by "get descriptor configuration"
**
*************************************************/


#define		descriptor_length( x )			*( x )
#define		descriptor_type( x )			*((x) + 1)

unsigned char devep_regist_config_descriptors( device_instance *dvi_ptr, unsigned char configuration_number, unsigned char interface_number )
{
	unsigned char				n_config		= 1;
	unsigned char				n_interface		= 0;
	unsigned char				*buf;
	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_if_descriptors		= False;
	unsigned char				get_ep_descriptors		= False;
	
	if ( !configuration_number )	
		return ( 0 );

	{
		unsigned char	b;
		unsigned short	rx_size		= 0;
	
		if ( devep_std_request( &b, dvi_ptr, std_Dv_request_SET_CONFIGURATION, configuration_number, 0x0000, &rx_size ) )
			return ( 1 );
		
		if ( interface_number )
		{
			if ( devep_std_request( &b, dvi_ptr, std_Dv_request_SET_INTERFACE, interface_number, 0x0000, &rx_size ) )
				return ( 1 );
		}
	}
	

	buf			= g_config_desc_buffer_ptr;
	buf_end		= buf + g_config_desc_buffer_length;

	while ( buf < buf_end )
	{
		desc_length		= descriptor_length( buf );
		desc_type		= descriptor_type( buf ) << 8;	/*	See "_hc_core/chap9.h". Constants descriptor_type_XXX are 
															defined as upper byte in unsigned short				*/
		
		switch ( desc_type )
		{
			case descriptor_type_CONFIGURATION :
			
				if ( n_config == configuration_number )
				{
					memcpy( (unsigned char *)(&(dvi_ptr->conf_descriptor)), (unsigned char *)(buf), sizeof( std_conf_descriptor ) );
					get_if_descriptors	= True;
				}	
				else if ( n_config > configuration_number )
				{
					return ( 0 );
				}
				n_config++;
				
				break;
				
			case descriptor_type_INTERFACE :
			
				if ( get_if_descriptors )
				{
					if ( n_interface == interface_number )
					{
						memcpy( (unsigned char *)(&(dvi_ptr->interfacef_descriptor)), (unsigned char *)(buf), sizeof( std_interface_descriptor ) );
						get_ep_descriptors	= True;
					}	
					else if ( n_interface > interface_number )
					{
						return ( 0 );
					}
					n_interface++;
				}
				
				break;
				
			case descriptor_type_ENDPOINT :
			
				if ( get_ep_descriptors )
				{
					memcpy( (unsigned char *)(&(tmp_ep_desc)), (unsigned char *)(buf), sizeof( std_endpoint_descriptor ) );

					{
						unsigned char	direction;
						unsigned char	ep_address;
					
						direction		= EpDirection_bEndpointAddress( tmp_ep_desc.bEndpointAddress ) ? EpIN : EpOUT;
						ep_address		= EpNumber_bEndpointAddress( tmp_ep_desc.bEndpointAddress );
						
						if ( !(dvi_ptr->epi_ptr[ direction ][ ep_address ]) )
						{
							epi_ptr		= create_endpoint(	
															dvi_ptr, 
															ep_address,
															direction,
															Ep_TransferType_bmAttributes( tmp_ep_desc.bmAttributes ), 
															tmp_ep_desc.wMaxPacketSize
														);
															
							if ( NULL == epi_ptr )
								return ( 1 );
					
							epi_ptr->endpoint_descriptor					= tmp_ep_desc;		
							dvi_ptr->epi_ptr[ direction ][ ep_address ]		= epi_ptr;
						}