drivers: can: split CAN classic and CAN-FD syscalls
Split CAN classic and CAN-FD syscalls into two:
- can_set_timing() -> can_set_timing() + can_set_timing_data()
- can_set_bitrate() -> can_set_bitrate() + can_set_bitrate_data()
Fixes: #45303
Signed-off-by: Henrik Brix Andersen <hebad@vestas.com>
diff --git a/doc/hardware/peripherals/canbus/controller.rst b/doc/hardware/peripherals/canbus/controller.rst
index 5a2894a..afecd05 100644
--- a/doc/hardware/peripherals/canbus/controller.rst
+++ b/doc/hardware/peripherals/canbus/controller.rst
@@ -284,11 +284,7 @@
*******************
The bitrate and sampling point is initially set at runtime. To change it from
-the application, one can use the :c:func:`can_set_timing` API. This function
-takes three arguments. The first timing parameter sets the timing for classic
-CAN and arbitration phase for CAN-FD. The second parameter sets the timing of
-the data phase for CAN-FD. For classic CAN, you can use only the first
-parameter and put NULL to the second one. The :c:func:`can_calc_timing`
+the application, one can use the :c:func:`can_set_timing` API. The :c:func:`can_calc_timing`
function can calculate timing from a bitrate and sampling point in permille.
The following example sets the bitrate to 250k baud with the sampling point at
87.5%.
@@ -309,11 +305,14 @@
return;
}
- ret = can_set_timing(can_dev, &timing, NULL);
+ ret = can_set_timing(can_dev, &timing);
if (ret != 0) {
LOG_ERR("Failed to set timing");
}
+A similar API exists for calculating and setting the timing for the data phase for CAN-FD capable
+controllers. See :c:func:`can_set_timing_data` and :c:func:`can_calc_timing_data`.
+
SocketCAN
*********
diff --git a/drivers/can/can_common.c b/drivers/can/can_common.c
index bbb494a..539c6cf 100644
--- a/drivers/can/can_common.c
+++ b/drivers/can/can_common.c
@@ -207,12 +207,9 @@
return sample_pnt;
}
-int z_impl_can_set_bitrate(const struct device *dev, uint32_t bitrate, uint32_t bitrate_data)
+int z_impl_can_set_bitrate(const struct device *dev, uint32_t bitrate)
{
struct can_timing timing;
-#ifdef CONFIG_CAN_FD_MODE
- struct can_timing timing_data;
-#endif /* CONFIG_CAN_FD_MODE */
uint32_t max_bitrate;
uint16_t sample_pnt;
int ret;
@@ -241,7 +238,25 @@
timing.sjw = CAN_SJW_NO_CHANGE;
+ return can_set_timing(dev, &timing);
+}
+
#ifdef CONFIG_CAN_FD_MODE
+int z_impl_can_set_bitrate_data(const struct device *dev, uint32_t bitrate_data)
+{
+ struct can_timing timing_data;
+ uint32_t max_bitrate;
+ uint16_t sample_pnt;
+ int ret;
+
+ ret = can_get_max_bitrate(dev, &max_bitrate);
+ if (ret == -ENOSYS) {
+ /* Maximum bitrate unknown */
+ max_bitrate = 0;
+ } else if (ret < 0) {
+ return ret;
+ }
+
if ((max_bitrate > 0) && (bitrate_data > max_bitrate)) {
return -ENOTSUP;
}
@@ -258,8 +273,6 @@
timing_data.sjw = CAN_SJW_NO_CHANGE;
- return can_set_timing(dev, &timing, &timing_data);
-#else /* CONFIG_CAN_FD_MODE */
- return can_set_timing(dev, &timing, NULL);
-#endif /* !CONFIG_CAN_FD_MODE */
+ return can_set_timing_data(dev, &timing_data);
}
+#endif /* CONFIG_CAN_FD_MODE */
diff --git a/drivers/can/can_handlers.c b/drivers/can/can_handlers.c
index f788239..922ba34 100644
--- a/drivers/can/can_handlers.c
+++ b/drivers/can/can_handlers.c
@@ -24,21 +24,14 @@
#include <syscalls/can_calc_timing_mrsh.c>
static inline int z_vrfy_can_set_timing(const struct device *dev,
- const struct can_timing *timing,
- const struct can_timing *timing_data)
+ const struct can_timing *timing)
{
struct can_timing timing_copy;
- struct can_timing timing_data_copy;
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, set_timing));
Z_OOPS(z_user_from_copy(&timing_copy, timing, sizeof(timing_copy)));
- if (timing_data != NULL) {
- Z_OOPS(z_user_from_copy(&timing_data_copy, timing_data, sizeof(timing_data_copy)));
- return z_impl_can_set_timing(dev, &timing_copy, &timing_data_copy);
- }
-
- return z_impl_can_set_timing(dev, &timing_copy, NULL);
+ return z_impl_can_set_timing(dev, &timing_copy);
}
#include <syscalls/can_set_timing_mrsh.c>
@@ -113,6 +106,27 @@
}
#include <syscalls/can_get_timing_max_data_mrsh.c>
+static inline int z_vrfy_can_set_timing_data(const struct device *dev,
+ const struct can_timing *timing_data)
+{
+ struct can_timing timing_data_copy;
+
+ Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, set_timing_data));
+ Z_OOPS(z_user_from_copy(&timing_data_copy, timing_data, sizeof(timing_data_copy)));
+
+ return z_impl_can_set_timing_data(dev, &timing_data_copy);
+}
+#include <syscalls/can_set_timing_data_mrsh.c>
+
+static inline int z_vrfy_can_set_bitrate_data(const struct device *dev,
+ uint32_t bitrate_data)
+{
+ Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, set_timing_data));
+
+ return z_impl_can_set_bitrate_data(dev, bitrate_data);
+}
+#include <syscalls/can_set_bitrate_data_mrsh.c>
+
#endif /* CONFIG_CAN_FD_MODE */
static inline int z_vrfy_can_get_max_filters(const struct device *dev, enum can_ide id_type)
@@ -132,12 +146,11 @@
}
#include <syscalls/can_set_mode_mrsh.c>
-static inline int z_vrfy_can_set_bitrate(const struct device *dev, uint32_t bitrate,
- uint32_t bitrate_data)
+static inline int z_vrfy_can_set_bitrate(const struct device *dev, uint32_t bitrate)
{
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, set_timing));
- return z_impl_can_set_bitrate(dev, bitrate, bitrate_data);
+ return z_impl_can_set_bitrate(dev, bitrate);
}
#include <syscalls/can_set_bitrate_mrsh.c>
diff --git a/drivers/can/can_loopback.c b/drivers/can/can_loopback.c
index 42539cc..e93b074 100644
--- a/drivers/can/can_loopback.c
+++ b/drivers/can/can_loopback.c
@@ -206,12 +206,11 @@
}
static int can_loopback_set_timing(const struct device *dev,
- const struct can_timing *timing,
- const struct can_timing *timing_data)
+ const struct can_timing *timing)
{
ARG_UNUSED(dev);
ARG_UNUSED(timing);
- ARG_UNUSED(timing_data);
+
return 0;
}
diff --git a/drivers/can/can_mcan.c b/drivers/can/can_mcan.c
index a5c3c54..063cc74 100644
--- a/drivers/can/can_mcan.c
+++ b/drivers/can/can_mcan.c
@@ -185,7 +185,34 @@
}
int can_mcan_set_timing(const struct device *dev,
- const struct can_timing *timing,
+ const struct can_timing *timing)
+{
+ const struct can_mcan_config *cfg = dev->config;
+ struct can_mcan_reg *can = cfg->can;
+ int ret;
+
+ ret = can_enter_init_mode(can, K_MSEC(CAN_INIT_TIMEOUT));
+ if (ret) {
+ LOG_ERR("Failed to enter init mode");
+ return -EIO;
+ }
+
+ /* Configuration Change Enable */
+ can->cccr |= CAN_MCAN_CCCR_CCE;
+
+ can_mcan_configure_timing(can, timing, NULL);
+
+ ret = can_leave_init_mode(can, K_MSEC(CAN_INIT_TIMEOUT));
+ if (ret) {
+ LOG_ERR("Failed to leave init mode");
+ return -EIO;
+ }
+
+ return 0;
+}
+
+#ifdef CONFIG_CAN_FD_MODE
+int can_mcan_set_timing_data(const struct device *dev,
const struct can_timing *timing_data)
{
const struct can_mcan_config *cfg = dev->config;
@@ -201,7 +228,7 @@
/* Configuration Change Enable */
can->cccr |= CAN_MCAN_CCCR_CCE;
- can_mcan_configure_timing(can, timing, timing_data);
+ can_mcan_configure_timing(can, NULL, timing_data);
ret = can_leave_init_mode(can, K_MSEC(CAN_INIT_TIMEOUT));
if (ret) {
@@ -211,6 +238,7 @@
return 0;
}
+#endif /* CONFIG_CAN_FD_MODE */
int can_mcan_set_mode(const struct device *dev, enum can_mode mode)
{
diff --git a/drivers/can/can_mcan.h b/drivers/can/can_mcan.h
index c723a7b..f83fb62 100644
--- a/drivers/can/can_mcan.h
+++ b/drivers/can/can_mcan.h
@@ -260,8 +260,10 @@
int can_mcan_set_mode(const struct device *dev, enum can_mode mode);
int can_mcan_set_timing(const struct device *dev,
- const struct can_timing *timing,
- const struct can_timing *timing_data);
+ const struct can_timing *timing);
+
+int can_mcan_set_timing_data(const struct device *dev,
+ const struct can_timing *timing_data);
int can_mcan_init(const struct device *dev);
diff --git a/drivers/can/can_mcp2515.c b/drivers/can/can_mcp2515.c
index 6bf9a02..3130a02 100644
--- a/drivers/can/can_mcp2515.c
+++ b/drivers/can/can_mcp2515.c
@@ -330,10 +330,8 @@
}
static int mcp2515_set_timing(const struct device *dev,
- const struct can_timing *timing,
- const struct can_timing *timing_data)
+ const struct can_timing *timing)
{
- ARG_UNUSED(timing_data);
struct mcp2515_data *dev_data = dev->data;
int ret;
@@ -949,7 +947,7 @@
}
}
- ret = can_set_timing(dev, &timing, NULL);
+ ret = can_set_timing(dev, &timing);
if (ret) {
return ret;
}
diff --git a/drivers/can/can_mcux_flexcan.c b/drivers/can/can_mcux_flexcan.c
index 517d4d2..1dc2a93 100644
--- a/drivers/can/can_mcux_flexcan.c
+++ b/drivers/can/can_mcux_flexcan.c
@@ -152,10 +152,8 @@
}
static int mcux_flexcan_set_timing(const struct device *dev,
- const struct can_timing *timing,
- const struct can_timing *timing_data)
+ const struct can_timing *timing)
{
- ARG_UNUSED(timing_data);
struct mcux_flexcan_data *data = dev->data;
const struct mcux_flexcan_config *config = dev->config;
uint8_t sjw_backup = data->timing.sjw;
diff --git a/drivers/can/can_mcux_mcan.c b/drivers/can/can_mcux_mcan.c
index 04b54dd..1330a9b 100644
--- a/drivers/can/can_mcux_mcan.c
+++ b/drivers/can/can_mcux_mcan.c
@@ -94,6 +94,7 @@
.prescaler = 512,
},
#ifdef CONFIG_CAN_FD_MODE
+ .set_timing_data = can_mcan_set_timing_data,
/*
* MCUX MCAN data timing limits are specified in the "Data bit timing
* and prescaler register (DBTP)" table in the SoC reference manual.
diff --git a/drivers/can/can_rcar.c b/drivers/can/can_rcar.c
index 7cce11e..a9c27fe 100644
--- a/drivers/can/can_rcar.c
+++ b/drivers/can/can_rcar.c
@@ -648,15 +648,12 @@
}
static int can_rcar_set_timing(const struct device *dev,
- const struct can_timing *timing,
- const struct can_timing *timing_data)
+ const struct can_timing *timing)
{
const struct can_rcar_cfg *config = dev->config;
struct can_rcar_data *data = dev->data;
int ret = 0;
- ARG_UNUSED(timing_data);
-
k_mutex_lock(&data->inst_mutex, K_FOREVER);
/* Changing bittiming should be done in reset mode */
@@ -955,7 +952,7 @@
}
}
- ret = can_rcar_set_timing(dev, &timing, NULL);
+ ret = can_rcar_set_timing(dev, &timing);
if (ret) {
return ret;
}
diff --git a/drivers/can/can_sam.c b/drivers/can/can_sam.c
index 56aef49..6d94242 100644
--- a/drivers/can/can_sam.c
+++ b/drivers/can/can_sam.c
@@ -98,6 +98,7 @@
.prescaler = 0x200
},
#ifdef CONFIG_CAN_FD_MODE
+ .set_timing_data = can_mcan_set_timing_data,
.timing_min_data = {
.sjw = 0x01,
.prop_seg = 0x00,
diff --git a/drivers/can/can_shell.c b/drivers/can/can_shell.c
index feebb6a..289955f 100644
--- a/drivers/can/can_shell.c
+++ b/drivers/can/can_shell.c
@@ -272,7 +272,7 @@
return -EINVAL;
}
- ret = can_set_bitrate(can_dev, bitrate, 0);
+ ret = can_set_bitrate(can_dev, bitrate);
if (ret) {
shell_error(sh, "Failed to set bitrate [%d]",
ret);
diff --git a/drivers/can/can_stm32.c b/drivers/can/can_stm32.c
index 08ff814..50b80c3 100644
--- a/drivers/can/can_stm32.c
+++ b/drivers/can/can_stm32.c
@@ -402,16 +402,13 @@
}
static int can_stm32_set_timing(const struct device *dev,
- const struct can_timing *timing,
- const struct can_timing *timing_data)
+ const struct can_timing *timing)
{
const struct can_stm32_config *cfg = dev->config;
CAN_TypeDef *can = cfg->can;
struct can_stm32_data *data = dev->data;
int ret = -EIO;
- ARG_UNUSED(timing_data);
-
k_mutex_lock(&data->inst_mutex, K_FOREVER);
ret = can_enter_init_mode(can);
if (ret) {
@@ -566,7 +563,7 @@
}
}
- ret = can_stm32_set_timing(dev, &timing, NULL);
+ ret = can_stm32_set_timing(dev, &timing);
if (ret) {
return ret;
}
diff --git a/drivers/can/can_stm32fd.c b/drivers/can/can_stm32fd.c
index 7bd9c02..6401eef 100644
--- a/drivers/can/can_stm32fd.c
+++ b/drivers/can/can_stm32fd.c
@@ -137,6 +137,7 @@
.prescaler = 0x200
},
#ifdef CONFIG_CAN_FD_MODE
+ .set_timing_data = can_mcan_set_timing_data,
.timing_min_data = {
.sjw = 0x01,
.prop_seg = 0x00,
diff --git a/drivers/can/can_stm32h7.c b/drivers/can/can_stm32h7.c
index 1171850..ab06af0 100644
--- a/drivers/can/can_stm32h7.c
+++ b/drivers/can/can_stm32h7.c
@@ -127,6 +127,7 @@
.prescaler = 0x200
},
#ifdef CONFIG_CAN_FD_MODE
+ .set_timing_data = can_mcan_set_timing_data,
/* Data timing limits are per the STM32H7 Reference Manual
* (RM0433 Rev 7), section 56.5.3, FDCAN data bit timing and prescaler
* register (FDCAN_DBTP).
diff --git a/include/zephyr/drivers/can.h b/include/zephyr/drivers/can.h
index 21e586c..ca384a9 100644
--- a/include/zephyr/drivers/can.h
+++ b/include/zephyr/drivers/can.h
@@ -297,8 +297,14 @@
* See @a can_set_timing() for argument description
*/
typedef int (*can_set_timing_t)(const struct device *dev,
- const struct can_timing *timing,
- const struct can_timing *timing_data);
+ const struct can_timing *timing);
+
+/**
+ * @brief Callback API upon setting CAN bus timing for the data phase.
+ * See @a can_set_timing_data() for argument description
+ */
+typedef int (*can_set_timing_data_t)(const struct device *dev,
+ const struct can_timing *timing_data);
/**
* @brief Callback API upon setting CAN controller mode
@@ -388,6 +394,7 @@
/* Max values for the timing registers */
struct can_timing timing_max;
#if defined(CONFIG_CAN_FD_MODE) || defined(__DOXYGEN__)
+ can_set_timing_data_t set_timing_data;
/* Min values for the timing registers during the data phase */
struct can_timing timing_min_data;
/* Max values for the timing registers during the data phase */
@@ -769,6 +776,60 @@
__syscall int can_calc_timing_data(const struct device *dev, struct can_timing *res,
uint32_t bitrate, uint16_t sample_pnt);
+/**
+ * @brief Configure the bus timing for the data phase of a CAN-FD controller.
+ *
+ * If the sjw equals CAN_SJW_NO_CHANGE, the sjw parameter is not changed.
+ *
+ * @note @kconfig{CONFIG_CAN_FD_MODE} must be selected for this function to be
+ * available.
+ *
+ * @see can_set_timing()
+ *
+ * @param dev Pointer to the device structure for the driver instance.
+ * @param timing_data Bus timings for data phase
+ *
+ * @retval 0 If successful.
+ * @retval -EIO General input/output error, failed to configure device.
+ */
+__syscall int can_set_timing_data(const struct device *dev,
+ const struct can_timing *timing_data);
+
+static inline int z_impl_can_set_timing_data(const struct device *dev,
+ const struct can_timing *timing_data)
+{
+ const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
+
+ return api->set_timing_data(dev, timing_data);
+}
+
+/**
+ * @brief Set the bitrate for the data phase of the CAN-FD controller
+ *
+ * CAN in Automation (CiA) 301 v4.2.0 recommends a sample point location of
+ * 87.5% percent for all bitrates. However, some CAN controllers have
+ * difficulties meeting this for higher bitrates.
+ *
+ * This function defaults to using a sample point of 75.0% for bitrates over 800
+ * kbit/s, 80.0% for bitrates over 500 kbit/s, and 87.5% for all other
+ * bitrates. This is in line with the sample point locations used by the Linux
+ * kernel.
+ *
+ * @note @kconfig{CONFIG_CAN_FD_MODE} must be selected for this function to be
+ * available.
+ *
+ * @see can_set_bitrate()
+
+ * @param dev Pointer to the device structure for the driver instance.
+ * @param bitrate_data Desired data phase bitrate.
+ *
+ * @retval 0 If successful.
+ * @retval -ENOTSUP bitrate not supported by CAN controller/transceiver combination
+ * @retval -EINVAL bitrate/sample point cannot be met.
+ * @retval -EIO General input/output error, failed to set bitrate.
+ */
+__syscall int can_set_bitrate_data(const struct device *dev, uint32_t bitrate_data);
+
#endif /* CONFIG_CAN_FD_MODE */
/**
@@ -800,28 +861,23 @@
*
* If the sjw equals CAN_SJW_NO_CHANGE, the sjw parameter is not changed.
*
- * @note The parameter ``timing_data`` is only relevant for CAN-FD. If the
- * controller does not support CAN-FD or if @kconfig{CONFIG_CAN_FD_MODE} is not
- * selected, the value of this parameter is ignored.
+ * @see can_set_timing_data()
*
* @param dev Pointer to the device structure for the driver instance.
* @param timing Bus timings.
- * @param timing_data Bus timings for data phase (CAN-FD only).
*
* @retval 0 If successful.
* @retval -EIO General input/output error, failed to configure device.
*/
__syscall int can_set_timing(const struct device *dev,
- const struct can_timing *timing,
- const struct can_timing *timing_data);
+ const struct can_timing *timing);
static inline int z_impl_can_set_timing(const struct device *dev,
- const struct can_timing *timing,
- const struct can_timing *timing_data)
+ const struct can_timing *timing)
{
const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
- return api->set_timing(dev, timing, timing_data);
+ return api->set_timing(dev, timing);
}
/**
@@ -854,20 +910,17 @@
* bitrates. This is in line with the sample point locations used by the Linux
* kernel.
*
- * @note The parameter ``bitrate_data`` is only relevant for CAN-FD. If the
- * controller does not support CAN-FD or if @kconfig{CONFIG_CAN_FD_MODE} is not
- * selected, the value of this parameter is ignored.
-
+ * @see can_set_bitrate_data()
+ *
* @param dev Pointer to the device structure for the driver instance.
* @param bitrate Desired arbitration phase bitrate.
- * @param bitrate_data Desired data phase bitrate.
*
* @retval 0 If successful.
* @retval -ENOTSUP bitrate not supported by CAN controller/transceiver combination
* @retval -EINVAL bitrate/sample point cannot be met.
* @retval -EIO General input/output error, failed to set bitrate.
*/
-__syscall int can_set_bitrate(const struct device *dev, uint32_t bitrate, uint32_t bitrate_data);
+__syscall int can_set_bitrate(const struct device *dev, uint32_t bitrate);
/** @} */
diff --git a/modules/canopennode/CO_driver.c b/modules/canopennode/CO_driver.c
index 6fab0aa..ba21ec1 100644
--- a/modules/canopennode/CO_driver.c
+++ b/modules/canopennode/CO_driver.c
@@ -223,7 +223,7 @@
txArray[i].bufferFull = false;
}
- err = can_set_bitrate(CANmodule->dev, KHZ(CANbitRate), 0);
+ err = can_set_bitrate(CANmodule->dev, KHZ(CANbitRate));
if (err) {
LOG_ERR("failed to configure CAN bitrate (err %d)", err);
return CO_ERROR_ILLEGAL_ARGUMENT;
diff --git a/tests/drivers/can/api/src/main.c b/tests/drivers/can/api/src/main.c
index e607aeb..05901ac 100644
--- a/tests/drivers/can/api/src/main.c
+++ b/tests/drivers/can/api/src/main.c
@@ -636,7 +636,7 @@
zassert_equal(err, 0, "failed to get max bitrate (err %d)", err);
zassert_not_equal(max, 0, "max bitrate is 0");
- err = can_set_bitrate(can_dev, max + 1, max + 1);
+ err = can_set_bitrate(can_dev, max + 1);
zassert_equal(err, -ENOTSUP, "too high bitrate accepted");
}
@@ -647,7 +647,7 @@
{
int err;
- err = can_set_bitrate(can_dev, TEST_BITRATE_1, 0);
+ err = can_set_bitrate(can_dev, TEST_BITRATE_1);
zassert_equal(err, 0, "failed to set bitrate");
}
@@ -981,10 +981,10 @@
zassert_equal(err, 0, "receive timeout");
assert_frame_equal(&frame, &test_std_frame_1, 0);
- err = can_set_bitrate(can_dev, TEST_BITRATE_2, 0);
+ err = can_set_bitrate(can_dev, TEST_BITRATE_2);
zassert_equal(err, 0, "failed to set bitrate");
- err = can_set_bitrate(can_dev, TEST_BITRATE_1, 0);
+ err = can_set_bitrate(can_dev, TEST_BITRATE_1);
zassert_equal(err, 0, "failed to set bitrate");
send_test_frame(can_dev, &test_std_frame_1);
diff --git a/tests/drivers/can/timing/src/main.c b/tests/drivers/can/timing/src/main.c
index a5ed56c..6e13e23 100644
--- a/tests/drivers/can/timing/src/main.c
+++ b/tests/drivers/can/timing/src/main.c
@@ -202,14 +202,10 @@
assert_timing_within_bounds(&timing, min, max);
assert_sp_within_margin(&timing, test->sp, SAMPLE_POINT_MARGIN);
- if (IS_ENABLED(CONFIG_CAN_FD_MODE)) {
- if (data_phase) {
- err = can_set_timing(dev, can_get_timing_min(dev), &timing);
- } else {
- err = can_set_timing(dev, &timing, can_get_timing_min_data(dev));
- }
+ if (IS_ENABLED(CONFIG_CAN_FD_MODE) && data_phase) {
+ err = can_set_timing_data(dev, &timing);
} else {
- err = can_set_timing(dev, &timing, NULL);
+ err = can_set_timing(dev, &timing);
}
zassert_equal(err, 0, "failed to set timing (err %d)", err);
@@ -258,12 +254,13 @@
const struct device *dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_canbus));
int err;
- if (IS_ENABLED(CONFIG_CAN_FD_MODE)) {
- err = can_set_timing(dev, can_get_timing_min(dev), can_get_timing_min_data(dev));
- } else {
- err = can_set_timing(dev, can_get_timing_min(dev), NULL);
- }
+ err = can_set_timing(dev, can_get_timing_min(dev));
zassert_equal(err, 0, "failed to set minimum timing parameters (err %d)", err);
+
+ if (IS_ENABLED(CONFIG_CAN_FD_MODE)) {
+ err = can_set_timing_data(dev, can_get_timing_min_data(dev));
+ zassert_equal(err, 0, "failed to set minimum timing data parameters (err %d)", err);
+ }
}
/**
@@ -274,12 +271,13 @@
const struct device *dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_canbus));
int err;
- if (IS_ENABLED(CONFIG_CAN_FD_MODE)) {
- err = can_set_timing(dev, can_get_timing_max(dev), can_get_timing_max_data(dev));
- } else {
- err = can_set_timing(dev, can_get_timing_max(dev), NULL);
- }
+ err = can_set_timing(dev, can_get_timing_max(dev));
zassert_equal(err, 0, "failed to set maximum timing parameters (err %d)", err);
+
+ if (IS_ENABLED(CONFIG_CAN_FD_MODE)) {
+ err = can_set_timing_data(dev, can_get_timing_max_data(dev));
+ zassert_equal(err, 0, "failed to set maximum timing data parameters (err %d)", err);
+ }
}
void test_main(void)
