fifo.h

44b0+PDIUSBD12开发的U盘源码

#ifndef __UFI_H__
#define __UFI_H__

#include"..\INC\user.h"
#include"..\D12\D12OP.h"

#include"FAT.h"
#include"..\INC\Uart.h"




#define UFI_INQUIRY					0x12
#define UFI_READ_CAPACITY			0x25
#define UFI_READ_FORMAT_CAPACITY	0x23
#define	UFI_READ					0x28
#define	UFI_WRITE					0x2a	
#define UFI_MODE_SENSE				0x1a
#define TEST_UNIT_READY				0x00
#define PREVENT_ALLOW_MEDIA_REMOVAL	0x1e


#define FAT_SECTOR_SIZE		512
#define SECTORS_PER_CLUSTER	8	//每簇大小为2048字(4096字节),为39VF1601的一个Page
#define CLUSTER_SIZE		FAT_SECTOR_SIZE*SECTORS_PER_CLUSTER

#define	MAX_LUN				0
#define BULKOUT_SIZE		64	

#define BULK_IN_FIFO_SIZE	5120
#define UFI_REMAIN_SIZE		20

/*****************************************************************************/
#define MAX_PACKAGE_SIZE				64
#define ReadPipeBulkOut(DBuffer)		D12RdEp(4,DBuffer,MAX_PACKAGE_SIZE)
#define WritePipeBulkIn(DBuffer,DSize)	D12WrEp(5,DBuffer,DSize);
/*****************************************************************************/


/*****！！！极其注意 ARM int型 数据是字对齐的！！！*****/
typedef struct{
	U8	OperationCode;
	U8	LUN;
	
	U8	LBA;
	U8	LBA1;
	U8	LBA2;
	U8	LBA3;
	
	U8	ReserveA;
	U8  TransferLength;
	U8  TransferLength1;
	U8	ReserveB[3];
}UFI_TYPE;
/*****！！！极其注意 ARM int型 数据是字对齐的！！！*****/

typedef struct{
	U32 dCBWSignature;
	U32 dCBWTag;
	U32 dCBWDataTransferLength;
	U8  bmCBWFlags;
	U8	bCBWLUN;
	U8	bCBWCBLength;
	U8  CBWCB[16];
}CBW_TYPE;

typedef struct{
	U32	dCSWSignature;
	U32 dCSWTag;
	U32 dCSWDataResidue;
	U8	bCSWStatus;
}CSW_TYPE;



CSW_TYPE	CSW;

U16		RemainSize;
U8 		DataBuffer[64];
U8		UFIBuffer[512];//[CLUSTER_SIZE];
U8		BulkInFIFO[BULK_IN_FIFO_SIZE];
U8*		pBulkInData;
U32		UFIRemainSize[UFI_REMAIN_SIZE];//一个UFI命令需传输数据的长度，不包括(CSW)






void UFIHandler(CBW_TYPE*);
void UFI_Inquiry(void);
void UFI_Read(UFI_TYPE*);
void UFI_ReadCapacity(void);
void UFI_ReadFormatCapacity(void);
void UFI_Write(void);
void UFI_ModeSense(void);
void UFI_TestUintReady(void);
void UFI_PreventAllowMediaRemoval(void);

void UFI_Init(void);
void PushInFIFO(U8*,int);
U32 GetUFIRemainSize(void);
/****************************************/
void UFI_Init(){
	pBulkInData=BulkInFIFO;
	RemainSize=0;

}
void PushInFIFO(U8* pData,int Size){
	int index=0;
	static	U32	Counter=0,CurFIFOPos=0,CurUFIRemainSizePos=0;
	
	if(pData==(U8*)(&CSW)){
		if(CurUFIRemainSizePos>=UFI_REMAIN_SIZE){
			CurUFIRemainSizePos=0;
		}
		UFIRemainSize[CurUFIRemainSizePos++]=Counter;
		Counter=0;
	}
	
	while(index++<Size){
		if(CurFIFOPos>=BULK_IN_FIFO_SIZE){
			CurFIFOPos=0;
		}
		BulkInFIFO[CurFIFOPos++]=*(pData++);
	}
	Counter+=Size;
	//RemainSize+=Size;
}
U32 GetUFIRemainSize(){
	static U32 CurGetUFIRemainSizePos=0;
	
	if(CurGetUFIRemainSizePos>=UFI_REMAIN_SIZE){
			CurGetUFIRemainSizePos=0;
	}
	return UFIRemainSize[CurGetUFIRemainSizePos++];
	
}

/*******************************************************************************/
void BulkOut(){
	U8 pData[MAX_PACKAGE_SIZE],size;
	CBW_TYPE* pCBW; 
	
	//if(CSWSendFlag==FALSE){
	//	return;//Uart_SendString("FLASE");
	//}
	size=ReadPipeBulkOut(pData);

	if(size==31){
		pCBW=(CBW_TYPE*)pData;
		if(pCBW->dCBWSignature==0x43425355){
			UFIHandler(pCBW);
		}
	}else{
		if(size!=0)
		Uart_Printf("BulkOut Size",size);
	}
	
	

}
void BulkIn(){
	U8	CurSendSize;
	
	if(RemainSize>0){
		if(RemainSize>BULKOUT_SIZE){
			CurSendSize=BULKOUT_SIZE;
			RemainSize-=BULKOUT_SIZE;
			WritePipeBulkIn(pBulkInData,CurSendSize);
			
			pBulkInData+=BULKOUT_SIZE;
			if(pBulkInData>=BulkInFIFO+BULKOUT_SIZE){
				pBulkInData=pBulkInData-(U32)BulkInFIFO-BULKOUT_SIZE;
			}
		}else{
			CurSendSize=RemainSize;
			RemainSize=0;
			WritePipeBulkIn(pBulkInData,CurSendSize);
			
			pBulkInData+=RemainSize;
			if(pBulkInData>=BulkInFIFO+BULKOUT_SIZE){
				pBulkInData=pBulkInData-(U32)BulkInFIFO-BULKOUT_SIZE;
			}
		}
		Uart_Printf("\nSend size:",CurSendSize);
	}
	
	
}

void UFIHandler(CBW_TYPE* pCBW){
	UFI_TYPE* pUFI;
	pUFI=(UFI_TYPE*)(&(pCBW->CBWCB));
	Uart_Printf("\nCommand:",pUFI->OperationCode);
	
	
	CSW.dCSWSignature=0x53425355;
	CSW.dCSWTag=pCBW->dCBWTag;
	
	switch(pUFI->OperationCode){
		case UFI_INQUIRY:				UFI_Inquiry();				break;
		case UFI_READ:					UFI_Read(pUFI);				break;	
		case UFI_READ_CAPACITY:			UFI_ReadCapacity();			break;
		case UFI_READ_FORMAT_CAPACITY:	UFI_ReadFormatCapacity();	break;
		case UFI_WRITE:					UFI_Write();				break;
		case UFI_MODE_SENSE:			UFI_ModeSense();			break;
		case TEST_UNIT_READY:			UFI_TestUintReady();		break;
		case PREVENT_ALLOW_MEDIA_REMOVAL:UFI_PreventAllowMediaRemoval();break;
		default:
			//CSW.bCSWStatus=0x00;
			break;
				
	}
	
	
	
}
/*************************************************************************/
/*************************************************************************/

void UFI_Inquiry(void){

	U8  InquiryData[36]={
		0x00,//外设类型 软磁盘设备
		0x80,//RMB 可移除介质
		0x02,//版本号
		0x02,//响应数据的格式
		0x1f,//附加数据长度
		0,0,0,//保留
		'B','7','0','7',0,0,0,0,//厂商信息
		'U','D','i','s','k',0,0,0,0,0,0,0,0,0,0,0,
		0,1,0,0//产品版本信息

	};
	
	CSW.dCSWDataResidue=0;
	CSW.bCSWStatus=0;
	
	
	
	PushInFIFO(InquiryData,36);
	PushInFIFO((U8*)(&CSW),13);
}

void UFI_ReadCapacity(){
	//((U32*)UFIBuffer)[0]=2047;	//Last logical block address
	//((U32*)UFIBuffer)[1]=1024;	//Block length in bytes
	U8	pd[8]={0x00,0x00,0x08,0x00,
			   0x00,0x00,0x02,0x00}; 
	
	
	CSW.dCSWDataResidue=0;
	CSW.bCSWStatus=0;
	
	
	PushInFIFO(pd,8);
	PushInFIFO((U8*)(&CSW),13);
}
void UFI_ReadFormatCapacity(){
	
	U8 bf[20]={0x00,0x00,0x00,0x10,
			   0x00,0x01,0xf4,0x00,
			   0x02,0x00,0x02,0x00,
			   0x00,0x01,0xf4,0x00,
			   0x00,0x00,0x02,0x00};
    
    //CSW.dCSWDataResidue=0xe8;
	CSW.bCSWStatus=0;
	
	PushInFIFO(bf,20);
	PushInFIFO((U8*)(&CSW),13);
	
}



void UFI_Write(){
	PushInFIFO((U8*)(&CSW),13);
}

void UFI_ModeSense(){
	
	
	UFIBuffer[0]=0x03;
	UFIBuffer[1]=0x00;
	UFIBuffer[2]=0x00;
	UFIBuffer[3]=0x00;
	
	PushInFIFO(UFIBuffer,4);
	PushInFIFO((U8*)(&CSW),13);
}

void UFI_TestUintReady(){
	CSW.dCSWDataResidue=0;
	CSW.bCSWStatus=0;
	
	
	PushInFIFO((U8*)(&CSW),13);
}

void UFI_PreventAllowMediaRemoval(){
	CSW.dCSWDataResidue=0;
	CSW.bCSWStatus=0;
	
	
	PushInFIFO((U8*)(&CSW),13);
}


void UFI_Read(UFI_TYPE* pUFI){
	U32 LBA;
	U8  Length;
	
	/*Uart_SendNum(*((U8*)pUFI));
	Uart_SendNum(*((U8*)pUFI+1));
	Uart_SendNum(*((U8*)pUFI+2));
	Uart_SendNum(*((U8*)pUFI+3));
	Uart_SendNum(*((U8*)pUFI+4));
	Uart_SendNum(*((U8*)pUFI+5));
	Uart_SendNum(*((U8*)pUFI+6));
	Uart_SendNum(*((U8*)pUFI+7));
	Uart_SendNum(*((U8*)pUFI+8));*/
	
	
	
	CSW.dCSWDataResidue=0;
	CSW.bCSWStatus=0;
	
	
	
	LBA=ConvertToU32(&pUFI->LBA);
	Length=ConvertToU16(&pUFI->TransferLength);
	
		
	 
	 
	    PushInFIFO(VDisk+512*LBA,512*Length);
		PushInFIFO((U8*)(&CSW),13);
	

	
	/*}else{
		
		pBulkInData=UFIBuffer+512;
		RemainSize=512*(*((U8*)pUFI+8));
		CSWSendFlag=FALSE;
	
	}*/
	
	//Uart_Printf("List:",pUFI->List);
	//while(1);
	
}


#endif