projects / pub / USBasp.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix device mode for the U4 parts.
[pub/USBasp.git] / LUFA / Drivers / USB / Class / Host / CDC.c
diff --git a/LUFA/Drivers/USB/Class/Host/CDC.c b/LUFA/Drivers/USB/Class/Host/CDC.c
index 5fb232c..0f81d0e 100644 (file)
--- a/LUFA/Drivers/USB/Class/Host/CDC.c
+++ b/LUFA/Drivers/USB/Class/Host/CDC.c
@@ -40,103 +40,98 @@ uint8_t CDC_Host_ConfigurePipes(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo
                                 uint16_t ConfigDescriptorSize,
                                 void* ConfigDescriptorData)
 {
                                 uint16_t ConfigDescriptorSize,
                                 void* ConfigDescriptorData)
 {
-       uint8_t FoundEndpoints = 0;
+       USB_Descriptor_Endpoint_t*  DataINEndpoint       = NULL;
+       USB_Descriptor_Endpoint_t*  DataOUTEndpoint      = NULL;
+       USB_Descriptor_Endpoint_t*  NotificationEndpoint = NULL;
+       USB_Descriptor_Interface_t* CDCControlInterface  = NULL;
 
        memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State));
 
        if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
          return CDC_ENUMERROR_InvalidConfigDescriptor;
 
        memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State));
 
        if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
          return CDC_ENUMERROR_InvalidConfigDescriptor;
-       
-       if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
-                                     DCOMP_CDC_Host_NextCDCControlInterface) != DESCRIPTOR_SEARCH_COMP_Found)
-       {
-               return CDC_ENUMERROR_NoCDCInterfaceFound;
-       }
-       
-       CDCInterfaceInfo->State.ControlInterfaceNumber = DESCRIPTOR_CAST(ConfigDescriptorData, USB_Descriptor_Interface_t).InterfaceNumber;
 
 
-       while (FoundEndpoints != (CDC_FOUND_NOTIFICATION_IN | CDC_FOUND_DATAPIPE_IN | CDC_FOUND_DATAPIPE_OUT))
+       while (!(DataINEndpoint) || !(DataOUTEndpoint) || !(NotificationEndpoint))
        {
        {
-               if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
+               if (!(CDCControlInterface) ||
+                   USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
                                              DCOMP_CDC_Host_NextCDCInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
                {
                                              DCOMP_CDC_Host_NextCDCInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
                {
-                       if (FoundEndpoints & CDC_FOUND_NOTIFICATION_IN)
+                       if (NotificationEndpoint)
                        {
                        {
-                               if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData, 
+                               if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
                                                              DCOMP_CDC_Host_NextCDCDataInterface) != DESCRIPTOR_SEARCH_COMP_Found)
                                {
                                                              DCOMP_CDC_Host_NextCDCDataInterface) != DESCRIPTOR_SEARCH_COMP_Found)
                                {
-                                       return CDC_ENUMERROR_NoCDCInterfaceFound;
-                               }
+                                       return CDC_ENUMERROR_NoCompatibleInterfaceFound;
+                               }                       
+
+                               DataINEndpoint  = NULL;
+                               DataOUTEndpoint = NULL;
                        }
                        else
                        {
                        }
                        else
                        {
-                               FoundEndpoints = 0;
-
-                               Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
-                               Pipe_DisablePipe();
-                               Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
-                               Pipe_DisablePipe();
-                               Pipe_SelectPipe(CDCInterfaceInfo->Config.NotificationPipeNumber);
-                               Pipe_DisablePipe();
-                       
                                if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
                                                              DCOMP_CDC_Host_NextCDCControlInterface) != DESCRIPTOR_SEARCH_COMP_Found)
                                {
                                if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
                                                              DCOMP_CDC_Host_NextCDCControlInterface) != DESCRIPTOR_SEARCH_COMP_Found)
                                {
-                                       return CDC_ENUMERROR_NoCDCInterfaceFound;
+                                       return CDC_ENUMERROR_NoCompatibleInterfaceFound;
                                }
                                }
-                       }
 
 
-                       if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
-                                                     DCOMP_CDC_Host_NextCDCInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
-                       {
-                               return CDC_ENUMERROR_EndpointsNotFound;
+                               CDCControlInterface = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Interface_t);
+
+                               NotificationEndpoint = NULL;
                        }
                        }
+                       
+                       continue;
                }
                
                USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
 
                }
                
                USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
 
-               if ((EndpointData->Attributes & EP_TYPE_MASK) == EP_TYPE_INTERRUPT)
+               if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
                {
                {
-                       if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
-                       {
-                               Pipe_ConfigurePipe(CDCInterfaceInfo->Config.NotificationPipeNumber, EP_TYPE_INTERRUPT, PIPE_TOKEN_IN,
-                                                                  EndpointData->EndpointAddress, EndpointData->EndpointSize,
-                                                                  CDCInterfaceInfo->Config.NotificationPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
-                               CDCInterfaceInfo->State.NotificationPipeSize = EndpointData->EndpointSize;
-
-                               Pipe_SetInterruptPeriod(EndpointData->PollingIntervalMS);
-                               
-                               FoundEndpoints |= CDC_FOUND_NOTIFICATION_IN;
-                       }
+                       if ((EndpointData->Attributes & EP_TYPE_MASK) == EP_TYPE_INTERRUPT)
+                         NotificationEndpoint = EndpointData;
+                       else
+                         DataINEndpoint = EndpointData;
                }
                else
                {
                }
                else
                {
-                       if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
-                       {
-                               Pipe_ConfigurePipe(CDCInterfaceInfo->Config.DataINPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_IN,
-                                                  EndpointData->EndpointAddress, EndpointData->EndpointSize, 
-                                                  CDCInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
+                       DataOUTEndpoint = EndpointData;
+               }
+       }
+       
+       for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
+       {
+               if (PipeNum == CDCInterfaceInfo->Config.DataINPipeNumber)
+               {
+                       Pipe_ConfigurePipe(PipeNum, EP_TYPE_BULK, PIPE_TOKEN_IN,
+                                          DataINEndpoint->EndpointAddress, DataINEndpoint->EndpointSize,
+                                          CDCInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
+
+                       CDCInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
+               }
+               else if (PipeNum == CDCInterfaceInfo->Config.DataOUTPipeNumber)
+               {
+                       Pipe_ConfigurePipe(PipeNum, EP_TYPE_BULK, PIPE_TOKEN_OUT,
+                                          DataOUTEndpoint->EndpointAddress, DataOUTEndpoint->EndpointSize,
+                                          CDCInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
 
 
-                               CDCInterfaceInfo->State.DataINPipeSize = EndpointData->EndpointSize;
+                       CDCInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
+               }
+               else if (PipeNum == CDCInterfaceInfo->Config.NotificationPipeNumber)
+               {
+                       Pipe_ConfigurePipe(PipeNum, EP_TYPE_INTERRUPT, PIPE_TOKEN_IN,
+                                          NotificationEndpoint->EndpointAddress, NotificationEndpoint->EndpointSize,
+                                          CDCInterfaceInfo->Config.NotificationPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
+                       Pipe_SetInterruptPeriod(NotificationEndpoint->PollingIntervalMS);
 
 
-                               FoundEndpoints |= CDC_FOUND_DATAPIPE_IN;
-                       }
-                       else
-                       {
-                               Pipe_ConfigurePipe(CDCInterfaceInfo->Config.DataOUTPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_OUT,
-                                                                  EndpointData->EndpointAddress, EndpointData->EndpointSize, 
-                                                                  CDCInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
-                       
-                               CDCInterfaceInfo->State.DataOUTPipeSize = EndpointData->EndpointSize;
-                               
-                               FoundEndpoints |= CDC_FOUND_DATAPIPE_OUT;
-                       }
+                       CDCInterfaceInfo->State.NotificationPipeSize = NotificationEndpoint->EndpointSize;
                }
        }
 
                }
        }
 
+       CDCInterfaceInfo->State.ControlInterfaceNumber = CDCControlInterface->InterfaceNumber;
        CDCInterfaceInfo->State.ControlLineStates.HostToDevice = (CDC_CONTROL_LINE_OUT_RTS | CDC_CONTROL_LINE_OUT_DTR);
        CDCInterfaceInfo->State.ControlLineStates.DeviceToHost = (CDC_CONTROL_LINE_IN_DCD  | CDC_CONTROL_LINE_IN_DSR);
        CDCInterfaceInfo->State.IsActive = true;
        CDCInterfaceInfo->State.ControlLineStates.HostToDevice = (CDC_CONTROL_LINE_OUT_RTS | CDC_CONTROL_LINE_OUT_DTR);
        CDCInterfaceInfo->State.ControlLineStates.DeviceToHost = (CDC_CONTROL_LINE_IN_DCD  | CDC_CONTROL_LINE_IN_DSR);
        CDCInterfaceInfo->State.IsActive = true;
+
        return CDC_ENUMERROR_NoError;
 }
 
        return CDC_ENUMERROR_NoError;
 }
 
@@ -149,7 +144,7 @@ static uint8_t DCOMP_CDC_Host_NextCDCControlInterface(void* const CurrentDescrip
        
                if ((CurrentInterface->Class    == CDC_CONTROL_CLASS)    &&
                    (CurrentInterface->SubClass == CDC_CONTROL_SUBCLASS) &&
        
                if ((CurrentInterface->Class    == CDC_CONTROL_CLASS)    &&
                    (CurrentInterface->SubClass == CDC_CONTROL_SUBCLASS) &&
-                       (CurrentInterface->Protocol == CDC_CONTROL_PROTOCOL))
+                   (CurrentInterface->Protocol == CDC_CONTROL_PROTOCOL))
                {
                        return DESCRIPTOR_SEARCH_Found;
                }
                {
                        return DESCRIPTOR_SEARCH_Found;
                }
@@ -167,7 +162,7 @@ static uint8_t DCOMP_CDC_Host_NextCDCDataInterface(void* const CurrentDescriptor
        
                if ((CurrentInterface->Class    == CDC_DATA_CLASS)    &&
                    (CurrentInterface->SubClass == CDC_DATA_SUBCLASS) &&
        
                if ((CurrentInterface->Class    == CDC_DATA_CLASS)    &&
                    (CurrentInterface->SubClass == CDC_DATA_SUBCLASS) &&
-                       (CurrentInterface->Protocol == CDC_DATA_PROTOCOL))
+                   (CurrentInterface->Protocol == CDC_DATA_PROTOCOL))
                {
                        return DESCRIPTOR_SEARCH_Found;
                }
                {
                        return DESCRIPTOR_SEARCH_Found;
                }
@@ -205,7 +200,6 @@ void CDC_Host_USBTask(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
          return;
        
        Pipe_SelectPipe(CDCInterfaceInfo->Config.NotificationPipeNumber);
          return;
        
        Pipe_SelectPipe(CDCInterfaceInfo->Config.NotificationPipeNumber);
-       Pipe_SetPipeToken(PIPE_TOKEN_IN);
        Pipe_Unfreeze();
 
        if (Pipe_IsINReceived())
        Pipe_Unfreeze();
 
        if (Pipe_IsINReceived())
@@ -213,7 +207,7 @@ void CDC_Host_USBTask(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
                USB_Request_Header_t Notification;
                Pipe_Read_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NO_STREAM_CALLBACK);
                
                USB_Request_Header_t Notification;
                Pipe_Read_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NO_STREAM_CALLBACK);
                
-               if ((Notification.bRequest      == NOTIF_SerialState) &&
+               if ((Notification.bRequest      == CDC_NOTIF_SerialState) &&
                    (Notification.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)))
                {
                        Pipe_Read_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
                    (Notification.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)))
                {
                        Pipe_Read_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
@@ -240,7 +234,7 @@ uint8_t CDC_Host_SetLineEncoding(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInf
        USB_ControlRequest = (USB_Request_Header_t)
        {
                .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
        USB_ControlRequest = (USB_Request_Header_t)
        {
                .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
-               .bRequest      = REQ_SetLineEncoding,
+               .bRequest      = CDC_REQ_SetLineEncoding,
                .wValue        = 0,
                .wIndex        = CDCInterfaceInfo->State.ControlInterfaceNumber,
                .wLength       = sizeof(CDCInterfaceInfo->State.LineEncoding),
                .wValue        = 0,
                .wIndex        = CDCInterfaceInfo->State.ControlInterfaceNumber,
                .wLength       = sizeof(CDCInterfaceInfo->State.LineEncoding),
@@ -256,7 +250,7 @@ uint8_t CDC_Host_SendControlLineStateChange(USB_ClassInfo_CDC_Host_t* const CDCI
        USB_ControlRequest = (USB_Request_Header_t)
        {
                .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
        USB_ControlRequest = (USB_Request_Header_t)
        {
                .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
-               .bRequest      = REQ_SetControlLineState,
+               .bRequest      = CDC_REQ_SetControlLineState,
                .wValue        = CDCInterfaceInfo->State.ControlLineStates.HostToDevice,
                .wIndex        = CDCInterfaceInfo->State.ControlInterfaceNumber,
                .wLength       = 0,
                .wValue        = CDCInterfaceInfo->State.ControlLineStates.HostToDevice,
                .wIndex        = CDCInterfaceInfo->State.ControlInterfaceNumber,
                .wLength       = 0,
@@ -273,7 +267,7 @@ uint8_t CDC_Host_SendBreak(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
        USB_ControlRequest = (USB_Request_Header_t)
        {
                .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
        USB_ControlRequest = (USB_Request_Header_t)
        {
                .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
-               .bRequest      = REQ_SendBreak,
+               .bRequest      = CDC_REQ_SendBreak,
                .wValue        = Duration,
                .wIndex        = CDCInterfaceInfo->State.ControlInterfaceNumber,
                .wLength       = 0,
                .wValue        = Duration,
                .wIndex        = CDCInterfaceInfo->State.ControlInterfaceNumber,
                .wLength       = 0,
@@ -285,7 +279,7 @@ uint8_t CDC_Host_SendBreak(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
 }
 
 uint8_t CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
 }
 
 uint8_t CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
-                            char* const Data,
+                            const char* const Data,
                             const uint16_t Length)
 {
        if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
                             const uint16_t Length)
 {
        if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
@@ -333,7 +327,6 @@ uint16_t CDC_Host_BytesReceived(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo
          return 0;
        
        Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
          return 0;
        
        Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
-       Pipe_SetPipeToken(PIPE_TOKEN_IN);
        Pipe_Unfreeze();
 
        if (Pipe_IsINReceived())
        Pipe_Unfreeze();
 
        if (Pipe_IsINReceived())
@@ -360,25 +353,25 @@ uint16_t CDC_Host_BytesReceived(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo
 
 int16_t CDC_Host_ReceiveByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 {
 
 int16_t CDC_Host_ReceiveByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 {
-       uint8_t ReceivedByte = -1;
-
        if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
        if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
-         return 0;
+         return -1;
          
          
+       int16_t ReceivedByte = -1;
+
        Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
        Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
-       Pipe_SetPipeToken(PIPE_TOKEN_IN);
        Pipe_Unfreeze();
 
        Pipe_Unfreeze();
 
-       if (!(Pipe_IsINReceived()))
-         return -1;
-       else if (Pipe_BytesInPipe())
-         ReceivedByte = Pipe_Read_Byte();
+       if (Pipe_IsINReceived())
+       {
+               if (Pipe_BytesInPipe())
+                 ReceivedByte = Pipe_Read_Byte();
 
 
-       if (!(Pipe_BytesInPipe()))
-         Pipe_ClearIN();
-               
-       Pipe_Freeze();
+               if (!(Pipe_BytesInPipe()))
+                 Pipe_ClearIN();
+       }
        
        
+       Pipe_Freeze();
+
        return ReceivedByte;
 }
 
        return ReceivedByte;
 }
 
USB isp AVR programmer