Separate usb2 usb3 stacks

src/wch-ch56x-lib/USBDevice/usb20.h

@@ -40,6 +40,8 @@ limitations under the License.
 extern "C" {
 #endif
 
+extern usb_device_t* usb2_backend_current_device;
+
 // USB20 Data structures
 
 // PID according to WCH569 doc, does not correspond to USB packets PIDs
@@ -103,16 +105,10 @@ void usb2_ep0_passthrough_enabled(bool enable);
 /**
  * @brief Called by the USB abstraction layer when new data has been set for the
  * corresponding endpoint
+ * @param endp_num Endpoint number
  * @param size Size of the new data
  */
-void usb2_endp0_tx_ready(uint16_t size);
-void usb2_endp1_tx_ready(uint16_t size);
-void usb2_endp2_tx_ready(uint16_t size);
-void usb2_endp3_tx_ready(uint16_t size);
-void usb2_endp4_tx_ready(uint16_t size);
-void usb2_endp5_tx_ready(uint16_t size);
-void usb2_endp6_tx_ready(uint16_t size);
-void usb2_endp7_tx_ready(uint16_t size);
+void usb2_endp_tx_ready(uint8_t endp_num, uint16_t size);
 
 /**
  * @brief Called by the USB abstraction layer when the user sets a new state for

src/wch-ch56x-lib/USBDevice/usb30.h

@@ -119,7 +119,7 @@ extern "C" {
 #define UP_STREAM (2 << 16)
 #define TIE_BRK (1 << 20)
 
-#define UsbSetupBuf ((USB_SETUP*)endp0_buffer) // endpoint 0
+#define UsbSetupBuf ((USB_SETUP*)usb3_backend_current_device->endpoints.rx[0].buffer) // endpoint 0
 #define ENDP0_MAXPACK 512
 
 // status response
@@ -146,6 +146,8 @@ extern "C" {
 	  ENDPOINT_12_TX | ENDPOINT_12_RX | ENDPOINT_13_TX | ENDPOINT_13_RX | \
 	  ENDPOINT_14_TX | ENDPOINT_14_RX | ENDPOINT_15_TX | ENDPOINT_15_RX))
 
+extern usb_device_t* usb3_backend_current_device;
+
 /**
  * @brief Enable USB30 device but without downgrade to USB2
  * @param enable_usb2_fallback If enabled, the connection will activate USB2 if
@@ -180,13 +182,7 @@ void usb30_itp_callback(uint32_t ITPCounter);
  * corresponding endpoint
  * @param size Size of the new data
  */
-void usb3_endp1_tx_ready(uint16_t size);
-void usb3_endp2_tx_ready(uint16_t size);
-void usb3_endp3_tx_ready(uint16_t size);
-void usb3_endp4_tx_ready(uint16_t size);
-void usb3_endp5_tx_ready(uint16_t size);
-void usb3_endp6_tx_ready(uint16_t size);
-void usb3_endp7_tx_ready(uint16_t size);
+void usb3_endp_tx_ready(uint8_t endp_num, uint16_t size);
 
 #ifdef __cplusplus
 }

src/wch-ch56x-lib/USBDevice/usb_descriptors.h

@@ -129,21 +129,25 @@ typedef struct __PACKED _USB_BOS_SUPERSPEED_USB_DEVICE_CAPABILITY
 // all their child descriptors. note that USB_BOS_DESCR is expected to be
 // followed contiguously by all its subordinates note that each USB_STRING_DESCR
 // is expected to be followed by its payload
+
 typedef struct __PACKED
 {
 	const USB_DEV_DESCR* usb_device_descr;
 	const USB_DEV_QUAL_DESCR* usb_device_qualifier_descr;
 	const uint8_t** usb_device_config_descrs;
 	const USB_STRING_DESCR* const* usb_string_descrs;
-} USB2_DEVICE_DESCRIPTORS;
+	const USB_BOS_DESCR* usb_bos_descr;
+} USB_DEVICE_DESCRIPTORS;
 
 typedef struct __PACKED
 {
-	const USB_DEV_DESCR* usb_device_descr;
+	const USB_DEV_DESCR* usb2_device_descr;
+	const USB_DEV_DESCR* usb3_device_descr;
 	const USB_DEV_QUAL_DESCR* usb_device_qualifier_descr;
-	const uint8_t** usb_device_config_descrs;
+	const uint8_t** usb2_device_config_descrs;
+	const uint8_t** usb3_device_config_descrs;
 	const USB_STRING_DESCR* const* usb_string_descrs;
 	const USB_BOS_DESCR* usb_bos_descr;
-} USB3_DEVICE_DESCRIPTORS;
+} USB23_DEVICE_DESCRIPTORS;
 
 #endif

src/wch-ch56x-lib/USBDevice/usb_device.c

@@ -17,66 +17,155 @@ limitations under the License.
 
 #include "wch-ch56x-lib/USBDevice/usb_device.h"
 
-USB_DEVICE usb_device = { .usb2_speed = USB2_HIGHSPEED };
+uint16_t _default_endp0_user_handled_control_request(USB_SETUP* request,
+													 uint8_t** buffer);
+uint16_t _default_endp0_user_handled_control_request(USB_SETUP* request,
+													 uint8_t** buffer)
+{
+	return 0xffff;
+}
+uint8_t _default_endp0_passthrough_setup_callback(uint8_t* ptr, uint16_t size);
+uint8_t _default_endp0_passthrough_setup_callback(uint8_t* ptr, uint16_t size)
+{
+	return ENDP_STATE_ACK;
+}
+void _default_endp_tx_complete(TRANSACTION_STATUS status);
+void _default_endp_tx_complete(TRANSACTION_STATUS status) {}
+uint8_t _default_endp_rx_callback(uint8_t* const ptr, uint16_t size);
+uint8_t _default_endp_rx_callback(uint8_t* const ptr, uint16_t size)
+{
+	return ENDP_STATE_STALL;
+}
 
-void usb_device_set_addr(uint8_t addr)
+/**
+ * Setting up default handlers here : this prevents the device from crashing and avoid an unnecessary check for handlers that are user-defined.
+ */
+usb_device_t usb_device_0 = {
+	.speed = USB2_HIGHSPEED,
+	.endpoints = {
+		.endp0_user_handled_control_request =
+			_default_endp0_user_handled_control_request,
+		.endp0_passthrough_setup_callback =
+			_default_endp0_passthrough_setup_callback,
+		.tx_complete = { _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete },
+		.rx_callback = { _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback } }
+};
+
+usb_device_t usb_device_1 = {
+	.speed = USB2_HIGHSPEED,
+	.endpoints = {
+		.endp0_user_handled_control_request =
+			_default_endp0_user_handled_control_request,
+		.endp0_passthrough_setup_callback =
+			_default_endp0_passthrough_setup_callback,
+		.tx_complete = { _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete,
+						 _default_endp_tx_complete },
+		.rx_callback = { _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback,
+						 _default_endp_rx_callback } }
+};
+
+void usb_device_set_addr(usb_device_t* usb_device, uint8_t addr)
 {
 	if (addr <= 0x7f)
 	{
-		usb_device.addr = addr;
+		usb_device->addr = addr;
 	}
 }
 
-void usb2_device_set_device_descriptor(const USB_DEV_DESCR* descriptor)
+void usb_device_set_usb2_device_descriptor(usb_device_t* usb_device, const USB_DEV_DESCR* descriptor)
 {
-	usb_device.usb2_descriptors.usb_device_descr = descriptor;
+	usb_device->usb_descriptors.usb2_device_descr = descriptor;
 }
 
-void usb3_device_set_device_descriptor(const USB_DEV_DESCR* descriptor)
+void usb_device_set_usb3_device_descriptor(usb_device_t* usb_device, const USB_DEV_DESCR* descriptor)
 {
-	usb_device.usb3_descriptors.usb_device_descr = descriptor;
+	usb_device->usb_descriptors.usb3_device_descr = descriptor;
 }
 
-void usb2_device_set_device_qualifier_descriptor(
-	const USB_DEV_QUAL_DESCR* descriptor)
+void usb_device_set_device_qualifier_descriptor(usb_device_t* usb_device,
+												const USB_DEV_QUAL_DESCR* descriptor)
 {
-	usb_device.usb2_descriptors.usb_device_qualifier_descr = descriptor;
+	usb_device->usb_descriptors.usb_device_qualifier_descr = descriptor;
 }
 
-void usb3_device_set_device_qualifier_descriptor(
-	const USB_DEV_QUAL_DESCR* descriptor)
+void usb_device_set_usb2_config_descriptors(usb_device_t* usb_device, const USB_DEVICE_CONFIG** descriptors)
 {
-	usb_device.usb3_descriptors.usb_device_qualifier_descr = descriptor;
+	usb_device->usb_descriptors.usb2_device_config_descrs = descriptors;
 }
 
-void usb2_device_set_config_descriptors(const USB_DEVICE_CONFIG** descriptors)
+void usb_device_set_usb3_config_descriptors(usb_device_t* usb_device, const USB_DEVICE_CONFIG** descriptors)
 {
-	usb_device.usb2_descriptors.usb_device_config_descrs = descriptors;
+	usb_device->usb_descriptors.usb3_device_config_descrs = descriptors;
 }
 
-void usb3_device_set_config_descriptors(const USB_DEVICE_CONFIG** descriptors)
+void usb_device_set_bos_descriptor(usb_device_t* usb_device, const USB_BOS_DESCR* const descriptor)
 {
-	usb_device.usb3_descriptors.usb_device_config_descrs = descriptors;
+	usb_device->usb_descriptors.usb_bos_descr = descriptor;
 }
 
-void usb3_device_set_bos_descriptor(const USB_BOS_DESCR* const descriptor)
+void usb_device_set_string_descriptors(usb_device_t* usb_device,
+									   const USB_STRING_DESCR* const* const descriptors)
 {
-	usb_device.usb3_descriptors.usb_bos_descr = descriptor;
+	usb_device->usb_descriptors.usb_string_descrs = descriptors;
 }
 
-void usb2_device_set_string_descriptors(
-	const USB_STRING_DESCR* const* const descriptors)
+void usb_device_set_endpoint_mask(usb_device_t* usb_device, uint32_t endpoint_mask)
 {
-	usb_device.usb2_descriptors.usb_string_descrs = descriptors;
+	usb_device->endpoint_mask = endpoint_mask;
 }
 
-void usb3_device_set_string_descriptors(
-	const USB_STRING_DESCR* const* const descriptors)
+void endp_rx_set_state(usb_device_t* usb_device, uint8_t endp_num, uint8_t state)
 {
-	usb_device.usb3_descriptors.usb_string_descrs = descriptors;
+	volatile USB_ENDPOINT* ep = &usb_device->endpoints.rx[endp_num];
+
+	if (ep != NULL)
+	{
+		ep->state = state;
+		if (usb_device->speed == USB30_SUPERSPEED)
+			; // not implemented
+		// usb3_endpoints_backend_handled.usb3_endp_rx_set_state_callback(endp_num);
+		else
+			usb2_endpoints_backend_handled.usb2_endp_rx_set_state_callback(endp_num);
+	}
 }
 
-void usb_device_set_endpoint_mask(uint32_t endpoint_mask)
+void endp_tx_set_state(usb_device_t* usb_device, uint8_t endp_num, uint8_t state)
 {
-	usb_device.endpoint_mask = endpoint_mask;
+	volatile USB_ENDPOINT* ep = &usb_device->endpoints.tx[endp_num];
+
+	if (ep != NULL)
+	{
+		ep->state = state;
+		if (usb_device->speed == USB30_SUPERSPEED)
+			// not implemented
+			; // usb3_endpoints_backend_handled.usb3_endp_tx_set_state_callback(endp_num);
+		else
+			usb2_endpoints_backend_handled.usb2_endp_tx_set_state_callback(endp_num);
+	}
 }