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

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2015.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2015  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 disclaims 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 "../../Core/USBMode.h"
  33
  34 #if defined(USB_CAN_BE_DEVICE)
  35
  36 #define  __INCLUDE_FROM_CDC_DRIVER
  37 #define  __INCLUDE_FROM_CDC_DEVICE_C
  38 #include "CDCClassDevice.h"
  39
  40 void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
  41 {
  42         if (!(Endpoint_IsSETUPReceived()))
  43           return;
  44
  45         if (USB_ControlRequest.wIndex != CDCInterfaceInfo->Config.ControlInterfaceNumber)
  46           return;
  47
  48         switch (USB_ControlRequest.bRequest)
  49         {
  50                 case CDC_REQ_GetLineEncoding:
  51                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
  52                         {
  53                                 Endpoint_ClearSETUP();
  54
  55                                 while (!(Endpoint_IsINReady()));
  56
  57                                 Endpoint_Write_32_LE(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
  58                                 Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.CharFormat);
  59                                 Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.ParityType);
  60                                 Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.DataBits);
  61
  62                                 Endpoint_ClearIN();
  63                                 Endpoint_ClearStatusStage();
  64                         }
  65
  66                         break;
  67                 case CDC_REQ_SetLineEncoding:
  68                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  69                         {
  70                                 Endpoint_ClearSETUP();
  71
  72                                 while (!(Endpoint_IsOUTReceived()))
  73                                 {
  74                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
  75                                           return;
  76                                 }
  77
  78                                 CDCInterfaceInfo->State.LineEncoding.BaudRateBPS = Endpoint_Read_32_LE();
  79                                 CDCInterfaceInfo->State.LineEncoding.CharFormat  = Endpoint_Read_8();
  80                                 CDCInterfaceInfo->State.LineEncoding.ParityType  = Endpoint_Read_8();
  81                                 CDCInterfaceInfo->State.LineEncoding.DataBits    = Endpoint_Read_8();
  82
  83                                 Endpoint_ClearOUT();
  84                                 Endpoint_ClearStatusStage();
  85
  86                                 EVENT_CDC_Device_LineEncodingChanged(CDCInterfaceInfo);
  87                         }
  88
  89                         break;
  90                 case CDC_REQ_SetControlLineState:
  91                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  92                         {
  93                                 Endpoint_ClearSETUP();
  94                                 Endpoint_ClearStatusStage();
  95
  96                                 CDCInterfaceInfo->State.ControlLineStates.HostToDevice = USB_ControlRequest.wValue;
  97
  98                                 EVENT_CDC_Device_ControLineStateChanged(CDCInterfaceInfo);
  99                         }
 100
 101                         break;
 102                 case CDC_REQ_SendBreak:
 103                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 104                         {
 105                                 Endpoint_ClearSETUP();
 106                                 Endpoint_ClearStatusStage();
 107
 108                                 EVENT_CDC_Device_BreakSent(CDCInterfaceInfo, (uint8_t)USB_ControlRequest.wValue);
 109                         }
 110
 111                         break;
 112         }
 113 }
 114
 115 bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 116 {
 117         memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State));
 118
 119         CDCInterfaceInfo->Config.DataINEndpoint.Type       = EP_TYPE_BULK;
 120         CDCInterfaceInfo->Config.DataOUTEndpoint.Type      = EP_TYPE_BULK;
 121         CDCInterfaceInfo->Config.NotificationEndpoint.Type = EP_TYPE_INTERRUPT;
 122
 123         if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataINEndpoint, 1)))
 124           return false;
 125
 126         if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataOUTEndpoint, 1)))
 127           return false;
 128
 129         if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.NotificationEndpoint, 1)))
 130           return false;
 131
 132         return true;
 133 }
 134
 135 void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 136 {
 137         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 138           return;
 139
 140         #if !defined(NO_CLASS_DRIVER_AUTOFLUSH)
 141         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 142
 143         if (Endpoint_IsINReady())
 144           CDC_Device_Flush(CDCInterfaceInfo);
 145         #endif
 146 }
 147
 148 uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 149                               const char* const String)
 150 {
 151         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 152           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 153
 154         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 155         return Endpoint_Write_Stream_LE(String, strlen(String), NULL);
 156 }
 157
 158 uint8_t CDC_Device_SendString_P(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 159                               const char* const String)
 160 {
 161         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 162           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 163
 164         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 165         return Endpoint_Write_PStream_LE(String, strlen_P(String), NULL);
 166 }
 167
 168 uint8_t CDC_Device_SendData(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 169                             const void* const Buffer,
 170                             const uint16_t Length)
 171 {
 172         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 173           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 174
 175         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 176         return Endpoint_Write_Stream_LE(Buffer, Length, NULL);
 177 }
 178
 179 uint8_t CDC_Device_SendData_P(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 180                             const void* const Buffer,
 181                             const uint16_t Length)
 182 {
 183         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 184           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 185
 186         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 187         return Endpoint_Write_PStream_LE(Buffer, Length, NULL);
 188 }
 189
 190 uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 191                             const uint8_t Data)
 192 {
 193         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 194           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 195
 196         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 197
 198         if (!(Endpoint_IsReadWriteAllowed()))
 199         {
 200                 Endpoint_ClearIN();
 201
 202                 uint8_t ErrorCode;
 203
 204                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 205                   return ErrorCode;
 206         }
 207
 208         Endpoint_Write_8(Data);
 209         return ENDPOINT_READYWAIT_NoError;
 210 }
 211
 212 uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 213 {
 214         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 215           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 216
 217         uint8_t ErrorCode;
 218
 219         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 220
 221         if (!(Endpoint_BytesInEndpoint()))
 222           return ENDPOINT_READYWAIT_NoError;
 223
 224         bool BankFull = !(Endpoint_IsReadWriteAllowed());
 225
 226         Endpoint_ClearIN();
 227
 228         if (BankFull)
 229         {
 230                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 231                   return ErrorCode;
 232
 233                 Endpoint_ClearIN();
 234         }
 235
 236         return ENDPOINT_READYWAIT_NoError;
 237 }
 238
 239 uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 240 {
 241         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 242           return 0;
 243
 244         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpoint.Address);
 245
 246         if (Endpoint_IsOUTReceived())
 247         {
 248                 if (!(Endpoint_BytesInEndpoint()))
 249                 {
 250                         Endpoint_ClearOUT();
 251                         return 0;
 252                 }
 253                 else
 254                 {
 255                         return Endpoint_BytesInEndpoint();
 256                 }
 257         }
 258         else
 259         {
 260                 return 0;
 261         }
 262 }
 263
 264 int16_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 265 {
 266         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 267           return -1;
 268
 269         int16_t ReceivedByte = -1;
 270
 271         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpoint.Address);
 272
 273         if (Endpoint_IsOUTReceived())
 274         {
 275                 if (Endpoint_BytesInEndpoint())
 276                   ReceivedByte = Endpoint_Read_8();
 277
 278                 if (!(Endpoint_BytesInEndpoint()))
 279                   Endpoint_ClearOUT();
 280         }
 281
 282         return ReceivedByte;
 283 }
 284
 285 void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 286 {
 287         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 288           return;
 289
 290         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.NotificationEndpoint.Address);
 291
 292         USB_Request_Header_t Notification = (USB_Request_Header_t)
 293                 {
 294                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 295                         .bRequest      = CDC_NOTIF_SerialState,
 296                         .wValue        = CPU_TO_LE16(0),
 297                         .wIndex        = CPU_TO_LE16(0),
 298                         .wLength       = CPU_TO_LE16(sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost)),
 299                 };
 300
 301         Endpoint_Write_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NULL);
 302         Endpoint_Write_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
 303                                  sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 304                                  NULL);
 305         Endpoint_ClearIN();
 306 }
 307
 308 #if defined(FDEV_SETUP_STREAM)
 309 void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 310                              FILE* const Stream)
 311 {
 312         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar, _FDEV_SETUP_RW);
 313         fdev_set_udata(Stream, CDCInterfaceInfo);
 314 }
 315
 316 void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 317                                      FILE* const Stream)
 318 {
 319         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar_Blocking, _FDEV_SETUP_RW);
 320         fdev_set_udata(Stream, CDCInterfaceInfo);
 321 }
 322
 323 static int CDC_Device_putchar(char c,
 324                               FILE* Stream)
 325 {
 326         return CDC_Device_SendByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
 327 }
 328
 329 static int CDC_Device_getchar(FILE* Stream)
 330 {
 331         int16_t ReceivedByte = CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 332
 333         if (ReceivedByte < 0)
 334           return _FDEV_EOF;
 335
 336         return ReceivedByte;
 337 }
 338
 339 static int CDC_Device_getchar_Blocking(FILE* Stream)
 340 {
 341         int16_t ReceivedByte;
 342
 343         while ((ReceivedByte = CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream))) < 0)
 344         {
 345                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 346                   return _FDEV_EOF;
 347
 348                 CDC_Device_USBTask((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 349                 USB_USBTask();
 350         }
 351
 352         return ReceivedByte;
 353 }
 354 #endif
 355
 356 void CDC_Device_Event_Stub(void)
 357 {
 358
 359 }
 360
 361 #endif
 362