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

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