git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/lwIP_Demo_Rowley_ARM7/USB/USB-CDC.c

   1 /*\r
   2     FreeRTOS V7.5.2 - Copyright (C) 2013 Real Time Engineers Ltd.\r
   3 \r
   4     VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
   5 \r
   6     ***************************************************************************\r
   7      *                                                                       *\r
   8      *    FreeRTOS provides completely free yet professionally developed,    *\r
   9      *    robust, strictly quality controlled, supported, and cross          *\r
  10      *    platform software that has become a de facto standard.             *\r
  11      *                                                                       *\r
  12      *    Help yourself get started quickly and support the FreeRTOS         *\r
  13      *    project by purchasing a FreeRTOS tutorial book, reference          *\r
  14      *    manual, or both from: http://www.FreeRTOS.org/Documentation        *\r
  15      *                                                                       *\r
  16      *    Thank you!                                                         *\r
  17      *                                                                       *\r
  18     ***************************************************************************\r
  19 \r
  20     This file is part of the FreeRTOS distribution.\r
  21 \r
  22     FreeRTOS is free software; you can redistribute it and/or modify it under\r
  23     the terms of the GNU General Public License (version 2) as published by the\r
  24     Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.\r
  25 \r
  26     >>! NOTE: The modification to the GPL is included to allow you to distribute\r
  27     >>! a combined work that includes FreeRTOS without being obliged to provide\r
  28     >>! the source code for proprietary components outside of the FreeRTOS\r
  29     >>! kernel.\r
  30 \r
  31     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
  32     WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
  33     FOR A PARTICULAR PURPOSE.  Full license text is available from the following\r
  34     link: http://www.freertos.org/a00114.html\r
  35 \r
  36     1 tab == 4 spaces!\r
  37 \r
  38     ***************************************************************************\r
  39      *                                                                       *\r
  40      *    Having a problem?  Start by reading the FAQ "My application does   *\r
  41      *    not run, what could be wrong?"                                     *\r
  42      *                                                                       *\r
  43      *    http://www.FreeRTOS.org/FAQHelp.html                               *\r
  44      *                                                                       *\r
  45     ***************************************************************************\r
  46 \r
  47     http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
  48     license and Real Time Engineers Ltd. contact details.\r
  49 \r
  50     http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
  51     including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
  52     compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
  53 \r
  54     http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
  55     Integrity Systems to sell under the OpenRTOS brand.  Low cost OpenRTOS\r
  56     licenses offer ticketed support, indemnification and middleware.\r
  57 \r
  58     http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
  59     engineered and independently SIL3 certified version for use in safety and\r
  60     mission critical applications that require provable dependability.\r
  61 \r
  62     1 tab == 4 spaces!\r
  63 */\r
  64 \r
  65 /*\r
  66         USB Communications Device Class driver.\r
  67         Implements task vUSBCDCTask and provides an Abstract Control Model serial \r
  68         interface.  Control is through endpoint 0, device-to-host notification is \r
  69         provided by interrupt-in endpoint 3, and raw data is transferred through \r
  70         bulk endpoints 1 and 2.\r
  71 \r
  72         - developed from original FreeRTOS HID example by Scott Miller\r
  73         - modified to support 3.2 GCC by najay\r
  74 */\r
  75 \r
  76 /* Standard includes. */\r
  77 #include <string.h>\r
  78 #include <stdio.h>\r
  79 \r
  80 /* Demo board includes. */\r
  81 #include "Board.h"\r
  82 \r
  83 /* Scheduler includes. */\r
  84 #include "FreeRTOS.h"\r
  85 #include "task.h"\r
  86 #include "queue.h"\r
  87 \r
  88 /* Demo app includes. */\r
  89 #include "USB-CDC.h"\r
  90 #include "descriptors.h"\r
  91 \r
  92 #define usbNO_BLOCK ( ( portTickType ) 0 )\r
  93 \r
  94 /* Reset all endpoints */\r
  95 static void prvResetEndPoints( void );\r
  96 \r
  97 /* Clear pull up resistor to detach device from host */\r
  98 static void vDetachUSBInterface( void );\r
  99 \r
 100 /* Set up interface and initialize variables */\r
 101 static void vInitUSBInterface( void );\r
 102 \r
 103 /* Handle control endpoint events. */\r
 104 static void prvProcessEndPoint0Interrupt( xISRStatus *pxMessage );\r
 105 \r
 106 /* Handle standard device requests. */\r
 107 static void prvHandleStandardDeviceRequest( xUSB_REQUEST *pxRequest );\r
 108 \r
 109 /* Handle standard interface requests. */\r
 110 static void prvHandleStandardInterfaceRequest( xUSB_REQUEST *pxRequest );\r
 111 \r
 112 /* Handle endpoint requests. */\r
 113 static void prvHandleStandardEndPointRequest( xUSB_REQUEST *pxRequest );\r
 114 \r
 115 /* Handle class interface requests. */\r
 116 static void prvHandleClassInterfaceRequest( xUSB_REQUEST *pxRequest );\r
 117 \r
 118 /* Prepare control data transfer.  prvSendNextSegment starts transfer. */\r
 119 static void prvSendControlData( unsigned char *pucData, unsigned short usRequestedLength, unsigned long ulLengthLeftToSend, long lSendingDescriptor );\r
 120 \r
 121 /* Send next segment of data for the control transfer */\r
 122 static void prvSendNextSegment( void );\r
 123 \r
 124 /* Send stall - used to respond to unsupported requests */\r
 125 static void prvSendStall( void );\r
 126 \r
 127 /* Send a zero-length (null) packet */\r
 128 static void prvSendZLP( void );\r
 129 \r
 130 /* Handle requests for standard interface descriptors */\r
 131 static void prvGetStandardInterfaceDescriptor( xUSB_REQUEST *pxRequest );\r
 132 \r
 133 /*------------------------------------------------------------*/\r
 134 \r
 135 /* File scope static variables */\r
 136 static unsigned char ucUSBConfig = ( unsigned char ) 0;\r
 137 static unsigned long ulReceivedAddress = ( unsigned long ) 0;\r
 138 static eDRIVER_STATE eDriverState = eNOTHING;\r
 139 \r
 140 /* Incoming and outgoing control data structures */\r
 141 static xCONTROL_MESSAGE pxControlTx;\r
 142 static xCONTROL_MESSAGE pxControlRx;\r
 143 \r
 144 /* Queue holding pointers to pending messages */\r
 145 xQueueHandle xUSBInterruptQueue; \r
 146 \r
 147 /* Queues used to hold received characters, and characters waiting to be\r
 148 transmitted.  Rx queue must be larger than FIFO size. */\r
 149 static xQueueHandle xRxCDC; \r
 150 static xQueueHandle xTxCDC; \r
 151 \r
 152 /* Line coding - 115,200 baud, N-8-1 */\r
 153 static const unsigned char pxLineCoding[] = { 0x00, 0xC2, 0x01, 0x00, 0x00, 0x00, 0x08 };\r
 154 \r
 155 /* Status variables. */\r
 156 static unsigned char ucControlState;\r
 157 static unsigned int uiCurrentBank;\r
 158 \r
 159 \r
 160 /*------------------------------------------------------------*/\r
 161 \r
 162 \r
 163 void vUSBCDCTask( void *pvParameters )\r
 164 {\r
 165 xISRStatus *pxMessage;\r
 166 unsigned long ulStatus;\r
 167 unsigned long ulRxBytes;\r
 168 unsigned char ucByte;\r
 169 portBASE_TYPE xByte;\r
 170 \r
 171         ( void ) pvParameters;\r
 172 \r
 173         /* Disconnect USB device from hub.  For debugging - causes host to register reset */\r
 174         portENTER_CRITICAL();\r
 175                  vDetachUSBInterface();\r
 176         portEXIT_CRITICAL();\r
 177         \r
 178         vTaskDelay( portTICK_RATE_MS * 60 );\r
 179 \r
 180         /* Init USB interface */\r
 181         portENTER_CRITICAL();\r
 182                 vInitUSBInterface();\r
 183         portEXIT_CRITICAL();\r
 184         \r
 185         /* Main task loop.  Process incoming endpoint 0 interrupts, handle data transfers. */\r
 186          \r
 187         for( ;; )\r
 188         {\r
 189                 /* Look for data coming from the ISR. */\r
 190                 if( xQueueReceive( xUSBInterruptQueue, &pxMessage, usbSHORTEST_DELAY ) )\r
 191                 {\r
 192                         if( pxMessage->ulISR & AT91C_UDP_EPINT0 )\r
 193                         {\r
 194                                 /* All endpoint 0 interrupts are handled here. */\r
 195                                 prvProcessEndPoint0Interrupt( pxMessage );\r
 196                         }\r
 197 \r
 198                         if( pxMessage->ulISR & AT91C_UDP_ENDBUSRES )\r
 199                         {\r
 200                                 /* End of bus reset - reset the endpoints and de-configure. */\r
 201                                 prvResetEndPoints();            \r
 202                         }\r
 203                 }\r
 204                 \r
 205                 /* See if we're ready to send and receive data. */\r
 206                 if( eDriverState == eREADY_TO_SEND && ucControlState ) \r
 207                 {\r
 208                         if( ( !(AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_2 ] & AT91C_UDP_TXPKTRDY) ) && uxQueueMessagesWaiting( xTxCDC ) )\r
 209                         {\r
 210                                 for( xByte = 0; xByte < 64; xByte++ )\r
 211                                 {                                  \r
 212                                         if( !xQueueReceive( xTxCDC, &ucByte, 0 ) ) \r
 213                                         {\r
 214                                                 /* No data buffered to transmit. */\r
 215                                                 break;\r
 216                                         }\r
 217 \r
 218                                         /* Got a byte to transmit. */\r
 219                                         AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_2 ] = ucByte;\r
 220                                 } \r
 221                                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_2 ] |= AT91C_UDP_TXPKTRDY;\r
 222                         }\r
 223 \r
 224                         /* Check for incoming data (host-to-device) on endpoint 1. */\r
 225                         while( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] & (AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RX_DATA_BK1) )\r
 226                         {\r
 227                                 ulRxBytes = (AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] >> 16) & usbRX_COUNT_MASK;\r
 228 \r
 229                                 /* Only process FIFO if there's room to store it in the queue */\r
 230                                 if( ulRxBytes < ( USB_CDC_QUEUE_SIZE - uxQueueMessagesWaiting( xRxCDC ) ) )\r
 231                                 {\r
 232                                         while( ulRxBytes-- )\r
 233                                         {\r
 234                                                 ucByte = AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_1 ];\r
 235                                                 xQueueSend( xRxCDC, &ucByte, 0 );\r
 236                                         }\r
 237 \r
 238                                         /* Release the FIFO */\r
 239                                         portENTER_CRITICAL();\r
 240                                         {\r
 241                                                 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ];\r
 242                                                 usbCSR_CLEAR_BIT( &ulStatus, uiCurrentBank );\r
 243                                                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] = ulStatus;\r
 244                                         }\r
 245                                         portEXIT_CRITICAL();\r
 246 \r
 247                                         /* Re-enable endpoint 1's interrupts */\r
 248                                         AT91C_BASE_UDP->UDP_IER = AT91C_UDP_EPINT1;\r
 249                                 \r
 250                                         /* Update the current bank in use */\r
 251                                         if( uiCurrentBank == AT91C_UDP_RX_DATA_BK0 ) \r
 252                                         {\r
 253                                                 uiCurrentBank = AT91C_UDP_RX_DATA_BK1;\r
 254                                         }\r
 255                                         else \r
 256                                         {\r
 257                                                 uiCurrentBank = AT91C_UDP_RX_DATA_BK0;\r
 258                                         }\r
 259 \r
 260                                 }\r
 261                                 else \r
 262                                 {\r
 263                                         break;\r
 264                                 }\r
 265                         }\r
 266                 }\r
 267         }\r
 268 }\r
 269 /*------------------------------------------------------------*/\r
 270 \r
 271 void vUSBSendByte( char cByte )\r
 272 {\r
 273         /* Queue the byte to be sent.  The USB task will send it. */\r
 274         xQueueSend( xTxCDC, &cByte, usbNO_BLOCK );\r
 275 }\r
 276 /*------------------------------------------------------------*/\r
 277 \r
 278 static void prvSendZLP( void )\r
 279 {\r
 280 unsigned long ulStatus;\r
 281 \r
 282         /* Wait until the FIFO is free - even though we are not going to use it.\r
 283         THERE IS NO TIMEOUT HERE! */\r
 284         while( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] & AT91C_UDP_TXPKTRDY )\r
 285         {\r
 286                 vTaskDelay( usbSHORTEST_DELAY );\r
 287         }\r
 288 \r
 289         portENTER_CRITICAL();\r
 290         {\r
 291                 /* Cancel any further pending data */\r
 292                 pxControlTx.ulTotalDataLength = pxControlTx.ulNextCharIndex;\r
 293 \r
 294                 /* Set the TXPKTRDY bit to cause a transmission with no data. */\r
 295                 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];\r
 296                 usbCSR_SET_BIT( &ulStatus, AT91C_UDP_TXPKTRDY );\r
 297                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;\r
 298         }\r
 299         portEXIT_CRITICAL();\r
 300 }\r
 301 /*------------------------------------------------------------*/\r
 302 \r
 303 static void prvSendStall( void )\r
 304 {\r
 305         unsigned long ulStatus;\r
 306 \r
 307         portENTER_CRITICAL();\r
 308         {\r
 309                 /* Force a stall by simply setting the FORCESTALL bit in the CSR. */\r
 310                 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];\r
 311                 usbCSR_SET_BIT( &ulStatus, AT91C_UDP_FORCESTALL );\r
 312                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;\r
 313         }\r
 314         portEXIT_CRITICAL();\r
 315 }\r
 316 /*------------------------------------------------------------*/\r
 317 \r
 318 static void prvResetEndPoints( void )\r
 319 {\r
 320 unsigned long ulTemp;\r
 321 \r
 322         eDriverState = eJUST_RESET;\r
 323         ucControlState = 0;\r
 324 \r
 325         /* Reset all the end points. */\r
 326         AT91C_BASE_UDP->UDP_RSTEP  = usbEND_POINT_RESET_MASK;\r
 327         AT91C_BASE_UDP->UDP_RSTEP  = ( unsigned long ) 0x00;\r
 328 \r
 329         /* Enable data to be sent and received. */\r
 330         AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;\r
 331 \r
 332         /* Repair the configuration end point. */\r
 333         portENTER_CRITICAL();\r
 334         {\r
 335                 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];\r
 336                 usbCSR_SET_BIT( &ulTemp, ( ( unsigned long ) ( AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL ) ) );\r
 337                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulTemp;\r
 338                 AT91C_BASE_UDP->UDP_IER = AT91C_UDP_EPINT0;\r
 339         }\r
 340         portEXIT_CRITICAL();\r
 341         uiCurrentBank = AT91C_UDP_RX_DATA_BK0;\r
 342 }\r
 343 /*------------------------------------------------------------*/\r
 344 \r
 345 static void prvProcessEndPoint0Interrupt( xISRStatus *pxMessage )\r
 346 {\r
 347 static xUSB_REQUEST xRequest;\r
 348 unsigned long ulRxBytes;\r
 349 \r
 350         /* Get number of bytes received, if any */\r
 351         ulRxBytes = pxMessage->ulCSR0 >> 16;\r
 352         ulRxBytes &= usbRX_COUNT_MASK;\r
 353 \r
 354         if( pxMessage->ulCSR0 & AT91C_UDP_TXCOMP )\r
 355         {\r
 356                 /* We received a TX complete interrupt.  What we do depends on\r
 357                 what we sent to get this interrupt. */\r
 358 \r
 359                 if( eDriverState == eJUST_GOT_CONFIG )\r
 360                 {\r
 361                         /* We sent an acknowledgement of a SET_CONFIG request.  We\r
 362                         are now at the end of the enumeration.\r
 363                         \r
 364                         TODO: Config 0 sets unconfigured state, should enter Address state.\r
 365                         Request for unsupported config should stall. */\r
 366                         AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_CONFG;\r
 367                         \r
 368                         /* Set up endpoints */\r
 369                         portENTER_CRITICAL();\r
 370                         {\r
 371                                 unsigned long ulTemp;\r
 372 \r
 373                                 /* Set endpoint 1 to bulk-out */\r
 374                                 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ];                                     \r
 375                                 usbCSR_SET_BIT( &ulTemp, AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_OUT );\r
 376                                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] = ulTemp;             \r
 377                                 AT91C_BASE_UDP->UDP_IER = AT91C_UDP_EPINT1;\r
 378                                 /* Set endpoint 2 to bulk-in */\r
 379                                 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_2 ];                                     \r
 380                                 usbCSR_SET_BIT( &ulTemp, AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_IN );\r
 381                                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_2 ] = ulTemp;             \r
 382                                 AT91C_BASE_UDP->UDP_IER = AT91C_UDP_EPINT2;\r
 383                                         /* Set endpoint 3 to interrupt-in, enable it, and enable interrupts */\r
 384                                 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_3 ];                                     \r
 385                                 usbCSR_SET_BIT( &ulTemp, AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_INT_IN );\r
 386                                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_3 ] = ulTemp;             \r
 387                                 /*AT91F_UDP_EnableIt( AT91C_BASE_UDP, AT91C_UDP_EPINT3 );                                */\r
 388                         }\r
 389                         portEXIT_CRITICAL();\r
 390 \r
 391                         eDriverState = eREADY_TO_SEND;\r
 392                 }               \r
 393                 else if( eDriverState == eJUST_GOT_ADDRESS )\r
 394                 {\r
 395                         /* We sent an acknowledgement of a SET_ADDRESS request.  Move\r
 396                         to the addressed state. */\r
 397                         if( ulReceivedAddress != ( unsigned long ) 0 )\r
 398                         {                       \r
 399                                 AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;\r
 400                         }\r
 401                         else\r
 402                         {\r
 403                                 AT91C_BASE_UDP->UDP_GLBSTATE = 0;\r
 404                         }                       \r
 405 \r
 406                         AT91C_BASE_UDP->UDP_FADDR = ( AT91C_UDP_FEN | ulReceivedAddress );              \r
 407                         eDriverState = eNOTHING;\r
 408                 }\r
 409                 else\r
 410                 {               \r
 411                         /* The TXCOMP was not for any special type of transmission.  See\r
 412                         if there is any more data to send. */\r
 413                         prvSendNextSegment();\r
 414                 }\r
 415         }\r
 416 \r
 417         if( pxMessage->ulCSR0 & AT91C_UDP_RX_DATA_BK0 )\r
 418         {\r
 419                 /* Received a control data packet.  May be a 0-length ACK or a data stage. */\r
 420                 unsigned char ucBytesToGet;\r
 421          \r
 422                 /* Got data.  Cancel any outgoing data. */\r
 423                 pxControlTx.ulNextCharIndex = pxControlTx.ulTotalDataLength;\r
 424                 \r
 425                  /* Determine how many bytes we need to receive. */\r
 426                 ucBytesToGet = pxControlRx.ulTotalDataLength - pxControlRx.ulNextCharIndex;\r
 427                 if( ucBytesToGet > ulRxBytes ) \r
 428                 {       \r
 429                         ucBytesToGet = ulRxBytes;\r
 430                 }\r
 431 \r
 432                 /* If we're not expecting any data, it's an ack - just quit now. */\r
 433                 if( !ucBytesToGet )\r
 434                 {\r
 435                          return;\r
 436                 }\r
 437 \r
 438                 /* Get the required data and update the index. */\r
 439                 memcpy( pxControlRx.ucBuffer, pxMessage->ucFifoData, ucBytesToGet );\r
 440                 pxControlRx.ulNextCharIndex += ucBytesToGet;    \r
 441         }\r
 442 \r
 443         if( pxMessage->ulCSR0 & AT91C_UDP_RXSETUP )\r
 444         {\r
 445                 /* Received a SETUP packet.  May be followed by data packets. */\r
 446 \r
 447                 if( ulRxBytes >= usbEXPECTED_NUMBER_OF_BYTES )\r
 448                 {                               \r
 449                         /* Create an xUSB_REQUEST variable from the raw bytes array. */\r
 450 \r
 451                         xRequest.ucReqType = pxMessage->ucFifoData[ usbREQUEST_TYPE_INDEX ];\r
 452                         xRequest.ucRequest = pxMessage->ucFifoData[ usbREQUEST_INDEX ];\r
 453 \r
 454                         xRequest.usValue = pxMessage->ucFifoData[ usbVALUE_HIGH_BYTE ];\r
 455                         xRequest.usValue <<= 8;\r
 456                         xRequest.usValue |= pxMessage->ucFifoData[ usbVALUE_LOW_BYTE ];\r
 457                                                 \r
 458                         xRequest.usIndex = pxMessage->ucFifoData[ usbINDEX_HIGH_BYTE ];\r
 459                         xRequest.usIndex <<= 8;\r
 460                         xRequest.usIndex |= pxMessage->ucFifoData[ usbINDEX_LOW_BYTE ];\r
 461                         \r
 462                         xRequest.usLength = pxMessage->ucFifoData[ usbLENGTH_HIGH_BYTE ];\r
 463                         xRequest.usLength <<= 8;\r
 464                         xRequest.usLength |= pxMessage->ucFifoData[ usbLENGTH_LOW_BYTE ];\r
 465 \r
 466                         pxControlRx.ulNextCharIndex = 0;\r
 467                         if( ! (xRequest.ucReqType & 0x80) ) /* Host-to-Device transfer, may need to get data first */\r
 468                         {\r
 469                                 if( xRequest.usLength > usbMAX_CONTROL_MESSAGE_SIZE )\r
 470                                 {       \r
 471                                         /* Too big!  No space for control data, stall and abort. */\r
 472                                         prvSendStall();\r
 473                                         return;\r
 474                                 }\r
 475 \r
 476                                 pxControlRx.ulTotalDataLength = xRequest.usLength;\r
 477                         }\r
 478                         else\r
 479                         {\r
 480                                 /* We're sending the data, don't wait for any. */\r
 481                                 pxControlRx.ulTotalDataLength = 0; \r
 482                         }\r
 483                 }\r
 484         }\r
 485 \r
 486         /* See if we've got a pending request and all its associated data ready */\r
 487         if( ( pxMessage->ulCSR0 & ( AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RXSETUP ) ) \r
 488                 && ( pxControlRx.ulNextCharIndex >= pxControlRx.ulTotalDataLength ) )\r
 489         {\r
 490                 unsigned char ucRequest;\r
 491 \r
 492                 /* Manipulate the ucRequestType and the ucRequest parameters to \r
 493                 generate a zero based request selection.  This is just done to \r
 494                 break up the requests into subsections for clarity.  The \r
 495                 alternative would be to have more huge switch statement that would\r
 496                 be difficult to optimise. */\r
 497                 ucRequest = ( ( xRequest.ucReqType & 0x60 ) >> 3 );\r
 498                 ucRequest |= ( xRequest.ucReqType & 0x03 );\r
 499                         \r
 500                 switch( ucRequest )\r
 501                 {\r
 502                         case usbSTANDARD_DEVICE_REQUEST:        \r
 503                                 /* Standard Device request */\r
 504                                 prvHandleStandardDeviceRequest( &xRequest );\r
 505                                 break;\r
 506 \r
 507                         case usbSTANDARD_INTERFACE_REQUEST:     \r
 508                                 /* Standard Interface request */\r
 509                                 prvHandleStandardInterfaceRequest( &xRequest );\r
 510                                 break;\r
 511 \r
 512                         case usbSTANDARD_END_POINT_REQUEST:     \r
 513                                 /* Standard Endpoint request */\r
 514                                 prvHandleStandardEndPointRequest( &xRequest );\r
 515                                 break;\r
 516 \r
 517                         case usbCLASS_INTERFACE_REQUEST:        \r
 518                                 /* Class Interface request */\r
 519                                 prvHandleClassInterfaceRequest( &xRequest );\r
 520                                 break;\r
 521 \r
 522                         default:        /* This is not something we want to respond to. */\r
 523                                 prvSendStall(); \r
 524                 }\r
 525         }\r
 526 }\r
 527 /*------------------------------------------------------------*/\r
 528 \r
 529 static void prvGetStandardDeviceDescriptor( xUSB_REQUEST *pxRequest )\r
 530 {\r
 531         /* The type is in the high byte.  Return whatever has been requested. */\r
 532         switch( ( pxRequest->usValue & 0xff00 ) >> 8 )\r
 533         {\r
 534                 case usbDESCRIPTOR_TYPE_DEVICE:\r
 535                         prvSendControlData( ( unsigned char * ) &pxDeviceDescriptor, pxRequest->usLength, sizeof( pxDeviceDescriptor ), pdTRUE );\r
 536                         break;\r
 537 \r
 538                 case usbDESCRIPTOR_TYPE_CONFIGURATION:\r
 539                         prvSendControlData( ( unsigned char * ) &( pxConfigDescriptor ), pxRequest->usLength, sizeof( pxConfigDescriptor ), pdTRUE );\r
 540                         break;\r
 541 \r
 542                 case usbDESCRIPTOR_TYPE_STRING:\r
 543 \r
 544                         /* The index to the string descriptor is the lower byte. */\r
 545                         switch( pxRequest->usValue & 0xff )\r
 546                         {                       \r
 547                                 case usbLANGUAGE_STRING:\r
 548                                         prvSendControlData( ( unsigned char * ) &pxLanguageStringDescriptor, pxRequest->usLength, sizeof(pxLanguageStringDescriptor), pdTRUE );\r
 549                                         break;\r
 550 \r
 551                                 case usbMANUFACTURER_STRING:\r
 552                                         prvSendControlData( ( unsigned char * ) &pxManufacturerStringDescriptor, pxRequest->usLength, sizeof( pxManufacturerStringDescriptor ), pdTRUE );\r
 553                                         break;\r
 554 \r
 555                                 case usbPRODUCT_STRING:\r
 556                                         prvSendControlData( ( unsigned char * ) &pxProductStringDescriptor, pxRequest->usLength, sizeof( pxProductStringDescriptor ), pdTRUE );\r
 557                                         break;\r
 558 \r
 559                                 case usbCONFIGURATION_STRING:\r
 560                                         prvSendControlData( ( unsigned char * ) &pxConfigurationStringDescriptor, pxRequest->usLength, sizeof( pxConfigurationStringDescriptor ), pdTRUE );\r
 561                                         break;\r
 562 \r
 563                                 case usbINTERFACE_STRING:\r
 564                                         prvSendControlData( ( unsigned char * ) &pxInterfaceStringDescriptor, pxRequest->usLength, sizeof( pxInterfaceStringDescriptor ), pdTRUE );\r
 565                                         break;\r
 566 \r
 567                                 default:\r
 568                                         prvSendStall();\r
 569                                         break;\r
 570                         }\r
 571                         break;\r
 572 \r
 573                 default:\r
 574                         prvSendStall();\r
 575                         break;\r
 576         }\r
 577 }\r
 578 /*------------------------------------------------------------*/\r
 579 \r
 580 static void prvHandleStandardDeviceRequest( xUSB_REQUEST *pxRequest )\r
 581 {\r
 582 unsigned short usStatus = 0;\r
 583 \r
 584         switch( pxRequest->ucRequest )\r
 585         {\r
 586                 case usbGET_STATUS_REQUEST:\r
 587                         /* Just send two byte dummy status. */\r
 588                         prvSendControlData( ( unsigned char * ) &usStatus, sizeof( usStatus ), sizeof( usStatus ), pdFALSE );\r
 589                         break;\r
 590 \r
 591                 case usbGET_DESCRIPTOR_REQUEST:\r
 592                         /* Send device descriptor */\r
 593                         prvGetStandardDeviceDescriptor( pxRequest );\r
 594                         break;\r
 595 \r
 596                 case usbGET_CONFIGURATION_REQUEST:\r
 597                         /* Send selected device configuration */\r
 598                         prvSendControlData( ( unsigned char * ) &ucUSBConfig, sizeof( ucUSBConfig ), sizeof( ucUSBConfig ), pdFALSE );\r
 599                         break;\r
 600 \r
 601                 case usbSET_FEATURE_REQUEST:\r
 602                         prvSendZLP();\r
 603                         break;\r
 604 \r
 605                 case usbSET_ADDRESS_REQUEST:                    \r
 606                         /* Get assigned address and send ack, but don't implement new address until we get a TXCOMP */\r
 607                         prvSendZLP();                   \r
 608                         eDriverState = eJUST_GOT_ADDRESS;                       \r
 609                         ulReceivedAddress = ( unsigned long ) pxRequest->usValue;\r
 610                         break;\r
 611 \r
 612                 case usbSET_CONFIGURATION_REQUEST:\r
 613                         /* Ack SET_CONFIGURATION request, but don't implement until TXCOMP */\r
 614                         ucUSBConfig = ( unsigned char ) ( pxRequest->usValue & 0xff );\r
 615                         eDriverState = eJUST_GOT_CONFIG;\r
 616                         prvSendZLP();\r
 617                         break;\r
 618 \r
 619                 default:\r
 620                         /* Any unsupported request results in a STALL response. */\r
 621                         prvSendStall();\r
 622                         break;\r
 623         }\r
 624 }\r
 625 /*------------------------------------------------------------*/\r
 626 \r
 627 static void prvHandleClassInterfaceRequest( xUSB_REQUEST *pxRequest )\r
 628 {\r
 629         switch( pxRequest->ucRequest )\r
 630         {\r
 631                 case usbSEND_ENCAPSULATED_COMMAND:\r
 632                         prvSendStall();\r
 633                         break;\r
 634 \r
 635                 case usbGET_ENCAPSULATED_RESPONSE:\r
 636                         prvSendStall();\r
 637                         break;\r
 638 \r
 639                 case usbSET_LINE_CODING:\r
 640                         /* Set line coding - baud rate, data bits, parity, stop bits */\r
 641                         prvSendZLP();\r
 642                         memcpy( ( void * ) pxLineCoding, pxControlRx.ucBuffer, sizeof( pxLineCoding ) );\r
 643                         break;\r
 644 \r
 645                 case usbGET_LINE_CODING:\r
 646                         /* Get line coding */\r
 647                         prvSendControlData( (unsigned char *) &pxLineCoding, pxRequest->usLength, sizeof( pxLineCoding ), pdFALSE );\r
 648                         break;\r
 649 \r
 650                 case usbSET_CONTROL_LINE_STATE:\r
 651                         /* D0: 1=DTR, 0=No DTR,  D1: 1=Activate Carrier, 0=Deactivate carrier (RTS, half-duplex) */\r
 652                         prvSendZLP();\r
 653                         ucControlState = pxRequest->usValue;\r
 654                         break;\r
 655 \r
 656                 default:\r
 657                         prvSendStall();\r
 658                         break;\r
 659         }\r
 660 }\r
 661 /*------------------------------------------------------------*/\r
 662 \r
 663 static void prvGetStandardInterfaceDescriptor( xUSB_REQUEST *pxRequest )\r
 664 {\r
 665         switch( ( pxRequest->usValue & ( unsigned short ) 0xff00 ) >> 8 )\r
 666         {\r
 667                 default:\r
 668                         prvSendStall();\r
 669                         break;\r
 670         }\r
 671 }\r
 672 /*-----------------------------------------------------------*/\r
 673 \r
 674 static void prvHandleStandardInterfaceRequest( xUSB_REQUEST *pxRequest )\r
 675 {\r
 676 unsigned short usStatus = 0;\r
 677 \r
 678         switch( pxRequest->ucRequest )\r
 679         {\r
 680                 case usbGET_STATUS_REQUEST:\r
 681                         /* Send dummy 2 bytes. */\r
 682                         prvSendControlData( ( unsigned char * ) &usStatus, sizeof( usStatus ), sizeof( usStatus ), pdFALSE );\r
 683                         break;\r
 684 \r
 685                 case usbGET_DESCRIPTOR_REQUEST:\r
 686                         prvGetStandardInterfaceDescriptor( pxRequest ); \r
 687                         break;\r
 688 \r
 689                 /* This minimal implementation does not respond to these. */\r
 690                 case usbGET_INTERFACE_REQUEST:\r
 691                 case usbSET_FEATURE_REQUEST:\r
 692                 case usbSET_INTERFACE_REQUEST:  \r
 693 \r
 694                 default:\r
 695                         prvSendStall();\r
 696                         break;\r
 697         }\r
 698 }\r
 699 /*-----------------------------------------------------------*/\r
 700 \r
 701 static void prvHandleStandardEndPointRequest( xUSB_REQUEST *pxRequest )\r
 702 {\r
 703         switch( pxRequest->ucRequest )\r
 704         {\r
 705                 /* This minimal implementation does not expect to respond to these. */\r
 706                 case usbGET_STATUS_REQUEST:\r
 707                 case usbCLEAR_FEATURE_REQUEST: \r
 708                 case usbSET_FEATURE_REQUEST:\r
 709 \r
 710                 default:                        \r
 711                         prvSendStall();\r
 712                         break;\r
 713         }\r
 714 }\r
 715 /*-----------------------------------------------------------*/\r
 716 \r
 717 static void vDetachUSBInterface( void)\r
 718 {\r
 719         /* Setup the PIO for the USB pull up resistor. */\r
 720         AT91C_BASE_PIOA->PIO_PER = AT91C_PIO_PA16;\r
 721         AT91C_BASE_PIOA->PIO_OER = AT91C_PIO_PA16;\r
 722 \r
 723 \r
 724         /* Disable pull up */\r
 725         AT91C_BASE_PIOA->PIO_SODR = AT91C_PIO_PA16;\r
 726 } \r
 727 /*-----------------------------------------------------------*/\r
 728 \r
 729 static void vInitUSBInterface( void )\r
 730 {\r
 731 extern void ( vUSB_ISR_Wrapper )( void );\r
 732 \r
 733         /* Create the queue used to communicate between the USB ISR and task. */\r
 734         xUSBInterruptQueue = xQueueCreate( usbQUEUE_LENGTH + 1, sizeof( xISRStatus * ) );\r
 735         \r
 736         /* Create the queues used to hold Rx and Tx characters. */\r
 737         xRxCDC = xQueueCreate( USB_CDC_QUEUE_SIZE, ( unsigned char ) sizeof( signed char ) );\r
 738         xTxCDC = xQueueCreate( USB_CDC_QUEUE_SIZE + 1, ( unsigned char ) sizeof( signed char ) );\r
 739 \r
 740         if( (!xUSBInterruptQueue) || (!xRxCDC) || (!xTxCDC) )\r
 741         {       \r
 742                 /* Not enough RAM to create queues!. */\r
 743                 return;\r
 744         }\r
 745         \r
 746         /* Initialise a few state variables. */\r
 747         pxControlTx.ulNextCharIndex = ( unsigned long ) 0;\r
 748         pxControlRx.ulNextCharIndex = ( unsigned long ) 0;\r
 749         ucUSBConfig = ( unsigned char ) 0;\r
 750         eDriverState = eNOTHING;\r
 751         ucControlState = 0;\r
 752         uiCurrentBank = AT91C_UDP_RX_DATA_BK0;\r
 753 \r
 754 \r
 755         /* HARDWARE SETUP */\r
 756 \r
 757         /* Set the PLL USB Divider */\r
 758         AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1;\r
 759 \r
 760         /* Enables the 48MHz USB clock UDPCK and System Peripheral USB Clock. */\r
 761         AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_UDP;\r
 762         AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_UDP);\r
 763 \r
 764         /* Setup the PIO for the USB pull up resistor. */\r
 765         AT91C_BASE_PIOA->PIO_PER = AT91C_PIO_PA16;\r
 766         AT91C_BASE_PIOA->PIO_OER = AT91C_PIO_PA16;\r
 767 \r
 768 \r
 769         /* Start without the pullup - this will get set at the end of this \r
 770         function. */\r
 771         AT91C_BASE_PIOA->PIO_SODR = AT91C_PIO_PA16;\r
 772 \r
 773 \r
 774         /* When using the USB debugger the peripheral registers do not always get\r
 775         set to the correct default values.  To make sure set the relevant registers\r
 776         manually here. */\r
 777         AT91C_BASE_UDP->UDP_IDR = ( unsigned long ) 0xffffffff;\r
 778         AT91C_BASE_UDP->UDP_ICR = ( unsigned long ) 0xffffffff;\r
 779         AT91C_BASE_UDP->UDP_CSR[ 0 ] = ( unsigned long ) 0x00;\r
 780         AT91C_BASE_UDP->UDP_CSR[ 1 ] = ( unsigned long ) 0x00;\r
 781         AT91C_BASE_UDP->UDP_CSR[ 2 ] = ( unsigned long ) 0x00;\r
 782         AT91C_BASE_UDP->UDP_CSR[ 3 ] = ( unsigned long ) 0x00;\r
 783         AT91C_BASE_UDP->UDP_GLBSTATE = 0;\r
 784         AT91C_BASE_UDP->UDP_FADDR = 0;\r
 785 \r
 786         /* Enable the transceiver. */\r
 787         AT91C_UDP_TRANSCEIVER_ENABLE = 0;\r
 788 \r
 789         /* Enable the USB interrupts - other interrupts get enabled as the \r
 790         enumeration process progresses. */\r
 791         AT91F_AIC_ConfigureIt( AT91C_ID_UDP, usbINTERRUPT_PRIORITY, AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL, ( void (*)( void ) ) vUSB_ISR_Wrapper );\r
 792         AT91C_BASE_AIC->AIC_IECR = 0x1 << AT91C_ID_UDP;\r
 793 \r
 794 \r
 795         /* Wait a short while before making our presence known. */\r
 796         vTaskDelay( usbINIT_DELAY );\r
 797         AT91C_BASE_PIOA->PIO_CODR = AT91C_PIO_PA16;\r
 798 }\r
 799 /*-----------------------------------------------------------*/\r
 800 \r
 801 static void prvSendControlData( unsigned char *pucData, unsigned short usRequestedLength, unsigned long ulLengthToSend, long lSendingDescriptor )\r
 802 {\r
 803         if( ( ( unsigned long ) usRequestedLength < ulLengthToSend ) )\r
 804         {\r
 805                 /* Cap the data length to that requested. */\r
 806                 ulLengthToSend = ( unsigned short ) usRequestedLength;\r
 807         }\r
 808         else if( ( ulLengthToSend < ( unsigned long ) usRequestedLength ) && lSendingDescriptor )\r
 809         {\r
 810                 /* We are sending a descriptor.  If the descriptor is an exact \r
 811                 multiple of the FIFO length then it will have to be terminated\r
 812                 with a NULL packet.  Set the state to indicate this if\r
 813                 necessary. */\r
 814                 if( ( ulLengthToSend % usbFIFO_LENGTH ) == 0 )\r
 815                 {\r
 816                         eDriverState = eSENDING_EVEN_DESCRIPTOR;\r
 817                 }\r
 818         }\r
 819 \r
 820         /* Here we assume that the previous message has been sent.  THERE IS NO\r
 821         BUFFER OVERFLOW PROTECTION HERE.\r
 822 \r
 823         Copy the data to send into the buffer as we cannot send it all at once\r
 824         (if it is greater than 8 bytes in length). */\r
 825         memcpy( pxControlTx.ucBuffer, pucData, ulLengthToSend );\r
 826 \r
 827         /* Reinitialise the buffer index so we start sending from the start of \r
 828         the data. */\r
 829         pxControlTx.ulTotalDataLength = ulLengthToSend;\r
 830         pxControlTx.ulNextCharIndex = ( unsigned long ) 0;\r
 831 \r
 832         /* Send the first 8 bytes now.  The rest will get sent in response to \r
 833         TXCOMP interrupts. */\r
 834         prvSendNextSegment();\r
 835 }\r
 836 /*-----------------------------------------------------------*/\r
 837 \r
 838 static void prvSendNextSegment( void )\r
 839 {\r
 840 volatile unsigned long ulNextLength, ulStatus, ulLengthLeftToSend;\r
 841 \r
 842         /* Is there any data to send? */\r
 843         if( pxControlTx.ulTotalDataLength > pxControlTx.ulNextCharIndex )\r
 844         {\r
 845                 ulLengthLeftToSend = pxControlTx.ulTotalDataLength - pxControlTx.ulNextCharIndex;\r
 846         \r
 847                 /* We can only send 8 bytes to the fifo at a time. */\r
 848                 if( ulLengthLeftToSend > usbFIFO_LENGTH )\r
 849                 {\r
 850                         ulNextLength = usbFIFO_LENGTH;\r
 851                 }\r
 852                 else\r
 853                 {\r
 854                         ulNextLength = ulLengthLeftToSend;\r
 855                 }\r
 856 \r
 857                 /* Wait until we can place data in the fifo.  THERE IS NO TIMEOUT\r
 858                 HERE! */\r
 859                 while( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] & AT91C_UDP_TXPKTRDY )\r
 860                 {\r
 861                         vTaskDelay( usbSHORTEST_DELAY );\r
 862                 }\r
 863 \r
 864                 /* Write the data to the FIFO. */\r
 865                 while( ulNextLength > ( unsigned long ) 0 )\r
 866                 {\r
 867                         AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_0 ] = pxControlTx.ucBuffer[ pxControlTx.ulNextCharIndex ];\r
 868         \r
 869                         ulNextLength--;\r
 870                         pxControlTx.ulNextCharIndex++;\r
 871                 }\r
 872         \r
 873                 /* Start the transmission. */\r
 874                 portENTER_CRITICAL();\r
 875                 {\r
 876                         ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];\r
 877                         usbCSR_SET_BIT( &ulStatus, ( ( unsigned long ) 0x10 ) );\r
 878                         AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;\r
 879                 }\r
 880                 portEXIT_CRITICAL();\r
 881         }\r
 882         else\r
 883         {\r
 884                 /* There is no data to send.  If we were sending a descriptor and the \r
 885                 descriptor was an exact multiple of the max packet size then we need\r
 886                 to send a null to terminate the transmission. */\r
 887                 if( eDriverState == eSENDING_EVEN_DESCRIPTOR )\r
 888                 {\r
 889                         prvSendZLP();\r
 890                         eDriverState = eNOTHING;\r
 891                 }\r
 892         }\r
 893 }\r
 894 \r
 895 \r