[nrf noup] drivers: can: mcan: implement CAN_MODE_ONE_SHOT

Implement CAN_MODE_ONE_SHOT in MCAN impementation. The implementation
contains a workaround for a bug in the MCAN IP which prevents an IRQ
from triggering.

This is a noup as the workaround is too complicated and the feature
is too niche to be accepted it upstream.

Signed-off-by: Bjarki Arge Andreasen <[email protected]>

Author: bjarki-andreasen

drivers/can/Kconfig.mcan

@@ -7,3 +7,18 @@ config CAN_MCAN
 	bool
 	help
 	  Enable the Bosch M_CAN CAN IP module driver backend.
+
+if CAN_MCAN
+
+config CAN_MCAN_TXBCF_POLL_INTERVAL_MS
+	int "Polling interval in milliseconds of TXBCF register if DAR is enabled"
+	default 75
+	help
+	  When DAR (Disable Automatic Retransmission), used for CAN_MODE_ONE_SHOT,
+	  is enabled, and a transmission fails, a bug in the MCAN IP prevents the
+	  TCF (Transmission Cancellation Finalized) interrupt from triggering,
+	  despite the correct bit being set in the TXBCF register. It is thus
+	  neccesary to poll TXBCF register to detect when a transmission failed if
+	  DAR is enabled.
+
+endif # CAN_MCAN

drivers/can/can_mcan.c

@@ -17,6 +17,7 @@
 LOG_MODULE_REGISTER(can_mcan, CONFIG_CAN_LOG_LEVEL);
 
 #define CAN_INIT_TIMEOUT_MS 100
+#define TXBCF_TIMER_TIMEOUT K_MSEC(CONFIG_CAN_MCAN_TXBCF_POLL_INTERVAL_MS)
 
 int can_mcan_read_reg(const struct device *dev, uint16_t reg, uint32_t *val)
 {
@@ -276,7 +277,7 @@ int can_mcan_get_capabilities(const struct device *dev, can_mode_t *cap)
 {
 	ARG_UNUSED(dev);
 
-	*cap = CAN_MODE_NORMAL | CAN_MODE_LOOPBACK | CAN_MODE_LISTENONLY;
+	*cap = CAN_MODE_NORMAL | CAN_MODE_LOOPBACK | CAN_MODE_LISTENONLY | CAN_MODE_ONE_SHOT;
 
 	if (IS_ENABLED(CONFIG_CAN_MANUAL_RECOVERY_MODE)) {
 		*cap |=  CAN_MODE_MANUAL_RECOVERY;
@@ -294,6 +295,7 @@ int can_mcan_start(const struct device *dev)
 	const struct can_mcan_config *config = dev->config;
 	struct can_mcan_data *data = dev->data;
 	int err = 0;
+	uint32_t cccr;
 
 	if (data->common.started) {
 		return -EALREADY;
@@ -322,12 +324,68 @@ int can_mcan_start(const struct device *dev)
 		return err;
 	}
 
+	err = can_mcan_read_reg(dev, CAN_MCAN_CCCR, &cccr);
+	if (err != 0) {
+		return err;
+	}
+
+	if (cccr & CAN_MCAN_CCCR_DAR) {
+		k_timer_start(&data->txbcf_timer, TXBCF_TIMER_TIMEOUT, TXBCF_TIMER_TIMEOUT);
+	}
+
 	data->common.started = true;
 	pm_device_busy_set(dev);
 
 	return err;
 }
 
+static int can_mcan_read_txbcf(const struct device *dev)
+{
+	const struct can_mcan_config *config = dev->config;
+	const struct can_mcan_callbacks *cbs = config->callbacks;
+	struct can_mcan_data *data = dev->data;
+	uint32_t txbcfs;
+	int err;
+	can_tx_callback_t tx_cb;
+	void *user_data;
+
+	err = can_mcan_read_reg(dev, CAN_MCAN_TXBCF, &txbcfs);
+	if (err != 0) {
+		LOG_ERR("failed to read tx cancellation finished (err %d)", err);
+		return err;
+	}
+
+	if (txbcfs == 0) {
+		return 0;
+	}
+
+	for (size_t tx_idx = 0; tx_idx < cbs->num_tx; tx_idx++) {
+		if ((txbcfs & BIT(tx_idx)) == 0) {
+			continue;
+		}
+
+		if (cbs->tx[tx_idx].function == NULL) {
+			continue;
+		}
+
+		tx_cb = cbs->tx[tx_idx].function;
+		user_data = cbs->tx[tx_idx].user_data;
+		cbs->tx[tx_idx].function = NULL;
+		LOG_DBG("tx buffer cancellation finished (idx %u)", tx_idx);
+		k_sem_give(&data->tx_sem);
+		tx_cb(dev, -EIO, user_data);
+	}
+
+	return 0;
+}
+
+static void can_mcan_txbcf_timer_handler(struct k_timer *timer_id)
+{
+	const struct device *dev = k_timer_user_data_get(timer_id);
+
+	can_mcan_read_txbcf(dev);
+}
+
 static bool can_mcan_rx_filters_exist(const struct device *dev)
 {
 	const struct can_mcan_config *config = dev->config;
@@ -362,6 +420,8 @@ int can_mcan_stop(const struct device *dev)
 		return -EALREADY;
 	}
 
+	k_timer_stop(&data->txbcf_timer);
+
 	/* CAN transmissions are automatically stopped when entering init mode */
 	err = can_mcan_enter_init_mode(dev, K_MSEC(CAN_INIT_TIMEOUT_MS));
 	if (err != 0) {
@@ -402,7 +462,7 @@ int can_mcan_stop(const struct device *dev)
 
 int can_mcan_set_mode(const struct device *dev, can_mode_t mode)
 {
-	can_mode_t supported = CAN_MODE_LOOPBACK | CAN_MODE_LISTENONLY;
+	can_mode_t supported = CAN_MODE_LOOPBACK | CAN_MODE_LISTENONLY | CAN_MODE_ONE_SHOT;
 	struct can_mcan_data *data = dev->data;
 	uint32_t cccr;
 	uint32_t test;
@@ -460,6 +520,13 @@ int can_mcan_set_mode(const struct device *dev, can_mode_t mode)
 	}
 #endif /* CONFIG_CAN_FD_MODE */
 
+	if ((mode & CAN_MODE_ONE_SHOT) != 0) {
+		/* Disable Automatic Retransmission */
+		cccr |= CAN_MCAN_CCCR_DAR;
+	} else {
+		cccr &= ~CAN_MCAN_CCCR_DAR;
+	}
+
 	err = can_mcan_write_reg(dev, CAN_MCAN_CCCR, cccr);
 	if (err != 0) {
 		goto unlock;
@@ -694,6 +761,7 @@ void can_mcan_line_0_isr(const struct device *dev)
 #ifdef CONFIG_CAN_STATS
 		if ((ir & (CAN_MCAN_IR_PEA | CAN_MCAN_IR_PED)) != 0U) {
 			uint32_t reg;
+
 			/* This function automatically updates protocol error stats */
 			can_mcan_read_psr(dev, &reg);
 		}
@@ -1424,6 +1492,8 @@ int can_mcan_init(const struct device *dev)
 	k_mutex_init(&data->lock);
 	k_mutex_init(&data->tx_mtx);
 	k_sem_init(&data->tx_sem, cbs->num_tx, cbs->num_tx);
+	k_timer_init(&data->txbcf_timer, can_mcan_txbcf_timer_handler, NULL);
+	k_timer_user_data_set(&data->txbcf_timer, (void *)dev);
 
 	if (config->common.phy != NULL && !device_is_ready(config->common.phy)) {
 		LOG_ERR("CAN transceiver not ready");
@@ -1565,5 +1635,14 @@ int can_mcan_init(const struct device *dev)
 		return err;
 	}
 
+	/*
+	 * Interrupt on every TX buffer cancellation finished event.
+	 */
+	reg = CAN_MCAN_TXBCIE_CFIE;
+	err = can_mcan_write_reg(dev, CAN_MCAN_TXBCIE, reg);
+	if (err != 0) {
+		return err;
+	}
+
 	return can_mcan_clear_mram(dev, 0, config->mram_size);
 }

include/zephyr/drivers/can/can_mcan.h

@@ -1065,6 +1065,7 @@ struct can_mcan_data {
 	struct k_mutex lock;
 	struct k_sem tx_sem;
 	struct k_mutex tx_mtx;
+	struct k_timer txbcf_timer;
 	void *custom;
 } __aligned(4);