Removed complicated logic for the Endpoint_ConfigureEndpoint() function to use inlined or function called versions depending of if the given bank size is a compile time constant, as the compiler does a better job of optimizing with basic code.

Changed over all device demos to use a clearer algorithm for the configuring of the application's endpoints.
pull/1469/head
Dean Camera 14 years ago
parent be520aed52
commit 508e905d8d

@ -136,10 +136,11 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(Audio_Device_ConfigureEndpoints(&Microphone_Audio_Interface))) ConfigSuccess &= Audio_Device_ConfigureEndpoints(&Microphone_Audio_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -188,10 +188,11 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(Audio_Device_ConfigureEndpoints(&Speaker_Audio_Interface))) ConfigSuccess &= Audio_Device_ConfigureEndpoints(&Speaker_Audio_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -175,13 +175,12 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial1_CDC_Interface))) ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial1_CDC_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial2_CDC_Interface);
if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial2_CDC_Interface))) LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -113,12 +113,13 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(HID_Device_ConfigureEndpoints(&Generic_HID_Interface))) ConfigSuccess &= HID_Device_ConfigureEndpoints(&Generic_HID_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
USB_Device_EnableSOFEvents(); USB_Device_EnableSOFEvents();
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -107,12 +107,13 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(HID_Device_ConfigureEndpoints(&Joystick_HID_Interface))) ConfigSuccess &= HID_Device_ConfigureEndpoints(&Joystick_HID_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
USB_Device_EnableSOFEvents(); USB_Device_EnableSOFEvents();
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -107,12 +107,13 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(HID_Device_ConfigureEndpoints(&Keyboard_HID_Interface))) ConfigSuccess &= HID_Device_ConfigureEndpoints(&Keyboard_HID_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
USB_Device_EnableSOFEvents(); USB_Device_EnableSOFEvents();
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -130,15 +130,14 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(HID_Device_ConfigureEndpoints(&Keyboard_HID_Interface))) ConfigSuccess &= HID_Device_ConfigureEndpoints(&Keyboard_HID_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); ConfigSuccess &= HID_Device_ConfigureEndpoints(&Mouse_HID_Interface);
if (!(HID_Device_ConfigureEndpoints(&Mouse_HID_Interface)))
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
USB_Device_EnableSOFEvents(); USB_Device_EnableSOFEvents();
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -180,10 +180,13 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(MIDI_Device_ConfigureEndpoints(&Keyboard_MIDI_Interface))) ConfigSuccess &= MIDI_Device_ConfigureEndpoints(&Keyboard_MIDI_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
USB_Device_EnableSOFEvents();
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -110,10 +110,13 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
ConfigSuccess &= MS_Device_ConfigureEndpoints(&Disk_MS_Interface);
USB_Device_EnableSOFEvents();
if (!(MS_Device_ConfigureEndpoints(&Disk_MS_Interface))) LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -136,15 +136,14 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(MS_Device_ConfigureEndpoints(&Disk_MS_Interface)))
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
if (!(HID_Device_ConfigureEndpoints(&Keyboard_HID_Interface))) ConfigSuccess &= MS_Device_ConfigureEndpoints(&Disk_MS_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); ConfigSuccess &= HID_Device_ConfigureEndpoints(&Keyboard_HID_Interface);
USB_Device_EnableSOFEvents(); USB_Device_EnableSOFEvents();
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -107,12 +107,13 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(HID_Device_ConfigureEndpoints(&Mouse_HID_Interface))) ConfigSuccess &= HID_Device_ConfigureEndpoints(&Mouse_HID_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
USB_Device_EnableSOFEvents(); USB_Device_EnableSOFEvents();
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -123,10 +123,11 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(RNDIS_Device_ConfigureEndpoints(&Ethernet_RNDIS_Interface))) ConfigSuccess &= RNDIS_Device_ConfigureEndpoints(&Ethernet_RNDIS_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -153,10 +153,11 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface))) ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -164,15 +164,14 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface))) ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); ConfigSuccess &= HID_Device_ConfigureEndpoints(&Mouse_HID_Interface);
if (!(HID_Device_ConfigureEndpoints(&Mouse_HID_Interface)))
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
USB_Device_EnableSOFEvents(); USB_Device_EnableSOFEvents();
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -95,22 +95,16 @@ void EVENT_USB_Device_Disconnect(void)
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
/* Setup Sideshow In and Out Endpoints */ /* Setup Sideshow Data Endpoints */
if (!(Endpoint_ConfigureEndpoint(SIDESHOW_IN_EPNUM, EP_TYPE_BULK, ConfigSuccess &= Endpoint_ConfigureEndpoint(SIDESHOW_IN_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, SIDESHOW_IO_EPSIZE, SIDESHOW_IO_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE))) ConfigSuccess &= Endpoint_ConfigureEndpoint(SIDESHOW_OUT_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_OUT,
{ SIDESHOW_IO_EPSIZE, ENDPOINT_BANK_SINGLE);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
if (!(Endpoint_ConfigureEndpoint(SIDESHOW_OUT_EPNUM, EP_TYPE_BULK, /* Indicate endpoint configuration success or failure */
ENDPOINT_DIR_OUT, SIDESHOW_IO_EPSIZE, LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
} }
void EVENT_USB_Device_UnhandledControlRequest(void) void EVENT_USB_Device_UnhandledControlRequest(void)

@ -118,29 +118,18 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
/* Setup TMC In, Out and Notification Endpoints */ /* Setup TMC In, Out and Notification Endpoints */
if (!(Endpoint_ConfigureEndpoint(TMC_IN_EPNUM, EP_TYPE_BULK, ConfigSuccess &= Endpoint_ConfigureEndpoint(TMC_IN_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, TMC_IO_EPSIZE, TMC_IO_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE))) ConfigSuccess &= Endpoint_ConfigureEndpoint(TMC_OUT_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_OUT,
{ TMC_IO_EPSIZE, ENDPOINT_BANK_SINGLE);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); ConfigSuccess &= Endpoint_ConfigureEndpoint(TMC_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
} TMC_IO_EPSIZE, ENDPOINT_BANK_SINGLE);
if (!(Endpoint_ConfigureEndpoint(TMC_OUT_EPNUM, EP_TYPE_BULK, /* Indicate endpoint configuration success or failure */
ENDPOINT_DIR_OUT, TMC_IO_EPSIZE, LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
if (!(Endpoint_ConfigureEndpoint(TMC_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT,
ENDPOINT_DIR_IN, TMC_NOTIFICATION_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
} }
/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific

@ -110,16 +110,14 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup audio stream endpoint */ /* Setup Audio Stream Endpoint */
if (!(Endpoint_ConfigureEndpoint(AUDIO_STREAM_EPNUM, EP_TYPE_ISOCHRONOUS, ConfigSuccess &= Endpoint_ConfigureEndpoint(AUDIO_STREAM_EPNUM, EP_TYPE_ISOCHRONOUS, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, AUDIO_STREAM_EPSIZE, AUDIO_STREAM_EPSIZE, ENDPOINT_BANK_DOUBLE);
ENDPOINT_BANK_DOUBLE)))
{ /* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
}
} }
/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific

@ -137,16 +137,14 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup audio stream endpoint */ /* Setup Audio Stream Endpoint */
if (!(Endpoint_ConfigureEndpoint(AUDIO_STREAM_EPNUM, EP_TYPE_ISOCHRONOUS, ConfigSuccess &= Endpoint_ConfigureEndpoint(AUDIO_STREAM_EPNUM, EP_TYPE_ISOCHRONOUS, ENDPOINT_DIR_OUT,
ENDPOINT_DIR_OUT, AUDIO_STREAM_EPSIZE, AUDIO_STREAM_EPSIZE, ENDPOINT_BANK_DOUBLE);
ENDPOINT_BANK_DOUBLE)))
{ /* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
}
} }
/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific

@ -119,57 +119,31 @@ void EVENT_USB_Device_Disconnect(void)
* of the USB device after enumeration - the device endpoints are configured and the CDC management tasks are started. * of the USB device after enumeration - the device endpoints are configured and the CDC management tasks are started.
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup first CDC Interface's Endpoints */
/* Setup CDC Notification, Rx and Tx Endpoints for the first CDC */ ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC1_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
if (!(Endpoint_ConfigureEndpoint(CDC1_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT, CDC_NOTIFICATION_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_DIR_IN, CDC_NOTIFICATION_EPSIZE, ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC1_TX_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_IN,
ENDPOINT_BANK_SINGLE))) CDC_TXRX_EPSIZE, ENDPOINT_BANK_SINGLE);
{ ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC1_RX_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_OUT,
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); CDC_TXRX_EPSIZE, ENDPOINT_BANK_SINGLE);
}
/* Setup second CDC Interface's Endpoints */
if (!(Endpoint_ConfigureEndpoint(CDC1_TX_EPNUM, EP_TYPE_BULK, ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC2_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, CDC_TXRX_EPSIZE, CDC_NOTIFICATION_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE))) ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC2_TX_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_IN,
{ CDC_TXRX_EPSIZE, ENDPOINT_BANK_SINGLE);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC2_RX_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_OUT,
} CDC_TXRX_EPSIZE, ENDPOINT_BANK_SINGLE);
if (!(Endpoint_ConfigureEndpoint(CDC1_RX_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_OUT, CDC_TXRX_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
/* Setup CDC Notification, Rx and Tx Endpoints for the second CDC */
if (!(Endpoint_ConfigureEndpoint(CDC2_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT,
ENDPOINT_DIR_IN, CDC_NOTIFICATION_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
if (!(Endpoint_ConfigureEndpoint(CDC2_TX_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_IN, CDC_TXRX_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
if (!(Endpoint_ConfigureEndpoint(CDC2_RX_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_OUT, CDC_TXRX_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
/* Reset line encoding baud rates so that the host knows to send new values */ /* Reset line encoding baud rates so that the host knows to send new values */
LineEncoding1.BaudRateBPS = 0; LineEncoding1.BaudRateBPS = 0;
LineEncoding2.BaudRateBPS = 0; LineEncoding2.BaudRateBPS = 0;
/* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific

@ -95,24 +95,16 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup Generic IN Report Endpoint */ /* Setup HID Report Endpoints */
if (!(Endpoint_ConfigureEndpoint(GENERIC_IN_EPNUM, EP_TYPE_INTERRUPT, ConfigSuccess &= Endpoint_ConfigureEndpoint(GENERIC_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, GENERIC_EPSIZE, GENERIC_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE))) ConfigSuccess &= Endpoint_ConfigureEndpoint(GENERIC_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
{ GENERIC_EPSIZE, ENDPOINT_BANK_SINGLE);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
} /* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
/* Setup Generic OUT Report Endpoint */
if (!(Endpoint_ConfigureEndpoint(GENERIC_OUT_EPNUM, EP_TYPE_INTERRUPT,
ENDPOINT_DIR_OUT, GENERIC_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
} }
/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific

@ -93,16 +93,14 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup Joystick Report Endpoint */ /* Setup HID Report Endpoint */
if (!(Endpoint_ConfigureEndpoint(JOYSTICK_EPNUM, EP_TYPE_INTERRUPT, ConfigSuccess &= Endpoint_ConfigureEndpoint(JOYSTICK_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, JOYSTICK_EPSIZE, JOYSTICK_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE)))
{ /* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
}
} }
/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific

@ -160,7 +160,7 @@ USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
{ {
.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
.EndpointAddress = (ENDPOINT_DESCRIPTOR_DIR_IN | KEYBOARD_EPNUM), .EndpointAddress = (ENDPOINT_DESCRIPTOR_DIR_IN | KEYBOARD_IN_EPNUM),
.Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
.EndpointSize = KEYBOARD_EPSIZE, .EndpointSize = KEYBOARD_EPSIZE,
.PollingIntervalMS = 0x0A .PollingIntervalMS = 0x0A
@ -170,7 +170,7 @@ USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
{ {
.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
.EndpointAddress = (ENDPOINT_DESCRIPTOR_DIR_OUT | KEYBOARD_LEDS_EPNUM), .EndpointAddress = (ENDPOINT_DESCRIPTOR_DIR_OUT | KEYBOARD_OUT_EPNUM),
.Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
.EndpointSize = KEYBOARD_EPSIZE, .EndpointSize = KEYBOARD_EPSIZE,
.PollingIntervalMS = 0x0A .PollingIntervalMS = 0x0A

@ -77,13 +77,13 @@
/* Macros: */ /* Macros: */
/** Endpoint number of the Keyboard HID reporting IN endpoint. */ /** Endpoint number of the Keyboard HID reporting IN endpoint. */
#define KEYBOARD_EPNUM 1 #define KEYBOARD_IN_EPNUM 1
/** Endpoint number of the Keyboard HID reporting OUT endpoint. */ /** Endpoint number of the Keyboard HID reporting OUT endpoint. */
#define KEYBOARD_LEDS_EPNUM 2 #define KEYBOARD_OUT_EPNUM 2
/** Size in bytes of the Keyboard HID reporting IN and OUT endpoints. */ /** Size in bytes of the Keyboard HID reporting IN and OUT endpoints. */
#define KEYBOARD_EPSIZE 8 #define KEYBOARD_EPSIZE 8
/** Descriptor header type value, to indicate a HID class HID descriptor. */ /** Descriptor header type value, to indicate a HID class HID descriptor. */
#define DTYPE_HID 0x21 #define DTYPE_HID 0x21

@ -114,26 +114,19 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup Keyboard Keycode Report Endpoint */ /* Setup HID Report Endpoints */
if (!(Endpoint_ConfigureEndpoint(KEYBOARD_EPNUM, EP_TYPE_INTERRUPT, ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, KEYBOARD_EPSIZE, KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE))) ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
{ KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
} /* Turn on Start-of-Frame events for tracking HID report period exiry */
/* Setup Keyboard LED Report Endpoint */
if (!(Endpoint_ConfigureEndpoint(KEYBOARD_LEDS_EPNUM, EP_TYPE_INTERRUPT,
ENDPOINT_DIR_OUT, KEYBOARD_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
USB_Device_EnableSOFEvents(); USB_Device_EnableSOFEvents();
/* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific
@ -332,7 +325,7 @@ void SendNextReport(void)
} }
/* Select the Keyboard Report Endpoint */ /* Select the Keyboard Report Endpoint */
Endpoint_SelectEndpoint(KEYBOARD_EPNUM); Endpoint_SelectEndpoint(KEYBOARD_IN_EPNUM);
/* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */ /* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */
if (Endpoint_IsReadWriteAllowed() && SendReport) if (Endpoint_IsReadWriteAllowed() && SendReport)
@ -352,7 +345,7 @@ void SendNextReport(void)
void ReceiveNextReport(void) void ReceiveNextReport(void)
{ {
/* Select the Keyboard LED Report Endpoint */ /* Select the Keyboard LED Report Endpoint */
Endpoint_SelectEndpoint(KEYBOARD_LEDS_EPNUM); Endpoint_SelectEndpoint(KEYBOARD_OUT_EPNUM);
/* Check if Keyboard LED Endpoint contains a packet */ /* Check if Keyboard LED Endpoint contains a packet */
if (Endpoint_IsOUTReceived()) if (Endpoint_IsOUTReceived())

@ -101,32 +101,20 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup Keyboard Report Endpoint */ /* Setup Keyboard HID Report Endpoints */
if (!(Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, HID_EPSIZE, HID_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE))) ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
{ HID_EPSIZE, ENDPOINT_BANK_SINGLE);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
/* Setup Keyboard LED Report Endpoint */
if (!(Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPNUM, EP_TYPE_INTERRUPT,
ENDPOINT_DIR_OUT, HID_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
/* Setup Mouse Report Endpoint */ /* Setup Mouse HID Report Endpoint */
if (!(Endpoint_ConfigureEndpoint(MOUSE_IN_EPNUM, EP_TYPE_INTERRUPT, ConfigSuccess &= Endpoint_ConfigureEndpoint(MOUSE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, HID_EPSIZE, HID_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE)))
{ /* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
}
} }
/** Event handler for the USB_UnhandledControlPacket event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlPacket event. This is used to catch standard and class specific

@ -91,23 +91,16 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup MIDI stream endpoints */ /* Setup MIDI Data Endpoints */
if (!(Endpoint_ConfigureEndpoint(MIDI_STREAM_OUT_EPNUM, EP_TYPE_BULK, ConfigSuccess &= Endpoint_ConfigureEndpoint(MIDI_STREAM_OUT_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_OUT,
ENDPOINT_DIR_OUT, MIDI_STREAM_EPSIZE, MIDI_STREAM_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE))) ConfigSuccess &= Endpoint_ConfigureEndpoint(MIDI_STREAM_IN_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_IN,
{ MIDI_STREAM_EPSIZE, ENDPOINT_BANK_SINGLE);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
} /* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
if (!(Endpoint_ConfigureEndpoint(MIDI_STREAM_IN_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_IN, MIDI_STREAM_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
} }
/** Task to handle the generation of MIDI note change events in response to presses of the board joystick, and send them /** Task to handle the generation of MIDI note change events in response to presses of the board joystick, and send them

@ -108,23 +108,16 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup Mass Storage In and Out Endpoints */ /* Setup Mass Storage Data Endpoints */
if (!(Endpoint_ConfigureEndpoint(MASS_STORAGE_IN_EPNUM, EP_TYPE_BULK, ConfigSuccess &= Endpoint_ConfigureEndpoint(MASS_STORAGE_IN_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, MASS_STORAGE_IO_EPSIZE, MASS_STORAGE_IO_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE))) ConfigSuccess &= Endpoint_ConfigureEndpoint(MASS_STORAGE_OUT_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_OUT,
{ MASS_STORAGE_IO_EPSIZE, ENDPOINT_BANK_SINGLE);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
} /* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
if (!(Endpoint_ConfigureEndpoint(MASS_STORAGE_OUT_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_OUT, MASS_STORAGE_IO_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
} }
/** Event handler for the USB_UnhandledControlPacket event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlPacket event. This is used to catch standard and class specific

@ -113,18 +113,17 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup Mouse Report Endpoint */
if (!(Endpoint_ConfigureEndpoint(MOUSE_EPNUM, EP_TYPE_INTERRUPT,
ENDPOINT_DIR_IN, MOUSE_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
/* Setup HID Report Endpoint */
ConfigSuccess &= Endpoint_ConfigureEndpoint(MOUSE_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
MOUSE_EPSIZE, ENDPOINT_BANK_SINGLE);
/* Turn on Start-of-Frame events for tracking HID report period exiry */
USB_Device_EnableSOFEvents(); USB_Device_EnableSOFEvents();
/* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific

@ -98,30 +98,18 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup RNDIS Data Endpoints */
/* Setup CDC Notification, Rx and Tx Endpoints */ ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_TX_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_IN,
if (!(Endpoint_ConfigureEndpoint(CDC_TX_EPNUM, EP_TYPE_BULK, CDC_TXRX_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_DIR_IN, CDC_TXRX_EPSIZE, ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_RX_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_OUT,
ENDPOINT_BANK_SINGLE))) CDC_TXRX_EPSIZE, ENDPOINT_BANK_SINGLE);
{ ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
LEDs_SetAllLEDs(LEDMASK_USB_ERROR); CDC_NOTIFICATION_EPSIZE, ENDPOINT_BANK_SINGLE);
}
/* Indicate endpoint configuration success or failure */
if (!(Endpoint_ConfigureEndpoint(CDC_RX_EPNUM, EP_TYPE_BULK, LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
ENDPOINT_DIR_OUT, CDC_TXRX_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
if (!(Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT,
ENDPOINT_DIR_IN, CDC_NOTIFICATION_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
} }
/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific

@ -105,33 +105,21 @@ void EVENT_USB_Device_Disconnect(void)
*/ */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup CDC Data Endpoints */
ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
CDC_NOTIFICATION_EPSIZE, ENDPOINT_BANK_SINGLE);
ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_TX_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_IN,
CDC_TXRX_EPSIZE, ENDPOINT_BANK_SINGLE);
ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_RX_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_OUT,
CDC_TXRX_EPSIZE, ENDPOINT_BANK_SINGLE);
/* Setup CDC Notification, Rx and Tx Endpoints */
if (!(Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT,
ENDPOINT_DIR_IN, CDC_NOTIFICATION_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
if (!(Endpoint_ConfigureEndpoint(CDC_TX_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_IN, CDC_TXRX_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
if (!(Endpoint_ConfigureEndpoint(CDC_RX_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_OUT, CDC_TXRX_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
/* Reset line encoding baud rate so that the host knows to send new values */ /* Reset line encoding baud rate so that the host knows to send new values */
LineEncoding.BaudRateBPS = 0; LineEncoding.BaudRateBPS = 0;
/* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific

@ -40,11 +40,6 @@
uint8_t USB_ControlEndpointSize = ENDPOINT_CONTROLEP_DEFAULT_SIZE; uint8_t USB_ControlEndpointSize = ENDPOINT_CONTROLEP_DEFAULT_SIZE;
#endif #endif
uint8_t Endpoint_BytesToEPSizeMaskDynamic(const uint16_t Size)
{
return Endpoint_BytesToEPSizeMask(Size);
}
bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number, bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number,
const uint8_t UECFG0XData, const uint8_t UECFG0XData,
const uint8_t UECFG1XData) const uint8_t UECFG1XData)

@ -98,7 +98,65 @@
#if !defined(__INCLUDE_FROM_USB_DRIVER) #if !defined(__INCLUDE_FROM_USB_DRIVER)
#error Do not include this file directly. Include LUFA/Drivers/USB/USB.h instead. #error Do not include this file directly. Include LUFA/Drivers/USB/USB.h instead.
#endif #endif
#if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)
#define __CALLBACK_PARAM , StreamCallbackPtr_t Callback
#else
#define __CALLBACK_PARAM
#endif
/* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__)
/* Macros: */
#define _ENDPOINT_GET_MAXSIZE(EPIndex) _ENDPOINT_GET_MAXSIZE2(ENDPOINT_DETAILS_EP ## EPIndex)
#define _ENDPOINT_GET_MAXSIZE2(EPDetails) _ENDPOINT_GET_MAXSIZE3(EPDetails)
#define _ENDPOINT_GET_MAXSIZE3(MaxSize, DB) (MaxSize)
#define _ENDPOINT_GET_DOUBLEBANK(EPIndex) _ENDPOINT_GET_DOUBLEBANK2(ENDPOINT_DETAILS_EP ## EPIndex)
#define _ENDPOINT_GET_DOUBLEBANK2(EPDetails) _ENDPOINT_GET_DOUBLEBANK3(EPDetails)
#define _ENDPOINT_GET_DOUBLEBANK3(MaxSize, DB) (DB)
#if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
#define ENDPOINT_DETAILS_EP0 64, true
#define ENDPOINT_DETAILS_EP1 256, true
#define ENDPOINT_DETAILS_EP2 64, true
#define ENDPOINT_DETAILS_EP3 64, true
#define ENDPOINT_DETAILS_EP4 64, true
#define ENDPOINT_DETAILS_EP5 64, true
#define ENDPOINT_DETAILS_EP6 64, true
#else
#define ENDPOINT_DETAILS_EP0 64, true
#define ENDPOINT_DETAILS_EP1 64, false
#define ENDPOINT_DETAILS_EP2 64, false
#define ENDPOINT_DETAILS_EP3 64, true
#define ENDPOINT_DETAILS_EP4 64, true
#endif
/* Inline Functions: */
static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST
ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes)
{
uint8_t MaskVal = 0;
uint16_t CheckBytes = 8;
while (CheckBytes < Bytes)
{
MaskVal++;
CheckBytes <<= 1;
}
return (MaskVal << EPSIZE0);
}
/* Function Prototypes: */
void Endpoint_ClearEndpoints(void);
bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number,
const uint8_t UECFG0XData,
const uint8_t UECFG1XData);
#endif
/* Public Interface - May be used in end-application: */ /* Public Interface - May be used in end-application: */
/* Macros: */ /* Macros: */
/** Endpoint data direction mask for \ref Endpoint_ConfigureEndpoint(). This indicates that the endpoint /** Endpoint data direction mask for \ref Endpoint_ConfigureEndpoint(). This indicates that the endpoint
@ -245,7 +303,45 @@
*/ */
}; };
/* Inline Functions: */ /* Inline Functions: */
/** Configures the specified endpoint number with the given endpoint type, direction, bank size
* and banking mode. Endpoints should be allocated in ascending order by their address in the
* device (i.e. endpoint 1 should be configured before endpoint 2 and so on) to prevent fragmentation
* of the USB FIFO memory.
*
* The endpoint type may be one of the EP_TYPE_* macros listed in LowLevel.h and the direction
* may be either \ref ENDPOINT_DIR_OUT or \ref ENDPOINT_DIR_IN.
*
* The bank size must indicate the maximum packet size that the endpoint can handle. Different
* endpoint numbers can handle different maximum packet sizes - refer to the chosen USB AVR's
* datasheet to determine the maximum bank size for each endpoint.
*
* The banking mode may be either \ref ENDPOINT_BANK_SINGLE or \ref ENDPOINT_BANK_DOUBLE.
*
* \note The default control endpoint should not be manually configured by the user application, as
* it is automatically configured by the library internally.
* \n\n
*
* \note This routine will select the specified endpoint, and the endpoint will remain selected
* once the routine completes regardless of if the endpoint configuration succeeds.
*
* \return Boolean true if the configuration succeeded, false otherwise.
*/
static inline bool Endpoint_ConfigureEndpoint(const uint8_t Number,
const uint8_t Type,
const uint8_t Direction,
const uint16_t Size,
const uint8_t Banks) ATTR_ALWAYS_INLINE;
static inline bool Endpoint_ConfigureEndpoint(const uint8_t Number,
const uint8_t Type,
const uint8_t Direction,
const uint16_t Size,
const uint8_t Banks)
{
return Endpoint_ConfigureEndpoint_Prv(Number, (((Type) << EPTYPE0) | (Direction)),
((1 << ALLOC) | Banks | Endpoint_BytesToEPSizeMask(Size)));
}
/** Indicates the number of bytes currently stored in the current endpoint's selected bank. /** Indicates the number of bytes currently stored in the current endpoint's selected bank.
* *
* \note The return width of this function may differ, depending on the maximum endpoint bank size * \note The return width of this function may differ, depending on the maximum endpoint bank size
@ -777,41 +873,6 @@
#endif #endif
/* Function Prototypes: */ /* Function Prototypes: */
#if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)
#define __CALLBACK_PARAM , StreamCallbackPtr_t Callback
#else
#define __CALLBACK_PARAM
#endif
/** Configures the specified endpoint number with the given endpoint type, direction, bank size
* and banking mode. Endpoints should be allocated in ascending order by their address in the
* device (i.e. endpoint 1 should be configured before endpoint 2 and so on) to prevent fragmentation
* of the USB FIFO memory.
*
* The endpoint type may be one of the EP_TYPE_* macros listed in LowLevel.h and the direction
* may be either \ref ENDPOINT_DIR_OUT or \ref ENDPOINT_DIR_IN.
*
* The bank size must indicate the maximum packet size that the endpoint can handle. Different
* endpoint numbers can handle different maximum packet sizes - refer to the chosen USB AVR's
* datasheet to determine the maximum bank size for each endpoint.
*
* The banking mode may be either \ref ENDPOINT_BANK_SINGLE or \ref ENDPOINT_BANK_DOUBLE.
*
* \note The default control endpoint should not be manually configured by the user application, as
* it is automatically configured by the library internally.
* \n\n
*
* \note This routine will select the specified endpoint, and the endpoint will remain selected
* once the routine completes regardless of if the endpoint configuration succeeds.
*
* \return Boolean true if the configuration succeeded, false otherwise.
*/
bool Endpoint_ConfigureEndpoint(const uint8_t Number,
const uint8_t Type,
const uint8_t Direction,
const uint16_t Size,
const uint8_t Banks);
/** Spin-loops until the currently selected non-control endpoint is ready for the next packet of data /** Spin-loops until the currently selected non-control endpoint is ready for the next packet of data
* to be read or written to it. * to be read or written to it.
* *
@ -1266,87 +1327,6 @@
uint8_t Endpoint_Read_Control_EStream_BE(void* Buffer, uint8_t Endpoint_Read_Control_EStream_BE(void* Buffer,
uint16_t Length) ATTR_NON_NULL_PTR_ARG(1); uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);
/* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__)
/* Macros: */
#define _ENDPOINT_GET_MAXSIZE(n) _ENDPOINT_GET_MAXSIZE2(ENDPOINT_DETAILS_EP ## n)
#define _ENDPOINT_GET_MAXSIZE2(details) _ENDPOINT_GET_MAXSIZE3(details)
#define _ENDPOINT_GET_MAXSIZE3(maxsize, db) maxsize
#define _ENDPOINT_GET_DOUBLEBANK(n) _ENDPOINT_GET_DOUBLEBANK2(ENDPOINT_DETAILS_EP ## n)
#define _ENDPOINT_GET_DOUBLEBANK2(details) _ENDPOINT_GET_DOUBLEBANK3(details)
#define _ENDPOINT_GET_DOUBLEBANK3(maxsize, db) db
#if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
#define ENDPOINT_DETAILS_EP0 64, true
#define ENDPOINT_DETAILS_EP1 256, true
#define ENDPOINT_DETAILS_EP2 64, true
#define ENDPOINT_DETAILS_EP3 64, true
#define ENDPOINT_DETAILS_EP4 64, true
#define ENDPOINT_DETAILS_EP5 64, true
#define ENDPOINT_DETAILS_EP6 64, true
#else
#define ENDPOINT_DETAILS_EP0 64, true
#define ENDPOINT_DETAILS_EP1 64, false
#define ENDPOINT_DETAILS_EP2 64, false
#define ENDPOINT_DETAILS_EP3 64, true
#define ENDPOINT_DETAILS_EP4 64, true
#endif
#define Endpoint_ConfigureEndpoint(Number, Type, Direction, Size, Banks) \
(__builtin_constant_p(Size) ? Endpoint_ConfigureEndpointStatic((Number), \
(Type), \
(Direction), \
Size, Banks) : \
Endpoint_ConfigureEndpointDynamic((Number), \
(Type), \
(Direction), \
Size, Banks))
/* Function Prototypes: */
void Endpoint_ClearEndpoints(void);
uint8_t Endpoint_BytesToEPSizeMaskDynamic(const uint16_t Size);
bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number,
const uint8_t UECFG0XData,
const uint8_t UECFG1XData);
/* Inline Functions: */
static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes)
{
uint8_t MaskVal = 0;
uint16_t CheckBytes = 8;
while (CheckBytes < Bytes)
{
MaskVal++;
CheckBytes <<= 1;
}
return (MaskVal << EPSIZE0);
}
static inline bool Endpoint_ConfigureEndpointStatic(const uint8_t Number,
const uint8_t Type,
const uint8_t Direction,
const uint16_t Size,
const uint8_t Banks)
{
return Endpoint_ConfigureEndpoint_Prv(Number, (((Type) << EPTYPE0) | (Direction)),
((1 << ALLOC) | Banks | Endpoint_BytesToEPSizeMask(Size)));
}
static inline bool Endpoint_ConfigureEndpointDynamic(const uint8_t Number,
const uint8_t Type,
const uint8_t Direction,
const uint16_t Size,
const uint8_t Banks)
{
return Endpoint_ConfigureEndpoint_Prv(Number, (((Type) << EPTYPE0) | (Direction)),
((1 << ALLOC) | Banks | Endpoint_BytesToEPSizeMaskDynamic(Size)));
}
#endif
/* Disable C linkage for C++ Compilers: */ /* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus) #if defined(__cplusplus)
} }

@ -106,13 +106,11 @@
#error Do not include this file directly. Include LUFA/Drivers/USB/USB.h instead. #error Do not include this file directly. Include LUFA/Drivers/USB/USB.h instead.
#endif #endif
/* Private Interface - For use in library only: */ #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)
#if !defined(__DOXYGEN__) #define __CALLBACK_PARAM , StreamCallbackPtr_t Callback
/* Macros: */ #else
#if !defined(ENDPOINT_CONTROLEP) && !defined(__DOXYGEN__) #define __CALLBACK_PARAM
#define ENDPOINT_CONTROLEP 0 #endif
#endif
#endif
/* Public Interface - May be used in end-application: */ /* Public Interface - May be used in end-application: */
/* Macros: */ /* Macros: */
@ -848,12 +846,6 @@
extern uint8_t USB_ControlPipeSize; extern uint8_t USB_ControlPipeSize;
/* Function Prototypes: */ /* Function Prototypes: */
#if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)
#define __CALLBACK_PARAM , StreamCallbackPtr_t Callback
#else
#define __CALLBACK_PARAM
#endif
/** Configures the specified pipe number with the given pipe type, token, target endpoint number in the /** Configures the specified pipe number with the given pipe type, token, target endpoint number in the
* attached device, bank size and banking mode. Pipes should be allocated in ascending order by their * attached device, bank size and banking mode. Pipes should be allocated in ascending order by their
* address in the device (i.e. pipe 1 should be configured before pipe 2 and so on) to prevent fragmentation * address in the device (i.e. pipe 1 should be configured before pipe 2 and so on) to prevent fragmentation
@ -1121,10 +1113,12 @@
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/* Private Interface - For use in library only: */ /* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__) #if !defined(__DOXYGEN__)
/* Function Prototypes: */ /* Macros: */
void Pipe_ClearPipes(void); #if !defined(ENDPOINT_CONTROLEP)
#define ENDPOINT_CONTROLEP 0
#endif
/* Inline Functions: */ /* Inline Functions: */
static inline uint8_t Pipe_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST ATTR_ALWAYS_INLINE; static inline uint8_t Pipe_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST ATTR_ALWAYS_INLINE;
static inline uint8_t Pipe_BytesToEPSizeMask(const uint16_t Bytes) static inline uint8_t Pipe_BytesToEPSizeMask(const uint16_t Bytes)
@ -1141,6 +1135,8 @@
return (MaskVal << EPSIZE0); return (MaskVal << EPSIZE0);
} }
/* Function Prototypes: */
void Pipe_ClearPipes(void);
#endif #endif
/* Disable C linkage for C++ Compilers: */ /* Disable C linkage for C++ Compilers: */

@ -7,7 +7,11 @@
/** \page Page_ChangeLog Project Changelog /** \page Page_ChangeLog Project Changelog
* *
* \section Sec_ChangeLogXXXXXX Version XXXXXX * \section Sec_ChangeLogXXXXXX Version XXXXXX
* There is currently no changelog information for this release. * <b>Changed:</b>
* - Removed complicated logic for the Endpoint_ConfigureEndpoint() function to use inlined or function called versions
* depending of if the given bank size is a compile time constant, as the compiler does a better job of optimizing
* with basic code
* - Changed over all device demos to use a clearer algorithm for the configuring of the application's endpoints
* *
* \section Sec_ChangeLog100807 Version 100807 * \section Sec_ChangeLog100807 Version 100807
* <b>New:</b> * <b>New:</b>

@ -90,25 +90,19 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
/* Indicate USB connected and ready */ bool ConfigSuccess = true;
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup AVRISP data Endpoints */ /* Setup AVRISP Data Endpoint(s) */
if (!(Endpoint_ConfigureEndpoint(AVRISP_DATA_OUT_EPNUM, EP_TYPE_BULK, ConfigSuccess &= Endpoint_ConfigureEndpoint(AVRISP_DATA_OUT_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_OUT,
ENDPOINT_DIR_OUT, AVRISP_DATA_EPSIZE, AVRISP_DATA_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
#if defined(LIBUSB_DRIVER_COMPAT) #if defined(LIBUSB_DRIVER_COMPAT)
if (!(Endpoint_ConfigureEndpoint(AVRISP_DATA_IN_EPNUM, EP_TYPE_BULK, ConfigSuccess &= Endpoint_ConfigureEndpoint(AVRISP_DATA_IN_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, AVRISP_DATA_EPSIZE, AVRISP_DATA_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
#endif #endif
/* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Processes incoming V2 Protocol commands from the host, returning a response when required. */ /** Processes incoming V2 Protocol commands from the host, returning a response when required. */

@ -190,11 +190,13 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
bool ConfigSuccess = true;
ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
PulseMSRemaining.PingPongLEDPulse = 0; PulseMSRemaining.PingPongLEDPulse = 0;
LEDs_SetAllLEDs(LEDS_NO_LEDS);
if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface))) LEDs_SetAllLEDs(ConfigSuccess ? LEDS_NO_LEDS : LEDMASK_ERROR);
LEDs_SetAllLEDs(LEDMASK_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -173,10 +173,11 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(MIDI_Device_ConfigureEndpoints(&Keyboard_MIDI_Interface))) ConfigSuccess &= MIDI_Device_ConfigureEndpoints(&Keyboard_MIDI_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -73,10 +73,11 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
ConfigSuccess &= MS_Device_ConfigureEndpoints(&DiskDevice_MS_Interface);
if (!(MS_Device_ConfigureEndpoints(&DiskDevice_MS_Interface))) LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -145,7 +145,7 @@ void ReadMagstripeData(void)
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
HID_Device_ConfigureEndpoints(&Keyboard_HID_Interface); HID_Device_ConfigureEndpoints(&Keyboard_HID_Interface);
USB_Device_EnableSOFEvents(); USB_Device_EnableSOFEvents();
} }

@ -237,13 +237,12 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
ConfigSuccess &= MS_Device_ConfigureEndpoints(&Disk_MS_Interface);
ConfigSuccess &= HID_Device_ConfigureEndpoints(&Generic_HID_Interface);
if (!(MS_Device_ConfigureEndpoints(&Disk_MS_Interface))) LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
if (!(HID_Device_ConfigureEndpoints(&Generic_HID_Interface)))
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -139,10 +139,11 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface))) ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -85,10 +85,11 @@ void EVENT_USB_Device_Disconnect(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
LEDs_SetAllLEDs(LEDMASK_USB_READY); bool ConfigSuccess = true;
ConfigSuccess &= MS_Device_ConfigureEndpoints(&Disk_MS_Interface);
if (!(MS_Device_ConfigureEndpoints(&Disk_MS_Interface))) LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

@ -172,12 +172,12 @@ void SetupHardware(void)
/** Event handler for the library USB Configuration Changed event. */ /** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void) void EVENT_USB_Device_ConfigurationChanged(void)
{ {
bool EndpointConfigSuccess = true; bool ConfigSuccess = true;
/* Configure the device endpoints according to the selected mode */ /* Configure the device endpoints according to the selected mode */
if (CurrentFirmwareMode == MODE_USART_BRIDGE) if (CurrentFirmwareMode == MODE_USART_BRIDGE)
{ {
EndpointConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface); ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
/* Configure the UART flush timer - run at Fcpu/1024 for maximum interval before overflow */ /* Configure the UART flush timer - run at Fcpu/1024 for maximum interval before overflow */
TCCR0B = ((1 << CS02) | (1 << CS00)); TCCR0B = ((1 << CS02) | (1 << CS00));
@ -191,24 +191,19 @@ void EVENT_USB_Device_ConfigurationChanged(void)
} }
else else
{ {
EndpointConfigSuccess &= Endpoint_ConfigureEndpoint(AVRISP_DATA_OUT_EPNUM, EP_TYPE_BULK, ConfigSuccess &= Endpoint_ConfigureEndpoint(AVRISP_DATA_OUT_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_OUT,
ENDPOINT_DIR_OUT, AVRISP_DATA_EPSIZE, AVRISP_DATA_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE);
#if defined(LIBUSB_DRIVER_COMPAT) #if defined(LIBUSB_DRIVER_COMPAT)
EndpointConfigSuccess &= Endpoint_ConfigureEndpoint(AVRISP_DATA_IN_EPNUM, EP_TYPE_BULK, ConfigSuccess &= Endpoint_ConfigureEndpoint(AVRISP_DATA_IN_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_IN,
ENDPOINT_DIR_IN, AVRISP_DATA_EPSIZE, AVRISP_DATA_EPSIZE, ENDPOINT_BANK_SINGLE);
ENDPOINT_BANK_SINGLE);
#endif #endif
/* Configure the V2 protocol packet handler */ /* Configure the V2 protocol packet handler */
V2Protocol_Init(); V2Protocol_Init();
} }
if (EndpointConfigSuccess) LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
LEDs_SetAllLEDs(LEDMASK_USB_READY);
else
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
} }
/** Event handler for the library USB Unhandled Control Request event. */ /** Event handler for the library USB Unhandled Control Request event. */

Loading…
Cancel
Save