drivers: can: update API to use DEIVCE_API macros

yishai1999 · yishai1999 · commit 7a13a3d33e0e · 2024-11-28T13:46:51.000+02:00
Update can API and device drivers to use DEVICE_API macros.

Signed-off-by: Yishai Jaffe &lt;yishai1999@gmail.com&gt;
diff --git a/drivers/can/can_common.c b/drivers/can/can_common.c
@@ -35,7 +35,8 @@ int z_impl_can_send(const struct device *dev, const struct can_frame *frame,
 		    k_timeout_t timeout, can_tx_callback_t callback,
 		    void *user_data)
 {
-	const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
+	__ASSERT_NO_MSG(DEVICE_API_IS(can, dev));
+
 	uint32_t id_mask;
 
 	CHECKIF(frame == NULL) {
@@ -62,7 +63,7 @@ int z_impl_can_send(const struct device *dev, const struct can_frame *frame,
 
 		k_sem_init(&ctx.done, 0, 1);
 
-		err = api->send(dev, frame, timeout, can_tx_default_cb, &ctx);
+		err = DEVICE_API_GET(can, dev)->send(dev, frame, timeout, can_tx_default_cb, &ctx);
 		if (err != 0) {
 			return err;
 		}
@@ -72,13 +73,14 @@ int z_impl_can_send(const struct device *dev, const struct can_frame *frame,
 		return ctx.status;
 	}
 
-	return api->send(dev, frame, timeout, callback, user_data);
+	return DEVICE_API_GET(can, dev)->send(dev, frame, timeout, callback, user_data);
 }
 
 int can_add_rx_filter(const struct device *dev, can_rx_callback_t callback,
 		      void *user_data, const struct can_filter *filter)
 {
-	const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
+	__ASSERT_NO_MSG(DEVICE_API_IS(can, dev));
+
 	uint32_t id_mask;
 
 	CHECKIF(callback == NULL || filter == NULL) {
@@ -100,7 +102,7 @@ int can_add_rx_filter(const struct device *dev, can_rx_callback_t callback,
 		return -EINVAL;
 	}
 
-	return api->add_rx_filter(dev, callback, user_data, filter);
+	return DEVICE_API_GET(can, dev)->add_rx_filter(dev, callback, user_data, filter);
 }
 
 static void can_msgq_put(const struct device *dev, struct can_frame *frame, void *user_data)
@@ -121,9 +123,9 @@ static void can_msgq_put(const struct device *dev, struct can_frame *frame, void
 int z_impl_can_add_rx_filter_msgq(const struct device *dev, struct k_msgq *msgq,
 				  const struct can_filter *filter)
 {
-	const struct can_driver_api *api = dev->api;
+	__ASSERT_NO_MSG(DEVICE_API_IS(can, dev));
 
-	return api->add_rx_filter(dev, can_msgq_put, msgq, filter);
+	return DEVICE_API_GET(can, dev)->add_rx_filter(dev, can_msgq_put, msgq, filter);
 }
 
 /**
@@ -383,7 +385,8 @@ static int check_timing_in_range(const struct can_timing *timing,
 int z_impl_can_set_timing(const struct device *dev,
 			  const struct can_timing *timing)
 {
-	const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
+	__ASSERT_NO_MSG(DEVICE_API_IS(can, dev));
+
 	const struct can_timing *min = can_get_timing_min(dev);
 	const struct can_timing *max = can_get_timing_max(dev);
 	int err;
@@ -393,7 +396,7 @@ int z_impl_can_set_timing(const struct device *dev,
 		return err;
 	}
 
-	return api->set_timing(dev, timing);
+	return DEVICE_API_GET(can, dev)->set_timing(dev, timing);
 }
 
 int z_impl_can_set_bitrate(const struct device *dev, uint32_t bitrate)
@@ -425,12 +428,13 @@ int z_impl_can_set_bitrate(const struct device *dev, uint32_t bitrate)
 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;
+	__ASSERT_NO_MSG(DEVICE_API_IS(can, dev));
+
 	const struct can_timing *min = can_get_timing_data_min(dev);
 	const struct can_timing *max = can_get_timing_data_max(dev);
 	int err;
 
-	if (api->set_timing_data == NULL) {
+	if (DEVICE_API_GET(can, dev)->set_timing_data == NULL) {
 		return -ENOSYS;
 	}
 
@@ -439,7 +443,7 @@ int z_impl_can_set_timing_data(const struct device *dev,
 		return err;
 	}
 
-	return api->set_timing_data(dev, timing_data);
+	return DEVICE_API_GET(can, dev)->set_timing_data(dev, timing_data);
 }
 
 int z_impl_can_set_bitrate_data(const struct device *dev, uint32_t bitrate_data)
diff --git a/drivers/can/can_esp32_twai.c b/drivers/can/can_esp32_twai.c
@@ -216,7 +216,7 @@ static int can_esp32_twai_init(const struct device *dev)
 	return err;
 }
 
-const struct can_driver_api can_esp32_twai_driver_api = {
+static DEVICE_API(can, can_esp32_twai_driver_api) = {
 	.get_capabilities = can_sja1000_get_capabilities,
 	.start = can_sja1000_start,
 	.stop = can_sja1000_stop,
diff --git a/drivers/can/can_fake.c b/drivers/can/can_fake.c
@@ -103,7 +103,7 @@ static int fake_can_init(const struct device *dev)
 	return 0;
 }
 
-static const struct can_driver_api fake_can_driver_api = {
+static DEVICE_API(can, fake_can_driver_api) = {
 	.start = fake_can_start,
 	.stop = fake_can_stop,
 	.get_capabilities = fake_can_get_capabilities,
diff --git a/drivers/can/can_kvaser_pci.c b/drivers/can/can_kvaser_pci.c
@@ -130,7 +130,7 @@ static int can_kvaser_pci_init(const struct device *dev)
 	return 0;
 }
 
-const struct can_driver_api can_kvaser_pci_driver_api = {
+DEVICE_API(can, can_kvaser_pci_driver_api) = {
 	.get_capabilities = can_sja1000_get_capabilities,
 	.start = can_sja1000_start,
 	.stop = can_sja1000_stop,
diff --git a/drivers/can/can_loopback.c b/drivers/can/can_loopback.c
@@ -365,7 +365,7 @@ static int can_loopback_get_max_filters(const struct device *dev, bool ide)
 	return CONFIG_CAN_MAX_FILTER;
 }
 
-static const struct can_driver_api can_loopback_driver_api = {
+static DEVICE_API(can, can_loopback_driver_api) = {
 	.get_capabilities = can_loopback_get_capabilities,
 	.start = can_loopback_start,
 	.stop = can_loopback_stop,
diff --git a/drivers/can/can_mcp2515.c b/drivers/can/can_mcp2515.c
@@ -877,7 +877,7 @@ static void mcp2515_int_gpio_callback(const struct device *dev,
 	k_sem_give(&dev_data->int_sem);
 }
 
-static const struct can_driver_api can_api_funcs = {
+static DEVICE_API(can, can_api_funcs) = {
 	.get_capabilities = mcp2515_get_capabilities,
 	.set_timing = mcp2515_set_timing,
 	.start = mcp2515_start,
diff --git a/drivers/can/can_mcp251xfd.c b/drivers/can/can_mcp251xfd.c
@@ -1682,7 +1682,7 @@ static int mcp251xfd_init(const struct device *dev)
 	return ret;
 }
 
-static const struct can_driver_api mcp251xfd_api_funcs = {
+static DEVICE_API(can, mcp251xfd_api_funcs) = {
 	.get_capabilities = mcp251xfd_get_capabilities,
 	.set_mode = mcp251xfd_set_mode,
 	.set_timing = mcp251xfd_set_timing,
diff --git a/drivers/can/can_mcux_flexcan.c b/drivers/can/can_mcux_flexcan.c
@@ -1257,7 +1257,7 @@ static int mcux_flexcan_init(const struct device *dev)
 	return 0;
 }
 
-__maybe_unused static const struct can_driver_api mcux_flexcan_driver_api = {
+static __maybe_unused DEVICE_API(can, mcux_flexcan_driver_api) = {
 	.get_capabilities = mcux_flexcan_get_capabilities,
 	.start = mcux_flexcan_start,
 	.stop = mcux_flexcan_stop,
@@ -1299,7 +1299,7 @@ __maybe_unused static const struct can_driver_api mcux_flexcan_driver_api = {
 };
 
 #ifdef CONFIG_CAN_MCUX_FLEXCAN_FD
-static const struct can_driver_api mcux_flexcan_fd_driver_api = {
+static DEVICE_API(can, mcux_flexcan_fd_driver_api) = {
 	.get_capabilities = mcux_flexcan_get_capabilities,
 	.start = mcux_flexcan_start,
 	.stop = mcux_flexcan_stop,
diff --git a/drivers/can/can_mcux_mcan.c b/drivers/can/can_mcux_mcan.c
@@ -135,7 +135,7 @@ static int mcux_mcan_init(const struct device *dev)
 	return 0;
 }
 
-static const struct can_driver_api mcux_mcan_driver_api = {
+static DEVICE_API(can, mcux_mcan_driver_api) = {
 	.get_capabilities = can_mcan_get_capabilities,
 	.start = can_mcan_start,
 	.stop = can_mcan_stop,
diff --git a/drivers/can/can_native_linux.c b/drivers/can/can_native_linux.c
@@ -399,7 +399,7 @@ static int can_native_linux_get_max_filters(const struct device *dev, bool ide)
 	return CONFIG_CAN_MAX_FILTER;
 }
 
-static const struct can_driver_api can_native_linux_driver_api = {
+static DEVICE_API(can, can_native_linux_driver_api) = {
 	.start = can_native_linux_start,
 	.stop = can_native_linux_stop,
 	.get_capabilities = can_native_linux_get_capabilities,
diff --git a/drivers/can/can_nrf.c b/drivers/can/can_nrf.c
@@ -57,7 +57,7 @@ static int can_nrf_get_core_clock(const struct device *dev, uint32_t *rate)
 	return clock_control_get_rate(config->clock, NULL, rate);
 }
 
-static const struct can_driver_api can_nrf_api = {
+static DEVICE_API(can, can_nrf_api) = {
 	.get_capabilities = can_mcan_get_capabilities,
 	.start = can_mcan_start,
 	.stop = can_mcan_stop,
diff --git a/drivers/can/can_numaker.c b/drivers/can/can_numaker.c
@@ -160,7 +160,7 @@ static int can_numaker_init(const struct device *dev)
 	return rc;
 }
 
-static const struct can_driver_api can_numaker_driver_api = {
+static DEVICE_API(can, can_numaker_driver_api) = {
 	.get_capabilities = can_mcan_get_capabilities,
 	.start = can_mcan_start,
 	.stop = can_mcan_stop,
diff --git a/drivers/can/can_nxp_s32_canxl.c b/drivers/can/can_nxp_s32_canxl.c
@@ -1080,7 +1080,7 @@ static void can_nxp_s32_isr_error(const struct device *dev)
 	Canexcel_Ip_ErrIRQHandler(config->instance);
 }
 
-static const struct can_driver_api can_nxp_s32_driver_api = {
+static DEVICE_API(can, can_nxp_s32_driver_api) = {
 	.get_capabilities = can_nxp_s32_get_capabilities,
 	.start = can_nxp_s32_start,
 	.stop = can_nxp_s32_stop,
diff --git a/drivers/can/can_rcar.c b/drivers/can/can_rcar.c
@@ -1150,7 +1150,7 @@ static int can_rcar_get_max_filters(const struct device *dev, bool ide)
 	return CONFIG_CAN_RCAR_MAX_FILTER;
 }
 
-static const struct can_driver_api can_rcar_driver_api = {
+static DEVICE_API(can, can_rcar_driver_api) = {
 	.get_capabilities = can_rcar_get_capabilities,
 	.start = can_rcar_start,
 	.stop = can_rcar_stop,
diff --git a/drivers/can/can_renesas_ra.c b/drivers/can/can_renesas_ra.c
@@ -969,7 +969,7 @@ static int can_renesas_ra_init(const struct device *dev)
 	return 0;
 }
 
-static const struct can_driver_api can_renesas_ra_driver_api = {
+static DEVICE_API(can, can_renesas_ra_driver_api) = {
 	.get_capabilities = can_renesas_ra_get_capabilities,
 	.start = can_renesas_ra_start,
 	.stop = can_renesas_ra_stop,
diff --git a/drivers/can/can_sam.c b/drivers/can/can_sam.c
@@ -123,7 +123,7 @@ static int can_sam_init(const struct device *dev)
 	return ret;
 }
 
-static const struct can_driver_api can_sam_driver_api = {
+static DEVICE_API(can, can_sam_driver_api) = {
 	.get_capabilities = can_mcan_get_capabilities,
 	.start = can_mcan_start,
 	.stop = can_mcan_stop,
diff --git a/drivers/can/can_sam0.c b/drivers/can/can_sam0.c
@@ -161,7 +161,7 @@ static int can_sam0_init(const struct device *dev)
 	return ret;
 }
 
-static const struct can_driver_api can_sam0_driver_api = {
+static DEVICE_API(can, can_sam0_driver_api) = {
 	.get_capabilities = can_mcan_get_capabilities,
 	.start = can_mcan_start,
 	.stop = can_mcan_stop,
diff --git a/drivers/can/can_stm32_bxcan.c b/drivers/can/can_stm32_bxcan.c
@@ -1063,7 +1063,7 @@ static void can_stm32_remove_rx_filter(const struct device *dev, int filter_id)
 	k_mutex_unlock(&filter_mutex);
 }
 
-static const struct can_driver_api can_api_funcs = {
+static DEVICE_API(can, can_api_funcs) = {
 	.get_capabilities = can_stm32_get_capabilities,
 	.start = can_stm32_start,
 	.stop = can_stm32_stop,
diff --git a/drivers/can/can_stm32_fdcan.c b/drivers/can/can_stm32_fdcan.c
@@ -507,7 +507,7 @@ static int can_stm32fd_init(const struct device *dev)
 	return ret;
 }
 
-static const struct can_driver_api can_stm32fd_driver_api = {
+static DEVICE_API(can, can_stm32fd_driver_api) = {
 	.get_capabilities = can_mcan_get_capabilities,
 	.start = can_mcan_start,
 	.stop = can_mcan_stop,
diff --git a/drivers/can/can_stm32h7_fdcan.c b/drivers/can/can_stm32h7_fdcan.c
@@ -194,7 +194,7 @@ static int can_stm32h7_init(const struct device *dev)
 	return 0;
 }
 
-static const struct can_driver_api can_stm32h7_driver_api = {
+static DEVICE_API(can, can_stm32h7_driver_api) = {
 	.get_capabilities = can_mcan_get_capabilities,
 	.start = can_mcan_start,
 	.stop = can_mcan_stop,
diff --git a/drivers/can/can_tcan4x5x.c b/drivers/can/can_tcan4x5x.c
@@ -713,7 +713,7 @@ static int tcan4x5x_init(const struct device *dev)
 	return 0;
 }
 
-static const struct can_driver_api tcan4x5x_driver_api = {
+static DEVICE_API(can, tcan4x5x_driver_api) = {
 	.get_capabilities = can_mcan_get_capabilities,
 	.start = can_mcan_start,
 	.stop = can_mcan_stop,
diff --git a/drivers/can/can_xmc4xxx.c b/drivers/can/can_xmc4xxx.c
@@ -882,7 +882,7 @@ static int can_xmc4xxx_init(const struct device *dev)
 	return can_set_timing(dev, &timing);
 }
 
-static const struct can_driver_api can_xmc4xxx_api_funcs = {
+static DEVICE_API(can, can_xmc4xxx_api_funcs) = {
 	.get_capabilities = can_xmc4xxx_get_capabilities,
 	.set_mode = can_xmc4xxx_set_mode,
 	.set_timing = can_xmc4xxx_set_timing,
diff --git a/include/zephyr/drivers/can.h b/include/zephyr/drivers/can.h

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,8 @@ int z_impl_can_send(const struct device dev, const struct can_frame frame,`
`35`	`35`	`k_timeout_t timeout, can_tx_callback_t callback,`
`36`	`36`	`void *user_data)`
`37`	`37`	`{`
`38`		`- const struct can_driver_api api = (const struct can_driver_api )dev->api;`
	`38`	`+ __ASSERT_NO_MSG(DEVICE_API_IS(can, dev));`
	`39`	`+`
`39`	`40`	`uint32_t id_mask;`
`40`	`41`
`41`	`42`	`CHECKIF(frame == NULL) {`
`@@ -62,7 +63,7 @@ int z_impl_can_send(const struct device dev, const struct can_frame frame,`
`62`	`63`
`63`	`64`	`k_sem_init(&ctx.done, 0, 1);`
`64`	`65`
`65`		`- err = api->send(dev, frame, timeout, can_tx_default_cb, &ctx);`
	`66`	`+ err = DEVICE_API_GET(can, dev)->send(dev, frame, timeout, can_tx_default_cb, &ctx);`
`66`	`67`	`if (err != 0) {`
`67`	`68`	`return err;`
`68`	`69`	`}`
`@@ -72,13 +73,14 @@ int z_impl_can_send(const struct device dev, const struct can_frame frame,`
`72`	`73`	`return ctx.status;`
`73`	`74`	`}`
`74`	`75`
`75`		`- return api->send(dev, frame, timeout, callback, user_data);`
	`76`	`+ return DEVICE_API_GET(can, dev)->send(dev, frame, timeout, callback, user_data);`
`76`	`77`	`}`
`77`	`78`
`78`	`79`	`int can_add_rx_filter(const struct device *dev, can_rx_callback_t callback,`
`79`	`80`	`void user_data, const struct can_filter filter)`
`80`	`81`	`{`
`81`		`- const struct can_driver_api api = (const struct can_driver_api )dev->api;`
	`82`	`+ __ASSERT_NO_MSG(DEVICE_API_IS(can, dev));`
	`83`	`+`
`82`	`84`	`uint32_t id_mask;`
`83`	`85`
`84`	`86`	`CHECKIF(callback == NULL \|\| filter == NULL) {`
`@@ -100,7 +102,7 @@ int can_add_rx_filter(const struct device *dev, can_rx_callback_t callback,`
`100`	`102`	`return -EINVAL;`
`101`	`103`	`}`
`102`	`104`
`103`		`- return api->add_rx_filter(dev, callback, user_data, filter);`
	`105`	`+ return DEVICE_API_GET(can, dev)->add_rx_filter(dev, callback, user_data, filter);`
`104`	`106`	`}`
`105`	`107`
`106`	`108`	`static void can_msgq_put(const struct device dev, struct can_frame frame, void *user_data)`
`@@ -121,9 +123,9 @@ static void can_msgq_put(const struct device dev, struct can_frame frame, void`
`121`	`123`	`int z_impl_can_add_rx_filter_msgq(const struct device dev, struct k_msgq msgq,`
`122`	`124`	`const struct can_filter *filter)`
`123`	`125`	`{`
`124`		`- const struct can_driver_api *api = dev->api;`
	`126`	`+ __ASSERT_NO_MSG(DEVICE_API_IS(can, dev));`
`125`	`127`
`126`		`- return api->add_rx_filter(dev, can_msgq_put, msgq, filter);`
	`128`	`+ return DEVICE_API_GET(can, dev)->add_rx_filter(dev, can_msgq_put, msgq, filter);`
`127`	`129`	`}`
`128`	`130`
`129`	`131`	`/**`
`@@ -383,7 +385,8 @@ static int check_timing_in_range(const struct can_timing *timing,`
`383`	`385`	`int z_impl_can_set_timing(const struct device *dev,`
`384`	`386`	`const struct can_timing *timing)`
`385`	`387`	`{`
`386`		`- const struct can_driver_api api = (const struct can_driver_api )dev->api;`
	`388`	`+ __ASSERT_NO_MSG(DEVICE_API_IS(can, dev));`
	`389`	`+`
`387`	`390`	`const struct can_timing *min = can_get_timing_min(dev);`
`388`	`391`	`const struct can_timing *max = can_get_timing_max(dev);`
`389`	`392`	`int err;`
`@@ -393,7 +396,7 @@ int z_impl_can_set_timing(const struct device *dev,`
`393`	`396`	`return err;`
`394`	`397`	`}`
`395`	`398`
`396`		`- return api->set_timing(dev, timing);`
	`399`	`+ return DEVICE_API_GET(can, dev)->set_timing(dev, timing);`
`397`	`400`	`}`
`398`	`401`
`399`	`402`	`int z_impl_can_set_bitrate(const struct device *dev, uint32_t bitrate)`
`@@ -425,12 +428,13 @@ int z_impl_can_set_bitrate(const struct device *dev, uint32_t bitrate)`
`425`	`428`	`int z_impl_can_set_timing_data(const struct device *dev,`
`426`	`429`	`const struct can_timing *timing_data)`
`427`	`430`	`{`
`428`		`- const struct can_driver_api api = (const struct can_driver_api )dev->api;`
	`431`	`+ __ASSERT_NO_MSG(DEVICE_API_IS(can, dev));`
	`432`	`+`
`429`	`433`	`const struct can_timing *min = can_get_timing_data_min(dev);`
`430`	`434`	`const struct can_timing *max = can_get_timing_data_max(dev);`
`431`	`435`	`int err;`
`432`	`436`
`433`		`- if (api->set_timing_data == NULL) {`
	`437`	`+ if (DEVICE_API_GET(can, dev)->set_timing_data == NULL) {`
`434`	`438`	`return -ENOSYS;`
`435`	`439`	`}`
`436`	`440`
`@@ -439,7 +443,7 @@ int z_impl_can_set_timing_data(const struct device *dev,`
`439`	`443`	`return err;`
`440`	`444`	`}`
`441`	`445`
`442`		`- return api->set_timing_data(dev, timing_data);`
	`446`	`+ return DEVICE_API_GET(can, dev)->set_timing_data(dev, timing_data);`
`443`	`447`	`}`
`444`	`448`
`445`	`449`	`int z_impl_can_set_bitrate_data(const struct device *dev, uint32_t bitrate_data)`
Original file line number	Diff line number	Diff line change
`@@ -216,7 +216,7 @@ static int can_esp32_twai_init(const struct device *dev)`
`216`	`216`	`return err;`
`217`	`217`	`}`
`218`	`218`
`219`		`-const struct can_driver_api can_esp32_twai_driver_api = {`
	`219`	`+static DEVICE_API(can, can_esp32_twai_driver_api) = {`
`220`	`220`	`.get_capabilities = can_sja1000_get_capabilities,`
`221`	`221`	`.start = can_sja1000_start,`
`222`	`222`	`.stop = can_sja1000_stop,`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ static int fake_can_init(const struct device *dev)`
`103`	`103`	`return 0;`
`104`	`104`	`}`
`105`	`105`
`106`		`-static const struct can_driver_api fake_can_driver_api = {`
	`106`	`+static DEVICE_API(can, fake_can_driver_api) = {`
`107`	`107`	`.start = fake_can_start,`
`108`	`108`	`.stop = fake_can_stop,`
`109`	`109`	`.get_capabilities = fake_can_get_capabilities,`
Original file line number	Diff line number	Diff line change
`@@ -130,7 +130,7 @@ static int can_kvaser_pci_init(const struct device *dev)`
`130`	`130`	`return 0;`
`131`	`131`	`}`
`132`	`132`
`133`		`-const struct can_driver_api can_kvaser_pci_driver_api = {`
	`133`	`+DEVICE_API(can, can_kvaser_pci_driver_api) = {`
`134`	`134`	`.get_capabilities = can_sja1000_get_capabilities,`
`135`	`135`	`.start = can_sja1000_start,`
`136`	`136`	`.stop = can_sja1000_stop,`
Original file line number	Diff line number	Diff line change
`@@ -365,7 +365,7 @@ static int can_loopback_get_max_filters(const struct device *dev, bool ide)`
`365`	`365`	`return CONFIG_CAN_MAX_FILTER;`
`366`	`366`	`}`
`367`	`367`
`368`		`-static const struct can_driver_api can_loopback_driver_api = {`
	`368`	`+static DEVICE_API(can, can_loopback_driver_api) = {`
`369`	`369`	`.get_capabilities = can_loopback_get_capabilities,`
`370`	`370`	`.start = can_loopback_start,`
`371`	`371`	`.stop = can_loopback_stop,`
Original file line number	Diff line number	Diff line change
`@@ -877,7 +877,7 @@ static void mcp2515_int_gpio_callback(const struct device *dev,`
`877`	`877`	`k_sem_give(&dev_data->int_sem);`
`878`	`878`	`}`
`879`	`879`
`880`		`-static const struct can_driver_api can_api_funcs = {`
	`880`	`+static DEVICE_API(can, can_api_funcs) = {`
`881`	`881`	`.get_capabilities = mcp2515_get_capabilities,`
`882`	`882`	`.set_timing = mcp2515_set_timing,`
`883`	`883`	`.start = mcp2515_start,`
Original file line number	Diff line number	Diff line change
`@@ -1682,7 +1682,7 @@ static int mcp251xfd_init(const struct device *dev)`
`1682`	`1682`	`return ret;`
`1683`	`1683`	`}`
`1684`	`1684`
`1685`		`-static const struct can_driver_api mcp251xfd_api_funcs = {`
	`1685`	`+static DEVICE_API(can, mcp251xfd_api_funcs) = {`
`1686`	`1686`	`.get_capabilities = mcp251xfd_get_capabilities,`
`1687`	`1687`	`.set_mode = mcp251xfd_set_mode,`
`1688`	`1688`	`.set_timing = mcp251xfd_set_timing,`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ static int mcux_mcan_init(const struct device *dev)`
`135`	`135`	`return 0;`
`136`	`136`	`}`
`137`	`137`
`138`		`-static const struct can_driver_api mcux_mcan_driver_api = {`
	`138`	`+static DEVICE_API(can, mcux_mcan_driver_api) = {`
`139`	`139`	`.get_capabilities = can_mcan_get_capabilities,`
`140`	`140`	`.start = can_mcan_start,`
`141`	`141`	`.stop = can_mcan_stop,`
Original file line number	Diff line number	Diff line change
`@@ -399,7 +399,7 @@ static int can_native_linux_get_max_filters(const struct device *dev, bool ide)`
`399`	`399`	`return CONFIG_CAN_MAX_FILTER;`
`400`	`400`	`}`
`401`	`401`
`402`		`-static const struct can_driver_api can_native_linux_driver_api = {`
	`402`	`+static DEVICE_API(can, can_native_linux_driver_api) = {`
`403`	`403`	`.start = can_native_linux_start,`
`404`	`404`	`.stop = can_native_linux_stop,`
`405`	`405`	`.get_capabilities = can_native_linux_get_capabilities,`