2 FreeRTOS V7.1.1 - Copyright (C) 2012 Real Time Engineers Ltd.
\r
5 ***************************************************************************
\r
7 * FreeRTOS tutorial books are available in pdf and paperback. *
\r
8 * Complete, revised, and edited pdf reference manuals are also *
\r
11 * Purchasing FreeRTOS documentation will not only help you, by *
\r
12 * ensuring you get running as quickly as possible and with an *
\r
13 * in-depth knowledge of how to use FreeRTOS, it will also help *
\r
14 * the FreeRTOS project to continue with its mission of providing *
\r
15 * professional grade, cross platform, de facto standard solutions *
\r
16 * for microcontrollers - completely free of charge! *
\r
18 * >>> See http://www.FreeRTOS.org/Documentation for details. <<< *
\r
20 * Thank you for using FreeRTOS, and thank you for your support! *
\r
22 ***************************************************************************
\r
25 This file is part of the FreeRTOS distribution.
\r
27 FreeRTOS is free software; you can redistribute it and/or modify it under
\r
28 the terms of the GNU General Public License (version 2) as published by the
\r
29 Free Software Foundation AND MODIFIED BY the FreeRTOS exception.
\r
30 >>>NOTE<<< The modification to the GPL is included to allow you to
\r
31 distribute a combined work that includes FreeRTOS without being obliged to
\r
32 provide the source code for proprietary components outside of the FreeRTOS
\r
33 kernel. FreeRTOS is distributed in the hope that it will be useful, but
\r
34 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
\r
35 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
\r
36 more details. You should have received a copy of the GNU General Public
\r
37 License and the FreeRTOS license exception along with FreeRTOS; if not it
\r
38 can be viewed here: http://www.freertos.org/a00114.html and also obtained
\r
39 by writing to Richard Barry, contact details for whom are available on the
\r
44 ***************************************************************************
\r
46 * Having a problem? Start by reading the FAQ "My application does *
\r
47 * not run, what could be wrong? *
\r
49 * http://www.FreeRTOS.org/FAQHelp.html *
\r
51 ***************************************************************************
\r
54 http://www.FreeRTOS.org - Documentation, training, latest information,
\r
55 license and contact details.
\r
57 http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
\r
58 including FreeRTOS+Trace - an indispensable productivity tool.
\r
60 Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell
\r
61 the code with commercial support, indemnification, and middleware, under
\r
62 the OpenRTOS brand: http://www.OpenRTOS.com. High Integrity Systems also
\r
63 provide a safety engineered and independently SIL3 certified version under
\r
64 the SafeRTOS brand: http://www.SafeRTOS.com.
\r
68 Sample interrupt driven USB device driver. This is a minimal implementation
\r
69 for demonstration only. Although functional, it is not a full and compliant
\r
72 The USB device enumerates as a simple 3 axis joystick, and once configured
\r
73 transmits 3 axis of data which can be viewed from the USB host machine.
\r
75 This file implements the USB interrupt service routine, and a demo FreeRTOS
\r
76 task. The interrupt service routine handles the USB hardware - taking a
\r
77 snapshot of the USB status at the point of the interrupt. The task receives
\r
78 the status information from the interrupt for processing at the task level.
\r
80 See the FreeRTOS.org WEB documentation for more information.
\r
86 + Descriptors that have a length that is an exact multiple of usbFIFO_LENGTH
\r
87 can now be transmitted. To this end an extra parameter has been
\r
88 added to the prvSendControlData() function, and the state
\r
89 eSENDING_EVEN_DESCRIPTOR has been introduced. Thanks to Scott Miller for
\r
90 assisting with this contribution.
\r
94 + Replaced the duplicated RX_DATA_BK0 in the interrupt mask with the
\r
98 /* Standard includes. */
\r
101 /* Demo board includes. */
\r
104 /* Scheduler includes. */
\r
105 #include "FreeRTOS.h"
\r
110 /* Descriptor type definitions. */
\r
111 #define usbDESCRIPTOR_TYPE_DEVICE ( 0x01 )
\r
112 #define usbDESCRIPTOR_TYPE_CONFIGURATION ( 0x02 )
\r
113 #define usbDESCRIPTOR_TYPE_STRING ( 0x03 )
\r
115 /* USB request type definitions. */
\r
116 #define usbGET_REPORT_REQUEST ( 0x01 )
\r
117 #define usbGET_IDLE_REQUEST ( 0x02 )
\r
118 #define usbGET_PROTOCOL_REQUEST ( 0x03 )
\r
119 #define usbSET_REPORT_REQUEST ( 0x09 )
\r
120 #define usbSET_IDLE_REQUEST ( 0x0A )
\r
121 #define usbSET_PROTOCOL_REQUEST ( 0x0B )
\r
122 #define usbGET_CONFIGURATION_REQUEST ( 0x08 )
\r
123 #define usbGET_STATUS_REQUEST ( 0x00 )
\r
124 #define usbCLEAR_FEATURE_REQUEST ( 0x01 )
\r
125 #define usbSET_FEATURE_REQUEST ( 0x03 )
\r
126 #define usbSET_ADDRESS_REQUEST ( 0x05 )
\r
127 #define usbGET_DESCRIPTOR_REQUEST ( 0x06 )
\r
128 #define usbSET_CONFIGURATION_REQUEST ( 0x09 )
\r
129 #define usbGET_INTERFACE_REQUEST ( 0x0A )
\r
130 #define usbSET_INTERFACE_REQUEST ( 0x0B )
\r
133 /* Misc USB definitions. */
\r
134 #define usbDEVICE_CLASS_VENDOR_SPECIFIC ( 0xFF )
\r
135 #define usbBUS_POWERED ( 0x80 )
\r
136 #define usbHID_REPORT_DESCRIPTOR ( 0x22 )
\r
137 #define AT91C_UDP_TRANSCEIVER_ENABLE ( *( ( unsigned long * ) 0xfffb0074 ) )
\r
139 /* Index to the various string. */
\r
140 #define usbLANGUAGE_STRING ( 0 )
\r
141 #define usbMANUFACTURER_STRING ( 1 )
\r
142 #define usbPRODUCT_STRING ( 2 )
\r
143 #define usbCONFIGURATION_STRING ( 3 )
\r
144 #define usbINTERFACE_STRING ( 4 )
\r
146 /* Data indexes for reading the request from the xISRStatus.ucFifoData[]
\r
147 into xUSB_REQUEST. The data order is designed for speed - so looks a
\r
149 #define usbREQUEST_TYPE_INDEX ( 7 )
\r
150 #define usbREQUEST_INDEX ( 6 )
\r
151 #define usbVALUE_HIGH_BYTE ( 4 )
\r
152 #define usbVALUE_LOW_BYTE ( 5 )
\r
153 #define usbINDEX_HIGH_BYTE ( 2 )
\r
154 #define usbINDEX_LOW_BYTE ( 3 )
\r
155 #define usbLENGTH_HIGH_BYTE ( 0 )
\r
156 #define usbLENGTH_LOW_BYTE ( 1 )
\r
158 /* Misc application definitions. */
\r
159 #define usbINTERRUPT_PRIORITY ( 3 )
\r
160 #define usbQUEUE_LENGTH ( 0x3 ) /* Must have all bits set! */
\r
161 #define usbFIFO_LENGTH ( ( unsigned long ) 8 )
\r
162 #define usbEND_POINT_0 ( 0 )
\r
163 #define usbEND_POINT_1 ( 1 )
\r
164 #define usbXUP ( 1 )
\r
165 #define usbXDOWN ( 2 )
\r
166 #define usbYUP ( 3 )
\r
167 #define usbYDOWN ( 4 )
\r
168 #define usbMAX_COORD ( 120 )
\r
169 #define usbMAX_TX_MESSAGE_SIZE ( 128 )
\r
170 #define usbRX_COUNT_MASK ( ( unsigned long ) 0x7ff )
\r
171 #define AT91C_UDP_STALLSENT AT91C_UDP_ISOERROR
\r
172 #define usbSHORTEST_DELAY ( ( portTickType ) 1 )
\r
173 #define usbINIT_DELAY ( ( portTickType ) 500 / portTICK_RATE_MS )
\r
174 #define usbSHORT_DELAY ( ( portTickType ) 50 / portTICK_RATE_MS )
\r
175 #define usbEND_POINT_RESET_MASK ( ( unsigned long ) 0x0f )
\r
176 #define usbDATA_INC ( ( char ) 5 )
\r
177 #define usbEXPECTED_NUMBER_OF_BYTES ( ( unsigned long ) 8 )
\r
179 /* Control request types. */
\r
180 #define usbSTANDARD_DEVICE_REQUEST ( 0 )
\r
181 #define usbSTANDARD_INTERFACE_REQUEST ( 1 )
\r
182 #define usbSTANDARD_END_POINT_REQUEST ( 2 )
\r
183 #define usbCLASS_INTERFACE_REQUEST ( 5 )
\r
185 /*-----------------------------------------------------------*/
\r
187 /* Structure used to take a snapshot of the USB status from within the ISR. */
\r
188 typedef struct X_ISR_STATUS
\r
190 unsigned long ulISR;
\r
191 unsigned long ulCSR0;
\r
192 unsigned char ucFifoData[ 8 ];
\r
195 /* Structure used to hold the received requests. */
\r
198 unsigned char ucReqType;
\r
199 unsigned char ucRequest;
\r
200 unsigned short usValue;
\r
201 unsigned short usIndex;
\r
202 unsigned short usLength;
\r
211 eSENDING_EVEN_DESCRIPTOR,
\r
215 /* Structure used to control the data being sent to the host. */
\r
218 unsigned char ucTxBuffer[ usbMAX_TX_MESSAGE_SIZE ];
\r
219 unsigned long ulNextCharIndex;
\r
220 unsigned long ulTotalDataLength;
\r
223 /*-----------------------------------------------------------*/
\r
226 * The USB interrupt service routine. This takes a snapshot of the USB
\r
227 * device at the time of the interrupt, clears the interrupts, and posts
\r
228 * the data to the USB processing task.
\r
230 __arm void vUSB_ISR( void );
\r
233 * Called after the bus reset interrupt - this function readies all the
\r
234 * end points for communication.
\r
236 static void prvResetEndPoints( void );
\r
239 * Setup the USB hardware, install the interrupt service routine and
\r
240 * initialise all the state variables.
\r
242 static void vInitUSBInterface( void );
\r
245 * Decode and act upon an interrupt generated by the control end point.
\r
247 static void prvProcessEndPoint0Interrupt( xISRStatus *pxMessage );
\r
250 * For simplicity requests are separated into device, interface, class
\r
251 * interface and end point requests.
\r
253 * Decode and handle standard device requests originating on the control
\r
256 static void prvHandleStandardDeviceRequest( xUSB_REQUEST *pxRequest );
\r
259 * For simplicity requests are separated into device, interface, class
\r
260 * interface and end point requests.
\r
262 * Decode and handle standard interface requests originating on the control
\r
265 static void prvHandleStandardInterfaceRequest( xUSB_REQUEST *pxRequest );
\r
268 * For simplicity requests are separated into device, interface, class
\r
269 * interface and end point requests.
\r
271 * Decode and handle standard end point requests originating on the control
\r
274 static void prvHandleStandardEndPointRequest( xUSB_REQUEST *pxRequest );
\r
277 * For simplicity requests are separated into device, interface, class
\r
278 * interface and end point requests.
\r
280 * Decode and handle the class interface requests.
\r
282 static void prvHandleClassInterfaceRequest( xUSB_REQUEST *pxRequest );
\r
285 * Setup the Tx buffer to send data in response to a control request.
\r
287 * The data to be transmitted is buffered, the state variables are updated,
\r
288 * then prvSendNextSegment() is called to start the transmission off. Once
\r
289 * the first segment has been sent the remaining segments are transmitted
\r
290 * in response to TXCOMP interrupts until the entire buffer has been
\r
293 static void prvSendControlData( unsigned char *pucData, unsigned short usRequestedLength, unsigned long ulLengthLeftToSend, long lSendingDescriptor );
\r
296 * Examine the Tx buffer to see if there is any more data to be transmitted.
\r
298 * If there is data to be transmitted then send the next segment. A segment
\r
299 * can have a maximum of 8 bytes (this is defined as the maximum for the end
\r
300 * point by the descriptor). The final segment may be less than 8 bytes if
\r
301 * the total data length was not an exact multiple of 8.
\r
303 static void prvSendNextSegment( void );
\r
306 * A stall condition is forced each time the host makes a request that is not
\r
307 * supported by this minimal implementation.
\r
309 * A stall is forced by setting the appropriate bit in the end points control
\r
310 * and status register.
\r
312 static void prvSendStall( void );
\r
315 * A NULL (or zero length packet) is transmitted in acknowledge the reception
\r
316 * of certain events from the host.
\r
318 static void prvUSBTransmitNull( void );
\r
321 * When the host requests a descriptor this function is called to determine
\r
322 * which descriptor is being requested and start its transmission.
\r
324 static void prvGetStandardInterfaceDescriptor( xUSB_REQUEST *pxRequest );
\r
327 * This demo USB device enumerates as a simple 3 axis joystick. Once
\r
328 * configured this function is periodically called to generate some sample
\r
331 * The x and y axis are made to move in a square. The z axis is made to
\r
332 * repeatedly increment up to its maximum.
\r
334 static void prvTransmitSampleValues( void );
\r
337 * The created task to handle the USB demo functionality.
\r
339 void vUSBDemoTask( void *pvParameters );
\r
341 /*-----------------------------------------------------------*/
\r
344 - DESCRIPTOR DEFINITIONS -
\r
347 /* String descriptors used during the enumeration process.
\r
348 These take the form:
\r
351 Length of descriptor,
\r
356 const char pxLanguageStringDescriptor[] =
\r
359 usbDESCRIPTOR_TYPE_STRING,
\r
363 const char pxManufacturerStringDescriptor[] =
\r
366 usbDESCRIPTOR_TYPE_STRING,
\r
378 const char pxProductStringDescriptor[] =
\r
381 usbDESCRIPTOR_TYPE_STRING,
\r
406 const char pxConfigurationStringDescriptor[] =
\r
409 usbDESCRIPTOR_TYPE_STRING,
\r
431 const char pxInterfaceStringDescriptor[] =
\r
434 usbDESCRIPTOR_TYPE_STRING,
\r
452 /* Enumeration descriptors. */
\r
453 const char pxReportDescriptor[] =
\r
455 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
\r
456 0x09, 0x04, /* USAGE (Joystick) */
\r
457 0xa1, 0x01, /* COLLECTION (Application) */
\r
458 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
\r
459 0x09, 0x01, /* USAGE (Pointer) */
\r
460 0xa1, 0x00, /* COLLECTION (Physical) */
\r
461 0x09, 0x30, /* USAGE (X) */
\r
462 0x09, 0x31, /* USAGE (Y) */
\r
463 0x09, 0x32, /* USAGE (Z) */
\r
464 0x15, 0x81, /* LOGICAL_MINIMUM (-127) */
\r
465 0x25, 0x7f, /* LOGICAL_MAXIMUM (127) */
\r
466 0x75, 0x08, /* REPORT_SIZE (8) */
\r
467 0x95, 0x03, /* REPORT_COUNT (3) */
\r
468 0x81, 0x02, /* INPUT (Data,Var,Abs) */
\r
469 0xc0, /* END_COLLECTION */
\r
470 0xc0 /* END_COLLECTION */
\r
473 const char pxDeviceDescriptor[] =
\r
475 /* Device descriptor */
\r
476 0x12, /* bLength */
\r
477 0x01, /* bDescriptorType */
\r
478 0x10, 0x01, /* bcdUSBL */
\r
479 usbDEVICE_CLASS_VENDOR_SPECIFIC, /* bDeviceClass: */
\r
480 0x00, /* bDeviceSubclass: */
\r
481 0x00, /* bDeviceProtocol: */
\r
482 0x08, /* bMaxPacketSize0 */
\r
483 0xFF, 0xFF, /* idVendorL */
\r
484 0x01, 0x00, /* idProductL */
\r
485 0x00, 0x01, /* bcdDeviceL */
\r
486 usbMANUFACTURER_STRING, /* iManufacturer */
\r
487 usbPRODUCT_STRING, /* iProduct */
\r
488 0x00, /* SerialNumber */
\r
489 0x01 /* bNumConfigs */
\r
492 const char pxConfigDescriptor[] = {
\r
493 /* Configuration 1 descriptor */
\r
494 0x09, /* CbLength */
\r
495 0x02, /* CbDescriptorType */
\r
496 0x22, 0x00, /* CwTotalLength 2 EP + Control */
\r
497 0x01, /* CbNumInterfaces */
\r
498 0x01, /* CbConfigurationValue */
\r
499 usbCONFIGURATION_STRING,/* CiConfiguration */
\r
500 usbBUS_POWERED, /* CbmAttributes Bus powered + Remote Wakeup*/
\r
501 0x32, /* CMaxPower: 100mA */
\r
503 /* Joystick Interface Descriptor Requirement */
\r
504 0x09, /* bLength */
\r
505 0x04, /* bDescriptorType */
\r
506 0x00, /* bInterfaceNumber */
\r
507 0x00, /* bAlternateSetting */
\r
508 0x01, /* bNumEndpoints */
\r
509 0x03, /* bInterfaceClass: HID code */
\r
510 0x00, /* bInterfaceSubclass */
\r
511 0x00, /* bInterfaceProtocol */
\r
512 usbINTERFACE_STRING,/* iInterface */
\r
514 /* HID Descriptor */
\r
515 0x09, /* bLength */
\r
516 0x21, /* bDescriptor type: HID Descriptor Type */
\r
517 0x00, 0x01, /* bcdHID */
\r
518 0x00, /* bCountryCode */
\r
519 0x01, /* bNumDescriptors */
\r
520 usbHID_REPORT_DESCRIPTOR, /* bDescriptorType */
\r
521 sizeof( pxReportDescriptor ), 0x00, /* wItemLength */
\r
523 /* Endpoint 1 descriptor */
\r
524 0x07, /* bLength */
\r
525 0x05, /* bDescriptorType */
\r
526 0x81, /* bEndpointAddress, Endpoint 01 - IN */
\r
527 0x03, /* bmAttributes INT */
\r
528 0x03, 0x00, /* wMaxPacketSize: 3 bytes (x, y, z) */
\r
529 0x0A /* bInterval */
\r
532 /*-----------------------------------------------------------*/
\r
534 /* File scope state variables. */
\r
535 static unsigned char ucUSBConfig = ( unsigned char ) 0;
\r
536 static unsigned long ulReceivedAddress = ( unsigned long ) 0;
\r
537 static eDRIVER_STATE eDriverState = eNOTHING;
\r
539 /* Array in which the USB interrupt status is passed between the ISR and task. */
\r
540 static xISRStatus xISRMessages[ usbQUEUE_LENGTH + 1 ];
\r
542 /* Structure used to control the characters being sent to the host. */
\r
543 static xTX_MESSAGE pxCharsForTx;
\r
545 /* Queue used to pass messages between the ISR and the task. */
\r
546 static xQueueHandle xUSBInterruptQueue;
\r
548 /* ISR entry has to be written in the asm file as we want a context switch
\r
549 to occur from within the ISR. See the port documentation on the FreeRTOS.org
\r
550 WEB site for more information. */
\r
551 extern void vUSBISREntry( void );
\r
553 /*-----------------------------------------------------------*/
\r
555 /* Macros to manipulate the control and status registers. These registers
\r
556 cannot be accessed using a direct read modify write operation outside of the
\r
557 ISR as some bits are left unchanged by writing with a 0, and some are left
\r
558 unchanged by writing with a 1. */
\r
560 #define usbINT_CLEAR_MASK (AT91C_UDP_TXCOMP | AT91C_UDP_STALLSENT | AT91C_UDP_RXSETUP | AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RX_DATA_BK1 )
\r
562 #define usbCSR_SET_BIT( pulValueNow, ulBit ) \
\r
564 /* Set TXCOMP, RX_DATA_BK0, RXSETUP, */ \
\r
565 /* STALLSENT and RX_DATA_BK1 to 1 so the */ \
\r
566 /* write has no effect. */ \
\r
567 ( * ( ( unsigned long * ) pulValueNow ) ) |= ( unsigned long ) 0x4f; \
\r
569 /* Clear the FORCE_STALL and TXPKTRDY bits */ \
\r
570 /* so the write has no effect. */ \
\r
571 ( * ( ( unsigned long * ) pulValueNow ) ) &= ( unsigned long ) 0xffffffcf; \
\r
573 /* Set whichever bit we want set. */ \
\r
574 ( * ( ( unsigned long * ) pulValueNow ) ) |= ( ulBit ); \
\r
577 #define usbCSR_CLEAR_BIT( pulValueNow, ulBit ) \
\r
579 /* Set TXCOMP, RX_DATA_BK0, RXSETUP, */ \
\r
580 /* STALLSENT and RX_DATA_BK1 to 1 so the */ \
\r
581 /* write has no effect. */ \
\r
582 ( * ( ( unsigned long * ) pulValueNow ) ) |= ( unsigned long ) 0x4f; \
\r
584 /* Clear the FORCE_STALL and TXPKTRDY bits */ \
\r
585 /* so the write has no effect. */ \
\r
586 ( * ( ( unsigned long * ) pulValueNow ) ) &= ( unsigned long ) 0xffffffcf; \
\r
588 /* Clear whichever bit we want clear. */ \
\r
589 ( * ( ( unsigned long * ) pulValueNow ) ) &= ( ~ulBit ); \
\r
592 /*-----------------------------------------------------------*/
\r
594 __arm void vUSB_ISR( void )
\r
596 portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
\r
597 static volatile unsigned long ulNextMessage = 0;
\r
598 xISRStatus *pxMessage;
\r
599 unsigned long ulTemp, ulRxBytes;
\r
601 /* Take the next message from the queue. Note that usbQUEUE_LENGTH *must*
\r
602 be all 1's, as in 0x01, 0x03, 0x07, etc. */
\r
603 pxMessage = &( xISRMessages[ ( ulNextMessage & usbQUEUE_LENGTH ) ] );
\r
606 /* Take a snapshot of the current USB state for processing at the task
\r
608 pxMessage->ulISR = AT91C_BASE_UDP->UDP_ISR;
\r
609 pxMessage->ulCSR0 = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];
\r
611 /* Clear the interrupts from the ICR register. The bus end interrupt is
\r
612 cleared separately as it does not appear in the mask register. */
\r
613 AT91C_BASE_UDP->UDP_ICR = AT91C_BASE_UDP->UDP_IMR | AT91C_UDP_ENDBUSRES;
\r
615 /* If there are bytes in the FIFO then we have to retrieve them here.
\r
616 Ideally this would be done at the task level. However we need to clear the
\r
617 RXSETUP interrupt before leaving the ISR, and this may cause the data in
\r
618 the FIFO to be overwritten. Also the DIR bit has to be changed before the
\r
619 RXSETUP bit is cleared (as per the SAM7 manual). */
\r
620 ulTemp = pxMessage->ulCSR0;
\r
622 /* Are there any bytes in the FIFO? */
\r
623 ulRxBytes = ulTemp >> 16;
\r
624 ulRxBytes &= usbRX_COUNT_MASK;
\r
626 /* With this minimal implementation we are only interested in receiving
\r
627 setup bytes on the control end point. */
\r
628 if( ( ulRxBytes > 0 ) && ( ulTemp & AT91C_UDP_RXSETUP ) )
\r
630 /* Take off 1 for a zero based index. */
\r
631 while( ulRxBytes > 0 )
\r
634 pxMessage->ucFifoData[ ulRxBytes ] = AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_0 ];
\r
637 /* The direction must be changed first. */
\r
638 usbCSR_SET_BIT( &ulTemp, ( AT91C_UDP_DIR ) );
\r
639 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulTemp;
\r
642 /* Must write zero's to TXCOMP, STALLSENT, RXSETUP, and the RX DATA
\r
643 registers to clear the interrupts in the CSR register. */
\r
644 usbCSR_CLEAR_BIT( &ulTemp, usbINT_CLEAR_MASK );
\r
645 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulTemp;
\r
647 /* Also clear the interrupts in the CSR1 register. */
\r
648 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ];
\r
649 usbCSR_CLEAR_BIT( &ulTemp, usbINT_CLEAR_MASK );
\r
650 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] = ulTemp;
\r
652 /* The message now contains the entire state and optional data from
\r
653 the USB interrupt. This can now be posted on the Rx queue ready for
\r
654 processing at the task level. */
\r
655 xQueueSendFromISR( xUSBInterruptQueue, &pxMessage, &xHigherPriorityTaskWoken );
\r
657 /* We may want to switch to the USB task, if this message has made
\r
658 it the highest priority task that is ready to execute. */
\r
659 portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );
\r
661 /* Clear the AIC ready for the next interrupt. */
\r
662 AT91C_BASE_AIC->AIC_EOICR = 0;
\r
664 /*-----------------------------------------------------------*/
\r
666 void vUSBDemoTask( void *pvParameters )
\r
668 xISRStatus *pxMessage;
\r
670 /* The parameters are not used in this task. */
\r
671 ( void ) pvParameters;
\r
673 /* Init USB device */
\r
674 portENTER_CRITICAL();
\r
675 vInitUSBInterface();
\r
676 portEXIT_CRITICAL();
\r
678 /* Process interrupts as they arrive. The ISR takes a snapshot of the
\r
679 interrupt status then posts the information on this queue for processing
\r
680 at the task level. This simple demo implementation only processes
\r
681 a few interrupt sources. */
\r
684 if( xQueueReceive( xUSBInterruptQueue, &pxMessage, usbSHORT_DELAY ) )
\r
686 if( pxMessage->ulISR & AT91C_UDP_EPINT0 )
\r
688 /* Process end point 0 interrupt. */
\r
689 prvProcessEndPoint0Interrupt( pxMessage );
\r
692 if( pxMessage->ulISR & AT91C_UDP_ENDBUSRES )
\r
694 /* Process an end of bus reset interrupt. */
\r
695 prvResetEndPoints();
\r
700 /* The ISR did not post any data for us to process on the queue, so
\r
701 just generate and send some sample data. */
\r
702 if( eDriverState == eREADY_TO_SEND )
\r
704 prvTransmitSampleValues();
\r
709 /*-----------------------------------------------------------*/
\r
711 static void prvTransmitSampleValues( void )
\r
713 unsigned long ulStatus;
\r
714 static long lState = usbXUP;
\r
716 /* Variables to hold dummy x, y and z joystick axis data. */
\r
717 static signed char x = 0, y = 0, z = 0;
\r
719 /* Generate some sample data in the x and y axis - draw a square. */
\r
722 case usbXUP : x += usbDATA_INC;
\r
723 if( x >= usbMAX_COORD )
\r
729 case usbXDOWN : x -= usbDATA_INC;
\r
730 if( x <= -usbMAX_COORD )
\r
736 case usbYUP : y += usbDATA_INC;
\r
737 if( y >= usbMAX_COORD )
\r
743 case usbYDOWN : y -= usbDATA_INC;
\r
744 if( y <= -usbMAX_COORD )
\r
751 /* Just make the z axis go up and down. */
\r
754 /* Can we place data in the fifo? */
\r
755 if( !( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] & AT91C_UDP_TXPKTRDY ) )
\r
757 /* Write our sample data to the fifo. */
\r
758 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_1 ] = x;
\r
759 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_1 ] = y;
\r
760 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_1 ] = z;
\r
762 /* Send the data. */
\r
763 portENTER_CRITICAL();
\r
765 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ];
\r
766 usbCSR_SET_BIT( &ulStatus, ( AT91C_UDP_TXPKTRDY ) );
\r
767 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] = ulStatus;
\r
769 portEXIT_CRITICAL();
\r
772 /*-----------------------------------------------------------*/
\r
774 static void prvUSBTransmitNull( void )
\r
776 unsigned long ulStatus;
\r
778 /* Wait until the FIFO is free - even though we are not going to use it.
\r
779 THERE IS NO TIMEOUT HERE! */
\r
780 while( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] & AT91C_UDP_TXPKTRDY )
\r
782 vTaskDelay( usbSHORTEST_DELAY );
\r
785 portENTER_CRITICAL();
\r
787 /* Set the length of data to send to equal the index of the next byte
\r
788 to send. This will prevent the ACK to this NULL packet causing any
\r
789 further data transmissions. */
\r
790 pxCharsForTx.ulTotalDataLength = pxCharsForTx.ulNextCharIndex;
\r
792 /* Set the TXPKTRDY bit to cause a transmission with no data. */
\r
793 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];
\r
794 usbCSR_SET_BIT( &ulStatus, ( AT91C_UDP_TXPKTRDY ) );
\r
795 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;
\r
797 portEXIT_CRITICAL();
\r
799 /*-----------------------------------------------------------*/
\r
801 static void prvSendStall( void )
\r
803 unsigned long ulStatus;
\r
805 portENTER_CRITICAL();
\r
807 /* Force a stall by simply setting the FORCESTALL bit in the CSR. */
\r
808 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];
\r
809 usbCSR_SET_BIT( &ulStatus, AT91C_UDP_FORCESTALL );
\r
810 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;
\r
812 portEXIT_CRITICAL();
\r
814 /*-----------------------------------------------------------*/
\r
816 static void prvResetEndPoints( void )
\r
818 unsigned long ulTemp;
\r
820 eDriverState = eJUST_RESET;
\r
822 /* Reset all the end points. */
\r
823 AT91C_BASE_UDP->UDP_RSTEP = usbEND_POINT_RESET_MASK;
\r
824 AT91C_BASE_UDP->UDP_RSTEP = ( unsigned long ) 0x00;
\r
826 /* Enable data to be sent and received. */
\r
827 AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
\r
829 /* Repair the configuration end point. */
\r
830 portENTER_CRITICAL();
\r
832 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];
\r
833 usbCSR_SET_BIT( &ulTemp, ( ( unsigned long ) ( AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL ) ) );
\r
834 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulTemp;
\r
835 AT91F_UDP_EnableIt( AT91C_BASE_UDP, AT91C_UDP_EPINT0 );
\r
837 portEXIT_CRITICAL();
\r
839 /*-----------------------------------------------------------*/
\r
841 static void prvProcessEndPoint0Interrupt( xISRStatus *pxMessage )
\r
843 if( pxMessage->ulCSR0 & AT91C_UDP_RX_DATA_BK0 )
\r
845 /* We only expect to receive zero length data here as ACK's.
\r
846 Set the data pointer to the end of the current Tx packet to
\r
847 ensure we don't send out any more data. */
\r
848 pxCharsForTx.ulNextCharIndex = pxCharsForTx.ulTotalDataLength;
\r
851 if( pxMessage->ulCSR0 & AT91C_UDP_TXCOMP )
\r
853 /* We received a TX complete interrupt. What we do depends on
\r
854 what we sent to get this interrupt. */
\r
856 if( eDriverState == eJUST_GOT_CONFIG )
\r
858 /* We sent an acknowledgement of a SET_CONFIG request. We
\r
859 are now at the end of the enumeration. */
\r
860 AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_CONFG;
\r
862 /* Read the end point for data transfer. */
\r
863 portENTER_CRITICAL();
\r
865 unsigned long ulTemp;
\r
867 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ];
\r
868 usbCSR_SET_BIT( &ulTemp, AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_INT_IN );
\r
869 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] = ulTemp;
\r
870 AT91F_UDP_EnableIt( AT91C_BASE_UDP, AT91C_UDP_EPINT1 );
\r
872 portEXIT_CRITICAL();
\r
874 eDriverState = eREADY_TO_SEND;
\r
876 else if( eDriverState == eJUST_GOT_ADDRESS )
\r
878 /* We sent an acknowledgement of a SET_ADDRESS request. Move
\r
879 to the addressed state. */
\r
880 if( ulReceivedAddress != ( unsigned long ) 0 )
\r
882 AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
\r
886 AT91C_BASE_UDP->UDP_GLBSTATE = 0;
\r
889 AT91C_BASE_UDP->UDP_FADDR = ( AT91C_UDP_FEN | ulReceivedAddress );
\r
890 eDriverState = eNOTHING;
\r
894 /* The TXCOMP was not for any special type of transmission. See
\r
895 if there is any more data to send. */
\r
896 prvSendNextSegment();
\r
900 if( pxMessage->ulCSR0 & AT91C_UDP_RXSETUP )
\r
902 xUSB_REQUEST xRequest;
\r
903 unsigned char ucRequest;
\r
904 unsigned long ulRxBytes;
\r
906 /* A data packet is available. */
\r
907 ulRxBytes = pxMessage->ulCSR0 >> 16;
\r
908 ulRxBytes &= usbRX_COUNT_MASK;
\r
910 if( ulRxBytes >= usbEXPECTED_NUMBER_OF_BYTES )
\r
912 /* Create an xUSB_REQUEST variable from the raw bytes array. */
\r
914 xRequest.ucReqType = pxMessage->ucFifoData[ usbREQUEST_TYPE_INDEX ];
\r
915 xRequest.ucRequest = pxMessage->ucFifoData[ usbREQUEST_INDEX ];
\r
917 /* NOT PORTABLE CODE! */
\r
918 xRequest.usValue = pxMessage->ucFifoData[ usbVALUE_HIGH_BYTE ];
\r
919 xRequest.usValue <<= 8;
\r
920 xRequest.usValue |= pxMessage->ucFifoData[ usbVALUE_LOW_BYTE ];
\r
922 xRequest.usIndex = pxMessage->ucFifoData[ usbINDEX_HIGH_BYTE ];
\r
923 xRequest.usIndex <<= 8;
\r
924 xRequest.usIndex |= pxMessage->ucFifoData[ usbINDEX_LOW_BYTE ];
\r
926 xRequest.usLength = pxMessage->ucFifoData[ usbLENGTH_HIGH_BYTE ];
\r
927 xRequest.usLength <<= 8;
\r
928 xRequest.usLength |= pxMessage->ucFifoData[ usbLENGTH_LOW_BYTE ];
\r
930 /* Manipulate the ucRequestType and the ucRequest parameters to
\r
931 generate a zero based request selection. This is just done to
\r
932 break up the requests into subsections for clarity. The
\r
933 alternative would be to have more huge switch statement that would
\r
934 be difficult to optimise. */
\r
935 ucRequest = ( ( xRequest.ucReqType & 0x60 ) >> 3 );
\r
936 ucRequest |= ( xRequest.ucReqType & 0x03 );
\r
938 switch( ucRequest )
\r
940 case usbSTANDARD_DEVICE_REQUEST:
\r
941 /* Standard Device request */
\r
942 prvHandleStandardDeviceRequest( &xRequest );
\r
945 case usbSTANDARD_INTERFACE_REQUEST:
\r
946 /* Standard Interface request */
\r
947 prvHandleStandardInterfaceRequest( &xRequest );
\r
950 case usbSTANDARD_END_POINT_REQUEST:
\r
951 /* Standard Endpoint request */
\r
952 prvHandleStandardEndPointRequest( &xRequest );
\r
955 case usbCLASS_INTERFACE_REQUEST:
\r
956 /* Class Interface request */
\r
957 prvHandleClassInterfaceRequest( &xRequest );
\r
960 default: /* This is not something we want to respond to. */
\r
966 /*-----------------------------------------------------------*/
\r
968 static void prvGetStandardDeviceDescriptor( xUSB_REQUEST *pxRequest )
\r
970 /* The type is in the high byte. Return whatever has been requested. */
\r
971 switch( ( pxRequest->usValue & 0xff00 ) >> 8 )
\r
973 case usbDESCRIPTOR_TYPE_DEVICE:
\r
974 prvSendControlData( ( unsigned char * ) &pxDeviceDescriptor, pxRequest->usLength, sizeof( pxDeviceDescriptor ), pdTRUE );
\r
977 case usbDESCRIPTOR_TYPE_CONFIGURATION:
\r
978 prvSendControlData( ( unsigned char * ) &( pxConfigDescriptor ), pxRequest->usLength, sizeof( pxConfigDescriptor ), pdTRUE );
\r
981 case usbDESCRIPTOR_TYPE_STRING:
\r
983 /* The index to the string descriptor is the lower byte. */
\r
984 switch( pxRequest->usValue & 0xff )
\r
986 case usbLANGUAGE_STRING:
\r
987 prvSendControlData( ( unsigned char * ) &pxLanguageStringDescriptor, pxRequest->usLength, sizeof(pxLanguageStringDescriptor), pdTRUE );
\r
990 case usbMANUFACTURER_STRING:
\r
991 prvSendControlData( ( unsigned char * ) &pxManufacturerStringDescriptor, pxRequest->usLength, sizeof( pxManufacturerStringDescriptor ), pdTRUE );
\r
994 case usbPRODUCT_STRING:
\r
995 prvSendControlData( ( unsigned char * ) &pxProductStringDescriptor, pxRequest->usLength, sizeof( pxProductStringDescriptor ), pdTRUE );
\r
998 case usbCONFIGURATION_STRING:
\r
999 prvSendControlData( ( unsigned char * ) &pxConfigurationStringDescriptor, pxRequest->usLength, sizeof( pxConfigurationStringDescriptor ), pdTRUE );
\r
1002 case usbINTERFACE_STRING:
\r
1003 prvSendControlData( ( unsigned char * ) &pxInterfaceStringDescriptor, pxRequest->usLength, sizeof( pxInterfaceStringDescriptor ), pdTRUE );
\r
1007 /* Don't know what this string is. */
\r
1015 /* We are not responding to anything else. */
\r
1020 /*-----------------------------------------------------------*/
\r
1022 static void prvHandleStandardDeviceRequest( xUSB_REQUEST *pxRequest )
\r
1024 unsigned short usStatus = 0;
\r
1026 switch( pxRequest->ucRequest )
\r
1028 case usbGET_STATUS_REQUEST:
\r
1029 /* Just send two byte dummy status. */
\r
1030 prvSendControlData( ( unsigned char * ) &usStatus, sizeof( usStatus ), sizeof( usStatus ), pdFALSE );
\r
1033 case usbGET_DESCRIPTOR_REQUEST:
\r
1034 /* Send device descriptor */
\r
1035 prvGetStandardDeviceDescriptor( pxRequest );
\r
1038 case usbGET_CONFIGURATION_REQUEST:
\r
1039 /* Send selected device configuration */
\r
1040 prvSendControlData( ( unsigned char * ) &ucUSBConfig, sizeof( ucUSBConfig ), sizeof( ucUSBConfig ), pdFALSE );
\r
1043 case usbSET_FEATURE_REQUEST:
\r
1044 prvUSBTransmitNull();
\r
1047 case usbSET_ADDRESS_REQUEST:
\r
1049 /* Acknowledge the SET_ADDRESS, but (according to the manual) we
\r
1050 cannot actually move to the addressed state until we get a TXCOMP
\r
1051 interrupt from this NULL packet. Therefore we just remember the
\r
1052 address and set our state so we know we have received the address. */
\r
1053 prvUSBTransmitNull();
\r
1054 eDriverState = eJUST_GOT_ADDRESS;
\r
1055 ulReceivedAddress = ( unsigned long ) pxRequest->usValue;
\r
1058 case usbSET_CONFIGURATION_REQUEST:
\r
1060 /* Acknowledge the SET_CONFIGURATION, but (according to the manual)
\r
1061 we cannot actually move to the configured state until we get a
\r
1062 TXCOMP interrupt from this NULL packet. Therefore we just remember the
\r
1063 config and set our state so we know we have received the go ahead. */
\r
1064 ucUSBConfig = ( unsigned char ) ( pxRequest->usValue & 0xff );
\r
1065 eDriverState = eJUST_GOT_CONFIG;
\r
1066 prvUSBTransmitNull();
\r
1071 /* We don't answer to anything else. */
\r
1076 /*-----------------------------------------------------------*/
\r
1078 static void prvHandleClassInterfaceRequest( xUSB_REQUEST *pxRequest )
\r
1080 switch( pxRequest->ucRequest )
\r
1082 case usbSET_IDLE_REQUEST:
\r
1083 prvUSBTransmitNull();
\r
1086 /* This minimal implementation ignores these. */
\r
1087 case usbGET_REPORT_REQUEST:
\r
1088 case usbGET_IDLE_REQUEST:
\r
1089 case usbGET_PROTOCOL_REQUEST:
\r
1090 case usbSET_REPORT_REQUEST:
\r
1091 case usbSET_PROTOCOL_REQUEST:
\r
1098 /*-----------------------------------------------------------*/
\r
1100 static void prvGetStandardInterfaceDescriptor( xUSB_REQUEST *pxRequest )
\r
1102 switch( ( pxRequest->usValue & ( unsigned short ) 0xff00 ) >> 8 )
\r
1104 case usbHID_REPORT_DESCRIPTOR:
\r
1105 prvSendControlData( ( unsigned char * ) pxReportDescriptor, pxRequest->usLength, sizeof( pxReportDescriptor ), pdTRUE );
\r
1110 /* Don't expect to send any others. */
\r
1115 /*-----------------------------------------------------------*/
\r
1117 static void prvHandleStandardInterfaceRequest( xUSB_REQUEST *pxRequest )
\r
1119 unsigned short usStatus = 0;
\r
1121 switch( pxRequest->ucRequest )
\r
1123 case usbGET_STATUS_REQUEST:
\r
1124 /* Send dummy 2 bytes. */
\r
1125 prvSendControlData( ( unsigned char * ) &usStatus, sizeof( usStatus ), sizeof( usStatus ), pdFALSE );
\r
1128 case usbGET_DESCRIPTOR_REQUEST:
\r
1129 prvGetStandardInterfaceDescriptor( pxRequest );
\r
1132 /* This minimal implementation does not respond to these. */
\r
1133 case usbGET_INTERFACE_REQUEST:
\r
1134 case usbSET_FEATURE_REQUEST:
\r
1135 case usbSET_INTERFACE_REQUEST:
\r
1142 /*-----------------------------------------------------------*/
\r
1144 static void prvHandleStandardEndPointRequest( xUSB_REQUEST *pxRequest )
\r
1146 switch( pxRequest->ucRequest )
\r
1148 /* This minimal implementation does not expect to respond to these. */
\r
1149 case usbGET_STATUS_REQUEST:
\r
1150 case usbCLEAR_FEATURE_REQUEST:
\r
1151 case usbSET_FEATURE_REQUEST:
\r
1158 /*-----------------------------------------------------------*/
\r
1160 static void vInitUSBInterface( void )
\r
1162 volatile unsigned long ulTemp;
\r
1164 /* Create the queue used to communicate between the USB ISR and task. */
\r
1165 xUSBInterruptQueue = xQueueCreate( usbQUEUE_LENGTH + 1, sizeof( xISRStatus * ) );
\r
1167 /* Initialise a few state variables. */
\r
1168 pxCharsForTx.ulNextCharIndex = ( unsigned long ) 0;
\r
1169 ucUSBConfig = ( unsigned char ) 0;
\r
1170 eDriverState = eNOTHING;
\r
1172 /* HARDWARE SETUP */
\r
1174 /* Set the PLL USB Divider */
\r
1175 AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1;
\r
1177 /* Enables the 48MHz USB clock UDPCK and System Peripheral USB Clock. */
\r
1178 AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_UDP;
\r
1179 AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_UDP);
\r
1181 /* Setup the PIO for the USB pull up resistor. */
\r
1182 AT91F_PIO_CfgOutput(AT91C_BASE_PIOA,AT91C_PIO_PA16);
\r
1184 /* Start without the pullup - this will get set at the end of this
\r
1186 AT91F_PIO_SetOutput( AT91C_BASE_PIOA, AT91C_PIO_PA16 );
\r
1188 /* When using the USB debugger the peripheral registers do not always get
\r
1189 set to the correct default values. To make sure set the relevant registers
\r
1191 AT91C_BASE_UDP->UDP_IDR = ( unsigned long ) 0xffffffff;
\r
1192 AT91C_BASE_UDP->UDP_ICR = ( unsigned long ) 0xffffffff;
\r
1193 AT91C_BASE_UDP->UDP_CSR[ 0 ] = ( unsigned long ) 0x00;
\r
1194 AT91C_BASE_UDP->UDP_CSR[ 1 ] = ( unsigned long ) 0x00;
\r
1195 AT91C_BASE_UDP->UDP_GLBSTATE = 0;
\r
1196 AT91C_BASE_UDP->UDP_FADDR = 0;
\r
1198 /* Enable the transceiver. */
\r
1199 AT91C_UDP_TRANSCEIVER_ENABLE = 0;
\r
1201 /* Enable the USB interrupts - other interrupts get enabled as the
\r
1202 enumeration process progresses. */
\r
1203 AT91F_AIC_ConfigureIt( AT91C_BASE_AIC, AT91C_ID_UDP, usbINTERRUPT_PRIORITY, AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE, ( void (*)( void ) ) vUSBISREntry );
\r
1204 AT91F_AIC_EnableIt( AT91C_BASE_AIC, AT91C_ID_UDP );
\r
1206 /* Wait a short while before making our presence known. */
\r
1207 vTaskDelay( usbINIT_DELAY );
\r
1208 AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, AT91C_PIO_PA16 );
\r
1210 /*-----------------------------------------------------------*/
\r
1212 static void prvSendControlData( unsigned char *pucData, unsigned short usRequestedLength, unsigned long ulLengthToSend, long lSendingDescriptor )
\r
1214 if( ( ( unsigned long ) usRequestedLength < ulLengthToSend ) )
\r
1216 /* Cap the data length to that requested. */
\r
1217 ulLengthToSend = ( unsigned short ) usRequestedLength;
\r
1219 else if( ( ulLengthToSend < ( unsigned long ) usRequestedLength ) && lSendingDescriptor )
\r
1221 /* We are sending a descriptor. If the descriptor is an exact
\r
1222 multiple of the FIFO length then it will have to be terminated
\r
1223 with a NULL packet. Set the state to indicate this if
\r
1225 if( ( ulLengthToSend % usbFIFO_LENGTH ) == 0 )
\r
1227 eDriverState = eSENDING_EVEN_DESCRIPTOR;
\r
1231 /* Here we assume that the previous message has been sent. THERE IS NO
\r
1232 BUFFER OVERFLOW PROTECTION HERE.
\r
1234 Copy the data to send into the buffer as we cannot send it all at once
\r
1235 (if it is greater than 8 bytes in length). */
\r
1236 memcpy( pxCharsForTx.ucTxBuffer, pucData, ulLengthToSend );
\r
1238 /* Reinitialise the buffer index so we start sending from the start of
\r
1240 pxCharsForTx.ulTotalDataLength = ulLengthToSend;
\r
1241 pxCharsForTx.ulNextCharIndex = ( unsigned long ) 0;
\r
1243 /* Send the first 8 bytes now. The rest will get sent in response to
\r
1244 TXCOMP interrupts. */
\r
1245 prvSendNextSegment();
\r
1247 /*-----------------------------------------------------------*/
\r
1249 static void prvSendNextSegment( void )
\r
1251 volatile unsigned long ulNextLength, ulStatus, ulLengthLeftToSend;
\r
1253 /* Is there any data to send? */
\r
1254 if( pxCharsForTx.ulTotalDataLength > pxCharsForTx.ulNextCharIndex )
\r
1256 ulLengthLeftToSend = pxCharsForTx.ulTotalDataLength - pxCharsForTx.ulNextCharIndex;
\r
1258 /* We can only send 8 bytes to the fifo at a time. */
\r
1259 if( ulLengthLeftToSend > usbFIFO_LENGTH )
\r
1261 ulNextLength = usbFIFO_LENGTH;
\r
1265 ulNextLength = ulLengthLeftToSend;
\r
1268 /* Wait until we can place data in the fifo. THERE IS NO TIMEOUT
\r
1270 while( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] & AT91C_UDP_TXPKTRDY )
\r
1272 vTaskDelay( usbSHORTEST_DELAY );
\r
1275 /* Write the data to the FIFO. */
\r
1276 while( ulNextLength > ( unsigned long ) 0 )
\r
1278 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_0 ] = pxCharsForTx.ucTxBuffer[ pxCharsForTx.ulNextCharIndex ];
\r
1281 pxCharsForTx.ulNextCharIndex++;
\r
1284 /* Start the transmission. */
\r
1285 portENTER_CRITICAL();
\r
1287 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];
\r
1288 usbCSR_SET_BIT( &ulStatus, ( ( unsigned long ) 0x10 ) );
\r
1289 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;
\r
1291 portEXIT_CRITICAL();
\r
1295 /* There is no data to send. If we were sending a descriptor and the
\r
1296 descriptor was an exact multiple of the max packet size then we need
\r
1297 to send a null to terminate the transmission. */
\r
1298 if( eDriverState == eSENDING_EVEN_DESCRIPTOR )
\r
1300 prvUSBTransmitNull();
\r
1301 eDriverState = eNOTHING;
\r
projects / freertos / blob