3 Copyright (C) Dean Camera, 2012.
\r
5 dean [at] fourwalledcubicle [dot] com
\r
10 Copyright 2012 Dean Camera (dean [at] fourwalledcubicle [dot] com)
\r
12 Permission to use, copy, modify, distribute, and sell this
\r
13 software and its documentation for any purpose is hereby granted
\r
14 without fee, provided that the above copyright notice appear in
\r
15 all copies and that both that the copyright notice and this
\r
16 permission notice and warranty disclaimer appear in supporting
\r
17 documentation, and that the name of the author not be used in
\r
18 advertising or publicity pertaining to distribution of the
\r
19 software without specific, written prior permission.
\r
21 The author disclaim all warranties with regard to this
\r
22 software, including all implied warranties of merchantability
\r
23 and fitness. In no event shall the author be liable for any
\r
24 special, indirect or consequential damages or any damages
\r
25 whatsoever resulting from loss of use, data or profits, whether
\r
26 in an action of contract, negligence or other tortious action,
\r
27 arising out of or in connection with the use or performance of
\r
31 #define __INCLUDE_FROM_USB_DRIVER
\r
32 #include "../../Core/USBMode.h"
\r
34 #if defined(USB_CAN_BE_HOST)
\r
36 #define __INCLUDE_FROM_CDC_DRIVER
\r
37 #define __INCLUDE_FROM_CDC_HOST_C
\r
38 #include "CDCClassHost.h"
\r
40 uint8_t CDC_Host_ConfigurePipes(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
\r
41 uint16_t ConfigDescriptorSize,
\r
42 void* ConfigDescriptorData)
\r
44 USB_Descriptor_Endpoint_t* DataINEndpoint = NULL;
\r
45 USB_Descriptor_Endpoint_t* DataOUTEndpoint = NULL;
\r
46 USB_Descriptor_Endpoint_t* NotificationEndpoint = NULL;
\r
47 USB_Descriptor_Interface_t* CDCControlInterface = NULL;
\r
49 memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State));
\r
51 if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
\r
52 return CDC_ENUMERROR_InvalidConfigDescriptor;
\r
54 while (!(DataINEndpoint) || !(DataOUTEndpoint) || !(NotificationEndpoint))
\r
56 if (!(CDCControlInterface) ||
\r
57 USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
\r
58 DCOMP_CDC_Host_NextCDCInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
\r
60 if (NotificationEndpoint)
\r
62 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
\r
63 DCOMP_CDC_Host_NextCDCDataInterface) != DESCRIPTOR_SEARCH_COMP_Found)
\r
65 return CDC_ENUMERROR_NoCompatibleInterfaceFound;
\r
68 DataINEndpoint = NULL;
\r
69 DataOUTEndpoint = NULL;
\r
73 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
\r
74 DCOMP_CDC_Host_NextCDCControlInterface) != DESCRIPTOR_SEARCH_COMP_Found)
\r
76 return CDC_ENUMERROR_NoCompatibleInterfaceFound;
\r
79 CDCControlInterface = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Interface_t);
\r
81 NotificationEndpoint = NULL;
\r
87 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
\r
89 if ((EndpointData->EndpointAddress & ENDPOINT_DIR_MASK) == ENDPOINT_DIR_IN)
\r
91 if ((EndpointData->Attributes & EP_TYPE_MASK) == EP_TYPE_INTERRUPT)
\r
92 NotificationEndpoint = EndpointData;
\r
94 DataINEndpoint = EndpointData;
\r
98 DataOUTEndpoint = EndpointData;
\r
102 CDCInterfaceInfo->Config.DataINPipe.Size = le16_to_cpu(DataINEndpoint->EndpointSize);
\r
103 CDCInterfaceInfo->Config.DataINPipe.EndpointAddress = DataINEndpoint->EndpointAddress;
\r
104 CDCInterfaceInfo->Config.DataINPipe.Type = EP_TYPE_BULK;
\r
106 CDCInterfaceInfo->Config.DataOUTPipe.Size = le16_to_cpu(DataOUTEndpoint->EndpointSize);
\r
107 CDCInterfaceInfo->Config.DataOUTPipe.EndpointAddress = DataOUTEndpoint->EndpointAddress;
\r
108 CDCInterfaceInfo->Config.DataOUTPipe.Type = EP_TYPE_BULK;
\r
110 CDCInterfaceInfo->Config.NotificationPipe.Size = le16_to_cpu(NotificationEndpoint->EndpointSize);
\r
111 CDCInterfaceInfo->Config.NotificationPipe.EndpointAddress = NotificationEndpoint->EndpointAddress;
\r
112 CDCInterfaceInfo->Config.NotificationPipe.Type = EP_TYPE_INTERRUPT;
\r
114 if (!(Pipe_ConfigurePipeTable(&CDCInterfaceInfo->Config.DataINPipe, 1)))
\r
117 if (!(Pipe_ConfigurePipeTable(&CDCInterfaceInfo->Config.DataOUTPipe, 1)))
\r
120 if (!(Pipe_ConfigurePipeTable(&CDCInterfaceInfo->Config.NotificationPipe, 1)))
\r
123 CDCInterfaceInfo->State.ControlInterfaceNumber = CDCControlInterface->InterfaceNumber;
\r
124 CDCInterfaceInfo->State.ControlLineStates.HostToDevice = (CDC_CONTROL_LINE_OUT_RTS | CDC_CONTROL_LINE_OUT_DTR);
\r
125 CDCInterfaceInfo->State.ControlLineStates.DeviceToHost = (CDC_CONTROL_LINE_IN_DCD | CDC_CONTROL_LINE_IN_DSR);
\r
126 CDCInterfaceInfo->State.IsActive = true;
\r
128 return CDC_ENUMERROR_NoError;
\r
131 static uint8_t DCOMP_CDC_Host_NextCDCControlInterface(void* const CurrentDescriptor)
\r
133 USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
\r
135 if (Header->Type == DTYPE_Interface)
\r
137 USB_Descriptor_Interface_t* Interface = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Interface_t);
\r
139 if ((Interface->Class == CDC_CSCP_CDCClass) &&
\r
140 (Interface->SubClass == CDC_CSCP_ACMSubclass) &&
\r
141 (Interface->Protocol == CDC_CSCP_ATCommandProtocol))
\r
143 return DESCRIPTOR_SEARCH_Found;
\r
147 return DESCRIPTOR_SEARCH_NotFound;
\r
150 static uint8_t DCOMP_CDC_Host_NextCDCDataInterface(void* const CurrentDescriptor)
\r
152 USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
\r
154 if (Header->Type == DTYPE_Interface)
\r
156 USB_Descriptor_Interface_t* Interface = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Interface_t);
\r
158 if ((Interface->Class == CDC_CSCP_CDCDataClass) &&
\r
159 (Interface->SubClass == CDC_CSCP_NoDataSubclass) &&
\r
160 (Interface->Protocol == CDC_CSCP_NoDataProtocol))
\r
162 return DESCRIPTOR_SEARCH_Found;
\r
166 return DESCRIPTOR_SEARCH_NotFound;
\r
169 static uint8_t DCOMP_CDC_Host_NextCDCInterfaceEndpoint(void* const CurrentDescriptor)
\r
171 USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
\r
173 if (Header->Type == DTYPE_Endpoint)
\r
175 USB_Descriptor_Endpoint_t* Endpoint = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Endpoint_t);
\r
177 uint8_t EndpointType = (Endpoint->Attributes & EP_TYPE_MASK);
\r
179 if (((EndpointType == EP_TYPE_BULK) || (EndpointType == EP_TYPE_INTERRUPT)) &&
\r
180 !(Pipe_IsEndpointBound(Endpoint->EndpointAddress)))
\r
182 return DESCRIPTOR_SEARCH_Found;
\r
185 else if (Header->Type == DTYPE_Interface)
\r
187 return DESCRIPTOR_SEARCH_Fail;
\r
190 return DESCRIPTOR_SEARCH_NotFound;
\r
193 void CDC_Host_USBTask(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
\r
195 if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
\r
198 Pipe_SelectPipe(CDCInterfaceInfo->Config.NotificationPipe.Address);
\r
201 if (Pipe_IsINReceived())
\r
203 USB_Request_Header_t Notification;
\r
204 Pipe_Read_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NULL);
\r
206 if ((Notification.bRequest == CDC_NOTIF_SerialState) &&
\r
207 (Notification.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)))
\r
209 Pipe_Read_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
\r
210 sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
\r
215 EVENT_CDC_Host_ControLineStateChanged(CDCInterfaceInfo);
\r
225 #if !defined(NO_CLASS_DRIVER_AUTOFLUSH)
\r
226 CDC_Host_Flush(CDCInterfaceInfo);
\r
230 uint8_t CDC_Host_SetLineEncoding(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
\r
232 USB_ControlRequest = (USB_Request_Header_t)
\r
234 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
\r
235 .bRequest = CDC_REQ_SetLineEncoding,
\r
237 .wIndex = CDCInterfaceInfo->State.ControlInterfaceNumber,
\r
238 .wLength = sizeof(CDCInterfaceInfo->State.LineEncoding),
\r
241 Pipe_SelectPipe(PIPE_CONTROLPIPE);
\r
243 return USB_Host_SendControlRequest(&CDCInterfaceInfo->State.LineEncoding);
\r
246 uint8_t CDC_Host_SendControlLineStateChange(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
\r
248 USB_ControlRequest = (USB_Request_Header_t)
\r
250 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
\r
251 .bRequest = CDC_REQ_SetControlLineState,
\r
252 .wValue = CDCInterfaceInfo->State.ControlLineStates.HostToDevice,
\r
253 .wIndex = CDCInterfaceInfo->State.ControlInterfaceNumber,
\r
257 Pipe_SelectPipe(PIPE_CONTROLPIPE);
\r
259 return USB_Host_SendControlRequest(NULL);
\r
262 uint8_t CDC_Host_SendBreak(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
\r
263 const uint8_t Duration)
\r
265 USB_ControlRequest = (USB_Request_Header_t)
\r
267 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
\r
268 .bRequest = CDC_REQ_SendBreak,
\r
269 .wValue = Duration,
\r
270 .wIndex = CDCInterfaceInfo->State.ControlInterfaceNumber,
\r
274 Pipe_SelectPipe(PIPE_CONTROLPIPE);
\r
276 return USB_Host_SendControlRequest(NULL);
\r
279 uint8_t CDC_Host_SendData(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
\r
280 const uint8_t* const Buffer,
\r
281 const uint16_t Length)
\r
283 if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
\r
284 return PIPE_READYWAIT_DeviceDisconnected;
\r
288 Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipe.Address);
\r
291 ErrorCode = Pipe_Write_Stream_LE(Buffer, Length, NULL);
\r
297 uint8_t CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
\r
298 const char* const String)
\r
300 if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
\r
301 return PIPE_READYWAIT_DeviceDisconnected;
\r
305 Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipe.Address);
\r
308 ErrorCode = Pipe_Write_Stream_LE(String, strlen(String), NULL);
\r
314 uint8_t CDC_Host_SendByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
\r
315 const uint8_t Data)
\r
317 if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
\r
318 return PIPE_READYWAIT_DeviceDisconnected;
\r
322 Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipe.Address);
\r
325 if (!(Pipe_IsReadWriteAllowed()))
\r
329 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
\r
333 Pipe_Write_8(Data);
\r
336 return PIPE_READYWAIT_NoError;
\r
339 uint16_t CDC_Host_BytesReceived(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
\r
341 if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
\r
344 Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipe.Address);
\r
347 if (Pipe_IsINReceived())
\r
349 if (!(Pipe_BytesInPipe()))
\r
358 return Pipe_BytesInPipe();
\r
369 int16_t CDC_Host_ReceiveByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
\r
371 if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
\r
374 int16_t ReceivedByte = -1;
\r
376 Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipe.Address);
\r
379 if (Pipe_IsINReceived())
\r
381 if (Pipe_BytesInPipe())
\r
382 ReceivedByte = Pipe_Read_8();
\r
384 if (!(Pipe_BytesInPipe()))
\r
390 return ReceivedByte;
\r
393 uint8_t CDC_Host_Flush(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
\r
395 if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
\r
396 return PIPE_READYWAIT_DeviceDisconnected;
\r
400 Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipe.Address);
\r
403 if (!(Pipe_BytesInPipe()))
\r
404 return PIPE_READYWAIT_NoError;
\r
406 bool BankFull = !(Pipe_IsReadWriteAllowed());
\r
412 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
\r
420 return PIPE_READYWAIT_NoError;
\r
423 #if defined(FDEV_SETUP_STREAM)
\r
424 void CDC_Host_CreateStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
\r
425 FILE* const Stream)
\r
427 *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Host_putchar, CDC_Host_getchar, _FDEV_SETUP_RW);
\r
428 fdev_set_udata(Stream, CDCInterfaceInfo);
\r
431 void CDC_Host_CreateBlockingStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
\r
432 FILE* const Stream)
\r
434 *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Host_putchar, CDC_Host_getchar_Blocking, _FDEV_SETUP_RW);
\r
435 fdev_set_udata(Stream, CDCInterfaceInfo);
\r
438 static int CDC_Host_putchar(char c,
\r
441 return CDC_Host_SendByte((USB_ClassInfo_CDC_Host_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
\r
444 static int CDC_Host_getchar(FILE* Stream)
\r
446 int16_t ReceivedByte = CDC_Host_ReceiveByte((USB_ClassInfo_CDC_Host_t*)fdev_get_udata(Stream));
\r
448 if (ReceivedByte < 0)
\r
451 return ReceivedByte;
\r
454 static int CDC_Host_getchar_Blocking(FILE* Stream)
\r
456 int16_t ReceivedByte;
\r
458 while ((ReceivedByte = CDC_Host_ReceiveByte((USB_ClassInfo_CDC_Host_t*)fdev_get_udata(Stream))) < 0)
\r
460 if (USB_HostState == HOST_STATE_Unattached)
\r
463 CDC_Host_USBTask((USB_ClassInfo_CDC_Host_t*)fdev_get_udata(Stream));
\r
467 return ReceivedByte;
\r
471 // cppcheck-suppress unusedFunction
\r
472 void CDC_Host_Event_Stub(void)
\r