2 FreeRTOS V7.5.1 - Copyright (C) 2013 Real Time Engineers Ltd.
\r
4 VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
\r
6 ***************************************************************************
\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
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
18 ***************************************************************************
\r
20 This file is part of the FreeRTOS distribution.
\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
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
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
38 ***************************************************************************
\r
40 * Having a problem? Start by reading the FAQ "My application does *
\r
41 * not run, what could be wrong?" *
\r
43 * http://www.FreeRTOS.org/FAQHelp.html *
\r
45 ***************************************************************************
\r
47 http://www.FreeRTOS.org - Documentation, books, training, latest versions,
\r
48 license and Real Time Engineers Ltd. contact details.
\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
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
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
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
72 - developed from original FreeRTOS HID example by Scott Miller
\r
73 - modified to support 3.2 GCC by najay
\r
76 /* Standard includes. */
\r
80 /* Demo board includes. */
\r
83 /* Scheduler includes. */
\r
84 #include "FreeRTOS.h"
\r
88 /* Demo app includes. */
\r
89 #include "USB-CDC.h"
\r
90 #include "descriptors.h"
\r
92 #define usbNO_BLOCK ( ( portTickType ) 0 )
\r
94 /* Reset all endpoints */
\r
95 static void prvResetEndPoints( void );
\r
97 /* Clear pull up resistor to detach device from host */
\r
98 static void vDetachUSBInterface( void );
\r
100 /* Set up interface and initialize variables */
\r
101 static void vInitUSBInterface( void );
\r
103 /* Handle control endpoint events. */
\r
104 static void prvProcessEndPoint0Interrupt( xISRStatus *pxMessage );
\r
106 /* Handle standard device requests. */
\r
107 static void prvHandleStandardDeviceRequest( xUSB_REQUEST *pxRequest );
\r
109 /* Handle standard interface requests. */
\r
110 static void prvHandleStandardInterfaceRequest( xUSB_REQUEST *pxRequest );
\r
112 /* Handle endpoint requests. */
\r
113 static void prvHandleStandardEndPointRequest( xUSB_REQUEST *pxRequest );
\r
115 /* Handle class interface requests. */
\r
116 static void prvHandleClassInterfaceRequest( xUSB_REQUEST *pxRequest );
\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
121 /* Send next segment of data for the control transfer */
\r
122 static void prvSendNextSegment( void );
\r
124 /* Send stall - used to respond to unsupported requests */
\r
125 static void prvSendStall( void );
\r
127 /* Send a zero-length (null) packet */
\r
128 static void prvSendZLP( void );
\r
130 /* Handle requests for standard interface descriptors */
\r
131 static void prvGetStandardInterfaceDescriptor( xUSB_REQUEST *pxRequest );
\r
133 /*------------------------------------------------------------*/
\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
140 /* Incoming and outgoing control data structures */
\r
141 static xCONTROL_MESSAGE pxControlTx;
\r
142 static xCONTROL_MESSAGE pxControlRx;
\r
144 /* Queue holding pointers to pending messages */
\r
145 xQueueHandle xUSBInterruptQueue;
\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
152 /* Line coding - 115,200 baud, N-8-1 */
\r
153 static const unsigned char pxLineCoding[] = { 0x00, 0xC2, 0x01, 0x00, 0x00, 0x00, 0x08 };
\r
155 /* Status variables. */
\r
156 static unsigned char ucControlState;
\r
157 static unsigned int uiCurrentBank;
\r
160 /*------------------------------------------------------------*/
\r
163 void vUSBCDCTask( void *pvParameters )
\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
171 ( void ) pvParameters;
\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
178 vTaskDelay( portTICK_RATE_MS * 60 );
\r
180 /* Init USB interface */
\r
181 portENTER_CRITICAL();
\r
182 vInitUSBInterface();
\r
183 portEXIT_CRITICAL();
\r
185 /* Main task loop. Process incoming endpoint 0 interrupts, handle data transfers. */
\r
189 /* Look for data coming from the ISR. */
\r
190 if( xQueueReceive( xUSBInterruptQueue, &pxMessage, usbSHORTEST_DELAY ) )
\r
192 if( pxMessage->ulISR & AT91C_UDP_EPINT0 )
\r
194 /* All endpoint 0 interrupts are handled here. */
\r
195 prvProcessEndPoint0Interrupt( pxMessage );
\r
198 if( pxMessage->ulISR & AT91C_UDP_ENDBUSRES )
\r
200 /* End of bus reset - reset the endpoints and de-configure. */
\r
201 prvResetEndPoints();
\r
205 /* See if we're ready to send and receive data. */
\r
206 if( eDriverState == eREADY_TO_SEND && ucControlState )
\r
208 if( ( !(AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_2 ] & AT91C_UDP_TXPKTRDY) ) && uxQueueMessagesWaiting( xTxCDC ) )
\r
210 for( xByte = 0; xByte < 64; xByte++ )
\r
212 if( !xQueueReceive( xTxCDC, &ucByte, 0 ) )
\r
214 /* No data buffered to transmit. */
\r
218 /* Got a byte to transmit. */
\r
219 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_2 ] = ucByte;
\r
221 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_2 ] |= AT91C_UDP_TXPKTRDY;
\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
227 ulRxBytes = (AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] >> 16) & usbRX_COUNT_MASK;
\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
232 while( ulRxBytes-- )
\r
234 ucByte = AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_1 ];
\r
235 xQueueSend( xRxCDC, &ucByte, 0 );
\r
238 /* Release the FIFO */
\r
239 portENTER_CRITICAL();
\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
245 portEXIT_CRITICAL();
\r
247 /* Re-enable endpoint 1's interrupts */
\r
248 AT91C_BASE_UDP->UDP_IER = AT91C_UDP_EPINT1;
\r
250 /* Update the current bank in use */
\r
251 if( uiCurrentBank == AT91C_UDP_RX_DATA_BK0 )
\r
253 uiCurrentBank = AT91C_UDP_RX_DATA_BK1;
\r
257 uiCurrentBank = AT91C_UDP_RX_DATA_BK0;
\r
269 /*------------------------------------------------------------*/
\r
271 void vUSBSendByte( char cByte )
\r
273 /* Queue the byte to be sent. The USB task will send it. */
\r
274 xQueueSend( xTxCDC, &cByte, usbNO_BLOCK );
\r
276 /*------------------------------------------------------------*/
\r
278 static void prvSendZLP( void )
\r
280 unsigned long ulStatus;
\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
286 vTaskDelay( usbSHORTEST_DELAY );
\r
289 portENTER_CRITICAL();
\r
291 /* Cancel any further pending data */
\r
292 pxControlTx.ulTotalDataLength = pxControlTx.ulNextCharIndex;
\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
299 portEXIT_CRITICAL();
\r
301 /*------------------------------------------------------------*/
\r
303 static void prvSendStall( void )
\r
305 unsigned long ulStatus;
\r
307 portENTER_CRITICAL();
\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
314 portEXIT_CRITICAL();
\r
316 /*------------------------------------------------------------*/
\r
318 static void prvResetEndPoints( void )
\r
320 unsigned long ulTemp;
\r
322 eDriverState = eJUST_RESET;
\r
323 ucControlState = 0;
\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
329 /* Enable data to be sent and received. */
\r
330 AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
\r
332 /* Repair the configuration end point. */
\r
333 portENTER_CRITICAL();
\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
340 portEXIT_CRITICAL();
\r
341 uiCurrentBank = AT91C_UDP_RX_DATA_BK0;
\r
343 /*------------------------------------------------------------*/
\r
345 static void prvProcessEndPoint0Interrupt( xISRStatus *pxMessage )
\r
347 static xUSB_REQUEST xRequest;
\r
348 unsigned long ulRxBytes;
\r
350 /* Get number of bytes received, if any */
\r
351 ulRxBytes = pxMessage->ulCSR0 >> 16;
\r
352 ulRxBytes &= usbRX_COUNT_MASK;
\r
354 if( pxMessage->ulCSR0 & AT91C_UDP_TXCOMP )
\r
356 /* We received a TX complete interrupt. What we do depends on
\r
357 what we sent to get this interrupt. */
\r
359 if( eDriverState == eJUST_GOT_CONFIG )
\r
361 /* We sent an acknowledgement of a SET_CONFIG request. We
\r
362 are now at the end of the enumeration.
\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
368 /* Set up endpoints */
\r
369 portENTER_CRITICAL();
\r
371 unsigned long ulTemp;
\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
389 portEXIT_CRITICAL();
\r
391 eDriverState = eREADY_TO_SEND;
\r
393 else if( eDriverState == eJUST_GOT_ADDRESS )
\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
399 AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
\r
403 AT91C_BASE_UDP->UDP_GLBSTATE = 0;
\r
406 AT91C_BASE_UDP->UDP_FADDR = ( AT91C_UDP_FEN | ulReceivedAddress );
\r
407 eDriverState = eNOTHING;
\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
417 if( pxMessage->ulCSR0 & AT91C_UDP_RX_DATA_BK0 )
\r
419 /* Received a control data packet. May be a 0-length ACK or a data stage. */
\r
420 unsigned char ucBytesToGet;
\r
422 /* Got data. Cancel any outgoing data. */
\r
423 pxControlTx.ulNextCharIndex = pxControlTx.ulTotalDataLength;
\r
425 /* Determine how many bytes we need to receive. */
\r
426 ucBytesToGet = pxControlRx.ulTotalDataLength - pxControlRx.ulNextCharIndex;
\r
427 if( ucBytesToGet > ulRxBytes )
\r
429 ucBytesToGet = ulRxBytes;
\r
432 /* If we're not expecting any data, it's an ack - just quit now. */
\r
433 if( !ucBytesToGet )
\r
438 /* Get the required data and update the index. */
\r
439 memcpy( pxControlRx.ucBuffer, pxMessage->ucFifoData, ucBytesToGet );
\r
440 pxControlRx.ulNextCharIndex += ucBytesToGet;
\r
443 if( pxMessage->ulCSR0 & AT91C_UDP_RXSETUP )
\r
445 /* Received a SETUP packet. May be followed by data packets. */
\r
447 if( ulRxBytes >= usbEXPECTED_NUMBER_OF_BYTES )
\r
449 /* Create an xUSB_REQUEST variable from the raw bytes array. */
\r
451 xRequest.ucReqType = pxMessage->ucFifoData[ usbREQUEST_TYPE_INDEX ];
\r
452 xRequest.ucRequest = pxMessage->ucFifoData[ usbREQUEST_INDEX ];
\r
454 xRequest.usValue = pxMessage->ucFifoData[ usbVALUE_HIGH_BYTE ];
\r
455 xRequest.usValue <<= 8;
\r
456 xRequest.usValue |= pxMessage->ucFifoData[ usbVALUE_LOW_BYTE ];
\r
458 xRequest.usIndex = pxMessage->ucFifoData[ usbINDEX_HIGH_BYTE ];
\r
459 xRequest.usIndex <<= 8;
\r
460 xRequest.usIndex |= pxMessage->ucFifoData[ usbINDEX_LOW_BYTE ];
\r
462 xRequest.usLength = pxMessage->ucFifoData[ usbLENGTH_HIGH_BYTE ];
\r
463 xRequest.usLength <<= 8;
\r
464 xRequest.usLength |= pxMessage->ucFifoData[ usbLENGTH_LOW_BYTE ];
\r
466 pxControlRx.ulNextCharIndex = 0;
\r
467 if( ! (xRequest.ucReqType & 0x80) ) /* Host-to-Device transfer, may need to get data first */
\r
469 if( xRequest.usLength > usbMAX_CONTROL_MESSAGE_SIZE )
\r
471 /* Too big! No space for control data, stall and abort. */
\r
476 pxControlRx.ulTotalDataLength = xRequest.usLength;
\r
480 /* We're sending the data, don't wait for any. */
\r
481 pxControlRx.ulTotalDataLength = 0;
\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
490 unsigned char ucRequest;
\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
500 switch( ucRequest )
\r
502 case usbSTANDARD_DEVICE_REQUEST:
\r
503 /* Standard Device request */
\r
504 prvHandleStandardDeviceRequest( &xRequest );
\r
507 case usbSTANDARD_INTERFACE_REQUEST:
\r
508 /* Standard Interface request */
\r
509 prvHandleStandardInterfaceRequest( &xRequest );
\r
512 case usbSTANDARD_END_POINT_REQUEST:
\r
513 /* Standard Endpoint request */
\r
514 prvHandleStandardEndPointRequest( &xRequest );
\r
517 case usbCLASS_INTERFACE_REQUEST:
\r
518 /* Class Interface request */
\r
519 prvHandleClassInterfaceRequest( &xRequest );
\r
522 default: /* This is not something we want to respond to. */
\r
527 /*------------------------------------------------------------*/
\r
529 static void prvGetStandardDeviceDescriptor( xUSB_REQUEST *pxRequest )
\r
531 /* The type is in the high byte. Return whatever has been requested. */
\r
532 switch( ( pxRequest->usValue & 0xff00 ) >> 8 )
\r
534 case usbDESCRIPTOR_TYPE_DEVICE:
\r
535 prvSendControlData( ( unsigned char * ) &pxDeviceDescriptor, pxRequest->usLength, sizeof( pxDeviceDescriptor ), pdTRUE );
\r
538 case usbDESCRIPTOR_TYPE_CONFIGURATION:
\r
539 prvSendControlData( ( unsigned char * ) &( pxConfigDescriptor ), pxRequest->usLength, sizeof( pxConfigDescriptor ), pdTRUE );
\r
542 case usbDESCRIPTOR_TYPE_STRING:
\r
544 /* The index to the string descriptor is the lower byte. */
\r
545 switch( pxRequest->usValue & 0xff )
\r
547 case usbLANGUAGE_STRING:
\r
548 prvSendControlData( ( unsigned char * ) &pxLanguageStringDescriptor, pxRequest->usLength, sizeof(pxLanguageStringDescriptor), pdTRUE );
\r
551 case usbMANUFACTURER_STRING:
\r
552 prvSendControlData( ( unsigned char * ) &pxManufacturerStringDescriptor, pxRequest->usLength, sizeof( pxManufacturerStringDescriptor ), pdTRUE );
\r
555 case usbPRODUCT_STRING:
\r
556 prvSendControlData( ( unsigned char * ) &pxProductStringDescriptor, pxRequest->usLength, sizeof( pxProductStringDescriptor ), pdTRUE );
\r
559 case usbCONFIGURATION_STRING:
\r
560 prvSendControlData( ( unsigned char * ) &pxConfigurationStringDescriptor, pxRequest->usLength, sizeof( pxConfigurationStringDescriptor ), pdTRUE );
\r
563 case usbINTERFACE_STRING:
\r
564 prvSendControlData( ( unsigned char * ) &pxInterfaceStringDescriptor, pxRequest->usLength, sizeof( pxInterfaceStringDescriptor ), pdTRUE );
\r
578 /*------------------------------------------------------------*/
\r
580 static void prvHandleStandardDeviceRequest( xUSB_REQUEST *pxRequest )
\r
582 unsigned short usStatus = 0;
\r
584 switch( pxRequest->ucRequest )
\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
591 case usbGET_DESCRIPTOR_REQUEST:
\r
592 /* Send device descriptor */
\r
593 prvGetStandardDeviceDescriptor( pxRequest );
\r
596 case usbGET_CONFIGURATION_REQUEST:
\r
597 /* Send selected device configuration */
\r
598 prvSendControlData( ( unsigned char * ) &ucUSBConfig, sizeof( ucUSBConfig ), sizeof( ucUSBConfig ), pdFALSE );
\r
601 case usbSET_FEATURE_REQUEST:
\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
608 eDriverState = eJUST_GOT_ADDRESS;
\r
609 ulReceivedAddress = ( unsigned long ) pxRequest->usValue;
\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
620 /* Any unsupported request results in a STALL response. */
\r
625 /*------------------------------------------------------------*/
\r
627 static void prvHandleClassInterfaceRequest( xUSB_REQUEST *pxRequest )
\r
629 switch( pxRequest->ucRequest )
\r
631 case usbSEND_ENCAPSULATED_COMMAND:
\r
635 case usbGET_ENCAPSULATED_RESPONSE:
\r
639 case usbSET_LINE_CODING:
\r
640 /* Set line coding - baud rate, data bits, parity, stop bits */
\r
642 memcpy( ( void * ) pxLineCoding, pxControlRx.ucBuffer, sizeof( pxLineCoding ) );
\r
645 case usbGET_LINE_CODING:
\r
646 /* Get line coding */
\r
647 prvSendControlData( (unsigned char *) &pxLineCoding, pxRequest->usLength, sizeof( pxLineCoding ), pdFALSE );
\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
653 ucControlState = pxRequest->usValue;
\r
661 /*------------------------------------------------------------*/
\r
663 static void prvGetStandardInterfaceDescriptor( xUSB_REQUEST *pxRequest )
\r
665 switch( ( pxRequest->usValue & ( unsigned short ) 0xff00 ) >> 8 )
\r
672 /*-----------------------------------------------------------*/
\r
674 static void prvHandleStandardInterfaceRequest( xUSB_REQUEST *pxRequest )
\r
676 unsigned short usStatus = 0;
\r
678 switch( pxRequest->ucRequest )
\r
680 case usbGET_STATUS_REQUEST:
\r
681 /* Send dummy 2 bytes. */
\r
682 prvSendControlData( ( unsigned char * ) &usStatus, sizeof( usStatus ), sizeof( usStatus ), pdFALSE );
\r
685 case usbGET_DESCRIPTOR_REQUEST:
\r
686 prvGetStandardInterfaceDescriptor( pxRequest );
\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
699 /*-----------------------------------------------------------*/
\r
701 static void prvHandleStandardEndPointRequest( xUSB_REQUEST *pxRequest )
\r
703 switch( pxRequest->ucRequest )
\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
715 /*-----------------------------------------------------------*/
\r
717 static void vDetachUSBInterface( void)
\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
724 /* Disable pull up */
\r
725 AT91C_BASE_PIOA->PIO_SODR = AT91C_PIO_PA16;
\r
727 /*-----------------------------------------------------------*/
\r
729 static void vInitUSBInterface( void )
\r
731 extern void ( vUSB_ISR_Wrapper )( void );
\r
733 /* Create the queue used to communicate between the USB ISR and task. */
\r
734 xUSBInterruptQueue = xQueueCreate( usbQUEUE_LENGTH + 1, sizeof( xISRStatus * ) );
\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
740 if( (!xUSBInterruptQueue) || (!xRxCDC) || (!xTxCDC) )
\r
742 /* Not enough RAM to create queues!. */
\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
755 /* HARDWARE SETUP */
\r
757 /* Set the PLL USB Divider */
\r
758 AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1;
\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
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
769 /* Start without the pullup - this will get set at the end of this
\r
771 AT91C_BASE_PIOA->PIO_SODR = AT91C_PIO_PA16;
\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
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
786 /* Enable the transceiver. */
\r
787 AT91C_UDP_TRANSCEIVER_ENABLE = 0;
\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
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
799 /*-----------------------------------------------------------*/
\r
801 static void prvSendControlData( unsigned char *pucData, unsigned short usRequestedLength, unsigned long ulLengthToSend, long lSendingDescriptor )
\r
803 if( ( ( unsigned long ) usRequestedLength < ulLengthToSend ) )
\r
805 /* Cap the data length to that requested. */
\r
806 ulLengthToSend = ( unsigned short ) usRequestedLength;
\r
808 else if( ( ulLengthToSend < ( unsigned long ) usRequestedLength ) && lSendingDescriptor )
\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
814 if( ( ulLengthToSend % usbFIFO_LENGTH ) == 0 )
\r
816 eDriverState = eSENDING_EVEN_DESCRIPTOR;
\r
820 /* Here we assume that the previous message has been sent. THERE IS NO
\r
821 BUFFER OVERFLOW PROTECTION HERE.
\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
827 /* Reinitialise the buffer index so we start sending from the start of
\r
829 pxControlTx.ulTotalDataLength = ulLengthToSend;
\r
830 pxControlTx.ulNextCharIndex = ( unsigned long ) 0;
\r
832 /* Send the first 8 bytes now. The rest will get sent in response to
\r
833 TXCOMP interrupts. */
\r
834 prvSendNextSegment();
\r
836 /*-----------------------------------------------------------*/
\r
838 static void prvSendNextSegment( void )
\r
840 volatile unsigned long ulNextLength, ulStatus, ulLengthLeftToSend;
\r
842 /* Is there any data to send? */
\r
843 if( pxControlTx.ulTotalDataLength > pxControlTx.ulNextCharIndex )
\r
845 ulLengthLeftToSend = pxControlTx.ulTotalDataLength - pxControlTx.ulNextCharIndex;
\r
847 /* We can only send 8 bytes to the fifo at a time. */
\r
848 if( ulLengthLeftToSend > usbFIFO_LENGTH )
\r
850 ulNextLength = usbFIFO_LENGTH;
\r
854 ulNextLength = ulLengthLeftToSend;
\r
857 /* Wait until we can place data in the fifo. THERE IS NO TIMEOUT
\r
859 while( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] & AT91C_UDP_TXPKTRDY )
\r
861 vTaskDelay( usbSHORTEST_DELAY );
\r
864 /* Write the data to the FIFO. */
\r
865 while( ulNextLength > ( unsigned long ) 0 )
\r
867 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_0 ] = pxControlTx.ucBuffer[ pxControlTx.ulNextCharIndex ];
\r
870 pxControlTx.ulNextCharIndex++;
\r
873 /* Start the transmission. */
\r
874 portENTER_CRITICAL();
\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
880 portEXIT_CRITICAL();
\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
890 eDriverState = eNOTHING;
\r