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* 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* 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* 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, char* const Data, const uint16_t Length)
 141 {
 142         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 143           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 144
 145         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 146         return Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);
 147 }
 148
 149 uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, 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 uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
 223 {
 224         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 225           return 0;
 226
 227         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
 228
 229         uint8_t DataByte = Endpoint_Read_Byte();
 230
 231         if (!(Endpoint_BytesInEndpoint()))
 232           Endpoint_ClearOUT();
 233
 234         return DataByte;
 235 }
 236
 237 void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 238 {
 239         if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 240           return;
 241
 242         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.NotificationEndpointNumber);
 243
 244         USB_Request_Header_t Notification = (USB_Request_Header_t)
 245                 {
 246                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 247                         .bRequest      = NOTIF_SerialState,
 248                         .wValue        = 0,
 249                         .wIndex        = 0,
 250                         .wLength       = sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 251                 };
 252
 253         Endpoint_Write_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NO_STREAM_CALLBACK);
 254         Endpoint_Write_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
 255                                  sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 256                                  NO_STREAM_CALLBACK);
 257         Endpoint_ClearIN();
 258 }
 259
 260 void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, FILE* Stream)
 261 {
 262         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar, _FDEV_SETUP_RW);
 263         fdev_set_udata(Stream, CDCInterfaceInfo);
 264 }
 265
 266 void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, FILE* Stream)
 267 {
 268         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar_Blocking, _FDEV_SETUP_RW);
 269         fdev_set_udata(Stream, CDCInterfaceInfo);
 270 }
 271
 272 static int CDC_Device_putchar(char c, FILE* Stream)
 273 {
 274         return CDC_Device_SendByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
 275 }
 276
 277 static int CDC_Device_getchar(FILE* Stream)
 278 {
 279         if (!(CDC_Device_BytesReceived((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream))))
 280           return _FDEV_EOF;
 281
 282         return CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 283 }
 284
 285 static int CDC_Device_getchar_Blocking(FILE* Stream)
 286 {
 287         while (!(CDC_Device_BytesReceived((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream))))
 288         {
 289                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 290                   return _FDEV_EOF;
 291
 292                 CDC_Device_USBTask((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 293                 USB_USBTask();
 294         }
 295
 296         return CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream));
 297 }
 298
 299 #endif