git.sur5r.net Git - freertos/blob - Demo/ARM7_AT91SAM7S64_IAR/USB/USBSample.c

   1 /*\r
   2         FreeRTOS V5.4.0 - Copyright (C) 2003-2009 Richard Barry.\r
   3 \r
   4         This file is part of the FreeRTOS distribution.\r
   5 \r
   6         FreeRTOS is free software; you can redistribute it and/or modify it     under \r
   7         the terms of the GNU General Public License (version 2) as published by the \r
   8         Free Software Foundation and modified by the FreeRTOS exception.\r
   9         **NOTE** The exception to the GPL is included to allow you to distribute a\r
  10         combined work that includes FreeRTOS without being obliged to provide the \r
  11         source code for proprietary components outside of the FreeRTOS kernel.  \r
  12         Alternative commercial license and support terms are also available upon \r
  13         request.  See the licensing section of http://www.FreeRTOS.org for full \r
  14         license details.\r
  15 \r
  16         FreeRTOS is distributed in the hope that it will be useful,     but WITHOUT\r
  17         ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
  18         FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for\r
  19         more details.\r
  20 \r
  21         You should have received a copy of the GNU General Public License along\r
  22         with FreeRTOS; if not, write to the Free Software Foundation, Inc., 59\r
  23         Temple Place, Suite 330, Boston, MA  02111-1307  USA.\r
  24 \r
  25 \r
  26         ***************************************************************************\r
  27         *                                                                         *\r
  28         * Looking for a quick start?  Then check out the FreeRTOS eBook!          *\r
  29         * See http://www.FreeRTOS.org/Documentation for details                   *\r
  30         *                                                                         *\r
  31         ***************************************************************************\r
  32 \r
  33         1 tab == 4 spaces!\r
  34 \r
  35         Please ensure to read the configuration and relevant port sections of the\r
  36         online documentation.\r
  37 \r
  38         http://www.FreeRTOS.org - Documentation, latest information, license and\r
  39         contact details.\r
  40 \r
  41         http://www.SafeRTOS.com - A version that is certified for use in safety\r
  42         critical systems.\r
  43 \r
  44         http://www.OpenRTOS.com - Commercial support, development, porting,\r
  45         licensing and training services.\r
  46 */\r
  47 \r
  48 /*\r
  49         Sample interrupt driven USB device driver.  This is a minimal implementation\r
  50         for demonstration only.  Although functional, it is not a full and compliant\r
  51         implementation.\r
  52         \r
  53         The USB device enumerates as a simple 3 axis joystick, and once configured\r
  54         transmits 3 axis of data which can be viewed from the USB host machine.\r
  55 \r
  56         This file implements the USB interrupt service routine, and a demo FreeRTOS\r
  57         task.  The interrupt service routine handles the USB hardware - taking a\r
  58         snapshot of the USB status at the point of the interrupt.  The task receives\r
  59         the status information from the interrupt for processing at the task level.\r
  60         \r
  61         See the FreeRTOS.org WEB documentation for more information.\r
  62 */\r
  63 \r
  64 /*\r
  65         Changes from V2.5.5\r
  66         \r
  67         + Descriptors that have a length that is an exact multiple of usbFIFO_LENGTH\r
  68           can now be transmitted.  To this end an extra parameter has been\r
  69           added to the prvSendControlData() function, and the state\r
  70           eSENDING_EVEN_DESCRIPTOR has been introduced.  Thanks to Scott Miller for\r
  71           assisting with this contribution.\r
  72 \r
  73         Changes from V2.6.0\r
  74 \r
  75         + Replaced the duplicated RX_DATA_BK0 in the interrupt mask with the\r
  76           RX_DATA_BK1.\r
  77 */\r
  78 \r
  79 /* Standard includes. */\r
  80 #include <string.h>\r
  81 \r
  82 /* Demo board includes. */\r
  83 #include "board.h"\r
  84 \r
  85 /* Scheduler includes. */\r
  86 #include "FreeRTOS.h"\r
  87 #include "task.h"\r
  88 #include "queue.h"\r
  89 \r
  90 \r
  91 /* Descriptor type definitions. */\r
  92 #define usbDESCRIPTOR_TYPE_DEVICE                       ( 0x01 )\r
  93 #define usbDESCRIPTOR_TYPE_CONFIGURATION        ( 0x02 )\r
  94 #define usbDESCRIPTOR_TYPE_STRING                       ( 0x03 )\r
  95 \r
  96 /* USB request type definitions. */\r
  97 #define usbGET_REPORT_REQUEST                           ( 0x01 )\r
  98 #define usbGET_IDLE_REQUEST                                     ( 0x02 )\r
  99 #define usbGET_PROTOCOL_REQUEST                         ( 0x03 )\r
 100 #define usbSET_REPORT_REQUEST                           ( 0x09 )\r
 101 #define usbSET_IDLE_REQUEST                                     ( 0x0A )\r
 102 #define usbSET_PROTOCOL_REQUEST                         ( 0x0B )\r
 103 #define usbGET_CONFIGURATION_REQUEST            ( 0x08 )\r
 104 #define usbGET_STATUS_REQUEST                           ( 0x00 )\r
 105 #define usbCLEAR_FEATURE_REQUEST                        ( 0x01 )\r
 106 #define usbSET_FEATURE_REQUEST                          ( 0x03 )\r
 107 #define usbSET_ADDRESS_REQUEST                          ( 0x05 )\r
 108 #define usbGET_DESCRIPTOR_REQUEST                       ( 0x06 )\r
 109 #define usbSET_CONFIGURATION_REQUEST            ( 0x09 )\r
 110 #define usbGET_INTERFACE_REQUEST                        ( 0x0A )\r
 111 #define usbSET_INTERFACE_REQUEST                        ( 0x0B )\r
 112 \r
 113 \r
 114 /* Misc USB definitions. */\r
 115 #define usbDEVICE_CLASS_VENDOR_SPECIFIC         ( 0xFF )\r
 116 #define usbBUS_POWERED                                          ( 0x80 )\r
 117 #define usbHID_REPORT_DESCRIPTOR                        ( 0x22 )\r
 118 #define AT91C_UDP_TRANSCEIVER_ENABLE                    ( *( ( unsigned long * ) 0xfffb0074 ) )\r
 119 \r
 120 /* Index to the various string. */\r
 121 #define usbLANGUAGE_STRING                                      ( 0 )\r
 122 #define usbMANUFACTURER_STRING                          ( 1 )\r
 123 #define usbPRODUCT_STRING                                       ( 2 )\r
 124 #define usbCONFIGURATION_STRING                         ( 3 )\r
 125 #define usbINTERFACE_STRING                                     ( 4 )\r
 126 \r
 127 /* Data indexes for reading the request from the xISRStatus.ucFifoData[]\r
 128 into xUSB_REQUEST.  The data order is designed for speed - so looks a\r
 129 little odd. */\r
 130 #define usbREQUEST_TYPE_INDEX                           ( 7 )\r
 131 #define usbREQUEST_INDEX                                        ( 6 )\r
 132 #define usbVALUE_HIGH_BYTE                                      ( 4 )\r
 133 #define usbVALUE_LOW_BYTE                                       ( 5 )\r
 134 #define usbINDEX_HIGH_BYTE                                      ( 2 )\r
 135 #define usbINDEX_LOW_BYTE                                       ( 3 )\r
 136 #define usbLENGTH_HIGH_BYTE                                     ( 0 )\r
 137 #define usbLENGTH_LOW_BYTE                                      ( 1 )\r
 138 \r
 139 /* Misc application definitions. */\r
 140 #define usbINTERRUPT_PRIORITY                           ( 3 )\r
 141 #define usbQUEUE_LENGTH                                         ( 0x3 ) /* Must have all bits set! */\r
 142 #define usbFIFO_LENGTH                                          ( ( unsigned portLONG ) 8 )\r
 143 #define usbEND_POINT_0                                          ( 0 )\r
 144 #define usbEND_POINT_1                                          ( 1 )\r
 145 #define usbXUP                                                          ( 1 )\r
 146 #define usbXDOWN                                                        ( 2 )\r
 147 #define usbYUP                                                          ( 3 )\r
 148 #define usbYDOWN                                                        ( 4 )\r
 149 #define usbMAX_COORD                                            ( 120 )\r
 150 #define usbMAX_TX_MESSAGE_SIZE                          ( 128 )\r
 151 #define usbRX_COUNT_MASK                                        ( ( unsigned portLONG ) 0x7ff )\r
 152 #define AT91C_UDP_STALLSENT                                     AT91C_UDP_ISOERROR\r
 153 #define usbSHORTEST_DELAY                                       ( ( portTickType ) 1 )\r
 154 #define usbINIT_DELAY                                           ( ( portTickType ) 500 / portTICK_RATE_MS )\r
 155 #define usbSHORT_DELAY                                          ( ( portTickType ) 50 / portTICK_RATE_MS )\r
 156 #define usbEND_POINT_RESET_MASK                         ( ( unsigned portLONG ) 0x0f )\r
 157 #define usbDATA_INC                                                     ( ( portCHAR ) 5 )\r
 158 #define usbEXPECTED_NUMBER_OF_BYTES                     ( ( unsigned portLONG ) 8 )\r
 159 \r
 160 /* Control request types. */\r
 161 #define usbSTANDARD_DEVICE_REQUEST                      ( 0 )\r
 162 #define usbSTANDARD_INTERFACE_REQUEST           ( 1 )\r
 163 #define usbSTANDARD_END_POINT_REQUEST           ( 2 )\r
 164 #define usbCLASS_INTERFACE_REQUEST                      ( 5 )\r
 165 \r
 166 /*-----------------------------------------------------------*/\r
 167 \r
 168 /* Structure used to take a snapshot of the USB status from within the ISR. */\r
 169 typedef struct X_ISR_STATUS\r
 170 {\r
 171         unsigned portLONG ulISR;\r
 172         unsigned portLONG ulCSR0;\r
 173         unsigned portCHAR ucFifoData[ 8 ];\r
 174 } xISRStatus;\r
 175 \r
 176 /* Structure used to hold the received requests. */\r
 177 typedef struct\r
 178 {\r
 179         unsigned portCHAR ucReqType;\r
 180         unsigned portCHAR ucRequest;\r
 181         unsigned portSHORT usValue;\r
 182         unsigned portSHORT usIndex;\r
 183         unsigned portSHORT usLength;\r
 184 } xUSB_REQUEST;\r
 185 \r
 186 typedef enum\r
 187 {\r
 188         eNOTHING,\r
 189         eJUST_RESET,\r
 190         eJUST_GOT_CONFIG,\r
 191         eJUST_GOT_ADDRESS,\r
 192         eSENDING_EVEN_DESCRIPTOR,\r
 193         eREADY_TO_SEND\r
 194 } eDRIVER_STATE;\r
 195 \r
 196 /* Structure used to control the data being sent to the host. */\r
 197 typedef struct\r
 198 {\r
 199         unsigned portCHAR ucTxBuffer[ usbMAX_TX_MESSAGE_SIZE ];\r
 200         unsigned portLONG ulNextCharIndex;\r
 201         unsigned portLONG ulTotalDataLength;\r
 202 } xTX_MESSAGE;\r
 203 \r
 204 /*-----------------------------------------------------------*/\r
 205 \r
 206 /*\r
 207  * The USB interrupt service routine.  This takes a snapshot of the USB\r
 208  * device at the time of the interrupt, clears the interrupts, and posts\r
 209  * the data to the USB processing task.\r
 210  */\r
 211 __arm void vUSB_ISR( void );\r
 212 \r
 213 /*\r
 214  * Called after the bus reset interrupt - this function readies all the\r
 215  * end points for communication.\r
 216  */\r
 217 static void prvResetEndPoints( void );\r
 218 \r
 219 /*\r
 220  * Setup the USB hardware, install the interrupt service routine and\r
 221  * initialise all the state variables.\r
 222  */\r
 223 static void vInitUSBInterface( void );\r
 224 \r
 225 /*\r
 226  * Decode and act upon an interrupt generated by the control end point.\r
 227  */\r
 228 static void prvProcessEndPoint0Interrupt( xISRStatus *pxMessage );\r
 229 \r
 230 /*\r
 231  * For simplicity requests are separated into device, interface, class\r
 232  * interface and end point requests.\r
 233  *\r
 234  * Decode and handle standard device requests originating on the control\r
 235  * end point.\r
 236  */\r
 237 static void prvHandleStandardDeviceRequest( xUSB_REQUEST *pxRequest );\r
 238 \r
 239 /*\r
 240  * For simplicity requests are separated into device, interface, class\r
 241  * interface and end point requests.\r
 242  *\r
 243  * Decode and handle standard interface requests originating on the control\r
 244  * end point.\r
 245  */\r
 246 static void prvHandleStandardInterfaceRequest( xUSB_REQUEST *pxRequest );\r
 247 \r
 248 /*\r
 249  * For simplicity requests are separated into device, interface, class\r
 250  * interface and end point requests.\r
 251  *\r
 252  * Decode and handle standard end point requests originating on the control\r
 253  * end point.\r
 254  */\r
 255 static void prvHandleStandardEndPointRequest( xUSB_REQUEST *pxRequest );\r
 256 \r
 257 /*\r
 258  * For simplicity requests are separated into device, interface, class\r
 259  * interface and end point requests.\r
 260  *\r
 261  * Decode and handle the class interface requests.\r
 262  */\r
 263 static void prvHandleClassInterfaceRequest( xUSB_REQUEST *pxRequest );\r
 264 \r
 265 /*\r
 266  * Setup the Tx buffer to send data in response to a control request.\r
 267  *\r
 268  * The data to be transmitted is buffered, the state variables are updated,\r
 269  * then prvSendNextSegment() is called to start the transmission off.  Once\r
 270  * the first segment has been sent the remaining segments are transmitted\r
 271  * in response to TXCOMP interrupts until the entire buffer has been\r
 272  * sent.\r
 273  */\r
 274 static void prvSendControlData( unsigned portCHAR *pucData, unsigned portSHORT usRequestedLength, unsigned portLONG ulLengthLeftToSend, portLONG lSendingDescriptor );\r
 275 \r
 276 /*\r
 277  * Examine the Tx buffer to see if there is any more data to be transmitted.\r
 278  *\r
 279  * If there is data to be transmitted then send the next segment.  A segment\r
 280  * can have a maximum of 8 bytes (this is defined as the maximum for the end\r
 281  * point by the descriptor).  The final segment may be less than 8 bytes if\r
 282  * the total data length was not an exact multiple of 8.\r
 283  */\r
 284 static void prvSendNextSegment( void );\r
 285 \r
 286 /*\r
 287  * A stall condition is forced each time the host makes a request that is not\r
 288  * supported by this minimal implementation.\r
 289  *\r
 290  * A stall is forced by setting the appropriate bit in the end points control\r
 291  * and status register.\r
 292  */\r
 293 static void prvSendStall( void );\r
 294 \r
 295 /*\r
 296  * A NULL (or zero length packet) is transmitted in acknowledge the reception\r
 297  * of certain events from the host.\r
 298  */\r
 299 static void prvUSBTransmitNull( void );\r
 300 \r
 301 /*\r
 302  * When the host requests a descriptor this function is called to determine\r
 303  * which descriptor is being requested and start its transmission.\r
 304  */\r
 305 static void prvGetStandardInterfaceDescriptor( xUSB_REQUEST *pxRequest );\r
 306 \r
 307 /*\r
 308  * This demo USB device enumerates as a simple 3 axis joystick.  Once\r
 309  * configured this function is periodically called to generate some sample\r
 310  * joystick data.\r
 311  *\r
 312  * The x and y axis are made to move in a square.  The z axis is made to\r
 313  * repeatedly increment up to its maximum.\r
 314  */\r
 315 static void prvTransmitSampleValues( void );\r
 316 \r
 317 /*\r
 318  * The created task to handle the USB demo functionality.\r
 319  */\r
 320 void vUSBDemoTask( void *pvParameters );\r
 321 \r
 322 /*-----------------------------------------------------------*/\r
 323 \r
 324 /*\r
 325         - DESCRIPTOR DEFINITIONS -\r
 326 */\r
 327 \r
 328 /* String descriptors used during the enumeration process.\r
 329 These take the form:\r
 330 \r
 331 {\r
 332         Length of descriptor,\r
 333         Descriptor type,\r
 334         Data\r
 335 }\r
 336 */\r
 337 const portCHAR pxLanguageStringDescriptor[] =\r
 338 {\r
 339         4,\r
 340         usbDESCRIPTOR_TYPE_STRING,\r
 341         0x09, 0x04\r
 342 };\r
 343 \r
 344 const portCHAR pxManufacturerStringDescriptor[] =\r
 345 {\r
 346         18,\r
 347         usbDESCRIPTOR_TYPE_STRING,\r
 348 \r
 349         'F', 0x00,\r
 350         'r', 0x00,\r
 351         'e', 0x00,\r
 352         'e', 0x00,\r
 353         'R', 0x00,\r
 354         'T', 0x00,\r
 355         'O', 0x00,\r
 356         'S', 0x00       \r
 357 };\r
 358 \r
 359 const portCHAR pxProductStringDescriptor[] =\r
 360 {\r
 361         44,\r
 362         usbDESCRIPTOR_TYPE_STRING,\r
 363 \r
 364         'F', 0x00,\r
 365         'r', 0x00,\r
 366         'e', 0x00,\r
 367         'e', 0x00,\r
 368         'R', 0x00,\r
 369         'T', 0x00,\r
 370         'O', 0x00,\r
 371         'S', 0x00,\r
 372         '.', 0x00,\r
 373         'o', 0x00,\r
 374         'r', 0x00,\r
 375         'g', 0x00,\r
 376         ' ', 0x00,\r
 377         'J', 0x00,\r
 378         'o', 0x00,\r
 379         'y', 0x00,\r
 380         's', 0x00,\r
 381         't', 0x00,\r
 382         'i', 0x00,\r
 383         'c', 0x00,\r
 384         'k', 0x00\r
 385 };\r
 386 \r
 387 const portCHAR pxConfigurationStringDescriptor[] =\r
 388 {\r
 389         38,\r
 390         usbDESCRIPTOR_TYPE_STRING,\r
 391 \r
 392         'C', 0x00,\r
 393         'o', 0x00,\r
 394         'n', 0x00,\r
 395         'f', 0x00,\r
 396         'i', 0x00,\r
 397         'g', 0x00,\r
 398         'u', 0x00,\r
 399         'r', 0x00,\r
 400         'a', 0x00,\r
 401         't', 0x00,\r
 402         'i', 0x00,\r
 403         'o', 0x00,\r
 404         'n', 0x00,\r
 405         ' ', 0x00,\r
 406         'N', 0x00,\r
 407         'a', 0x00,\r
 408         'm', 0x00,\r
 409         'e', 0x00\r
 410 };\r
 411 \r
 412 const portCHAR pxInterfaceStringDescriptor[] =\r
 413 {\r
 414         30,\r
 415         usbDESCRIPTOR_TYPE_STRING,\r
 416 \r
 417         'I', 0x00,\r
 418         'n', 0x00,\r
 419         't', 0x00,\r
 420         'e', 0x00,\r
 421         'r', 0x00,\r
 422         'f', 0x00,\r
 423         'a', 0x00,\r
 424         'c', 0x00,\r
 425         'e', 0x00,\r
 426         ' ', 0x00,\r
 427         'N', 0x00,\r
 428         'a', 0x00,\r
 429         'm', 0x00,\r
 430         'e', 0x00\r
 431 };\r
 432 \r
 433 /* Enumeration descriptors. */\r
 434 const portCHAR pxReportDescriptor[] =\r
 435 {\r
 436          0x05,  0x01,   /* USAGE_PAGE (Generic Desktop)         */\r
 437          0x09,  0x04,   /* USAGE (Joystick)                                     */\r
 438          0xa1,  0x01,   /* COLLECTION (Application)                     */\r
 439          0x05,  0x01,   /*   USAGE_PAGE (Generic Desktop)       */\r
 440          0x09,  0x01,   /*   USAGE (Pointer)                            */\r
 441          0xa1,  0x00,   /*   COLLECTION (Physical)                      */\r
 442          0x09,  0x30,   /*     USAGE (X)                                        */\r
 443          0x09,  0x31,   /*     USAGE (Y)                                        */\r
 444          0x09,  0x32,   /*     USAGE (Z)                                        */\r
 445          0x15,  0x81,   /*     LOGICAL_MINIMUM (-127)           */\r
 446          0x25,  0x7f,   /*     LOGICAL_MAXIMUM (127)            */\r
 447          0x75,  0x08,   /*     REPORT_SIZE (8)                          */\r
 448          0x95,  0x03,   /*     REPORT_COUNT (3)                         */\r
 449          0x81,  0x02,   /*     INPUT (Data,Var,Abs)                     */\r
 450          0xc0,                  /*   END_COLLECTION                                     */\r
 451          0xc0                   /* END_COLLECTION                                       */\r
 452 };\r
 453 \r
 454 const char pxDeviceDescriptor[] =\r
 455 {\r
 456         /* Device descriptor */\r
 457         0x12,                                                           /* bLength                              */\r
 458         0x01,                                                           /* bDescriptorType              */\r
 459         0x10, 0x01,                                                     /* bcdUSBL                              */\r
 460         usbDEVICE_CLASS_VENDOR_SPECIFIC,        /* bDeviceClass:                */\r
 461         0x00,                                                           /* bDeviceSubclass:             */\r
 462         0x00,                                                           /* bDeviceProtocol:             */\r
 463         0x08,                                                           /* bMaxPacketSize0              */\r
 464         0xFF, 0xFF,                                                     /* idVendorL                    */\r
 465         0x01, 0x00,                                                     /* idProductL                   */\r
 466         0x00, 0x01,                                                     /* bcdDeviceL                   */\r
 467         usbMANUFACTURER_STRING,                         /* iManufacturer                */\r
 468         usbPRODUCT_STRING,                                      /* iProduct                             */\r
 469         0x00,                                                           /* SerialNumber                 */\r
 470         0x01                                                            /* bNumConfigs                  */\r
 471 };\r
 472 \r
 473 const char pxConfigDescriptor[] = {\r
 474         /* Configuration 1 descriptor */\r
 475         0x09,                   /* CbLength                                                                     */\r
 476         0x02,                   /* CbDescriptorType                                                     */\r
 477         0x22, 0x00,             /* CwTotalLength 2 EP + Control                         */\r
 478         0x01,                   /* CbNumInterfaces                                                      */\r
 479         0x01,                   /* CbConfigurationValue                                         */\r
 480         usbCONFIGURATION_STRING,/* CiConfiguration                                      */\r
 481         usbBUS_POWERED, /* CbmAttributes Bus powered + Remote Wakeup*/\r
 482         0x32,                   /* CMaxPower: 100mA                                                     */\r
 483 \r
 484         /* Joystick Interface Descriptor Requirement */\r
 485         0x09,                   /* bLength                                                                      */\r
 486         0x04,                   /* bDescriptorType                                                      */\r
 487         0x00,                   /* bInterfaceNumber                                                     */\r
 488         0x00,                   /* bAlternateSetting                                            */\r
 489         0x01,                   /* bNumEndpoints                                                        */\r
 490         0x03,                   /* bInterfaceClass: HID code                            */\r
 491         0x00,                   /* bInterfaceSubclass                                           */\r
 492         0x00,                   /* bInterfaceProtocol                                           */\r
 493         usbINTERFACE_STRING,/* iInterface                                                       */\r
 494 \r
 495         /* HID Descriptor */\r
 496         0x09,                   /* bLength                                                                      */\r
 497         0x21,                   /* bDescriptor type: HID Descriptor Type        */\r
 498         0x00, 0x01,             /* bcdHID                                                                       */\r
 499         0x00,                   /* bCountryCode                                                         */\r
 500         0x01,                   /* bNumDescriptors                                                      */\r
 501         usbHID_REPORT_DESCRIPTOR,         /* bDescriptorType                    */\r
 502         sizeof( pxReportDescriptor ), 0x00, /* wItemLength                      */\r
 503 \r
 504         /* Endpoint 1 descriptor */\r
 505         0x07,                   /* bLength                                                                      */\r
 506         0x05,                   /* bDescriptorType                                                      */\r
 507         0x81,                   /* bEndpointAddress, Endpoint 01 - IN           */\r
 508         0x03,                   /* bmAttributes      INT                                        */\r
 509         0x03, 0x00,             /* wMaxPacketSize: 3 bytes (x, y, z)            */\r
 510         0x0A                    /* bInterval                                                            */\r
 511 };\r
 512 \r
 513 /*-----------------------------------------------------------*/\r
 514 \r
 515 /* File scope state variables. */\r
 516 static unsigned portCHAR ucUSBConfig = ( unsigned portCHAR ) 0;\r
 517 static unsigned portLONG ulReceivedAddress = ( unsigned portLONG ) 0;\r
 518 static eDRIVER_STATE eDriverState = eNOTHING;\r
 519 \r
 520 /* Array in which the USB interrupt status is passed between the ISR and task. */\r
 521 static xISRStatus xISRMessages[ usbQUEUE_LENGTH + 1 ];\r
 522 \r
 523 /* Structure used to control the characters being sent to the host. */\r
 524 static xTX_MESSAGE pxCharsForTx;\r
 525 \r
 526 /* Queue used to pass messages between the ISR and the task. */\r
 527 static xQueueHandle xUSBInterruptQueue;\r
 528 \r
 529 /* ISR entry has to be written in the asm file as we want a context switch\r
 530 to occur from within the ISR.  See the port documentation on the FreeRTOS.org\r
 531 WEB site for more information. */\r
 532 extern void vUSBISREntry( void );\r
 533 \r
 534 /*-----------------------------------------------------------*/\r
 535 \r
 536 /* Macros to manipulate the control and status registers.  These registers\r
 537 cannot be accessed using a direct read modify write operation outside of the\r
 538 ISR as some bits are left unchanged by writing with a 0, and some are left\r
 539 unchanged by writing with a 1. */\r
 540 \r
 541 #define usbINT_CLEAR_MASK       (AT91C_UDP_TXCOMP | AT91C_UDP_STALLSENT | AT91C_UDP_RXSETUP | AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RX_DATA_BK1 )\r
 542 \r
 543 #define usbCSR_SET_BIT( pulValueNow, ulBit )                                                                                    \\r
 544 {                                                                                                                                                                               \\r
 545         /* Set TXCOMP, RX_DATA_BK0, RXSETUP, */                                                                                         \\r
 546         /* STALLSENT and RX_DATA_BK1 to 1 so the */                                                                                     \\r
 547         /* write has no effect. */                                                                                                                      \\r
 548         ( * ( ( unsigned portLONG * ) pulValueNow ) ) |= ( unsigned portLONG ) 0x4f;            \\r
 549                                                                                                                                                                                 \\r
 550         /* Clear the FORCE_STALL and TXPKTRDY bits */                                                                           \\r
 551         /* so the write has no effect. */                                                                                                       \\r
 552         ( * ( ( unsigned portLONG * ) pulValueNow ) ) &= ( unsigned portLONG ) 0xffffffcf;      \\r
 553                                                                                                                                                                                 \\r
 554         /* Set whichever bit we want set. */                                                                                            \\r
 555         ( * ( ( unsigned portLONG * ) pulValueNow ) ) |= ( ulBit );                                                     \\r
 556 }\r
 557 \r
 558 #define usbCSR_CLEAR_BIT( pulValueNow, ulBit )                                                                                  \\r
 559 {                                                                                                                                                                               \\r
 560         /* Set TXCOMP, RX_DATA_BK0, RXSETUP, */                                                                                         \\r
 561         /* STALLSENT and RX_DATA_BK1 to 1 so the */                                                                                     \\r
 562         /* write has no effect. */                                                                                                                      \\r
 563         ( * ( ( unsigned portLONG * ) pulValueNow ) ) |= ( unsigned portLONG ) 0x4f;            \\r
 564                                                                                                                                                                                 \\r
 565         /* Clear the FORCE_STALL and TXPKTRDY bits */                                                                           \\r
 566         /* so the write has no effect. */                                                                                                       \\r
 567         ( * ( ( unsigned portLONG * ) pulValueNow ) ) &= ( unsigned portLONG ) 0xffffffcf;      \\r
 568                                                                                                                                                                                 \\r
 569         /* Clear whichever bit we want clear. */                                                                                        \\r
 570         ( * ( ( unsigned portLONG * ) pulValueNow ) ) &= ( ~ulBit );                                            \\r
 571 }\r
 572 \r
 573 /*-----------------------------------------------------------*/\r
 574 \r
 575 __arm void vUSB_ISR( void )\r
 576 {\r
 577 portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
 578 static volatile unsigned portLONG ulNextMessage = 0;\r
 579 xISRStatus *pxMessage;\r
 580 unsigned portLONG ulTemp, ulRxBytes;\r
 581 \r
 582         /* Take the next message from the queue.  Note that usbQUEUE_LENGTH *must*\r
 583         be all 1's, as in 0x01, 0x03, 0x07, etc. */\r
 584         pxMessage = &( xISRMessages[ ( ulNextMessage & usbQUEUE_LENGTH ) ] );\r
 585         ulNextMessage++;\r
 586 \r
 587         /* Take a snapshot of the current USB state for processing at the task\r
 588         level. */\r
 589         pxMessage->ulISR = AT91C_BASE_UDP->UDP_ISR;\r
 590         pxMessage->ulCSR0 = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];\r
 591 \r
 592         /* Clear the interrupts from the ICR register.  The bus end interrupt is\r
 593         cleared separately as it does not appear in the mask register. */\r
 594         AT91C_BASE_UDP->UDP_ICR = AT91C_BASE_UDP->UDP_IMR | AT91C_UDP_ENDBUSRES;\r
 595         \r
 596         /* If there are bytes in the FIFO then we have to retrieve them here.\r
 597         Ideally this would be done at the task level.  However we need to clear the\r
 598         RXSETUP interrupt before leaving the ISR, and this may cause the data in\r
 599         the FIFO to be overwritten.  Also the DIR bit has to be changed before the\r
 600         RXSETUP bit is cleared (as per the SAM7 manual). */\r
 601         ulTemp = pxMessage->ulCSR0;\r
 602         \r
 603         /* Are there any bytes in the FIFO? */\r
 604         ulRxBytes = ulTemp >> 16;\r
 605         ulRxBytes &= usbRX_COUNT_MASK;\r
 606         \r
 607         /* With this minimal implementation we are only interested in receiving\r
 608         setup bytes on the control end point. */\r
 609         if( ( ulRxBytes > 0 ) && ( ulTemp & AT91C_UDP_RXSETUP ) )\r
 610         {\r
 611                 /* Take off 1 for a zero based index. */\r
 612                 while( ulRxBytes > 0 )\r
 613                 {\r
 614                         ulRxBytes--;\r
 615                         pxMessage->ucFifoData[ ulRxBytes ] = AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_0 ];                 \r
 616                 }\r
 617                 \r
 618                 /* The direction must be changed first. */\r
 619                 usbCSR_SET_BIT( &ulTemp, ( AT91C_UDP_DIR ) );\r
 620                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulTemp;\r
 621         }\r
 622         \r
 623         /* Must write zero's to TXCOMP, STALLSENT, RXSETUP, and the RX DATA\r
 624         registers to clear the interrupts in the CSR register. */\r
 625         usbCSR_CLEAR_BIT( &ulTemp, usbINT_CLEAR_MASK );\r
 626         AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulTemp;\r
 627 \r
 628         /* Also clear the interrupts in the CSR1 register. */\r
 629         ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ];\r
 630         usbCSR_CLEAR_BIT( &ulTemp, usbINT_CLEAR_MASK ); \r
 631         AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] = ulTemp;\r
 632 \r
 633         /* The message now contains the entire state and optional data from\r
 634         the USB interrupt.  This can now be posted on the Rx queue ready for\r
 635         processing at the task level. */\r
 636         xQueueSendFromISR( xUSBInterruptQueue, &pxMessage, &xHigherPriorityTaskWoken );\r
 637 \r
 638         /* We may want to switch to the USB task, if this message has made\r
 639         it the highest priority task that is ready to execute. */\r
 640         portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
 641 \r
 642         /* Clear the AIC ready for the next interrupt. */               \r
 643         AT91C_BASE_AIC->AIC_EOICR = 0;\r
 644 }\r
 645 /*-----------------------------------------------------------*/\r
 646 \r
 647 void vUSBDemoTask( void *pvParameters )\r
 648 {\r
 649 xISRStatus *pxMessage;\r
 650 \r
 651         /* The parameters are not used in this task. */\r
 652         ( void ) pvParameters;\r
 653 \r
 654     /* Init USB device */\r
 655     portENTER_CRITICAL();\r
 656             vInitUSBInterface();\r
 657     portEXIT_CRITICAL();\r
 658 \r
 659         /* Process interrupts as they arrive.   The ISR takes a snapshot of the\r
 660         interrupt status then posts the information on this queue for processing\r
 661         at the task level.  This simple demo implementation only processes\r
 662         a few interrupt sources. */\r
 663         for( ;; )\r
 664         {\r
 665                 if( xQueueReceive( xUSBInterruptQueue, &pxMessage, usbSHORT_DELAY ) )\r
 666                 {\r
 667                         if( pxMessage->ulISR & AT91C_UDP_EPINT0 )\r
 668                         {\r
 669                                 /* Process end point 0 interrupt. */\r
 670                                 prvProcessEndPoint0Interrupt( pxMessage );\r
 671                         }\r
 672 \r
 673                         if( pxMessage->ulISR & AT91C_UDP_ENDBUSRES )\r
 674                         {\r
 675                                 /* Process an end of bus reset interrupt. */\r
 676                                 prvResetEndPoints();            \r
 677                         }\r
 678                 }\r
 679                 else\r
 680                 {\r
 681                         /* The ISR did not post any data for us to process on the queue, so\r
 682                         just generate and send some sample data. */\r
 683                         if( eDriverState == eREADY_TO_SEND )\r
 684                         {\r
 685                                 prvTransmitSampleValues();\r
 686                         }\r
 687                 }\r
 688         }\r
 689 }\r
 690 /*-----------------------------------------------------------*/\r
 691 \r
 692 static void prvTransmitSampleValues( void )\r
 693 {\r
 694 unsigned portLONG ulStatus;\r
 695 static portLONG lState = usbXUP;\r
 696 \r
 697 /* Variables to hold dummy x, y and z joystick axis data. */\r
 698 static signed portCHAR x = 0, y = 0, z = 0;\r
 699 \r
 700         /* Generate some sample data in the x and y axis - draw a square. */\r
 701         switch( lState )\r
 702         {\r
 703                 case usbXUP     :       x += usbDATA_INC;\r
 704                                                 if( x >= usbMAX_COORD )\r
 705                                                 {\r
 706                                                         lState = usbYUP;\r
 707                                                 }\r
 708                                                 break;\r
 709                                                 \r
 710                 case usbXDOWN : x -= usbDATA_INC;\r
 711                                                 if( x <= -usbMAX_COORD )\r
 712                                                 {\r
 713                                                         lState = usbYDOWN;\r
 714                                                 }\r
 715                                                 break;\r
 716                                                 \r
 717                 case usbYUP :   y += usbDATA_INC;\r
 718                                                 if( y >= usbMAX_COORD )\r
 719                                                 {\r
 720                                                         lState = usbXDOWN;\r
 721                                                 }\r
 722                                                 break;\r
 723                                                 \r
 724                 case usbYDOWN : y -= usbDATA_INC;\r
 725                                                 if( y <= -usbMAX_COORD )\r
 726                                                 {\r
 727                                                         lState = usbXUP;\r
 728                                                 }\r
 729                                                 break;\r
 730         }\r
 731 \r
 732         /* Just make the z axis go up and down. */\r
 733         z += usbDATA_INC;\r
 734 \r
 735         /* Can we place data in the fifo? */\r
 736         if( !( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] & AT91C_UDP_TXPKTRDY ) )\r
 737         {\r
 738                 /* Write our sample data to the fifo. */\r
 739                 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_1 ] = x;\r
 740                 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_1 ] = y;\r
 741                 AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_1 ] = z;\r
 742                 \r
 743                 /* Send the data. */\r
 744                 portENTER_CRITICAL();\r
 745                 {\r
 746                         ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ];\r
 747                         usbCSR_SET_BIT( &ulStatus, ( AT91C_UDP_TXPKTRDY ) );\r
 748                         AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] = ulStatus;\r
 749                 }\r
 750                 portEXIT_CRITICAL();\r
 751         }\r
 752 }\r
 753 /*-----------------------------------------------------------*/\r
 754 \r
 755 static void prvUSBTransmitNull( void )\r
 756 {\r
 757 unsigned portLONG ulStatus;\r
 758 \r
 759         /* Wait until the FIFO is free - even though we are not going to use it.\r
 760         THERE IS NO TIMEOUT HERE! */\r
 761         while( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] & AT91C_UDP_TXPKTRDY )\r
 762         {\r
 763                 vTaskDelay( usbSHORTEST_DELAY );\r
 764         }\r
 765 \r
 766         portENTER_CRITICAL();\r
 767         {\r
 768                 /* Set the length of data to send to equal the index of the next byte\r
 769                 to send.  This will prevent the ACK to this NULL packet causing any\r
 770                 further data transmissions. */\r
 771                 pxCharsForTx.ulTotalDataLength = pxCharsForTx.ulNextCharIndex;\r
 772 \r
 773                 /* Set the TXPKTRDY bit to cause a transmission with no data. */\r
 774                 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];\r
 775                 usbCSR_SET_BIT( &ulStatus, ( AT91C_UDP_TXPKTRDY ) );\r
 776                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;\r
 777         }\r
 778         portEXIT_CRITICAL();\r
 779 }\r
 780 /*-----------------------------------------------------------*/\r
 781 \r
 782 static void prvSendStall( void )\r
 783 {\r
 784 unsigned portLONG ulStatus;\r
 785 \r
 786         portENTER_CRITICAL();\r
 787         {\r
 788                 /* Force a stall by simply setting the FORCESTALL bit in the CSR. */\r
 789                 ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];\r
 790                 usbCSR_SET_BIT( &ulStatus, AT91C_UDP_FORCESTALL );\r
 791                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;\r
 792         }\r
 793         portEXIT_CRITICAL();\r
 794 }\r
 795 /*-----------------------------------------------------------*/\r
 796 \r
 797 static void prvResetEndPoints( void )\r
 798 {\r
 799 unsigned portLONG ulTemp;\r
 800 \r
 801         eDriverState = eJUST_RESET;\r
 802 \r
 803         /* Reset all the end points. */\r
 804         AT91C_BASE_UDP->UDP_RSTEP  = usbEND_POINT_RESET_MASK;\r
 805         AT91C_BASE_UDP->UDP_RSTEP  = ( unsigned portLONG ) 0x00;\r
 806 \r
 807         /* Enable data to be sent and received. */\r
 808         AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;\r
 809 \r
 810         /* Repair the configuration end point. */\r
 811         portENTER_CRITICAL();\r
 812         {\r
 813                 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];\r
 814                 usbCSR_SET_BIT( &ulTemp, ( ( unsigned portLONG ) ( AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL ) ) );\r
 815                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulTemp;\r
 816                 AT91F_UDP_EnableIt( AT91C_BASE_UDP, AT91C_UDP_EPINT0 );\r
 817         }\r
 818         portEXIT_CRITICAL();\r
 819 }\r
 820 /*-----------------------------------------------------------*/\r
 821 \r
 822 static void prvProcessEndPoint0Interrupt( xISRStatus *pxMessage )\r
 823 {\r
 824         if( pxMessage->ulCSR0 & AT91C_UDP_RX_DATA_BK0 )\r
 825         {               \r
 826                 /* We only expect to receive zero length data here as ACK's.\r
 827                 Set the data pointer to the end of the current Tx packet to\r
 828                 ensure we don't send out any more data. */      \r
 829                 pxCharsForTx.ulNextCharIndex = pxCharsForTx.ulTotalDataLength;\r
 830         }\r
 831 \r
 832         if( pxMessage->ulCSR0 & AT91C_UDP_TXCOMP )\r
 833         {\r
 834                 /* We received a TX complete interrupt.  What we do depends on\r
 835                 what we sent to get this interrupt. */\r
 836 \r
 837                 if( eDriverState == eJUST_GOT_CONFIG )\r
 838                 {\r
 839                         /* We sent an acknowledgement of a SET_CONFIG request.  We\r
 840                         are now at the end of the enumeration. */\r
 841                         AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_CONFG;\r
 842 \r
 843                         /* Read the end point for data transfer. */\r
 844                         portENTER_CRITICAL();\r
 845                         {\r
 846                                 unsigned portLONG ulTemp;\r
 847 \r
 848                                 ulTemp = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ];                                     \r
 849                                 usbCSR_SET_BIT( &ulTemp, AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_INT_IN );\r
 850                                 AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_1 ] = ulTemp;             \r
 851                                 AT91F_UDP_EnableIt( AT91C_BASE_UDP, AT91C_UDP_EPINT1 );\r
 852                         }\r
 853                         portEXIT_CRITICAL();\r
 854 \r
 855                         eDriverState = eREADY_TO_SEND;\r
 856                 }               \r
 857                 else if( eDriverState == eJUST_GOT_ADDRESS )\r
 858                 {\r
 859                         /* We sent an acknowledgement of a SET_ADDRESS request.  Move\r
 860                         to the addressed state. */\r
 861                         if( ulReceivedAddress != ( unsigned portLONG ) 0 )\r
 862                         {                       \r
 863                                 AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;\r
 864                         }\r
 865                         else\r
 866                         {\r
 867                                 AT91C_BASE_UDP->UDP_GLBSTATE = 0;\r
 868                         }                       \r
 869 \r
 870                         AT91C_BASE_UDP->UDP_FADDR = ( AT91C_UDP_FEN | ulReceivedAddress );              \r
 871                         eDriverState = eNOTHING;\r
 872                 }\r
 873                 else\r
 874                 {               \r
 875                         /* The TXCOMP was not for any special type of transmission.  See\r
 876                         if there is any more data to send. */\r
 877                         prvSendNextSegment();\r
 878                 }\r
 879         }\r
 880 \r
 881         if( pxMessage->ulCSR0 & AT91C_UDP_RXSETUP )\r
 882         {\r
 883                 xUSB_REQUEST xRequest;\r
 884                 unsigned portCHAR ucRequest;\r
 885                 unsigned portLONG ulRxBytes;\r
 886 \r
 887                 /* A data packet is available. */       \r
 888                 ulRxBytes = pxMessage->ulCSR0 >> 16;\r
 889                 ulRxBytes &= usbRX_COUNT_MASK;\r
 890 \r
 891                 if( ulRxBytes >= usbEXPECTED_NUMBER_OF_BYTES )\r
 892                 {\r
 893                         /* Create an xUSB_REQUEST variable from the raw bytes array. */\r
 894 \r
 895                         xRequest.ucReqType = pxMessage->ucFifoData[ usbREQUEST_TYPE_INDEX ];\r
 896                         xRequest.ucRequest = pxMessage->ucFifoData[ usbREQUEST_INDEX ];\r
 897 \r
 898                         /* NOT PORTABLE CODE! */\r
 899                         xRequest.usValue = pxMessage->ucFifoData[ usbVALUE_HIGH_BYTE ];\r
 900                         xRequest.usValue <<= 8;\r
 901                         xRequest.usValue |= pxMessage->ucFifoData[ usbVALUE_LOW_BYTE ];\r
 902                                                 \r
 903                         xRequest.usIndex = pxMessage->ucFifoData[ usbINDEX_HIGH_BYTE ];\r
 904                         xRequest.usIndex <<= 8;\r
 905                         xRequest.usIndex |= pxMessage->ucFifoData[ usbINDEX_LOW_BYTE ];\r
 906                         \r
 907                         xRequest.usLength = pxMessage->ucFifoData[ usbLENGTH_HIGH_BYTE ];\r
 908                         xRequest.usLength <<= 8;\r
 909                         xRequest.usLength |= pxMessage->ucFifoData[ usbLENGTH_LOW_BYTE ];\r
 910         \r
 911                         /* Manipulate the ucRequestType and the ucRequest parameters to\r
 912                         generate a zero based request selection.  This is just done to\r
 913                         break up the requests into subsections for clarity.  The\r
 914                         alternative would be to have more huge switch statement that would\r
 915                         be difficult to optimise. */\r
 916                         ucRequest = ( ( xRequest.ucReqType & 0x60 ) >> 3 );\r
 917                         ucRequest |= ( xRequest.ucReqType & 0x03 );\r
 918 \r
 919                         switch( ucRequest )\r
 920                         {\r
 921                                 case usbSTANDARD_DEVICE_REQUEST:        \r
 922                                                         /* Standard Device request */\r
 923                                                         prvHandleStandardDeviceRequest( &xRequest );\r
 924                                                         break;\r
 925         \r
 926                                 case usbSTANDARD_INTERFACE_REQUEST:     \r
 927                                                         /* Standard Interface request */\r
 928                                                         prvHandleStandardInterfaceRequest( &xRequest );\r
 929                                                         break;\r
 930         \r
 931                                 case usbSTANDARD_END_POINT_REQUEST:     \r
 932                                                         /* Standard Endpoint request */\r
 933                                                         prvHandleStandardEndPointRequest( &xRequest );\r
 934                                                         break;\r
 935         \r
 936                                 case usbCLASS_INTERFACE_REQUEST:        \r
 937                                                         /* Class Interface request */\r
 938                                                         prvHandleClassInterfaceRequest( &xRequest );\r
 939                                                         break;\r
 940         \r
 941                                 default:        /* This is not something we want to respond to. */\r
 942                                                         prvSendStall(); \r
 943                         }\r
 944                 }\r
 945         }\r
 946 }\r
 947 /*-----------------------------------------------------------*/\r
 948 \r
 949 static void prvGetStandardDeviceDescriptor( xUSB_REQUEST *pxRequest )\r
 950 {\r
 951         /* The type is in the high byte.  Return whatever has been requested. */\r
 952         switch( ( pxRequest->usValue & 0xff00 ) >> 8 )\r
 953         {\r
 954             case usbDESCRIPTOR_TYPE_DEVICE:\r
 955                         prvSendControlData( ( unsigned portCHAR * ) &pxDeviceDescriptor, pxRequest->usLength, sizeof( pxDeviceDescriptor ), pdTRUE );\r
 956                     break;\r
 957         \r
 958             case usbDESCRIPTOR_TYPE_CONFIGURATION:\r
 959                         prvSendControlData( ( unsigned portCHAR * ) &( pxConfigDescriptor ), pxRequest->usLength, sizeof( pxConfigDescriptor ), pdTRUE );\r
 960                     break;\r
 961 \r
 962             case usbDESCRIPTOR_TYPE_STRING:\r
 963 \r
 964                         /* The index to the string descriptor is the lower byte. */\r
 965                     switch( pxRequest->usValue & 0xff )\r
 966                         {                       \r
 967                         case usbLANGUAGE_STRING:\r
 968                                         prvSendControlData( ( unsigned portCHAR * ) &pxLanguageStringDescriptor, pxRequest->usLength, sizeof(pxLanguageStringDescriptor), pdTRUE );\r
 969                                 break;\r
 970 \r
 971                         case usbMANUFACTURER_STRING:\r
 972                                         prvSendControlData( ( unsigned portCHAR * ) &pxManufacturerStringDescriptor, pxRequest->usLength, sizeof( pxManufacturerStringDescriptor ), pdTRUE );\r
 973                                 break;\r
 974 \r
 975                         case usbPRODUCT_STRING:\r
 976                                         prvSendControlData( ( unsigned portCHAR * ) &pxProductStringDescriptor, pxRequest->usLength, sizeof( pxProductStringDescriptor ), pdTRUE );\r
 977                                 break;\r
 978 \r
 979                         case usbCONFIGURATION_STRING:\r
 980                                         prvSendControlData( ( unsigned portCHAR * ) &pxConfigurationStringDescriptor, pxRequest->usLength, sizeof( pxConfigurationStringDescriptor ), pdTRUE );\r
 981                                 break;\r
 982 \r
 983                         case usbINTERFACE_STRING:\r
 984                                         prvSendControlData( ( unsigned portCHAR * ) &pxInterfaceStringDescriptor, pxRequest->usLength, sizeof( pxInterfaceStringDescriptor ), pdTRUE );\r
 985                                 break;\r
 986 \r
 987                         default:\r
 988                                 /* Don't know what this string is. */\r
 989                                         prvSendStall();\r
 990                                         break;\r
 991                         }\r
 992 \r
 993                         break;\r
 994 \r
 995             default:\r
 996                         /* We are not responding to anything else. */\r
 997                         prvSendStall();\r
 998                     break;\r
 999         }\r
1000 }\r
1001 /*-----------------------------------------------------------*/\r
1002 \r
1003 static void prvHandleStandardDeviceRequest( xUSB_REQUEST *pxRequest )\r
1004 {\r
1005 unsigned portSHORT usStatus = 0;\r
1006 \r
1007         switch( pxRequest->ucRequest )\r
1008         {\r
1009             case usbGET_STATUS_REQUEST:\r
1010                         /* Just send two byte dummy status. */\r
1011                         prvSendControlData( ( unsigned portCHAR * ) &usStatus, sizeof( usStatus ), sizeof( usStatus ), pdFALSE );\r
1012                     break;\r
1013 \r
1014             case usbGET_DESCRIPTOR_REQUEST:\r
1015                         /* Send device descriptor */\r
1016                     prvGetStandardDeviceDescriptor( pxRequest );\r
1017                     break;\r
1018 \r
1019             case usbGET_CONFIGURATION_REQUEST:\r
1020                         /* Send selected device configuration */\r
1021                         prvSendControlData( ( unsigned portCHAR * ) &ucUSBConfig, sizeof( ucUSBConfig ), sizeof( ucUSBConfig ), pdFALSE );\r
1022                     break;\r
1023 \r
1024                 case usbSET_FEATURE_REQUEST:\r
1025                     prvUSBTransmitNull();\r
1026                     break;\r
1027 \r
1028             case usbSET_ADDRESS_REQUEST:\r
1029                 \r
1030                         /* Acknowledge the SET_ADDRESS, but (according to the manual) we\r
1031                         cannot actually move to the addressed state until we get a TXCOMP\r
1032                         interrupt from this NULL packet.  Therefore we just remember the\r
1033                         address and set our state so we know we have received the address. */\r
1034                 prvUSBTransmitNull();                   \r
1035                         eDriverState = eJUST_GOT_ADDRESS;               \r
1036                         ulReceivedAddress = ( unsigned portLONG ) pxRequest->usValue;\r
1037                     break;\r
1038 \r
1039             case usbSET_CONFIGURATION_REQUEST:\r
1040 \r
1041                         /* Acknowledge the SET_CONFIGURATION, but (according to the manual)\r
1042                         we cannot actually move to the configured state until we get a\r
1043                         TXCOMP interrupt from this NULL packet.  Therefore we just remember the\r
1044                         config and set our state so we know we have received the go ahead. */                   \r
1045                         ucUSBConfig = ( unsigned portCHAR ) ( pxRequest->usValue & 0xff );\r
1046                         eDriverState = eJUST_GOT_CONFIG;\r
1047                         prvUSBTransmitNull();\r
1048                     break;\r
1049 \r
1050             default:\r
1051 \r
1052                     /* We don't answer to anything else. */\r
1053                         prvSendStall();\r
1054                     break;\r
1055         }\r
1056 }\r
1057 /*-----------------------------------------------------------*/\r
1058 \r
1059 static void prvHandleClassInterfaceRequest( xUSB_REQUEST *pxRequest )\r
1060 {\r
1061         switch( pxRequest->ucRequest )\r
1062         {\r
1063             case usbSET_IDLE_REQUEST:\r
1064                 prvUSBTransmitNull();\r
1065                         break;\r
1066 \r
1067                 /* This minimal implementation ignores these. */\r
1068             case usbGET_REPORT_REQUEST:\r
1069             case usbGET_IDLE_REQUEST:\r
1070             case usbGET_PROTOCOL_REQUEST:\r
1071             case usbSET_REPORT_REQUEST:\r
1072             case usbSET_PROTOCOL_REQUEST:       \r
1073             default:\r
1074 \r
1075                         prvSendStall();\r
1076                         break;\r
1077         }\r
1078 }\r
1079 /*-----------------------------------------------------------*/\r
1080 \r
1081 static void prvGetStandardInterfaceDescriptor( xUSB_REQUEST *pxRequest )\r
1082 {\r
1083         switch( ( pxRequest->usValue & ( unsigned portSHORT ) 0xff00 ) >> 8 )\r
1084         {\r
1085             case usbHID_REPORT_DESCRIPTOR:\r
1086                         prvSendControlData( ( unsigned portCHAR * ) pxReportDescriptor, pxRequest->usLength, sizeof( pxReportDescriptor ), pdTRUE );\r
1087                     break;\r
1088 \r
1089             default:\r
1090 \r
1091                         /* Don't expect to send any others. */\r
1092                         prvSendStall();\r
1093                     break;\r
1094         }\r
1095 }\r
1096 /*-----------------------------------------------------------*/\r
1097 \r
1098 static void prvHandleStandardInterfaceRequest( xUSB_REQUEST *pxRequest )\r
1099 {\r
1100 unsigned portSHORT usStatus = 0;\r
1101 \r
1102         switch( pxRequest->ucRequest )\r
1103         {\r
1104             case usbGET_STATUS_REQUEST:\r
1105                         /* Send dummy 2 bytes. */\r
1106                         prvSendControlData( ( unsigned portCHAR * ) &usStatus, sizeof( usStatus ), sizeof( usStatus ), pdFALSE );\r
1107                         break;\r
1108 \r
1109             case usbGET_DESCRIPTOR_REQUEST:\r
1110                         prvGetStandardInterfaceDescriptor( pxRequest );\r
1111                         break;\r
1112 \r
1113                 /* This minimal implementation does not respond to these. */\r
1114             case usbGET_INTERFACE_REQUEST:\r
1115             case usbSET_FEATURE_REQUEST:\r
1116             case usbSET_INTERFACE_REQUEST:      \r
1117 \r
1118             default:\r
1119                         prvSendStall();\r
1120                         break;\r
1121         }\r
1122 }\r
1123 /*-----------------------------------------------------------*/\r
1124 \r
1125 static void prvHandleStandardEndPointRequest( xUSB_REQUEST *pxRequest )\r
1126 {\r
1127         switch( pxRequest->ucRequest )\r
1128         {\r
1129                 /* This minimal implementation does not expect to respond to these. */\r
1130             case usbGET_STATUS_REQUEST:\r
1131             case usbCLEAR_FEATURE_REQUEST:\r
1132             case usbSET_FEATURE_REQUEST:\r
1133 \r
1134             default:                    \r
1135                         prvSendStall();\r
1136                         break;\r
1137         }\r
1138 }\r
1139 /*-----------------------------------------------------------*/\r
1140 \r
1141 static void vInitUSBInterface( void )\r
1142 {\r
1143 volatile unsigned portLONG ulTemp;\r
1144 \r
1145         /* Create the queue used to communicate between the USB ISR and task. */\r
1146         xUSBInterruptQueue = xQueueCreate( usbQUEUE_LENGTH + 1, sizeof( xISRStatus * ) );\r
1147 \r
1148         /* Initialise a few state variables. */\r
1149         pxCharsForTx.ulNextCharIndex = ( unsigned portLONG ) 0;\r
1150         ucUSBConfig = ( unsigned portCHAR ) 0;\r
1151         eDriverState = eNOTHING;\r
1152 \r
1153         /* HARDWARE SETUP */\r
1154 \r
1155     /* Set the PLL USB Divider */\r
1156     AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1;\r
1157 \r
1158     /* Enables the 48MHz USB clock UDPCK and System Peripheral USB Clock. */\r
1159     AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_UDP;\r
1160     AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_UDP);\r
1161 \r
1162     /* Setup the PIO for the USB pull up resistor. */\r
1163     AT91F_PIO_CfgOutput(AT91C_BASE_PIOA,AT91C_PIO_PA16);\r
1164 \r
1165     /* Start without the pullup - this will get set at the end of this\r
1166         function. */\r
1167     AT91F_PIO_SetOutput( AT91C_BASE_PIOA, AT91C_PIO_PA16 );\r
1168 \r
1169         /* When using the USB debugger the peripheral registers do not always get\r
1170         set to the correct default values.  To make sure set the relevant registers\r
1171         manually here. */\r
1172         AT91C_BASE_UDP->UDP_IDR = ( unsigned portLONG ) 0xffffffff;\r
1173         AT91C_BASE_UDP->UDP_ICR = ( unsigned portLONG ) 0xffffffff;\r
1174         AT91C_BASE_UDP->UDP_CSR[ 0 ] = ( unsigned portLONG ) 0x00;\r
1175         AT91C_BASE_UDP->UDP_CSR[ 1 ] = ( unsigned portLONG ) 0x00;\r
1176         AT91C_BASE_UDP->UDP_GLBSTATE = 0;\r
1177         AT91C_BASE_UDP->UDP_FADDR = 0;\r
1178 \r
1179         /* Enable the transceiver. */\r
1180         AT91C_UDP_TRANSCEIVER_ENABLE = 0;\r
1181 \r
1182         /* Enable the USB interrupts - other interrupts get enabled as the\r
1183         enumeration process progresses. */\r
1184         AT91F_AIC_ConfigureIt( AT91C_BASE_AIC, AT91C_ID_UDP, usbINTERRUPT_PRIORITY, AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE, ( void (*)( void ) ) vUSBISREntry );\r
1185         AT91F_AIC_EnableIt( AT91C_BASE_AIC, AT91C_ID_UDP );\r
1186 \r
1187         /* Wait a short while before making our presence known. */\r
1188         vTaskDelay( usbINIT_DELAY );\r
1189     AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, AT91C_PIO_PA16 );\r
1190 }\r
1191 /*-----------------------------------------------------------*/\r
1192 \r
1193 static void prvSendControlData( unsigned portCHAR *pucData, unsigned portSHORT usRequestedLength, unsigned portLONG ulLengthToSend, portLONG lSendingDescriptor )\r
1194 {\r
1195         if( ( ( unsigned portLONG ) usRequestedLength < ulLengthToSend ) )\r
1196         {\r
1197                 /* Cap the data length to that requested. */\r
1198                 ulLengthToSend = ( unsigned portSHORT ) usRequestedLength;\r
1199         }\r
1200         else if( ( ulLengthToSend < ( unsigned portLONG ) usRequestedLength ) && lSendingDescriptor )\r
1201         {\r
1202                 /* We are sending a descriptor.  If the descriptor is an exact\r
1203                 multiple of the FIFO length then it will have to be terminated\r
1204                 with a NULL packet.  Set the state to indicate this if\r
1205                 necessary. */\r
1206                 if( ( ulLengthToSend % usbFIFO_LENGTH ) == 0 )\r
1207                 {\r
1208                         eDriverState = eSENDING_EVEN_DESCRIPTOR;\r
1209                 }\r
1210         }\r
1211 \r
1212         /* Here we assume that the previous message has been sent.  THERE IS NO\r
1213         BUFFER OVERFLOW PROTECTION HERE.\r
1214 \r
1215         Copy the data to send into the buffer as we cannot send it all at once\r
1216         (if it is greater than 8 bytes in length). */\r
1217         memcpy( pxCharsForTx.ucTxBuffer, pucData, ulLengthToSend );\r
1218 \r
1219         /* Reinitialise the buffer index so we start sending from the start of\r
1220         the data. */\r
1221         pxCharsForTx.ulTotalDataLength = ulLengthToSend;\r
1222         pxCharsForTx.ulNextCharIndex = ( unsigned portLONG ) 0;\r
1223 \r
1224         /* Send the first 8 bytes now.  The rest will get sent in response to\r
1225         TXCOMP interrupts. */\r
1226         prvSendNextSegment();\r
1227 }\r
1228 /*-----------------------------------------------------------*/\r
1229 \r
1230 static void prvSendNextSegment( void )\r
1231 {\r
1232 volatile unsigned portLONG ulNextLength, ulStatus, ulLengthLeftToSend;\r
1233 \r
1234         /* Is there any data to send? */\r
1235         if( pxCharsForTx.ulTotalDataLength > pxCharsForTx.ulNextCharIndex )\r
1236         {\r
1237                 ulLengthLeftToSend = pxCharsForTx.ulTotalDataLength - pxCharsForTx.ulNextCharIndex;\r
1238         \r
1239                 /* We can only send 8 bytes to the fifo at a time. */\r
1240                 if( ulLengthLeftToSend > usbFIFO_LENGTH )\r
1241                 {\r
1242                         ulNextLength = usbFIFO_LENGTH;\r
1243                 }\r
1244                 else\r
1245                 {\r
1246                         ulNextLength = ulLengthLeftToSend;\r
1247                 }\r
1248 \r
1249                 /* Wait until we can place data in the fifo.  THERE IS NO TIMEOUT\r
1250                 HERE! */\r
1251                 while( AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] & AT91C_UDP_TXPKTRDY )\r
1252                 {\r
1253                         vTaskDelay( usbSHORTEST_DELAY );\r
1254                 }\r
1255 \r
1256                 /* Write the data to the FIFO. */\r
1257                 while( ulNextLength > ( unsigned portLONG ) 0 )\r
1258                 {\r
1259                         AT91C_BASE_UDP->UDP_FDR[ usbEND_POINT_0 ] = pxCharsForTx.ucTxBuffer[ pxCharsForTx.ulNextCharIndex ];\r
1260         \r
1261                         ulNextLength--;\r
1262                         pxCharsForTx.ulNextCharIndex++;\r
1263                 }\r
1264         \r
1265                 /* Start the transmission. */\r
1266                 portENTER_CRITICAL();\r
1267                 {\r
1268                         ulStatus = AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ];\r
1269                         usbCSR_SET_BIT( &ulStatus, ( ( unsigned portLONG ) 0x10 ) );\r
1270                         AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_0 ] = ulStatus;\r
1271                 }\r
1272                 portEXIT_CRITICAL();\r
1273         }\r
1274         else\r
1275         {\r
1276                 /* There is no data to send.  If we were sending a descriptor and the\r
1277                 descriptor was an exact multiple of the max packet size then we need\r
1278                 to send a null to terminate the transmission. */\r
1279                 if( eDriverState == eSENDING_EVEN_DESCRIPTOR )\r
1280                 {\r
1281                         prvUSBTransmitNull();\r
1282                         eDriverState = eNOTHING;\r
1283                 }\r
1284         }\r
1285 }\r
1286 \r
1287 \r
1288 \r