at91usbslave.c

AT91RM9200 BSP with dual ethernet port

	2,      /* None Parity*/
	8};     /* 8 Data bits*/

	
/**----------------------------------------------------------------------------*/
/** \fn    AT91F_CDC_GetLineCoding*/
/** \brief This request allows the host to find out the currently configured line coding*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_CDC_GetLineCoding(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	unsigned short wLength = *((unsigned short *) &(pUSBCTL->pSetup[6]));
	pUSBCTL->Write(pUSBCTL,
		(const char *) &lineCoding,
		MIN(sizeof(lineCoding), wLength),
		(AT91PF_SVC_USBCTL_RWComplete) 0);    /* No callback*/
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_CDC_SetLineCodingComplete*/
/** \brief AT91F_CDC_SetLineCodingComplete once AT91F_CDC_SetLineCoding is achieved*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_CDC_SetLineCodingComplete(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	AT91PS_UDP   pUdp = pUSBCTL->pUdp; /* Pointer to UDP registers*/
	/* Send a STATUS IN*/
	AT91F_UDP_EpEndOfWr(pUdp, 0);
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_CDC_SetLineCoding*/
/** \brief This request allows the host to specify typical asynchronous line-characterformatting properties*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_CDC_SetLineCoding(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	unsigned short wLength = *((unsigned short *) &(pUSBCTL->pSetup[6]));
	pUSBCTL->Read(pUSBCTL,
		(char *) &lineCoding,
		MIN(sizeof(lineCoding), wLength),
		(AT91PF_SVC_USBCTL_RWComplete) AT91F_CDC_SetLineCodingComplete);    /* No callback*/
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_USB_SetAddress*/
/** \brief Answer to a standard SET ADDRESS request*/
/**----------------------------------------------------------------------------*/
void AT91F_CDC_NotificationComplete(
	AT91PS_SVC_USBIN pUSBIN)
{
	usbEp3.Write(&usbEp3, networkConnection, sizeof(networkConnection), (AT91PF_SVC_SVCUSBIN_TxComplete) 0);

}

void AT91F_CDC_SetControlLineStateComplete(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	currentConnection = pUSBCTL->pSetup[2];
	if (currentConnection == 3)
		usbEp3.Write(&usbEp3, serialState, sizeof(serialState), (AT91PF_SVC_SVCUSBIN_TxComplete) 0);
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_CDC_SetControlLineState*/
/** \brief This request allows the host to specify typical asynchronous line-characterformatting properties*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_CDC_SetControlLineState(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	/*AT91PS_UDP   pUdp = pUSBCTL->pUdp; // Pointer to UDP registers*/
	/* Send a STATUS IN*/
	pUSBCTL->Write(pUSBCTL,	(char *) 0,	0, AT91F_CDC_SetControlLineStateComplete);
	/*AT91F_UDP_EpEndOfWr(pUdp, 0);*/
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_USB_DispatchRequest*/
/** \brief This function is a callback invoked when a SETUP packet is received*/
/**----------------------------------------------------------------------------*/
void AT91F_USB_DispatchRequest(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	unsigned short request = *((unsigned short *) pUSBCTL->pSetup);

	/* Handle supported standard device request Cf Table 9-3 in USB specification Rev 1.1*/
	if ((request == STD_GET_DESCRIPTOR) && (pUSBCTL->pSetup[3] == 1))
		AT91F_USB_GetDescriptorDevice(pUSBCTL);
	else if ((request == STD_GET_DESCRIPTOR) && (pUSBCTL->pSetup[3] == 2))
		AT91F_USB_GetDescriptorConfiguration(pUSBCTL);
	else if (request == STD_SET_ADDRESS)             AT91F_USB_SetAddress(pUSBCTL);
	else if (request == STD_SET_CONFIGURATION)       AT91F_USB_SetConfiguration(pUSBCTL);
	else if (request == STD_GET_CONFIGURATION)       AT91F_USB_GetConfiguration(pUSBCTL);
	else if (request == STD_GET_STATUS_ZERO)         AT91F_USB_GetStatusZero(pUSBCTL);
	else if (request == STD_GET_STATUS_INTERFACE)    AT91F_USB_GetStatusInterface(pUSBCTL);
	else if (request == STD_GET_STATUS_ENDPOINT)     AT91F_USB_GetStatusEndpoint(pUSBCTL);
	else if (request == STD_SET_FEATURE_ZERO)        AT91F_USB_SetFeatureZero(pUSBCTL);
	else if (request == STD_SET_FEATURE_INTERFACE)   AT91F_USB_SetFeatureInterface(pUSBCTL);
	else if (request == STD_SET_FEATURE_ENDPOINT)    AT91F_USB_SetFeatureEndpoint(pUSBCTL);
	else if (request == STD_CLEAR_FEATURE_ZERO)      AT91F_USB_ClrFeatureZero(pUSBCTL);
	else if (request == STD_CLEAR_FEATURE_INTERFACE) AT91F_USB_ClrFeatureInterface(pUSBCTL);
	else if (request == STD_CLEAR_FEATURE_ENDPOINT)  AT91F_USB_ClrFeatureEndpoint(pUSBCTL);

	/* handle CDC class requests*/
	else if (request == SET_LINE_CODING) AT91F_CDC_SetLineCoding(pUSBCTL);
	else if (request == GET_LINE_CODING) AT91F_CDC_GetLineCoding(pUSBCTL);
	else if (request == SET_CONTROL_LINE_STATE) AT91F_CDC_SetControlLineState(pUSBCTL);
	/* Unsupported requests*/
	else
		AT91F_UDP_EpStall(pUSBCTL->pUdp, 0);
}

#define BUFFER_SIZE 64
char pBuffer[BUFFER_SIZE];


TRANS_HEADER gTransHeader,gReplyHeader;


char* downloadAddress=(char*)-1;
long downloadFileSize=0;
long receivedSize = 0;
char* malloced_ptr = 0;


//long uploadAddress=-1,uploadSize=0;
//long gMagic=0;

LOCAL char * transmitBuf=0;
void usbSentCallBack(AT91PS_SVC_USBIN pUsbIn)
{
	if(	gReplyHeader.magic==0x87654321)
	{
		if(transmitBuf !=0 )
		{
			gReplyHeader.magic=0;
			usbEp2.Write(&usbEp2,transmitBuf,gReplyHeader.fsize,usbSentCallBack);
		}else
		{
			memset(&gReplyHeader,0,sizeof(gReplyHeader));
		}
	}else 
	{
		if(transmitBuf)
		{
			free(transmitBuf);transmitBuf=0;
			memset(&gReplyHeader,0,sizeof(gReplyHeader));
		}
	}
}


void usbReceiveCallBack(AT91PS_SVC_USBOUT pSvcUdp,int bytesReceived,char epNb)
{
	int count=0;
	if(downloadFileSize==0)
	{
		char *pHeader = (char*) &gTransHeader;
		if( bytesReceived<sizeof(gTransHeader) )
		{
			while (bytesReceived--)
				(void)AT91F_UDP_EpRead(pSvcUdp->pUdp, epNb);
			return;	
		}
	

		while (bytesReceived-- && count<sizeof(gTransHeader))
		{
			*(pHeader)++ = AT91F_UDP_EpRead(pSvcUdp->pUdp, epNb);
			count++;
		}
		bytesReceived++ ;
	 	if(gTransHeader.magic==0x12345678)/* download request */
	 	{
		 	downloadAddress=(char*)  gTransHeader.target_addr;
			downloadFileSize= gTransHeader.fsize-sizeof(gTransHeader);
			receivedSize = 0;
		 	/*downloadAddress=  *(long*)(downPt+4);
			downloadFileSize= *(long*)(downPt+8);*/
			if(downloadAddress==(char*)-1||downloadAddress==0)
			{
				malloced_ptr = (char*) malloc( downloadFileSize);
				if(malloced_ptr==0)
				{
					
				}else
					downloadAddress =  malloced_ptr;
				gTransHeader.target_addr =(long)downloadAddress;
			}				
			while (bytesReceived-- )
			{
				*(downloadAddress)++ = AT91F_UDP_EpRead(pSvcUdp->pUdp, epNb);
				receivedSize++;
			}
			bytesReceived++;
			
   		}else if(gTransHeader.magic==0x87654321) /*upload request */
   		{
// 			uploadAddress = gTransHeader.target_addr;
//			uploadSize = gTransHeader.fsize;
   			//usbEp2.Write(&usbEp2,(char*)uploadAddress,uploadSize,usbSentCallBack);
   			if(gReplyHeader.magic!=0x87654321){
	   			memcpy(&gReplyHeader,&gTransHeader,sizeof(gReplyHeader));
				eventSend(usbTaskID,EV_USB_SLAVE_SEND);
			}

   		}else
   		{
			while (bytesReceived--)
				(void)AT91F_UDP_EpRead(pSvcUdp->pUdp, epNb);
			bytesReceived++;	
			downloadAddress = (char*)-1;
			memset(&gTransHeader,0,sizeof(gTransHeader));
   		}
   		
	}else
	{
		if(gTransHeader.magic==0x12345678)
		{
			if(receivedSize>=downloadFileSize)
			{
				while (bytesReceived-- )
				{
					(void) AT91F_UDP_EpRead(pSvcUdp->pUdp, epNb);
				}
				bytesReceived++;
			}else
			{
				while (bytesReceived-- )
				{
					*(downloadAddress)++ = AT91F_UDP_EpRead(pSvcUdp->pUdp, epNb);
					receivedSize++;
				}
				bytesReceived++;
			}
			if(receivedSize==downloadFileSize)
			{   //AT91F_UDP_DisableIt(pSvcUdp->pUdp, (1 << epNb));
				//semGive(rcvSem);downloadFileSize=0;
				eventSend(usbTaskID,EV_USB_SLAVE_RCV);
			}
	  	}
	}
	//AT91F_UDP_EnableIt(pSvcUdp->pUdp, (1 << pSvcUdp->epNb));
}


/*******************************************************************************
*
* at91UsbInit - initialize S3C2510 USB
*
* RETURNS: OK, or ERROR.
*/
#define TASK_PRIORITY    0
#define TASK_OPTIONS     0
#define TASK_STACK_SIZE  2048


STATUS at91UsbSlaveInit(void)
{
	int i;

    /* Disable interrupt. */
    intDisable(INT_LVL_UDP);
	AT91F_UDP_CfgPMC();                        /* Enable UDP peripheral*/
	AT91C_BASE_PMC->PMC_SCER |= AT91C_PMC_UDP; /* Enable 48 MHz*/
	/* Open DMA service for each endpoint*/
	AT91F_SVC_USBCTL_Open(&usbEp0, AT91C_BASE_UDP);
	usbEp0.DisptachSetup = AT91F_USB_DispatchRequest;
	AT91F_SVC_USBOUT_Open(&usbEp1, AT91C_BASE_UDP, 1, 64, 2);
	AT91F_SVC_USBIN_Open(&usbEp2, AT91C_BASE_UDP, 2, 64, 2);
#if 0
	/* eConfigure AIC controller to handle USB interrupts*/
	AT91F_AIC_ConfigureIt (
		AT91C_BASE_AIC,                        /* AIC base address*/
		AT91C_ID_UDP,                          /* System peripheral ID*/
		AT91C_AIC_PRIOR_HIGHEST,               /* Max priority*/
		AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE, /* Level sensitive*/
		AT91F_ASM_UDP_Handler );

	/* Enable Udp interrupt in AIC*/
	AT91F_AIC_EnableIt(AT91C_BASE_AIC, AT91C_ID_UDP);
#endif	
	/* Enable UDP pullUp (PIOA10 on AT91RM3400DK)*/
	AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, AT91C_PIO_PA10);
	AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, AT91C_PIO_PA10);

	AT91F_PIO_CfgOutput(AT91C_BASE_PIOD, AT91C_PIO_PD5);
	AT91F_PIO_ClearOutput(AT91C_BASE_PIOD, AT91C_PIO_PD5);
	AT91F_PIO_SetOutput(AT91C_BASE_PIOD, AT91C_PIO_PD5);	
	
    AT91F_PIO_CfgOutput(AT91C_BASE_PIOC, (1 << 15) | (1 << 14));
    /* reset endpoints */
 /*   	
	AT91F_UDP_ResetEp(AT91C_BASE_UDP, (AT91C_UDP_EPINT1 | AT91C_UDP_EPINT2));
	AT91F_UDP_ResetEp(AT91C_BASE_UDP, 0);    
*/
    /* Connect interrupt. */
    intConnect(INT_VEC_UDP, (VOIDFUNCPTR)at91_usb_int, 0);

    /* Disable interrupt. */
    intEnable(AT91C_ID_UDP);
    
	AT91F_PIO_ClearOutput(AT91C_BASE_PIOD, AT91C_PIO_PD5);
	for(i=0;i<500000;i++);
	AT91F_PIO_SetOutput(AT91C_BASE_PIOD, AT91C_PIO_PD5);    
 
   //  sendSem = semCCreate (SEM_Q_FIFO, 0);
  //  rcvSem = semCCreate (SEM_Q_FIFO, 0);
    usbTaskID = taskSpawn ("tUsbSlaveTask", TASK_PRIORITY, TASK_OPTIONS,
			 TASK_STACK_SIZE, usbSlaveHelperTask, 0,
			 0, 0, 0, 0, 0, 0, 0, 0, 0);
			 
	memset(&gTransHeader,0,sizeof(gTransHeader));
	memset(&gReplyHeader,0,sizeof(gReplyHeader));		 
    usbEp1.Read(&usbEp1, pBuffer, BUFFER_SIZE, usbReceiveCallBack);

    return OK;
} 

int usbStartRead()
{
//	AT91F_PIO_ClearOutput(AT91C_BASE_PIOD, AT91C_PIO_PD5);
//	AT91F_PIO_SetOutput(AT91C_BASE_PIOD, AT91C_PIO_PD5); 
    usbEp1.Read(&usbEp1, pBuffer, BUFFER_SIZE, usbReceiveCallBack);
    return 0;
}
/*---------------------------------------------------------------------------*/
/* \fn    AT91F_UDP_Handler*/
/* \brief This function is invoked by AT91F_ASM_UDP_Handler*/
/* This function is for demonstration purpose only*/
/*----------------------------------------------------------------------------*/
static void at91_usb_int(void)
{
	unsigned int interrupt = (AT91C_BASE_UDP->UDP_ISR  & AT91C_BASE_UDP->UDP_IMR);
	
	AT91F_PIO_SetOutput(AT91C_BASE_PIOC, (1 << 14));
	while (interrupt ) {
		if (interrupt & AT91C_UDP_ENDBUSRES) {
			AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES;		
			AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES;	
			/* reset all endpoints	*/
			AT91F_UDP_ResetEp(AT91C_BASE_UDP, (AT91C_UDP_EPINT1 | AT91C_UDP_EPINT2));
			AT91F_UDP_ResetEp(AT91C_BASE_UDP, 0);
			/*AT91F_UDP_EnableEp(AT91C_BASE_UDP, (AT91C_UDP_EPINT0));*/
			AT91F_UDP_EpSet(AT91C_BASE_UDP, 0, (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL)); /* Endpoint 1 is a ctl endpoint		*/
			AT91F_UDP_EnableIt(AT91C_BASE_UDP, AT91C_UDP_EPINT0);
		}
		else if (interrupt & AT91C_UDP_EPINT0) {
			usbEp0.Handler(&usbEp0);
			AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_EPINT0;		
		}
		
		else if (interrupt & AT91C_UDP_EPINT1) {
			usbEp1.Handler(&usbEp1);
			AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_EPINT1;
		}
		
		else if (interrupt & AT91C_UDP_EPINT2) {
			usbEp2.Handler(&usbEp2);
			AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_EPINT2;
		}

		else if (interrupt & AT91C_UDP_EPINT3) {
			usbEp3.Handler(&usbEp3);
			AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_EPINT3;
		}
		
		else {
			AT91C_BASE_UDP->UDP_ICR = interrupt;
		}
		interrupt = (AT91C_BASE_UDP->UDP_ISR  & AT91C_BASE_UDP->UDP_IMR);
	}
	AT91F_PIO_ClearOutput(AT91C_BASE_PIOC, (1 << 14));
}


static int usbSlaveHelperTask (long l)
{
  FILE *f;
  char szfile[32];
  UINT32 ev;
  while (1)
  {
    
    //if (semTake (rcvSem, WAIT_FOREVER)==0)
    if(OK==eventReceive(usbSlaveEvent,EVENTS_WAIT_ANY,WAIT_FOREVER,&ev))
    {
    	if(ev&EV_USB_SLAVE_RCV)
    	{
	    	if(malloced_ptr)
	    	{
		    	sprintf(szfile,"/ram0/%s",gTransHeader.filename);
		    	f = fopen(szfile,"w");
				if(f)
				{
			 	   	fwrite((char*)gTransHeader.target_addr ,1, gTransHeader.fsize-sizeof(gTransHeader),f);
					if(malloced_ptr)
					{
						free(malloced_ptr);malloced_ptr=0;
					}	 	   	
					fclose(f);downloadFileSize=0;
				}
			}
		}
		if(ev&EV_USB_SLAVE_SEND)
    	{
    		struct stat sa;
	    	sprintf(szfile,"%s",gReplyHeader.filename);
			if(stat(szfile,&sa)==OK)
			{
	    		f = fopen(szfile,"r");
				if(f)
				{
			 	   	transmitBuf = (char*)malloc(sa.st_size);
			 	   	if(transmitBuf)
			 	   	{
			 	   	fread( transmitBuf ,1, sa.st_size,f);
			 	   	gReplyHeader.fsize=sa.st_size;
			 	   	usbEp2.Write(&usbEp2,(char*)&gReplyHeader,sizeof(gReplyHeader),usbSentCallBack);
			 	   	
	    			//usbEp2.Write(&usbEp2,buf,sa.st_size,usbSentCallBack);
					//free(buf);buf=0;
					}
					//fclose(f);
				}
    		}else
    		{
				gReplyHeader.fsize=0;
		 	   	usbEp2.Write(&usbEp2,(char*)&gReplyHeader,sizeof(gReplyHeader),usbSentCallBack);    			
    		}
    	}
    }
  }  
    
}