mass.c

usb host在ARM7上的实现

#include "HostStack.h"

MassStorageClass *create_mass_class_instance( device_instance *dvi_ptr );
void				dispose_mass_class_instance( device_instance *dvi_ptr );

unsigned char MassStorageReset(device_instance * DevicePtr);
unsigned char GetMaxLUN(device_instance * DevicePtr);

unsigned char  GetThisInquiryData(hMedLUN * hMedLUNPtr);
unsigned char  GetThisMediumCapacity(hMedLUN * hMedLUNPtr);
unsigned char	GetRequestSense(hMedLUN * hMedLUNPtr, SENSE_DATA *SenseDataPtr);

hMedLUN	*GetMassBulkOnlyInfo(MassStorageClass *mass_i_ptr);
hMedLUN	*GetMassCBIOnlyInfo(MassStorageClass *mass_i_ptr);

//******************************************************************************************
// 函数名称：mass_init_commands
// 输入参数：dvi_ptr，设备描述信息数据结构指针
// 输出参数：正常返回0，出错返回非0。
// 功能描述：大容量类设备初始化函数
//******************************************************************************************
unsigned short mass_init_commands( device_instance *dvi_ptr )
{	MassStorageClass *mass_i_ptr;
	mass_i_ptr= create_mass_class_instance( dvi_ptr );
	if ( NULL == mass_i_ptr )
		return (1);
	dvi_ptr->class_instance_ptr	= mass_i_ptr;
	return ( 0 );
}


	MassStorageClass MSCDevices[MAX_MASS_DEVICES_DEFINE];
/*初始化大容量类内存 */
void ini_mass_device_mem(void)
{
	uint16	i;
	for( i=0; i<MAX_MASS_DEVICES_DEFINE ;i++)
		MSCDevices[i].dvi_ptr = NULL;
}
/* 获取大容量类内存 */
MassStorageClass 	*malloc_mass_device_mem(void)
{
	uint16	i;
	for( i=0; i<MAX_MASS_DEVICES_DEFINE ;i++)
		if(MSCDevices[i].dvi_ptr==NULL)
		{
			MSCDevices[i].dvi_ptr = (device_instance *)(-1);
			return &MSCDevices[i];
		}
	return NULL;
}
/*释放大容量类内存 */
void free_mass_device_mem(MassStorageClass * MSC_ptr)
{
	uint16	i;
	for( i=0; i<MAX_MASS_DEVICES_DEFINE ;i++)
		if( &MSCDevices[i] == MSC_ptr )
			MSC_ptr->dvi_ptr = NULL;
}
/******************************************************************/
/*  逻辑单元内存管理  */
/******************************************************************/
#define MAX_MASS_DEVICES_LUN_DEFINE 	MAX_MASS_DEVICES_DEFINE+ 3
	hMedLUN MSCDeviceLNUs[MAX_MASS_DEVICES_LUN_DEFINE];

void ini_mass_device_LUN_mem(void)
{
	uint16	i;
	for( i=0; i<MAX_MASS_DEVICES_LUN_DEFINE ;i++)
		MSCDeviceLNUs[i].MSC = NULL;
}
hMedLUN 	*malloc_mass_device_LUN_mem(void)
{
	uint16	i;
	for( i=0; i<MAX_MASS_DEVICES_LUN_DEFINE ;i++)
		if(MSCDeviceLNUs[i].MSC==NULL)
		{
			MSCDeviceLNUs[i].MSC = (MassStorageClass *)(-1);
			return &MSCDeviceLNUs[i];
		}
	return NULL;		
}

void free_mass_device_LNU_mem(hMedLUN * MSCLUN_ptr)
{
	uint16	i;
	for( i=0; i<MAX_MASS_DEVICES_LUN_DEFINE ;i++)
		if( &MSCDeviceLNUs[i] == MSCLUN_ptr)
			MSCLUN_ptr->MSC = NULL;
}
	

//************************************************************************************
// 函数名称：create_mass_class_instance
// 输入参数：dvi_ptr，设备描述信息数据结构指针
// 输出参数：设描述信息结构指针
// 功能描述：建立大容量类设备实例
//************************************************************************************
MassStorageClass *create_mass_class_instance( device_instance *dvi_ptr )
{
	//	This instance will be disposed in function "dispose_device()"

	MassStorageClass			*mass_i_ptr;
	endpoint_info				*epi_ptr;
	transfer_instance			*tr_instance_ptr;

	if ( NULL == (mass_i_ptr = malloc_mass_device_mem()) )/*分配内存*/
		return NULL ;

	mass_i_ptr->LUN = 0 ;
	mass_i_ptr->dvi_ptr = dvi_ptr;				
	mass_i_ptr->setup_epi_ptr = dvi_ptr->epi_ptr[0];
	mass_i_ptr->ProtocolCode = Get_bInterfaceProtocol(dvi_ptr);
	mass_i_ptr->SubclassCode = Get_bInterfaceSubClass(dvi_ptr);
	mass_i_ptr->tr_bulk_in_ptr = NULL ;
	mass_i_ptr->tr_bulk_out_ptr = NULL ;
	mass_i_ptr->tr_int_in_ptr = NULL ;
	mass_i_ptr->CBW_BuffPtr = NULL ;
	/* 创建传输描述符 */
	epi_ptr = find_endport_type(dvi_ptr, Ep_TransferType_Bulk, Ep_Direction_IN_ENDPOINT, 1);
	if( epi_ptr == NULL )
		return NULL ;
	if(NO_OPEN_ATL_TRANSFER==(tr_instance_ptr=atl_open_transfer_instance( epi_ptr )))
		return NULL ;
	mass_i_ptr->tr_bulk_in_ptr = tr_instance_ptr;

	epi_ptr = find_endport_type(dvi_ptr, Ep_TransferType_Bulk, Ep_Direction_OUT_ENDPOINT, 1);
	if( epi_ptr == NULL )
		return NULL ;
	if(NO_OPEN_ATL_TRANSFER==(tr_instance_ptr=atl_open_transfer_instance( epi_ptr )))
		return NULL ;
	mass_i_ptr->tr_bulk_out_ptr = tr_instance_ptr;

	/* 保存大容量设备的接口子类及传输协议代码 */ 


	
	if(mass_i_ptr->ProtocolCode  == 0x50)	/* Bulk-Only */
	{
		if(GetMassBulkOnlyInfo(mass_i_ptr) == NULL)
			return NULL;
	}
	else									/* CBI-Only */
	{
		if(GetMassCBIOnlyInfo(mass_i_ptr) == NULL)
			return NULL;
	}


	return ( mass_i_ptr );
}
//**********************************************************************************************
// 函数名称：GetMassBulkOnlyInfo
// 输入参数：mass_i_ptr，大容量类设备描述数据结构指针
// 输出参数：出错返回NULL
//				    正确返回最后一个逻辑单元描述指针
// 功能描述：获取大容量类CBI协议设备描述信息。
//**********************************************************************************************
hMedLUN	*GetMassBulkOnlyInfo(MassStorageClass *mass_i_ptr)
{
	unsigned char  MediumIndex;
	hMedLUN		*medium_infor_ptr;
	
	mass_i_ptr->CBW_BuffPtr = malloc( sizeof( unsigned char )* 31 );	// 为CBW包分配固定内存
	if(mass_i_ptr->CBW_BuffPtr ==NULL)
		return NULL ;
	mass_i_ptr->CBW_BuffPtr[0] = 0x55;
	mass_i_ptr->CBW_BuffPtr[1] = 0x53;
	mass_i_ptr->CBW_BuffPtr[2] = 0x42;
	mass_i_ptr->CBW_BuffPtr[3] = 0x43;

//	if(FALSE ==MassStorageReset(mass_i_ptr->dvi_ptr))// 大容量设备复位
//		return NULL ;
	mass_i_ptr->LUN = GetMaxLUN(mass_i_ptr->dvi_ptr);	//获取媒体最大逻辑单元号
	for(MediumIndex = 0;mass_i_ptr->LUN +1>MediumIndex;MediumIndex++)
	{
		if ( NULL == (medium_infor_ptr= malloc_mass_device_LUN_mem()) )	/*分配内存*/
			break ;
		mass_i_ptr->LUN_infor_ptr[MediumIndex] = medium_infor_ptr;	// 保存逻辑单元描述信息数据结构指针
		medium_infor_ptr->LUN = MediumIndex;
		medium_infor_ptr->MSC = mass_i_ptr ;
		medium_infor_ptr->BlockLengthInBytes = 0;
		medium_infor_ptr->LastLogicalBlookAddress=0;
		if( GetThisInquiryData( medium_infor_ptr ) )						// 获取产品及厂家信息
			return NULL ;
	}
	return medium_infor_ptr;
}

//**********************************************************************************************
// 函数名称：GetMassCBIOnlyInfo
// 输入参数：mass_i_ptr，大容量类设备描述数据结构指针
// 输出参数：出错返回NULL
//				    正确返回逻辑单元描述指针
// 功能描述：获取大容量类CBI协议设备描述信息。
//**********************************************************************************************
hMedLUN	*GetMassCBIOnlyInfo(MassStorageClass *mass_i_ptr)
{
	hMedLUN			*medium_infor_ptr;
	endpoint_info		*epi_ptr;
	transfer_instance	*tr_instance_ptr;
	if( NULL == (epi_ptr = find_endport_type(mass_i_ptr->dvi_ptr, Ep_TransferType_Interrupt, Ep_Direction_IN_ENDPOINT, 1)))
		return NULL ;
	if(NO_OPEN_ATL_TRANSFER==(tr_instance_ptr=atl_open_transfer_instance( epi_ptr )))
		return NULL ;
	mass_i_ptr->tr_int_in_ptr = tr_instance_ptr;
	if ( NULL == (medium_infor_ptr = malloc_mass_device_LUN_mem()) )	/*分配内存*/
		return NULL ;
	mass_i_ptr->LUN_infor_ptr[0] = medium_infor_ptr;	// 保存逻辑单元描述信息数据结构指针
	medium_infor_ptr->LUN = 0;
	medium_infor_ptr->MSC = mass_i_ptr ;
	medium_infor_ptr->BlockLengthInBytes = 0;
	medium_infor_ptr->LastLogicalBlookAddress=0;
	if(GetThisInquiryData(medium_infor_ptr) )						// 获取产品及厂家信息
		return NULL ;
	return medium_infor_ptr;
}


//**********************************************************************************************
// 函数名称：dispose_mass_class_instance
// 输入参数：dvi_ptr，设备描述信息数据结构指针
// 输出参数：无
// 功能描述：删除大容量设备处理。
//**********************************************************************************************
void dispose_mass_class_instance( device_instance *dvi_ptr )
{
	MassStorageClass		*mass_i_ptr;
	unsigned short			i;

	
	mass_i_ptr = (MassStorageClass *)mass_instance_ptr( dvi_ptr );
	if(mass_i_ptr==NULL)
		return;

	/* 删除传输描述符 */
	if(mass_i_ptr->tr_bulk_in_ptr)
		atl_close_transfer_instance(mass_i_ptr->tr_bulk_in_ptr);
	if(mass_i_ptr->tr_bulk_out_ptr)
		atl_close_transfer_instance(mass_i_ptr->tr_bulk_out_ptr);
	if(mass_i_ptr->tr_int_in_ptr)
		atl_close_transfer_instance(mass_i_ptr->tr_int_in_ptr);
	/* 释放命令块占用的内存*/ 
	if(mass_i_ptr->CBW_BuffPtr)
		free(mass_i_ptr->CBW_BuffPtr);				
	/* 释放逻辑单元描述信息数据结构 */
	for(i=0;i <= mass_i_ptr->LUN+1; i++)
		if(mass_i_ptr->LUN_infor_ptr[i])
		{
			free_mass_device_LNU_mem(mass_i_ptr->LUN_infor_ptr[i]);
			mass_i_ptr->LUN_infor_ptr[i] = NULL;
		}
	/* 释放大容量类设备描述符 */
	if( dvi_ptr->class_instance_ptr )
		free_mass_device_mem(dvi_ptr->class_instance_ptr);
	dvi_ptr->class_instance_ptr = NULL;
}

//******************************************************************************************
// 函数名称：mass_dispose_process
// 输入参数：dvi_ptr，设备描述信息数据结构指针
// 输出参数：返回0
// 功能描述：删除大容量类设备处理函数
//******************************************************************************************
unsigned short mass_dispose_process( device_instance *dvi_ptr )
{
	dispose_mass_class_instance(dvi_ptr);
	return ( 0 );
}


//********************************************************************************
//函数名称：Creat_Medium
//输入参数：dvi_ptr，大容量设备的设备描述信息结构指针
//				   LUNIndex，逻辑单元索引，0为第1个逻辑单元
//输出参数：逻辑单元存在，返回逻辑单元描述符指针
//				   逻辑单元不存在，返回一个容指针
//功能描述：建立(获取)大容量设备的一个媒介(逻辑单元)描述符。
//********************************************************************************
hMedLUN * Creat_Medium(device_instance *dvi_ptr ,unsigned char LUNIndex)
{
	hMedLUN * hMedLUNPtr=0;
	MassStorageClass *MSC_ptr;
	unsigned char i,Statue;
	SENSE_DATA SenseData;
		
	MSC_ptr = mass_instance_ptr(dvi_ptr);
	if(MSC_ptr ==NULL)				/* 检验类描述结构指针*/
		return NULL;
	if(MSC_ptr->LUN < LUNIndex)		/* 检验逻辑单元索引 */
		return NULL;
	
	if( (MSC_ptr->LUN_infor_ptr[LUNIndex]->LastLogicalBlookAddress==0) 
	    && ( MSC_ptr->LUN_infor_ptr[LUNIndex]->BlockLengthInBytes==0))
	{
		hMedLUNPtr = MSC_ptr->LUN_infor_ptr[LUNIndex];
		for( i=0; i<3; i++ )
		{
			Statue = GetThisMediumCapacity(hMedLUNPtr);	
			if(Statue)
			{ 	
				
				if(Statue== COMMAND_FAILED)
				{	if(GetRequestSense(hMedLUNPtr, &SenseData))
						return NULL;
					else
					{  /* 这里分析出错原因 */
						if((SenseData.ASC==0x34)&&(SenseData.ASCQ==0x00))
						{/* MEDIUM NOT PRESENT */
								
						}