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