mass_storage.c

君正早期ucos系统(只有早期的才不没有打包成库),MPLAYER,文件系统,图片解码,浏览,电子书,录音,想学ucos,识货的人就下吧 russblock fmradio explore set

		break;
	default:
		pBus->StartTransfer(handle,pipe[0].ep, (unsigned char *)&confDesc, sizeof(confDesc));
		break;
	}
}

static inline void get_dev_qualify_descitptor(unsigned int handle,USB_DeviceRequest *dreq)
{
    PUDC_BUS pBus = (PUDC_BUS)handle;
    pBus->StartTransfer(handle,pipe[0].ep, (unsigned char *)&devQualifyDesc, sizeof(devQualifyDesc));	
}


static inline unsigned int usbHandleClassDevReq(unsigned int handle,unsigned char *buf)
{
	u8 scsiLUN = 0;
	PUDC_BUS pBus = (PUDC_BUS)handle;
	switch (buf[1]) {
	case 0xfe:
		scsiLUN = curLunCount - 1;
		dprintf("Get max lun %d %x\n",scsiLUN,handle,pipe[0].ep);
		if (buf[0] == 0xa1)
			pBus->StartTransfer(handle,pipe[0].ep, (unsigned char *)&scsiLUN, 1);
		break;
	case 0xff:
		dprintf("Mass storage reset\n");
		break;
	}
	return 1;
	
}
static inline void get_dev_descriptor_string(unsigned int handle,USB_DeviceRequest *dreq)
{
	int size = dreq->wLength;
	PUDC_BUS pBus = (PUDC_BUS)handle;
	static u16 str_ret[] = {
		0x0336,    //0x1a=26 byte
		'F',
		'i',
		'l',
		'e',
		'-',
		'b',
		'a',
		'c',
		'k',
		'e',
		'd',
		'S',

		't',
		'o',
		'r',
		'a',
		'g',
		'e',
		'G',

		'a',
		'd',
		'g',
		'e',
		't'
	};
	static u16 str_lang[] = {
		0x0304,
		0x0409
	};

	static u16 str_isernum[] = {
		0x031a,
		'3',
		'2',
		'3',
		'8',
		'2',
		'0',
		'4',
		'7',
		'4',
		'0',
		'7',
		'7'
	};

	printf("send_dev_desc_string size = %d type %d \r\n",size,dreq->wValue & 0xff);

	switch ( dreq->wValue & 0xff )
	{
	case 0:       //land ids
		if ( size > sizeof(str_lang) )
			pBus->StartTransfer(handle,pipe[0].ep,(unsigned char *)str_lang,sizeof(str_lang));
		else
			pBus->StartTransfer(handle,pipe[0].ep,(unsigned char *)str_lang,size);
		return;
		break;
	case 1:       //iserialnumber
		if(size >= sizeof(str_isernum))
			size = sizeof(str_isernum);
		pBus->StartTransfer(handle,pipe[0].ep,(unsigned char *)str_isernum,size);
		break;

	case 2:       //iproduct
		if(size >= 36)
			size = 36;
		str_ret[0] = (0x0300 | size);
		pBus->StartTransfer(handle,pipe[0].ep,(unsigned char *)str_ret,size);
		break;
	case 3:       //iserialnumber
		if(size >= sizeof(str_isernum))
			size = sizeof(str_isernum);
		pBus->StartTransfer(handle,pipe[0].ep,(unsigned char *)str_isernum,size);
		break;
	case 0xee:    //microsoft OS!
		str_isernum[0] = (0x0300 | size);
		pBus->StartTransfer(handle,pipe[0].ep,(unsigned char *)str_isernum,size);
		break;
	}
}

static unsigned int udc_setup_handle(unsigned int handle,unsigned int stat,unsigned char *bufaddr,unsigned int len)
{
	PUDC_BUS pBus = (PUDC_BUS)handle;
	USB_DeviceRequest *dreq = (USB_DeviceRequest *)bufaddr;
	if(len != 8)
		return 0;
	if(dreq->bmRequestType == 0xa1)
	{
		if(dreq->bRequest == 0xfe)
		{
			return usbHandleClassDevReq(handle,bufaddr);
			
		}
		return;
		
		
	}
	if(dreq->bmRequestType == 0x21)
	{
		if(dreq->bRequest == 0xff)
		{
			return usbHandleClassDevReq(handle,bufaddr);
		}
		
	}
	
	switch (dreq->bRequest) {
	case GET_DESCRIPTOR:
		if (dreq->bmRequestType == 0x80)	/* Dev2Host */
			switch(dreq->wValue >> 8) 
			{
			case DEVICE_DESCRIPTOR:
				dprintf("get device!\n");
				get_dev_descriptor(handle,dreq);
				break;
			case CONFIGURATION_DESCRIPTOR:
				dprintf("get config!\n");
				get_dev_configuration(handle,dreq);
				break;
			case STRING_DESCRIPTOR:
				dprintf("get string!\n");
				get_dev_descriptor_string(handle,dreq);
				break;
			case DEVICE_QUALIFIER_DESCRIPTOR:
				dprintf("get qualify!\n");
				get_dev_qualify_descitptor(handle,dreq);
				break;
				
			}
		
		break;
	case SET_ADDRESS:
		dprintf("\nSET_ADDRESS!");
		pBus->SetAddress(handle,dreq->wValue);
		break;
		
	case GET_STATUS:
		switch (dreq->bmRequestType) {
		case 80:	/* device */
		  mass_get_state = 0x1;
			pBus->StartTransfer(handle,pipe[0].ep,(u8*)&mass_get_state,2);			
			break;
		case 81:	/* interface */
		case 82:	/* ep */
			mass_get_state = 0;
			pBus->StartTransfer(handle,pipe[0].ep,(u8*)&mass_get_state,2);			
			break;
		}

		break;
   
	case CLEAR_FEATURE:
		printf("CLEAR_FEATURE!\r\n");
		break;
		
	case SET_CONFIGURATION:
		printf("SET_CONFIGURATION!\r\n");
//		pBus->StartTransfer(handle,pipe[0].ep,massbuf,0);			

		break;
		
	case SET_INTERFACE:
		printf("SET_INTERFACE!\r\n");
		break;
	case SET_FEATURE:
		printf("SET_FEATURE!\r\n");
		break;
	default:	
        printf("protal isn't surporst\r\n");
		
	}
	return 1;
}


static unsigned int handle_receive_data(unsigned handle,unsigned char *buf,unsigned int len)
{
	PUDC_LUN pdev = pDev[cbw.bCBWLUN]; 
	PUDC_BUS pBus = (PUDC_BUS)handle;
	unsigned int ret;
	unsigned int sectors = len / g_sector_size;
   
//	ret = pdev->WriteDevSector((unsigned int)pdev,buf,g_start_sector,sectors);
#ifndef MUTI_THREAD
	ret = pdev->WriteDevSector((unsigned int)pdev,buf,g_start_sector,sectors);
#else
	if ( udc_trigger == 1 )
	{
		udc_trigger = 0;
		OSSemPost(sem_buf1);
	}
	else 
	{
		udc_trigger = 1;
		OSSemPost(sem_buf0);
	}
	
	OSSemPend(sem_device, 0, &err);    //lock device!
	ssector = g_start_sector;
	nsector = sectors;
	OSSemPost(sem_mass);                //wake mass task
#endif

	g_start_sector += sectors;
	g_nr_sectors -= sectors;
	if(g_nr_sectors)
	{
		sectors = g_nr_sectors * g_sector_size;
#ifdef MUTI_THREAD
		if ( udc_trigger == 1 )
		{
			massbuf = (unsigned char *)((unsigned int)massBuf1 | 0xa0000000);
			OSSemPend(sem_buf1, 0, &err);
		}
		else 
		{
			massbuf = (unsigned char *)((unsigned int)massBuf0 | 0xa0000000);
			OSSemPend(sem_buf0, 0, &err);
		}
#endif
		if(sectors > UDC_FRAME_SIZE)
			pBus->StartTransfer(handle,pipe[2].ep,massbuf_ptr,UDC_FRAME_SIZE);
		else
			pBus->StartTransfer(handle,pipe[2].ep,massbuf_ptr,sectors);
		
	}else
	{
		mass_state = SENDED_CSW;
		//send csw data
		Handle_CSW(handle);
		
		
	}
	return ret;
}

static unsigned int handle_receive(unsigned handle,unsigned char *buf,unsigned int len)
{
	//printf("mass_state = %d,RECEIVE_CBW = %d\n",mass_state,RECEIVE_CBW);
	
	if(mass_state == RECEIVE_CBW)
	{
		return USB_HandleCBW(handle);
		
	}
	if(mass_state == RECEIVE_DATA) 
	{
		return handle_receive_data(handle,buf,len);
	}
	
	return 1;
}
static unsigned int handle_send_data(unsigned handle,unsigned char *buf,unsigned int len)
{
	PUDC_LUN pdev = pDev[cbw.bCBWLUN]; 
	PUDC_BUS pBus = (PUDC_BUS)handle;
	unsigned short sectors = UDC_FRAME_SIZE / g_sector_size;
	if(g_nr_sectors)
	{
		
		if(sectors > g_nr_sectors)
			sectors = g_nr_sectors;
		
		
		pdev->ReadDevSector((unsigned int)pdev,massbuf_ptr,g_start_sector,sectors);
		pBus->StartTransfer(handle,pipe[1].ep, (unsigned char *)massbuf_ptr,
							sectors * g_sector_size);
		g_start_sector += sectors;	
		g_nr_sectors -= sectors;
	
	}else
	{
		mass_state = SENDED_CSW;
		//send csw data
		Handle_CSW(handle);
			
	}
	
	return 1;
}

static unsigned int handle_send(unsigned handle,unsigned char *buf,unsigned int len)
{
	PUDC_BUS pBus = (PUDC_BUS)handle;
	if(mass_state == SEND_DATA)
	{
		return handle_send_data(handle,buf,len);
		
	}
	if(mass_state == SENDING_CSW)
	{
		mass_state = SENDED_CSW;
		Handle_CSW(handle);
		
	}
	
	if(mass_state == SENDED_CSW)
	{
		mass_state = RECEIVE_CBW;
		pBus->StartTransfer(handle,pipe[2].ep,(unsigned char *)&cbw,sizeof(cbw));
	}
	
	return 1;
}

static unsigned int notify(unsigned int handle,unsigned int stat,unsigned char *bufaddr,unsigned int len)
{
//	printf("Bus notify stat :%x \n",stat);
	
	if((stat < 0x200) && (stat >=0x100))
	   return mass_detect(handle,stat);
	if(stat == UDC_RESET)
		return mass_reset(handle);
	if(stat == UDC_SUSPEND)
		return mass_suspend(handle);
	if((stat >= UDC_FULLSPEED) && (stat <= UDC_HIGHSPEED))
		return set_udc_speed(stat);
	if(stat == UDC_SETUP_PKG_FINISH)
		return udc_setup_handle(handle,stat,bufaddr,len);
	if(stat == UDC_PROTAL_RECEIVE_FINISH)
		return handle_receive(handle,bufaddr,len);
	if(stat == UDC_PROTAL_SEND_FINISH)
		return handle_send(handle,bufaddr,len);
	return 0;
}

#ifdef MUTI_THREAD

static void mass_task(void *arg)
{
	PUDC_LUN pdev ; 
//	MASS_ARGS *p ;
	u8 *Massbuf;
	u8 err;
	while (1) {
		OSSemPend(sem_mass, 0, &err);
		pdev = pDev[cbw.bCBWLUN]; 
		if ( mass_trigger == 0)
		{
			Massbuf = (unsigned char *)((unsigned int)massBuf0 | 0xa0000000);
			OSSemPend(sem_buf0, 0, &err);
			pdev->WriteDevSector((unsigned int)pdev,Massbuf,ssector,nsector);
			mass_trigger = 1;
			OSSemPost(sem_buf0);
		}
		else
		{
			Massbuf = (unsigned char *)((unsigned int)massBuf1 | 0xa0000000);
			OSSemPend(sem_buf1, 0, &err);
			pdev->WriteDevSector((unsigned int)pdev,Massbuf,ssector,nsector);
			mass_trigger = 0;
			OSSemPost(sem_buf1);
		}
		OSSemPost(sem_device);
	}
	
}
#endif
static unsigned char FInitThread = 0;
static void init_thread()
{
	if(FInitThread == 0)
	{
		#ifdef MUTI_THREAD
		udc_mass_alloc();
		sem_buf0 = OSSemCreate(1);
		sem_buf1 = OSSemCreate(1);
		sem_mass = OSSemCreate(0);
		sem_device = OSSemCreate(1);
		    
		OSTaskCreate(mass_task, (void *)0,
			     (void *)&MassTaskStack[MASS_TASK_STK_SIZE - 1],
			     MASS_TASK_PRIO);
		#else
    udc_mass_alloc();
    #endif

	}
	FInitThread = 1;	
}
static void deinit_thread()
{
	if(FInitThread)
	{
		#ifdef MUTI_THREAD
		unsigned char err;
		OSTaskDel(MASS_TASK_PRIO);
		OSSemDel(sem_buf0,OS_DEL_ALWAYS,&err);
		sem_buf0 = NULL;
		OSSemDel(sem_buf1,OS_DEL_ALWAYS,&err);
		sem_buf1 = NULL;
		OSSemDel(sem_mass,OS_DEL_ALWAYS,&err);
		sem_mass = NULL;
		OSSemDel(sem_device,OS_DEL_ALWAYS,&err);
		sem_device = NULL;
		udc_mass_free();
		#else
		udc_mass_free();
		#endif
		
	}
	FInitThread = 0;
}
static unsigned char InitMassStorage = 0;

void init_mass_storage()
{

	if(InitMassStorage == 0)
	{
		CreateDevice(notify);

	}
	InitMassStorage = 1;
}