LUFA/Drivers/USB/Class/Device/CDC.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 #define  __INCLUDE_FROM_USB_DRIVER
  32 #include "../../HighLevel/USBMode.h"
  33 #if defined(USB_CAN_BE_DEVICE)
  34
  35 #define  __INCLUDE_FROM_CDC_CLASS_DEVICE_C
  36 #define  __INCLUDE_FROM_CDC_DRIVER
  37 #include "CDC.h"
  38
  39 void CDC_Device_Event_Stub(void)
  40 {
  41
  42 }
  43
  44 void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
  45 {
  46         if (!(Endpoint_IsSETUPReceived()))
  47           return;
  48
  49         if (USB_ControlRequest.wIndex != CDCInterfaceInfo->Config.ControlInterfaceNumber)
  50           return;
  51
  52         switch (USB_ControlRequest.bRequest)
  53         {
  54                 case CDC_REQ_GetLineEncoding:
  55                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
  56                         {
  57                                 Endpoint_ClearSETUP();
  58                                 Endpoint_Write_Control_Stream_LE(&CDCInterfaceInfo->State.LineEncoding, sizeof(CDCInterfaceInfo->State.LineEncoding));
  59                                 Endpoint_ClearOUT();
  60                         }
  61
  62                         break;
  63                 case CDC_REQ_SetLineEncoding:
  64                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  65                         {
  66                                 Endpoint_ClearSETUP();
  67                                 Endpoint_Read_Control_Stream_LE(&CDCInterfaceInfo->State.LineEncoding, sizeof(CDCInterfaceInfo->State.LineEncoding));
  68                                 Endpoint_ClearIN();
  69
  70                                 EVENT_CDC_Device_LineEncodingChanged(CDCInterfaceInfo);
  71                         }
  72
  73                         break;
  74                 case CDC_REQ_SetControlLineState:
  75                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  76                         {
  77                                 Endpoint_ClearSETUP();
  78                                 Endpoint_ClearStatusStage();
  79
  80                                 CDCInterfaceInfo->State.ControlLineStates.HostToDevice = USB_ControlRequest.wValue;
  81
  82                                 EVENT_CDC_Device_ControLineStateChanged(CDCInterfaceInfo);
  83                         }
  84
  85                         break;
  86                 case CDC_REQ_SendBreak:
  87                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  88                         {
  89                                 Endpoint_ClearSETUP();
  90                                 Endpoint_ClearStatusStage();
  91
  92                                 EVENT_CDC_Device_BreakSent(CDCInterfaceInfo, (uint8_t)USB_ControlRequest.wValue);
  93                         }
  94
  95                         break;
  96         }
  97 }
  98
  99 bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 100 {
 101         memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State));
 102
 103         for (uint8_t EndpointNum = 1; EndpointNum < ENDPOINT_TOTAL_ENDPOINTS; EndpointNum++)
 104         {
 105                 uint16_t Size;
 106                 uint8_t  Type;
 107                 uint8_t  Direction;
 108                 bool     DoubleBanked;
 109
 110                 if (EndpointNum == CDCInterfaceInfo->Config.DataINEndpointNumber)
 111                 {
 112                         Size         = CDCInterfaceInfo->Config.DataINEndpointSize;
 113                         Direction    = ENDPOINT_DIR_IN;
 114                         Type         = EP_TYPE_BULK;
 115                         DoubleBanked = CDCInterfaceInfo->Config.DataINEndpointDoubleBank;
 116                 }
 117                 else if (EndpointNum == CDCInterfaceInfo->Config.DataOUTEndpointNumber)
 118                 {
 119                         Size         = CDCInterfaceInfo->Config.DataOUTEndpointSize;
 120                         Direction    = ENDPOINT_DIR_OUT;
 121                         Type         = EP_TYPE_BULK;
 122                         DoubleBanked = CDCInterfaceInfo->Config.DataOUTEndpointDoubleBank;
 123                 }
 124                 else if (EndpointNum == CDCInterfaceInfo->Config.NotificationEndpointNumber)
 125                 {
 126                         Size         = CDCInterfaceInfo->Config.NotificationEndpointSize;
 127                         Direction    = ENDPOINT_DIR_IN;
 128                         Type         = EP_TYPE_INTERRUPT;
 129                         DoubleBanked = CDCInterfaceInfo->Config.NotificationEndpointDoubleBank;
 130                 }
 131                 else
 132                 {
 133                         continue;
 134                 }
 135
 136                 if (!(Endpoint_ConfigureEndpoint(EndpointNum, Type, Direction, Size,
 137                                                                                  DoubleBanked ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
 138                 {
 139                         return false;
 140                 }
 141         }
 142
 143         return true;
 144 }
 145
 146 void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 147 {
 148         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 149           return;
 150
 151         CDC_Device_Flush(CDCInterfaceInfo);
 152 }
 153
 154 uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 155                               const char* const Data,
 156                               const uint16_t Length)
 157 {
 158         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 159           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 160
 161         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 162         return Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);
 163 }
 164
 165 uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 166                             const uint8_t Data)
 167 {
 168         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 169           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 170
 171         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 172
 173         if (!(Endpoint_IsReadWriteAllowed()))
 174         {
 175                 Endpoint_ClearIN();
 176
 177                 uint8_t ErrorCode;
 178
 179                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 180                   return ErrorCode;
 181         }
 182
 183         Endpoint_Write_Byte(Data);
 184         return ENDPOINT_READYWAIT_NoError;
 185 }
 186
 187 uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 188 {
 189         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 190           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 191
 192         uint8_t ErrorCode;
 193
 194         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 195
 196         if (!(Endpoint_BytesInEndpoint()))
 197           return ENDPOINT_READYWAIT_NoError;
 198
 199         bool BankFull = !(Endpoint_IsReadWriteAllowed());
 200
 201         Endpoint_ClearIN();
 202
 203         if (BankFull)
 204         {
 205                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 206                   return ErrorCode;
 207
 208                 Endpoint_ClearIN();
 209         }
 210
 211         return ENDPOINT_READYWAIT_NoError;
 212 }
 213
 214 uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 215 {
 216         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 217           return 0;
 218
 219         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
 220
 221         if (Endpoint_IsOUTReceived())
 222         {
 223                 if (!(Endpoint_BytesInEndpoint()))
 224                 {
 225                         Endpoint_ClearOUT();
 226                         return 0;
 227                 }
 228                 else
 229                 {
 230                         return Endpoint_BytesInEndpoint();
 231                 }
 232         }
 233         else
 234         {
 235                 return 0;
 236         }
 237 }
 238
 239 int16_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 240 {
 241         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 242           return -1;
 243
 244         int16_t ReceivedByte = -1;
 245
 246         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
 247
 248         if (Endpoint_IsOUTReceived())
 249         {
 250                 if (Endpoint_BytesInEndpoint())
 251                   ReceivedByte = Endpoint_Read_Byte();
 252
 253                 if (!(Endpoint_BytesInEndpoint()))
 254                   Endpoint_ClearOUT();
 255         }
 256
 257         return ReceivedByte;
 258 }
 259
 260 void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 261 {
 262         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 263           return;
 264
 265         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.NotificationEndpointNumber);
 266
 267         USB_Request_Header_t Notification = (USB_Request_Header_t)
 268                 {
 269                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 270                         .bRequest      = CDC_NOTIF_SerialState,
 271                         .wValue        = 0,
 272                         .wIndex        = 0,
 273                         .wLength       = sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 274                 };
 275
 276         Endpoint_Write_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NO_STREAM_CALLBACK);
 277         Endpoint_Write_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
 278                                  sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 279                                  NO_STREAM_CALLBACK);
 280         Endpoint_ClearIN();
 281 }
 282
 283 void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 284                              FILE* const Stream)
 285 {
 286         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar, _FDEV_SETUP_RW);
 287         fdev_set_udata(Stream, CDCInterfaceInfo);
 288 }
 289
 290 void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 291                                      FILE* const Stream)
 292 {
 293         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar_Blocking, _FDEV_SETUP_RW);
 294         fdev_set_udata(Stream, CDCInterfaceInfo);
 295 }
 296
 297 static int CDC_Device_putchar(char c,
 298                               FILE* Stream)
 299 {
 300         return CDC_Device_SendByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
 301 }
 302
 303 static int CDC_Device_getchar(FILE* Stream)
 304 {
 305         int16_t ReceivedByte = CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 306
 307         if (ReceivedByte < 0)
 308           return _FDEV_EOF;
 309
 310         return ReceivedByte;
 311 }
 312
 313 static int CDC_Device_getchar_Blocking(FILE* Stream)
 314 {
 315         int16_t ReceivedByte;
 316
 317         while ((ReceivedByte = CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream))) < 0)
 318         {
 319                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 320                   return _FDEV_EOF;
 321
 322                 CDC_Device_USBTask((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 323                 USB_USBTask();
 324         }
 325
 326         return ReceivedByte;
 327 }
 328
 329 #endif