diff --git a/boards/nxp/mr_canhubk3/doc/index.rst b/boards/nxp/mr_canhubk3/doc/index.rst
index 570a2157c6308..1c5a5e6a06deb 100644
--- a/boards/nxp/mr_canhubk3/doc/index.rst
+++ b/boards/nxp/mr_canhubk3/doc/index.rst
@@ -143,11 +143,11 @@ flexcan5         | PTC11  | PTC11_CAN0_RX  P22/P23
    and support maximum 32 message buffers for concurrent active instances with 8 bytes
    payload. We need to pay attention to configuration options:
 
-   1. :kconfig:option:`CONFIG_CAN_MAX_MB` must be less or equal than the
+   1. :kconfig:option:`CONFIG_CAN_MCUX_FLEXCAN_MAX_MB` must be less or equal than the
       maximum number of message buffers that is according to the table below.
 
-   2. :kconfig:option:`CONFIG_CAN_MAX_FILTER` must be less or equal than
-      :kconfig:option:`CONFIG_CAN_MAX_MB`.
+   2. :kconfig:option:`CONFIG_CAN_MCUX_FLEXCAN_MAX_FILTERS` must be less or equal than
+      :kconfig:option:`CONFIG_CAN_MCUX_FLEXCAN_MAX_MB`.
 
 ===============  ==========  ================  ================
 Devicetree node  Payload     Hardware support  Software support
diff --git a/doc/releases/migration-guide-4.4.rst b/doc/releases/migration-guide-4.4.rst
index fff4a17ab0b7d..08b6a720df8c5 100644
--- a/doc/releases/migration-guide-4.4.rst
+++ b/doc/releases/migration-guide-4.4.rst
@@ -39,6 +39,31 @@ Device Drivers and Devicetree
 
 .. zephyr-keep-sorted-start re(^\w)
 
+Controller Area Network (CAN)
+=============================
+
+* Removed ``CONFIG_CAN_MAX_FILTER``, ``CONFIG_CAN_MAX_STD_ID_FILTER``,
+  ``CONFIG_CAN_MAX_EXT_ID_FILTER``, and ``CONFIG_CAN_MAX_MB`` (:github:`100596`). These are replaced
+  by the following driver-specific Kconfig symbols, some of which have had their default value
+  increased to meet typical software needs:
+
+  * :kconfig:option:`CONFIG_CAN_LOOPBACK_MAX_FILTERS` for :dtcompatible:`zephyr,can-loopback`
+  * :kconfig:option:`CONFIG_CAN_MAX32_MAX_FILTERS` for :dtcompatible:`adi,max32-can`
+  * :kconfig:option:`CONFIG_CAN_MCP2515_MAX_FILTERS` for :dtcompatible:`microchip,mcp2515`
+  * :kconfig:option:`CONFIG_CAN_MCP251XFD_MAX_FILTERS` for :dtcompatible:`microchip,mcp251xfd`
+  * :kconfig:option:`CONFIG_CAN_MCUX_FLEXCAN_MAX_FILTERS` for :dtcompatible:`nxp,flexcan`
+  * :kconfig:option:`CONFIG_CAN_MCUX_FLEXCAN_MAX_MB` for :dtcompatible:`nxp,flexcan`
+  * :kconfig:option:`CONFIG_CAN_NATIVE_LINUX_MAX_FILTERS` for
+    :dtcompatible:`zephyr,native-linux-can`
+  * :kconfig:option:`CONFIG_CAN_RCAR_MAX_FILTERS` for :dtcompatible:`renesas,rcar-can`
+  * :kconfig:option:`CONFIG_CAN_SJA1000_MAX_FILTERS` for :dtcompatible:`kvaser,pcican` and
+    :dtcompatible:`espressif,esp32-twai`
+  * :kconfig:option:`CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS` for :dtcompatible:`st,stm32-bxcan`
+  * :kconfig:option:`CONFIG_CAN_STM32_BXCAN_MAX_STD_ID_FILTERS` for :dtcompatible:`st,stm32-bxcan`
+  * :kconfig:option:`CONFIG_CAN_STM32_FDCAN_MAX_EXT_ID_FILTERS` for :dtcompatible:`st,stm32-fdcan`
+  * :kconfig:option:`CONFIG_CAN_STM32_FDCAN_MAX_STD_ID_FILTERS` for :dtcompatible:`st,stm32-fdcan`
+  * :kconfig:option:`CONFIG_CAN_XMC4XXX_MAX_FILTERS` for :dtcompatible:`infineon,xmc4xxx-can-node`
+
 Ethernet
 ========
 
diff --git a/drivers/can/Kconfig.loopback b/drivers/can/Kconfig.loopback
index fd0d7731ef830..8c1d8149c817c 100644
--- a/drivers/can/Kconfig.loopback
+++ b/drivers/can/Kconfig.loopback
@@ -12,7 +12,7 @@ config CAN_LOOPBACK
 
 if CAN_LOOPBACK
 
-config CAN_MAX_FILTER
+config CAN_LOOPBACK_MAX_FILTERS
 	int "Maximum number of concurrent active filters"
 	default 16
 	range 1 1024
diff --git a/drivers/can/Kconfig.max32 b/drivers/can/Kconfig.max32
index e3be7c17b1d51..5beb8c95f36f8 100644
--- a/drivers/can/Kconfig.max32
+++ b/drivers/can/Kconfig.max32
@@ -11,9 +11,9 @@ config CAN_MAX32
 
 if CAN_MAX32
 
-config CAN_MAX_FILTER
+config CAN_MAX32_MAX_FILTERS
 	int "Maximum number of concurrent active filters"
-	default 5
+	default 16
 	range 1 32
 	help
 	  Maximum number of filters supported by the can_add_rx_callback() API call.
diff --git a/drivers/can/Kconfig.mcp2515 b/drivers/can/Kconfig.mcp2515
index 56eb9506d7a84..b14f841780a2d 100644
--- a/drivers/can/Kconfig.mcp2515
+++ b/drivers/can/Kconfig.mcp2515
@@ -27,9 +27,9 @@ config CAN_MCP2515_INT_THREAD_PRIO
 	  Priority level of the internal thread which is ran for
 	  interrupt handling and incoming packets.
 
-config CAN_MAX_FILTER
+config CAN_MCP2515_MAX_FILTERS
 	int "Maximum number of concurrent active filters"
-	default 5
+	default 16
 	range 1 32
 	help
 	  Defines the array size of the callback/msgq pointers.
diff --git a/drivers/can/Kconfig.mcp251xfd b/drivers/can/Kconfig.mcp251xfd
index 128becf8e95b6..f924c7b40735a 100644
--- a/drivers/can/Kconfig.mcp251xfd
+++ b/drivers/can/Kconfig.mcp251xfd
@@ -51,9 +51,9 @@ config CAN_MCP251XFD_READ_CRC_RETRIES
 	help
 	  Number of retries during SFR register read if CRC fails.
 
-config CAN_MAX_FILTER
+config CAN_MCP251XFD_MAX_FILTERS
 	int "Maximum number of concurrent active filters"
-	default 5
+	default 16
 	range 1 32
 	help
 	  Maximum number of filters supported by the can_add_rx_callback() API call.
diff --git a/drivers/can/Kconfig.mcux b/drivers/can/Kconfig.mcux
index e2ee5a8d27d8f..723cd6108545a 100644
--- a/drivers/can/Kconfig.mcux
+++ b/drivers/can/Kconfig.mcux
@@ -28,7 +28,7 @@ config CAN_MCUX_FLEXCAN_WAIT_TIMEOUT
 	  Maximum number of wait loop iterations for the MCUX FlexCAN HAL when entering/leaving
 	  freeze mode.
 
-config CAN_MAX_MB
+config CAN_MCUX_FLEXCAN_MAX_MB
 	int "Maximum number of message buffers for concurrent active instances"
 	default 16
 	depends on SOC_SERIES_S32K3 || SOC_SERIES_S32K1 || SOC_SERIES_S32ZE
@@ -39,9 +39,9 @@ config CAN_MAX_MB
 	help
 	  Defines maximum number of message buffers for concurrent active instances.
 
-config CAN_MAX_FILTER
+config CAN_MCUX_FLEXCAN_MAX_FILTERS
 	int "Maximum number of concurrent active RX filters"
-	default 5
+	default 13
 	range 1 15 if SOC_SERIES_KINETIS_KE1XF || SOC_SERIES_KINETIS_K6X
 	range 1 13 if (SOC_SERIES_IMXRT10XX || SOC_SERIES_IMXRT11XX) && CAN_MCUX_FLEXCAN_FD
 	range 1 63 if SOC_SERIES_IMXRT10XX || SOC_SERIES_IMXRT11XX
diff --git a/drivers/can/Kconfig.native_linux b/drivers/can/Kconfig.native_linux
index 54969fd7de11f..1de766bb8f2d0 100644
--- a/drivers/can/Kconfig.native_linux
+++ b/drivers/can/Kconfig.native_linux
@@ -20,9 +20,9 @@ config CAN_NATIVE_LINUX_RX_THREAD_PRIORITY
 	  Priority level of the internal thread which is run for
 	  handling of incoming packets.
 
-config CAN_MAX_FILTER
+config CAN_NATIVE_LINUX_MAX_FILTERS
 	int "Maximum number of concurrent active filters"
-	default 5
+	default 16
 	range 1 32
 	help
 	  Defines the array size of the callback/msgq pointers.
diff --git a/drivers/can/Kconfig.rcar b/drivers/can/Kconfig.rcar
index 7ae2e1e927ea2..f1392a45562f5 100644
--- a/drivers/can/Kconfig.rcar
+++ b/drivers/can/Kconfig.rcar
@@ -11,10 +11,10 @@ config CAN_RCAR
 	help
 	  Enable Renesas R-Car CAN Driver.
 
-config CAN_RCAR_MAX_FILTER
+config CAN_RCAR_MAX_FILTERS
 	int "Maximum number of concurrent active filters"
 	depends on CAN_RCAR
-	default 5
+	default 16
 	range 1 32
 	help
 	  Defines the array size of the callback/msgq pointers.
diff --git a/drivers/can/Kconfig.sja1000 b/drivers/can/Kconfig.sja1000
index 97ca0ba20990c..ce253479b203b 100644
--- a/drivers/can/Kconfig.sja1000
+++ b/drivers/can/Kconfig.sja1000
@@ -8,10 +8,10 @@ config CAN_SJA1000
 	help
 	  This enables support for the shared NXP SJA1000 CAN driver.
 
-config CAN_MAX_FILTER
+config CAN_SJA1000_MAX_FILTERS
 	int "Maximum number of concurrent active RX filters"
 	depends on CAN_SJA1000
-	default 5
+	default 16
 	range 1 32
 	help
 	  As the NXP SJA1000 only supports one full-width RX filter, filtering of received CAN
diff --git a/drivers/can/Kconfig.stm32 b/drivers/can/Kconfig.stm32
index 7a9bfae3a731f..4fa75466d3732 100644
--- a/drivers/can/Kconfig.stm32
+++ b/drivers/can/Kconfig.stm32
@@ -14,7 +14,7 @@ config CAN_STM32_BXCAN
 
 if CAN_STM32_BXCAN
 
-config CAN_MAX_STD_ID_FILTER
+config CAN_STM32_BXCAN_MAX_STD_ID_FILTERS
 	int "Maximum number of standard (11-bit) ID filters"
 	default 14
 	range 0 28
@@ -28,9 +28,9 @@ config CAN_MAX_STD_ID_FILTER
 	  The following equation determines the maximum total number of
 	  filters:
 
-	    CAN_MAX_STD_ID_FILTER + CAN_MAX_EXT_ID_FILTER * 2 <= 28
+	  CAN_STM32_BXCAN_MAX_STD_ID_FILTERS + CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS * 2 <= 28
 
-config CAN_MAX_EXT_ID_FILTER
+config CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS
 	int "Maximum number of extended (29-bit) ID filters"
 	default 7
 	range 0 14
@@ -44,7 +44,7 @@ config CAN_MAX_EXT_ID_FILTER
 	  The following equation determines the maximum total number of
 	  filters:
 
-	    CAN_MAX_STD_ID_FILTER + CAN_MAX_EXT_ID_FILTER * 2 <= 28
+	  CAN_STM32_BXCAN_MAX_STD_ID_FILTERS + CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS * 2 <= 28
 
 endif # CAN_STM32_BXCAN
 
@@ -57,7 +57,7 @@ config CAN_STM32_FDCAN
 
 if CAN_STM32_FDCAN
 
-config CAN_MAX_STD_ID_FILTER
+config CAN_STM32_FDCAN_MAX_STD_ID_FILTERS
 	int "Maximum number of standard (11-bit) ID filters"
 	default 28
 	range 0 28
@@ -65,7 +65,7 @@ config CAN_MAX_STD_ID_FILTER
 	  Defines the maximum number of filters with standard ID (11-bit)
 	  that can be added by the application.
 
-config CAN_MAX_EXT_ID_FILTER
+config CAN_STM32_FDCAN_MAX_EXT_ID_FILTERS
 	int "Maximum number of extended (29-bit) ID filters"
 	default 8
 	range 0 8
diff --git a/drivers/can/Kconfig.xmc4xxx b/drivers/can/Kconfig.xmc4xxx
index 39fbc34a7cc5d..3f65f1edf307b 100644
--- a/drivers/can/Kconfig.xmc4xxx
+++ b/drivers/can/Kconfig.xmc4xxx
@@ -35,9 +35,9 @@ config CAN_XMC4XXX_INTERNAL_BUS_MODE
 	  Connects all XMC4XXX CAN devices to an internal bus. Enables
 	  message exchange between MCU CAN devices without any external connectors.
 
-config CAN_MAX_FILTER
+config CAN_XMC4XXX_MAX_FILTERS
 	int "Maximum number of concurrent active filters"
-	default 4
+	default 16
 	range 1 32
 	help
 	  Maximum number of filters supported by the can_add_rx_callback() API call.
diff --git a/drivers/can/can_loopback.c b/drivers/can/can_loopback.c
index 9d0322abbc08c..9744b04561512 100644
--- a/drivers/can/can_loopback.c
+++ b/drivers/can/can_loopback.c
@@ -35,7 +35,7 @@ struct can_loopback_config {
 
 struct can_loopback_data {
 	struct can_driver_data common;
-	struct can_loopback_filter filters[CONFIG_CAN_MAX_FILTER];
+	struct can_loopback_filter filters[CONFIG_CAN_LOOPBACK_MAX_FILTERS];
 	struct k_mutex mtx;
 	struct k_msgq tx_msgq;
 	char msgq_buffer[CONFIG_CAN_LOOPBACK_TX_MSGQ_SIZE * sizeof(struct can_loopback_frame)];
@@ -90,7 +90,7 @@ static void tx_thread(void *arg1, void *arg2, void *arg3)
 
 		k_mutex_lock(&data->mtx, K_FOREVER);
 
-		for (int i = 0; i < CONFIG_CAN_MAX_FILTER; i++) {
+		for (int i = 0; i < CONFIG_CAN_LOOPBACK_MAX_FILTERS; i++) {
 			filter = &data->filters[i];
 			if (filter->rx_cb != NULL &&
 			    can_frame_matches_filter(&frame.frame, &filter->filter)) {
@@ -163,7 +163,7 @@ static int can_loopback_send(const struct device *dev,
 
 static inline int get_free_filter(struct can_loopback_filter *filters)
 {
-	for (int i = 0; i < CONFIG_CAN_MAX_FILTER; i++) {
+	for (int i = 0; i < CONFIG_CAN_LOOPBACK_MAX_FILTERS; i++) {
 		if (filters[i].rx_cb == NULL) {
 			return i;
 		}
@@ -362,7 +362,7 @@ static int can_loopback_get_max_filters(const struct device *dev, bool ide)
 {
 	ARG_UNUSED(ide);
 
-	return CONFIG_CAN_MAX_FILTER;
+	return CONFIG_CAN_LOOPBACK_MAX_FILTERS;
 }
 
 static DEVICE_API(can, can_loopback_driver_api) = {
@@ -420,7 +420,7 @@ static int can_loopback_init(const struct device *dev)
 
 	k_mutex_init(&data->mtx);
 
-	for (int i = 0; i < CONFIG_CAN_MAX_FILTER; i++) {
+	for (int i = 0; i < CONFIG_CAN_LOOPBACK_MAX_FILTERS; i++) {
 		data->filters[i].rx_cb = NULL;
 	}
 
diff --git a/drivers/can/can_max32.c b/drivers/can/can_max32.c
index f7b621778947b..04d13caece0b2 100644
--- a/drivers/can/can_max32.c
+++ b/drivers/can/can_max32.c
@@ -54,7 +54,7 @@ struct max32_can_data {
 	struct max32_req_data tx_data;
 
 	uint32_t filter_usage;
-	struct max32_can_rx_callback rx_callbacks[CONFIG_CAN_MAX_FILTER];
+	struct max32_can_rx_callback rx_callbacks[CONFIG_CAN_MAX32_MAX_FILTERS];
 	struct max32_req_data rx_data;
 };
 
@@ -352,12 +352,13 @@ static int can_max32_add_rx_filter(const struct device *dev, can_rx_callback_t c
 	k_mutex_lock(&dev_data->inst_mutex, K_FOREVER);
 
 	/* find free filter */
-	while ((BIT(filter_idx) & dev_data->filter_usage) && (filter_idx < CONFIG_CAN_MAX_FILTER)) {
+	while ((BIT(filter_idx) & dev_data->filter_usage) &&
+		(filter_idx < CONFIG_CAN_MAX32_MAX_FILTERS)) {
 		filter_idx++;
 	}
 
 	/* setup filter */
-	if (filter_idx < CONFIG_CAN_MAX_FILTER) {
+	if (filter_idx < CONFIG_CAN_MAX32_MAX_FILTERS) {
 		unsigned int key = irq_lock();
 
 		dev_data->filter_usage |= BIT(filter_idx);
@@ -371,7 +372,8 @@ static int can_max32_add_rx_filter(const struct device *dev, can_rx_callback_t c
 		LOG_DBG("Set filter id:%08X mask:%08X", filter->id, filter->mask);
 	} else {
 		filter_idx = -ENOSPC;
-		LOG_WRN("All filters are used CONFIG_CAN_MAX_FILTER=%d", CONFIG_CAN_MAX_FILTER);
+		LOG_WRN("All filters are used CONFIG_CAN_MAX32_MAX_FILTERS=%d",
+			CONFIG_CAN_MAX32_MAX_FILTERS);
 	}
 
 	k_mutex_unlock(&dev_data->inst_mutex);
@@ -384,7 +386,7 @@ static void can_max32_remove_rx_filter(const struct device *dev, int filter_idx)
 	struct max32_can_data *dev_data = dev->data;
 	unsigned int key;
 
-	if ((filter_idx < 0) || (filter_idx >= CONFIG_CAN_MAX_FILTER)) {
+	if ((filter_idx < 0) || (filter_idx >= CONFIG_CAN_MAX32_MAX_FILTERS)) {
 		LOG_ERR("Filter ID %d out of bounds", filter_idx);
 		return;
 	}
@@ -465,7 +467,7 @@ static int can_max32_get_max_filters(const struct device *dev, bool ide)
 	ARG_UNUSED(dev);
 	ARG_UNUSED(ide);
 
-	return CONFIG_CAN_MAX_FILTER;
+	return CONFIG_CAN_MAX32_MAX_FILTERS;
 }
 
 #ifdef CONFIG_CAN_MANUAL_RECOVERY_MODE
@@ -510,7 +512,7 @@ static void can_max32_rx_soft_filter(const struct device *dev, struct can_frame
 	}
 #endif /* !CONFIG_CAN_ACCEPT_RTR */
 
-	for (; filter_id < CONFIG_CAN_MAX_FILTER; filter_id++) {
+	for (; filter_id < CONFIG_CAN_MAX32_MAX_FILTERS; filter_id++) {
 		if (!(BIT(filter_id) & dev_data->filter_usage)) {
 			continue; /* filter slot empty */
 		}
diff --git a/drivers/can/can_mcp2515.c b/drivers/can/can_mcp2515.c
index 6979401884279..273609abe65c4 100644
--- a/drivers/can/can_mcp2515.c
+++ b/drivers/can/can_mcp2515.c
@@ -338,7 +338,7 @@ static int mcp2515_get_max_filters(const struct device *dev, bool ide)
 {
 	ARG_UNUSED(ide);
 
-	return CONFIG_CAN_MAX_FILTER;
+	return CONFIG_CAN_MCP2515_MAX_FILTERS;
 }
 
 static int mcp2515_set_timing(const struct device *dev, const struct can_timing *timing)
@@ -622,12 +622,13 @@ static int mcp2515_add_rx_filter(const struct device *dev, can_rx_callback_t rx_
 	k_mutex_lock(&dev_data->mutex, K_FOREVER);
 
 	/* find free filter */
-	while ((BIT(filter_id) & dev_data->filter_usage) && (filter_id < CONFIG_CAN_MAX_FILTER)) {
+	while ((BIT(filter_id) & dev_data->filter_usage) &&
+		(filter_id < CONFIG_CAN_MCP2515_MAX_FILTERS)) {
 		filter_id++;
 	}
 
 	/* setup filter */
-	if (filter_id < CONFIG_CAN_MAX_FILTER) {
+	if (filter_id < CONFIG_CAN_MCP2515_MAX_FILTERS) {
 		dev_data->filter_usage |= BIT(filter_id);
 
 		dev_data->filter[filter_id] = *filter;
@@ -647,7 +648,7 @@ static void mcp2515_remove_rx_filter(const struct device *dev, int filter_id)
 {
 	struct mcp2515_data *dev_data = dev->data;
 
-	if (filter_id < 0 || filter_id >= CONFIG_CAN_MAX_FILTER) {
+	if (filter_id < 0 || filter_id >= CONFIG_CAN_MCP2515_MAX_FILTERS) {
 		LOG_ERR("filter ID %d out of bounds", filter_id);
 		return;
 	}
@@ -681,7 +682,7 @@ static void mcp2515_rx_filter(const struct device *dev, struct can_frame *frame)
 
 	k_mutex_lock(&dev_data->mutex, K_FOREVER);
 
-	for (; filter_id < CONFIG_CAN_MAX_FILTER; filter_id++) {
+	for (; filter_id < CONFIG_CAN_MCP2515_MAX_FILTERS; filter_id++) {
 		if (!(BIT(filter_id) & dev_data->filter_usage)) {
 			continue; /* filter slot empty */
 		}
diff --git a/drivers/can/can_mcp2515.h b/drivers/can/can_mcp2515.h
index c71a8f0f76d61..84c5611487726 100644
--- a/drivers/can/can_mcp2515.h
+++ b/drivers/can/can_mcp2515.h
@@ -37,9 +37,9 @@ struct mcp2515_data {
 
 	/* filter data */
 	uint32_t filter_usage;
-	can_rx_callback_t rx_cb[CONFIG_CAN_MAX_FILTER];
-	void *cb_arg[CONFIG_CAN_MAX_FILTER];
-	struct can_filter filter[CONFIG_CAN_MAX_FILTER];
+	can_rx_callback_t rx_cb[CONFIG_CAN_MCP2515_MAX_FILTERS];
+	void *cb_arg[CONFIG_CAN_MCP2515_MAX_FILTERS];
+	struct can_filter filter[CONFIG_CAN_MCP2515_MAX_FILTERS];
 
 	/* general data */
 	struct k_mutex mutex;
diff --git a/drivers/can/can_mcp251xfd.c b/drivers/can/can_mcp251xfd.c
index 893ff63e980ec..a6bc2c9267778 100644
--- a/drivers/can/can_mcp251xfd.c
+++ b/drivers/can/can_mcp251xfd.c
@@ -556,13 +556,13 @@ static int mcp251xfd_add_rx_filter(const struct device *dev, can_rx_callback_t r
 
 	k_mutex_lock(&dev_data->mutex, K_FOREVER);
 
-	for (filter_idx = 0; filter_idx < CONFIG_CAN_MAX_FILTER ; filter_idx++) {
+	for (filter_idx = 0; filter_idx < CONFIG_CAN_MCP251XFD_MAX_FILTERS ; filter_idx++) {
 		if ((BIT(filter_idx) & dev_data->filter_usage) == 0) {
 			break;
 		}
 	}
 
-	if (filter_idx >= CONFIG_CAN_MAX_FILTER) {
+	if (filter_idx >= CONFIG_CAN_MCP251XFD_MAX_FILTERS) {
 		filter_idx = -ENOSPC;
 		goto done;
 	}
@@ -629,7 +629,7 @@ static void mcp251xfd_remove_rx_filter(const struct device *dev, int filter_idx)
 	uint32_t *reg;
 	int ret;
 
-	if (filter_idx < 0 || filter_idx >= CONFIG_CAN_MAX_FILTER) {
+	if (filter_idx < 0 || filter_idx >= CONFIG_CAN_MCP251XFD_MAX_FILTERS) {
 		LOG_ERR("Filter ID %d out of bounds", filter_idx);
 		return;
 	}
@@ -731,7 +731,7 @@ static int mcp251xfd_get_max_filters(const struct device *dev, bool ide)
 {
 	ARG_UNUSED(ide);
 
-	return CONFIG_CAN_MAX_FILTER;
+	return CONFIG_CAN_MCP251XFD_MAX_FILTERS;
 }
 
 static int mcp251xfd_handle_fifo_read(const struct device *dev, const struct mcp251xfd_fifo *fifo,
diff --git a/drivers/can/can_mcp251xfd.h b/drivers/can/can_mcp251xfd.h
index 4392079685644..353902032fba6 100644
--- a/drivers/can/can_mcp251xfd.h
+++ b/drivers/can/can_mcp251xfd.h
@@ -499,9 +499,9 @@ struct mcp251xfd_data {
 
 	/* Filter Data */
 	uint32_t filter_usage;
-	struct can_filter filter[CONFIG_CAN_MAX_FILTER];
-	can_rx_callback_t rx_cb[CONFIG_CAN_MAX_FILTER];
-	void *cb_arg[CONFIG_CAN_MAX_FILTER];
+	struct can_filter filter[CONFIG_CAN_MCP251XFD_MAX_FILTERS];
+	can_rx_callback_t rx_cb[CONFIG_CAN_MCP251XFD_MAX_FILTERS];
+	void *cb_arg[CONFIG_CAN_MCP251XFD_MAX_FILTERS];
 
 	const struct device *dev;
 
diff --git a/drivers/can/can_mcux_flexcan.c b/drivers/can/can_mcux_flexcan.c
index 7a6c72e3eb3d0..57ab127bbd9ce 100644
--- a/drivers/can/can_mcux_flexcan.c
+++ b/drivers/can/can_mcux_flexcan.c
@@ -34,8 +34,8 @@ LOG_MODULE_REGISTER(can_mcux_flexcan, CONFIG_CAN_LOG_LEVEL);
 #endif
 
 /* The maximum number of message buffers for concurrent active instances */
-#ifdef CONFIG_CAN_MAX_MB
-#define MCUX_FLEXCAN_MAX_MB CONFIG_CAN_MAX_MB
+#ifdef CONFIG_CAN_MCUX_FLEXCAN_MAX_MB
+#define MCUX_FLEXCAN_MAX_MB CONFIG_CAN_MCUX_FLEXCAN_MAX_MB
 #else
 #define MCUX_FLEXCAN_MAX_MB FSL_FEATURE_FLEXCAN_HAS_MESSAGE_BUFFER_MAX_NUMBERn(0)
 #endif
@@ -44,7 +44,7 @@ LOG_MODULE_REGISTER(can_mcux_flexcan, CONFIG_CAN_LOG_LEVEL);
  * RX message buffers (filters) will take up the first N message
  * buffers. The rest are available for TX use.
  */
-#define MCUX_FLEXCAN_MAX_RX (CONFIG_CAN_MAX_FILTER + RX_START_IDX)
+#define MCUX_FLEXCAN_MAX_RX (CONFIG_CAN_MCUX_FLEXCAN_MAX_FILTERS + RX_START_IDX)
 #define MCUX_FLEXCAN_MAX_TX (MCUX_FLEXCAN_MAX_MB - MCUX_FLEXCAN_MAX_RX)
 
 /*
@@ -144,7 +144,7 @@ static int mcux_flexcan_get_max_filters(const struct device *dev, bool ide)
 {
 	ARG_UNUSED(ide);
 
-	return CONFIG_CAN_MAX_FILTER;
+	return CONFIG_CAN_MCUX_FLEXCAN_MAX_FILTERS;
 }
 
 static int mcux_flexcan_set_timing(const struct device *dev,
diff --git a/drivers/can/can_native_linux.c b/drivers/can/can_native_linux.c
index b4f8c8e525372..66d732680d493 100644
--- a/drivers/can/can_native_linux.c
+++ b/drivers/can/can_native_linux.c
@@ -33,7 +33,7 @@ struct can_filter_context {
 
 struct can_native_linux_data {
 	struct can_driver_data common;
-	struct can_filter_context filters[CONFIG_CAN_MAX_FILTER];
+	struct can_filter_context filters[CONFIG_CAN_NATIVE_LINUX_MAX_FILTERS];
 	struct k_mutex filter_mutex;
 	struct k_sem tx_idle;
 	can_tx_callback_t tx_callback;
@@ -399,7 +399,7 @@ static int can_native_linux_get_max_filters(const struct device *dev, bool ide)
 {
 	ARG_UNUSED(ide);
 
-	return CONFIG_CAN_MAX_FILTER;
+	return CONFIG_CAN_NATIVE_LINUX_MAX_FILTERS;
 }
 
 static DEVICE_API(can, can_native_linux_driver_api) = {
diff --git a/drivers/can/can_rcar.c b/drivers/can/can_rcar.c
index 8ac6be729cc9b..f9c5aa7328c03 100644
--- a/drivers/can/can_rcar.c
+++ b/drivers/can/can_rcar.c
@@ -190,9 +190,9 @@ struct can_rcar_data {
 	uint8_t tx_tail;
 	uint8_t tx_unsent;
 	struct k_mutex rx_mutex;
-	can_rx_callback_t rx_callback[CONFIG_CAN_RCAR_MAX_FILTER];
-	void *rx_callback_arg[CONFIG_CAN_RCAR_MAX_FILTER];
-	struct can_filter filter[CONFIG_CAN_RCAR_MAX_FILTER];
+	can_rx_callback_t rx_callback[CONFIG_CAN_RCAR_MAX_FILTERS];
+	void *rx_callback_arg[CONFIG_CAN_RCAR_MAX_FILTERS];
+	struct can_filter filter[CONFIG_CAN_RCAR_MAX_FILTERS];
 	enum can_state state;
 };
 
@@ -364,7 +364,7 @@ static void can_rcar_rx_filter_isr(const struct device *dev,
 	}
 #endif /* !CONFIG_CAN_ACCEPT_RTR */
 
-	for (i = 0; i < CONFIG_CAN_RCAR_MAX_FILTER; i++) {
+	for (i = 0; i < CONFIG_CAN_RCAR_MAX_FILTERS; i++) {
 		if (data->rx_callback[i] == NULL) {
 			continue;
 		}
@@ -957,7 +957,7 @@ static inline int can_rcar_add_rx_filter_unlocked(const struct device *dev,
 	struct can_rcar_data *data = dev->data;
 	int i;
 
-	for (i = 0; i < CONFIG_CAN_RCAR_MAX_FILTER; i++) {
+	for (i = 0; i < CONFIG_CAN_RCAR_MAX_FILTERS; i++) {
 		if (data->rx_callback[i] == NULL) {
 			data->rx_callback_arg[i] = cb_arg;
 			data->filter[i] = *filter;
@@ -991,7 +991,7 @@ static void can_rcar_remove_rx_filter(const struct device *dev, int filter_id)
 {
 	struct can_rcar_data *data = dev->data;
 
-	if (filter_id < 0 || filter_id >= CONFIG_CAN_RCAR_MAX_FILTER) {
+	if (filter_id < 0 || filter_id >= CONFIG_CAN_RCAR_MAX_FILTERS) {
 		LOG_ERR("filter ID %d out of bounds", filter_id);
 		return;
 	}
@@ -1142,7 +1142,7 @@ static int can_rcar_get_max_filters(const struct device *dev, bool ide)
 {
 	ARG_UNUSED(ide);
 
-	return CONFIG_CAN_RCAR_MAX_FILTER;
+	return CONFIG_CAN_RCAR_MAX_FILTERS;
 }
 
 static DEVICE_API(can, can_rcar_driver_api) = {
diff --git a/drivers/can/can_sja1000.c b/drivers/can/can_sja1000.c
index 937217b3551fb..43f2b6461f1eb 100644
--- a/drivers/can/can_sja1000.c
+++ b/drivers/can/can_sja1000.c
@@ -550,7 +550,7 @@ int can_sja1000_get_max_filters(const struct device *dev, bool ide)
 	ARG_UNUSED(dev);
 	ARG_UNUSED(ide);
 
-	return CONFIG_CAN_MAX_FILTER;
+	return CONFIG_CAN_SJA1000_MAX_FILTERS;
 }
 
 static void can_sja1000_handle_receive_irq(const struct device *dev)
diff --git a/drivers/can/can_stm32_bxcan.c b/drivers/can/can_stm32_bxcan.c
index 678ed8fc3ebf0..a6ddc854f2828 100644
--- a/drivers/can/can_stm32_bxcan.c
+++ b/drivers/can/can_stm32_bxcan.c
@@ -26,7 +26,7 @@ LOG_MODULE_REGISTER(can_stm32, CONFIG_CAN_LOG_LEVEL);
 
 #define CAN_STM32_NUM_FILTER_BANKS (14)
 #define CAN_STM32_MAX_FILTER_ID \
-	(CONFIG_CAN_MAX_EXT_ID_FILTER + CONFIG_CAN_MAX_STD_ID_FILTER * 2)
+	(CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS + CONFIG_CAN_STM32_BXCAN_MAX_STD_ID_FILTERS * 2)
 
 #define CAN_STM32_FIRX_STD_IDE_POS   (3U)
 #define CAN_STM32_FIRX_STD_RTR_POS   (4U)
@@ -37,7 +37,7 @@ LOG_MODULE_REGISTER(can_stm32, CONFIG_CAN_LOG_LEVEL);
 #define CAN_STM32_FIRX_EXT_STD_ID_POS (21U)
 #define CAN_STM32_FIRX_EXT_EXT_ID_POS (3U)
 
-#if (CONFIG_CAN_MAX_STD_ID_FILTER + CONFIG_CAN_MAX_EXT_ID_FILTER * 2) > \
+#if (CONFIG_CAN_STM32_BXCAN_MAX_STD_ID_FILTERS + CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS * 2) > \
 						(CAN_STM32_NUM_FILTER_BANKS * 2)
 #error Number of configured filters exceeds available filter bank slots.
 #endif
@@ -54,10 +54,10 @@ struct can_stm32_data {
 	struct can_stm32_mailbox mb0;
 	struct can_stm32_mailbox mb1;
 	struct can_stm32_mailbox mb2;
-	can_rx_callback_t rx_cb_std[CONFIG_CAN_MAX_STD_ID_FILTER];
-	can_rx_callback_t rx_cb_ext[CONFIG_CAN_MAX_EXT_ID_FILTER];
-	void *cb_arg_std[CONFIG_CAN_MAX_STD_ID_FILTER];
-	void *cb_arg_ext[CONFIG_CAN_MAX_EXT_ID_FILTER];
+	can_rx_callback_t rx_cb_std[CONFIG_CAN_STM32_BXCAN_MAX_STD_ID_FILTERS];
+	can_rx_callback_t rx_cb_ext[CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS];
+	void *cb_arg_std[CONFIG_CAN_STM32_BXCAN_MAX_STD_ID_FILTERS];
+	void *cb_arg_ext[CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS];
 	enum can_state state;
 };
 
@@ -130,11 +130,11 @@ static inline void can_stm32_rx_isr_handler(const struct device *dev)
 
 		can_stm32_rx_fifo_pop(mbox, &frame);
 
-		if (filter_id < CONFIG_CAN_MAX_EXT_ID_FILTER) {
+		if (filter_id < CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS) {
 			callback = data->rx_cb_ext[filter_id];
 			cb_arg = data->cb_arg_ext[filter_id];
 		} else if (filter_id < CAN_STM32_MAX_FILTER_ID) {
-			index = filter_id - CONFIG_CAN_MAX_EXT_ID_FILTER;
+			index = filter_id - CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS;
 			callback = data->rx_cb_std[index];
 			cb_arg = data->cb_arg_std[index];
 		}
@@ -586,9 +586,9 @@ static int can_stm32_get_max_filters(const struct device *dev, bool ide)
 	ARG_UNUSED(dev);
 
 	if (ide) {
-		return CONFIG_CAN_MAX_EXT_ID_FILTER;
+		return CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS;
 	} else {
-		return CONFIG_CAN_MAX_STD_ID_FILTER;
+		return CONFIG_CAN_STM32_BXCAN_MAX_STD_ID_FILTERS;
 	}
 }
 
@@ -643,15 +643,17 @@ static int can_stm32_init(const struct device *dev)
 		return ret;
 	}
 
-	/* configure scale of filter banks < CONFIG_CAN_MAX_EXT_ID_FILTER for ext ids */
-	/* We have to have set filters after initializing master CAN */
+	/*
+	 * Configure scale of filter banks < CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS for ext ids
+	 * We have to have set filters after initializing master CAN
+	 */
 	if (cfg->can == cfg->master_can) {
 		cfg->master_can->FMR |= CAN_FMR_FINIT;
-		cfg->master_can->FS1R |= ((1U << CONFIG_CAN_MAX_EXT_ID_FILTER) - 1);
+		cfg->master_can->FS1R |= ((1U << CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS) - 1);
 
 #if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) > 1
 		/* reserve ext_id filters on slave CAN device */
-		cfg->master_can->FS1R |= ((1U << CONFIG_CAN_MAX_EXT_ID_FILTER) - 1)
+		cfg->master_can->FS1R |= ((1U << CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS) - 1)
 					 << CAN_STM32_NUM_FILTER_BANKS;
 #endif /* DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) > 1 */
 
@@ -863,7 +865,7 @@ static void can_stm32_set_filter_bank(int filter_id, CAN_FilterRegister_TypeDef
 		filter_reg->FR1 = id;
 		filter_reg->FR2 = mask;
 	} else {
-		if ((filter_id - CONFIG_CAN_MAX_EXT_ID_FILTER) % 2 == 0) {
+		if ((filter_id - CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS) % 2 == 0) {
 			/* even std filter id: first 1/2 bank */
 			filter_reg->FR1 = id | (mask << 16);
 		} else {
@@ -919,7 +921,7 @@ static inline int can_stm32_set_filter(const struct device *dev, const struct ca
 	}
 
 	if ((filter->flags & CAN_FILTER_IDE) != 0) {
-		for (int i = 0; i < CONFIG_CAN_MAX_EXT_ID_FILTER; i++) {
+		for (int i = 0; i < CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS; i++) {
 			if (data->rx_cb_ext[i] == NULL) {
 				id = can_stm32_filter_to_ext_id(filter);
 				mask = can_stm32_filter_to_ext_mask(filter);
@@ -929,12 +931,13 @@ static inline int can_stm32_set_filter(const struct device *dev, const struct ca
 			}
 		}
 	} else {
-		for (int i = 0; i < CONFIG_CAN_MAX_STD_ID_FILTER; i++) {
+		for (int i = 0; i < CONFIG_CAN_STM32_BXCAN_MAX_STD_ID_FILTERS; i++) {
 			if (data->rx_cb_std[i] == NULL) {
 				id = can_stm32_filter_to_std_id(filter);
 				mask = can_stm32_filter_to_std_mask(filter);
-				filter_id = CONFIG_CAN_MAX_EXT_ID_FILTER + i;
-				bank_num = bank_offset + CONFIG_CAN_MAX_EXT_ID_FILTER + i / 2;
+				filter_id = CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS + i;
+				bank_num = bank_offset + CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS +
+					i / 2;
 				break;
 			}
 		}
@@ -965,7 +968,7 @@ static inline int can_stm32_set_filter(const struct device *dev, const struct ca
  * This driver uses masked mode for all filters (CAN_FM1R left at reset value
  * 0x00) in order to simplify mapping between filter match index from the FIFOs
  * and array index for the callbacks. All ext ID filters are stored in the
- * banks below CONFIG_CAN_MAX_EXT_ID_FILTER, followed by the std ID filters,
+ * banks below CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS, followed by the std ID filters,
  * which consume only 1/2 bank per filter.
  *
  * The more complicated list mode must be implemented if someone requires more
@@ -993,8 +996,9 @@ static int can_stm32_add_rx_filter(const struct device *dev, can_rx_callback_t c
 			data->rx_cb_ext[filter_id] = cb;
 			data->cb_arg_ext[filter_id] = cb_arg;
 		} else {
-			data->rx_cb_std[filter_id - CONFIG_CAN_MAX_EXT_ID_FILTER] = cb;
-			data->cb_arg_std[filter_id - CONFIG_CAN_MAX_EXT_ID_FILTER] = cb_arg;
+			data->rx_cb_std[filter_id - CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS] = cb;
+			data->cb_arg_std[filter_id - CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS] =
+				cb_arg;
 		}
 	}
 
@@ -1026,7 +1030,7 @@ static void can_stm32_remove_rx_filter(const struct device *dev, int filter_id)
 		bank_offset = CAN_STM32_NUM_FILTER_BANKS;
 	}
 
-	if (filter_id < CONFIG_CAN_MAX_EXT_ID_FILTER) {
+	if (filter_id < CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS) {
 		ide = true;
 		bank_num = bank_offset + filter_id;
 
@@ -1035,18 +1039,18 @@ static void can_stm32_remove_rx_filter(const struct device *dev, int filter_id)
 
 		bank_unused = true;
 	} else {
-		int filter_index = filter_id - CONFIG_CAN_MAX_EXT_ID_FILTER;
+		int filter_index = filter_id - CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS;
 
 		ide = false;
-		bank_num = bank_offset + CONFIG_CAN_MAX_EXT_ID_FILTER +
-			  (filter_id - CONFIG_CAN_MAX_EXT_ID_FILTER) / 2;
+		bank_num = bank_offset + CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS +
+			  (filter_id - CONFIG_CAN_STM32_BXCAN_MAX_EXT_ID_FILTERS) / 2;
 
 		data->rx_cb_std[filter_index] = NULL;
 		data->cb_arg_std[filter_index] = NULL;
 
 		if (filter_index % 2 == 1) {
 			bank_unused = data->rx_cb_std[filter_index - 1] == NULL;
-		} else if (filter_index + 1 < CONFIG_CAN_MAX_STD_ID_FILTER) {
+		} else if (filter_index + 1 < CONFIG_CAN_STM32_BXCAN_MAX_STD_ID_FILTERS) {
 			bank_unused = data->rx_cb_std[filter_index + 1] == NULL;
 		} else {
 			bank_unused = true;
diff --git a/drivers/can/can_stm32_fdcan.c b/drivers/can/can_stm32_fdcan.c
index ee54d38c263b0..8a5021cf29539 100644
--- a/drivers/can/can_stm32_fdcan.c
+++ b/drivers/can/can_stm32_fdcan.c
@@ -361,8 +361,10 @@ static int can_stm32fd_write_reg(const struct device *dev, uint16_t reg, uint32_
 		break;
 	case CAN_MCAN_GFC:
 		/* Map fields to RXGFC including STM32 FDCAN LSS and LSE fields */
-		bits |= FIELD_PREP(CAN_STM32FD_RXGFC_LSS, CONFIG_CAN_MAX_STD_ID_FILTER) |
-			FIELD_PREP(CAN_STM32FD_RXGFC_LSE, CONFIG_CAN_MAX_EXT_ID_FILTER);
+		bits |= FIELD_PREP(CAN_STM32FD_RXGFC_LSS,
+				   CONFIG_CAN_STM32_FDCAN_MAX_STD_ID_FILTERS);
+		bits |= FIELD_PREP(CAN_STM32FD_RXGFC_LSE,
+				   CONFIG_CAN_STM32_FDCAN_MAX_EXT_ID_FILTERS);
 		bits |= val & (CAN_MCAN_GFC_ANFS | CAN_MCAN_GFC_ANFE |
 			CAN_MCAN_GFC_RRFS | CAN_MCAN_GFC_RRFE);
 		break;
@@ -499,8 +501,8 @@ static int can_stm32fd_init(const struct device *dev)
 		return ret;
 	}
 
-	rxgfc |= FIELD_PREP(CAN_STM32FD_RXGFC_LSS, CONFIG_CAN_MAX_STD_ID_FILTER) |
-		 FIELD_PREP(CAN_STM32FD_RXGFC_LSE, CONFIG_CAN_MAX_EXT_ID_FILTER);
+	rxgfc |= FIELD_PREP(CAN_STM32FD_RXGFC_LSS, CONFIG_CAN_STM32_FDCAN_MAX_STD_ID_FILTERS) |
+		 FIELD_PREP(CAN_STM32FD_RXGFC_LSE, CONFIG_CAN_STM32_FDCAN_MAX_EXT_ID_FILTERS);
 
 	ret = can_mcan_write_reg(dev, CAN_STM32FD_RXGFC, rxgfc);
 	if (ret != 0) {
@@ -594,8 +596,8 @@ static const struct can_mcan_ops can_stm32fd_ops = {
 	PINCTRL_DT_INST_DEFINE(inst);						\
 	CAN_MCAN_CALLBACKS_DEFINE(can_stm32fd_cbs_##inst,			\
 				  CAN_MCAN_DT_INST_MRAM_TX_BUFFER_ELEMENTS(inst), \
-				  CONFIG_CAN_MAX_STD_ID_FILTER,			\
-				  CONFIG_CAN_MAX_EXT_ID_FILTER);		\
+				  CONFIG_CAN_STM32_FDCAN_MAX_STD_ID_FILTERS,	\
+				  CONFIG_CAN_STM32_FDCAN_MAX_EXT_ID_FILTERS);	\
 										\
 	static const struct stm32_pclken can_stm32fd_pclken_##inst[] =		\
 					STM32_DT_INST_CLOCKS(inst);		\
diff --git a/drivers/can/can_xmc4xxx.c b/drivers/can/can_xmc4xxx.c
index 894bf5f10b6e5..fc758cc6909a8 100644
--- a/drivers/can/can_xmc4xxx.c
+++ b/drivers/can/can_xmc4xxx.c
@@ -65,10 +65,10 @@ struct can_xmc4xxx_data {
 	struct can_xmc4xxx_tx_callback tx_callbacks[CONFIG_CAN_XMC4XXX_MAX_TX_QUEUE];
 
 	uint32_t filter_usage;
-	struct can_xmc4xxx_rx_callback rx_callbacks[CONFIG_CAN_MAX_FILTER];
-	struct can_xmc4xxx_rx_fifo rx_fifos[CONFIG_CAN_MAX_FILTER];
+	struct can_xmc4xxx_rx_callback rx_callbacks[CONFIG_CAN_XMC4XXX_MAX_FILTERS];
+	struct can_xmc4xxx_rx_fifo rx_fifos[CONFIG_CAN_XMC4XXX_MAX_FILTERS];
 #if defined(CONFIG_CAN_ACCEPT_RTR)
-	struct can_xmc4xxx_rx_fifo rtr_fifos[CONFIG_CAN_MAX_FILTER];
+	struct can_xmc4xxx_rx_fifo rtr_fifos[CONFIG_CAN_XMC4XXX_MAX_FILTERS];
 #endif
 
 	CAN_MO_TypeDef *tx_mo[CONFIG_CAN_XMC4XXX_MAX_TX_QUEUE];
@@ -362,13 +362,13 @@ static int can_xmc4xxx_add_rx_filter(const struct device *dev, can_rx_callback_t
 
 	k_mutex_lock(&dev_data->mutex, K_FOREVER);
 
-	for (filter_idx = 0; filter_idx < CONFIG_CAN_MAX_FILTER; filter_idx++) {
+	for (filter_idx = 0; filter_idx < CONFIG_CAN_XMC4XXX_MAX_FILTERS; filter_idx++) {
 		if ((BIT(filter_idx) & dev_data->filter_usage) == 0) {
 			break;
 		}
 	}
 
-	if (filter_idx >= CONFIG_CAN_MAX_FILTER) {
+	if (filter_idx >= CONFIG_CAN_XMC4XXX_MAX_FILTERS) {
 		filter_idx = -ENOSPC;
 	} else {
 		unsigned int key = irq_lock();
@@ -408,7 +408,7 @@ static void can_xmc4xxx_remove_rx_filter(const struct device *dev, int filter_id
 	struct can_xmc4xxx_data *dev_data = dev->data;
 	unsigned int key;
 
-	if (filter_idx < 0 || filter_idx >= CONFIG_CAN_MAX_FILTER) {
+	if (filter_idx < 0 || filter_idx >= CONFIG_CAN_XMC4XXX_MAX_FILTERS) {
 		LOG_ERR("Filter ID %d out of bounds", filter_idx);
 		return;
 	}
@@ -509,7 +509,7 @@ static int can_xmc4xxx_get_max_filters(const struct device *dev, bool ide)
 {
 	ARG_UNUSED(ide);
 
-	return CONFIG_CAN_MAX_FILTER;
+	return CONFIG_CAN_XMC4XXX_MAX_FILTERS;
 }
 
 static void can_xmc4xxx_reset_tx_fifos(const struct device *dev, int status)
@@ -640,7 +640,7 @@ static void can_xmc4xxx_rx_handler(const struct device *dev)
 {
 	struct can_xmc4xxx_data *dev_data = dev->data;
 
-	for (int i = 0; i < CONFIG_CAN_MAX_FILTER; i++) {
+	for (int i = 0; i < CONFIG_CAN_XMC4XXX_MAX_FILTERS; i++) {
 		if ((BIT(i) & dev_data->filter_usage) == 0) {
 			continue;
 		}
diff --git a/include/zephyr/drivers/can/can_sja1000.h b/include/zephyr/drivers/can/can_sja1000.h
index fa9647bd9b531..3a3e7c99e4f82 100644
--- a/include/zephyr/drivers/can/can_sja1000.h
+++ b/include/zephyr/drivers/can/can_sja1000.h
@@ -163,8 +163,8 @@ struct can_sja1000_rx_filter {
  */
 struct can_sja1000_data {
 	struct can_driver_data common;
-	ATOMIC_DEFINE(rx_allocs, CONFIG_CAN_MAX_FILTER);
-	struct can_sja1000_rx_filter filters[CONFIG_CAN_MAX_FILTER];
+	ATOMIC_DEFINE(rx_allocs, CONFIG_CAN_SJA1000_MAX_FILTERS);
+	struct can_sja1000_rx_filter filters[CONFIG_CAN_SJA1000_MAX_FILTERS];
 	struct k_mutex mod_lock;
 	enum can_state state;
 	struct k_sem tx_idle;
diff --git a/samples/drivers/can/counter/prj.conf b/samples/drivers/can/counter/prj.conf
index 7345dfaba83c0..1b7858867b65b 100644
--- a/samples/drivers/can/counter/prj.conf
+++ b/samples/drivers/can/counter/prj.conf
@@ -1,7 +1,6 @@
 CONFIG_POLL=y
 CONFIG_CAN=y
 CONFIG_CAN_INIT_PRIORITY=80
-CONFIG_CAN_MAX_FILTER=5
 
 CONFIG_SHELL=y
 CONFIG_CAN_SHELL=y
diff --git a/samples/modules/canopennode/prj.conf b/samples/modules/canopennode/prj.conf
index 905a1934f4998..7df1d4fbad038 100644
--- a/samples/modules/canopennode/prj.conf
+++ b/samples/modules/canopennode/prj.conf
@@ -4,7 +4,6 @@ CONFIG_CANOPEN_LOG_LEVEL_DBG=y
 CONFIG_GPIO=y
 
 CONFIG_CAN=y
-CONFIG_CAN_MAX_FILTER=13
 
 CONFIG_FLASH=y
 CONFIG_NVS=y
diff --git a/samples/modules/canopennode/prj_img_mgmt.conf b/samples/modules/canopennode/prj_img_mgmt.conf
index c837ad05a9412..7ef604d92b5b9 100644
--- a/samples/modules/canopennode/prj_img_mgmt.conf
+++ b/samples/modules/canopennode/prj_img_mgmt.conf
@@ -4,7 +4,6 @@ CONFIG_CANOPEN_LOG_LEVEL_DBG=y
 CONFIG_GPIO=y
 
 CONFIG_CAN=y
-CONFIG_CAN_MAX_FILTER=13
 
 CONFIG_FLASH=y
 CONFIG_FLASH_MAP=y
diff --git a/samples/modules/canopennode/prj_no_storage.conf b/samples/modules/canopennode/prj_no_storage.conf
index b296e8c083202..3e9177c26da6c 100644
--- a/samples/modules/canopennode/prj_no_storage.conf
+++ b/samples/modules/canopennode/prj_no_storage.conf
@@ -4,7 +4,6 @@ CONFIG_CANOPEN_LOG_LEVEL_DBG=y
 CONFIG_GPIO=y
 
 CONFIG_CAN=y
-CONFIG_CAN_MAX_FILTER=13
 
 CONFIG_CANOPEN=y
 CONFIG_CANOPENNODE_SYNC_THREAD=y
diff --git a/samples/net/sockets/can/prj.conf b/samples/net/sockets/can/prj.conf
index 04ea69917edde..2ba72a0957f39 100644
--- a/samples/net/sockets/can/prj.conf
+++ b/samples/net/sockets/can/prj.conf
@@ -1,6 +1,5 @@
 CONFIG_CAN=y
 CONFIG_NET_L2_ETHERNET=n
-CONFIG_CAN_MAX_FILTER=5
 
 CONFIG_NETWORKING=y
 CONFIG_NET_DRIVERS=y
diff --git a/samples/subsys/canbus/isotp/prj.conf b/samples/subsys/canbus/isotp/prj.conf
index 04c9fc95d1309..3250795716dc2 100644
--- a/samples/subsys/canbus/isotp/prj.conf
+++ b/samples/subsys/canbus/isotp/prj.conf
@@ -1,7 +1,6 @@
 CONFIG_LOG=y
 
 CONFIG_CAN=y
-CONFIG_CAN_MAX_FILTER=8
 
 CONFIG_ISOTP=y
 # We have two receiving contexts that are bound to a single address.