Initial import of FreeRTOS code for OpenPICC

git-svn-id: https://svn.openpcd.org:2342/trunk@311 6dc7ffe9-61d6-0310-9af1-9938baff3ed1

5 files changed, 1545 insertions, 0 deletions

diff --git a/openpicc/os/usb/USB-CDC.c b/openpicc/os/usb/USB-CDC.c
new file mode 100644
index 0000000..4496c55
--- /dev/null
+++ b/openpicc/os/usb/USB-CDC.c
@@ -0,0 +1,953 @@
+/*
+	FreeRTOS.org V4.2.1 - Copyright (C) 2003-2007 Richard Barry.
+
+	This file is part of the FreeRTOS.org distribution.
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+
+	FreeRTOS.org is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with FreeRTOS.org; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+	A special exception to the GPL can be applied should you wish to distribute
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+	the source code for any proprietary components.  See the licensing section
+	of http://www.FreeRTOS.org for full details of how and when the exception
+	can be applied.
+
+	***************************************************************************
+	See http://www.FreeRTOS.org for documentation, latest information, license
+	and contact details.  Please ensure to read the configuration and relevant
+	port sections of the online documentation.
+
+	Also see http://www.SafeRTOS.com for an IEC 61508 compliant version along
+	with commercial development and support options.
+	***************************************************************************
+*/
+
+/*
+	USB Communications Device Class driver.
+	Implements task vUSBCDCTask and provides an Abstract Control Model serial 
+	interface.  Control is through endpoint 0, device-to-host notification is 
+	provided by interrupt-in endpoint 3, and raw data is transferred through 
+	bulk endpoints 1 and 2.
+
+	- developed from original FreeRTOS HID example by Scott Miller
+	- modified to support 3.2 GCC by najay
+*/
+
+/* Standard includes. */
+#include <string.h>
+#include <stdio.h>
+
+/* Demo board includes. */
+#include <board.h>
+
+/* Scheduler includes. */
+#include <FreeRTOS.h>
+#include <task.h>
+#include <queue.h>
+
+/* Demo app includes. */
+#include <USB-CDC.h>
+#include <descriptors.h>
+
+#define usbNO_BLOCK ( ( portTickType ) 0 )
+
+/* Reset all endpoints */
+static void prvResetEndPoints (void);
+
+/* Clear pull up resistor to detach device from host */
+static void vDetachUSBInterface (void);
+
+/* Set up interface and initialize variables */
+static void vInitUSBInterface (void);
+
+/* Handle control endpoint events. */
+static void prvProcessEndPoint0Interrupt (xISRStatus * pxMessage);
+
+/* Handle standard device requests. */
+static void prvHandleStandardDeviceRequest (xUSB_REQUEST * pxRequest);
+
+/* Handle standard interface requests. */
+static void prvHandleStandardInterfaceRequest (xUSB_REQUEST * pxRequest);
+
+/* Handle endpoint requests. */
+static void prvHandleStandardEndPointRequest (xUSB_REQUEST * pxRequest);
+
+/* Handle class interface requests. */
+static void prvHandleClassInterfaceRequest (xUSB_REQUEST * pxRequest);
+
+/* Prepare control data transfer.  prvSendNextSegment starts transfer. */
+static void prvSendControlData (unsigned portCHAR * pucData,
+				unsigned portSHORT usRequestedLength,
+				unsigned portLONG ulLengthLeftToSend,
+				portLONG lSendingDescriptor);
+
+/* Send next segment of data for the control transfer */
+static void prvSendNextSegment (void);
+
+/* Send stall - used to respond to unsupported requests */
+static void prvSendStall (void);
+
+/* Send a zero-length (null) packet */
+static void prvSendZLP (void);
+
+/* Handle requests for standard interface descriptors */
+static void prvGetStandardInterfaceDescriptor (xUSB_REQUEST * pxRequest);
+
+/*------------------------------------------------------------*/
+
+/* File scope static variables */
+static unsigned portCHAR ucUSBConfig = (unsigned portCHAR) 0;
+static unsigned portLONG ulReceivedAddress = (unsigned portLONG) 0;
+static eDRIVER_STATE eDriverState = eNOTHING;
+
+/* Incoming and outgoing control data structures */
+static xCONTROL_MESSAGE pxControlTx;
+static xCONTROL_MESSAGE pxControlRx;
+
+/* Queue holding pointers to pending messages */
+xQueueHandle xUSBInterruptQueue;
+
+/* Queues used to hold received characters, and characters waiting to be
+transmitted.  Rx queue must be larger than FIFO size. */
+static xQueueHandle xRxCDC;
+static xQueueHandle xTxCDC;
+
+/* Line coding - 115,200 baud, N-8-1 */
+static const unsigned portCHAR pxLineCoding[] =
+  { 0x00, 0xC2, 0x01, 0x00, 0x00, 0x00, 0x08 };
+
+/* Status variables. */
+static unsigned portCHAR ucControlState;
+static unsigned int uiCurrentBank;
+
+
+/*------------------------------------------------------------*/
+
+
+void
+vUSBCDCTask (void *pvParameters)
+{
+  xISRStatus *pxMessage;
+  unsigned portLONG ulStatus;
+  unsigned portLONG ulRxBytes;
+  unsigned portCHAR ucByte;
+  portBASE_TYPE xByte;
+
+  (void) pvParameters;
+
+  /* Disconnect USB device from hub.  For debugging - causes host to register reset */
+  portENTER_CRITICAL ();
+  vDetachUSBInterface ();
+  portEXIT_CRITICAL ();
+
+  vTaskDelay (portTICK_RATE_MS * 60);
+
+  /* Init USB interface */
+  portENTER_CRITICAL ();
+  vInitUSBInterface ();
+  portEXIT_CRITICAL ();
+
+  /* Main task loop.  Process incoming endpoint 0 interrupts, handle data transfers. */
+
+  for (;;)
+    {
+      /* Look for data coming from the ISR. */
+      if (xQueueReceive (xUSBInterruptQueue, &pxMessage, usbSHORTEST_DELAY))
+	{
+	  if (pxMessage->ulISR & AT91C_UDP_EPINT0)
+	    {
+	      /* All endpoint 0 interrupts are handled here. */
+	      prvProcessEndPoint0Interrupt (pxMessage);
+	    }
+
+	  if (pxMessage->ulISR & AT91C_UDP_ENDBUSRES)
+	    {
+	      /* End of bus reset - reset the endpoints and de-configure. */
+	      prvResetEndPoints ();
+	    }
+	}
+
+      /* See if we're ready to send and receive data. */
+      if (eDriverState == eREADY_TO_SEND && ucControlState)
+	{
+	  if ((!
+	       (AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_2] & AT91C_UDP_TXPKTRDY))
+	      && uxQueueMessagesWaiting (xTxCDC))
+	    {
+	      for (xByte = 0; xByte < 64; xByte++)
+		{
+		  if (!xQueueReceive (xTxCDC, &ucByte, 0))
+		    {
+		      /* No data buffered to transmit. */
+		      break;
+		    }
+
+		  /* Got a byte to transmit. */
+		  AT91C_BASE_UDP->UDP_FDR[usbEND_POINT_2] = ucByte;
+		}
+	      AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_2] |= AT91C_UDP_TXPKTRDY;
+	    }
+
+	  /* Check for incoming data (host-to-device) on endpoint 1. */
+	  while (AT91C_BASE_UDP->
+		 UDP_CSR[usbEND_POINT_1] & (AT91C_UDP_RX_DATA_BK0 |
+					    AT91C_UDP_RX_DATA_BK1))
+	    {
+	      ulRxBytes =
+		(AT91C_BASE_UDP->
+		 UDP_CSR[usbEND_POINT_1] >> 16) & usbRX_COUNT_MASK;
+
+	      /* Only process FIFO if there's room to store it in the queue */
+	      if (ulRxBytes <
+		  (USB_CDC_QUEUE_SIZE - uxQueueMessagesWaiting (xRxCDC)))
+		{
+		  while (ulRxBytes--)
+		    {
+		      ucByte = AT91C_BASE_UDP->UDP_FDR[usbEND_POINT_1];
+		      xQueueSend (xRxCDC, &ucByte, 0);
+		    }
+
+		  /* Release the FIFO */
+		  portENTER_CRITICAL ();
+		  {
+		    ulStatus = AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_1];
+		    usbCSR_CLEAR_BIT (&ulStatus, uiCurrentBank);
+		    AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_1] = ulStatus;
+		  }
+		  portEXIT_CRITICAL ();
+
+		  /* Re-enable endpoint 1's interrupts */
+		  AT91C_BASE_UDP->UDP_IER = AT91C_UDP_EPINT1;
+
+		  /* Update the current bank in use */
+		  if (uiCurrentBank == AT91C_UDP_RX_DATA_BK0)
+		    {
+		      uiCurrentBank = AT91C_UDP_RX_DATA_BK1;
+		    }
+		  else
+		    {
+		      uiCurrentBank = AT91C_UDP_RX_DATA_BK0;
+		    }
+
+		}
+	      else
+		{
+		  break;
+		}
+	    }
+	}
+    }
+}
+
+/*------------------------------------------------------------*/
+
+void
+vUSBSendByte (portCHAR cByte)
+{
+  /* Queue the byte to be sent.  The USB task will send it. */
+  xQueueSend (xTxCDC, &cByte, usbNO_BLOCK);
+}
+
+/*------------------------------------------------------------*/
+
+portLONG
+vUSBRecvByte (portCHAR *cByte, portLONG size, portTickType xTicksToWait)
+{
+    portLONG res;
+    if(size<=0 || !cByte || !xRxCDC)
+        return 0;
+
+    res=0;
+    while(size-- && xQueueReceive(xRxCDC, cByte++, xTicksToWait))
+        res++;
+
+    return res;
+}
+
+/*------------------------------------------------------------*/
+
+static void
+prvSendZLP (void)
+{
+  unsigned portLONG ulStatus;
+
+  /* Wait until the FIFO is free - even though we are not going to use it.
+     THERE IS NO TIMEOUT HERE! */
+  while (AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] & AT91C_UDP_TXPKTRDY)
+    {
+      vTaskDelay (usbSHORTEST_DELAY);
+    }
+
+  portENTER_CRITICAL ();
+  {
+    /* Cancel any further pending data */
+    pxControlTx.ulTotalDataLength = pxControlTx.ulNextCharIndex;
+
+    /* Set the TXPKTRDY bit to cause a transmission with no data. */
+    ulStatus = AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0];
+    usbCSR_SET_BIT (&ulStatus, AT91C_UDP_TXPKTRDY);
+    AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] = ulStatus;
+  }
+  portEXIT_CRITICAL ();
+}
+
+/*------------------------------------------------------------*/
+
+static void
+prvSendStall (void)
+{
+  unsigned portLONG ulStatus;
+
+  portENTER_CRITICAL ();
+  {
+    /* Force a stall by simply setting the FORCESTALL bit in the CSR. */
+    ulStatus = AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0];
+    usbCSR_SET_BIT (&ulStatus, AT91C_UDP_FORCESTALL);
+    AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] = ulStatus;
+  }
+  portEXIT_CRITICAL ();
+}
+
+/*------------------------------------------------------------*/
+
+static void
+prvResetEndPoints (void)
+{
+  unsigned portLONG ulTemp;
+
+  eDriverState = eJUST_RESET;
+  ucControlState = 0;
+
+  /* Reset all the end points. */
+  AT91C_BASE_UDP->UDP_RSTEP = usbEND_POINT_RESET_MASK;
+  AT91C_BASE_UDP->UDP_RSTEP = (unsigned portLONG) 0x00;
+
+  /* Enable data to be sent and received. */
+  AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
+
+  /* Repair the configuration end point. */
+  portENTER_CRITICAL ();
+  {
+    ulTemp = AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0];
+    usbCSR_SET_BIT (&ulTemp,
+		    ((unsigned portLONG) (AT91C_UDP_EPEDS |
+					  AT91C_UDP_EPTYPE_CTRL)));
+    AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] = ulTemp;
+    AT91C_BASE_UDP->UDP_IER = AT91C_UDP_EPINT0;
+  }
+  portEXIT_CRITICAL ();
+  uiCurrentBank = AT91C_UDP_RX_DATA_BK0;
+}
+
+/*------------------------------------------------------------*/
+
+static void
+prvProcessEndPoint0Interrupt (xISRStatus * pxMessage)
+{
+  static xUSB_REQUEST xRequest;
+  unsigned portLONG ulRxBytes;
+
+  /* Get number of bytes received, if any */
+  ulRxBytes = pxMessage->ulCSR0 >> 16;
+  ulRxBytes &= usbRX_COUNT_MASK;
+
+  if (pxMessage->ulCSR0 & AT91C_UDP_TXCOMP)
+    {
+      /* We received a TX complete interrupt.  What we do depends on
+         what we sent to get this interrupt. */
+
+      if (eDriverState == eJUST_GOT_CONFIG)
+	{
+	  /* We sent an acknowledgement of a SET_CONFIG request.  We
+	     are now at the end of the enumeration.
+
+	     TODO: Config 0 sets unconfigured state, should enter Address state.
+	     Request for unsupported config should stall. */
+	  AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_CONFG;
+
+	  /* Set up endpoints */
+	  portENTER_CRITICAL ();
+	  {
+	    unsigned portLONG ulTemp;
+
+	    /* Set endpoint 1 to bulk-out */
+	    ulTemp = AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_1];
+	    usbCSR_SET_BIT (&ulTemp,
+			    AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_OUT);
+	    AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_1] = ulTemp;
+	    AT91C_BASE_UDP->UDP_IER = AT91C_UDP_EPINT1;
+	    /* Set endpoint 2 to bulk-in */
+	    ulTemp = AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_2];
+	    usbCSR_SET_BIT (&ulTemp,
+			    AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_IN);
+	    AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_2] = ulTemp;
+	    AT91C_BASE_UDP->UDP_IER = AT91C_UDP_EPINT2;
+	    /* Set endpoint 3 to interrupt-in, enable it, and enable interrupts */
+	    ulTemp = AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_3];
+	    usbCSR_SET_BIT (&ulTemp,
+			    AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_INT_IN);
+	    AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_3] = ulTemp;
+	    /*AT91F_UDP_EnableIt( AT91C_BASE_UDP, AT91C_UDP_EPINT3 );                                */
+	  }
+	  portEXIT_CRITICAL ();
+
+	  eDriverState = eREADY_TO_SEND;
+	}
+      else if (eDriverState == eJUST_GOT_ADDRESS)
+	{
+	  /* We sent an acknowledgement of a SET_ADDRESS request.  Move
+	     to the addressed state. */
+	  if (ulReceivedAddress != (unsigned portLONG) 0)
+	    {
+	      AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
+	    }
+	  else
+	    {
+	      AT91C_BASE_UDP->UDP_GLBSTATE = 0;
+	    }
+
+	  AT91C_BASE_UDP->UDP_FADDR = (AT91C_UDP_FEN | ulReceivedAddress);
+	  eDriverState = eNOTHING;
+	}
+      else
+	{
+	  /* The TXCOMP was not for any special type of transmission.  See
+	     if there is any more data to send. */
+	  prvSendNextSegment ();
+	}
+    }
+
+  if (pxMessage->ulCSR0 & AT91C_UDP_RX_DATA_BK0)
+    {
+      /* Received a control data packet.  May be a 0-length ACK or a data stage. */
+      unsigned portCHAR ucBytesToGet;
+
+      /* Got data.  Cancel any outgoing data. */
+      pxControlTx.ulNextCharIndex = pxControlTx.ulTotalDataLength;
+
+      /* Determine how many bytes we need to receive. */
+      ucBytesToGet =
+	pxControlRx.ulTotalDataLength - pxControlRx.ulNextCharIndex;
+      if (ucBytesToGet > ulRxBytes)
+	{
+	  ucBytesToGet = ulRxBytes;
+	}
+
+      /* If we're not expecting any data, it's an ack - just quit now. */
+      if (!ucBytesToGet)
+	{
+	  return;
+	}
+
+      /* Get the required data and update the index. */
+      memcpy (pxControlRx.ucBuffer, pxMessage->ucFifoData, ucBytesToGet);
+      pxControlRx.ulNextCharIndex += ucBytesToGet;
+    }
+
+  if (pxMessage->ulCSR0 & AT91C_UDP_RXSETUP)
+    {
+      /* Received a SETUP packet.  May be followed by data packets. */
+
+      if (ulRxBytes >= usbEXPECTED_NUMBER_OF_BYTES)
+	{
+	  /* Create an xUSB_REQUEST variable from the raw bytes array. */
+
+	  xRequest.ucReqType = pxMessage->ucFifoData[usbREQUEST_TYPE_INDEX];
+	  xRequest.ucRequest = pxMessage->ucFifoData[usbREQUEST_INDEX];
+
+	  xRequest.usValue = pxMessage->ucFifoData[usbVALUE_HIGH_BYTE];
+	  xRequest.usValue <<= 8;
+	  xRequest.usValue |= pxMessage->ucFifoData[usbVALUE_LOW_BYTE];
+
+	  xRequest.usIndex = pxMessage->ucFifoData[usbINDEX_HIGH_BYTE];
+	  xRequest.usIndex <<= 8;
+	  xRequest.usIndex |= pxMessage->ucFifoData[usbINDEX_LOW_BYTE];
+
+	  xRequest.usLength = pxMessage->ucFifoData[usbLENGTH_HIGH_BYTE];
+	  xRequest.usLength <<= 8;
+	  xRequest.usLength |= pxMessage->ucFifoData[usbLENGTH_LOW_BYTE];
+
+	  pxControlRx.ulNextCharIndex = 0;
+	  if (!(xRequest.ucReqType & 0x80))	/* Host-to-Device transfer, may need to get data first */
+	    {
+	      if (xRequest.usLength > usbMAX_CONTROL_MESSAGE_SIZE)
+		{
+		  /* Too big!  No space for control data, stall and abort. */
+		  prvSendStall ();
+		  return;
+		}
+
+	      pxControlRx.ulTotalDataLength = xRequest.usLength;
+	    }
+	  else
+	    {
+	      /* We're sending the data, don't wait for any. */
+	      pxControlRx.ulTotalDataLength = 0;
+	    }
+	}
+    }
+
+  /* See if we've got a pending request and all its associated data ready */
+  if ((pxMessage->ulCSR0 & (AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RXSETUP))
+      && (pxControlRx.ulNextCharIndex >= pxControlRx.ulTotalDataLength))
+    {
+      unsigned portCHAR ucRequest;
+
+      /* Manipulate the ucRequestType and the ucRequest parameters to 
+         generate a zero based request selection.  This is just done to 
+         break up the requests into subsections for clarity.  The 
+         alternative would be to have more huge switch statement that would
+         be difficult to optimise. */
+      ucRequest = ((xRequest.ucReqType & 0x60) >> 3);
+      ucRequest |= (xRequest.ucReqType & 0x03);
+
+      switch (ucRequest)
+	{
+	case usbSTANDARD_DEVICE_REQUEST:
+	  /* Standard Device request */
+	  prvHandleStandardDeviceRequest (&xRequest);
+	  break;
+
+	case usbSTANDARD_INTERFACE_REQUEST:
+	  /* Standard Interface request */
+	  prvHandleStandardInterfaceRequest (&xRequest);
+	  break;
+
+	case usbSTANDARD_END_POINT_REQUEST:
+	  /* Standard Endpoint request */
+	  prvHandleStandardEndPointRequest (&xRequest);
+	  break;
+
+	case usbCLASS_INTERFACE_REQUEST:
+	  /* Class Interface request */
+	  prvHandleClassInterfaceRequest (&xRequest);
+	  break;
+
+	default:		/* This is not something we want to respond to. */
+	  prvSendStall ();
+	}
+    }
+}
+
+/*------------------------------------------------------------*/
+
+static void
+prvGetStandardDeviceDescriptor (xUSB_REQUEST * pxRequest)
+{
+  /* The type is in the high byte.  Return whatever has been requested. */
+  switch ((pxRequest->usValue & 0xff00) >> 8)
+    {
+    case usbDESCRIPTOR_TYPE_DEVICE:
+      prvSendControlData ((unsigned portCHAR *) &pxDeviceDescriptor,
+			  pxRequest->usLength, sizeof (pxDeviceDescriptor),
+			  pdTRUE);
+      break;
+
+    case usbDESCRIPTOR_TYPE_CONFIGURATION:
+      prvSendControlData ((unsigned portCHAR *) &(pxConfigDescriptor),
+			  pxRequest->usLength, sizeof (pxConfigDescriptor),
+			  pdTRUE);
+      break;
+
+    case usbDESCRIPTOR_TYPE_STRING:
+
+      /* The index to the string descriptor is the lower byte. */
+      switch (pxRequest->usValue & 0xff)
+	{
+	case usbLANGUAGE_STRING:
+	  prvSendControlData ((unsigned portCHAR *)
+			      &pxLanguageStringDescriptor,
+			      pxRequest->usLength,
+			      sizeof (pxLanguageStringDescriptor), pdTRUE);
+	  break;
+
+	case usbMANUFACTURER_STRING:
+	  prvSendControlData ((unsigned portCHAR *)
+			      &pxManufacturerStringDescriptor,
+			      pxRequest->usLength,
+			      sizeof (pxManufacturerStringDescriptor),
+			      pdTRUE);
+	  break;
+
+	case usbPRODUCT_STRING:
+	  prvSendControlData ((unsigned portCHAR *)
+			      &pxProductStringDescriptor, pxRequest->usLength,
+			      sizeof (pxProductStringDescriptor), pdTRUE);
+	  break;
+
+	default:
+	  prvSendStall ();
+	  break;
+	}
+      break;
+
+    default:
+      prvSendStall ();
+      break;
+    }
+}
+
+/*------------------------------------------------------------*/
+
+static void
+prvHandleStandardDeviceRequest (xUSB_REQUEST * pxRequest)
+{
+  unsigned portSHORT usStatus = 0;
+
+  switch (pxRequest->ucRequest)
+    {
+    case usbGET_STATUS_REQUEST:
+      /* Just send two byte dummy status. */
+      prvSendControlData ((unsigned portCHAR *) &usStatus, sizeof (usStatus),
+			  sizeof (usStatus), pdFALSE);
+      break;
+
+    case usbGET_DESCRIPTOR_REQUEST:
+      /* Send device descriptor */
+      prvGetStandardDeviceDescriptor (pxRequest);
+      break;
+
+    case usbGET_CONFIGURATION_REQUEST:
+      /* Send selected device configuration */
+      prvSendControlData ((unsigned portCHAR *) &ucUSBConfig,
+			  sizeof (ucUSBConfig), sizeof (ucUSBConfig),
+			  pdFALSE);
+      break;
+
+    case usbSET_FEATURE_REQUEST:
+      prvSendZLP ();
+      break;
+
+    case usbSET_ADDRESS_REQUEST:
+      /* Get assigned address and send ack, but don't implement new address until we get a TXCOMP */
+      prvSendZLP ();
+      eDriverState = eJUST_GOT_ADDRESS;
+      ulReceivedAddress = (unsigned portLONG) pxRequest->usValue;
+      break;
+
+    case usbSET_CONFIGURATION_REQUEST:
+      /* Ack SET_CONFIGURATION request, but don't implement until TXCOMP */
+      ucUSBConfig = (unsigned portCHAR) (pxRequest->usValue & 0xff);
+      eDriverState = eJUST_GOT_CONFIG;
+      prvSendZLP ();
+      break;
+
+    default:
+      /* Any unsupported request results in a STALL response. */
+      prvSendStall ();
+      break;
+    }
+}
+
+/*------------------------------------------------------------*/
+
+static void
+prvHandleClassInterfaceRequest (xUSB_REQUEST * pxRequest)
+{
+  switch (pxRequest->ucRequest)
+    {
+    case usbSEND_ENCAPSULATED_COMMAND:
+      prvSendStall ();
+      break;
+
+    case usbGET_ENCAPSULATED_RESPONSE:
+      prvSendStall ();
+      break;
+
+    case usbSET_LINE_CODING:
+      /* Set line coding - baud rate, data bits, parity, stop bits */
+      prvSendZLP ();
+      memcpy ((void *) pxLineCoding, pxControlRx.ucBuffer,
+	      sizeof (pxLineCoding));
+      break;
+
+    case usbGET_LINE_CODING:
+      /* Get line coding */
+      prvSendControlData ((unsigned portCHAR *) &pxLineCoding,
+			  pxRequest->usLength, sizeof (pxLineCoding),
+			  pdFALSE);
+      break;
+
+    case usbSET_CONTROL_LINE_STATE:
+      /* D0: 1=DTR, 0=No DTR,  D1: 1=Activate Carrier, 0=Deactivate carrier (RTS, half-duplex) */
+      prvSendZLP ();
+      ucControlState = pxRequest->usValue;
+      break;
+
+    default:
+      prvSendStall ();
+      break;
+    }
+}
+
+/*------------------------------------------------------------*/
+
+static void
+prvGetStandardInterfaceDescriptor (xUSB_REQUEST * pxRequest)
+{
+  switch ((pxRequest->usValue & (unsigned portSHORT) 0xff00) >> 8)
+    {
+    default:
+      prvSendStall ();
+      break;
+    }
+}
+
+/*-----------------------------------------------------------*/
+
+static void
+prvHandleStandardInterfaceRequest (xUSB_REQUEST * pxRequest)
+{
+  unsigned portSHORT usStatus = 0;
+
+  switch (pxRequest->ucRequest)
+    {
+    case usbGET_STATUS_REQUEST:
+      /* Send dummy 2 bytes. */
+      prvSendControlData ((unsigned portCHAR *) &usStatus, sizeof (usStatus),
+			  sizeof (usStatus), pdFALSE);
+      break;
+
+    case usbGET_DESCRIPTOR_REQUEST:
+      prvGetStandardInterfaceDescriptor (pxRequest);
+      break;
+
+      /* This minimal implementation does not respond to these. */
+    case usbGET_INTERFACE_REQUEST:
+    case usbSET_FEATURE_REQUEST:
+    case usbSET_INTERFACE_REQUEST:
+
+    default:
+      prvSendStall ();
+      break;
+    }
+}
+
+/*-----------------------------------------------------------*/
+
+static void
+prvHandleStandardEndPointRequest (xUSB_REQUEST * pxRequest)
+{
+  switch (pxRequest->ucRequest)
+    {
+      /* This minimal implementation does not expect to respond to these. */
+    case usbGET_STATUS_REQUEST:
+    case usbCLEAR_FEATURE_REQUEST:
+    case usbSET_FEATURE_REQUEST:
+
+    default:
+      prvSendStall ();
+      break;
+    }
+}
+
+/*-----------------------------------------------------------*/
+
+static void
+vDetachUSBInterface (void)
+{
+  /* Setup the PIO for the USB pull up resistor. */
+  AT91C_BASE_PIOA->PIO_PER = AT91C_PIO_PA16;
+  AT91C_BASE_PIOA->PIO_OER = AT91C_PIO_PA16;
+
+
+  /* Disable pull up */
+  AT91C_BASE_PIOA->PIO_SODR = AT91C_PIO_PA16;
+}
+
+/*-----------------------------------------------------------*/
+
+static void
+vInitUSBInterface (void)
+{
+  extern void (vUSB_ISR) (void);
+
+  /* Create the queue used to communicate between the USB ISR and task. */
+  xUSBInterruptQueue =
+    xQueueCreate (usbQUEUE_LENGTH + 1, sizeof (xISRStatus *));
+
+  /* Create the queues used to hold Rx and Tx characters. */
+  xRxCDC =
+    xQueueCreate (USB_CDC_QUEUE_SIZE,
+		  (unsigned portCHAR) sizeof (signed portCHAR));
+  xTxCDC =
+    xQueueCreate (USB_CDC_QUEUE_SIZE + 1,
+		  (unsigned portCHAR) sizeof (signed portCHAR));
+
+  if ((!xUSBInterruptQueue) || (!xRxCDC) || (!xTxCDC))
+    {
+      /* Not enough RAM to create queues!. */
+      return;
+    }
+
+  /* Initialise a few state variables. */
+  pxControlTx.ulNextCharIndex = (unsigned portLONG) 0;
+  pxControlRx.ulNextCharIndex = (unsigned portLONG) 0;
+  ucUSBConfig = (unsigned portCHAR) 0;
+  eDriverState = eNOTHING;
+  ucControlState = 0;
+  uiCurrentBank = AT91C_UDP_RX_DATA_BK0;
+
+
+  /* HARDWARE SETUP */
+
+  /* Set the PLL USB Divider */
+  AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1;
+
+  /* Enables the 48MHz USB clock UDPCK and System Peripheral USB Clock. */
+  AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_UDP;
+  AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_UDP);
+
+  /* Setup the PIO for the USB pull up resistor. */
+  AT91C_BASE_PIOA->PIO_PER = AT91C_PIO_PA16;
+  AT91C_BASE_PIOA->PIO_OER = AT91C_PIO_PA16;
+
+
+  /* Start without the pullup - this will get set at the end of this 
+     function. */
+  AT91C_BASE_PIOA->PIO_SODR = AT91C_PIO_PA16;
+
+
+  /* When using the USB debugger the peripheral registers do not always get
+     set to the correct default values.  To make sure set the relevant registers
+     manually here. */
+  AT91C_BASE_UDP->UDP_IDR = (unsigned portLONG) 0xffffffff;
+  AT91C_BASE_UDP->UDP_ICR = (unsigned portLONG) 0xffffffff;
+  AT91C_BASE_UDP->UDP_CSR[0] = (unsigned portLONG) 0x00;
+  AT91C_BASE_UDP->UDP_CSR[1] = (unsigned portLONG) 0x00;
+  AT91C_BASE_UDP->UDP_CSR[2] = (unsigned portLONG) 0x00;
+  AT91C_BASE_UDP->UDP_CSR[3] = (unsigned portLONG) 0x00;
+  AT91C_BASE_UDP->UDP_GLBSTATE = 0;
+  AT91C_BASE_UDP->UDP_FADDR = 0;
+
+  /* Enable the transceiver. */
+  AT91C_UDP_TRANSCEIVER_ENABLE = 0;
+
+  /* Enable the USB interrupts - other interrupts get enabled as the 
+     enumeration process progresses. */
+  AT91F_AIC_ConfigureIt (AT91C_ID_UDP, usbINTERRUPT_PRIORITY,
+			 AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL,
+			 (void (*)(void)) vUSB_ISR);
+  AT91C_BASE_AIC->AIC_IECR = 0x1 << AT91C_ID_UDP;
+
+
+  /* Wait a short while before making our presence known. */
+  vTaskDelay (usbINIT_DELAY);
+  AT91C_BASE_PIOA->PIO_CODR = AT91C_PIO_PA16;
+}
+
+/*-----------------------------------------------------------*/
+
+static void
+prvSendControlData (unsigned portCHAR * pucData,
+		    unsigned portSHORT usRequestedLength,
+		    unsigned portLONG ulLengthToSend,
+		    portLONG lSendingDescriptor)
+{
+  if (((unsigned portLONG) usRequestedLength < ulLengthToSend))
+    {
+      /* Cap the data length to that requested. */
+      ulLengthToSend = (unsigned portSHORT) usRequestedLength;
+    }
+  else if ((ulLengthToSend < (unsigned portLONG) usRequestedLength)
+	   && lSendingDescriptor)
+    {
+      /* We are sending a descriptor.  If the descriptor is an exact 
+         multiple of the FIFO length then it will have to be terminated
+         with a NULL packet.  Set the state to indicate this if
+         necessary. */
+      if ((ulLengthToSend % usbFIFO_LENGTH) == 0)
+	{
+	  eDriverState = eSENDING_EVEN_DESCRIPTOR;
+	}
+    }
+
+  /* Here we assume that the previous message has been sent.  THERE IS NO
+     BUFFER OVERFLOW PROTECTION HERE.
+
+     Copy the data to send into the buffer as we cannot send it all at once
+     (if it is greater than 8 bytes in length). */
+  memcpy (pxControlTx.ucBuffer, pucData, ulLengthToSend);
+
+  /* Reinitialise the buffer index so we start sending from the start of 
+     the data. */
+  pxControlTx.ulTotalDataLength = ulLengthToSend;
+  pxControlTx.ulNextCharIndex = (unsigned portLONG) 0;
+
+  /* Send the first 8 bytes now.  The rest will get sent in response to 
+     TXCOMP interrupts. */
+  prvSendNextSegment ();
+}
+
+/*-----------------------------------------------------------*/
+
+static void
+prvSendNextSegment (void)
+{
+  volatile unsigned portLONG ulNextLength, ulStatus, ulLengthLeftToSend;
+
+  /* Is there any data to send? */
+  if (pxControlTx.ulTotalDataLength > pxControlTx.ulNextCharIndex)
+    {
+      ulLengthLeftToSend =
+	pxControlTx.ulTotalDataLength - pxControlTx.ulNextCharIndex;
+
+      /* We can only send 8 bytes to the fifo at a time. */
+      if (ulLengthLeftToSend > usbFIFO_LENGTH)
+	{
+	  ulNextLength = usbFIFO_LENGTH;
+	}
+      else
+	{
+	  ulNextLength = ulLengthLeftToSend;
+	}
+
+      /* Wait until we can place data in the fifo.  THERE IS NO TIMEOUT
+         HERE! */
+      while (AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] & AT91C_UDP_TXPKTRDY)
+	{
+	  vTaskDelay (usbSHORTEST_DELAY);
+	}
+
+      /* Write the data to the FIFO. */
+      while (ulNextLength > (unsigned portLONG) 0)
+	{
+	  AT91C_BASE_UDP->UDP_FDR[usbEND_POINT_0] =
+	    pxControlTx.ucBuffer[pxControlTx.ulNextCharIndex];
+
+	  ulNextLength--;
+	  pxControlTx.ulNextCharIndex++;
+	}
+
+      /* Start the transmission. */
+      portENTER_CRITICAL ();
+      {
+	ulStatus = AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0];
+	usbCSR_SET_BIT (&ulStatus, ((unsigned portLONG) 0x10));
+	AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] = ulStatus;
+      }
+      portEXIT_CRITICAL ();
+    }
+  else
+    {
+      /* There is no data to send.  If we were sending a descriptor and the 
+         descriptor was an exact multiple of the max packet size then we need
+         to send a null to terminate the transmission. */
+      if (eDriverState == eSENDING_EVEN_DESCRIPTOR)
+	{
+	  prvSendZLP ();
+	  eDriverState = eNOTHING;
+	}
+    }
+}
diff --git a/openpicc/os/usb/USB-CDC.h b/openpicc/os/usb/USB-CDC.h
new file mode 100644
index 0000000..894ebfb
--- /dev/null
+++ b/openpicc/os/usb/USB-CDC.h
@@ -0,0 +1,87 @@
+/*
+	FreeRTOS.org V4.2.1 - Copyright (C) 2003-2007 Richard Barry.
+
+	This file is part of the FreeRTOS.org distribution.
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+
+	FreeRTOS.org is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with FreeRTOS.org; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+	A special exception to the GPL can be applied should you wish to distribute
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+	the source code for any proprietary components.  See the licensing section
+	of http://www.FreeRTOS.org for full details of how and when the exception
+	can be applied.
+
+	***************************************************************************
+	See http://www.FreeRTOS.org for documentation, latest information, license
+	and contact details.  Please ensure to read the configuration and relevant
+	port sections of the online documentation.
+
+	Also see http://www.SafeRTOS.com for an IEC 61508 compliant version along
+	with commercial development and support options.
+	***************************************************************************
+*/
+
+#ifndef USB_CDC_H
+#define USB_CDC_H
+
+#include "usb.h"
+
+#define USB_CDC_QUEUE_SIZE    1024
+
+/* Structure used to take a snapshot of the USB status from within the ISR. */
+typedef struct X_ISR_STATUS
+{
+  unsigned portLONG ulISR;
+  unsigned portLONG ulCSR0;
+  unsigned portCHAR ucFifoData[8];
+} xISRStatus;
+
+/* Structure used to hold the received requests. */
+typedef struct
+{
+  unsigned portCHAR ucReqType;
+  unsigned portCHAR ucRequest;
+  unsigned portSHORT usValue;
+  unsigned portSHORT usIndex;
+  unsigned portSHORT usLength;
+} xUSB_REQUEST;
+
+typedef enum
+{
+  eNOTHING,
+  eJUST_RESET,
+  eJUST_GOT_CONFIG,
+  eJUST_GOT_ADDRESS,
+  eSENDING_EVEN_DESCRIPTOR,
+  eREADY_TO_SEND
+} eDRIVER_STATE;
+
+/* Structure used to control the data being sent to the host. */
+typedef struct
+{
+  unsigned portCHAR ucBuffer[usbMAX_CONTROL_MESSAGE_SIZE];
+  unsigned portLONG ulNextCharIndex;
+  unsigned portLONG ulTotalDataLength;
+} xCONTROL_MESSAGE;
+
+/*-----------------------------------------------------------*/
+void vUSBCDCTask (void *pvParameters);
+
+/* Send cByte down the USB port.  Characters are simply buffered and not
+sent unless the port is connected. */
+void vUSBSendByte (portCHAR cByte);
+portLONG vUSBRecvByte (portCHAR *cByte,portLONG size, portTickType xTicksToWait);
+
+#endif
diff --git a/openpicc/os/usb/USBIsr.c b/openpicc/os/usb/USBIsr.c
new file mode 100644
index 0000000..cbc5f85
--- /dev/null
+++ b/openpicc/os/usb/USBIsr.c
@@ -0,0 +1,169 @@
+/*
+  FreeRTOS.org V4.2.1 - Copyright (C) 2003-2007 Richard Barry.
+
+  This file is part of the FreeRTOS.org distribution.
+
+  FreeRTOS.org is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  FreeRTOS.org is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with FreeRTOS.org; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  A special exception to the GPL can be applied should you wish to distribute
+  a combined work that includes FreeRTOS.org, without being obliged to provide
+  the source code for any proprietary components.  See the licensing section 
+  of http://www.FreeRTOS.org for full details of how and when the exception
+  can be applied.
+
+  ***************************************************************************
+  See http://www.FreeRTOS.org for documentation, latest information, license 
+  and contact details.  Please ensure to read the configuration and relevant 
+  port sections of the online documentation.
+  ***************************************************************************
+*/
+
+
+/* 
+  BASIC INTERRUPT DRIVEN DRIVER FOR USB. 
+
+  This file contains all the usb components that must be compiled
+  to ARM mode.  The components that can be compiled to either ARM or THUMB
+  mode are contained in USB-CDC.c.
+
+*/
+
+/* Scheduler includes. */
+#include <FreeRTOS.h>
+#include <task.h>
+#include <queue.h>
+
+/* Demo application includes. */
+#include <board.h>
+#include <usb.h>
+#include <USB-CDC.h>
+
+#define usbINT_CLEAR_MASK	(AT91C_UDP_TXCOMP | AT91C_UDP_STALLSENT | AT91C_UDP_RXSETUP | AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RX_DATA_BK1 )
+/*-----------------------------------------------------------*/
+
+/* Messages and queue used to communicate between the ISR and the USB task. */
+static xISRStatus xISRMessages[usbQUEUE_LENGTH + 1];
+extern xQueueHandle xUSBInterruptQueue;
+/*-----------------------------------------------------------*/
+
+/* The ISR can cause a context switch so is declared naked. */
+void vUSB_ISR (void) __attribute__ ((naked));
+
+/*-----------------------------------------------------------*/
+
+
+void
+vUSB_ISR (void)
+{
+  /* This ISR can cause a context switch.  Therefore a call to the 
+     portENTER_SWITCHING_ISR() macro is made.  This must come BEFORE any 
+     stack variable declarations. */
+  portENTER_SWITCHING_ISR ();
+
+  /* Now variables can be declared. */
+  portCHAR cTaskWokenByPost = pdFALSE;
+  static volatile unsigned portLONG ulNextMessage = 0;
+  xISRStatus *pxMessage;
+  unsigned portLONG ulRxBytes;
+  unsigned portCHAR ucFifoIndex;
+
+  /* Use the next message from the array. */
+  pxMessage = &(xISRMessages[(ulNextMessage & usbQUEUE_LENGTH)]);
+  ulNextMessage++;
+
+  /* Save UDP ISR state for task-level processing. */
+  pxMessage->ulISR = AT91C_BASE_UDP->UDP_ISR;
+  pxMessage->ulCSR0 = AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0];
+
+  /* Clear interrupts from ICR. */
+  AT91C_BASE_UDP->UDP_ICR = AT91C_BASE_UDP->UDP_IMR | AT91C_UDP_ENDBUSRES;
+
+
+  /* Process incoming FIFO data.  Must set DIR (if needed) and clear RXSETUP 
+     before exit. */
+
+  /* Read CSR and get incoming byte count. */
+  ulRxBytes = (pxMessage->ulCSR0 >> 16) & usbRX_COUNT_MASK;
+
+  /* Receive control transfers on endpoint 0. */
+  if (pxMessage->ulCSR0 & (AT91C_UDP_RXSETUP | AT91C_UDP_RX_DATA_BK0))
+    {
+      /* Save FIFO data buffer for either a SETUP or DATA stage */
+      for (ucFifoIndex = 0; ucFifoIndex < ulRxBytes; ucFifoIndex++)
+	{
+	  pxMessage->ucFifoData[ucFifoIndex] =
+	    AT91C_BASE_UDP->UDP_FDR[usbEND_POINT_0];
+	}
+
+      /* Set direction for data stage.  Must be done before RXSETUP is 
+         cleared. */
+      if ((AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] & AT91C_UDP_RXSETUP))
+	{
+	  if (ulRxBytes
+	      && (pxMessage->ucFifoData[usbREQUEST_TYPE_INDEX] & 0x80))
+	    {
+	      AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] |= AT91C_UDP_DIR;
+
+	      /* Might not be wise in an ISR! */
+	      while (!
+		     (AT91C_BASE_UDP->
+		      UDP_CSR[usbEND_POINT_0] & AT91C_UDP_DIR));
+	    }
+
+	  /* Clear RXSETUP */
+	  AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] &= ~AT91C_UDP_RXSETUP;
+
+	  /* Might not be wise in an ISR! */
+	  while (AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] & AT91C_UDP_RXSETUP);
+	}
+      else
+	{
+	  /* Clear RX_DATA_BK0 */
+	  AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] &= ~AT91C_UDP_RX_DATA_BK0;
+
+	  /* Might not be wise in an ISR! */
+	  while (AT91C_BASE_UDP->
+		 UDP_CSR[usbEND_POINT_0] & AT91C_UDP_RX_DATA_BK0);
+	}
+    }
+
+  /* If we received data on endpoint 1, disable its interrupts until it is 
+     processed in the main loop */
+  if (AT91C_BASE_UDP->
+      UDP_CSR[usbEND_POINT_1] & (AT91C_UDP_RX_DATA_BK0 |
+				 AT91C_UDP_RX_DATA_BK1))
+    {
+      AT91C_BASE_UDP->UDP_IDR = AT91C_UDP_EPINT1;
+    }
+
+  AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_0] &=
+    ~(AT91C_UDP_TXCOMP | AT91C_UDP_STALLSENT);
+
+  /* Clear interrupts for the other endpoints, retain data flags for endpoint 
+     1. */
+  AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_1] &=
+    ~(AT91C_UDP_TXCOMP | AT91C_UDP_STALLSENT | AT91C_UDP_RXSETUP);
+  AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_2] &= ~usbINT_CLEAR_MASK;
+  AT91C_BASE_UDP->UDP_CSR[usbEND_POINT_3] &= ~usbINT_CLEAR_MASK;
+
+  /* Post ISR data to queue for task-level processing */
+  cTaskWokenByPost =
+    xQueueSendFromISR (xUSBInterruptQueue, &pxMessage, cTaskWokenByPost);
+
+  /* Clear AIC to complete ISR processing */
+  AT91C_BASE_AIC->AIC_EOICR = 0;
+
+  /* Do a task switch if needed */
+portEXIT_SWITCHING_ISR (cTaskWokenByPost)}
diff --git a/openpicc/os/usb/descriptors.h b/openpicc/os/usb/descriptors.h
new file mode 100644
index 0000000..230122f
--- /dev/null
+++ b/openpicc/os/usb/descriptors.h
@@ -0,0 +1,190 @@
+/*
+	FreeRTOS.org V4.2.1 - Copyright (C) 2003-2007 Richard Barry.
+
+	This file is part of the FreeRTOS.org distribution.
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+
+	FreeRTOS.org is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with FreeRTOS.org; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+	A special exception to the GPL can be applied should you wish to distribute
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+	the source code for any proprietary components.  See the licensing section
+	of http://www.FreeRTOS.org for full details of how and when the exception
+	can be applied.
+
+	***************************************************************************
+	See http://www.FreeRTOS.org for documentation, latest information, license
+	and contact details.  Please ensure to read the configuration and relevant
+	port sections of the online documentation.
+
+	Also see http://www.SafeRTOS.com for an IEC 61508 compliant version along
+	with commercial development and support options.
+	***************************************************************************
+*/
+
+/*
+	- DESCRIPTOR DEFINITIONS -
+*/
+
+/* String descriptors used during the enumeration process.
+These take the form:
+
+{
+	Length of descriptor,
+	Descriptor type,
+	Data
+}
+*/
+
+const portCHAR pxLanguageStringDescriptor[] = {
+  4,
+  usbDESCRIPTOR_TYPE_STRING,
+  0x09, 0x04
+};
+
+const portCHAR pxManufacturerStringDescriptor[] = {
+  28,
+  usbDESCRIPTOR_TYPE_STRING,
+
+  'b', 0x00, 'i', 0x00, 't', 0x00, 'm', 0x00,
+  'a', 0x00, 'n', 0x00, 'u', 0x00, 'f', 0x00,
+  'a', 0x00, 'k', 0x00, 't', 0x00, 'u', 0x00,
+  'r', 0x00
+};
+
+const portCHAR pxProductStringDescriptor[] = {
+  44,
+  usbDESCRIPTOR_TYPE_STRING,
+  
+  'O', 0x00, 'p', 0x00, 'e', 0x00, 'n', 0x00,
+  'B', 0x00, 'e', 0x00, 'a', 0x00, 'c', 0x00,
+  'o', 0x00, 'n', 0x00, ' ', 0x00, 'U', 0x00,
+  'S', 0x00, 'B', 0x00, ' ', 0x00, '2', 0x00,
+  '.', 0x00, '4', 0x00, 'G', 0x00, 'H', 0x00,
+  'z', 0x00
+};
+
+/* Device should properly be 0x134A:0x9001, using 0x05F9:0xFFFF for Linux testing */
+const char pxDeviceDescriptor[] = {
+  /* Device descriptor */
+  0x12,				/* bLength                      */
+  0x01,				/* bDescriptorType              */
+  0x10, 0x01,			/* bcdUSBL                      */
+  0x02,				/* bDeviceClass:                */
+  0x00,				/* bDeviceSubclass:             */
+  0x00,				/* bDeviceProtocol:             */
+  0x08,				/* bMaxPacketSize0              */
+  0xC0, 0x16,			/* idVendorL                    */
+  0xAC, 0x08,			/* idProductL                   */
+  0x10, 0x01,			/* bcdDeviceL                   */
+  usbMANUFACTURER_STRING,	/* iManufacturer                */
+  usbPRODUCT_STRING,		/* iProduct                     */
+  0x00,				/* SerialNumber                 */
+  0x01				/* bNumConfigs                  */
+};
+
+const char pxConfigDescriptor[] = {
+
+  /* Configuration 1 descriptor
+     Here we define two interfaces (0 and 1) and a total of 3 endpoints.
+     Interface 0 is a CDC Abstract Control Model interface with one interrupt-in endpoint.
+     Interface 1 is a CDC Data Interface class, with a bulk-in and bulk-out endpoint.
+     Endpoint 0 gets used as the CDC management element.
+   */
+  0x09,				/* CbLength                                                             */
+  0x02,				/* CbDescriptorType                                             */
+  0x43, 0x00,			/* CwTotalLength 2 EP + Control         ?       */
+  0x02,				/* CbNumInterfaces                                              */
+  0x01,				/* CbConfigurationValue                                 */
+  0x00,				/* CiConfiguration                                      */
+  usbBUS_POWERED,		/* CbmAttributes Bus powered + Remote Wakeup */
+  0x32,				/* CMaxPower: 100mA                                             */
+
+  /* Communication Class Interface Descriptor Requirement         */
+  0x09,				/* bLength                                                              */
+  0x04,				/* bDescriptorType                                              */
+  0x00,				/* bInterfaceNumber                                             */
+  0x00,				/* bAlternateSetting                                    */
+  0x01,				/* bNumEndpoints                                                */
+  0x02,				/* bInterfaceClass: Comm Interface Class */
+  0x02,				/* bInterfaceSubclass: Abstract Control Model */
+  0x01,				/* bInterfaceProtocol                                   */
+  usbINTERFACE_STRING,		/* iInterface                                                       */
+
+  /* Header Functional Descriptor                                                         */
+  0x05,				/* bLength                                                              */
+  0x24,				/* bDescriptor type: CS_INTERFACE               */
+  0x00,				/* bDescriptor subtype: Header Func Desc */
+  0x10, 0x01,			/* bcdCDC:1.1                                                   */
+
+  /* ACM Functional Descriptor                                                            */
+  0x04,				/* bFunctionLength                                              */
+  0x24,				/* bDescriptor type: CS_INTERFACE               */
+  0x02,				/* bDescriptor subtype: ACM Func Desc   */
+  0x00,				/* bmCapabilities: We don't support squat */
+
+  /* Union Functional Descriptor                                                          */
+  0x05,				/* bFunctionLength                                              */
+  0x24,				/* bDescriptor type: CS_INTERFACE               */
+  0x06,				/* bDescriptor subtype: Union Func Desc */
+  0x00,				/* bMasterInterface: CDC Interface              */
+  0x01,				/* bSlaveInterface0: Data Class Interface */
+
+  /* Call Management Functional Descriptor
+     0 in D1 and D0 indicates that device does not handle call management */
+  0x05,				/* bFunctionLength                                              */
+  0x24,				/* bDescriptor type: CS_INTERFACE               */
+  0x01,				/* bDescriptor subtype: Call Management Func */
+  0x00,				/* bmCapabilities: D1 + D0                              */
+  0x01,				/* bDataInterface: Data Class Interface 1 */
+
+  /* CDC Control - Endpoint 3 descriptor
+     This endpoint serves as a notification element.                              */
+
+  0x07,				/* bLength                                                              */
+  0x05,				/* bDescriptorType                                              */
+  0x83,				/* bEndpointAddress, Endpoint 03 - IN   */
+  0x03,				/* bmAttributes   INT                                   */
+  0x08, 0x00,			/* wMaxPacketSize: 8 bytes                              */
+  0xFF,				/* bInterval                                                    */
+
+  /* Data Class Interface Descriptor Requirement                          */
+  0x09,				/* bLength                                                              */
+  0x04,				/* bDescriptorType                                              */
+  0x01,				/* bInterfaceNumber                                             */
+  0x00,				/* bAlternateSetting                                    */
+  0x02,				/* bNumEndPoints                                                */
+  0x0A,				/* bInterfaceClass                                              */
+  0x00,				/* bInterfaceSubclass                                   */
+  0x00,				/* bInterfaceProtocol                                   */
+  0x00,				/* iInterface                                                   */
+
+  /* CDC Data - Endpoint 1 descriptor */
+  0x07,				/* bLenght                                                              */
+  0x05,				/* bDescriptorType                                              */
+  0x01,				/* bEndPointAddress, Endpoint 01 - OUT  */
+  0x02,				/* bmAttributes BULK                                    */
+  64,				/* wMaxPacketSize                                               */
+  0x00,
+  0x00,				/* bInterval                                                    */
+
+  /* CDC Data - Endpoint 2 descriptor */
+  0x07,				/* bLength                                                              */
+  0x05,				/* bDescriptorType                                              */
+  0x82,				/* bEndPointAddress, Endpoint 02 - IN   */
+  0x02,				/* bmAttributes BULK                                    */
+  64,				/* wMaxPacketSize                                               */
+  0x00,
+  0x00				/* bInterval                                                    */
+};
diff --git a/openpicc/os/usb/usb.h b/openpicc/os/usb/usb.h
new file mode 100644
index 0000000..86d98f9
--- /dev/null
+++ b/openpicc/os/usb/usb.h
@@ -0,0 +1,146 @@
+/*
+	FreeRTOS.org V4.2.1 - Copyright (C) 2003-2007 Richard Barry.
+
+	This file is part of the FreeRTOS.org distribution.
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+
+	FreeRTOS.org is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with FreeRTOS.org; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+	A special exception to the GPL can be applied should you wish to distribute
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+	the source code for any proprietary components.  See the licensing section
+	of http://www.FreeRTOS.org for full details of how and when the exception
+	can be applied.
+
+	***************************************************************************
+	See http://www.FreeRTOS.org for documentation, latest information, license
+	and contact details.  Please ensure to read the configuration and relevant
+	port sections of the online documentation.
+
+	Also see http://www.SafeRTOS.com for an IEC 61508 compliant version along
+	with commercial development and support options.
+	***************************************************************************
+*/
+
+/* Descriptor type definitions. */
+#define usbDESCRIPTOR_TYPE_DEVICE			( 0x01 )
+#define usbDESCRIPTOR_TYPE_CONFIGURATION		( 0x02 )
+#define usbDESCRIPTOR_TYPE_STRING			( 0x03 )
+
+/* USB request type definitions. */
+#define usbGET_REPORT_REQUEST				( 0x01 )
+#define usbGET_IDLE_REQUEST				( 0x02 )
+#define usbGET_PROTOCOL_REQUEST				( 0x03 )
+#define usbSET_REPORT_REQUEST				( 0x09 )
+#define usbSET_IDLE_REQUEST				( 0x0A )
+#define usbSET_PROTOCOL_REQUEST				( 0x0B )
+#define usbGET_CONFIGURATION_REQUEST			( 0x08 )
+#define usbGET_STATUS_REQUEST				( 0x00 )
+#define usbCLEAR_FEATURE_REQUEST			( 0x01 )
+#define usbSET_FEATURE_REQUEST				( 0x03 )
+#define usbSET_ADDRESS_REQUEST				( 0x05 )
+#define usbGET_DESCRIPTOR_REQUEST			( 0x06 )
+#define usbSET_CONFIGURATION_REQUEST			( 0x09 )
+#define usbGET_INTERFACE_REQUEST			( 0x0A )
+#define usbSET_INTERFACE_REQUEST			( 0x0B )
+
+/* ACM Requests */
+#define usbSEND_ENCAPSULATED_COMMAND			( 0x00 )
+#define usbGET_ENCAPSULATED_RESPONSE			( 0x01 )
+#define usbSET_LINE_CODING				( 0x20 )
+#define usbGET_LINE_CODING				( 0x21 )
+#define usbSET_CONTROL_LINE_STATE			( 0x22 )
+
+/* Misc USB definitions. */
+#define usbDEVICE_CLASS_VENDOR_SPECIFIC			( 0xFF )
+#define usbBUS_POWERED					( 0x80 )
+#define usbHID_REPORT_DESCRIPTOR			( 0x22 )
+#define AT91C_UDP_TRANSCEIVER_ENABLE		( *( ( unsigned long * ) 0xfffb0074 ) )
+
+/* Index to the various string. */
+#define usbLANGUAGE_STRING				( 0 )
+#define usbMANUFACTURER_STRING				( 1 )
+#define usbPRODUCT_STRING				( 2 )
+#define usbCONFIGURATION_STRING				( 3 )
+#define usbINTERFACE_STRING				( 4 )
+
+/* Defines fields of standard SETUP request.  Now in normal order. */
+#define usbREQUEST_TYPE_INDEX				( 0 )
+#define usbREQUEST_INDEX				( 1 )
+#define usbVALUE_HIGH_BYTE				( 3 )
+#define usbVALUE_LOW_BYTE				( 2 )
+#define usbINDEX_HIGH_BYTE				( 5 )
+#define usbINDEX_LOW_BYTE				( 4 )
+#define usbLENGTH_HIGH_BYTE				( 7 )
+#define usbLENGTH_LOW_BYTE				( 6 )
+
+/* Misc application definitions. */
+#define usbINTERRUPT_PRIORITY				( 3 )
+#define usbQUEUE_LENGTH					( 0x3 )	/* Must have all bits set! */
+#define usbFIFO_LENGTH					( ( unsigned portLONG ) 8 )
+#define usbEND_POINT_0					( 0 )
+#define usbEND_POINT_1					( 1 )
+#define usbEND_POINT_2					( 2 )
+#define usbEND_POINT_3					( 3 )
+#define usbMAX_CONTROL_MESSAGE_SIZE			( 128 )
+#define usbRX_COUNT_MASK				( ( unsigned portLONG ) 0x7ff )
+#define usbSHORTEST_DELAY				( ( portTickType ) 1 )
+#define usbINIT_DELAY					( ( portTickType ) 1000 / portTICK_RATE_MS )
+#define usbSHORT_DELAY					( ( portTickType ) 50 / portTICK_RATE_MS )
+#define usbEND_POINT_RESET_MASK				( ( unsigned portLONG ) 0x0f )
+#define usbDATA_INC					( ( portCHAR ) 5 )
+#define usbEXPECTED_NUMBER_OF_BYTES			( ( unsigned portLONG ) 8 )
+
+/* Control request types. */
+#define usbSTANDARD_DEVICE_REQUEST			( 0 )
+#define usbSTANDARD_INTERFACE_REQUEST			( 1 )
+#define usbSTANDARD_END_POINT_REQUEST			( 2 )
+#define usbCLASS_INTERFACE_REQUEST			( 5 )
+
+
+/* Macros to manipulate the control and status registers.  These registers 
+cannot be accessed using a direct read modify write operation outside of the 
+ISR as some bits are left unchanged by writing with a 0, and some are left 
+unchanged by writing with a 1. */
+
+
+#define usbCSR_SET_BIT( pulValueNow, ulBit )											\
+{																						\
+	/* Set TXCOMP, RX_DATA_BK0, RXSETUP, */												\
+	/* STALLSENT and RX_DATA_BK1 to 1 so the */											\
+	/* write has no effect. */															\
+	( * ( ( unsigned portLONG * ) pulValueNow ) ) |= ( unsigned portLONG ) 0x4f;		\
+																						\
+	/* Clear the FORCE_STALL and TXPKTRDY bits */										\
+	/* so the write has no effect. */													\
+	( * ( ( unsigned portLONG * ) pulValueNow ) ) &= ( unsigned portLONG ) 0xffffffcf;	\
+																						\
+	/* Set whichever bit we want set. */												\
+	( * ( ( unsigned portLONG * ) pulValueNow ) ) |= ( ulBit );							\
+}
+
+#define usbCSR_CLEAR_BIT( pulValueNow, ulBit )											\
+{																						\
+	/* Set TXCOMP, RX_DATA_BK0, RXSETUP, */												\
+	/* STALLSENT and RX_DATA_BK1 to 1 so the */											\
+	/* write has no effect. */															\
+	( * ( ( unsigned portLONG * ) pulValueNow ) ) |= ( unsigned portLONG ) 0x4f;		\
+																						\
+	/* Clear the FORCE_STALL and TXPKTRDY bits */										\
+	/* so the write has no effect. */													\
+	( * ( ( unsigned portLONG * ) pulValueNow ) ) &= ( unsigned portLONG ) 0xffffffcf;	\
+																						\
+	/* Clear whichever bit we want clear. */											\
+	( * ( ( unsigned portLONG * ) pulValueNow ) ) &= ( ~ulBit );						\
+}