From 18890828b8cfc16197df9ce8a19bec728457af18 Mon Sep 17 00:00:00 2001 From: Henrik Brix Andersen Date: Tue, 3 May 2022 22:05:53 +0200 Subject: [PATCH] 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 --- .../peripherals/canbus/controller.rst | 11 ++- drivers/can/can_common.c | 29 +++++-- drivers/can/can_handlers.c | 37 +++++--- drivers/can/can_loopback.c | 5 +- drivers/can/can_mcan.c | 32 ++++++- drivers/can/can_mcan.h | 6 +- drivers/can/can_mcp2515.c | 6 +- drivers/can/can_mcux_flexcan.c | 4 +- drivers/can/can_mcux_mcan.c | 1 + drivers/can/can_rcar.c | 7 +- drivers/can/can_sam.c | 1 + drivers/can/can_shell.c | 2 +- drivers/can/can_stm32.c | 7 +- drivers/can/can_stm32fd.c | 1 + drivers/can/can_stm32h7.c | 1 + include/zephyr/drivers/can.h | 87 +++++++++++++++---- modules/canopennode/CO_driver.c | 2 +- tests/drivers/can/api/src/main.c | 8 +- tests/drivers/can/timing/src/main.c | 32 ++++--- 19 files changed, 189 insertions(+), 90 deletions(-) diff --git a/doc/hardware/peripherals/canbus/controller.rst b/doc/hardware/peripherals/canbus/controller.rst index 5a2894a97c6..afecd056542 100644 --- a/doc/hardware/peripherals/canbus/controller.rst +++ b/doc/hardware/peripherals/canbus/controller.rst @@ -284,11 +284,7 @@ Setting the bitrate ******************* 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 @@ The following example sets the bitrate to 250k baud with the sampling point at 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 bbb494af808..539c6cf09b5 100644 --- a/drivers/can/can_common.c +++ b/drivers/can/can_common.c @@ -207,12 +207,9 @@ uint16_t sample_point_for_bitrate(uint32_t bitrate) 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 @@ int z_impl_can_set_bitrate(const struct device *dev, uint32_t bitrate, uint32_t 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 @@ int z_impl_can_set_bitrate(const struct device *dev, uint32_t bitrate, uint32_t 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 f7882398fdd..922ba34e501 100644 --- a/drivers/can/can_handlers.c +++ b/drivers/can/can_handlers.c @@ -24,21 +24,14 @@ static int z_vrfy_can_calc_timing(const struct device *dev, struct can_timing *r #include 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 @@ -113,6 +106,27 @@ static inline const struct can_timing *z_vrfy_can_get_timing_max_data(const stru } #include +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 + +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 + #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 @@ static inline int z_vrfy_can_set_mode(const struct device *dev, enum can_mode mo } #include -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 diff --git a/drivers/can/can_loopback.c b/drivers/can/can_loopback.c index 42539cc781e..e93b074e8ee 100644 --- a/drivers/can/can_loopback.c +++ b/drivers/can/can_loopback.c @@ -206,12 +206,11 @@ static int can_loopback_set_mode(const struct device *dev, enum can_mode mode) } 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 a5c3c54b1b8..063cc743330 100644 --- a/drivers/can/can_mcan.c +++ b/drivers/can/can_mcan.c @@ -185,7 +185,34 @@ void can_mcan_configure_timing(struct can_mcan_reg *can, } 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 @@ int can_mcan_set_timing(const struct device *dev, /* 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 @@ int can_mcan_set_timing(const struct device *dev, 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 c723a7b78eb..f83fb62d3c8 100644 --- a/drivers/can/can_mcan.h +++ b/drivers/can/can_mcan.h @@ -260,8 +260,10 @@ struct can_mcan_reg; 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 6bf9a0279cd..3130a026a94 100644 --- a/drivers/can/can_mcp2515.c +++ b/drivers/can/can_mcp2515.c @@ -330,10 +330,8 @@ static int mcp2515_get_max_bitrate(const struct device *dev, uint32_t *max_bitra } 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 @@ static int mcp2515_init(const struct device *dev) } } - 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 517d4d277c7..1dc2a9335f7 100644 --- a/drivers/can/can_mcux_flexcan.c +++ b/drivers/can/can_mcux_flexcan.c @@ -152,10 +152,8 @@ static int mcux_flexcan_get_max_bitrate(const struct device *dev, uint32_t *max_ } 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 04b54dd6c76..1330a9b7524 100644 --- a/drivers/can/can_mcux_mcan.c +++ b/drivers/can/can_mcux_mcan.c @@ -94,6 +94,7 @@ static const struct can_driver_api mcux_mcan_driver_api = { .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 7cce11e870a..a9c27fef0f8 100644 --- a/drivers/can/can_rcar.c +++ b/drivers/can/can_rcar.c @@ -648,15 +648,12 @@ static void can_rcar_set_bittiming(const struct can_rcar_cfg *config, } 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 @@ static int can_rcar_init(const struct device *dev) } } - 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 56aef49565d..6d9424287d5 100644 --- a/drivers/can/can_sam.c +++ b/drivers/can/can_sam.c @@ -98,6 +98,7 @@ static const struct can_driver_api can_sam_driver_api = { .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 feebb6a48fe..289955ff311 100644 --- a/drivers/can/can_shell.c +++ b/drivers/can/can_shell.c @@ -272,7 +272,7 @@ static int cmd_config(const struct shell *sh, size_t argc, char **argv) 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 08ff814610a..50b80c31fb4 100644 --- a/drivers/can/can_stm32.c +++ b/drivers/can/can_stm32.c @@ -402,16 +402,13 @@ done: } 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 @@ static int can_stm32_init(const struct device *dev) } } - 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 7bd9c02cdbc..6401eef9bf5 100644 --- a/drivers/can/can_stm32fd.c +++ b/drivers/can/can_stm32fd.c @@ -137,6 +137,7 @@ static const struct can_driver_api can_stm32fd_driver_api = { .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 117185077e5..ab06af018d9 100644 --- a/drivers/can/can_stm32h7.c +++ b/drivers/can/can_stm32h7.c @@ -127,6 +127,7 @@ static const struct can_driver_api can_stm32h7_driver_api = { .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 21e586cf0ea..ca384a90388 100644 --- a/include/zephyr/drivers/can.h +++ b/include/zephyr/drivers/can.h @@ -297,8 +297,14 @@ typedef void (*can_state_change_callback_t)(const struct device *dev, * 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 @@ __subsystem struct can_driver_api { /* 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 @@ static inline const struct can_timing *z_impl_can_get_timing_max_data(const stru __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 @@ int can_calc_prescaler(const struct device *dev, struct can_timing *timing, * * 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 @@ static inline int z_impl_can_set_mode(const struct device *dev, enum can_mode mo * 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 6fab0aa861f..ba21ec1f28e 100644 --- a/modules/canopennode/CO_driver.c +++ b/modules/canopennode/CO_driver.c @@ -223,7 +223,7 @@ CO_ReturnError_t CO_CANmodule_init(CO_CANmodule_t *CANmodule, 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 e607aebe284..05901ac6c16 100644 --- a/tests/drivers/can/api/src/main.c +++ b/tests/drivers/can/api/src/main.c @@ -636,7 +636,7 @@ static void test_set_bitrate_too_high(void) 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 @@ static void test_set_bitrate(void) { 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 @@ static void test_filters_preserved_through_bitrate_change(void) 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 a5ed56c3092..6e13e23bd9a 100644 --- a/tests/drivers/can/timing/src/main.c +++ b/tests/drivers/can/timing/src/main.c @@ -202,14 +202,10 @@ static void test_timing_values(const struct device *dev, const struct can_timing 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 @@ void test_set_timing_min(void) 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 @@ void test_set_timing_max(void) 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)