hal.c

USB驱动程序,和NANDflash的驱动, 包括文件系统,cpu是arm

			}
			else												// normal data endpoint, exit now !!! , non-zero ep
				break;											// main loop control the interval polling
		}
				//-----------------------TIMEOUT--------------------------
		if (result & EP0_TIMEOUT)								// TIMEOUT Detected
		{														
			if(usbstack.endpoint==0)										// happens when hub enumeration
			{
				if(++timeout >= TIMEOUT_RETRY)
				{	
				    timeout--;
					break;										// exit on the timeout detected	
				}
				SL811Write(IntStatus,INT_CLEAR);				// clear interrupt status, need to
				SL811Write(EP0Control,cmd);						// re-arm and request for last cmd again
			}
			else												
			{													// all other data endpoint, data transfer 
				bXXGFlags.bits.TIMEOUT_ERR = TRUE;								// failed, set flag to terminate transfer
				break;											// happens when data transfer on a device
			}													// through the hub
		}

		//-----------------------STALL----------------------------
		if (result & EP0_STALL)  								// STALL detected
			return TRUE;										// for unsupported request.
																		
		//----------------------OVEFLOW---------------------------
		if (result & EP0_OVERFLOW)  							// OVERFLOW detected
			//result=result;
			break;
		//-----------------------ERROR----------------------------
		if (result & EP0_ERROR)  								// ERROR detected
			//result=result;
			break;
	}	// end of While(1)
   
	if (result & EP0_ACK) 	// on ACK transmission
		return TRUE;		// return OK
	return FALSE;
}
unsigned char ep0Xfer(void)
{
	usbstack.endpoint=0;
	usbstack.pid=PID_SETUP;
	usbstack.wLen=8;
	if (!usbXfer()) 
   		return FALSE;
	usbstack.pid  = PID_IN;
	usbstack.wLen=usbstack.setup.wLength;
   	if (usbstack.wLen)
	{
		if (usbstack.setup.bmRequest & 0x80)
		{
			usbstack.pid  = PID_IN;	
			
			if(!usbXfer())
				return FALSE;
			usbstack.pid  = PID_OUT;
		}
		else
   		{							
			usbstack.pid  = PID_OUT;
				
			if(!usbXfer())
				return FALSE;
			usbstack.pid  = PID_IN;
		}
	}
	usbstack.wLen=0;
	if(!usbXfer())
		return FALSE;

	return TRUE;											
					
}


int GetDesc(void)
{ 
	usbstack.setup.bmRequest=0x80;
	usbstack.setup.bRequest=GET_DESCRIPTOR;
	usbstack.setup.wValue=WordSwap(usbstack.setup.wValue);
	return ep0Xfer();
}
int SetAddress(int addr)
{
	usbstack.usbaddr=0;
	usbstack.setup.bmRequest=0;
	usbstack.setup.bRequest=SET_ADDRESS;
	usbstack.setup.wValue=addr;
	usbstack.setup.wIndex=0;
	usbstack.setup.wLength=0;
	return ep0Xfer();

}
int Set_Configuration(void)
{
	usbstack.setup.bmRequest=0;
	usbstack.setup.bRequest=SET_CONFIG;
	usbstack.setup.wIndex=0;
	usbstack.setup.wLength=0;
	usbstack.buffer=NULL;
	return ep0Xfer();

}
int Set_Interface(void)//INTERFACE
{
	usbstack.setup.bmRequest=01;
	usbstack.setup.bRequest=0x0b;
	usbstack.setup.wIndex=0;
	usbstack.setup.wValue=0;
	usbstack.setup.wLength=0;
	usbstack.buffer=NULL;
	return ep0Xfer();

}
int Set_Class(void)//INTERFACE
{
	usbstack.setup.bmRequest=0xa1;
	usbstack.setup.bRequest=0xfe;
	usbstack.setup.wIndex=0;
	usbstack.setup.wValue=0;
	usbstack.setup.wLength=01;
//	usbstack.buffer=NULL;
	return ep0Xfer();

}
int EnumUsbDev(int usbaddr)
{  
	int i,j;	
	BYTE k;										// always reset USB transfer address 
	int uAddr = 0;							// for enumeration to Address #0
	int epLen;
	pDevDesc  pDev;	
	pCfgDesc pCfg;
	pIntfDesc pIfc;
	pEPDesc pEnp;

//	uDev.wPayLoad[0] = 64;	
	usbstack.wPayload=64;
	if(usbaddr == 1)	
		USBReset();	
   	Delay(0);

	
	pDev =(pDevDesc)DBUF;
	usbstack.usbaddr=uAddr;
	usbstack.setup.wValue=DEVICE;
	usbstack.setup.wIndex=0;
	usbstack.setup.wLength=18;
	usbstack.buffer=DBUF;
	if (!GetDesc())return FALSE;
	usbstack.wPayload=pDev->bMaxPacketSize0;
	uDev.wPayLoad[0]=pDev->bMaxPacketSize0;// on current non-zero USB address

	if (!SetAddress(usbaddr)) 						// set to specific USB address
		return FALSE;
	uAddr = usbaddr;								// transfer using this new address

	//------------------------------------------------
	// Get USB Device Descriptors on EP0 & Addr X
	//------------------------------------------------
	pDev =(pDevDesc)DBUF;
	usbstack.usbaddr=uAddr;
	
	usbstack.setup.wLength=pDev->bLength;
	usbstack.setup.wValue=DEVICE;
	usbstack.setup.wIndex=0;
	usbstack.buffer=DBUF;
	
	if (!GetDesc()) 	
		return FALSE;								// For this current device:
	uDev.wVID  = pDev->idVendor;			// save VID
	uDev.wPID  = pDev->idProduct;			// save PID
	uDev.iMfg  = pDev->iManufacturer;		// save Mfg Index
	uDev.iPdt  = pDev->iProduct;			// save Product Index
	
	pCfg = (pCfgDesc)DBUF;	
	
	usbstack.usbaddr=uAddr;
	usbstack.setup.wValue=CONFIGURATION;
	usbstack.setup.wIndex=0;
	usbstack.setup.wLength=64;
	usbstack.buffer=DBUF;	
	if (!GetDesc()) 		
		return FALSE;	
	pIfc = (pIntfDesc)(DBUF + 9);					// point to Interface Descp
	uDev.bClass 	= pIfc->iClass;			// update to class type
	uDev.bNumOfEPs = (pIfc->bEndPoints <= MAX_EP) ? pIfc->bEndPoints : MAX_EP;
	
	if(uDev.bClass==8) //mass storage device
		bXXGFlags.bits.bMassDevice=TRUE;
	//------------------------------------------------
	// Set configuration (except for HUB device)
	//------------------------------------------------
	usbstack.usbaddr=uAddr;
	usbstack.setup.wValue=DEVICE;
	if (!Set_Configuration())		// connected directly to SL811HS
		return FALSE;
	if (!Set_Interface())		// connected directly to SL811HS
		return FALSE;

	epLen = 0;
	
	for (i=1; i<=uDev.bNumOfEPs; i++)				// For each data endpoint
	{
		pEnp = (pEPDesc)(DBUF + 9 + 9 + epLen);	   			// point to Endpoint Descp(non-HID)
		//if(pIfc->iClass == HIDCLASS)	
		//	pEnp = (pEPDesc)(DBUF + 9 + 9 + 9 + epLen);		// update pointer to Endpoint(HID)
		uDev.bEPAddr[i]  	= pEnp->bEPAdd;			// Ep address and direction
		uDev.bAttr[i]		= pEnp->bAttr;			// Attribute of Endpoint
		k=*(DBUF + 9 + 9 + epLen+4);
		j=k;
		j=j<<8;
		k=*(DBUF + 9 + 9 + epLen+5);
		j|=k;
		uDev.wPayLoad[i] 	= j;//	WordSwap(pEnp->wPayLoad);
		uDev.bInterval[i] 	= pEnp->bInterval;		// Polling interval
	    	uDev.bData1[i] = 0;			            // init data toggle
		epLen += 7;
		//////////////////////////////
		if(uDev.bAttr[i]==0x2)
		{
		    if(uDev.bEPAddr[i]&0x80)
		    	usbstack.epbulkin=uDev.bEPAddr[i];
		    else
		    	usbstack.epbulkout=uDev.bEPAddr[i];
		}
		//////////////////////////////
	}
	usbstack.buffer=DBUF;
	if (!Set_Class())		// connected directly to SL811HS
		return FALSE;
	
	return TRUE;
}
int epBulkSend(unsigned char *pBuffer,unsigned int len,unsigned int lba)
{
	int i,j;
	unsigned char is;
	usbstack.usbaddr=0x1;
	usbstack.endpoint=usbstack.epbulkout;
	usbstack.pid=PID_OUT;
	usbstack.wPayload=64;
	usbstack.wLen=len;
	usbstack.buffer=pBuffer;
	j=len;
	while(len>0)
	{
		if (len > usbstack.wPayload)
			usbstack.wLen = usbstack.wPayload;
		else				
			usbstack.wLen = len;
		if(lba!=0)
		{
			if((j-len-0x40)%512==0)
			{
				if(0==((j-len-0x40)/512 + lba)%0x100)
					Delay(100);
			}
		}
//		i=100;
//		while(!usbXfer())
//		{
//			i--;
//			Delay(100);
//			if(i==0)
//				return FALSE;
//		}
		if(!usbXfer())
			return FALSE;
		len-=usbstack.wLen;
		usbstack.buffer=usbstack.buffer+usbstack.wLen;
	}
	return TRUE;
}

int epBulkRcv(unsigned char *pBuffer,unsigned int len)
{
	int i;
	usbstack.usbaddr=0x1;
	usbstack.endpoint=usbstack.epbulkin;
	usbstack.pid=PID_IN;
	usbstack.wPayload=64;
	usbstack.wLen=len;
	usbstack.buffer=pBuffer;
	if(usbstack.wLen)
	{
		i=10;
		while(!usbXfer()){
		i--;
		if(i==0)return FALSE;}
	//	if(!usbXfer())return FALSE;
	}
	return TRUE;
}