host_811.c

usb2.0驱动程序

	sCBW1->dCBWSignature[0]=0x55;
	sCBW1->dCBWSignature[1]=0x53;
	sCBW1->dCBWSignature[2]=0x42;
	sCBW1->dCBWSignature[3]=0x43;
	sCBW1->dCBWTag[0]=(BYTE)(dcbwTag&0x000000ff);
	sCBW1->dCBWTag[1]=(BYTE)((dcbwTag&0x0000ff00)>>8);
	sCBW1->dCBWTag[2]=(BYTE)((dcbwTag&0x00ff0000)>>16);
	sCBW1->dCBWTag[3]=(BYTE)((dcbwTag&0xff000000)>>24);
	sCBW1->dCBWDataTransferLength[0]=(BYTE)(transLength&0x000000ff);
	sCBW1->dCBWDataTransferLength[1]=(BYTE)((transLength&0x0000ff00)>>8);
	sCBW1->dCBWDataTransferLength[2]=(BYTE)((transLength&0x00ff0000)>>16);
	sCBW1->dCBWDataTransferLength[3]=(BYTE)((transLength&0xff000000)>>24);
	sCBW1->bmCBWFlags=flag;
	sCBW1->bCBWLUN=0;
	sCBW1->bCBWCBLength=CBLength;
	sCBW1->CBWCB[0]=CB0;
	sCBW1->CBWCB[1]=CB1;
	sCBW1->CBWCB[2]=CB2;
	sCBW1->CBWCB[3]=CB3;
	sCBW1->CBWCB[4]=CB4;
	sCBW1->CBWCB[5]=CB5;
	sCBW1->CBWCB[6]=CB6;
	sCBW1->CBWCB[7]=CB7;
	sCBW1->CBWCB[8]=CB8;
	sCBW1->CBWCB[9]=CB9;
	sCBW1->CBWCB[10]=CBa;
	sCBW1->CBWCB[11]=CBb;
	sCBW1->CBWCB[12]=CBc;
	sCBW1->CBWCB[13]=CBd;
	sCBW1->CBWCB[14]=CBe;
	sCBW1->CBWCB[15]=CBf;
}

//*************************************************************************
// mass storage SCSI command bulk-only transfer   
//edit by csl
//************************************************************************
int Inquiry(BYTE *buffer)
{
           BYTE tmp;
           sCBW sCBW1;
	    CBW(&sCBW1,random++,0x24,0x80,6,	
		INQUIRY,0,0,0,0x20,0,0,
		0,0,0,0,0,0,0,0,0);
	    while(TRUE)
	    {
		  tmp=BulkOnlyXfer(2,&sCBW1,buffer,1500,50);
	   	  if((tmp==1)||(tmp==2))
			break;
		  MassStoReset(0);
		  ClearFeature(2);
		  ClearFeature(1);
	    }
	    usb_Delay(2);
	    return TRUE;
}

//*************************************************************************
int Read_Capacity(BYTE*buffer)
{
    BYTE tmp;
    sCBW sCBW1;
    CBW(&sCBW1,random++,8,0x80,0x0a,	
		READ_CAPACITY,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0);
	    while(TRUE)
	    {
		  tmp=BulkOnlyXfer(2,&sCBW1,buffer,1500,50);
		  if((tmp==1)||(tmp==2))
			break;
		 return FALSE;
		  MassStoReset(0);
		  ClearFeature(2);
		  ClearFeature(1);
	    }
	    usb_Delay(1);	  
	    return TRUE;
}


//************************************************************************
int Test_Unit_Ready()
{
     BYTE tmp;
    sCBW sCBW1;
    CBW(&sCBW1,random++,0,0,6,TEST_UNIT_READY,0,0,0,0,0,
    	0,0,0,0,0,0,0,0,0,0);
       //while(TRUE)
	//   {
		tmp=BulkOnlyXfer(2,&sCBW1,NULL,1500,50);
		if((tmp==1)||(tmp==2))
                return TRUE;
		else
			return FALSE;
		//		break;
	//	MassStoReset(0);
	//	ClearFeature(2);
	//	ClearFeature(1);
	//  }
       //return TRUE;
}


//***********************************************************************
int Mode_Sense(BYTE PageCode,BYTE SubPageCode,BYTE length,BYTE *buffer)
{
      BYTE tmp;
      sCBW sCBW1;
      CBW(&sCBW1,random++,56,0x80,6,MODE_SENSE,0,PageCode,SubPageCode,length,0,
  	         0,0,0,0,0,0,0,0,0,0);
      while(TRUE)
	   {
		tmp=BulkOnlyXfer(2,&sCBW1,buffer,1500,850);
		if((tmp==1)||(tmp==2))
			break;
		MassStoReset(0);
		ClearFeature(2);
		ClearFeature(1);
	   }     
       return TRUE;
}

//**************************************************************************
int Verify(DWORD StartLogicalAddr,WORD length)
{
   BYTE tmp,b1,b2,b3,b4,len1,len2;
   sCBW sCBW1;

   b1=(BYTE)StartLogicalAddr;
   b2=(BYTE)((StartLogicalAddr&0xff00)>>8);
   b3=(BYTE)((StartLogicalAddr&0xff0000)>>16);
   b4=(BYTE)((StartLogicalAddr&0xff000000)>>24);
   len1=(BYTE)length;
   len2=(BYTE)((length&0xff00)>>8);
   CBW(&sCBW1,random++,0,0x80,0xa,VERIFY,0,b4,b3,b2,b1,0,len2,len1,0,
  	     0,0,0,0,0,0);
  //while(TRUE)
 //	   {
		tmp=BulkOnlyXfer(2,&sCBW1,NULL,1500,20);
		if((tmp==1)||(tmp==2))
//			break;
//		MassStoReset(0);
//		ClearFeature(2);
//		ClearFeature(1);
//	   }      
       return TRUE;
       else
          return FALSE;
   
}


//***************************************************************************
int  Prevent_Allow_Medium_Removal(BYTE prevent)
{
    BYTE tmp;
    sCBW sCBW1;

    CBW(&sCBW1,random++,0,0x80,6,MED_REMOVAL,0,0,0,prevent,0,   //prevent should be 0x00 or 0x01
    	       0,0,0,0,0,0,0,0,0,0);
    while(TRUE)
	   {
		tmp=BulkOnlyXfer(2,&sCBW1,NULL,1500,50);
		if((tmp==1)||(tmp==2))
			break;
		MassStoReset(0);
		ClearFeature(2);
		ClearFeature(1);
	   }     
       return TRUE;
}
     

//***************************************************************************************
//write sectors
//input:   buffer data to write
//edit by csl
//***************************************************************************************
int WriteSectors(DWORD StartSectorNo,WORD NumOfSectors,BYTE *buffer,int out_delay)
{
   BYTE tmp,a1,a2,a3,a4,len2,len1;
   sCBW sCBW1;

   //get start logical sector number to write
   a1=(BYTE)(StartSectorNo&0xff);
   a2=(BYTE)((StartSectorNo&0xff00)>>8);
   a3=(BYTE)((StartSectorNo&0xff0000)>>16);
   a4=(BYTE)((StartSectorNo&0xff000000)>>24);
   //get number of sectors to write
   len1=(BYTE)(NumOfSectors&0x00ff);
   len2=(BYTE)((NumOfSectors&0xff00)>>8);
   //write10 command transfer
   CBW(&sCBW1,random++,NumOfSectors*SECTOR_SIZE,0x00,0x0a,			
		WRITE10,0,a4,a3,a2,a1,0,len2,len1,0,
		0,0,0,0,0,0);
  // while(TRUE)
	//   {
	       //must add  too_long_delay  or abnormal control 	      
		 tmp=BulkOnlyXfer(2,&sCBW1,buffer,0,out_delay);//DBUF3[16*1024] ,max for 32 sectors data
		 if((tmp==1)||(tmp==2))
		//	break;
		// MassStoReset(0);
		// ClearFeature(2);
		 //ClearFeature(1);
	 //  }
	           return TRUE;
		 else
		    return FALSE;     
}
//***************************************************************************************
//read sectors
//save in buffer
//edit by csl
//***************************************************************************************
int ReadSectors(DWORD StartSectorNo,WORD NumOfSectors,BYTE *buffer,int in_delay)
{
   BYTE tmp,a1,a2,a3,a4,lng2,lng1;
   sCBW sCBW1;   
   
   //get start logical sector number to read
   a1=(BYTE)(StartSectorNo & 0xff);
   a2=(BYTE)((StartSectorNo & 0xff00)>>8);
   a3=(BYTE)((StartSectorNo & 0xff0000)>>16);
   a4=(BYTE)((StartSectorNo & 0xff000000)>>24);
   //get number of sectors to read 
   lng1=(BYTE)((NumOfSectors) & (0xff));
   lng2=(BYTE)((NumOfSectors&0xff00)>>8);
   //read10 command transfer
   CBW(&sCBW1,random++,NumOfSectors*SECTOR_SIZE,0x80,0x0a,			
		READ10,0,a4,a3,a2,a1,0,lng2,lng1,0,
		0,0,0,0,0,0);
   //while(TRUE)
	//   {
	        tmp=BulkOnlyXfer(2,&sCBW1,buffer,in_delay,0);
		 if((tmp==1)||(tmp==2))
			//break;
			return TRUE;
		 else 
		 	return FALSE;
		// MassStoReset(0);
		// ClearFeature(2);
		// ClearFeature(1);
	//   }   
}

//************************
//short delay
//************************
void short_delay(BYTE sec)
{ 
    BYTE tmp1,tmp2,unit=10;
   
   for (tmp1=0;tmp1<=sec;tmp1++)
   	{
   	  for(tmp2=0;tmp2<=unit;tmp2++)
   	  	{
   	  	}
   	}
}
//*********************************
//待定义masstorage function
//***********************************
void ReadMasterBootSector(BYTE *pData)
{
}

void Read_BPB_Info(BYTE *pData)
{
}

void ListRootDir(BYTE *pData)
{
}



//***************************************
//initialise fat12 global variable
//***************************************
int FAT12_init()
{
       DWORD total_data_sectors;
        
       //read master boot sector
       if(!ReadMasterBootSector(&sMbsInfo_global))
       {
       	return FALSE;
       }
	StartLogicalSectorNo=sMbsInfo_global.dStartLogicalSectorNo;	
       //read partion boot sector
       if(!Read_BPB_Info(&sBpbFat12_global))
       {
            return FALSE;
       }
       RootStartSectorNo=StartLogicalSectorNo+(sBpbFat12_global.wBpbReservedSectors)
                         +(sBpbFat12_global.bBpbNumberOfFats)*(sBpbFat12_global.wBpbSectorsPerFat);
      DataStartSectorNo=RootStartSectorNo
       	               +((sBpbFat12_global.wBpbRootEntries)*0x0020)/SECTOR_SIZE;              
      total_data_sectors=(sBpbFat12_global.dBpbTotalSectorsBig)-(sBpbFat12_global.wBpbReservedSectors)
      	               -(sBpbFat12_global.bBpbNumberOfFats)*(sBpbFat12_global.wBpbSectorsPerFat)
      	               -((sBpbFat12_global.wBpbRootEntries)*0x0020)/SECTOR_SIZE;
      CountOfClusters_mp3=total_data_sectors/(sBpbFat12_global.bBpbSectorsPerCluster);

      total_dosage_mp3=total_data_sectors*(sBpbFat12_global.wBpbBytesPerSector)/1024;  //capacity in KB

      return TRUE;
}
//*****************************************
//verify mp3 player
//if it support mass storage class,return true
//otherwise return false
//*****************************************
int Mp3_Verify(BYTE uAddr)
{
  if((uDev[uAddr].bClass==MASSCLASS)&&(uDev[uAddr].bSub==SCSI_CMD_SET)&&(uDev[uAddr].bProto==BULK_ONLY))
     return TRUE;
  else
    return FALSE;
}
//***************************************************************************************
//edit by csl
//***************************************************************************************

int usb_Main(void)
{
	BYTE errors=0;
	
       //SL811H hardware reset and variables initialization
      sl811h_init(); 
       //sl811hs chip test
      if(!SL811HMemTest())
      	{
      	     errors=1;  //USB 控制芯片测试失败
      	     return errors;
      	}	
       //speed detect and enumerate slave device,i.e. mp3 player
	if(!slave_detect())
	{
	     errors=2;  //USB设备列举失败
	     return errors;
	}
	MP3Present=SLAVE_ENUMERATED;
       //verify mp3 whether support mass storage bulk_only and scsi_cmd_set
       if(!Mp3_Verify(2))
       {
         errors=3;  //不支持标准mass storage 类及相应协议
         return errors;
       }
       //initialize global varible
      if(! FAT12_init())
      	{
      	  errors=4;  //播放器读写有问题
      	  return errors;
      	}
     ListRootDir(&UnusedDosage_Mp3);
     DIR_MP3_music=DIR_MP3[0];

     return errors;
    
}