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 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 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                                 EVENT_CDC_Device_LineEncodingChanged(CDCInterfaceInfo);
  69                                 Endpoint_ClearIN();
  70                         }
  71
  72                         break;
  73                 case REQ_SetControlLineState:
  74                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  75                         {
  76                                 Endpoint_ClearSETUP();
  77
  78                                 CDCInterfaceInfo->State.ControlLineStates.HostToDevice = USB_ControlRequest.wValue;
  79                                 EVENT_CDC_Device_ControLineStateChanged(CDCInterfaceInfo);
  80
  81                                 Endpoint_ClearStatusStage();
  82                         }
  83
  84                         break;
  85                 case REQ_SendBreak:
  86                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  87                         {
  88                                 Endpoint_ClearSETUP();
  89
  90                                 EVENT_CDC_Device_BreakSent(CDCInterfaceInfo, (uint8_t)USB_ControlRequest.wValue);
  91
  92                                 Endpoint_ClearStatusStage();
  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         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
 133
 134         if (Endpoint_IsOUTReceived() && !(Endpoint_BytesInEndpoint()))
 135           Endpoint_ClearOUT();
 136
 137         CDC_Device_Flush(CDCInterfaceInfo);
 138 }
 139
 140 uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 141                               char* const Data,
 142                               const uint16_t Length)
 143 {
 144         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 145           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 146
 147         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 148         return Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);
 149 }
 150
 151 uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 152                             const uint8_t Data)
 153 {
 154         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 155           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 156
 157         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 158
 159         if (!(Endpoint_IsReadWriteAllowed()))
 160         {
 161                 Endpoint_ClearIN();
 162
 163                 uint8_t ErrorCode;
 164
 165                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 166                   return ErrorCode;
 167         }
 168
 169         Endpoint_Write_Byte(Data);
 170         return ENDPOINT_READYWAIT_NoError;
 171 }
 172
 173 uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 174 {
 175         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 176           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 177
 178         uint8_t ErrorCode;
 179
 180         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 181
 182         if (!(Endpoint_BytesInEndpoint()))
 183           return ENDPOINT_READYWAIT_NoError;
 184
 185         bool BankFull = !(Endpoint_IsReadWriteAllowed());
 186
 187         Endpoint_ClearIN();
 188
 189         if (BankFull)
 190         {
 191                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 192                   return ErrorCode;
 193
 194                 Endpoint_ClearIN();
 195         }
 196
 197         return ENDPOINT_READYWAIT_NoError;
 198 }
 199
 200 uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 201 {
 202         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 203           return 0;
 204
 205         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
 206
 207         if (Endpoint_IsOUTReceived())
 208         {
 209                 if (!(Endpoint_BytesInEndpoint()))
 210                 {
 211                         Endpoint_ClearOUT();
 212                         return 0;
 213                 }
 214                 else
 215                 {
 216                         return Endpoint_BytesInEndpoint();
 217                 }
 218         }
 219         else
 220         {
 221                 return 0;
 222         }
 223 }
 224
 225 uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 226 {
 227         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 228           return 0;
 229
 230         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
 231
 232         uint8_t DataByte = Endpoint_Read_Byte();
 233
 234         if (!(Endpoint_BytesInEndpoint()))
 235           Endpoint_ClearOUT();
 236
 237         return DataByte;
 238 }
 239
 240 void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 241 {
 242         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 243           return;
 244
 245         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.NotificationEndpointNumber);
 246
 247         USB_Request_Header_t Notification = (USB_Request_Header_t)
 248                 {
 249                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 250                         .bRequest      = NOTIF_SerialState,
 251                         .wValue        = 0,
 252                         .wIndex        = 0,
 253                         .wLength       = sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 254                 };
 255
 256         Endpoint_Write_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NO_STREAM_CALLBACK);
 257         Endpoint_Write_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
 258                                  sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 259                                  NO_STREAM_CALLBACK);
 260         Endpoint_ClearIN();
 261 }
 262
 263 void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 264                              FILE* const Stream)
 265 {
 266         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar, _FDEV_SETUP_RW);
 267         fdev_set_udata(Stream, CDCInterfaceInfo);
 268 }
 269
 270 void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 271                                      FILE* const Stream)
 272 {
 273         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar_Blocking, _FDEV_SETUP_RW);
 274         fdev_set_udata(Stream, CDCInterfaceInfo);
 275 }
 276
 277 static int CDC_Device_putchar(char c,
 278                               FILE* Stream)
 279 {
 280         return CDC_Device_SendByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
 281 }
 282
 283 static int CDC_Device_getchar(FILE* Stream)
 284 {
 285         if (!(CDC_Device_BytesReceived((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream))))
 286           return _FDEV_EOF;
 287
 288         return CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 289 }
 290
 291 static int CDC_Device_getchar_Blocking(FILE* Stream)
 292 {
 293         while (!(CDC_Device_BytesReceived((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream))))
 294         {
 295                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 296                   return _FDEV_EOF;
 297
 298                 CDC_Device_USBTask((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 299                 USB_USBTask();
 300         }
 301
 302         return CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 303 }
 304
 305 #endif