LUFA/Drivers/USB/Class/Host/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_HOST)
  33
  34 #define  INCLUDE_FROM_CDC_CLASS_HOST_C
  35 #include "CDC.h"
  36
  37 uint8_t CDC_Host_ConfigurePipes(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, uint16_t ConfigDescriptorSize,
  38                                 uint8_t* ConfigDescriptorData)
  39 {
  40         uint8_t FoundEndpoints = 0;
  41
  42         memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State));
  43
  44         if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
  45           return CDC_ENUMERROR_InvalidConfigDescriptor;
  46
  47         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  48                                       DComp_CDC_Host_NextCDCControlInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  49         {
  50                 return CDC_ENUMERROR_NoCDCInterfaceFound;
  51         }
  52
  53         CDCInterfaceInfo->State.ControlInterfaceNumber = DESCRIPTOR_CAST(ConfigDescriptorData, USB_Descriptor_Interface_t).InterfaceNumber;
  54
  55         while (FoundEndpoints != (CDC_FOUND_NOTIFICATION_IN | CDC_FOUND_DATAPIPE_IN | CDC_FOUND_DATAPIPE_OUT))
  56         {
  57                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  58                                               DComp_CDC_Host_NextCDCInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  59                 {
  60                         if (FoundEndpoints & CDC_FOUND_NOTIFICATION_IN)
  61                         {
  62                                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  63                                                               DComp_CDC_Host_NextCDCDataInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  64                                 {
  65                                         return CDC_ENUMERROR_NoCDCInterfaceFound;
  66                                 }
  67                         }
  68                         else
  69                         {
  70                                 FoundEndpoints = 0;
  71
  72                                 Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
  73                                 Pipe_DisablePipe();
  74                                 Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
  75                                 Pipe_DisablePipe();
  76                                 Pipe_SelectPipe(CDCInterfaceInfo->Config.NotificationPipeNumber);
  77                                 Pipe_DisablePipe();
  78
  79                                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  80                                                               DComp_CDC_Host_NextCDCControlInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  81                                 {
  82                                         return CDC_ENUMERROR_NoCDCInterfaceFound;
  83                                 }
  84                         }
  85
  86                         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  87                                                       DComp_CDC_Host_NextCDCInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  88                         {
  89                                 return CDC_ENUMERROR_EndpointsNotFound;
  90                         }
  91                 }
  92
  93                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
  94
  95                 if ((EndpointData->Attributes & EP_TYPE_MASK) == EP_TYPE_INTERRUPT)
  96                 {
  97                         if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
  98                         {
  99                                 Pipe_ConfigurePipe(CDCInterfaceInfo->Config.NotificationPipeNumber, EP_TYPE_INTERRUPT, PIPE_TOKEN_IN,
 100                                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize, PIPE_BANK_SINGLE);
 101                                 CDCInterfaceInfo->State.NotificationPipeSize = EndpointData->EndpointSize;
 102
 103                                 Pipe_SetInterruptPeriod(EndpointData->PollingIntervalMS);
 104
 105                                 FoundEndpoints |= CDC_FOUND_NOTIFICATION_IN;
 106                         }
 107                 }
 108                 else
 109                 {
 110                         if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
 111                         {
 112                                 Pipe_ConfigurePipe(CDCInterfaceInfo->Config.DataINPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_IN,
 113                                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize, PIPE_BANK_SINGLE);
 114                                 CDCInterfaceInfo->State.DataINPipeSize = EndpointData->EndpointSize;
 115
 116                                 FoundEndpoints |= CDC_FOUND_DATAPIPE_IN;
 117                         }
 118                         else
 119                         {
 120                                 Pipe_ConfigurePipe(CDCInterfaceInfo->Config.DataOUTPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_OUT,
 121                                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize, PIPE_BANK_SINGLE);
 122                                 CDCInterfaceInfo->State.DataOUTPipeSize = EndpointData->EndpointSize;
 123
 124                                 FoundEndpoints |= CDC_FOUND_DATAPIPE_OUT;
 125                         }
 126                 }
 127         }
 128
 129         CDCInterfaceInfo->State.ControlLineStates.HostToDevice = (CDC_CONTROL_LINE_OUT_RTS | CDC_CONTROL_LINE_OUT_DTR);
 130         CDCInterfaceInfo->State.ControlLineStates.DeviceToHost = (CDC_CONTROL_LINE_IN_DCD  | CDC_CONTROL_LINE_IN_DSR);
 131         CDCInterfaceInfo->State.IsActive = true;
 132         return CDC_ENUMERROR_NoError;
 133 }
 134
 135 static uint8_t DComp_CDC_Host_NextCDCControlInterface(void* const CurrentDescriptor)
 136 {
 137         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 138         {
 139                 USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
 140                                                                                 USB_Descriptor_Interface_t);
 141
 142                 if ((CurrentInterface->Class    == CDC_CONTROL_CLASS)    &&
 143                     (CurrentInterface->SubClass == CDC_CONTROL_SUBCLASS) &&
 144                         (CurrentInterface->Protocol == CDC_CONTROL_PROTOCOL))
 145                 {
 146                         return DESCRIPTOR_SEARCH_Found;
 147                 }
 148         }
 149
 150         return DESCRIPTOR_SEARCH_NotFound;
 151 }
 152
 153 static uint8_t DComp_CDC_Host_NextCDCDataInterface(void* const CurrentDescriptor)
 154 {
 155         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 156         {
 157                 USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
 158                                                                                 USB_Descriptor_Interface_t);
 159
 160                 if ((CurrentInterface->Class    == CDC_DATA_CLASS)    &&
 161                     (CurrentInterface->SubClass == CDC_DATA_SUBCLASS) &&
 162                         (CurrentInterface->Protocol == CDC_DATA_PROTOCOL))
 163                 {
 164                         return DESCRIPTOR_SEARCH_Found;
 165                 }
 166         }
 167
 168         return DESCRIPTOR_SEARCH_NotFound;
 169 }
 170
 171 static uint8_t DComp_CDC_Host_NextCDCInterfaceEndpoint(void* const CurrentDescriptor)
 172 {
 173         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
 174         {
 175                 USB_Descriptor_Endpoint_t* CurrentEndpoint = DESCRIPTOR_PCAST(CurrentDescriptor,
 176                                                                               USB_Descriptor_Endpoint_t);
 177
 178                 uint8_t EndpointType = (CurrentEndpoint->Attributes & EP_TYPE_MASK);
 179
 180                 if (((EndpointType == EP_TYPE_BULK) || (EndpointType == EP_TYPE_INTERRUPT)) &&
 181                     !(Pipe_IsEndpointBound(CurrentEndpoint->EndpointAddress)))
 182                 {
 183                         return DESCRIPTOR_SEARCH_Found;
 184                 }
 185         }
 186         else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 187         {
 188                 return DESCRIPTOR_SEARCH_Fail;
 189         }
 190
 191         return DESCRIPTOR_SEARCH_NotFound;
 192 }
 193
 194 void CDC_Host_USBTask(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 195 {
 196         if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 197           return;
 198
 199         Pipe_SelectPipe(CDCInterfaceInfo->Config.NotificationPipeNumber);
 200         Pipe_Unfreeze();
 201
 202         if (Pipe_IsINReceived())
 203         {
 204                 USB_Request_Header_t Notification;
 205                 Pipe_Read_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NO_STREAM_CALLBACK);
 206
 207                 if ((Notification.bRequest      == NOTIF_SerialState) &&
 208                     (Notification.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)))
 209                 {
 210                         Pipe_Read_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
 211                                             sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 212                                             NO_STREAM_CALLBACK);
 213
 214                 }
 215
 216                 Pipe_ClearIN();
 217
 218                 EVENT_CDC_Host_ControLineStateChanged(CDCInterfaceInfo);
 219         }
 220
 221         Pipe_Freeze();
 222 }
 223
 224 uint8_t CDC_Host_SetLineEncoding(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 225 {
 226         USB_ControlRequest = (USB_Request_Header_t)
 227         {
 228                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 229                 .bRequest      = REQ_SetLineEncoding,
 230                 .wValue        = 0,
 231                 .wIndex        = CDCInterfaceInfo->State.ControlInterfaceNumber,
 232                 .wLength       = sizeof(CDCInterfaceInfo->State.LineEncoding),
 233         };
 234
 235         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 236
 237         return USB_Host_SendControlRequest(&CDCInterfaceInfo->State.LineEncoding);
 238 }
 239
 240 uint8_t CDC_Host_SendControlLineStateChange(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 241 {
 242         USB_ControlRequest = (USB_Request_Header_t)
 243         {
 244                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 245                 .bRequest      = REQ_SetControlLineState,
 246                 .wValue        = CDCInterfaceInfo->State.ControlLineStates.HostToDevice,
 247                 .wIndex        = CDCInterfaceInfo->State.ControlInterfaceNumber,
 248                 .wLength       = 0,
 249         };
 250
 251         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 252
 253         return USB_Host_SendControlRequest(NULL);
 254 }
 255
 256 uint8_t CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, char* Data, const uint16_t Length)
 257 {
 258         if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 259           return PIPE_READYWAIT_NoError;
 260
 261         uint8_t ErrorCode;
 262
 263         Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
 264         Pipe_Unfreeze();
 265         ErrorCode = Pipe_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);
 266         Pipe_Freeze();
 267
 268         return ErrorCode;
 269 }
 270
 271 uint8_t CDC_Host_SendByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, const uint8_t Data)
 272 {
 273         if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 274           return PIPE_READYWAIT_NoError;;
 275
 276         uint8_t ErrorCode;
 277
 278         Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
 279         Pipe_Unfreeze();
 280
 281         if (!(Pipe_IsReadWriteAllowed()))
 282         {
 283                 Pipe_ClearOUT();
 284
 285                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 286                   return ErrorCode;
 287         }
 288
 289         Pipe_Write_Byte(Data);
 290         Pipe_Freeze();
 291
 292         return PIPE_READYWAIT_NoError;
 293 }
 294
 295 uint16_t CDC_Host_BytesReceived(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 296 {
 297         uint16_t BytesInPipe = 0;
 298
 299         if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 300           return BytesInPipe;
 301
 302         Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
 303         Pipe_Unfreeze();
 304
 305         if (Pipe_IsINReceived() && !(Pipe_BytesInPipe()))
 306           Pipe_ClearIN();
 307
 308         BytesInPipe = Pipe_BytesInPipe();
 309         Pipe_Freeze();
 310
 311         return BytesInPipe;
 312 }
 313
 314 uint8_t CDC_Host_ReceiveByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 315 {
 316         uint8_t ReceivedByte = 0;
 317
 318         if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 319           return ReceivedByte;
 320
 321         Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
 322         Pipe_Unfreeze();
 323
 324         ReceivedByte = Pipe_Read_Byte();
 325
 326         if (!(Pipe_BytesInPipe()))
 327           Pipe_ClearIN();
 328
 329         Pipe_Freeze();
 330
 331         return ReceivedByte;
 332 }
 333
 334 void CDC_Host_Event_Stub(void)
 335 {
 336
 337 }
 338
 339 #endif