LUFA/Drivers/USB/Class/Host/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_HOST)
  34
  35 #define  __INCLUDE_FROM_CDC_CLASS_HOST_C
  36 #define  __INCLUDE_FROM_CDC_DRIVER
  37 #include "CDC.h"
  38
  39 uint8_t CDC_Host_ConfigurePipes(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
  40                                 uint16_t ConfigDescriptorSize,
  41                                 void* ConfigDescriptorData)
  42 {
  43         uint8_t FoundEndpoints = 0;
  44
  45         memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State));
  46
  47         if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
  48           return CDC_ENUMERROR_InvalidConfigDescriptor;
  49
  50         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  51                                       DCOMP_CDC_Host_NextCDCControlInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  52         {
  53                 return CDC_ENUMERROR_NoCDCInterfaceFound;
  54         }
  55
  56         CDCInterfaceInfo->State.ControlInterfaceNumber = DESCRIPTOR_CAST(ConfigDescriptorData, USB_Descriptor_Interface_t).InterfaceNumber;
  57
  58         while (FoundEndpoints != (CDC_FOUND_NOTIFICATION_IN | CDC_FOUND_DATAPIPE_IN | CDC_FOUND_DATAPIPE_OUT))
  59         {
  60                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  61                                               DCOMP_CDC_Host_NextCDCInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  62                 {
  63                         if (FoundEndpoints & CDC_FOUND_NOTIFICATION_IN)
  64                         {
  65                                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  66                                                               DCOMP_CDC_Host_NextCDCDataInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  67                                 {
  68                                         return CDC_ENUMERROR_NoCDCInterfaceFound;
  69                                 }
  70                         }
  71                         else
  72                         {
  73                                 FoundEndpoints = 0;
  74
  75                                 Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
  76                                 Pipe_DisablePipe();
  77                                 Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
  78                                 Pipe_DisablePipe();
  79                                 Pipe_SelectPipe(CDCInterfaceInfo->Config.NotificationPipeNumber);
  80                                 Pipe_DisablePipe();
  81
  82                                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  83                                                               DCOMP_CDC_Host_NextCDCControlInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  84                                 {
  85                                         return CDC_ENUMERROR_NoCDCInterfaceFound;
  86                                 }
  87                         }
  88
  89                         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  90                                                       DCOMP_CDC_Host_NextCDCInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  91                         {
  92                                 return CDC_ENUMERROR_EndpointsNotFound;
  93                         }
  94                 }
  95
  96                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
  97
  98                 if ((EndpointData->Attributes & EP_TYPE_MASK) == EP_TYPE_INTERRUPT)
  99                 {
 100                         if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
 101                         {
 102                                 Pipe_ConfigurePipe(CDCInterfaceInfo->Config.NotificationPipeNumber, EP_TYPE_INTERRUPT, PIPE_TOKEN_IN,
 103                                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize,
 104                                                                    CDCInterfaceInfo->Config.NotificationPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
 105                                 CDCInterfaceInfo->State.NotificationPipeSize = EndpointData->EndpointSize;
 106
 107                                 Pipe_SetInterruptPeriod(EndpointData->PollingIntervalMS);
 108
 109                                 FoundEndpoints |= CDC_FOUND_NOTIFICATION_IN;
 110                         }
 111                 }
 112                 else
 113                 {
 114                         if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
 115                         {
 116                                 Pipe_ConfigurePipe(CDCInterfaceInfo->Config.DataINPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_IN,
 117                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize,
 118                                                    CDCInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
 119
 120                                 CDCInterfaceInfo->State.DataINPipeSize = EndpointData->EndpointSize;
 121
 122                                 FoundEndpoints |= CDC_FOUND_DATAPIPE_IN;
 123                         }
 124                         else
 125                         {
 126                                 Pipe_ConfigurePipe(CDCInterfaceInfo->Config.DataOUTPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_OUT,
 127                                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize,
 128                                                                    CDCInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
 129
 130                                 CDCInterfaceInfo->State.DataOUTPipeSize = EndpointData->EndpointSize;
 131
 132                                 FoundEndpoints |= CDC_FOUND_DATAPIPE_OUT;
 133                         }
 134                 }
 135         }
 136
 137         CDCInterfaceInfo->State.ControlLineStates.HostToDevice = (CDC_CONTROL_LINE_OUT_RTS | CDC_CONTROL_LINE_OUT_DTR);
 138         CDCInterfaceInfo->State.ControlLineStates.DeviceToHost = (CDC_CONTROL_LINE_IN_DCD  | CDC_CONTROL_LINE_IN_DSR);
 139         CDCInterfaceInfo->State.IsActive = true;
 140         return CDC_ENUMERROR_NoError;
 141 }
 142
 143 static uint8_t DCOMP_CDC_Host_NextCDCControlInterface(void* const CurrentDescriptor)
 144 {
 145         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 146         {
 147                 USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
 148                                                                                 USB_Descriptor_Interface_t);
 149
 150                 if ((CurrentInterface->Class    == CDC_CONTROL_CLASS)    &&
 151                     (CurrentInterface->SubClass == CDC_CONTROL_SUBCLASS) &&
 152                         (CurrentInterface->Protocol == CDC_CONTROL_PROTOCOL))
 153                 {
 154                         return DESCRIPTOR_SEARCH_Found;
 155                 }
 156         }
 157
 158         return DESCRIPTOR_SEARCH_NotFound;
 159 }
 160
 161 static uint8_t DCOMP_CDC_Host_NextCDCDataInterface(void* const CurrentDescriptor)
 162 {
 163         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 164         {
 165                 USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
 166                                                                                 USB_Descriptor_Interface_t);
 167
 168                 if ((CurrentInterface->Class    == CDC_DATA_CLASS)    &&
 169                     (CurrentInterface->SubClass == CDC_DATA_SUBCLASS) &&
 170                         (CurrentInterface->Protocol == CDC_DATA_PROTOCOL))
 171                 {
 172                         return DESCRIPTOR_SEARCH_Found;
 173                 }
 174         }
 175
 176         return DESCRIPTOR_SEARCH_NotFound;
 177 }
 178
 179 static uint8_t DCOMP_CDC_Host_NextCDCInterfaceEndpoint(void* const CurrentDescriptor)
 180 {
 181         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
 182         {
 183                 USB_Descriptor_Endpoint_t* CurrentEndpoint = DESCRIPTOR_PCAST(CurrentDescriptor,
 184                                                                               USB_Descriptor_Endpoint_t);
 185
 186                 uint8_t EndpointType = (CurrentEndpoint->Attributes & EP_TYPE_MASK);
 187
 188                 if (((EndpointType == EP_TYPE_BULK) || (EndpointType == EP_TYPE_INTERRUPT)) &&
 189                     !(Pipe_IsEndpointBound(CurrentEndpoint->EndpointAddress)))
 190                 {
 191                         return DESCRIPTOR_SEARCH_Found;
 192                 }
 193         }
 194         else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 195         {
 196                 return DESCRIPTOR_SEARCH_Fail;
 197         }
 198
 199         return DESCRIPTOR_SEARCH_NotFound;
 200 }
 201
 202 void CDC_Host_USBTask(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 203 {
 204         if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 205           return;
 206
 207         Pipe_SelectPipe(CDCInterfaceInfo->Config.NotificationPipeNumber);
 208         Pipe_Unfreeze();
 209
 210         if (Pipe_IsINReceived())
 211         {
 212                 USB_Request_Header_t Notification;
 213                 Pipe_Read_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NO_STREAM_CALLBACK);
 214
 215                 if ((Notification.bRequest      == NOTIF_SerialState) &&
 216                     (Notification.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)))
 217                 {
 218                         Pipe_Read_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
 219                                             sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
 220                                             NO_STREAM_CALLBACK);
 221
 222                         Pipe_ClearIN();
 223
 224                         EVENT_CDC_Host_ControLineStateChanged(CDCInterfaceInfo);
 225                 }
 226                 else
 227                 {
 228                         Pipe_ClearIN();
 229                 }
 230         }
 231
 232         Pipe_Freeze();
 233
 234         CDC_Host_Flush(CDCInterfaceInfo);
 235 }
 236
 237 uint8_t CDC_Host_SetLineEncoding(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 238 {
 239         USB_ControlRequest = (USB_Request_Header_t)
 240         {
 241                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 242                 .bRequest      = REQ_SetLineEncoding,
 243                 .wValue        = 0,
 244                 .wIndex        = CDCInterfaceInfo->State.ControlInterfaceNumber,
 245                 .wLength       = sizeof(CDCInterfaceInfo->State.LineEncoding),
 246         };
 247
 248         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 249
 250         return USB_Host_SendControlRequest(&CDCInterfaceInfo->State.LineEncoding);
 251 }
 252
 253 uint8_t CDC_Host_SendControlLineStateChange(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 254 {
 255         USB_ControlRequest = (USB_Request_Header_t)
 256         {
 257                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 258                 .bRequest      = REQ_SetControlLineState,
 259                 .wValue        = CDCInterfaceInfo->State.ControlLineStates.HostToDevice,
 260                 .wIndex        = CDCInterfaceInfo->State.ControlInterfaceNumber,
 261                 .wLength       = 0,
 262         };
 263
 264         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 265
 266         return USB_Host_SendControlRequest(NULL);
 267 }
 268
 269 uint8_t CDC_Host_SendBreak(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
 270                            const uint8_t Duration)
 271 {
 272         USB_ControlRequest = (USB_Request_Header_t)
 273         {
 274                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 275                 .bRequest      = REQ_SendBreak,
 276                 .wValue        = Duration,
 277                 .wIndex        = CDCInterfaceInfo->State.ControlInterfaceNumber,
 278                 .wLength       = 0,
 279         };
 280
 281         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 282
 283         return USB_Host_SendControlRequest(NULL);
 284 }
 285
 286 uint8_t CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
 287                             const char* const Data,
 288                             const uint16_t Length)
 289 {
 290         if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 291           return PIPE_READYWAIT_DeviceDisconnected;
 292
 293         uint8_t ErrorCode;
 294
 295         Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
 296
 297         Pipe_Unfreeze();
 298         ErrorCode = Pipe_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);
 299         Pipe_Freeze();
 300
 301         return ErrorCode;
 302 }
 303
 304 uint8_t CDC_Host_SendByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
 305                           const uint8_t Data)
 306 {
 307         if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 308           return PIPE_READYWAIT_DeviceDisconnected;
 309
 310         uint8_t ErrorCode;
 311
 312         Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
 313         Pipe_Unfreeze();
 314
 315         if (!(Pipe_IsReadWriteAllowed()))
 316         {
 317                 Pipe_ClearOUT();
 318
 319                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 320                   return ErrorCode;
 321         }
 322
 323         Pipe_Write_Byte(Data);
 324         Pipe_Freeze();
 325
 326         return PIPE_READYWAIT_NoError;
 327 }
 328
 329 uint16_t CDC_Host_BytesReceived(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 330 {
 331         if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 332           return 0;
 333
 334         Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
 335         Pipe_Unfreeze();
 336
 337         if (Pipe_IsINReceived())
 338         {
 339                 if (!(Pipe_BytesInPipe()))
 340                 {
 341                         Pipe_ClearIN();
 342                         Pipe_Freeze();
 343                         return 0;
 344                 }
 345                 else
 346                 {
 347                         Pipe_Freeze();
 348                         return Pipe_BytesInPipe();
 349                 }
 350         }
 351         else
 352         {
 353                 Pipe_Freeze();
 354
 355                 return 0;
 356         }
 357 }
 358
 359 int16_t CDC_Host_ReceiveByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 360 {
 361         if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 362           return -1;
 363
 364         int16_t ReceivedByte = -1;
 365
 366         Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
 367         Pipe_Unfreeze();
 368
 369         if (Pipe_IsINReceived())
 370         {
 371                 if (Pipe_BytesInPipe())
 372                   ReceivedByte = Pipe_Read_Byte();
 373
 374                 if (!(Pipe_BytesInPipe()))
 375                   Pipe_ClearIN();
 376         }
 377
 378         Pipe_Freeze();
 379
 380         return ReceivedByte;
 381 }
 382
 383 uint8_t CDC_Host_Flush(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 384 {
 385         if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 386           return PIPE_READYWAIT_DeviceDisconnected;
 387
 388         uint8_t ErrorCode;
 389
 390         Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
 391         Pipe_Unfreeze();
 392
 393         if (!(Pipe_BytesInPipe()))
 394           return PIPE_READYWAIT_NoError;
 395
 396         bool BankFull = !(Pipe_IsReadWriteAllowed());
 397
 398         Pipe_ClearOUT();
 399
 400         if (BankFull)
 401         {
 402                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 403                   return ErrorCode;
 404
 405                 Pipe_ClearOUT();
 406         }
 407
 408         Pipe_Freeze();
 409
 410         return PIPE_READYWAIT_NoError;
 411 }
 412
 413 void CDC_Host_CreateStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
 414                            FILE* const Stream)
 415 {
 416         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Host_putchar, CDC_Host_getchar, _FDEV_SETUP_RW);
 417         fdev_set_udata(Stream, CDCInterfaceInfo);
 418 }
 419
 420 void CDC_Host_CreateBlockingStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
 421                                    FILE* const Stream)
 422 {
 423         *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Host_putchar, CDC_Host_getchar_Blocking, _FDEV_SETUP_RW);
 424         fdev_set_udata(Stream, CDCInterfaceInfo);
 425 }
 426
 427 static int CDC_Host_putchar(char c,
 428                             FILE* Stream)
 429 {
 430         return CDC_Host_SendByte((USB_ClassInfo_CDC_Host_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
 431 }
 432
 433 static int CDC_Host_getchar(FILE* Stream)
 434 {
 435         int16_t ReceivedByte = CDC_Host_ReceiveByte((USB_ClassInfo_CDC_Host_t*)fdev_get_udata(Stream));
 436
 437         if (ReceivedByte < 0)
 438           return _FDEV_EOF;
 439
 440         return ReceivedByte;
 441 }
 442
 443 static int CDC_Host_getchar_Blocking(FILE* Stream)
 444 {
 445         int16_t ReceivedByte;
 446
 447         while ((ReceivedByte = CDC_Host_ReceiveByte((USB_ClassInfo_CDC_Host_t*)fdev_get_udata(Stream))) < 0)
 448         {
 449                 if (USB_HostState == HOST_STATE_Unattached)
 450                   return _FDEV_EOF;
 451
 452                 CDC_Host_USBTask((USB_ClassInfo_CDC_Host_t*)fdev_get_udata(Stream));
 453                 USB_USBTask();
 454         }
 455
 456         return ReceivedByte;
 457 }
 458
 459 void CDC_Host_Event_Stub(void)
 460 {
 461
 462 }
 463
 464 #endif