2 FreeRTOS.org V4.3.1 - Copyright (C) 2003-2007 Richard Barry.
\r
4 This file is part of the FreeRTOS.org distribution.
\r
6 FreeRTOS.org is free software; you can redistribute it and/or modify
\r
7 it under the terms of the GNU General Public License as published by
\r
8 the Free Software Foundation; either version 2 of the License, or
\r
9 (at your option) any later version.
\r
11 FreeRTOS.org is distributed in the hope that it will be useful,
\r
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
14 GNU General Public License for more details.
\r
16 You should have received a copy of the GNU General Public License
\r
17 along with FreeRTOS.org; if not, write to the Free Software
\r
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
\r
20 A special exception to the GPL can be applied should you wish to distribute
\r
21 a combined work that includes FreeRTOS.org, without being obliged to provide
\r
22 the source code for any proprietary components. See the licensing section
\r
23 of http://www.FreeRTOS.org for full details of how and when the exception
\r
26 ***************************************************************************
\r
27 See http://www.FreeRTOS.org for documentation, latest information, license
\r
28 and contact details. Please ensure to read the configuration and relevant
\r
29 port sections of the online documentation.
\r
31 Also see http://www.SafeRTOS.com for an IEC 61508 compliant version along
\r
32 with commercial development and support options.
\r
33 ***************************************************************************
\r
37 Sample interrupt driven USB device driver. This is a minimal implementation
\r
38 for demonstration only. Although functional, it is not a full and compliant
\r
41 The USB device enumerates as a simple 3 axis joystick, and once configured
\r
42 transmits 3 axis of data which can be viewed from the USB host machine.
\r
44 This file implements the USB interrupt service routine, and a demo FreeRTOS
\r
45 task. The interrupt service routine handles the USB hardware - taking a
\r
46 snapshot of the USB status at the point of the interrupt. The task receives
\r
47 the status information from the interrupt for processing at the task level.
\r
49 See the FreeRTOS.org WEB documentation for more information.
\r
55 + Descriptors that have a length that is an exact multiple of usbFIFO_LENGTH
\r
56 can now be transmitted. To this end an extra parameter has been
\r
57 added to the prvSendControlData() function, and the state
\r
58 eSENDING_EVEN_DESCRIPTOR has been introduced. Thanks to Scott Miller for
\r
59 assisting with this contribution.
\r
63 + Replaced the duplicated RX_DATA_BK0 in the interrupt mask with the
\r
67 /* Standard includes. */
\r
70 /* Demo board includes. */
\r
73 /* Scheduler includes. */
\r
74 #include "FreeRTOS.h"
\r
79 /* Descriptor type definitions. */
\r
80 #define usbDESCRIPTOR_TYPE_DEVICE ( 0x01 )
\r
81 #define usbDESCRIPTOR_TYPE_CONFIGURATION ( 0x02 )
\r
82 #define usbDESCRIPTOR_TYPE_STRING ( 0x03 )
\r
84 /* USB request type definitions. */
\r
85 #define usbGET_REPORT_REQUEST ( 0x01 )
\r
86 #define usbGET_IDLE_REQUEST ( 0x02 )
\r
87 #define usbGET_PROTOCOL_REQUEST ( 0x03 )
\r
88 #define usbSET_REPORT_REQUEST ( 0x09 )
\r
89 #define usbSET_IDLE_REQUEST ( 0x0A )
\r
90 #define usbSET_PROTOCOL_REQUEST ( 0x0B )
\r
91 #define usbGET_CONFIGURATION_REQUEST ( 0x08 )
\r
92 #define usbGET_STATUS_REQUEST ( 0x00 )
\r
93 #define usbCLEAR_FEATURE_REQUEST ( 0x01 )
\r
94 #define usbSET_FEATURE_REQUEST ( 0x03 )
\r
95 #define usbSET_ADDRESS_REQUEST ( 0x05 )
\r
96 #define usbGET_DESCRIPTOR_REQUEST ( 0x06 )
\r
97 #define usbSET_CONFIGURATION_REQUEST ( 0x09 )
\r
98 #define usbGET_INTERFACE_REQUEST ( 0x0A )
\r
99 #define usbSET_INTERFACE_REQUEST ( 0x0B )
\r
102 /* Misc USB definitions. */
\r
103 #define usbDEVICE_CLASS_VENDOR_SPECIFIC ( 0xFF )
\r
104 #define usbBUS_POWERED ( 0x80 )
\r
105 #define usbHID_REPORT_DESCRIPTOR ( 0x22 )
\r
106 #define AT91C_UDP_TRANSCEIVER_ENABLE ( *( ( unsigned long * ) 0xfffb0074 ) )
\r
108 /* Index to the various string. */
\r
109 #define usbLANGUAGE_STRING ( 0 )
\r
110 #define usbMANUFACTURER_STRING ( 1 )
\r
111 #define usbPRODUCT_STRING ( 2 )
\r
112 #define usbCONFIGURATION_STRING ( 3 )
\r
113 #define usbINTERFACE_STRING ( 4 )
\r
115 /* Data indexes for reading the request from the xISRStatus.ucFifoData[]
\r
116 into xUSB_REQUEST. The data order is designed for speed - so looks a
\r
118 #define usbREQUEST_TYPE_INDEX ( 7 )
\r
119 #define usbREQUEST_INDEX ( 6 )
\r
120 #define usbVALUE_HIGH_BYTE ( 4 )
\r
121 #define usbVALUE_LOW_BYTE ( 5 )
\r
122 #define usbINDEX_HIGH_BYTE ( 2 )
\r
123 #define usbINDEX_LOW_BYTE ( 3 )
\r
124 #define usbLENGTH_HIGH_BYTE ( 0 )
\r
125 #define usbLENGTH_LOW_BYTE ( 1 )
\r
127 /* Misc application definitions. */
\r
128 #define usbINTERRUPT_PRIORITY ( 3 )
\r
129 #define usbQUEUE_LENGTH ( 0x3 ) /* Must have all bits set! */
\r
130 #define usbFIFO_LENGTH ( ( unsigned portLONG ) 8 )
\r
131 #define usbEND_POINT_0 ( 0 )
\r
132 #define usbEND_POINT_1 ( 1 )
\r
133 #define usbXUP ( 1 )
\r
134 #define usbXDOWN ( 2 )
\r
135 #define usbYUP ( 3 )
\r
136 #define usbYDOWN ( 4 )
\r
137 #define usbMAX_COORD ( 120 )
\r
138 #define usbMAX_TX_MESSAGE_SIZE ( 128 )
\r
139 #define usbRX_COUNT_MASK ( ( unsigned portLONG ) 0x7ff )
\r
140 #define AT91C_UDP_STALLSENT AT91C_UDP_ISOERROR
\r
141 #define usbSHORTEST_DELAY ( ( portTickType ) 1 )
\r
142 #define usbINIT_DELAY ( ( portTickType ) 500 / portTICK_RATE_MS )
\r
143 #define usbSHORT_DELAY ( ( portTickType ) 50 / portTICK_RATE_MS )
\r
144 #define usbEND_POINT_RESET_MASK ( ( unsigned portLONG ) 0x0f )
\r
145 #define usbDATA_INC ( ( portCHAR ) 5 )
\r
146 #define usbEXPECTED_NUMBER_OF_BYTES ( ( unsigned portLONG ) 8 )
\r
148 /* Control request types. */
\r
149 #define usbSTANDARD_DEVICE_REQUEST ( 0 )
\r
150 #define usbSTANDARD_INTERFACE_REQUEST ( 1 )
\r
151 #define usbSTANDARD_END_POINT_REQUEST ( 2 )
\r
152 #define usbCLASS_INTERFACE_REQUEST ( 5 )
\r
154 /*-----------------------------------------------------------*/
\r
156 /* Structure used to take a snapshot of the USB status from within the ISR. */
\r
157 typedef struct X_ISR_STATUS
\r
159 unsigned portLONG ulISR;
\r
160 unsigned portLONG ulCSR0;
\r
161 unsigned portCHAR ucFifoData[ 8 ];
\r
164 /* Structure used to hold the received requests. */
\r
167 unsigned portCHAR ucReqType;
\r
168 unsigned portCHAR ucRequest;
\r
169 unsigned portSHORT usValue;
\r
170 unsigned portSHORT usIndex;
\r
171 unsigned portSHORT usLength;
\r
180 eSENDING_EVEN_DESCRIPTOR,
\r
184 /* Structure used to control the data being sent to the host. */
\r
187 unsigned portCHAR ucTxBuffer[ usbMAX_TX_MESSAGE_SIZE ];
\r
188 unsigned portLONG ulNextCharIndex;
\r
189 unsigned portLONG ulTotalDataLength;
\r
192 /*-----------------------------------------------------------*/
\r
195 * The USB interrupt service routine. This takes a snapshot of the USB
\r
196 * device at the time of the interrupt, clears the interrupts, and posts
\r
197 * the data to the USB processing task.
\r
199 __arm void vUSB_ISR( void );
\r
202 * Called after the bus reset interrupt - this function readies all the
\r
203 * end points for communication.
\r
205 static void prvResetEndPoints( void );
\r
208 * Setup the USB hardware, install the interrupt service routine and
\r
209 * initialise all the state variables.
\r
211 static void vInitUSBInterface( void );
\r
214 * Decode and act upon an interrupt generated by the control end point.
\r
216 static void prvProcessEndPoint0Interrupt( xISRStatus *pxMessage );
\r
219 * For simplicity requests are separated into device, interface, class
\r
220 * interface and end point requests.
\r
222 * Decode and handle standard device requests originating on the control
\r
225 static void prvHandleStandardDeviceRequest( xUSB_REQUEST *pxRequest );
\r
228 * For simplicity requests are separated into device, interface, class
\r
229 * interface and end point requests.
\r
231 * Decode and handle standard interface requests originating on the control
\r
234 static void prvHandleStandardInterfaceRequest( xUSB_REQUEST *pxRequest );
\r
237 * For simplicity requests are separated into device, interface, class
\r
238 * interface and end point requests.
\r
240 * Decode and handle standard end point requests originating on the control
\r
243 static void prvHandleStandardEndPointRequest( xUSB_REQUEST *pxRequest );
\r
246 * For simplicity requests are separated into device, interface, class
\r
247 * interface and end point requests.
\r
249 * Decode and handle the class interface requests.
\r
251 static void prvHandleClassInterfaceRequest( xUSB_REQUEST *pxRequest );
\r
254 * Setup the Tx buffer to send data in response to a control request.
\r
256 * The data to be transmitted is buffered, the state variables are updated,
\r
257 * then prvSendNextSegment() is called to start the transmission off. Once
\r
258 * the first segment has been sent the remaining segments are transmitted
\r
259 * in response to TXCOMP interrupts until the entire buffer has been
\r
262 static void prvSendControlData( unsigned portCHAR *pucData, unsigned portSHORT usRequestedLength, unsigned portLONG ulLengthLeftToSend, portLONG lSendingDescriptor );
\r
265 * Examine the Tx buffer to see if there is any more data to be transmitted.
\r
267 * If there is data to be transmitted then send the next segment. A segment
\r
268 * can have a maximum of 8 bytes (this is defined as the maximum for the end
\r
269 * point by the descriptor). The final segment may be less than 8 bytes if
\r
270 * the total data length was not an exact multiple of 8.
\r
272 static void prvSendNextSegment( void );
\r
275 * A stall condition is forced each time the host makes a request that is not
\r
276 * supported by this minimal implementation.
\r
278 * A stall is forced by setting the appropriate bit in the end points control
\r
279 * and status register.
\r
281 static void prvSendStall( void );
\r
284 * A NULL (or zero length packet) is transmitted in acknowledge the reception
\r
285 * of certain events from the host.
\r
287 static void prvUSBTransmitNull( void );
\r
290 * When the host requests a descriptor this function is called to determine
\r
291 * which descriptor is being requested and start its transmission.
\r
293 static void prvGetStandardInterfaceDescriptor( xUSB_REQUEST *pxRequest );
\r
296 * This demo USB device enumerates as a simple 3 axis joystick. Once
\r
297 * configured this function is periodically called to generate some sample
\r
300 * The x and y axis are made to move in a square. The z axis is made to
\r
301 * repeatedly increment up to its maximum.
\r
303 static void prvTransmitSampleValues( void );
\r
306 * The created task to handle the USB demo functionality.
\r
308 void vUSBDemoTask( void *pvParameters );
\r
310 /*-----------------------------------------------------------*/
\r
313 - DESCRIPTOR DEFINITIONS -
\r
316 /* String descriptors used during the enumeration process.
\r
317 These take the form:
\r
320 Length of descriptor,
\r
325 const portCHAR pxLanguageStringDescriptor[] =
\r
328 usbDESCRIPTOR_TYPE_STRING,
\r
332 const portCHAR pxManufacturerStringDescriptor[] =
\r
335 usbDESCRIPTOR_TYPE_STRING,
\r
347 const portCHAR pxProductStringDescriptor[] =
\r
350 usbDESCRIPTOR_TYPE_STRING,
\r
375 const portCHAR pxConfigurationStringDescriptor[] =
\r
378 usbDESCRIPTOR_TYPE_STRING,
\r
400 const portCHAR pxInterfaceStringDescriptor[] =
\r
403 usbDESCRIPTOR_TYPE_STRING,
\r
421 /* Enumeration descriptors. */
\r
422 const portCHAR pxReportDescriptor[] =
\r
424 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
\r
425 0x09, 0x04, /* USAGE (Joystick) */
\r
426 0xa1, 0x01, /* COLLECTION (Application) */
\r
427 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
\r
428 0x09, 0x01, /* USAGE (Pointer) */
\r
429 0xa1, 0x00, /* COLLECTION (Physical) */
\r
430 0x09, 0x30, /* USAGE (X) */
\r
431 0x09, 0x31, /* USAGE (Y) */
\r
432 0x09, 0x32, /* USAGE (Z) */
\r
433 0x15, 0x81, /* LOGICAL_MINIMUM (-127) */
\r
434 0x25, 0x7f, /* LOGICAL_MAXIMUM (127) */
\r
435 0x75, 0x08, /* REPORT_SIZE (8) */
\r
436 0x95, 0x03, /* REPORT_COUNT (3) */
\r
437 0x81, 0x02, /* INPUT (Data,Var,Abs) */
\r
438 0xc0, /* END_COLLECTION */
\r
439 0xc0 /* END_COLLECTION */
\r
442 const char pxDeviceDescriptor[] =
\r
444 /* Device descriptor */
\r
445 0x12, /* bLength */
\r
446 0x01, /* bDescriptorType */
\r
447 0x10, 0x01, /* bcdUSBL */
\r
448 usbDEVICE_CLASS_VENDOR_SPECIFIC, /* bDeviceClass: */
\r
449 0x00, /* bDeviceSubclass: */
\r
450 0x00, /* bDeviceProtocol: */
\r
451 0x08, /* bMaxPacketSize0 */
\r
452 0xFF, 0xFF, /* idVendorL */
\r
453 0x01, 0x00, /* idProductL */
\r
454 0x00, 0x01, /* bcdDeviceL */
\r
455 usbMANUFACTURER_STRING, /* iManufacturer */
\r
456 usbPRODUCT_STRING, /* iProduct */
\r
457 0x00, /* SerialNumber */
\r
458 0x01 /* bNumConfigs */
\r
461 const char pxConfigDescriptor[] = {
\r
462 /* Configuration 1 descriptor */
\r
463 0x09, /* CbLength */
\r
464 0x02, /* CbDescriptorType */
\r
465 0x22, 0x00, /* CwTotalLength 2 EP + Control */
\r
466 0x01, /* CbNumInterfaces */
\r
467 0x01, /* CbConfigurationValue */
\r
468 usbCONFIGURATION_STRING,/* CiConfiguration */
\r
469 usbBUS_POWERED, /* CbmAttributes Bus powered + Remote Wakeup*/
\r
470 0x32, /* CMaxPower: 100mA */
\r
472 /* Joystick Interface Descriptor Requirement */
\r
473 0x09, /* bLength */
\r
474 0x04, /* bDescriptorType */
\r
475 0x00, /* bInterfaceNumber */
\r
476 0x00, /* bAlternateSetting */
\r
477 0x01, /* bNumEndpoints */
\r
478 0x03, /* bInterfaceClass: HID code */
\r
479 0x00, /* bInterfaceSubclass */
\r
480 0x00, /* bInterfaceProtocol */
\r
481 usbINTERFACE_STRING,/* iInterface */
\r
483 /* HID Descriptor */
\r
484 0x09, /* bLength */
\r
485 0x21, /* bDescriptor type: HID Descriptor Type */
\r
486 0x00, 0x01, /* bcdHID */
\r
487 0x00, /* bCountryCode */
\r
488 0x01, /* bNumDescriptors */
\r
489 usbHID_REPORT_DESCRIPTOR, /* bDescriptorType */
\r
490 sizeof( pxReportDescriptor ), 0x00, /* wItemLength */
\r
492 /* Endpoint 1 descriptor */
\r
493 0x07, /* bLength */
\r
494 0x05, /* bDescriptorType */
\r
495 0x81, /* bEndpointAddress, Endpoint 01 - IN */
\r
496 0x03, /* bmAttributes INT */
\r
497 0x03, 0x00, /* wMaxPacketSize: 3 bytes (x, y, z) */
\r
498 0x0A /* bInterval */
\r
501 /*-----------------------------------------------------------*/
\r
503 /* File scope state variables. */
\r
504 static unsigned portCHAR ucUSBConfig = ( unsigned portCHAR ) 0;
\r
505 static unsigned portLONG ulReceivedAddress = ( unsigned portLONG ) 0;
\r
506 static eDRIVER_STATE eDriverState = eNOTHING;
\r
508 /* Array in which the USB interrupt status is passed between the ISR and task. */
\r
509 static xISRStatus xISRMessages[ usbQUEUE_LENGTH + 1 ];
\r
511 /* Structure used to control the characters being sent to the host. */
\r
512 static xTX_MESSAGE pxCharsForTx;
\r
514 /* Queue used to pass messages between the ISR and the task. */
\r
515 static xQueueHandle xUSBInterruptQueue;
\r
517 /* ISR entry has to be written in the asm file as we want a context switch
\r
518 to occur from within the ISR. See the port documentation on the FreeRTOS.org
\r
519 WEB site for more information. */
\r
520 extern void vUSBISREntry( void );
\r
522 /*-----------------------------------------------------------*/
\r
524 /* Macros to manipulate the control and status registers. These registers
\r
525 cannot be accessed using a direct read modify write operation outside of the
\r
526 ISR as some bits are left unchanged by writing with a 0, and some are left
\r
527 unchanged by writing with a 1. */
\r
529 #define usbINT_CLEAR_MASK (AT91C_UDP_TXCOMP | AT91C_UDP_STALLSENT | AT91C_UDP_RXSETUP | AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RX_DATA_BK1 )
\r
531 #define usbCSR_SET_BIT( pulValueNow, ulBit ) \
\r
533 /* Set TXCOMP, RX_DATA_BK0, RXSETUP, */ \
\r
534 /* STALLSENT and RX_DATA_BK1 to 1 so the */ \
\r
535 /* write has no effect. */ \
\r
536 ( * ( ( unsigned portLONG * ) pulValueNow ) ) |= ( unsigned portLONG ) 0x4f; \
\r
538 /* Clear the FORCE_STALL and TXPKTRDY bits */ \
\r
539 /* so the write has no effect. */ \
\r
540 ( * ( ( unsigned portLONG * ) pulValueNow ) ) &= ( unsigned portLONG ) 0xffffffcf; \
\r
542 /* Set whichever bit we want set. */ \
\r
543 ( * ( ( unsigned portLONG * ) pulValueNow ) ) |= ( ulBit ); \
\r
546 #define usbCSR_CLEAR_BIT( pulValueNow, ulBit ) \
\r
548 /* Set TXCOMP, RX_DATA_BK0, RXSETUP, */ \
\r
549 /* STALLSENT and RX_DATA_BK1 to 1 so the */ \
\r
550 /* write has no effect. */ \
\r
551 ( * ( ( unsigned portLONG * ) pulValueNow ) ) |= ( unsigned portLONG ) 0x4f; \
\r
553 /* Clear the FORCE_STALL and TXPKTRDY bits */ \
\r
554 /* so the write has no effect. */ \
\r
555 ( * ( ( unsigned portLONG * ) pulValueNow ) ) &= ( unsigned portLONG ) 0xffffffcf; \
\r
557 /* Clear whichever bit we want clear. */ \
\r
558 ( * ( ( unsigned portLONG * ) pulValueNow ) ) &= ( ~ulBit ); \
\r
561 /*-----------------------------------------------------------*/
\r
563 __arm void vUSB_ISR( void )
\r
565 portBASE_TYPE xTaskWokenByPost = pdFALSE;
\r
566 static volatile unsigned portLONG ulNextMessage = 0;
\r
567 xISRStatus *pxMessage;
\r
568 unsigned portLONG ulTemp, ulRxBytes;
\r
570 /* Take the next message from the queue. Note that usbQUEUE_LENGTH *must*
\r
571 be all 1's, as in 0x01, 0x03, 0x07, etc. */
\r
572 pxMessage = &( xISRMessages[ ( ulNextMessage & usbQUEUE_LENGTH ) ] );
\r
575 /* Take a snapshot of the current USB state for processing at the task
\r
577 pxMessage->ulISR = AT91C_BASE_UDP->UDP_ISR;
\r
578 pxMessage->ulCSR0 = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];
\r
580 /* Clear the interrupts from the ICR register. The bus end interrupt is
\r
581 cleared separately as it does not appear in the mask register. */
\r
582 AT91C_BASE_UDP->UDP_ICR = AT91C_BASE_UDP->UDP_IMR | AT91C_UDP_ENDBUSRES;
\r
584 /* If there are bytes in the FIFO then we have to retrieve them here.
\r
585 Ideally this would be done at the task level. However we need to clear the
\r
586 RXSETUP interrupt before leaving the ISR, and this may cause the data in
\r
587 the FIFO to be overwritten. Also the DIR bit has to be changed before the
\r
588 RXSETUP bit is cleared (as per the SAM7 manual). */
\r
589 ulTemp = pxMessage->ulCSR0;
\r
591 /* Are there any bytes in the FIFO? */
\r
592 ulRxBytes = ulTemp >> 16;
\r
593 ulRxBytes &= usbRX_COUNT_MASK;
\r
595 /* With this minimal implementation we are only interested in receiving
\r
596 setup bytes on the control end point. */
\r
597 if( ( ulRxBytes > 0 ) && ( ulTemp & AT91C_UDP_RXSETUP ) )
\r
599 /* Take off 1 for a zero based index. */
\r
600 while( ulRxBytes > 0 )
\r
603 pxMessage->ucFifoData[ ulRxBytes ] = AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_0 ];
\r
606 /* The direction must be changed first. */
\r
607 usbCSR_SET_BIT( &ulTemp, ( AT91C_UDP_DIR ) );
\r
608 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulTemp;
\r
611 /* Must write zero's to TXCOMP, STALLSENT, RXSETUP, and the RX DATA
\r
612 registers to clear the interrupts in the CSR register. */
\r
613 usbCSR_CLEAR_BIT( &ulTemp, usbINT_CLEAR_MASK );
\r
614 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulTemp;
\r
616 /* Also clear the interrupts in the CSR1 register. */
\r
617 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ];
\r
618 usbCSR_CLEAR_BIT( &ulTemp, usbINT_CLEAR_MASK );
\r
619 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] = ulTemp;
\r
621 /* The message now contains the entire state and optional data from
\r
622 the USB interrupt. This can now be posted on the Rx queue ready for
\r
623 processing at the task level. */
\r
624 xTaskWokenByPost = xQueueSendFromISR( xUSBInterruptQueue, &pxMessage, xTaskWokenByPost );
\r
626 /* We may want to switch to the USB task, if this message has made
\r
627 it the highest priority task that is ready to execute. */
\r
628 portEND_SWITCHING_ISR( xTaskWokenByPost );
\r
630 /* Clear the AIC ready for the next interrupt. */
\r
631 AT91C_BASE_AIC->AIC_EOICR = 0;
\r
633 /*-----------------------------------------------------------*/
\r
635 void vUSBDemoTask( void *pvParameters )
\r
637 xISRStatus *pxMessage;
\r
639 /* The parameters are not used in this task. */
\r
640 ( void ) pvParameters;
\r
642 /* Init USB device */
\r
643 portENTER_CRITICAL();
\r
644 vInitUSBInterface();
\r
645 portEXIT_CRITICAL();
\r
647 /* Process interrupts as they arrive. The ISR takes a snapshot of the
\r
648 interrupt status then posts the information on this queue for processing
\r
649 at the task level. This simple demo implementation only processes
\r
650 a few interrupt sources. */
\r
653 if( xQueueReceive( xUSBInterruptQueue, &pxMessage, usbSHORT_DELAY ) )
\r
655 if( pxMessage->ulISR & AT91C_UDP_EPINT0 )
\r
657 /* Process end point 0 interrupt. */
\r
658 prvProcessEndPoint0Interrupt( pxMessage );
\r
661 if( pxMessage->ulISR & AT91C_UDP_ENDBUSRES )
\r
663 /* Process an end of bus reset interrupt. */
\r
664 prvResetEndPoints();
\r
669 /* The ISR did not post any data for us to process on the queue, so
\r
670 just generate and send some sample data. */
\r
671 if( eDriverState == eREADY_TO_SEND )
\r
673 prvTransmitSampleValues();
\r
678 /*-----------------------------------------------------------*/
\r
680 static void prvTransmitSampleValues( void )
\r
682 unsigned portLONG ulStatus;
\r
683 static portLONG lState = usbXUP;
\r
685 /* Variables to hold dummy x, y and z joystick axis data. */
\r
686 static signed portCHAR x = 0, y = 0, z = 0;
\r
688 /* Generate some sample data in the x and y axis - draw a square. */
\r
691 case usbXUP : x += usbDATA_INC;
\r
692 if( x >= usbMAX_COORD )
\r
698 case usbXDOWN : x -= usbDATA_INC;
\r
699 if( x <= -usbMAX_COORD )
\r
705 case usbYUP : y += usbDATA_INC;
\r
706 if( y >= usbMAX_COORD )
\r
712 case usbYDOWN : y -= usbDATA_INC;
\r
713 if( y <= -usbMAX_COORD )
\r
720 /* Just make the z axis go up and down. */
\r
723 /* Can we place data in the fifo? */
\r
724 if( !( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] & AT91C_UDP_TXPKTRDY ) )
\r
726 /* Write our sample data to the fifo. */
\r
727 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_1 ] = x;
\r
728 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_1 ] = y;
\r
729 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_1 ] = z;
\r
731 /* Send the data. */
\r
732 portENTER_CRITICAL();
\r
734 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ];
\r
735 usbCSR_SET_BIT( &ulStatus, ( AT91C_UDP_TXPKTRDY ) );
\r
736 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] = ulStatus;
\r
738 portEXIT_CRITICAL();
\r
741 /*-----------------------------------------------------------*/
\r
743 static void prvUSBTransmitNull( void )
\r
745 unsigned portLONG ulStatus;
\r
747 /* Wait until the FIFO is free - even though we are not going to use it.
\r
748 THERE IS NO TIMEOUT HERE! */
\r
749 while( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] & AT91C_UDP_TXPKTRDY )
\r
751 vTaskDelay( usbSHORTEST_DELAY );
\r
754 portENTER_CRITICAL();
\r
756 /* Set the length of data to send to equal the index of the next byte
\r
757 to send. This will prevent the ACK to this NULL packet causing any
\r
758 further data transmissions. */
\r
759 pxCharsForTx.ulTotalDataLength = pxCharsForTx.ulNextCharIndex;
\r
761 /* Set the TXPKTRDY bit to cause a transmission with no data. */
\r
762 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];
\r
763 usbCSR_SET_BIT( &ulStatus, ( AT91C_UDP_TXPKTRDY ) );
\r
764 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;
\r
766 portEXIT_CRITICAL();
\r
768 /*-----------------------------------------------------------*/
\r
770 static void prvSendStall( void )
\r
772 unsigned portLONG ulStatus;
\r
774 portENTER_CRITICAL();
\r
776 /* Force a stall by simply setting the FORCESTALL bit in the CSR. */
\r
777 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];
\r
778 usbCSR_SET_BIT( &ulStatus, AT91C_UDP_FORCESTALL );
\r
779 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;
\r
781 portEXIT_CRITICAL();
\r
783 /*-----------------------------------------------------------*/
\r
785 static void prvResetEndPoints( void )
\r
787 unsigned portLONG ulTemp;
\r
789 eDriverState = eJUST_RESET;
\r
791 /* Reset all the end points. */
\r
792 AT91C_BASE_UDP->UDP_RSTEP = usbEND_POINT_RESET_MASK;
\r
793 AT91C_BASE_UDP->UDP_RSTEP = ( unsigned portLONG ) 0x00;
\r
795 /* Enable data to be sent and received. */
\r
796 AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
\r
798 /* Repair the configuration end point. */
\r
799 portENTER_CRITICAL();
\r
801 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];
\r
802 usbCSR_SET_BIT( &ulTemp, ( ( unsigned portLONG ) ( AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL ) ) );
\r
803 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulTemp;
\r
804 AT91F_UDP_EnableIt( AT91C_BASE_UDP, AT91C_UDP_EPINT0 );
\r
806 portEXIT_CRITICAL();
\r
808 /*-----------------------------------------------------------*/
\r
810 static void prvProcessEndPoint0Interrupt( xISRStatus *pxMessage )
\r
812 if( pxMessage->ulCSR0 & AT91C_UDP_RX_DATA_BK0 )
\r
814 /* We only expect to receive zero length data here as ACK's.
\r
815 Set the data pointer to the end of the current Tx packet to
\r
816 ensure we don't send out any more data. */
\r
817 pxCharsForTx.ulNextCharIndex = pxCharsForTx.ulTotalDataLength;
\r
820 if( pxMessage->ulCSR0 & AT91C_UDP_TXCOMP )
\r
822 /* We received a TX complete interrupt. What we do depends on
\r
823 what we sent to get this interrupt. */
\r
825 if( eDriverState == eJUST_GOT_CONFIG )
\r
827 /* We sent an acknowledgement of a SET_CONFIG request. We
\r
828 are now at the end of the enumeration. */
\r
829 AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_CONFG;
\r
831 /* Read the end point for data transfer. */
\r
832 portENTER_CRITICAL();
\r
834 unsigned portLONG ulTemp;
\r
836 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ];
\r
837 usbCSR_SET_BIT( &ulTemp, AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_INT_IN );
\r
838 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] = ulTemp;
\r
839 AT91F_UDP_EnableIt( AT91C_BASE_UDP, AT91C_UDP_EPINT1 );
\r
841 portEXIT_CRITICAL();
\r
843 eDriverState = eREADY_TO_SEND;
\r
845 else if( eDriverState == eJUST_GOT_ADDRESS )
\r
847 /* We sent an acknowledgement of a SET_ADDRESS request. Move
\r
848 to the addressed state. */
\r
849 if( ulReceivedAddress != ( unsigned portLONG ) 0 )
\r
851 AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
\r
855 AT91C_BASE_UDP->UDP_GLBSTATE = 0;
\r
858 AT91C_BASE_UDP->UDP_FADDR = ( AT91C_UDP_FEN | ulReceivedAddress );
\r
859 eDriverState = eNOTHING;
\r
863 /* The TXCOMP was not for any special type of transmission. See
\r
864 if there is any more data to send. */
\r
865 prvSendNextSegment();
\r
869 if( pxMessage->ulCSR0 & AT91C_UDP_RXSETUP )
\r
871 xUSB_REQUEST xRequest;
\r
872 unsigned portCHAR ucRequest;
\r
873 unsigned portLONG ulRxBytes;
\r
875 /* A data packet is available. */
\r
876 ulRxBytes = pxMessage->ulCSR0 >> 16;
\r
877 ulRxBytes &= usbRX_COUNT_MASK;
\r
879 if( ulRxBytes >= usbEXPECTED_NUMBER_OF_BYTES )
\r
881 /* Create an xUSB_REQUEST variable from the raw bytes array. */
\r
883 xRequest.ucReqType = pxMessage->ucFifoData[ usbREQUEST_TYPE_INDEX ];
\r
884 xRequest.ucRequest = pxMessage->ucFifoData[ usbREQUEST_INDEX ];
\r
886 /* NOT PORTABLE CODE! */
\r
887 xRequest.usValue = pxMessage->ucFifoData[ usbVALUE_HIGH_BYTE ];
\r
888 xRequest.usValue <<= 8;
\r
889 xRequest.usValue |= pxMessage->ucFifoData[ usbVALUE_LOW_BYTE ];
\r
891 xRequest.usIndex = pxMessage->ucFifoData[ usbINDEX_HIGH_BYTE ];
\r
892 xRequest.usIndex <<= 8;
\r
893 xRequest.usIndex |= pxMessage->ucFifoData[ usbINDEX_LOW_BYTE ];
\r
895 xRequest.usLength = pxMessage->ucFifoData[ usbLENGTH_HIGH_BYTE ];
\r
896 xRequest.usLength <<= 8;
\r
897 xRequest.usLength |= pxMessage->ucFifoData[ usbLENGTH_LOW_BYTE ];
\r
899 /* Manipulate the ucRequestType and the ucRequest parameters to
\r
900 generate a zero based request selection. This is just done to
\r
901 break up the requests into subsections for clarity. The
\r
902 alternative would be to have more huge switch statement that would
\r
903 be difficult to optimise. */
\r
904 ucRequest = ( ( xRequest.ucReqType & 0x60 ) >> 3 );
\r
905 ucRequest |= ( xRequest.ucReqType & 0x03 );
\r
907 switch( ucRequest )
\r
909 case usbSTANDARD_DEVICE_REQUEST:
\r
910 /* Standard Device request */
\r
911 prvHandleStandardDeviceRequest( &xRequest );
\r
914 case usbSTANDARD_INTERFACE_REQUEST:
\r
915 /* Standard Interface request */
\r
916 prvHandleStandardInterfaceRequest( &xRequest );
\r
919 case usbSTANDARD_END_POINT_REQUEST:
\r
920 /* Standard Endpoint request */
\r
921 prvHandleStandardEndPointRequest( &xRequest );
\r
924 case usbCLASS_INTERFACE_REQUEST:
\r
925 /* Class Interface request */
\r
926 prvHandleClassInterfaceRequest( &xRequest );
\r
929 default: /* This is not something we want to respond to. */
\r
935 /*-----------------------------------------------------------*/
\r
937 static void prvGetStandardDeviceDescriptor( xUSB_REQUEST *pxRequest )
\r
939 /* The type is in the high byte. Return whatever has been requested. */
\r
940 switch( ( pxRequest->usValue & 0xff00 ) >> 8 )
\r
942 case usbDESCRIPTOR_TYPE_DEVICE:
\r
943 prvSendControlData( ( unsigned portCHAR * ) &pxDeviceDescriptor, pxRequest->usLength, sizeof( pxDeviceDescriptor ), pdTRUE );
\r
946 case usbDESCRIPTOR_TYPE_CONFIGURATION:
\r
947 prvSendControlData( ( unsigned portCHAR * ) &( pxConfigDescriptor ), pxRequest->usLength, sizeof( pxConfigDescriptor ), pdTRUE );
\r
950 case usbDESCRIPTOR_TYPE_STRING:
\r
952 /* The index to the string descriptor is the lower byte. */
\r
953 switch( pxRequest->usValue & 0xff )
\r
955 case usbLANGUAGE_STRING:
\r
956 prvSendControlData( ( unsigned portCHAR * ) &pxLanguageStringDescriptor, pxRequest->usLength, sizeof(pxLanguageStringDescriptor), pdTRUE );
\r
959 case usbMANUFACTURER_STRING:
\r
960 prvSendControlData( ( unsigned portCHAR * ) &pxManufacturerStringDescriptor, pxRequest->usLength, sizeof( pxManufacturerStringDescriptor ), pdTRUE );
\r
963 case usbPRODUCT_STRING:
\r
964 prvSendControlData( ( unsigned portCHAR * ) &pxProductStringDescriptor, pxRequest->usLength, sizeof( pxProductStringDescriptor ), pdTRUE );
\r
967 case usbCONFIGURATION_STRING:
\r
968 prvSendControlData( ( unsigned portCHAR * ) &pxConfigurationStringDescriptor, pxRequest->usLength, sizeof( pxConfigurationStringDescriptor ), pdTRUE );
\r
971 case usbINTERFACE_STRING:
\r
972 prvSendControlData( ( unsigned portCHAR * ) &pxInterfaceStringDescriptor, pxRequest->usLength, sizeof( pxInterfaceStringDescriptor ), pdTRUE );
\r
976 /* Don't know what this string is. */
\r
984 /* We are not responding to anything else. */
\r
989 /*-----------------------------------------------------------*/
\r
991 static void prvHandleStandardDeviceRequest( xUSB_REQUEST *pxRequest )
\r
993 unsigned portSHORT usStatus = 0;
\r
995 switch( pxRequest->ucRequest )
\r
997 case usbGET_STATUS_REQUEST:
\r
998 /* Just send two byte dummy status. */
\r
999 prvSendControlData( ( unsigned portCHAR * ) &usStatus, sizeof( usStatus ), sizeof( usStatus ), pdFALSE );
\r
1002 case usbGET_DESCRIPTOR_REQUEST:
\r
1003 /* Send device descriptor */
\r
1004 prvGetStandardDeviceDescriptor( pxRequest );
\r
1007 case usbGET_CONFIGURATION_REQUEST:
\r
1008 /* Send selected device configuration */
\r
1009 prvSendControlData( ( unsigned portCHAR * ) &ucUSBConfig, sizeof( ucUSBConfig ), sizeof( ucUSBConfig ), pdFALSE );
\r
1012 case usbSET_FEATURE_REQUEST:
\r
1013 prvUSBTransmitNull();
\r
1016 case usbSET_ADDRESS_REQUEST:
\r
1018 /* Acknowledge the SET_ADDRESS, but (according to the manual) we
\r
1019 cannot actually move to the addressed state until we get a TXCOMP
\r
1020 interrupt from this NULL packet. Therefore we just remember the
\r
1021 address and set our state so we know we have received the address. */
\r
1022 prvUSBTransmitNull();
\r
1023 eDriverState = eJUST_GOT_ADDRESS;
\r
1024 ulReceivedAddress = ( unsigned portLONG ) pxRequest->usValue;
\r
1027 case usbSET_CONFIGURATION_REQUEST:
\r
1029 /* Acknowledge the SET_CONFIGURATION, but (according to the manual)
\r
1030 we cannot actually move to the configured state until we get a
\r
1031 TXCOMP interrupt from this NULL packet. Therefore we just remember the
\r
1032 config and set our state so we know we have received the go ahead. */
\r
1033 ucUSBConfig = ( unsigned portCHAR ) ( pxRequest->usValue & 0xff );
\r
1034 eDriverState = eJUST_GOT_CONFIG;
\r
1035 prvUSBTransmitNull();
\r
1040 /* We don't answer to anything else. */
\r
1045 /*-----------------------------------------------------------*/
\r
1047 static void prvHandleClassInterfaceRequest( xUSB_REQUEST *pxRequest )
\r
1049 switch( pxRequest->ucRequest )
\r
1051 case usbSET_IDLE_REQUEST:
\r
1052 prvUSBTransmitNull();
\r
1055 /* This minimal implementation ignores these. */
\r
1056 case usbGET_REPORT_REQUEST:
\r
1057 case usbGET_IDLE_REQUEST:
\r
1058 case usbGET_PROTOCOL_REQUEST:
\r
1059 case usbSET_REPORT_REQUEST:
\r
1060 case usbSET_PROTOCOL_REQUEST:
\r
1067 /*-----------------------------------------------------------*/
\r
1069 static void prvGetStandardInterfaceDescriptor( xUSB_REQUEST *pxRequest )
\r
1071 switch( ( pxRequest->usValue & ( unsigned portSHORT ) 0xff00 ) >> 8 )
\r
1073 case usbHID_REPORT_DESCRIPTOR:
\r
1074 prvSendControlData( ( unsigned portCHAR * ) pxReportDescriptor, pxRequest->usLength, sizeof( pxReportDescriptor ), pdTRUE );
\r
1079 /* Don't expect to send any others. */
\r
1084 /*-----------------------------------------------------------*/
\r
1086 static void prvHandleStandardInterfaceRequest( xUSB_REQUEST *pxRequest )
\r
1088 unsigned portSHORT usStatus = 0;
\r
1090 switch( pxRequest->ucRequest )
\r
1092 case usbGET_STATUS_REQUEST:
\r
1093 /* Send dummy 2 bytes. */
\r
1094 prvSendControlData( ( unsigned portCHAR * ) &usStatus, sizeof( usStatus ), sizeof( usStatus ), pdFALSE );
\r
1097 case usbGET_DESCRIPTOR_REQUEST:
\r
1098 prvGetStandardInterfaceDescriptor( pxRequest );
\r
1101 /* This minimal implementation does not respond to these. */
\r
1102 case usbGET_INTERFACE_REQUEST:
\r
1103 case usbSET_FEATURE_REQUEST:
\r
1104 case usbSET_INTERFACE_REQUEST:
\r
1111 /*-----------------------------------------------------------*/
\r
1113 static void prvHandleStandardEndPointRequest( xUSB_REQUEST *pxRequest )
\r
1115 switch( pxRequest->ucRequest )
\r
1117 /* This minimal implementation does not expect to respond to these. */
\r
1118 case usbGET_STATUS_REQUEST:
\r
1119 case usbCLEAR_FEATURE_REQUEST:
\r
1120 case usbSET_FEATURE_REQUEST:
\r
1127 /*-----------------------------------------------------------*/
\r
1129 static void vInitUSBInterface( void )
\r
1131 volatile unsigned portLONG ulTemp;
\r
1133 /* Create the queue used to communicate between the USB ISR and task. */
\r
1134 xUSBInterruptQueue = xQueueCreate( usbQUEUE_LENGTH + 1, sizeof( xISRStatus * ) );
\r
1136 /* Initialise a few state variables. */
\r
1137 pxCharsForTx.ulNextCharIndex = ( unsigned portLONG ) 0;
\r
1138 ucUSBConfig = ( unsigned portCHAR ) 0;
\r
1139 eDriverState = eNOTHING;
\r
1141 /* HARDWARE SETUP */
\r
1143 /* Set the PLL USB Divider */
\r
1144 AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1;
\r
1146 /* Enables the 48MHz USB clock UDPCK and System Peripheral USB Clock. */
\r
1147 AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_UDP;
\r
1148 AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_UDP);
\r
1150 /* Setup the PIO for the USB pull up resistor. */
\r
1151 AT91F_PIO_CfgOutput(AT91C_BASE_PIOA,AT91C_PIO_PA16);
\r
1153 /* Start without the pullup - this will get set at the end of this
\r
1155 AT91F_PIO_SetOutput( AT91C_BASE_PIOA, AT91C_PIO_PA16 );
\r
1157 /* When using the USB debugger the peripheral registers do not always get
\r
1158 set to the correct default values. To make sure set the relevant registers
\r
1160 AT91C_BASE_UDP->UDP_IDR = ( unsigned portLONG ) 0xffffffff;
\r
1161 AT91C_BASE_UDP->UDP_ICR = ( unsigned portLONG ) 0xffffffff;
\r
1162 AT91C_BASE_UDP->UDP_CSR[ 0 ] = ( unsigned portLONG ) 0x00;
\r
1163 AT91C_BASE_UDP->UDP_CSR[ 1 ] = ( unsigned portLONG ) 0x00;
\r
1164 AT91C_BASE_UDP->UDP_GLBSTATE = 0;
\r
1165 AT91C_BASE_UDP->UDP_FADDR = 0;
\r
1167 /* Enable the transceiver. */
\r
1168 AT91C_UDP_TRANSCEIVER_ENABLE = 0;
\r
1170 /* Enable the USB interrupts - other interrupts get enabled as the
\r
1171 enumeration process progresses. */
\r
1172 AT91F_AIC_ConfigureIt( AT91C_BASE_AIC, AT91C_ID_UDP, usbINTERRUPT_PRIORITY, AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE, ( void (*)( void ) ) vUSBISREntry );
\r
1173 AT91F_AIC_EnableIt( AT91C_BASE_AIC, AT91C_ID_UDP );
\r
1175 /* Wait a short while before making our presence known. */
\r
1176 vTaskDelay( usbINIT_DELAY );
\r
1177 AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, AT91C_PIO_PA16 );
\r
1179 /*-----------------------------------------------------------*/
\r
1181 static void prvSendControlData( unsigned portCHAR *pucData, unsigned portSHORT usRequestedLength, unsigned portLONG ulLengthToSend, portLONG lSendingDescriptor )
\r
1183 if( ( ( unsigned portLONG ) usRequestedLength < ulLengthToSend ) )
\r
1185 /* Cap the data length to that requested. */
\r
1186 ulLengthToSend = ( unsigned portSHORT ) usRequestedLength;
\r
1188 else if( ( ulLengthToSend < ( unsigned portLONG ) usRequestedLength ) && lSendingDescriptor )
\r
1190 /* We are sending a descriptor. If the descriptor is an exact
\r
1191 multiple of the FIFO length then it will have to be terminated
\r
1192 with a NULL packet. Set the state to indicate this if
\r
1194 if( ( ulLengthToSend % usbFIFO_LENGTH ) == 0 )
\r
1196 eDriverState = eSENDING_EVEN_DESCRIPTOR;
\r
1200 /* Here we assume that the previous message has been sent. THERE IS NO
\r
1201 BUFFER OVERFLOW PROTECTION HERE.
\r
1203 Copy the data to send into the buffer as we cannot send it all at once
\r
1204 (if it is greater than 8 bytes in length). */
\r
1205 memcpy( pxCharsForTx.ucTxBuffer, pucData, ulLengthToSend );
\r
1207 /* Reinitialise the buffer index so we start sending from the start of
\r
1209 pxCharsForTx.ulTotalDataLength = ulLengthToSend;
\r
1210 pxCharsForTx.ulNextCharIndex = ( unsigned portLONG ) 0;
\r
1212 /* Send the first 8 bytes now. The rest will get sent in response to
\r
1213 TXCOMP interrupts. */
\r
1214 prvSendNextSegment();
\r
1216 /*-----------------------------------------------------------*/
\r
1218 static void prvSendNextSegment( void )
\r
1220 volatile unsigned portLONG ulNextLength, ulStatus, ulLengthLeftToSend;
\r
1222 /* Is there any data to send? */
\r
1223 if( pxCharsForTx.ulTotalDataLength > pxCharsForTx.ulNextCharIndex )
\r
1225 ulLengthLeftToSend = pxCharsForTx.ulTotalDataLength - pxCharsForTx.ulNextCharIndex;
\r
1227 /* We can only send 8 bytes to the fifo at a time. */
\r
1228 if( ulLengthLeftToSend > usbFIFO_LENGTH )
\r
1230 ulNextLength = usbFIFO_LENGTH;
\r
1234 ulNextLength = ulLengthLeftToSend;
\r
1237 /* Wait until we can place data in the fifo. THERE IS NO TIMEOUT
\r
1239 while( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] & AT91C_UDP_TXPKTRDY )
\r
1241 vTaskDelay( usbSHORTEST_DELAY );
\r
1244 /* Write the data to the FIFO. */
\r
1245 while( ulNextLength > ( unsigned portLONG ) 0 )
\r
1247 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_0 ] = pxCharsForTx.ucTxBuffer[ pxCharsForTx.ulNextCharIndex ];
\r
1250 pxCharsForTx.ulNextCharIndex++;
\r
1253 /* Start the transmission. */
\r
1254 portENTER_CRITICAL();
\r
1256 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];
\r
1257 usbCSR_SET_BIT( &ulStatus, ( ( unsigned portLONG ) 0x10 ) );
\r
1258 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;
\r
1260 portEXIT_CRITICAL();
\r
1264 /* There is no data to send. If we were sending a descriptor and the
\r
1265 descriptor was an exact multiple of the max packet size then we need
\r
1266 to send a null to terminate the transmission. */
\r
1267 if( eDriverState == eSENDING_EVEN_DESCRIPTOR )
\r
1269 prvUSBTransmitNull();
\r
1270 eDriverState = eNOTHING;
\r