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