Merge pull request #318 from marckleinebudde/add-tdc-support

add TDC support

Author: marckleinebudde

include/can.h

@@ -34,20 +34,38 @@
 #include "led.h"
 #include "list.h"
 
+struct can_drv_reg_status {
+#if defined (CONFIG_BXCAN)
+	uint32_t esr;
+#endif
+};
+
+enum can_channel_flag {
+	CAN_CHANNEL_FLAG_BITTIMING_SET = BIT(0),
+	CAN_CHANNEL_FLAG_DATA_BITTIMING_SET = BIT(1),
+	CAN_CHANNEL_FLAG_TDC_SET = BIT(2),
+};
+
 #define CAN_CHANNEL_BUS_OFF_RESTART_DISABLED 0
 
 typedef struct can_channel {
 #if defined (CONFIG_BXCAN)
 	CAN_TypeDef *instance;
 #endif
+	struct can_drv_reg_status reg_status;
 	struct list_head list_from_host;
 	led_data_t leds;
 	uint32_t feature;
+	enum can_channel_flag flags;
 	enum gs_can_state state;
 	uint32_t bus_off_restart;
+	struct gs_device_bittiming bittiming;
+#ifdef CONFIG_CANFD
+	struct gs_device_bittiming data_bittiming;
+	struct gs_device_tdc tdc;
+#endif
 #if defined (CONFIG_BXCAN)
 	struct gs_device_filter filter;
-	uint32_t btr;
 #endif
 #if (NUM_CAN_CHANNEL > 1)
 	uint8_t nr;
@@ -57,21 +75,11 @@ typedef struct can_channel {
 extern const struct gs_device_bt_const CAN_btconst;
 extern const struct gs_device_bt_const_extended CAN_btconst_ext;
 extern const struct gs_device_filter_info CAN_filter_info;
+extern const struct gs_device_tdc_const CAN_tdc_const;
 
 struct board_channel_config;
 
 void can_init(can_data_t *channel, const struct board_channel_config *config);
-void can_set_bittiming(can_data_t *channel, const struct gs_device_bittiming *timing);
-
-#ifdef CONFIG_CANFD
-void can_set_data_bittiming(can_data_t *channel, const struct gs_device_bittiming *timing);
-#else
-static inline bool can_set_data_bittiming(can_data_t __maybe_unused *channel,
-										  const struct gs_device_bittiming __maybe_unused *timing)
-{
-	return false;
-}
-#endif
 
 #ifdef CONFIG_CAN_FILTER
 void can_set_filter(can_data_t *channel, const struct gs_device_filter *filter);

include/can_common.h

@@ -40,7 +40,37 @@
 #define CAN_LEC_CRC_ERROR	6
 #define CAN_LEC_SOFTWARE	7
 
+bool can_check_feature_ok(const can_data_t *channel, const uint32_t feature);
 bool can_check_bittiming_ok(const struct can_bittiming_const *btc, const struct gs_device_bittiming *timing);
+void can_set_bittiming(struct can_channel *channel, const struct gs_device_bittiming *bt);
+
+#ifdef CONFIG_CANFD
+void can_set_data_bittiming(struct can_channel *channel, const struct gs_device_bittiming *timing);
+bool can_check_tdc_ok(const struct gs_device_tdc_const *tdc_const, const struct gs_device_tdc *tdc);
+void can_set_tdc(struct can_channel *channel, const struct gs_device_tdc *tdc);
+void can_get_device_tdc(const struct can_channel *channel, struct gs_device_tdc *tdc);
+#else
+static inline void can_set_data_bittiming(struct can_channel __maybe_unused *channel,
+										  const struct gs_device_bittiming __maybe_unused *timing)
+{
+}
+
+static inline bool can_check_tdc_ok(const struct gs_device_tdc_const __maybe_unused *tdc_const,
+									const struct gs_device_tdc __maybe_unused *tdc)
+{
+	return false;
+}
+
+static inline void can_set_tdc(struct can_channel __maybe_unused *channel,
+							   const struct gs_device_tdc __maybe_unused *tdc)
+{
+}
+
+static inline void can_get_device_tdc(const struct can_channel __maybe_unused *channel,
+									  struct gs_device_tdc __maybe_unused *tdc)
+{
+}
+#endif
 
 #ifdef CONFIG_CAN_FILTER
 bool can_check_filter_ok(const struct gs_device_filter *filter);

include/can_drv.h

@@ -29,19 +29,23 @@
 #include <stdint.h>
 
 struct can_channel;
+struct can_drv_reg_status;
 struct gs_device_state;
+struct gs_device_tdc;
 struct gs_host_frame;
 
 void can_drv_enable(struct can_channel *channel);
 void can_drv_disable(struct can_channel *channel);
 
-uint32_t can_drv_read_reg_status(const struct can_channel *channel);
+void can_drv_get_device_tdc(const struct can_channel *channel, struct gs_device_tdc *tdc);
 
-bool can_drv_bus_error_pending(const uint32_t reg);
-bool can_drv_handle_bus_error(const struct can_channel *channel, struct gs_host_frame *frame, const uint32_t reg);
+void can_drv_read_reg_status(struct can_channel *channel);
 
-enum gs_can_state can_drv_get_state(const uint32_t reg);
-void can_drv_get_device_state(const struct can_channel *channel, struct gs_device_state *state, const uint32_t reg);
-void can_drv_handle_state_change(const struct can_channel *channel, struct gs_host_frame *frame, const uint32_t reg);
+bool can_drv_bus_error_pending(const struct can_channel *channel);
+bool can_drv_handle_bus_error(const struct can_channel *channel, struct gs_host_frame *frame);
+
+enum gs_can_state can_drv_get_state(const struct can_channel *channel);
+void can_drv_get_device_state(const struct can_channel *channel, struct gs_device_state *state);
+void can_drv_handle_state_change(const struct can_channel *channel, struct gs_host_frame *frame);
 
 void can_drv_handle_bus_off_recovery(struct can_channel *channel);

include/gs_usb.h

@@ -75,6 +75,14 @@
  * - struct gs_device_filter
  */
 #define GS_CAN_FEATURE_FILTER							  (1<<16)
+/* device supports TDC configuration, see:
+ * - GS_USB_BREQ_GET_TDC_CONST
+ * - GS_USB_BREQ_SET_TDC
+ * - GS_USB_BREQ_GET_TDC
+ * - struct gs_device_tdc_const
+ * - struct gs_device_tdc
+ */
+#define GS_CAN_FEATURE_TDC								  (1<<17)
 /* device support CAN bus off recovery
  * - GS_USB_BREQ_BUS_OFF_RECOVERY
  * - struct gs_device_bus_off_recovery
@@ -186,9 +194,9 @@ enum gs_usb_breq {
 	GS_USB_BREQ_GET_STATE,
 	GS_USB_BREQ_SET_FILTER,
 	GS_USB_BREQ_GET_FILTER,
-	__GS_USB_BREQ_PLACEHOLDER_17,
-	__GS_USB_BREQ_PLACEHOLDER_18,
-	__GS_USB_BREQ_PLACEHOLDER_19,
+	GS_USB_BREQ_GET_TDC_CONST,
+	GS_USB_BREQ_SET_TDC,
+	GS_USB_BREQ_GET_TDC,
 	GS_USB_BREQ_ELM_GET_BOARDINFO = 20,
 	GS_USB_BREQ_ELM_SET_FILTER,
 	GS_USB_BREQ_ELM_GET_LASTERROR,
@@ -325,6 +333,29 @@ struct gs_device_filter {
 	};
 } __packed __aligned(4);
 
+enum gs_device_tdc_mode {
+	GS_CAN_TDC_MODE_OFF = BIT(0),
+	GS_CAN_TDC_MODE_AUTO = BIT(1),
+	GS_CAN_TDC_MODE_MANUAL = BIT(2),
+};
+
+struct gs_device_tdc_const {
+	u32 tdcv_min;
+	u32 tdcv_max;
+	u32 tdco_min;
+	u32 tdco_max;
+	u32 tdcf_min;
+	u32 tdcf_max;
+	u32 mode;
+} __packed __aligned(4);
+
+struct gs_device_tdc {
+	u32 tdcv;
+	u32 tdco;
+	u32 tdcf;
+	enum gs_device_tdc_mode mode;
+} __packed __aligned(4);
+
 struct gs_device_bus_off_recovery {
 	u32 unused;
 } __packed __aligned(4);

include/usbd_gs_can.h

@@ -89,6 +89,7 @@ typedef struct {
 
 			// Device <-> Host
 			struct gs_device_termination_state term_state;
+			struct gs_device_tdc tdc;
 		}; );
 		uint8_t __aligned(4) buf[sizeof(struct ep0_data)];
 	} ep0;

src/can/bxcan.c

@@ -103,14 +103,6 @@ void can_init(can_data_t *channel, const struct board_channel_config *channel_co
 	filter->fa1r = 0x1;     // Enable filter bank 0
 }
 
-void can_set_bittiming(can_data_t *channel, const struct gs_device_bittiming *timing)
-{
-	channel->btr = FIELD_PREP(CAN_BTR_SJW, timing->sjw - 1) |
-				   FIELD_PREP(CAN_BTR_TS2, timing->phase_seg2 - 1) |
-				   FIELD_PREP(CAN_BTR_TS1, timing->prop_seg + timing->phase_seg1 - 1) |
-				   FIELD_PREP(CAN_BTR_BRP, timing->brp - 1);
-}
-
 #ifdef CONFIG_CAN_FILTER
 void can_set_filter(can_data_t *channel, const struct gs_device_filter *filter)
 {
@@ -160,7 +152,10 @@ void can_drv_enable(struct can_channel *channel)
 		mcr |= CAN_MCR_NART;
 	}
 
-	uint32_t btr = channel->btr;
+	uint32_t btr = FIELD_PREP(CAN_BTR_SJW, channel->bittiming.sjw - 1) |
+				   FIELD_PREP(CAN_BTR_TS2, channel->bittiming.phase_seg2 - 1) |
+				   FIELD_PREP(CAN_BTR_TS1, channel->bittiming.prop_seg + channel->bittiming.phase_seg1 - 1) |
+				   FIELD_PREP(CAN_BTR_BRP, channel->bittiming.brp - 1);
 
 	if (feature & GS_CAN_FEATURE_LISTEN_ONLY) {
 		btr |= CAN_MODE_SILENT;
@@ -302,28 +297,28 @@ bool can_send(can_data_t *channel, struct gs_host_frame *frame)
 	}
 }
 
-bool can_drv_bus_error_pending(const uint32_t reg_esr)
+bool can_drv_bus_error_pending(const struct can_channel *channel)
 {
+	const uint32_t reg_esr = channel->reg_status.esr;
 	const uint8_t lec = FIELD_GET(CAN_ESR_LEC, reg_esr);
 
 	return can_is_lec_error(lec);
 }
 
-uint32_t can_drv_read_reg_status(const struct can_channel *channel)
+void can_drv_read_reg_status(struct can_channel *channel)
 {
-	const uint32_t reg_esr = channel->instance->ESR;
+	channel->reg_status.esr = channel->instance->ESR;
 
-	if (can_drv_bus_error_pending(reg_esr)) {
+	if (can_drv_bus_error_pending(channel)) {
 		/* mark as handled by software */
 		channel->instance->ESR |= FIELD_PREP(CAN_ESR_LEC, CAN_LEC_SOFTWARE);
 	}
-
-	return reg_esr;
 }
 
-bool can_drv_handle_bus_error(const struct can_channel __maybe_unused *channel, struct gs_host_frame *frame,
-							  const uint32_t reg_esr)
+bool can_drv_handle_bus_error(const struct can_channel *channel, struct gs_host_frame *frame)
 {
+	const uint32_t reg_esr = channel->reg_status.esr;
+
 	const uint8_t tx_err = FIELD_GET(CAN_ESR_TEC, reg_esr);
 	const uint8_t rx_err = FIELD_GET(CAN_ESR_REC, reg_esr);
 
@@ -341,8 +336,10 @@ bool can_drv_handle_bus_error(const struct can_channel __maybe_unused *channel,
 	return true;
 }
 
-enum gs_can_state can_drv_get_state(const uint32_t reg_esr)
+enum gs_can_state can_drv_get_state(const struct can_channel *channel)
 {
+	const uint32_t reg_esr = channel->reg_status.esr;
+
 	if (!(reg_esr & (CAN_ESR_BOFF | CAN_ESR_EPVF | CAN_ESR_EWGF))) {
 		return GS_CAN_STATE_ERROR_ACTIVE;
 	}
@@ -358,25 +355,24 @@ enum gs_can_state can_drv_get_state(const uint32_t reg_esr)
 	return GS_CAN_STATE_ERROR_WARNING;
 }
 
-void can_drv_get_device_state(const struct can_channel __maybe_unused *channel, struct gs_device_state *state,
-							  const uint32_t reg_esr)
+void can_drv_get_device_state(const struct can_channel *channel, struct gs_device_state *state)
 {
-	state->state = can_drv_get_state(reg_esr);
+	const uint32_t reg_esr = channel->reg_status.esr;
+
+	state->state = can_drv_get_state(channel);
 	state->rxerr = FIELD_GET(CAN_ESR_REC, reg_esr);
 	state->txerr = FIELD_GET(CAN_ESR_TEC, reg_esr);
 }
 
-void can_drv_handle_state_change(const struct can_channel __maybe_unused *channel, struct gs_host_frame *frame,
-								 const uint32_t reg_esr)
+void can_drv_handle_state_change(const struct can_channel *channel, struct gs_host_frame *frame)
 {
-	enum gs_can_state tx_state, rx_state;
-	uint8_t tx_err, rx_err;
+	const uint32_t reg_esr = channel->reg_status.esr;
 
-	tx_err = FIELD_GET(CAN_ESR_TEC, reg_esr);
-	rx_err = FIELD_GET(CAN_ESR_REC, reg_esr);
+	const uint8_t tx_err = FIELD_GET(CAN_ESR_TEC, reg_esr);
+	const uint8_t rx_err = FIELD_GET(CAN_ESR_REC, reg_esr);
 
-	tx_state = can_err_to_state(tx_err);
-	rx_state = can_err_to_state(rx_err);
+	const enum gs_can_state tx_state = can_err_to_state(tx_err);
+	const enum gs_can_state rx_state = can_err_to_state(rx_err);
 
 	if (tx_state >= rx_state) {
 		frame->classic_can->data[1] |= gs_can_tx_state_to_frame(tx_state);