git.sur5r.net Git - freertos/blob - FreeRTOS-Plus/Demo/FreeRTOS_Plus_UDP_and_CLI_LPC1830_GCC/ThirdParty/USB_CDC/cdcuser.c

   1 /*----------------------------------------------------------------------------\r
   2  *      U S B  -  K e r n e l\r
   3  *----------------------------------------------------------------------------\r
   4  *      Name:    cdcuser.c\r
   5  *      Purpose: USB Communication Device Class User module\r
   6  *      Version: V1.10\r
   7  *----------------------------------------------------------------------------\r
   8 *      This software is supplied "AS IS" without any warranties, express,\r
   9  *      implied or statutory, including but not limited to the implied\r
  10  *      warranties of fitness for purpose, satisfactory quality and\r
  11  *      noninfringement. Keil extends you a royalty-free right to reproduce\r
  12  *      and distribute executable files created using this software for use\r
  13  *      on NXP Semiconductors LPC microcontroller devices only. Nothing else\r
  14  *      gives you the right to use this software.\r
  15  *\r
  16  * Copyright (c) 2009 Keil - An ARM Company. All rights reserved.\r
  17  *---------------------------------------------------------------------------*/\r
  18 \r
  19 #include "lpc_types.h"\r
  20 \r
  21 #include "usb.h"\r
  22 #include "usbhw.h"\r
  23 #include "usbcfg.h"\r
  24 #include "usbcore.h"\r
  25 #include "cdc.h"\r
  26 #include "cdcuser.h"\r
  27 \r
  28 #ifdef __ICCARM__\r
  29 #pragma data_alignment=4\r
  30 #define __align(x)\r
  31 #elif defined   (  __GNUC__  )\r
  32 #define __align(x) __attribute__((aligned(x)))\r
  33 #endif\r
  34 \r
  35 unsigned char __align(4) BulkBufOut [USB_CDC_BUFSIZE];            // Buffer to store USB OUT packet\r
  36 \r
  37 #ifdef __ICCARM__\r
  38 #undef __align(x)\r
  39 #endif\r
  40 \r
  41 /*----------------------------------------------------------------------------\r
  42   We need a buffer for incomming data on USB port because USB receives\r
  43   much faster than  UART transmits\r
  44  *---------------------------------------------------------------------------*/\r
  45 /* Buffer masks */\r
  46 #define CDC_BUF_SIZE               (64)               // Output buffer in bytes (power 2)\r
  47                                                        // large enough for file transfer\r
  48 #define CDC_BUF_MASK               (CDC_BUF_SIZE-1ul)\r
  49 \r
  50 /* Buffer read / write macros */\r
  51 #define CDC_BUF_RESET(cdcBuf)      (cdcBuf.rdIdx = cdcBuf.wrIdx = 0)\r
  52 #define CDC_BUF_WR(cdcBuf, dataIn) (cdcBuf.data[CDC_BUF_MASK & cdcBuf.wrIdx++] = (dataIn))\r
  53 #define CDC_BUF_RD(cdcBuf)         (cdcBuf.data[CDC_BUF_MASK & cdcBuf.rdIdx++])\r
  54 #define CDC_BUF_EMPTY(cdcBuf)      (cdcBuf.rdIdx == cdcBuf.wrIdx)\r
  55 #define CDC_BUF_FULL(cdcBuf)       (cdcBuf.rdIdx == cdcBuf.wrIdx+1)\r
  56 #define CDC_BUF_COUNT(cdcBuf)      (CDC_BUF_MASK & (cdcBuf.wrIdx - cdcBuf.rdIdx))\r
  57 \r
  58 \r
  59 // CDC output buffer\r
  60 typedef struct __CDC_BUF_T {\r
  61   unsigned char data[CDC_BUF_SIZE];\r
  62   unsigned int wrIdx;\r
  63   unsigned int rdIdx;\r
  64 } CDC_BUF_T;\r
  65 \r
  66 CDC_BUF_T  CDC_OutBuf;                                 // buffer for all CDC Out data\r
  67 \r
  68 /*----------------------------------------------------------------------------\r
  69   read data from CDC_OutBuf\r
  70  *---------------------------------------------------------------------------*/\r
  71 int CDC_RdOutBuf (char *buffer, const int *length) {\r
  72   int bytesToRead, bytesRead;\r
  73 \r
  74   /* Read *length bytes, block if *bytes are not avaialable     */\r
  75   bytesToRead = *length;\r
  76   bytesToRead = (bytesToRead < (*length)) ? bytesToRead : (*length);\r
  77   bytesRead = bytesToRead;\r
  78 \r
  79   // ... add code to check for underrun\r
  80 \r
  81   while (bytesToRead--) {\r
  82     *buffer++ = CDC_BUF_RD(CDC_OutBuf);\r
  83   }\r
  84   return (bytesRead);\r
  85 }\r
  86 \r
  87 /*----------------------------------------------------------------------------\r
  88   write data to CDC_OutBuf\r
  89  *---------------------------------------------------------------------------*/\r
  90 int CDC_WrOutBuf (const char *buffer, int length) {\r
  91   int bytesWritten;\r
  92 \r
  93   // ... add code to check for overwrite\r
  94 \r
  95   for( bytesWritten = 0; bytesWritten < length; bytesWritten++ ) {\r
  96       CDC_BUF_WR(CDC_OutBuf, *buffer++);           // Copy Data to buffer\r
  97   }\r
  98 \r
  99   return (bytesWritten);\r
 100 }\r
 101 \r
 102 /*----------------------------------------------------------------------------\r
 103   check if character(s) are available at CDC_OutBuf\r
 104  *---------------------------------------------------------------------------*/\r
 105 int CDC_OutBufAvailChar (int *availChar) {\r
 106 \r
 107   *availChar = CDC_BUF_COUNT(CDC_OutBuf);\r
 108 \r
 109   return (0);\r
 110 }\r
 111 /* end Buffer handling */\r
 112 \r
 113 \r
 114 \r
 115 /*----------------------------------------------------------------------------\r
 116   CDC SendEncapsulatedCommand Request Callback\r
 117   Called automatically on CDC SEND_ENCAPSULATED_COMMAND Request\r
 118   Parameters:   None                          (global SetupPacket and EP0Buf)\r
 119   Return Value: TRUE - Success, FALSE - Error\r
 120  *---------------------------------------------------------------------------*/\r
 121 uint32_t CDC_SendEncapsulatedCommand (void) {\r
 122 \r
 123   return (TRUE);\r
 124 }\r
 125 \r
 126 \r
 127 /*----------------------------------------------------------------------------\r
 128   CDC GetEncapsulatedResponse Request Callback\r
 129   Called automatically on CDC Get_ENCAPSULATED_RESPONSE Request\r
 130   Parameters:   None                          (global SetupPacket and EP0Buf)\r
 131   Return Value: TRUE - Success, FALSE - Error\r
 132  *---------------------------------------------------------------------------*/\r
 133 uint32_t CDC_GetEncapsulatedResponse (void) {\r
 134 \r
 135   /* ... add code to handle request */\r
 136   return (TRUE);\r
 137 }\r
 138 \r
 139 \r
 140 /*----------------------------------------------------------------------------\r
 141   CDC SetCommFeature Request Callback\r
 142   Called automatically on CDC Set_COMM_FATURE Request\r
 143   Parameters:   FeatureSelector\r
 144   Return Value: TRUE - Success, FALSE - Error\r
 145  *---------------------------------------------------------------------------*/\r
 146 uint32_t CDC_SetCommFeature (unsigned short wFeatureSelector) {\r
 147 \r
 148   /* ... add code to handle request */\r
 149   ( void ) wFeatureSelector;\r
 150   return (TRUE);\r
 151 }\r
 152 \r
 153 \r
 154 /*----------------------------------------------------------------------------\r
 155   CDC GetCommFeature Request Callback\r
 156   Called automatically on CDC Get_COMM_FATURE Request\r
 157   Parameters:   FeatureSelector\r
 158   Return Value: TRUE - Success, FALSE - Error\r
 159  *---------------------------------------------------------------------------*/\r
 160 uint32_t CDC_GetCommFeature (unsigned short wFeatureSelector) {\r
 161 \r
 162   /* ... add code to handle request */\r
 163   ( void ) wFeatureSelector;\r
 164   return (TRUE);\r
 165 }\r
 166 \r
 167 \r
 168 /*----------------------------------------------------------------------------\r
 169   CDC ClearCommFeature Request Callback\r
 170   Called automatically on CDC CLEAR_COMM_FATURE Request\r
 171   Parameters:   FeatureSelector\r
 172   Return Value: TRUE - Success, FALSE - Error\r
 173  *---------------------------------------------------------------------------*/\r
 174 uint32_t CDC_ClearCommFeature (unsigned short wFeatureSelector) {\r
 175 \r
 176   /* ... add code to handle request */\r
 177   ( void ) wFeatureSelector;\r
 178   return (TRUE);\r
 179 }\r
 180 \r
 181 \r
 182 /*----------------------------------------------------------------------------\r
 183   CDC SetLineCoding Request Callback\r
 184   Called automatically on CDC SET_LINE_CODING Request\r
 185   Parameters:   none                    (global SetupPacket and EP0Buf)\r
 186   Return Value: TRUE - Success, FALSE - Error\r
 187  *---------------------------------------------------------------------------*/\r
 188 uint32_t CDC_SetLineCoding (void) {\r
 189   return (TRUE);\r
 190 }\r
 191 \r
 192 \r
 193 /*----------------------------------------------------------------------------\r
 194   CDC GetLineCoding Request Callback\r
 195   Called automatically on CDC GET_LINE_CODING Request\r
 196   Parameters:   None                         (global SetupPacket and EP0Buf)\r
 197   Return Value: TRUE - Success, FALSE - Error\r
 198  *---------------------------------------------------------------------------*/\r
 199 uint32_t CDC_GetLineCoding (void) {\r
 200   return (TRUE);\r
 201 }\r
 202 \r
 203 \r
 204 /*----------------------------------------------------------------------------\r
 205   CDC SetControlLineState Request Callback\r
 206   Called automatically on CDC SET_CONTROL_LINE_STATE Request\r
 207   Parameters:   ControlSignalBitmap\r
 208   Return Value: TRUE - Success, FALSE - Error\r
 209  *---------------------------------------------------------------------------*/\r
 210 uint32_t CDC_SetControlLineState (unsigned short wControlSignalBitmap) {\r
 211 \r
 212   /* ... add code to handle request */\r
 213   ( void ) wControlSignalBitmap;\r
 214   return (TRUE);\r
 215 }\r
 216 \r
 217 \r
 218 /*----------------------------------------------------------------------------\r
 219   CDC SendBreak Request Callback\r
 220   Called automatically on CDC Set_COMM_FATURE Request\r
 221   Parameters:   0xFFFF  start of Break\r
 222                 0x0000  stop  of Break\r
 223                 0x####  Duration of Break\r
 224   Return Value: TRUE - Success, FALSE - Error\r
 225  *---------------------------------------------------------------------------*/\r
 226 uint32_t CDC_SendBreak (unsigned short wDurationOfBreak) {\r
 227 \r
 228   /* ... add code to handle request */\r
 229   ( void ) wDurationOfBreak;\r
 230   return (TRUE);\r
 231 }\r
 232 \r
 233 \r
 234 /*----------------------------------------------------------------------------\r
 235   CDC_BulkIn call on DataIn Request\r
 236   Parameters:   none\r
 237   Return Value: none\r
 238  *---------------------------------------------------------------------------*/\r
 239 void CDC_BulkIn(void) {\r
 240 }\r
 241 \r
 242 \r
 243 /*----------------------------------------------------------------------------\r
 244   CDC_BulkOut call on DataOut Request\r
 245   Parameters:   none\r
 246   Return Value: none\r
 247  *---------------------------------------------------------------------------*/\r
 248 void CDC_BulkOut(void) {\r
 249   int numBytesRead;\r
 250 \r
 251   // get data from USB into intermediate buffer\r
 252   numBytesRead = USB_ReadEP(CDC_DEP_OUT, &BulkBufOut[0]);\r
 253 \r
 254   // ... add code to check for overwrite\r
 255 \r
 256   // store data in a buffer to transmit it over serial interface\r
 257   CDC_WrOutBuf ((char *)&BulkBufOut[0], numBytesRead);\r
 258   vCDCNewDataNotify();\r
 259 }\r
 260 \r
 261 void CDC_BulkOutNak(void){\r
 262 \r
 263     USB_ReadReqEP(CDC_DEP_OUT, &BulkBufOut[0], 64);\r
 264 }\r