gs_usb: CAN-FD support

Enable CAN-FD frame handling through the gs_usb (candlelight/SocketCAN)
interface, controlled by the host via GS_CAN_MODE_FD flag:

- Add GS_CAN_FLAG_FD/BRS/ESI frame flag defines per gs_usb protocol
- Advertise GS_CAN_FEATURE_FD in device capabilities
- Handle GS_CAN_MODE_FD in breq_set_mode to set enable_fdcan
- Update RAMN_GSUSB_ProcessRX to accept FD frames with FD/BRS/ESI flags
- Update RAMN_GSUSB_ProcessTX to set FD/BRS flags on TX echo frames
- Update RAMN_RxTask2Func TX path to decode FD/BRS/ESI flags from host
- Fix marshal/unmarshal to use FDCAN_ConvertToActual for data copy size
  (DLC codes 9-15 map to 12-64 bytes, not 9-15 bytes)
- Remove "CAN-FD is not supported" from ramn_config.h limitations

Author: BenGardiner

firmware/RAMNV1/Core/Inc/ramn_config.h

@@ -47,11 +47,15 @@
 
 // Enable this flag to enable the candlelight interface (gs_usb drivers)
 // Current implementation is experimental:
-// - CAN-FD is not supported
 // - Due to clock differences, bit timings are not respected (but equivalent baudrates are used)
 // Try increasing _Min_Stack_Size if you run into issues
 //#define ENABLE_GSUSB
 
+// Enable this flag to enable CAN-FD support in the gs_usb interface.
+// When enabled, FD frames (up to 64 bytes) with BRS and ESI flags are supported.
+// Requires ENABLE_GSUSB to be defined.
+//#define ENABLE_GSUSB_CANFD
+
 #ifndef ENABLE_GSUSB
 #define USBD_VID                        0x483
 #define USBD_PID                        0x5740
@@ -399,6 +403,10 @@
 #error Cannot activate GSUSB without enabling USB
 #endif
 
+#if defined(ENABLE_GSUSB_CANFD) && !defined(ENABLE_GSUSB)
+#error Cannot activate GSUSB_CANFD without enabling GSUSB
+#endif
+
 #if defined(ENABLE_USB) && !defined(ENABLE_CDC) && !defined(ENABLE_GSUSB)
 #error At least one USB interface must be active if you enable USB
 #endif

firmware/RAMNV1/Core/Src/main.c

@@ -2293,10 +2293,7 @@ void RAMN_RxTask2Func(void *argument)
 		else
 		{
 
-			// TODO implement CAN-FD
-
 			//recvFrame->echo_id
-			//recvFrame.flags
 			//recvFrame.reserved
 
 
@@ -2308,9 +2305,20 @@ void RAMN_RxTask2Func(void *argument)
 			if (recvFrame->can_id & CAN_EFF_FLAG) CANTxHeader.IdType = FDCAN_EXTENDED_ID;
 			else CANTxHeader.IdType = FDCAN_STANDARD_ID;
 
-			CANTxHeader.BitRateSwitch = FDCAN_BRS_OFF;
-			CANTxHeader.ErrorStateIndicator = FDCAN_ESI_ACTIVE;
-			CANTxHeader.FDFormat = FDCAN_CLASSIC_CAN;
+#ifdef ENABLE_GSUSB_CANFD
+			if (recvFrame->flags & GS_CAN_FLAG_FD)
+			{
+				CANTxHeader.FDFormat = FDCAN_FD_CAN;
+				CANTxHeader.BitRateSwitch = (recvFrame->flags & GS_CAN_FLAG_BRS) ? FDCAN_BRS_ON : FDCAN_BRS_OFF;
+				CANTxHeader.ErrorStateIndicator = (recvFrame->flags & GS_CAN_FLAG_ESI) ? FDCAN_ESI_PASSIVE : FDCAN_ESI_ACTIVE;
+			}
+			else
+#endif
+			{
+				CANTxHeader.FDFormat = FDCAN_CLASSIC_CAN;
+				CANTxHeader.BitRateSwitch = FDCAN_BRS_OFF;
+				CANTxHeader.ErrorStateIndicator = FDCAN_ESI_ACTIVE;
+			}
 			CANTxHeader.TxEventFifoControl = FDCAN_NO_TX_EVENTS;
 
 			//CANTxHeader.MessageMarker = 0U;

firmware/RAMNV1/Core/Src/ramn_gsusb.c

@@ -30,15 +30,6 @@ RAMN_Result_t RAMN_GSUSB_ProcessRX(FDCAN_RxHeaderTypeDef *canRxHeader, uint8_t *
 	qret = xQueueReceive(RAMN_GSUSB_PoolQueueHandle, &frameData, portMAX_DELAY);
 	if (qret == pdPASS)
 	{
-		// Does not support CAN FD yet
-		if(canRxHeader->FDFormat == FDCAN_FD_CAN)
-		{
-#ifdef HANG_ON_ERRORS
-			Error_Handler();
-#endif
-			return RAMN_ERROR;
-		}
-
 		frameData->can_id = canRxHeader->Identifier;
 		if (canRxHeader->IdType != FDCAN_STANDARD_ID) frameData->can_id |= CAN_EFF_FLAG;
 		if (canRxHeader->RxFrameType != FDCAN_DATA_FRAME) frameData->can_id |= CAN_RTR_FLAG;
@@ -49,7 +40,20 @@ RAMN_Result_t RAMN_GSUSB_ProcessRX(FDCAN_RxHeaderTypeDef *canRxHeader, uint8_t *
 		frameData->can_dlc = canRxHeader->DataLength;
 		frameData->timestamp_us = (xTaskGetTickCount() * (1000000 /*us per sec*/ / configTICK_RATE_HZ) );
 
-		if (!(frameData->can_id & CAN_RTR_FLAG)) RAMN_memcpy(frameData->data, canRxData, frameData->can_dlc);
+#ifdef ENABLE_GSUSB_CANFD
+		if (canRxHeader->FDFormat == FDCAN_FD_CAN)
+		{
+			frameData->flags |= GS_CAN_FLAG_FD;
+			if (canRxHeader->BitRateSwitch == FDCAN_BRS_ON)   frameData->flags |= GS_CAN_FLAG_BRS;
+			if (canRxHeader->ErrorStateIndicator == FDCAN_ESI_PASSIVE) frameData->flags |= GS_CAN_FLAG_ESI;
+		}
+#endif
+
+		if (!(frameData->can_id & CAN_RTR_FLAG))
+		{
+			uint8_t actual = FDCAN_ConvertToActual(frameData->can_dlc);
+			RAMN_memcpy(frameData->data, canRxData, actual);
+		}
 
 		// Send to task
 		qret = xQueueSendToBack(RAMN_GSUSB_SendQueueHandle, &frameData, CAN_QUEUE_TIMEOUT);
@@ -75,21 +79,25 @@ RAMN_Result_t RAMN_GSUSB_ProcessTX(FDCAN_TxHeaderTypeDef *canTxHeader, uint8_t *
 	qret = xQueueReceive(RAMN_GSUSB_PoolQueueHandle, &frameData, CAN_QUEUE_TIMEOUT);
 	if (qret == pdPASS)
 	{
-		// Does not support CAN FD yet
-		if(canTxHeader->FDFormat == FDCAN_FD_CAN)
-		{
-#ifdef HANG_ON_ERRORS
-			Error_Handler();
-#endif
-			return RAMN_ERROR;
-		}
-
 		frameData->can_id = canTxHeader->Identifier;
 		frameData->echo_id = 0xFFFFFFFF;
 		frameData->channel = 0;
+		frameData->flags = 0;
 		frameData->can_dlc = canTxHeader->DataLength;
 		frameData->timestamp_us = 0;  // timestamps are ignored on send
-		RAMN_memcpy(frameData->data, canRxData, frameData->can_dlc);
+
+#ifdef ENABLE_GSUSB_CANFD
+		if (canTxHeader->FDFormat == FDCAN_FD_CAN)
+		{
+			frameData->flags |= GS_CAN_FLAG_FD;
+			if (canTxHeader->BitRateSwitch == FDCAN_BRS_ON) frameData->flags |= GS_CAN_FLAG_BRS;
+		}
+#endif
+
+		{
+			uint8_t actual = FDCAN_ConvertToActual(frameData->can_dlc);
+			RAMN_memcpy(frameData->data, canRxData, actual);
+		}
 
 		// Send to task
 		qret = xQueueSendToBack(RAMN_GSUSB_SendQueueHandle, &frameData, CAN_QUEUE_TIMEOUT);

firmware/RAMNV1/Middlewares/ST/STM32_USB_Device_Library/USBClass/Composite/gs_usb/gs_usb_breq.c

@@ -83,6 +83,11 @@ void breq_set_mode(USBD_GS_CAN_HandleTypeDef *hcan, USBD_SetupReqTypedef *req)
 	}
 	else if (mode->mode == GS_CAN_MODE_START)
 	{
+#ifdef ENABLE_GSUSB_CANFD
+		hcan->enable_fdcan = (mode->flags & GS_CAN_MODE_FD) != 0;
+#else
+		hcan->enable_fdcan = 0;
+#endif
 		FDCAN_InitQueues(hcan);
 		hcan->timestamps_enabled = (mode->flags & GS_CAN_MODE_HW_TIMESTAMP) != 0;
 		hcan->pad_pkts_to_max_pkt_size = (mode->flags & GS_CAN_MODE_PAD_PKTS_TO_MAX_PKT_SIZE) != 0;
@@ -121,6 +126,7 @@ void breq_set_bittiming(USBD_GS_CAN_HandleTypeDef *hcan, USBD_SetupReqTypedef *r
  */
 void breq_set_data_bittiming(USBD_GS_CAN_HandleTypeDef *hcan, USBD_SetupReqTypedef *req)
 {
+#ifdef ENABLE_GSUSB_CANFD
 	struct gs_device_bittiming *timing;
 
 	timing = (struct gs_device_bittiming *)hcan->ep0_buf;
@@ -133,6 +139,7 @@ void breq_set_data_bittiming(USBD_GS_CAN_HandleTypeDef *hcan, USBD_SetupReqTyped
 	);
 
 	hcan->enable_fdcan = 1;
+#endif
 }
 
 #endif

firmware/RAMNV1/Middlewares/ST/STM32_USB_Device_Library/USBClass/Composite/gs_usb/usbd_gs_usb.c

@@ -64,7 +64,12 @@ const struct gs_device_bt_const gscan_btconst = {
 		| GS_CAN_FEATURE_HW_TIMESTAMP
 		| GS_CAN_FEATURE_IDENTIFY
 		| GS_CAN_FEATURE_USER_ID
-		| GS_CAN_FEATURE_PAD_PKTS_TO_MAX_PKT_SIZE,
+		| GS_CAN_FEATURE_PAD_PKTS_TO_MAX_PKT_SIZE
+#ifdef ENABLE_GSUSB_CANFD
+		| GS_CAN_FEATURE_FD
+		| GS_CAN_FEATURE_BT_CONST_EXT
+#endif
+		,
 		48000000, // can timing base clock
 		1,        // tseg1 min
 		16,       // tseg1 max
@@ -76,6 +81,36 @@ const struct gs_device_bt_const gscan_btconst = {
 		1,        // brp increment;
 };
 
+#ifdef ENABLE_GSUSB_CANFD
+static const struct gs_device_bt_const_extended gscan_btconst_ext = {
+		GS_CAN_FEATURE_LISTEN_ONLY  // supported features
+		| GS_CAN_FEATURE_LOOP_BACK
+		| GS_CAN_FEATURE_HW_TIMESTAMP
+		| GS_CAN_FEATURE_IDENTIFY
+		| GS_CAN_FEATURE_USER_ID
+		| GS_CAN_FEATURE_PAD_PKTS_TO_MAX_PKT_SIZE
+		| GS_CAN_FEATURE_FD
+		| GS_CAN_FEATURE_BT_CONST_EXT,
+		48000000, // can timing base clock
+		1,        // tseg1 min
+		16,       // tseg1 max
+		2,        // tseg2 min
+		8,        // tseg2 max
+		4,        // sjw max
+		1,        // brp min
+		512,      // brp_max
+		1,        // brp increment
+		1,        // dtseg1 min
+		16,       // dtseg1 max
+		2,        // dtseg2 min
+		8,        // dtseg2 max
+		4,        // dsjw max
+		1,        // dbrp min
+		512,      // dbrp_max
+		1,        // dbrp increment
+};
+#endif
+
 
 /*  Microsoft Compatible ID Feature Descriptor  */
 static const uint8_t USBD_MS_COMP_ID_FEATURE_DESC[] = {
@@ -224,11 +259,15 @@ static uint8_t gsusb_config_request(USBD_HandleTypeDef *pdev, USBD_SetupReqTyped
 		USBD_CtlPrepareRx(pdev, hcan->ep0_buf, req->wLength);
 		break;
 	case GS_USB_BREQ_DATA_BITTIMING:
-
+#ifdef ENABLE_GSUSB_CANFD
 		hcan->enable_fdcan = 1;
 		hcan->last_setup_request = *req;
 		USBD_CtlPrepareRx(pdev, hcan->ep0_buf, req->wLength);
 		break;
+#else
+		ret = USBD_FAIL;
+		break;
+#endif
 	case GS_USB_BREQ_DEVICE_CONFIG:
 		RAMN_memcpy(hcan->ep0_buf, &gscan_dconf, sizeof(gscan_dconf));
 		USBD_CtlSendData(pdev, hcan->ep0_buf, req->wLength);
@@ -239,6 +278,14 @@ static uint8_t gsusb_config_request(USBD_HandleTypeDef *pdev, USBD_SetupReqTyped
 		USBD_CtlSendData(pdev, hcan->ep0_buf, req->wLength);
 		break;
 
+#ifdef ENABLE_GSUSB_CANFD
+	case GS_USB_BREQ_BT_CONST_EXT:
+		// Use USBD_DescBuf instead of ep0_buf: extended bt_const (72 bytes) exceeds ep0_buf (64 bytes)
+		RAMN_memcpy(USBD_DescBuf, &gscan_btconst_ext, sizeof(gscan_btconst_ext));
+		USBD_CtlSendData(pdev, USBD_DescBuf, MIN(sizeof(gscan_btconst_ext), req->wLength));
+		break;
+#endif
+
 	case GS_USB_BREQ_TIMESTAMP:
 		RAMN_memcpy(hcan->ep0_buf, &hcan->sof_timestamp_us, sizeof(hcan->sof_timestamp_us));
 		USBD_CtlSendData(pdev, hcan->ep0_buf, sizeof(hcan->sof_timestamp_us));
@@ -412,16 +459,19 @@ void GSUSB_MarshalFrame(USBD_HandleTypeDef *pdev, struct gs_host_frame *in, uint
 	out[ofs++] = in->channel;
 	out[ofs++] = in->flags;
 	out[ofs++] = in->reserved;
-	RAMN_memcpy(&out[ofs], in->data, in->can_dlc);
-	if(!hcan->enable_fdcan)
 	{
-		RAMN_memset(&out[ofs + in->can_dlc], 0x00, 8 - in->can_dlc);
-		ofs += 8;
-	}
-	else
-	{
-		RAMN_memset(&out[ofs + in->can_dlc], 0x00, 64 - in->can_dlc);
-		ofs += 64;
+		uint8_t actual = FDCAN_ConvertToActual(in->can_dlc);
+		RAMN_memcpy(&out[ofs], in->data, actual);
+		if(!hcan->enable_fdcan)
+		{
+			RAMN_memset(&out[ofs + actual], 0x00, 8 - actual);
+			ofs += 8;
+		}
+		else
+		{
+			RAMN_memset(&out[ofs + actual], 0x00, 64 - actual);
+			ofs += 64;
+		}
 	}
 
 	if (hcan->timestamps_enabled)
@@ -446,16 +496,19 @@ void GSUSB_UnmarshalFrame(USBD_HandleTypeDef *pdev, uint8_t *in, uint16_t inlen,
 	out->channel = in[ofs++];
 	out->flags = in[ofs++];
 	out->reserved = in[ofs++];
-	RAMN_memcpy(out->data, &in[ofs], out->can_dlc);
-	if(!hcan->enable_fdcan)
-	{
-		RAMN_memset(&out->data[out->can_dlc], 0x00, 8 - out->can_dlc);
-		ofs += 8;
-	}
-	else
 	{
-		RAMN_memset(&out->data[out->can_dlc], 0x00, 64 - out->can_dlc);
-		ofs += 64;
+		uint8_t actual = FDCAN_ConvertToActual(out->can_dlc);
+		RAMN_memcpy(out->data, &in[ofs], actual);
+		if(!hcan->enable_fdcan)
+		{
+			RAMN_memset(&out->data[actual], 0x00, 8 - actual);
+			ofs += 8;
+		}
+		else
+		{
+			RAMN_memset(&out->data[actual], 0x00, 64 - actual);
+			ofs += 64;
+		}
 	}
 
 	if (hcan->timestamps_enabled)

firmware/RAMNV1/Middlewares/ST/STM32_USB_Device_Library/USBClass/Composite/gs_usb/usbd_gs_usb.h

@@ -60,8 +60,12 @@ THE SOFTWARE.
 
 #define GS_CAN_FEATURE_PAD_PKTS_TO_MAX_PKT_SIZE (1<<7)
 #define GS_CAN_FEATURE_FD                       (1<<8)
+#define GS_CAN_FEATURE_BT_CONST_EXT             (1<<10)
 
 #define GS_CAN_FLAG_OVERFLOW 1
+#define GS_CAN_FLAG_FD       (1<<1)
+#define GS_CAN_FLAG_BRS      (1<<2)
+#define GS_CAN_FLAG_ESI      (1<<3)
 
 #define CAN_EFF_FLAG 0x80000000U /* EFF/SFF is set in the MSB */
 #define CAN_RTR_FLAG 0x40000000U /* remote transmission request */
@@ -163,6 +167,8 @@ enum gs_usb_breq {
 	GS_USB_BREQ_TIMESTAMP,
 	GS_USB_BREQ_IDENTIFY,
 	GS_USB_BREQ_DATA_BITTIMING,
+	GS_USB_BREQ_GET_USER_ID,    // not implemented, placeholder for correct enum numbering
+	GS_USB_BREQ_BT_CONST_EXT,
 };
 
 enum gs_can_mode {
@@ -231,6 +237,27 @@ struct __attribute__ ((__packed__)) gs_device_bt_const {
 	uint32_t brp_inc;
 };
 
+struct __attribute__ ((__packed__)) gs_device_bt_const_extended {
+	uint32_t feature;
+	uint32_t fclk_can;
+	uint32_t tseg1_min;
+	uint32_t tseg1_max;
+	uint32_t tseg2_min;
+	uint32_t tseg2_max;
+	uint32_t sjw_max;
+	uint32_t brp_min;
+	uint32_t brp_max;
+	uint32_t brp_inc;
+	uint32_t dtseg1_min;
+	uint32_t dtseg1_max;
+	uint32_t dtseg2_min;
+	uint32_t dtseg2_max;
+	uint32_t dsjw_max;
+	uint32_t dbrp_min;
+	uint32_t dbrp_max;
+	uint32_t dbrp_inc;
+};
+
 
 struct __attribute__ ((__packed__)) gs_host_frame {
 	uint32_t echo_id;