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

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