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