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         if (!(Endpoint_ConfigureEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,
 104                                                                  ENDPOINT_DIR_IN, CDCInterfaceInfo->Config.DataINEndpointSize,
 105                                                                  CDCInterfaceInfo->Config.DataINEndpointDoubleBank ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
 106         {
 107                 return false;
 108         }
 109
 110         if (!(Endpoint_ConfigureEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber, EP_TYPE_BULK,
 111                                          ENDPOINT_DIR_OUT, CDCInterfaceInfo->Config.DataOUTEndpointSize,
 112                                          CDCInterfaceInfo->Config.DataOUTEndpointDoubleBank ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
 113         {
 114                 return false;
 115         }
 116
 117         if (!(Endpoint_ConfigureEndpoint(CDCInterfaceInfo->Config.NotificationEndpointNumber, EP_TYPE_INTERRUPT,
 118                                          ENDPOINT_DIR_IN, CDCInterfaceInfo->Config.NotificationEndpointSize,
 119                                          CDCInterfaceInfo->Config.NotificationEndpointDoubleBank ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
 120         {
 121                 return false;
 122         }
 123
 124         return true;
 125 }
 126
 127 void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 128 {
 129         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 130           return;
 131
 132         CDC_Device_Flush(CDCInterfaceInfo);
 133 }
 134
 135 uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 136                               const char* const Data,
 137                               const uint16_t Length)
 138 {
 139         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 140           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 141
 142         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 143         return Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);
 144 }
 145
 146 uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 147                             const uint8_t Data)
 148 {
 149         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 150           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 151
 152         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 153
 154         if (!(Endpoint_IsReadWriteAllowed()))
 155         {
 156                 Endpoint_ClearIN();
 157
 158                 uint8_t ErrorCode;
 159
 160                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 161                   return ErrorCode;
 162         }
 163
 164         Endpoint_Write_Byte(Data);
 165         return ENDPOINT_READYWAIT_NoError;
 166 }
 167
 168 uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 169 {
 170         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 171           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 172
 173         uint8_t ErrorCode;
 174
 175         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 176
 177         if (!(Endpoint_BytesInEndpoint()))
 178           return ENDPOINT_READYWAIT_NoError;
 179
 180         bool BankFull = !(Endpoint_IsReadWriteAllowed());
 181
 182         Endpoint_ClearIN();
 183
 184         if (BankFull)
 185         {
 186                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 187                   return ErrorCode;
 188
 189                 Endpoint_ClearIN();
 190         }
 191
 192         return ENDPOINT_READYWAIT_NoError;
 193 }
 194
 195 uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 196 {
 197         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 198           return 0;
 199
 200         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
 201
 202         if (Endpoint_IsOUTReceived())
 203         {
 204                 if (!(Endpoint_BytesInEndpoint()))
 205                 {
 206                         Endpoint_ClearOUT();
 207                         return 0;
 208                 }
 209                 else
 210                 {
 211                         return Endpoint_BytesInEndpoint();
 212                 }
 213         }
 214         else
 215         {
 216                 return 0;
 217         }
 218 }
 219
 220 int16_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 221 {
 222         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 223           return -1;
 224
 225         int16_t ReceivedByte = -1;
 226
 227         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
 228
 229         if (Endpoint_IsOUTReceived())
 230         {
 231                 if (Endpoint_BytesInEndpoint())
 232                   ReceivedByte = Endpoint_Read_Byte();
 233
 234                 if (!(Endpoint_BytesInEndpoint()))
 235                   Endpoint_ClearOUT();
 236         }
 237
 238         return ReceivedByte;
 239 }
 240
 241 void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 242 {
 243         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 244           return;
 245
 246         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.NotificationEndpointNumber);
 247
 248         USB_Request_Header_t Notification = (USB_Request_Header_t)
 249                 {
 250                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 251                         .bRequest      = CDC_NOTIF_SerialState,
 252                         .wValue        = 0,
 253                         .wIndex        = 0,
 254                         .wLength       = sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 255                 };
 256
 257         Endpoint_Write_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NO_STREAM_CALLBACK);
 258         Endpoint_Write_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
 259                                  sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 260                                  NO_STREAM_CALLBACK);
 261         Endpoint_ClearIN();
 262 }
 263
 264 void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 265                              FILE* const Stream)
 266 {
 267         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar, _FDEV_SETUP_RW);
 268         fdev_set_udata(Stream, CDCInterfaceInfo);
 269 }
 270
 271 void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 272                                      FILE* const Stream)
 273 {
 274         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar_Blocking, _FDEV_SETUP_RW);
 275         fdev_set_udata(Stream, CDCInterfaceInfo);
 276 }
 277
 278 static int CDC_Device_putchar(char c,
 279                               FILE* Stream)
 280 {
 281         return CDC_Device_SendByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
 282 }
 283
 284 static int CDC_Device_getchar(FILE* Stream)
 285 {
 286         int16_t ReceivedByte = CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 287
 288         if (ReceivedByte < 0)
 289           return _FDEV_EOF;
 290
 291         return ReceivedByte;
 292 }
 293
 294 static int CDC_Device_getchar_Blocking(FILE* Stream)
 295 {
 296         int16_t ReceivedByte;
 297
 298         while ((ReceivedByte = CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream))) < 0)
 299         {
 300                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 301                   return _FDEV_EOF;
 302
 303                 CDC_Device_USBTask((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 304                 USB_USBTask();
 305         }
 306
 307         return ReceivedByte;
 308 }
 309
 310 #endif