drivers: can: add can_get_bitrate_{min,max}(), deprecate existing APIs
Since the minimum/maximum supported bitrates are now stored in the common
CAN controller driver configuration struct, retrieving these can no longer
fail.
Add new CAN controller API functions can_get_bitrate_min() and
can_get_bitrate_max() reflecting this and deprecate the existing
can_get_min_bitrate() and can_get_max_bitrate().
Signed-off-by: Henrik Brix Andersen <hebad@vestas.com>
diff --git a/drivers/can/can_common.c b/drivers/can/can_common.c
index cb2e7c3..29397fd 100644
--- a/drivers/can/can_common.c
+++ b/drivers/can/can_common.c
@@ -351,22 +351,12 @@
int z_impl_can_set_bitrate(const struct device *dev, uint32_t bitrate)
{
struct can_timing timing = { 0 };
- uint32_t min_bitrate;
- uint32_t max_bitrate;
+ uint32_t min = can_get_bitrate_min(dev);
+ uint32_t max = can_get_bitrate_max(dev);
uint16_t sample_pnt;
int ret;
- (void)can_get_min_bitrate(dev, &min_bitrate);
-
- ret = can_get_max_bitrate(dev, &max_bitrate);
- if (ret == -ENOSYS) {
- /* Maximum bitrate unknown */
- max_bitrate = 0;
- } else if (ret < 0) {
- return ret;
- }
-
- if ((bitrate < min_bitrate) || (((max_bitrate > 0) && (bitrate > max_bitrate)))) {
+ if ((bitrate < min) || (bitrate > max)) {
return -ENOTSUP;
}
@@ -407,22 +397,12 @@
int z_impl_can_set_bitrate_data(const struct device *dev, uint32_t bitrate_data)
{
struct can_timing timing_data = { 0 };
- uint32_t min_bitrate;
- uint32_t max_bitrate;
+ uint32_t min = can_get_bitrate_min(dev);
+ uint32_t max = can_get_bitrate_max(dev);
uint16_t sample_pnt;
int ret;
- (void)can_get_min_bitrate(dev, &min_bitrate);
-
- ret = can_get_max_bitrate(dev, &max_bitrate);
- if (ret == -ENOSYS) {
- /* Maximum bitrate unknown */
- max_bitrate = 0;
- } else if (ret < 0) {
- return ret;
- }
-
- if ((bitrate_data < min_bitrate) || ((max_bitrate > 0) && (bitrate_data > max_bitrate))) {
+ if ((bitrate_data < min) || (bitrate_data > max)) {
return -ENOTSUP;
}
diff --git a/drivers/can/can_handlers.c b/drivers/can/can_handlers.c
index a7f89d5..b762b80 100644
--- a/drivers/can/can_handlers.c
+++ b/drivers/can/can_handlers.c
@@ -45,25 +45,21 @@
}
#include <syscalls/can_get_core_clock_mrsh.c>
-static inline int z_vrfy_can_get_min_bitrate(const struct device *dev,
- uint32_t *min_bitrate)
+static inline uint32_t z_vrfy_can_get_bitrate_min(const struct device *dev)
{
K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_CAN));
- K_OOPS(K_SYSCALL_MEMORY_WRITE(min_bitrate, sizeof(*min_bitrate)));
- return z_impl_can_get_min_bitrate(dev, min_bitrate);
+ return z_impl_can_get_bitrate_min(dev);
}
-#include <syscalls/can_get_min_bitrate_mrsh.c>
+#include <syscalls/can_get_bitrate_min_mrsh.c>
-static inline int z_vrfy_can_get_max_bitrate(const struct device *dev,
- uint32_t *max_bitrate)
+static inline uint32_t z_vrfy_can_get_bitrate_max(const struct device *dev)
{
K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_CAN));
- K_OOPS(K_SYSCALL_MEMORY_WRITE(max_bitrate, sizeof(*max_bitrate)));
- return z_impl_can_get_max_bitrate(dev, max_bitrate);
+ return z_impl_can_get_bitrate_max(dev);
}
-#include <syscalls/can_get_max_bitrate_mrsh.c>
+#include <syscalls/can_get_bitrate_max_mrsh.c>
static inline const struct can_timing *z_vrfy_can_get_timing_min(const struct device *dev)
{
diff --git a/drivers/can/can_shell.c b/drivers/can/can_shell.c
index 66cb4c1..6c07448 100644
--- a/drivers/can/can_shell.c
+++ b/drivers/can/can_shell.c
@@ -280,9 +280,9 @@
const struct can_timing *timing_max;
struct can_bus_err_cnt err_cnt;
enum can_state state;
- uint32_t max_bitrate = 0;
- int max_std_filters = 0;
- int max_ext_filters = 0;
+ uint32_t bitrate_max;
+ int max_std_filters;
+ int max_ext_filters;
uint32_t core_clock;
can_mode_t cap;
int err;
@@ -298,11 +298,7 @@
return err;
}
- err = can_get_max_bitrate(dev, &max_bitrate);
- if (err != 0 && err != -ENOSYS) {
- shell_error(sh, "failed to get maximum bitrate (err %d)", err);
- return err;
- }
+ bitrate_max = can_get_bitrate_max(dev);
max_std_filters = can_get_max_filters(dev, false);
if (max_std_filters < 0 && max_std_filters != -ENOSYS) {
@@ -329,7 +325,7 @@
}
shell_print(sh, "core clock: %d Hz", core_clock);
- shell_print(sh, "max bitrate: %d bps", max_bitrate);
+ shell_print(sh, "max bitrate: %d bps", bitrate_max);
shell_print(sh, "max std filters: %d", max_std_filters);
shell_print(sh, "max ext filters: %d", max_ext_filters);
diff --git a/include/zephyr/drivers/can.h b/include/zephyr/drivers/can.h
index 9b589e9..1171bd8 100644
--- a/include/zephyr/drivers/can.h
+++ b/include/zephyr/drivers/can.h
@@ -840,18 +840,33 @@
* Get the minimum supported bitrate for the CAN controller/transceiver combination.
*
* @param dev Pointer to the device structure for the driver instance.
+ * @return Minimum supported bitrate in bits/s
+ */
+__syscall uint32_t can_get_bitrate_min(const struct device *dev);
+
+static inline uint32_t z_impl_can_get_bitrate_min(const struct device *dev)
+{
+ const struct can_driver_config *common = (const struct can_driver_config *)dev->config;
+
+ return common->min_bitrate;
+}
+
+/**
+ * @brief Get minimum supported bitrate
+ *
+ * Get the minimum supported bitrate for the CAN controller/transceiver combination.
+ *
+ * @deprecated Use @a can_get_bitrate_min() instead.
+ *
+ * @param dev Pointer to the device structure for the driver instance.
* @param[out] min_bitrate Minimum supported bitrate in bits/s
*
* @retval -EIO General input/output error.
* @retval -ENOSYS If this function is not implemented by the driver.
*/
-__syscall int can_get_min_bitrate(const struct device *dev, uint32_t *min_bitrate);
-
-static inline int z_impl_can_get_min_bitrate(const struct device *dev, uint32_t *min_bitrate)
+__deprecated static inline int can_get_min_bitrate(const struct device *dev, uint32_t *min_bitrate)
{
- const struct can_driver_config *common = (const struct can_driver_config *)dev->config;
-
- *min_bitrate = common->min_bitrate;
+ *min_bitrate = can_get_bitrate_min(dev);
return 0;
}
@@ -862,23 +877,34 @@
* Get the maximum supported bitrate for the CAN controller/transceiver combination.
*
* @param dev Pointer to the device structure for the driver instance.
+ * @return Maximum supported bitrate in bits/s
+ */
+__syscall uint32_t can_get_bitrate_max(const struct device *dev);
+
+static inline uint32_t z_impl_can_get_bitrate_max(const struct device *dev)
+{
+ const struct can_driver_config *common = (const struct can_driver_config *)dev->config;
+
+ return common->max_bitrate;
+}
+
+/**
+ * @brief Get maximum supported bitrate
+ *
+ * Get the maximum supported bitrate for the CAN controller/transceiver combination.
+ *
+ * @deprecated Use @a can_get_bitrate_max() instead.
+ *
+ * @param dev Pointer to the device structure for the driver instance.
* @param[out] max_bitrate Maximum supported bitrate in bits/s
*
* @retval 0 If successful.
* @retval -EIO General input/output error.
* @retval -ENOSYS If this function is not implemented by the driver.
*/
-__syscall int can_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate);
-
-static inline int z_impl_can_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate)
+__deprecated static inline int can_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate)
{
- const struct can_driver_config *common = (const struct can_driver_config *)dev->config;
-
- if (common->max_bitrate == 0U) {
- return -ENOSYS;
- }
-
- *max_bitrate = common->max_bitrate;
+ *max_bitrate = can_get_bitrate_max(dev);
return 0;
}
diff --git a/tests/drivers/can/api/src/canfd.c b/tests/drivers/can/api/src/canfd.c
index ec881b0..2059c02 100644
--- a/tests/drivers/can/api/src/canfd.c
+++ b/tests/drivers/can/api/src/canfd.c
@@ -397,22 +397,14 @@
*/
ZTEST_USER(canfd, test_set_bitrate_too_high)
{
- uint32_t max = 8000000U;
- int expected = -EINVAL;
+ uint32_t max = can_get_bitrate_max(can_dev);
int err;
- err = can_get_max_bitrate(can_dev, &max);
- if (err != -ENOSYS) {
- zassert_equal(err, 0, "failed to get max bitrate (err %d)", err);
- zassert_not_equal(max, 0, "max bitrate is 0");
- expected = -ENOTSUP;
- }
-
err = can_stop(can_dev);
zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
err = can_set_bitrate_data(can_dev, max + 1);
- zassert_equal(err, expected, "too high data phase bitrate accepted");
+ zassert_equal(err, -ENOTSUP, "too high data phase bitrate accepted");
err = can_start(can_dev);
zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
diff --git a/tests/drivers/can/api/src/classic.c b/tests/drivers/can/api/src/classic.c
index c59e346..0b99f9a 100644
--- a/tests/drivers/can/api/src/classic.c
+++ b/tests/drivers/can/api/src/classic.c
@@ -480,19 +480,8 @@
*/
ZTEST_USER(can_classic, test_bitrate_limits)
{
- uint32_t min = 0U;
- uint32_t max = 0U;
- int err;
-
- err = can_get_min_bitrate(can_dev, &min);
- zassert_equal(err, 0, "failed to get min bitrate (err %d)", err);
-
- err = can_get_max_bitrate(can_dev, &max);
- if (err == -ENOSYS) {
- ztest_test_skip();
- }
-
- zassert_equal(err, 0, "failed to get max bitrate (err %d)", err);
+ uint32_t min = can_get_bitrate_min(can_dev);
+ uint32_t max = can_get_bitrate_max(can_dev);
zassert_true(min <= max, "min bitrate must be lower or equal to max bitrate");
}
@@ -502,22 +491,14 @@
*/
ZTEST_USER(can_classic, test_set_bitrate_too_high)
{
- uint32_t max = 1000000U;
- int expected = -EINVAL;
+ uint32_t max = can_get_bitrate_max(can_dev);
int err;
- err = can_get_max_bitrate(can_dev, &max);
- if (err != -ENOSYS) {
- zassert_equal(err, 0, "failed to get max bitrate (err %d)", err);
- zassert_not_equal(max, 0, "max bitrate is 0");
- expected = -ENOTSUP;
- }
-
err = can_stop(can_dev);
zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
err = can_set_bitrate(can_dev, max + 1);
- zassert_equal(err, expected, "too high bitrate accepted");
+ zassert_equal(err, -ENOTSUP, "too high bitrate accepted");
err = can_start(can_dev);
zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
