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

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2018.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2018  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_SendData(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 159                             const void* const Buffer,
 160                             const uint16_t Length)
 161 {
 162         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 163           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 164
 165         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 166         return Endpoint_Write_Stream_LE(Buffer, Length, NULL);
 167 }
 168
 169 #if defined(ARCH_HAS_FLASH_ADDRESS_SPACE)
 170         uint8_t CDC_Device_SendString_P(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 171                                         const char* const String)
 172         {
 173                 if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 174                   return ENDPOINT_RWSTREAM_DeviceDisconnected;
 175
 176                 Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 177                 return Endpoint_Write_PStream_LE(String, strlen_P(String), NULL);
 178         }
 179
 180         uint8_t CDC_Device_SendData_P(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 181                                       const void* const Buffer,
 182                                       const uint16_t Length)
 183         {
 184                 if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 185                   return ENDPOINT_RWSTREAM_DeviceDisconnected;
 186
 187                 Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 188                 return Endpoint_Write_PStream_LE(Buffer, Length, NULL);
 189         }
 190 #endif
 191
 192 uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 193                             const uint8_t Data)
 194 {
 195         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 196           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 197
 198         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 199
 200         if (!(Endpoint_IsReadWriteAllowed()))
 201         {
 202                 Endpoint_ClearIN();
 203
 204                 uint8_t ErrorCode;
 205
 206                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 207                   return ErrorCode;
 208         }
 209
 210         Endpoint_Write_8(Data);
 211         return ENDPOINT_READYWAIT_NoError;
 212 }
 213
 214 uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 215 {
 216         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 217           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 218
 219         uint8_t ErrorCode;
 220
 221         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 222
 223         if (!(Endpoint_BytesInEndpoint()))
 224           return ENDPOINT_READYWAIT_NoError;
 225
 226         bool BankFull = !(Endpoint_IsReadWriteAllowed());
 227
 228         Endpoint_ClearIN();
 229
 230         if (BankFull)
 231         {
 232                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 233                   return ErrorCode;
 234
 235                 Endpoint_ClearIN();
 236         }
 237
 238         return ENDPOINT_READYWAIT_NoError;
 239 }
 240
 241 uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 242 {
 243         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 244           return 0;
 245
 246         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpoint.Address);
 247
 248         if (Endpoint_IsOUTReceived())
 249         {
 250                 if (!(Endpoint_BytesInEndpoint()))
 251                 {
 252                         Endpoint_ClearOUT();
 253                         return 0;
 254                 }
 255                 else
 256                 {
 257                         return Endpoint_BytesInEndpoint();
 258                 }
 259         }
 260         else
 261         {
 262                 return 0;
 263         }
 264 }
 265
 266 int16_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 267 {
 268         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 269           return -1;
 270
 271         int16_t ReceivedByte = -1;
 272
 273         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpoint.Address);
 274
 275         if (Endpoint_IsOUTReceived())
 276         {
 277                 if (Endpoint_BytesInEndpoint())
 278                   ReceivedByte = Endpoint_Read_8();
 279
 280                 if (!(Endpoint_BytesInEndpoint()))
 281                   Endpoint_ClearOUT();
 282         }
 283
 284         return ReceivedByte;
 285 }
 286
 287 void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 288 {
 289         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 290           return;
 291
 292         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.NotificationEndpoint.Address);
 293
 294         USB_Request_Header_t Notification = (USB_Request_Header_t)
 295                 {
 296                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 297                         .bRequest      = CDC_NOTIF_SerialState,
 298                         .wValue        = CPU_TO_LE16(0),
 299                         .wIndex        = CPU_TO_LE16(0),
 300                         .wLength       = CPU_TO_LE16(sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost)),
 301                 };
 302
 303         Endpoint_Write_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NULL);
 304         Endpoint_Write_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
 305                                  sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 306                                  NULL);
 307         Endpoint_ClearIN();
 308 }
 309
 310 #if defined(FDEV_SETUP_STREAM)
 311         void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 312                                      FILE* const Stream)
 313         {
 314                 *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar, _FDEV_SETUP_RW);
 315                 fdev_set_udata(Stream, CDCInterfaceInfo);
 316         }
 317
 318         void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 319                                              FILE* const Stream)
 320         {
 321                 *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar_Blocking, _FDEV_SETUP_RW);
 322                 fdev_set_udata(Stream, CDCInterfaceInfo);
 323         }
 324
 325         static int CDC_Device_putchar(char c,
 326                                       FILE* Stream)
 327         {
 328                 return CDC_Device_SendByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : c;
 329         }
 330
 331         static int CDC_Device_getchar(FILE* Stream)
 332         {
 333                 int16_t ReceivedByte = CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 334
 335                 if (ReceivedByte < 0)
 336                   return _FDEV_EOF;
 337
 338                 return ReceivedByte;
 339         }
 340
 341         static int CDC_Device_getchar_Blocking(FILE* Stream)
 342         {
 343                 int16_t ReceivedByte;
 344
 345                 while ((ReceivedByte = CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream))) < 0)
 346                 {
 347                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 348                           return _FDEV_EOF;
 349
 350                         CDC_Device_USBTask((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 351                         USB_USBTask();
 352                 }
 353
 354                 return ReceivedByte;
 355         }
 356 #endif
 357
 358 void CDC_Device_Event_Stub(void)
 359 {
 360
 361 }
 362
 363 #endif
 364