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);