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

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   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 #include "../../HighLevel/USBMode.h"
  32 #if defined(USB_CAN_BE_DEVICE)
  33
  34 #define  INCLUDE_FROM_CDC_CLASS_DEVICE_C
  35 #include "CDC.h"
  36
  37 void CDC_Device_Event_Stub(void)
  38 {
  39
  40 }
  41
  42 void CDC_Device_ProcessControlPacket(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
  43 {
  44         if (!(Endpoint_IsSETUPReceived()))
  45           return;
  46
  47         if (USB_ControlRequest.wIndex != CDCInterfaceInfo->Config.ControlInterfaceNumber)
  48           return;
  49
  50         switch (USB_ControlRequest.bRequest)
  51         {
  52                 case REQ_GetLineEncoding:
  53                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
  54                         {
  55                                 Endpoint_ClearSETUP();
  56                                 Endpoint_Write_Control_Stream_LE(&CDCInterfaceInfo->State.LineEncoding, sizeof(CDCInterfaceInfo->State.LineEncoding));
  57                                 Endpoint_ClearOUT();
  58                         }
  59
  60                         break;
  61                 case REQ_SetLineEncoding:
  62                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  63                         {
  64                                 Endpoint_ClearSETUP();
  65                                 Endpoint_Read_Control_Stream_LE(&CDCInterfaceInfo->State.LineEncoding, sizeof(CDCInterfaceInfo->State.LineEncoding));
  66                                 Endpoint_ClearIN();
  67
  68                                 EVENT_CDC_Device_LineEncodingChanged(CDCInterfaceInfo);
  69                         }
  70
  71                         break;
  72                 case REQ_SetControlLineState:
  73                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  74                         {
  75                                 Endpoint_ClearSETUP();
  76
  77                                 CDCInterfaceInfo->State.ControlLineStates.HostToDevice = USB_ControlRequest.wValue;
  78
  79                                 EVENT_CDC_Device_ControLineStateChanged(CDCInterfaceInfo);
  80
  81                                 Endpoint_ClearStatusStage();
  82                         }
  83
  84                         break;
  85         }
  86 }
  87
  88 bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
  89 {
  90         if (!(Endpoint_ConfigureEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,
  91                                                                  ENDPOINT_DIR_IN, CDCInterfaceInfo->Config.DataINEndpointSize,
  92                                                                  ENDPOINT_BANK_SINGLE)))
  93         {
  94                 return false;
  95         }
  96
  97         if (!(Endpoint_ConfigureEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber, EP_TYPE_BULK,
  98                                          ENDPOINT_DIR_OUT, CDCInterfaceInfo->Config.DataOUTEndpointSize,
  99                                          ENDPOINT_BANK_SINGLE)))
 100         {
 101                 return false;
 102         }
 103
 104         if (!(Endpoint_ConfigureEndpoint(CDCInterfaceInfo->Config.NotificationEndpointNumber, EP_TYPE_INTERRUPT,
 105                                          ENDPOINT_DIR_IN, CDCInterfaceInfo->Config.NotificationEndpointSize,
 106                                          ENDPOINT_BANK_SINGLE)))
 107         {
 108                 return false;
 109         }
 110
 111         return true;
 112 }
 113
 114 void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
 115 {
 116         if (USB_DeviceState != DEVICE_STATE_Configured)
 117           return;
 118
 119         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 120
 121         if (!(Endpoint_BytesInEndpoint()))
 122           return;
 123
 124         if (!(Endpoint_IsReadWriteAllowed()))
 125         {
 126                 Endpoint_ClearIN();
 127
 128                 while (!(Endpoint_IsReadWriteAllowed()))
 129                 {
 130                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 131                           return;
 132                 }
 133         }
 134
 135         Endpoint_ClearIN();
 136 }
 137
 138 void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length)
 139 {
 140         if (USB_DeviceState != DEVICE_STATE_Configured)
 141           return;
 142
 143         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 144         Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);
 145 }
 146
 147 void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data)
 148 {
 149         if (USB_DeviceState != DEVICE_STATE_Configured)
 150           return;
 151
 152         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
 153
 154         if (!(Endpoint_IsReadWriteAllowed()))
 155         {
 156                 Endpoint_ClearIN();
 157
 158                 while (!(Endpoint_IsReadWriteAllowed()))
 159                 {
 160                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 161                           return;
 162                 }
 163         }
 164
 165         Endpoint_Write_Byte(Data);
 166 }
 167
 168 uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 169 {
 170         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
 171
 172         return Endpoint_BytesInEndpoint();
 173 }
 174
 175 uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
 176 {
 177         if (USB_DeviceState != DEVICE_STATE_Configured)
 178           return 0;
 179
 180         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
 181
 182         uint8_t DataByte = Endpoint_Read_Byte();
 183
 184         if (!(Endpoint_BytesInEndpoint()))
 185           Endpoint_ClearOUT();
 186
 187         return DataByte;
 188 }
 189
 190 void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 191 {
 192         if (USB_DeviceState != DEVICE_STATE_Configured)
 193           return;
 194
 195         Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.NotificationEndpointNumber);
 196
 197         USB_Request_Header_t Notification = (USB_Request_Header_t)
 198                 {
 199                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 200                         .bRequest      = NOTIF_SerialState,
 201                         .wValue        = 0,
 202                         .wIndex        = 0,
 203                         .wLength       = sizeof(uint16_t),
 204                 };
 205
 206         Endpoint_Write_Stream_LE(&Notification, sizeof(Notification), NO_STREAM_CALLBACK);
 207         Endpoint_Write_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost, sizeof(uint8_t), NO_STREAM_CALLBACK);
 208         Endpoint_ClearIN();
 209 }
 210
 211 #endif