michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers: can: catch up on API naming changes

Browse source 
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 <hebad@vestas.com>
This commit is contained in:
Henrik Brix Andersen 2021-12-04 15:21:32 +01:00 • committed by Christopher Friedt
commit b21a91e468
12 changed files with 125 additions and 125 deletions
Download patch file Download diff file Expand all files Collapse all files

6
drivers/can/can_common.c
View file

@ -120,7 +120,7 @@ static void can_work_isr_put(struct zcan_frame *frame, void *arg)
ret = can_work_buffer_put(frame, &work->buf); ret = can_work_buffer_put(frame, &work->buf);
if (ret) { 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; return;
} }
@ -129,7 +129,7 @@ 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, int can_attach_workq(const struct device *dev, struct k_work_q *work_q,
struct zcan_work *work, 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 zcan_filter *filter)
{ {
const struct can_driver_api *api = dev->api; const struct can_driver_api *api = dev->api;
@ -137,7 +137,7 @@ int can_attach_workq(const struct device *dev, struct k_work_q *work_q,
k_work_init(&work->work_item, can_work_handler); k_work_init(&work->work_item, can_work_handler);
work->work_queue = work_q; work->work_queue = work_q;
work->cb = callback; work->cb = callback;
work->cb_arg = callback_arg; work->cb_arg = user_data;
can_work_buffer_init(&work->buf); can_work_buffer_init(&work->buf);
return api->attach_isr(dev, can_work_isr_put, work, filter); return api->attach_isr(dev, can_work_isr_put, work, filter);

22
drivers/can/can_handlers.c
View file

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

4
drivers/can/can_loopback.c
View file

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

4
drivers/can/can_mcan.c
View file

@ -626,7 +626,7 @@ int can_mcan_send(const struct can_mcan_config *cfg,
struct can_mcan_msg_sram *msg_ram, struct can_mcan_msg_sram *msg_ram,
const struct zcan_frame *frame, const struct zcan_frame *frame,
k_timeout_t timeout, 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; struct can_mcan_reg *can = cfg->can;
size_t data_length = can_dlc_to_bytes(frame->dlc); 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[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); can->txbar = (1U << put_idx);

2
drivers/can/can_mcan.h
View file

@ -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, struct can_mcan_msg_sram *msg_ram,
const struct zcan_frame *frame, const struct zcan_frame *frame,
k_timeout_t timeout, can_tx_callback_t callback, 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, int can_mcan_attach_isr(struct can_mcan_data *data,
struct can_mcan_msg_sram *msg_ram, struct can_mcan_msg_sram *msg_ram,

30
drivers/can/can_mcp2515.c
View file

@ -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, 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, k_timeout_t timeout, can_tx_callback_t callback,
void *callback_arg) void *user_data)
{ {
struct mcp2515_data *dev_data = DEV_DATA(dev); struct mcp2515_data *dev_data = DEV_DATA(dev);
uint8_t tx_idx = 0U; uint8_t tx_idx = 0U;
@ -467,9 +467,9 @@ static int mcp2515_send(const struct device *dev,
uint8_t len; uint8_t len;
uint8_t tx_frame[MCP2515_FRAME_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)", LOG_ERR("DLC of %d exceeds maximum (%d)",
msg->dlc, CAN_MAX_DLC); frame->dlc, CAN_MAX_DLC);
return CAN_TX_EINVAL; 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 = 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 */ /* Address Pointer selection */
abc = 2 * tx_idx; abc = 2 * tx_idx;
/* Calculate minimum length to transfer */ /* 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); 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, 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); struct mcp2515_data *dev_data = DEV_DATA(dev);
uint8_t filter_idx = 0U; uint8_t filter_idx = 0U;
can_rx_callback_t callback; can_rx_callback_t callback;
struct zcan_frame tmp_msg; struct zcan_frame tmp_frame;
k_mutex_lock(&dev_data->mutex, K_FOREVER); 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 */ continue; /* filter slot empty */
} }
if (!can_utils_filter_match(msg, if (!can_utils_filter_match(frame,
&dev_data->filter[filter_idx])) { &dev_data->filter[filter_idx])) {
continue; /* filter did not match */ continue; /* filter did not match */
} }
callback = dev_data->rx_cb[filter_idx]; callback = dev_data->rx_cb[filter_idx];
/*Make a temporary copy in case the user modifies the message*/ /*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); 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"); __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 rx_frame[MCP2515_FRAME_LEN];
uint8_t nm; uint8_t nm;
@ -613,8 +613,8 @@ static void mcp2515_rx(const struct device *dev, uint8_t rx_idx)
/* Fetch rx buffer */ /* Fetch rx buffer */
mcp2515_cmd_read_rx_buffer(dev, nm, rx_frame, sizeof(rx_frame)); mcp2515_cmd_read_rx_buffer(dev, nm, rx_frame, sizeof(rx_frame));
mcp2515_convert_mcp2515frame_to_zcanframe(rx_frame, &msg); mcp2515_convert_mcp2515frame_to_zcanframe(rx_frame, &frame);
mcp2515_rx_filter(dev, &msg); mcp2515_rx_filter(dev, &frame);
} }
static void mcp2515_tx_done(const struct device *dev, uint8_t tx_idx) static void mcp2515_tx_done(const struct device *dev, uint8_t tx_idx)

20
drivers/can/can_mcux_flexcan.c
View file

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

82
drivers/can/can_rcar.c
View file

@ -364,9 +364,9 @@ static void can_rcar_error(const struct device *dev)
} }
static void can_rcar_rx_filter_isr(struct can_rcar_data *data, static void can_rcar_rx_filter_isr(struct can_rcar_data *data,
const struct zcan_frame *msg) const struct zcan_frame *frame)
{ {
struct zcan_frame tmp_msg; struct zcan_frame tmp_frame;
uint8_t i; uint8_t i;
for (i = 0; i < CONFIG_CAN_RCAR_MAX_FILTER; i++) { for (i = 0; i < CONFIG_CAN_RCAR_MAX_FILTER; i++) {
@ -374,15 +374,15 @@ static void can_rcar_rx_filter_isr(struct can_rcar_data *data,
continue; continue;
} }
if (!can_utils_filter_match(msg, if (!can_utils_filter_match(frame,
&data->filter[i])) { &data->filter[i])) {
continue; /* filter did not match */ continue; /* filter did not match */
} }
/* Make a temporary copy in case the user /* Make a temporary copy in case the user
* modifies the message. * modifies the message.
*/ */
tmp_msg = *msg; tmp_frame = *frame;
data->rx_callback[i](&tmp_msg, data->rx_callback_arg[i]); data->rx_callback[i](&tmp_frame, data->rx_callback_arg[i]);
} }
} }
@ -390,51 +390,51 @@ static void can_rcar_rx_isr(const struct device *dev)
{ {
struct can_rcar_data *data = DEV_CAN_DATA(dev); struct can_rcar_data *data = DEV_CAN_DATA(dev);
const struct can_rcar_cfg *config = DEV_CAN_CFG(dev); const struct can_rcar_cfg *config = DEV_CAN_CFG(dev);
struct zcan_frame msg; struct zcan_frame frame;
uint32_t val; uint32_t val;
int i; int i;
val = sys_read32(config->reg_addr + RCAR_CAN_MB_60); val = sys_read32(config->reg_addr + RCAR_CAN_MB_60);
if (val & RCAR_CAN_MB_IDE) { if (val & RCAR_CAN_MB_IDE) {
msg.id_type = CAN_EXTENDED_IDENTIFIER; frame.id_type = CAN_EXTENDED_IDENTIFIER;
msg.id = val & RCAR_CAN_MB_EID_MASK; frame.id = val & RCAR_CAN_MB_EID_MASK;
} else { } else {
msg.id_type = CAN_STANDARD_IDENTIFIER; frame.id_type = CAN_STANDARD_IDENTIFIER;
msg.id = (val & RCAR_CAN_MB_SID_MASK) >> RCAR_CAN_MB_SID_SHIFT; frame.id = (val & RCAR_CAN_MB_SID_MASK) >> RCAR_CAN_MB_SID_SHIFT;
} }
if (val & RCAR_CAN_MB_RTR) { if (val & RCAR_CAN_MB_RTR) {
msg.rtr = CAN_REMOTEREQUEST; frame.rtr = CAN_REMOTEREQUEST;
} else { } else {
msg.rtr = CAN_DATAFRAME; frame.rtr = CAN_DATAFRAME;
} }
msg.dlc = sys_read16(config->reg_addr frame.dlc = sys_read16(config->reg_addr +
+ RCAR_CAN_MB_60 + RCAR_CAN_MB_DLC_OFFSET) & 0xF; RCAR_CAN_MB_60 + RCAR_CAN_MB_DLC_OFFSET) & 0xF;
/* Be paranoid doc states that any value greater than 8 /* Be paranoid doc states that any value greater than 8
* should be considered as 8 bytes. * should be considered as 8 bytes.
*/ */
if (msg.dlc > CAN_MAX_DLC) { if (frame.dlc > CAN_MAX_DLC) {
msg.dlc = CAN_MAX_DLC; frame.dlc = CAN_MAX_DLC;
} }
for (i = 0; i < msg.dlc; i++) { for (i = 0; i < frame.dlc; i++) {
msg.data[i] = sys_read8(config->reg_addr frame.data[i] = sys_read8(config->reg_addr +
+ RCAR_CAN_MB_60 + RCAR_CAN_MB_DATA_OFFSET + i); RCAR_CAN_MB_60 + RCAR_CAN_MB_DATA_OFFSET + i);
} }
#if defined(CONFIG_CAN_RX_TIMESTAMP) #if defined(CONFIG_CAN_RX_TIMESTAMP)
/* read upper byte */ /* read upper byte */
msg.timestamp = sys_read8(config->reg_addr + frame.timestamp = sys_read8(config->reg_addr +
RCAR_CAN_MB_60 + RCAR_CAN_MB_TSH_OFFSET) << 8; RCAR_CAN_MB_60 + RCAR_CAN_MB_TSH_OFFSET) << 8;
/* and then read lower byte */ /* and then read lower byte */
msg.timestamp |= sys_read8(config->reg_addr + frame.timestamp |= sys_read8(config->reg_addr +
RCAR_CAN_MB_60 + RCAR_CAN_MB_TSL_OFFSET); RCAR_CAN_MB_60 + RCAR_CAN_MB_TSL_OFFSET);
#endif #endif
/* Increment CPU side pointer */ /* Increment CPU side pointer */
sys_write8(0xff, config->reg_addr + RCAR_CAN_RFPCR); sys_write8(0xff, config->reg_addr + RCAR_CAN_RFPCR);
can_rcar_rx_filter_isr(data, &msg); can_rcar_rx_filter_isr(data, &frame);
} }
static void can_rcar_isr(const struct device *dev) static void can_rcar_isr(const struct device *dev)
@ -711,9 +711,9 @@ done:
} }
#endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */ #endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */
int can_rcar_send(const struct device *dev, const struct zcan_frame *msg, int can_rcar_send(const struct device *dev, const struct zcan_frame *frame,
k_timeout_t timeout, can_tx_callback_t callback, k_timeout_t timeout, can_tx_callback_t callback,
void *callback_arg) void *user_data)
{ {
const struct can_rcar_cfg *config = DEV_CAN_CFG(dev); const struct can_rcar_cfg *config = DEV_CAN_CFG(dev);
struct can_rcar_data *data = DEV_CAN_DATA(dev); struct can_rcar_data *data = DEV_CAN_DATA(dev);
@ -725,17 +725,17 @@ int can_rcar_send(const struct device *dev, const struct zcan_frame *msg,
"Id: 0x%x, " "Id: 0x%x, "
"ID type: %s, " "ID type: %s, "
"Remote Frame: %s" "Remote Frame: %s"
, msg->dlc, dev->name , frame->dlc, dev->name
, msg->id , frame->id
, msg->id_type == CAN_STANDARD_IDENTIFIER ? , frame->id_type == CAN_STANDARD_IDENTIFIER ?
"standard" : "extended" "standard" : "extended"
, msg->rtr == CAN_DATAFRAME ? "no" : "yes"); , frame->rtr == CAN_DATAFRAME ? "no" : "yes");
__ASSERT(msg->dlc == 0U || msg->data != NULL, "Dataptr is null"); __ASSERT(frame->dlc == 0U || frame->data != NULL, "Dataptr is null");
if (msg->dlc > CAN_MAX_DLC) { if (frame->dlc > CAN_MAX_DLC) {
LOG_ERR("DLC of %d exceeds maximum (%d)", LOG_ERR("DLC of %d exceeds maximum (%d)",
msg->dlc, CAN_MAX_DLC); frame->dlc, CAN_MAX_DLC);
return CAN_TX_EINVAL; return CAN_TX_EINVAL;
} }
@ -747,7 +747,7 @@ int can_rcar_send(const struct device *dev, const struct zcan_frame *msg,
k_mutex_lock(&data->inst_mutex, K_FOREVER); k_mutex_lock(&data->inst_mutex, K_FOREVER);
tx_cb = &data->tx_cb[data->tx_head]; tx_cb = &data->tx_cb[data->tx_head];
tx_cb->cb = callback; tx_cb->cb = callback;
tx_cb->cb_arg = callback_arg; tx_cb->cb_arg = user_data;
k_sem_reset(&tx_cb->sem); k_sem_reset(&tx_cb->sem);
@ -756,23 +756,23 @@ int can_rcar_send(const struct device *dev, const struct zcan_frame *msg,
data->tx_head = 0; data->tx_head = 0;
} }
if (msg->id_type == CAN_STANDARD_IDENTIFIER) { if (frame->id_type == CAN_STANDARD_IDENTIFIER) {
identifier = msg->id << RCAR_CAN_MB_SID_SHIFT; identifier = frame->id << RCAR_CAN_MB_SID_SHIFT;
} else { } else {
identifier = msg->id | RCAR_CAN_MB_IDE; identifier = frame->id | RCAR_CAN_MB_IDE;
} }
if (msg->rtr == CAN_REMOTEREQUEST) { if (frame->rtr == CAN_REMOTEREQUEST) {
identifier |= RCAR_CAN_MB_RTR; identifier |= RCAR_CAN_MB_RTR;
} }
sys_write32(identifier, config->reg_addr + RCAR_CAN_MB_56); sys_write32(identifier, config->reg_addr + RCAR_CAN_MB_56);
sys_write16(msg->dlc, config->reg_addr sys_write16(frame->dlc, config->reg_addr
+ RCAR_CAN_MB_56 + RCAR_CAN_MB_DLC_OFFSET); + RCAR_CAN_MB_56 + RCAR_CAN_MB_DLC_OFFSET);
for (i = 0; i < msg->dlc; i++) { for (i = 0; i < frame->dlc; i++) {
sys_write8(msg->data[i], config->reg_addr sys_write8(frame->data[i], config->reg_addr
+ RCAR_CAN_MB_56 + RCAR_CAN_MB_DATA_OFFSET + i); + RCAR_CAN_MB_56 + RCAR_CAN_MB_DATA_OFFSET + i);
} }

60
drivers/can/can_stm32.c
View file

@ -63,22 +63,22 @@ static void can_stm32_signal_tx_complete(struct can_mailbox *mb)
} }
static void can_stm32_get_msg_fifo(CAN_FIFOMailBox_TypeDef *mbox, static void can_stm32_get_msg_fifo(CAN_FIFOMailBox_TypeDef *mbox,
struct zcan_frame *msg) struct zcan_frame *frame)
{ {
if (mbox->RIR & CAN_RI0R_IDE) { if (mbox->RIR & CAN_RI0R_IDE) {
msg->id = mbox->RIR >> CAN_RI0R_EXID_Pos; frame->id = mbox->RIR >> CAN_RI0R_EXID_Pos;
msg->id_type = CAN_EXTENDED_IDENTIFIER; frame->id_type = CAN_EXTENDED_IDENTIFIER;
} else { } else {
msg->id = mbox->RIR >> CAN_RI0R_STID_Pos; frame->id = mbox->RIR >> CAN_RI0R_STID_Pos;
msg->id_type = CAN_STANDARD_IDENTIFIER; frame->id_type = CAN_STANDARD_IDENTIFIER;
} }
msg->rtr = mbox->RIR & CAN_RI0R_RTR ? CAN_REMOTEREQUEST : CAN_DATAFRAME; frame->rtr = mbox->RIR & CAN_RI0R_RTR ? CAN_REMOTEREQUEST : CAN_DATAFRAME;
msg->dlc = mbox->RDTR & (CAN_RDT0R_DLC >> CAN_RDT0R_DLC_Pos); frame->dlc = mbox->RDTR & (CAN_RDT0R_DLC >> CAN_RDT0R_DLC_Pos);
msg->data_32[0] = mbox->RDLR; frame->data_32[0] = mbox->RDLR;
msg->data_32[1] = mbox->RDHR; frame->data_32[1] = mbox->RDHR;
#ifdef CONFIG_CAN_RX_TIMESTAMP #ifdef CONFIG_CAN_RX_TIMESTAMP
msg->timestamp = ((mbox->RDTR & CAN_RDT0R_TIME) >> CAN_RDT0R_TIME_Pos); frame->timestamp = ((mbox->RDTR & CAN_RDT0R_TIME) >> CAN_RDT0R_TIME_Pos);
#endif #endif
} }
@ -87,7 +87,7 @@ void can_stm32_rx_isr_handler(CAN_TypeDef *can, struct can_stm32_data *data)
{ {
CAN_FIFOMailBox_TypeDef *mbox; CAN_FIFOMailBox_TypeDef *mbox;
int filter_match_index; int filter_match_index;
struct zcan_frame msg; struct zcan_frame frame;
can_rx_callback_t callback; can_rx_callback_t callback;
while (can->RF0R & CAN_RF0R_FMP0) { while (can->RF0R & CAN_RF0R_FMP0) {
@ -100,12 +100,12 @@ void can_stm32_rx_isr_handler(CAN_TypeDef *can, struct can_stm32_data *data)
} }
LOG_DBG("Message on filter index %d", filter_match_index); LOG_DBG("Message on filter index %d", filter_match_index);
can_stm32_get_msg_fifo(mbox, &msg); can_stm32_get_msg_fifo(mbox, &frame);
callback = data->rx_cb[filter_match_index]; callback = data->rx_cb[filter_match_index];
if (callback) { if (callback) {
callback(&msg, data->cb_arg[filter_match_index]); callback(&frame, data->cb_arg[filter_match_index]);
} }
/* Release message */ /* Release message */
@ -606,9 +606,9 @@ done:
#endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */ #endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */
int can_stm32_send(const struct device *dev, const struct zcan_frame *msg, int can_stm32_send(const struct device *dev, const struct zcan_frame *frame,
k_timeout_t timeout, can_tx_callback_t callback, k_timeout_t timeout, can_tx_callback_t callback,
void *callback_arg) void *user_data)
{ {
const struct can_stm32_config *cfg = DEV_CFG(dev); const struct can_stm32_config *cfg = DEV_CFG(dev);
struct can_stm32_data *data = DEV_DATA(dev); struct can_stm32_data *data = DEV_DATA(dev);
@ -621,16 +621,16 @@ int can_stm32_send(const struct device *dev, const struct zcan_frame *msg,
"Id: 0x%x, " "Id: 0x%x, "
"ID type: %s, " "ID type: %s, "
"Remote Frame: %s" "Remote Frame: %s"
, msg->dlc, dev->name , frame->dlc, dev->name
, msg->id , frame->id
, msg->id_type == CAN_STANDARD_IDENTIFIER ? , frame->id_type == CAN_STANDARD_IDENTIFIER ?
"standard" : "extended" "standard" : "extended"
, msg->rtr == CAN_DATAFRAME ? "no" : "yes"); , frame->rtr == CAN_DATAFRAME ? "no" : "yes");
__ASSERT(msg->dlc == 0U || msg->data != NULL, "Dataptr is null"); __ASSERT(frame->dlc == 0U || frame->data != NULL, "Dataptr is null");
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); LOG_ERR("DLC of %d exceeds maximum (%d)", frame->dlc, CAN_MAX_DLC);
return CAN_TX_EINVAL; return CAN_TX_EINVAL;
} }
@ -665,28 +665,28 @@ int can_stm32_send(const struct device *dev, const struct zcan_frame *msg,
} }
mb->tx_callback = callback; mb->tx_callback = callback;
mb->callback_arg = callback_arg; mb->callback_arg = user_data;
k_sem_reset(&mb->tx_int_sem); k_sem_reset(&mb->tx_int_sem);
/* mailbox identifier register setup */ /* mailbox identifier register setup */
mailbox->TIR &= CAN_TI0R_TXRQ; mailbox->TIR &= CAN_TI0R_TXRQ;
if (msg->id_type == CAN_STANDARD_IDENTIFIER) { if (frame->id_type == CAN_STANDARD_IDENTIFIER) {
mailbox->TIR |= (msg->id << CAN_TI0R_STID_Pos); mailbox->TIR |= (frame->id << CAN_TI0R_STID_Pos);
} else { } else {
mailbox->TIR |= (msg->id << CAN_TI0R_EXID_Pos) mailbox->TIR |= (frame->id << CAN_TI0R_EXID_Pos)
| CAN_TI0R_IDE; | CAN_TI0R_IDE;
} }
if (msg->rtr == CAN_REMOTEREQUEST) { if (frame->rtr == CAN_REMOTEREQUEST) {
mailbox->TIR |= CAN_TI1R_RTR; mailbox->TIR |= CAN_TI1R_RTR;
} }
mailbox->TDTR = (mailbox->TDTR & ~CAN_TDT1R_DLC) | mailbox->TDTR = (mailbox->TDTR & ~CAN_TDT1R_DLC) |
((msg->dlc & 0xF) << CAN_TDT1R_DLC_Pos); ((frame->dlc & 0xF) << CAN_TDT1R_DLC_Pos);
mailbox->TDLR = msg->data_32[0]; mailbox->TDLR = frame->data_32[0];
mailbox->TDHR = msg->data_32[1]; mailbox->TDHR = frame->data_32[1];
mailbox->TIR |= CAN_TI0R_TXRQ; mailbox->TIR |= CAN_TI0R_TXRQ;
k_mutex_unlock(&data->inst_mutex); k_mutex_unlock(&data->inst_mutex);

4
drivers/can/can_stm32fd.c
View file

@ -100,7 +100,7 @@ enum can_state can_stm32fd_get_state(const struct device *dev,
int can_stm32fd_send(const struct device *dev, const struct zcan_frame *frame, int can_stm32fd_send(const struct device *dev, const struct zcan_frame *frame,
k_timeout_t timeout, can_tx_callback_t callback, k_timeout_t timeout, can_tx_callback_t callback,
void *callback_arg) void *user_data)
{ {
const struct can_stm32fd_config *cfg = DEV_CFG(dev); const struct can_stm32fd_config *cfg = DEV_CFG(dev);
const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg;
@ -108,7 +108,7 @@ int can_stm32fd_send(const struct device *dev, const struct zcan_frame *frame,
struct can_mcan_msg_sram *msg_ram = cfg->msg_sram; struct can_mcan_msg_sram *msg_ram = cfg->msg_sram;
return can_mcan_send(mcan_cfg, mcan_data, msg_ram, frame, timeout, return can_mcan_send(mcan_cfg, mcan_data, msg_ram, frame, timeout,
callback, callback_arg); callback, user_data);
} }
int can_stm32fd_attach_isr(const struct device *dev, can_rx_callback_t isr, int can_stm32fd_attach_isr(const struct device *dev, can_rx_callback_t isr,

8
drivers/can/can_utils.h
View file

@ -11,18 +11,18 @@
#ifndef ZEPHYR_DRIVERS_CAN_CAN_UTILS_H_ #ifndef ZEPHYR_DRIVERS_CAN_CAN_UTILS_H_
#define ZEPHYR_DRIVERS_CAN_CAN_UTILS_H_ #define ZEPHYR_DRIVERS_CAN_CAN_UTILS_H_
static inline uint8_t can_utils_filter_match(const struct zcan_frame *msg, static inline uint8_t can_utils_filter_match(const struct zcan_frame *frame,
struct zcan_filter *filter) struct zcan_filter *filter)
{ {
if (msg->id_type != filter->id_type) { if (frame->id_type != filter->id_type) {
return 0; return 0;
} }
if ((msg->rtr ^ filter->rtr) & filter->rtr_mask) { if ((frame->rtr ^ filter->rtr) & filter->rtr_mask) {
return 0; return 0;
} }
if ((msg->id ^ filter->id) & filter->id_mask) { if ((frame->id ^ filter->id) & filter->id_mask) {
return 0; return 0;
} }

8
drivers/can/socket_can_generic.h
View file

@ -123,18 +123,18 @@ static inline void rx_thread(void *ctx, void *unused1, void *unused2)
{ {
struct socket_can_context *socket_context = ctx; struct socket_can_context *socket_context = ctx;
struct net_pkt *pkt; struct net_pkt *pkt;
struct zcan_frame msg; struct zcan_frame frame;
int ret; int ret;
ARG_UNUSED(unused1); ARG_UNUSED(unused1);
ARG_UNUSED(unused2); ARG_UNUSED(unused2);
while (1) { while (1) {
k_msgq_get((struct k_msgq *)socket_context->msgq, &msg, k_msgq_get((struct k_msgq *)socket_context->msgq, &frame,
K_FOREVER); K_FOREVER);
pkt = net_pkt_rx_alloc_with_buffer(socket_context->iface, pkt = net_pkt_rx_alloc_with_buffer(socket_context->iface,
sizeof(msg), sizeof(frame),
AF_CAN, 0, AF_CAN, 0,
BUF_ALLOC_TIMEOUT); BUF_ALLOC_TIMEOUT);
if (!pkt) { if (!pkt) {
@ -142,7 +142,7 @@ static inline void rx_thread(void *ctx, void *unused1, void *unused2)
continue; continue;
} }
if (net_pkt_write(pkt, (void *)&msg, sizeof(msg))) { if (net_pkt_write(pkt, (void *)&frame, sizeof(frame))) {
LOG_ERR("Failed to append RX data"); LOG_ERR("Failed to append RX data");
net_pkt_unref(pkt); net_pkt_unref(pkt);
continue; continue;