sl811.c

s3c44b0+sl811读写u盘程序

	usbstack.usbaddr=0x1;
	usbstack.endpoint=usbstack.epbulkin;
	usbstack.pid=PID_IN;
	usbstack.wPayload=64;
	usbstack.wLen=len;
	usbstack.buffer=pBuffer;
	if(usbstack.wLen)
	{
		if(!usbXfer())
			return FALSE;
	}
	return TRUE;
}

//*****************************************************************************************
// Set Device Address : 
//*****************************************************************************************
unsigned char SetAddress(unsigned char addr)
{
	usbstack.usbaddr=0;
	usbstack.setup.bmRequest=0;
	usbstack.setup.bRequest=SET_ADDRESS;  //05
	usbstack.setup.wValue=addr;
	usbstack.setup.wIndex=0;
	usbstack.setup.wLength=0;
	return ep0Xfer();

}

//*****************************************************************************************
// Set Device Configuration : 
//*****************************************************************************************
unsigned char Set_Configuration(void)
{
	usbstack.setup.bmRequest=0;
	usbstack.setup.bRequest=SET_CONFIG;
	//usbstack.setup.wValue = WordSwap(0x01);  //20071115
	//Uart_Printf("\n SET_CONFIG=%d",SET_CONFIG);
	//Uart_Printf("\n usbstack.setup.wValue=%d",usbstack.setup.wValue);
	usbstack.setup.wIndex=0;
	usbstack.setup.wLength=0;
	usbstack.buffer=NULL;
	return ep0Xfer();

}

int Set_Interface()
{

 //  SetupPKG setup; 
   usbstack.setup.bmRequest  = 0x01;
   usbstack.setup.bRequest   = 0x0b;
 //  usbstack.setup.wValue     = 0;
   usbstack.setup.wIndex     = 0;
   usbstack.setup.wLength    = 0;
   return ep0Xfer();
}

//*****************************************************************************************
// Get Device Descriptor : Device, Configuration, String
//*****************************************************************************************
unsigned char GetDesc(void)
{ 
	
	usbstack.setup.bmRequest=0x80;
	usbstack.setup.bRequest=GET_DESCRIPTOR;  //06
	usbstack.setup.wValue=WordSwap(usbstack.setup.wValue);	
	usbstack.wPayload=uDev.wPayLoad[0];
	
	return ep0Xfer();
}

unsigned char Get_Max_Lun(void)
{ 
	
	usbstack.setup.bmRequest=0xa1;
	usbstack.setup.bRequest=0xfe;
	usbstack.setup.wValue=0;
	usbstack.setup.wIndex = 0;
   usbstack.setup.wLength = 0x0100;	
	return ep0Xfer();
}

////////////////////////////////////////////////////////////////////////////
/*int VendorCmd(BYTE usbaddr,BYTE bReq,BYTE bCmd,WORD wvalue,WORD wIndex,WORD wLen,BYTE *pData)
{ 
    SetupPKG setup; 


    usbstack.setup.bmRequest  = bReq;
    usbstack.setup.bRequest   = bCmd;
    usbstack.setup.wValue     = WordSwap(wvalue);
    usbstack.setup.wIndex     = wIndex;
    usbstack.setup.wLength    = wLen;

//   return ep0Xfer(usbaddr, uDev[usbaddr].wPayLoad[0], &setup, pData);
}

int Set_Interface(BYTE usbaddr,BYTE bnum,BYTE baltset)
{

   return VendorCmd(usbaddr, 1, SET_INTERFACE, baltset, bnum, 0, NULL);
}
*/

//*****************************************************************************************
// USB Device Enumeration Process
// Support 1 confguration and interface #0 and alternate setting #0 only
// Support up to 1 control endpoint + 4 data endpoint only
//*****************************************************************************************
unsigned char EnumUsbDev(BYTE usbaddr)
{  
	unsigned char i;											// always reset USB transfer address 
	unsigned char uAddr = 0;							// for enumeration to Address #0
	unsigned char epLen;
		
	//------------------------------------------------
	// Reset only Slave device attached directly
	//------------------------------------------------
	uDev.wPayLoad[0] = 64;	// default 64-byte payload of Endpoint 0, address #0
	if(usbaddr == 1)		// bus reset for the device attached to SL811HS only
		USBReset();		// that will always have the USB address = 0x01 (for a hub)
    	
    	DelayMs(25);
	
	//------------------------------------------------
	// Get USB Device Descriptors on EP0 & Addr 0
	// with default 64-byte payload
	//------------------------------------------------
		
	usbstack.usbaddr=uAddr;
	usbstack.setup.wValue=DEVICE;   //01
	usbstack.setup.wIndex=0;
	usbstack.setup.wLength=18;
	usbstack.buffer=DBUF;
	
	if (!GetDesc())			// and determine the wPayload size
	{
		error0++;
		 Uart_Printf("\n获取描述符不成功");
		return FALSE;								// get correct wPayload of Endpoint 0
	}
	uDev.wPayLoad[0]=DBUF[7];	// on current non-zero USB address
	
	//------------------------------------------------
	// Set Slave USB Device Address
	//------------------------------------------------
	if (!SetAddress(usbaddr)) 						// set to specific USB address
	{
	    error1++;
		return FALSE;
	}								 
	uAddr = usbaddr;								// transfer using this new address

	//------------------------------------------------
	// Get USB Device Descriptors on EP0 & Addr X
	//------------------------------------------------
	

	usbstack.usbaddr=uAddr;	
	usbstack.setup.wLength=DBUF[0];	
	usbstack.setup.wValue=DEVICE;
	usbstack.setup.wIndex=0;	
	usbstack.buffer=DBUF;	
	if (!GetDesc()) 
	{	
	    error2++;
		return FALSE;								// For this current device:
	}
	uDev.iMfg  = DBUF[14];	
	uDev.iPdt  = DBUF[15];
	
	//------------------------------------------------
	// Get Slave USB Configuration Descriptors
	//------------------------------------------------
	
	usbstack.usbaddr=uAddr;
	usbstack.setup.wValue=CONFIGURATION;
	usbstack.setup.wIndex=0;
	usbstack.setup.wLength=64;
	usbstack.buffer=DBUF;	
	if (!GetDesc()) 
	{	
		error3++;	
		return FALSE;	
    }
	uDev.bClass 	= DBUF[9+5];	// update to class type
	uDev.bNumOfEPs = (DBUF[9+4] <= MAX_EP) ? DBUF[9+4] : MAX_EP;
	switch (uDev.bClass)
	{
		case 8:bFlags.bits.bMassDevice=TRUE;
			   Uart_Printf("\nMass Storage 设备");
			   break;
	    case 3:Uart_Printf("\nHID设备");
	           break;
	    case 2:Uart_Printf("\nCommunication and CDC conrol");
	           break;
	    default:Uart_Printf("\n其他设备 class code : %x",uDev.bClass);
	            
	}
	//------------------------------------------------
	// Set configuration (except for HUB device)
	//------------------------------------------------
	usbstack.usbaddr=uAddr;
	usbstack.setup.wValue=DEVICE;
					// enumerating a FS/LS non-hub device
		if (!Set_Configuration())		// connected directly to SL811HS
		{
				Uart_Printf("\n set configuration 失败");
				return FALSE;
        }

     if(!Set_Interface())  //20071018  没成功
     {
         Uart_Printf("\n设置interface 失败");
         return FALSE;
	 }
	 
/*	 if(!Get_Max_Lun())
	 {
	  	Uart_Printf("\nGet_max_lun失败");
         return FALSE;
	 }
*/	 
	//------------------------------------------------
	// For each slave endpoints, get its attributes
	// Excluding endpoint0, only data endpoints
	//------------------------------------------------
	
	epLen = 0;
	for (i=1; i<=uDev.bNumOfEPs; i++)				// For each data endpoint
	{
		uDev.bEPAddr[i]		= DBUF[9 + 9 + epLen+2];	// Ep address and direction				
		uDev.bAttr[i]		= DBUF[9 + 9 + epLen+3];	// Attribute of Endpoint			
		uDev.wPayLoad[i] 	= LSwapINT16(DBUF[9 + 9 + epLen+4],DBUF[9 + 9 + epLen+5]);	// Payload of Endpoint
		uDev.bInterval[i] 	= DBUF[9 + 9 + epLen+6];	// Polling interval
	    uDev.bData1[i] = 0;			            // init data toggle
		epLen += 7;
		//////////////////////////////
		if(uDev.bAttr[i]==0x2)     //bulk transfer
		{
		    if(uDev.bEPAddr[i]&0x80)
		    	usbstack.epbulkin=uDev.bEPAddr[i];
		    else
		    	usbstack.epbulkout=uDev.bEPAddr[i];
		}
		//////////////////////////////
	}
	
	return TRUE;
}

void SL811_Memtest(void)
{
 int errors=0;
 int i;
 
 BYTE temp;
 
 for(i=0x10;i<0xff;i++)
   SL811Write((BYTE)i,(BYTE)i);
   
 for(i=0x10;i<0xff;i++)
 {
   if( (BYTE)i != (SL811Read((BYTE)i)&0xff) )
      errors++;
   SL811Write((BYTE)i,(BYTE)~i);
   if((BYTE)~i != SL811Read((BYTE)i))
      errors++;
  }
  
  if(0 != errors)
 	 Uart_Printf("total errors : 0x%x \n",errors);
  else
     Uart_Printf("No memory errors    ");
}

///////////////////////////////////////////////////////////////////////////////////////////

void SL811_Init(void)   //原装的 
{	
    unsigned int i,j,k;
	bFlags.bits.SLAVE_ONLINE = FALSE;
	bFlags.bits.SLAVE_FOUND = FALSE;
	bFlags.bits.SLAVE_REMOVED=FALSE;
	
	bFlags.bits.SLAVE_ENUMERATED = FALSE;
	bFlags.bits.SLAVE_IS_ATTACHED = FALSE;
	
	//rPDATF=0x6f; //20071106 
	//for(i=0;i<50000;i++)
   //    for(j=0;j<500;j++);
  //  rPDATF=0xff; //20071106
       
	SL811_Memtest();   //20071019
	///////////////////////////////////////////////////////
	SL811Write(CtrlReg,0x04);  //原装的
	DelayMs(100);
	SL811Write(CtrlReg,0x01);
	
	SL811Write(cDATASet,0xe0);
	SL811Write(cSOFcnt,0xae);
			
	SL811Write(EP0Status,0x50);
	SL811Write(EP0Counter,0);
	SL811Write(EP0Control,0x01);
		
	SL811Write(IntEna,0x20);      		// USB-A, Insert/Remove, USB_Resume.
	SL811Write(IntStatus,INT_CLEAR);	// Clear Interrupt enable status

	USBReset();	   //20070823
	
}


/*
void SL811_Init(void)
{
    SL811Write(cDATASet,0xe0); //设定SOF计数器低8位
    SL811Write(cSOFcnt,0xae);  //设定主机工作模式
    SL811Write(CtrlReg,0x5);   //开SOF
    delay(150);               //延时        
    SL811Write(EP0Counter,0);   
    SL811Write(IntEna,0x20);   // 写中断寄存器 
    SL811Write(IntStatus,INT_CLEAR);   //清楚中断
}
*/
void check_usb(void)
{
	unsigned char  intr;
	
	intr=SL811Read(IntStatus);
	if(intr & 0x40)
		   {
		   		
		   if(bFlags.bits.SLAVE_ONLINE ==TRUE)
		   	{bFlags.bits.SLAVE_REMOVED=TRUE;
		   	bFlags.bits.SLAVE_ONLINE =FALSE;}
		   }
	else	{
		   		
		  if(bFlags.bits.SLAVE_ONLINE == FALSE)
		   	{bFlags.bits.SLAVE_FOUND=TRUE;
		   	bFlags.bits.SLAVE_ONLINE =TRUE;}
		   }	
	SL811Write(IntStatus,INT_CLEAR);
	SL811Write(IntStatus,INSERT_REMOVE);
		
}