usbout.c

S3C2410 USB Mass storage 源码.

/****************************************************************
 NAME: usbout.c
 DESC: USB bulk-OUT operation related functions
 HISTORY:
 Mar.25.2002:purnnamu: ported for S3C2410X.
 Mar.27.2002:purnnamu: DMA is enabled.
 ****************************************************************/
 
#include <string.h>
#include "option.h"
#include "2410addr.h"
#include "2410lib.h"
#include "def.h"

#include "2410usb.h"
#include "usbmain.h"
#include "usb.h"
#include "usblib.h"
#include "usbsetup.h"
#include "usbout.h"
#include "usbin.h"
#include "Globe.h"

#include "F_driver.h"
#include "F_system.h"
#include "f_fat.h"
#include "f_type.h"
//static void PrintEpoPkt(U8 *pt,int cnt);
static void RdPktEp3_CheckSum(U8 *buf,int num);


// ===================================================================
// All following commands will operate in case 
// - out_csr3 is valid.
// ===================================================================

 

#define CLR_EP3_OUT_PKT_READY() rOUT_CSR1_REG= ( out_csr3 &(~ EPO_WR_BITS)\
					&(~EPO_OUT_PKT_READY) ) 
#define SET_EP3_SEND_STALL()	rOUT_CSR1_REG= ( out_csr3 & (~EPO_WR_BITS)\
					| EPO_SEND_STALL) )
#define CLR_EP3_SENT_STALL()	rOUT_CSR1_REG= ( out_csr3 & (~EPO_WR_BITS)\
					&(~EPO_SENT_STALL) )
#define FLUSH_EP3_FIFO() 	rOUT_CSR1_REG= ( out_csr3 & (~EPO_WR_BITS)\
					|EPO_FIFO_FLUSH )

// ***************************
// *** VERY IMPORTANT NOTE ***
// ***************************
// Prepare for the packit size constraint!!!

// EP3 = OUT end point. 
unsigned char DISK_CAPACITY[8]={0};

unsigned char SENSE[0x12]=                                      //模式探测返回数据
{
  0x70,
   0x00,
   0x05,
   0x00,
   
   0x00,
   0x00,
   0x00,
   0x0a,
   
   0x00,
   0x00,
   0x00,
   0x00,
   
   0x20,
   0x00,
   0x00,
   0x00,
   
   0x00,
   0x00,
};

unsigned char REQUEST_1A[0x04]=                                      //模式探测返回数据
{
0x03, 0x00, 0x00, 0x00
};

unsigned char REQUEST_23[0x14/*12*/]=                                      //模式探测返回数据
{
0x00, 0x00, 0x00, 0x10, 0x00, 0x1e, 0x46, 0x00,      
0x02, 0x00, 0x02, 0x00, 0x00, 0x1e, 0x46, 0x00, 0x00, 0x00, 0x02, 0x00

};
///*
unsigned char DISK_INF[36]
=                                      //磁盘信息
{
 0x00,
 0x80,
 0x00,
 0x00,
 0x1F,
 0x00,0x00,0x00,
 0x4D,0x6F,0x64,0x69,0x6F,0x74,0x65,0x6B, 
 0x54,0x68,0x6F,0x6D,0x61,0x73,0xB5,0xC4,0x55,0xC5,0xCC,0x00,0x00,0x00,0x00,0x00,
 0x31,0x2E,0x30,0x31
};

tHANDLE hFile;
U8 ep3Buf[EP3_PKT_SIZE];
//static U8 tempBuf[64+1];
static U8 TempMem[16];//Save address from PC
U8* CBW_Block;
U32 dCBWDataTrLen;
U32 dCSWDataResidue;
U32 LBA_START;
U16 LBA_Length;
U32 DATA_Length;
U8 TR_Flag;        //0:none;1:csw;2:read data
U32 count=0;
unsigned char sectorbuf[512];
U8* buffer;

void read_10(void)
{
	U8 i;
	U8 tempbuf[64];

	if((count%8==0)&&(LBA_Length*8>count))
	{		
		F_ReadSector(hFile,LBA_START,1,sectorbuf);
		buffer = sectorbuf;
		LBA_START++;
	}
	if(DATA_Length>EP1_PKT_SIZE)
	{
		for(i=0;i<EP1_PKT_SIZE;i++)
		{
			tempbuf[i] = buffer[i];
		}
		buffer+=EP3_PKT_SIZE;
		DATA_Length-=EP1_PKT_SIZE;		
		count++;
	
		PrepareEp1Fifo(tempbuf,EP1_PKT_SIZE); 
	}
	else
	{
		
		for(i=0;i<DATA_Length;i++)
		{
			tempbuf[i] = buffer[i];
		}

		PrepareEp1Fifo(tempbuf,DATA_Length); 
		DATA_Length=0;
		TR_Flag=1;
		count=0;
	}

}

void write_10(void)
{
	U8 i;
	U8 tempbuf[64];

	if(DATA_Length>EP1_PKT_SIZE)
	{
		for(i=0;i<EP1_PKT_SIZE;i++)
		{
			buffer[i] = ep3Buf[i];
		}
		buffer+=EP3_PKT_SIZE;
		DATA_Length-=EP1_PKT_SIZE;		
		count++;
	}
	else
	{
		
		for(i=0;i<DATA_Length;i++)
		{
			buffer[i] = ep3Buf[i];
		}
		DATA_Length=0;
		TR_Flag=0;
		count=0;
	}
	if(((count%8==0)&&(count!=0))||(DATA_Length==0))
	{		
		F_WriteSector(hFile,LBA_START,1,sectorbuf);
		buffer = sectorbuf;
		LBA_START++;
		
	}
	if(DATA_Length==0)
		Return_CSW();
}

U8 read_capacity(U8 *Capacity)
{
	u8 i;
	u8 secBuf[512] = {0};
	F_partrecord PartInfo;
	PartInfo.prStartLBA = 0;

	for(i=0;i<8;i++)
	{
		Capacity[i] = 0;
	}

	if(F_ReadSector(hFile, PartInfo.prStartLBA, 1, secBuf))
		return F_ERR_DRIVER_READ_FAILURE;
	
	if(secBuf[0] == 0xE9 || (secBuf[0] == 0xEB && secBuf[2] == 0x90))//It's Boot Sector 
	{
		if(secBuf[510] != BOOTSIG0 || secBuf[511] != BOOTSIG1 )
			return F_ERR_INVALID_BOOT_SECTOR;
	}
	else//It's MBR
	{
		if(secBuf[510] != BOOTSIG0 || secBuf[511] != BOOTSIG1 )
			return F_ERR_INVALID_MBR;
		//PartInfo.prStartLBA = (u32)((((u32)secBuf[0x1C9])<<24) + (((u32)secBuf[0x1C8])<<16)+ (((u32)secBuf[0x1C7])<<8) + (secBuf[0x1C6]));
		PartInfo.prStartLBA = (u32)((((u32)secBuf[0x1C9])*0x1000000) + (((u32)secBuf[0x1C8])*0x10000)+ (((u32)secBuf[0x1C7])*0x100) + (secBuf[0x1C6]));

		if(F_ReadSector(hFile, PartInfo.prStartLBA, 1, secBuf))
			return F_ERR_DRIVER_READ_FAILURE;

		if(secBuf[510] != BOOTSIG0 || secBuf[511] != BOOTSIG1 )
			return F_ERR_INVALID_BOOT_SECTOR;
	}
	
	if(secBuf[0x20]==0x00)
	{	
		secBuf[0x20]=0xFF;
		if(secBuf[0x21]==0x00)
		{
			secBuf[0x21]=0xFF;
			if(secBuf[0x22]==0x00)
			{
				secBuf[0x22]=0xFF;
				secBuf[0x23]-=1;
			}
			else	
			{	secBuf[0x22]-=1;}
		}
		else
		{	secBuf[0x21]-=1;}
	}
	else
	{	secBuf[0x20]-=1;}
		
		

	Capacity[0]=secBuf[0x23];
	Capacity[1]=secBuf[0x22];
	Capacity[2]=secBuf[0x21];
	Capacity[3]=secBuf[0x20];
	
	Capacity[7]=secBuf[0x0B];
	Capacity[6]=secBuf[0x0C];	   //每扇区字节数
	return 0;
}

void Ep3Handler(void)
{
    U8 out_csr3;
    int fifoCnt;
	U8 i;
    rINDEX_REG=3;

    out_csr3=rOUT_CSR1_REG;
    
    //DbgPrintf("<3:%x]",out_csr3);

    if(out_csr3 & EPO_OUT_PKT_READY)
    {   
		fifoCnt=rOUT_FIFO_CNT1_REG; 
		
		RdPktEp3((U8 *)ep3Buf,fifoCnt); 	    
   		CLR_EP3_OUT_PKT_READY();
		CBW_Block = ep3Buf;
		if((CBW_Block[0]!=0x55)||(CBW_Block[1]!=0x53)||(CBW_Block[2]!=0x42)||(CBW_Block[3]!=0x43))
		{	
			write_10();
			return;
		}	
		dCBWDataTrLen = (U32)(CBW_Block[11]<<24)+(U32)(CBW_Block[10]<<16)+(U32)(CBW_Block[9]<<8)+(U32)CBW_Block[8];
		
		switch(CBW_Block[15])
		{
			case Format_Unit:				
				break;
			case Inquiry: 
				TR_Flag=1;
				dCSWDataResidue=dCBWDataTrLen-0x24;
				PrepareEp1Fifo(DISK_INF,0x24);
				break;
			case Read_Capacity: 
				TR_Flag=1;
				dCSWDataResidue=dCBWDataTrLen-0x08;
				read_capacity(DISK_CAPACITY);
				PrepareEp1Fifo(DISK_CAPACITY,0x08);
				break;
			case Read_Format_capacity: 		
				TR_Flag=1;
				dCSWDataResidue=dCBWDataTrLen-0x14;
				PrepareEp1Fifo(REQUEST_23,0x14);
				break;
			case Request_Sense: 
				TR_Flag=1;
				dCSWDataResidue=dCBWDataTrLen-0x12;
				PrepareEp1Fifo(SENSE,0x12);
				break;
			case Mode_Select:
								
				TR_Flag=1;
				//PrepareEp1Fifo(0x00,0x00);
				break;
			case Mode_Sense:
				break;
			case Medium_Removal: 
				
				dCSWDataResidue=0x00;
				Return_CSW(); 
				break;
			case Read_10: 
				LBA_START = (u32)((CBW_Block[17]&0xff)<<24)+(u32)((CBW_Block[18]&0xff) << 16)+(u32)((CBW_Block[19]&0xff)<< 8)+(u32)(CBW_Block[20]&0xff);
				LBA_Length = (u16)((CBW_Block[22]&0xff)<< 8)+(u16)(CBW_Block[23]&0xff);
				DATA_Length = LBA_Length*512;
				TR_Flag=2;
				dCSWDataResidue=0;
				read_10();	
				break;
			case Write_10: 
				LBA_START = (u32)((CBW_Block[17]&0xff)<<24)+(u32)((CBW_Block[18]&0xff) << 16)+(u32)((CBW_Block[19]&0xff)<< 8)+(u32)(CBW_Block[20]&0xff);
				LBA_Length = (u16)((CBW_Block[22]&0xff)<< 8)+(u16)(CBW_Block[23]&0xff);
				DATA_Length = LBA_Length*512;
				buffer = sectorbuf;
				dCSWDataResidue=0;
				//write_10();
				break;
	    	case Test_Unit_Ready: 
				//TR_Flag=1;
				dCSWDataResidue=0x00;
				Return_CSW();
				break; 
	       	case  Verify: 
				dCSWDataResidue=0x00;
				Return_CSW();
				break;
			case Mode_Sence_06: 
				TR_Flag=1;
				dCSWDataResidue=dCBWDataTrLen-0x04;
				PrepareEp1Fifo(REQUEST_1A,0x04);
				break;
			default: 
				break;
		}
		
    }//End of if(out_csr3 & EPO_OUT_PKT_READY)
    
    //I think that EPO_SENT_STALL will not be set to 1.
    if(out_csr3 & EPO_SENT_STALL)
    {   
   		//DbgPrintf("[STALL]");
   		CLR_EP3_SENT_STALL();
   		return;
    }	
}

/*
void PrintEpoPkt(U8 *pt,int cnt)
{
    int i;
    DbgPrintf("[BOUT:%d:",cnt);
    for(i=0;i<cnt;i++)
    	DbgPrintf("%x,",pt[i]);
    DbgPrintf("]");
}
*/

void RdPktEp3_CheckSum(U8 *buf,int num)
{
    int i;
    	
    for(i=0;i<num;i++)
    {
        buf[i]=(U8)rEP3_FIFO;
        checkSum+=buf[i];
		
    }
}



void __irq IsrDma2(void)
{
    U8 out_csr3;
    U32 nextTotalDmaCount;
    U8 saveIndexReg=rINDEX_REG;//Push to buffer

    rINDEX_REG=3;
    out_csr3=rOUT_CSR1_REG;
    
    ClearPending(BIT_DMA2);	    
    
    totalDmaCount+=0x80000;//extern volatile U32 totalDmaCount;

    if(totalDmaCount>=DownloadFileSize)// is last?
    {
    	totalDmaCount=DownloadFileSize;
	
    	ConfigEp3IntMode();	

    	if(out_csr3& EPO_OUT_PKT_READY)
    	{
   	    	CLR_EP3_OUT_PKT_READY();
		}
        rINTMSK|=BIT_DMA2;  
        rINTMSK&=~(BIT_USBD);  
    }
    else
    {
    	if((totalDmaCount+0x80000)<DownloadFileSize)	
    	{
	    	nextTotalDmaCount=totalDmaCount+0x80000;
    
    	    if((nextTotalDmaCount+0x80000)<DownloadFileSize)
    		{
       			//for (2~n)th autoreload.	 
				while((rDSTAT2&0xfffff)==0); //wait until autoreload occurs.
				rDIDST2=((U32)DownloadAddress+nextTotalDmaCount-8);  
				rDIDSTC2=(0<<1)|(0<<0);  
    	    	rDCON2=rDCON2&~(0xfffff)|(0x80000); 
    	    	
    	    	while(rEP3_DMA_TTC<0xfffff)
    	    	{
    	    	    rEP3_DMA_TTC_L=0xff;
    	    	    rEP3_DMA_TTC_M=0xff;
    	    	    rEP3_DMA_TTC_H=0xf;
    	    	    //0xfffff;
    	    	}
    	    }
 	   		else
 	   		{
				while((rDSTAT2&0xfffff)==0); //wait until autoreload occurs.
   	       		rDIDST2=((U32)DownloadAddress+nextTotalDmaCount-8);  
      	        rDIDSTC2=(0<<1)|(0<<0);  
      	        rDCON2=rDCON2&~(0xfffff)|(DownloadFileSize-nextTotalDmaCount); 		
    	    	while(rEP3_DMA_TTC<0xfffff)
    	    	{
    	    	    rEP3_DMA_TTC_L=0xff;
    	    	    rEP3_DMA_TTC_M=0xff;
    	    	    rEP3_DMA_TTC_H=0xf;
    	    	    //0xfffff;
    	    	}
	    	}
		}
		else
		{
	 	   while((rDSTAT2&0xfffff)==0); //wait until autoreload occurs.
  	 	   rDIDST2=((U32)DownloadAddress+DownloadFileSize-8);  //for next autoreload.	    		
  	 	   rDIDSTC2=(0<<1)|(0<<0);
  	 	   rDCON2=rDCON2&~(0xfffff)|(0); 		
		   //There is no 2nd autoreload. This will not be used.  	    
	       //rDMA_TX+=0x0; //USBD register		
		}
    }
    rINDEX_REG=saveIndexReg;
}


void ClearEp3OutPktReady(void)
{
    U8 out_csr3;
    rINDEX_REG=3;//USB EndPoint3
    out_csr3=rOUT_CSR1_REG;
    CLR_EP3_OUT_PKT_READY();//IN_CSR1_REG(0x52000190)=0x0
}