usb.c

sl811hs 的驱动

				}
				else
				{
					uartpush("More then 1 byte received!\n\r");
					EP0A_OUT_Arm(EP0_LEN);						//get ready for next SETUP token
				}/////////////////////////////////////////////////////////////////////////////////////////
			}

		}
	}
	//----------------------------------------------------------------------------------------
	// End of ACK received 
	//----------------------------------------------------------------------------------------

	//----------------------------------------------------------------------------------------
	// If a STALL was sent out by device, it will still interrupt, but
	// STALL bit in status register does not reflect this when in slave mode.
	//----------------------------------------------------------------------------------------
	else if( USBRead(EP0AControl)&0x20 )			// check for previous stall sent
	{
		uartpush("__STALL!\n\r");
		EP0A_OUT_Arm(EP0_LEN);						// get ready for next SETUP token				
	}
	return;
}

//*****************************************************************************************
// SOF interrupt service routine (AS A 1MS TIMER)
//*****************************************************************************************

void sof_isr(void)
{
	USBWrite(IntStatus,SOF_DONE);					// clear SOF interrupt		
	//uartpush("sof_isr();\n\r");
	return;
}


//*****************************************************************************************
// EP0's IN Token Arming (using Set A)
//*****************************************************************************************
void EP0A_IN_Arm(B8	buf_adr, B8 len, B8 seq)
{												
    USBWrite(EP0AAddress,buf_adr); 				// ep0 address buffer start adress
	USBWrite(EP0AXferLen,len);					// max length of transfer allowed
	if(seq)
	    USBWrite(EP0AControl,DATA1_IN);			// armed to transmit to host, DATA1
	else
	    USBWrite(EP0AControl,DATA0_IN);			// armed to transmit to host, DATA0
}

//*****************************************************************************************
// EP0's SETUP/OUT Token Arming (using Set A)
//*****************************************************************************************
void EP0A_OUT_Arm(B8 len)
{
    USBWrite(EP0AAddress,EP0A_Slave_Buf); 	// ep0 address buffer start adress
    USBWrite(EP0AXferLen,len);				// max length of transfer allowed
    USBWrite(EP0AControl,DATA0_OUT);		// armed to receive from host
}


//*****************************************************************************************
// EP1 interrupt service routine 
//*****************************************************************************************
void ep1_isr(void)
{
	char data[64];
	B8 i;
	uartpush("ep1_isr();\n\r");			
	USBWrite(IntStatus,EP1_DONE);																		// clear EP1 interrupt	
	if(USBRead(EP1AStatus) & EP_ACK)																	// check for ACK bit set
	{uartpush("ep1's ack aquired\n\r");
											// toggle DATA sequence	
	ep1_toggle = (((USBRead(EP1AControl)&DATAX)==0) ? 1:0);	
		if(PacketShift_T0!=PacketShift_T1%max)																//have data to send to the host			
		{	
			USBBufWrite(EP1A_Slave_Buf,(B8 *)&UsbBuf_T[PacketShift_T1+1][1],UsbBuf_T[PacketShift_T1+1][0]);	//write data into ep1_buffer										
			
			EP1A_IN_Arm(EP1A_Slave_Buf,UsbBuf_T[PacketShift_T1+1][0],ep1_toggle);							//ready to send back to the host
			//-------------------------------------------------------------------------------
			//send debug data back to the pc through uart			
			//-------------------------------------------------------------------------------
			uartpush("UsbBuf_T[PacketShift_T1][0]=");
			ltoa(UsbBuf_T[PacketShift_T1][0],data,10);
			uartpush(data);
			uartpush("\n\r");
			
			uartpush("@@@@packet_to_host:");
			data[1]='\0';
			for(i=0;i<UsbBuf_T[PacketShift_T1][0] ;i++)
			{
				data[0]=UsbBuf_T[PacketShift_T1][i+1];
				uartpush(data);
				uartpush(" ");
			}
			uartpush("\n\r\n\r");
			//-------------------------------------------------------------------------------
			// end send debug data		
			//-------------------------------------------------------------------------------
		//	ep1_toggle = (((USBRead(EP1AControl)&DATAX)==0) ? 1:0);	
	PacketShift_T1=	(PacketShift_T1+1)%max;				//point to next UsbBuf_T block
			
		}
	}
	
	return;
}

//*****************************************************************************************
// EP1's IN Token Arming (using Set A)
//*****************************************************************************************
void EP1A_IN_Arm(B8 buf_adr, B8 len, B8 seq)
{												
    //uartpush("EP1A_IN_Arm();\n\r");
    USBWrite(EP1AAddress,buf_adr); 				// ep1 address buffer start adress
	USBWrite(EP1AXferLen,len);					// max length of transfer allowed
	if(seq)
	    USBWrite(EP1AControl,DATA1_IN);			// armed to transmit to host, DATA1
	else
	    USBWrite(EP1AControl,DATA0_IN);			// armed to transmit to host, DATA0
}

//*****************************************************************************************
// EP2 interrupt service routine 
//*****************************************************************************************
void ep2_isr(void)
{
	B8 i;
	char data[64];
	uartpush("ep2_isr();\n\r");
	USBWrite(IntStatus,EP2_DONE);																			// clear EP2 interrupt	
	
	if(((PacketShift_R0+1)%max)!=PacketShift_R1) 		//buffer was not full
	{	
		if(USBRead(EP2AStatus) & EP_ACK)																	// got a packet from host
		{	
			UsbBuf_R[PacketShift_R0][0] = USBRead(EP2AXferLen) - USBRead(EP2ACounter);						//get the number of data received
			USBBufRead(EP2A_Slave_Buf, (B8*)&UsbBuf_R[PacketShift_R0][1],UsbBuf_R[PacketShift_R0][0]);		//save the data into the buffer	
				ep2_toggle = (((USBRead(EP2AControl)&DATAX)==0) ? 1:0);	
			    EP2A_OUT_Arm(EP2_LEN,ep2_toggle);																			// enable transfer from host
			
			//-------------------------------------------------------------------------------
			//send debug data back to the pc through uart			
			//-------------------------------------------------------------------------------
			uartpush("UsbBuf_R[PacketShift_R0][0]=");
			ltoa(UsbBuf_R[PacketShift_R0][0],data,10);
			uartpush(data);
			uartpush("\n\r");
			
			uartpush("@@@@packet_from_host:");
			data[1]='\0';
			for(i=0;i<UsbBuf_R[PacketShift_R0][0] ;i++)
			{
				data[0]=UsbBuf_R[PacketShift_R0][i+1];
				uartpush(data);
				uartpush(" ");
			}
			uartpush("\n\r\n\r");
			//-------------------------------------------------------------------------------
			// end send debug data		
			//-------------------------------------------------------------------------------
			
			PacketShift_R0=(PacketShift_R0+1)%max;						//point to next UsbBuf_R block
		//	ep2_toggle = (((USBRead(EP2AControl)&DATAX)==0) ? 1:0);		
		}
		
	}	
			
	return;
}

//*****************************************************************************************
// EP2's OUT Token Arming (using Set A)
//*****************************************************************************************
void EP2A_OUT_Arm(B8 len,B8 seq)
{												
    // uartpush("EP2A_OUT_Arm();\n\r");
    USBWrite(EP2AAddress,EP2A_Slave_Buf); 	// ep2 address buffer start adress
    USBWrite(EP2AXferLen,len);// max length of transfer allowed
    if(seq)
  		 USBWrite(EP2AControl,DATA1_OUT);	
    else
    USBWrite(EP2AControl,DATA0_OUT);		// armed to receive from host    
}


//*****************************************************************************************
// SL811S variables initialization
//*****************************************************************************************
void sl811s_init(void)
{
	int i;
	uartpush("sl811s_init();\n\r");
	//----------------------------
	// Application-Specific
	//----------------------------
	
	//flags = 0;					// clear flag
	dev_first=0;
	//timeout=0;
	enum_done=0;
	////////////////////////////////////
	
	
	sof_cnt	= 0;				// sof counter equal zero
	ep1_toggle = 0;				// ep1 toggle state
	ep2_toggle = 0;
	PacketShift_T0=0;			//init the point of the  UsbBuf_T and UsbBuf_R
	PacketShift_R0=0;			//
	PacketShift_T1=0;			//
	PacketShift_R1=0;			//	
	
	EP1_BUF_Full=0;				
	
	
	
	//----------------------------
	// SL811S-Specific
	//----------------------------
	BUS_POWERED = 0;						// define as a not bus powered device
	Slave_USBaddr = 0;						// set to default USB address zero
	Slave_ConfigVal = 0;					// default device config value
	Slave_Protocol = 0;						// HID class default boot protocol
	Slave_IdleRate = 0;						// HID class default idle rate
	Slave_RemoteWU = 0;						// device remote wakeup support
	Slave_inEPstall = 0;					// EP0 ~ EP7's IN
	Slave_outEPstall = 0;					// EP0 ~ EP7's OUT
	for(i=0;i<MAXIFCNUM;i++)				// reset alternate setting
		Slave_IfcAlt[i] = 0;
	
    USBWrite(USBAddress,0x00);  			// usb address
    USBWrite(IntEna,0x63);					// enable SOF, EP0, EP1, USB Reset interrupts
    USBWrite(IntStatus,0xFF);				// clear all interrupts
	EP0A_OUT_Arm(EP0_LEN);					// ready to receive from host
	
	/////////////////////////////////////
	USBWrite(EP1AControl,0x40);				// make the first in is data0
	
	
	
}

//*****************************************************************************************
//BUFFER SCAN  transfer data in buffer_R to buffer_T to make a transfer back to the host  
//*****************************************************************************************
void bufscan(void)
{
	B8 *point_T,*point_R,i;
	char data[64];
	if(((PacketShift_T0+1)%max)!=PacketShift_T1 && PacketShift_R0!=PacketShift_R1)	//buffer_T was not full			//have data to send to the buffer_T			
		  {	
			uartpush("bufscan();\n\r");
			
			
			UsbBuf_T[PacketShift_T0][0]=UsbBuf_R[PacketShift_R1][0];		//the byte num of the packet
			
			uartpush("datanum_from_R_to_T =");
			ltoa(UsbBuf_R[PacketShift_R1][0],data,10);
			uartpush(data);
			uartpush("\n\r");
			
			point_T=&UsbBuf_T[PacketShift_T0][1];		
			point_R=&UsbBuf_R[PacketShift_R1][1];
			
			for(i=0;i<UsbBuf_R[PacketShift_R1][0];i++)							//data transfer
			{
				*point_T=*point_R;
				point_T++;
				point_R++;
			
			}
			
			PacketShift_R1=(PacketShift_R1+1)%max;
			
			
			PacketShift_T0=(PacketShift_T0+1)%max;
		
				
	/*		if(EP1_BUF_Full==0)
			{	
				uartpush("EP1_BUF_Full=0-->1\n\r");
				EP1_BUF_Full=1;
				if(PacketShift_T0!=PacketShift_T1)				//have data to send to the host			
				{	
					
	
					USBBufWrite(EP1A_Slave_Buf,(B8 *)&UsbBuf_T[PacketShift_T1][1],UsbBuf_T[PacketShift_T1][0]);												
					EP1A_IN_Arm(EP1A_Slave_Buf,UsbBuf_T[PacketShift_T1][0],ep1_toggle);
					
					uartpush("UsbBuf_T[PacketShift_T1][0]=");
					ltoa(UsbBuf_T[PacketShift_T1][0],data,10);
					uartpush(data);
					uartpush("\n\r");
					
					uartpush("@@@@packet_to_host:");
					data[1]='\0';
					for(i=0;i<UsbBuf_T[PacketShift_T1][0] ;i++)
					{
						data[0]=UsbBuf_T[PacketShift_T1][i+1];
						uartpush(data);
						uartpush(" ");
					}
					uartpush("\n\r");
					}
					
					PacketShift_T1++;
					if(PacketShift_T1==65)
						PacketShift_T1=1;
												//wait to be read;
			}	*/
				
		}
}

//*****************************************************************************************
// Main loop start here
//*****************************************************************************************
void usb_main(void)
{
	B8	int_status;
	char data[256];
		//--------------------------------------------
		// USB-Specific Tasks
		//--------------------------------------------
		int_status = USBRead(IntStatus);
		
		if(int_status & USB_RESET_DONE)				// wait for USB Reset interrupt
		{
			sl811s_init();
			while(USBRead(IntStatus)&USB_RESET_DONE)
				USBWrite(IntStatus, 0xFF);
			uartpush("\n\rUSB_RESET_DONE!\n\r");
		}			
		else if(int_status & EP0_DONE)				// wait for EP0 interrupt
		{
					
			ep0_isr();
		}	
		else if(int_status & EP1_DONE)				// wait for EP1 interrupt
		{	
			ep1_isr();
		}
		else if(int_status & EP2_DONE)
		{
			ep2_isr();
			bufscan();
			USBBufWrite(EP1A_Slave_Buf,(B8 *)&UsbBuf_T[PacketShift_T1][1],UsbBuf_T[PacketShift_T1][0]);	
		EP1A_IN_Arm(EP1A_Slave_Buf,UsbBuf_T[PacketShift_T1][0],ep1_toggle);	
		}
		else if(int_status & SOF_DONE)				// wait for SOF interrupt
		{	
			sof_isr();
		}
		
		///////////////////////////////////
		int_status=USBRead(EP0AStatus);				//if error occured ,send information to the pc
		if((int_status&0xe6)!=0x0)
		{
		
		ltoa(int_status,data,16);
		uartpush("ERROR was found on ep0!\n\r");
		uartpush("####EP0A_status=0x");
		uartpush(data);
		uartpush("\n\r");	
		}
		///////////////////////////////////
		//bufscan();
		
		if(enum_done == 1)						//will be only execute once after reset
		{  // EP1A_IN_Arm(EP1A_Slave_Buf,UsbBuf_T[PacketShift_T1][0],ep1_toggle);
			EP2A_OUT_Arm(EP2_LEN,ep2_toggle);				//ep2 is ready to received from host
			uartpush("____Ready to received from host at ep2!\n\r");
			enum_done=0;
		}	

}

//*****************************************************************************************
// Swap high and low byte 
//*****************************************************************************************
B16 WordSwap(B16 input)
{
	//uartpush("WordSwap();\n\r");
	return(((input&0x00FF)<<8)|((input&0xFF00)>>8));
}