drivers: can: catch up on API naming changes

Catch up on the CAN driver API argument naming changes:
- Unify naming of callback function pointers as "callback".
- Unify naming of user-specified callback function arguments as
  "user_data".
- Instances and pointers to struct zcan_frame are named "frame",
  not "msg", to avoid confusion with the CAN message queue support.

Signed-off-by: Henrik Brix Andersen <[email protected]>

Author: henrikbrixandersen

drivers/can/can_common.c

@@ -120,7 +120,7 @@ static void can_work_isr_put(struct zcan_frame *frame, void *arg)
 
 	ret = can_work_buffer_put(frame, &work->buf);
 	if (ret) {
-		LOG_ERR("Workq buffer overflow. Msg ID: 0x%x", frame->id);
+		LOG_ERR("Workq buffer overflow. Frame ID: 0x%x", frame->id);
 		return;
 	}
 
@@ -129,15 +129,15 @@ static void can_work_isr_put(struct zcan_frame *frame, void *arg)
 
 int can_attach_workq(const struct device *dev, struct k_work_q *work_q,
 			    struct zcan_work *work,
-			    can_rx_callback_t callback, void *callback_arg,
+			    can_rx_callback_t callback, void *user_data,
 			    const struct zcan_filter *filter)
 {
 	const struct can_driver_api *api = dev->api;
 
 	k_work_init(&work->work_item, can_work_handler);
 	work->work_queue = work_q;
 	work->cb = callback;
-	work->cb_arg = callback_arg;
+	work->cb_arg = user_data;
 	can_work_buffer_init(&work->buf);
 
 	return api->attach_isr(dev, can_work_isr_put, work, filter);

drivers/can/can_handlers.c

@@ -31,27 +31,27 @@ static inline int z_vrfy_can_get_core_clock(const struct device *dev,
 #include <syscalls/can_get_core_clock_mrsh.c>
 
 static inline int z_vrfy_can_send(const struct device *dev,
-				  const struct zcan_frame *msg,
+				  const struct zcan_frame *frame,
 				  k_timeout_t timeout,
-				  can_tx_callback_t callback_isr,
-				  void *callback_arg)
+				  can_tx_callback_t callback,
+				  void *user_data)
 {
 	Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, send));
 
-	Z_OOPS(Z_SYSCALL_MEMORY_READ((const struct zcan_frame *)msg,
+	Z_OOPS(Z_SYSCALL_MEMORY_READ((const struct zcan_frame *)frame,
 				      sizeof(struct zcan_frame)));
-	Z_OOPS(Z_SYSCALL_MEMORY_READ(((struct zcan_frame *)msg)->data,
-				     sizeof((struct zcan_frame *)msg)->data));
-	Z_OOPS(Z_SYSCALL_VERIFY_MSG(callback_isr == 0,
+	Z_OOPS(Z_SYSCALL_MEMORY_READ(((struct zcan_frame *)frame)->data,
+				     sizeof((struct zcan_frame *)frame)->data));
+	Z_OOPS(Z_SYSCALL_VERIFY_MSG(callback == 0,
 				    "callbacks may not be set from user mode"));
 
-	Z_OOPS(Z_SYSCALL_MEMORY_READ((void *)callback_arg, sizeof(void *)));
+	Z_OOPS(Z_SYSCALL_MEMORY_READ((void *)user_data, sizeof(void *)));
 
 	return z_impl_can_send((const struct device *)dev,
-			       (const struct zcan_frame *)msg,
+			       (const struct zcan_frame *)frame,
 			       (k_timeout_t)timeout,
-			       (can_tx_callback_t) callback_isr,
-			       (void *)callback_arg);
+			       (can_tx_callback_t) callback,
+			       (void *)user_data);
 }
 #include <syscalls/can_send_mrsh.c>
 

drivers/can/can_loopback.c

@@ -81,7 +81,7 @@ void tx_thread(void *data_arg, void *arg2, void *arg3)
 int can_loopback_send(const struct device *dev,
 		      const struct zcan_frame *frame,
 		      k_timeout_t timeout, can_tx_callback_t callback,
-		      void *callback_arg)
+		      void *user_data)
 {
 	struct can_loopback_data *data = DEV_DATA(dev);
 	int ret;
@@ -105,7 +105,7 @@ int can_loopback_send(const struct device *dev,
 
 	loopback_frame.frame = *frame;
 	loopback_frame.cb = callback;
-	loopback_frame.cb_arg = callback_arg;
+	loopback_frame.cb_arg = user_data;
 	loopback_frame.tx_compl = &tx_sem;
 
 	if (!callback) {

drivers/can/can_mcan.c

@@ -626,7 +626,7 @@ int can_mcan_send(const struct can_mcan_config *cfg,
 		  struct can_mcan_msg_sram *msg_ram,
 		  const struct zcan_frame *frame,
 		  k_timeout_t timeout,
-		  can_tx_callback_t callback, void *callback_arg)
+		  can_tx_callback_t callback, void *user_data)
 {
 	struct can_mcan_reg  *can = cfg->can;
 	size_t data_length = can_dlc_to_bytes(frame->dlc);
@@ -704,7 +704,7 @@ int can_mcan_send(const struct can_mcan_config *cfg,
 	}
 
 	data->tx_fin_cb[put_idx] = callback;
-	data->tx_fin_cb_arg[put_idx] = callback_arg;
+	data->tx_fin_cb_arg[put_idx] = user_data;
 
 	can->txbar = (1U << put_idx);
 

drivers/can/can_mcan.h

@@ -217,7 +217,7 @@ int can_mcan_send(const struct can_mcan_config *cfg, struct can_mcan_data *data,
 		  struct can_mcan_msg_sram *msg_ram,
 		  const struct zcan_frame *frame,
 		  k_timeout_t timeout, can_tx_callback_t callback,
-		  void *callback_arg);
+		  void *user_data);
 
 int can_mcan_attach_isr(struct can_mcan_data *data,
 			struct can_mcan_msg_sram *msg_ram,

drivers/can/can_mcp2515.c

@@ -456,9 +456,9 @@ static int mcp2515_set_mode(const struct device *dev, enum can_mode mode)
 }
 
 static int mcp2515_send(const struct device *dev,
-			const struct zcan_frame *msg,
+			const struct zcan_frame *frame,
 			k_timeout_t timeout, can_tx_callback_t callback,
-			void *callback_arg)
+			void *user_data)
 {
 	struct mcp2515_data *dev_data = DEV_DATA(dev);
 	uint8_t tx_idx = 0U;
@@ -467,9 +467,9 @@ static int mcp2515_send(const struct device *dev,
 	uint8_t len;
 	uint8_t tx_frame[MCP2515_FRAME_LEN];
 
-	if (msg->dlc > CAN_MAX_DLC) {
+	if (frame->dlc > CAN_MAX_DLC) {
 		LOG_ERR("DLC of %d exceeds maximum (%d)",
-			msg->dlc, CAN_MAX_DLC);
+			frame->dlc, CAN_MAX_DLC);
 		return CAN_TX_EINVAL;
 	}
 
@@ -495,15 +495,15 @@ static int mcp2515_send(const struct device *dev,
 	}
 
 	dev_data->tx_cb[tx_idx].cb = callback;
-	dev_data->tx_cb[tx_idx].cb_arg = callback_arg;
+	dev_data->tx_cb[tx_idx].cb_arg = user_data;
 
-	mcp2515_convert_zcanframe_to_mcp2515frame(msg, tx_frame);
+	mcp2515_convert_zcanframe_to_mcp2515frame(frame, tx_frame);
 
 	/* Address Pointer selection */
 	abc = 2 * tx_idx;
 
 	/* Calculate minimum length to transfer */
-	len = sizeof(tx_frame) - CAN_MAX_DLC + msg->dlc;
+	len = sizeof(tx_frame) - CAN_MAX_DLC + frame->dlc;
 
 	mcp2515_cmd_load_tx_buffer(dev, abc, tx_frame, len);
 
@@ -571,12 +571,12 @@ static void mcp2515_register_state_change_isr(const struct device *dev,
 }
 
 static void mcp2515_rx_filter(const struct device *dev,
-			      struct zcan_frame *msg)
+			      struct zcan_frame *frame)
 {
 	struct mcp2515_data *dev_data = DEV_DATA(dev);
 	uint8_t filter_idx = 0U;
 	can_rx_callback_t callback;
-	struct zcan_frame tmp_msg;
+	struct zcan_frame tmp_frame;
 
 	k_mutex_lock(&dev_data->mutex, K_FOREVER);
 
@@ -585,16 +585,16 @@ static void mcp2515_rx_filter(const struct device *dev,
 			continue; /* filter slot empty */
 		}
 
-		if (!can_utils_filter_match(msg,
+		if (!can_utils_filter_match(frame,
 					    &dev_data->filter[filter_idx])) {
 			continue; /* filter did not match */
 		}
 
 		callback = dev_data->rx_cb[filter_idx];
 		/*Make a temporary copy in case the user modifies the message*/
-		tmp_msg = *msg;
+		tmp_frame = *frame;
 
-		callback(&tmp_msg, dev_data->cb_arg[filter_idx]);
+		callback(&tmp_frame, dev_data->cb_arg[filter_idx]);
 	}
 
 	k_mutex_unlock(&dev_data->mutex);
@@ -604,7 +604,7 @@ static void mcp2515_rx(const struct device *dev, uint8_t rx_idx)
 {
 	__ASSERT(rx_idx < MCP2515_RX_CNT, "rx_idx < MCP2515_RX_CNT");
 
-	struct zcan_frame msg;
+	struct zcan_frame frame;
 	uint8_t rx_frame[MCP2515_FRAME_LEN];
 	uint8_t nm;
 
@@ -613,8 +613,8 @@ static void mcp2515_rx(const struct device *dev, uint8_t rx_idx)
 
 	/* Fetch rx buffer */
 	mcp2515_cmd_read_rx_buffer(dev, nm, rx_frame, sizeof(rx_frame));
-	mcp2515_convert_mcp2515frame_to_zcanframe(rx_frame, &msg);
-	mcp2515_rx_filter(dev, &msg);
+	mcp2515_convert_mcp2515frame_to_zcanframe(rx_frame, &frame);
+	mcp2515_rx_filter(dev, &frame);
 }
 
 static void mcp2515_tx_done(const struct device *dev, uint8_t tx_idx)

drivers/can/can_mcux_flexcan.c

@@ -316,18 +316,18 @@ static int mcux_get_tx_alloc(struct mcux_flexcan_data *data)
 }
 
 static int mcux_flexcan_send(const struct device *dev,
-			     const struct zcan_frame *msg,
+			     const struct zcan_frame *frame,
 			     k_timeout_t timeout,
-			     can_tx_callback_t callback_isr, void *callback_arg)
+			     can_tx_callback_t callback, void *user_data)
 {
 	const struct mcux_flexcan_config *config = dev->config;
 	struct mcux_flexcan_data *data = dev->data;
 	flexcan_mb_transfer_t xfer;
 	status_t status;
 	int alloc;
 
-	if (msg->dlc > CAN_MAX_DLC) {
-		LOG_ERR("DLC of %d exceeds maximum (%d)", msg->dlc, CAN_MAX_DLC);
+	if (frame->dlc > CAN_MAX_DLC) {
+		LOG_ERR("DLC of %d exceeds maximum (%d)", frame->dlc, CAN_MAX_DLC);
 		return CAN_TX_EINVAL;
 	}
 
@@ -346,9 +346,9 @@ static int mcux_flexcan_send(const struct device *dev,
 		}
 	}
 
-	mcux_flexcan_copy_zframe_to_frame(msg, &data->tx_cbs[alloc].frame);
-	data->tx_cbs[alloc].function = callback_isr;
-	data->tx_cbs[alloc].arg = callback_arg;
+	mcux_flexcan_copy_zframe_to_frame(frame, &data->tx_cbs[alloc].frame);
+	data->tx_cbs[alloc].function = callback;
+	data->tx_cbs[alloc].arg = user_data;
 	xfer.frame = &data->tx_cbs[alloc].frame;
 	xfer.mbIdx = ALLOC_IDX_TO_TXMB_IDX(alloc);
 	FLEXCAN_SetTxMbConfig(config->base, xfer.mbIdx, true);
@@ -358,7 +358,7 @@ static int mcux_flexcan_send(const struct device *dev,
 		return CAN_TX_ERR;
 	}
 
-	if (callback_isr == NULL) {
+	if (callback == NULL) {
 		k_sem_take(&data->tx_cbs[alloc].done, K_FOREVER);
 		return data->tx_cbs[alloc].status;
 	}
@@ -368,7 +368,7 @@ static int mcux_flexcan_send(const struct device *dev,
 
 static int mcux_flexcan_attach_isr(const struct device *dev,
 				   can_rx_callback_t isr,
-				   void *callback_arg,
+				   void *user_data,
 				   const struct zcan_filter *filter)
 {
 	const struct mcux_flexcan_config *config = dev->config;
@@ -399,7 +399,7 @@ static int mcux_flexcan_attach_isr(const struct device *dev,
 					      &data->rx_cbs[alloc].mb_config,
 					      &mask);
 
-	data->rx_cbs[alloc].arg = callback_arg;
+	data->rx_cbs[alloc].arg = user_data;
 	data->rx_cbs[alloc].function = isr;
 
 	FLEXCAN_SetRxIndividualMask(config->base, ALLOC_IDX_TO_RXMB_IDX(alloc),