From 5b3712a9ac04c5d232e168357a2a784c1f69e5f8 Mon Sep 17 00:00:00 2001 From: Henrik Brix Andersen Date: Tue, 19 Apr 2022 13:46:30 +0200 Subject: [PATCH] drivers: can: mcan: refactor to get rid of wrapper functions Refactor the Bosch M_CAN shared driver functions to get rid of the front-end driver wrapper functions. This requires flipping the relationship between shared config/data structs and front-end config/data structs. Front-end drivers can now store a pointer to their custom config/data structs in the .custom fields of the can_mcan_config and can_mcan_data data structures. Signed-off-by: Henrik Brix Andersen --- drivers/can/can_mcan.c | 126 ++++++++++------ drivers/can/can_mcan.h | 40 +++-- drivers/can/can_mcux_mcan.c | 154 ++++--------------- drivers/can/can_sam.c | 198 +++++++------------------ drivers/can/can_stm32fd.c | 287 +++++++++++------------------------- drivers/can/can_stm32fd.h | 24 --- drivers/can/can_stm32h7.c | 174 +++++----------------- 7 files changed, 300 insertions(+), 703 deletions(-) delete mode 100644 drivers/can/can_stm32fd.h diff --git a/drivers/can/can_mcan.c b/drivers/can/can_mcan.c index dc2e701d435..290488f6c6a 100644 --- a/drivers/can/can_mcan.c +++ b/drivers/can/can_mcan.c @@ -1,4 +1,5 @@ /* + * Copyright (c) 2022 Vestas Wind Systems A/S * Copyright (c) 2020 Alexander Wachter * * SPDX-License-Identifier: Apache-2.0 @@ -120,7 +121,7 @@ static int can_leave_init_mode(struct can_mcan_reg *can, k_timeout_t timeout) return 0; } -void can_mcan_configure_timing(struct can_mcan_reg *can, +void can_mcan_configure_timing(struct can_mcan_reg *can, const struct can_timing *timing, const struct can_timing *timing_data) { @@ -183,10 +184,11 @@ void can_mcan_configure_timing(struct can_mcan_reg *can, #endif } -int can_mcan_set_timing(const struct can_mcan_config *cfg, +int can_mcan_set_timing(const struct device *dev, const struct can_timing *timing, const struct can_timing *timing_data) { + const struct can_mcan_config *cfg = dev->config; struct can_mcan_reg *can = cfg->can; int ret; @@ -210,8 +212,9 @@ int can_mcan_set_timing(const struct can_mcan_config *cfg, return 0; } -int can_mcan_set_mode(const struct can_mcan_config *cfg, enum can_mode mode) +int can_mcan_set_mode(const struct device *dev, enum can_mode mode) { + const struct can_mcan_config *cfg = dev->config; struct can_mcan_reg *can = cfg->can; int ret; @@ -279,18 +282,18 @@ int can_mcan_set_mode(const struct can_mcan_config *cfg, enum can_mode mode) return 0; } -int can_mcan_init(const struct device *dev, const struct can_mcan_config *cfg, - struct can_mcan_msg_sram *msg_ram, - struct can_mcan_data *data) +int can_mcan_init(const struct device *dev) { - struct can_mcan_reg *can = cfg->can; + const struct can_mcan_config *cfg = dev->config; + struct can_mcan_data *data = dev->data; + struct can_mcan_reg *can = cfg->can; + struct can_mcan_msg_sram *msg_ram = data->msg_ram; struct can_timing timing; #ifdef CONFIG_CAN_FD_MODE struct can_timing timing_data; #endif int ret; - data->dev = dev; k_mutex_init(&data->inst_mutex); k_mutex_init(&data->tx_mtx); k_sem_init(&data->tx_sem, NUM_TX_BUF_ELEMENTS, NUM_TX_BUF_ELEMENTS); @@ -495,25 +498,27 @@ done: return ret; } -static void can_mcan_state_change_handler(const struct can_mcan_config *cfg, - struct can_mcan_data *data) +static void can_mcan_state_change_handler(const struct device *dev) { - enum can_state state; - struct can_bus_err_cnt err_cnt; + struct can_mcan_data *data = dev->data; const can_state_change_callback_t cb = data->state_change_cb; void *cb_data = data->state_change_cb_data; + struct can_bus_err_cnt err_cnt; + enum can_state state; - (void)can_mcan_get_state(cfg, &state, &err_cnt); + (void)can_mcan_get_state(dev, &state, &err_cnt); if (cb != NULL) { - cb(data->dev, state, err_cnt, cb_data); + cb(dev, state, err_cnt, cb_data); } } -static void can_mcan_tc_event_handler(struct can_mcan_reg *can, - struct can_mcan_msg_sram *msg_ram, - struct can_mcan_data *data) +static void can_mcan_tc_event_handler(const struct device *dev) { + const struct can_mcan_config *cfg = dev->config; + struct can_mcan_data *data = dev->data; + struct can_mcan_reg *can = cfg->can; + struct can_mcan_msg_sram *msg_ram = data->msg_ram; volatile struct can_mcan_tx_event_fifo *tx_event; can_tx_callback_t tx_cb; uint32_t event_idx, tx_idx; @@ -534,15 +539,15 @@ static void can_mcan_tc_event_handler(struct can_mcan_reg *can, if (tx_cb == NULL) { k_sem_give(&data->tx_fin_sem[tx_idx]); } else { - tx_cb(data->dev, 0, data->tx_fin_cb_arg[tx_idx]); + tx_cb(dev, 0, data->tx_fin_cb_arg[tx_idx]); } } } -void can_mcan_line_0_isr(const struct can_mcan_config *cfg, - struct can_mcan_msg_sram *msg_ram, - struct can_mcan_data *data) +void can_mcan_line_0_isr(const struct device *dev) { + const struct can_mcan_config *cfg = dev->config; + struct can_mcan_data *data = dev->data; struct can_mcan_reg *can = cfg->can; do { @@ -550,12 +555,12 @@ void can_mcan_line_0_isr(const struct can_mcan_config *cfg, CAN_MCAN_IR_EW)) { can->ir = CAN_MCAN_IR_BO | CAN_MCAN_IR_EP | CAN_MCAN_IR_EW; - can_mcan_state_change_handler(cfg, data); + can_mcan_state_change_handler(dev); } /* TX event FIFO new entry */ if (can->ir & CAN_MCAN_IR_TEFN) { can->ir = CAN_MCAN_IR_TEFN; - can_mcan_tc_event_handler(can, msg_ram, data); + can_mcan_tc_event_handler(dev); } if (can->ir & CAN_MCAN_IR_TEFL) { @@ -578,11 +583,12 @@ void can_mcan_line_0_isr(const struct can_mcan_config *cfg, CAN_MCAN_IR_TEFL | CAN_MCAN_IR_TEFN)); } -static void can_mcan_get_message(struct can_mcan_data *data, +static void can_mcan_get_message(const struct device *dev, volatile struct can_mcan_rx_fifo *fifo, volatile uint32_t *fifo_status_reg, volatile uint32_t *fifo_ack_reg) { + struct can_mcan_data *data = dev->data; uint32_t get_idx, filt_idx; struct zcan_frame frame; can_rx_callback_t cb; @@ -647,7 +653,7 @@ static void can_mcan_get_message(struct can_mcan_data *data, } if (cb) { - cb(data->dev, &frame, cb_arg); + cb(dev, &frame, cb_arg); } else { LOG_DBG("cb missing"); } @@ -659,24 +665,25 @@ static void can_mcan_get_message(struct can_mcan_data *data, } } -void can_mcan_line_1_isr(const struct can_mcan_config *cfg, - struct can_mcan_msg_sram *msg_ram, - struct can_mcan_data *data) +void can_mcan_line_1_isr(const struct device *dev) { + const struct can_mcan_config *cfg = dev->config; + struct can_mcan_data *data = dev->data; struct can_mcan_reg *can = cfg->can; + struct can_mcan_msg_sram *msg_ram = data->msg_ram; do { if (can->ir & CAN_MCAN_IR_RF0N) { can->ir = CAN_MCAN_IR_RF0N; LOG_DBG("RX FIFO0 INT"); - can_mcan_get_message(data, msg_ram->rx_fifo0, + can_mcan_get_message(dev, msg_ram->rx_fifo0, &can->rxf0s, &can->rxf0a); } if (can->ir & CAN_MCAN_IR_RF1N) { can->ir = CAN_MCAN_IR_RF1N; LOG_DBG("RX FIFO1 INT"); - can_mcan_get_message(data, msg_ram->rx_fifo1, + can_mcan_get_message(dev, msg_ram->rx_fifo1, &can->rxf1s, &can->rxf1a); } @@ -694,9 +701,10 @@ void can_mcan_line_1_isr(const struct can_mcan_config *cfg, CAN_MCAN_IR_RF0L | CAN_MCAN_IR_RF1L)); } -int can_mcan_get_state(const struct can_mcan_config *cfg, enum can_state *state, +int can_mcan_get_state(const struct device *dev, enum can_state *state, struct can_bus_err_cnt *err_cnt) { + const struct can_mcan_config *cfg = dev->config; struct can_mcan_reg *can = cfg->can; if (state != NULL) { @@ -723,8 +731,9 @@ int can_mcan_get_state(const struct can_mcan_config *cfg, enum can_state *state, } #ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY -int can_mcan_recover(const struct can_mcan_config *cfg, k_timeout_t timeout) +int can_mcan_recover(const struct device *dev, k_timeout_t timeout) { + const struct can_mcan_config *cfg = dev->config; struct can_mcan_reg *can = cfg->can; return can_leave_init_mode(can, timeout); @@ -732,14 +741,15 @@ int can_mcan_recover(const struct can_mcan_config *cfg, k_timeout_t timeout) #endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */ -int can_mcan_send(const struct can_mcan_config *cfg, - struct can_mcan_data *data, - struct can_mcan_msg_sram *msg_ram, +int can_mcan_send(const struct device *dev, const struct zcan_frame *frame, k_timeout_t timeout, can_tx_callback_t callback, void *user_data) { - struct can_mcan_reg *can = cfg->can; + const struct can_mcan_config *cfg = dev->config; + struct can_mcan_data *data = dev->data; + struct can_mcan_reg *can = cfg->can; + struct can_mcan_msg_sram *msg_ram = data->msg_ram; size_t data_length = can_dlc_to_bytes(frame->dlc); struct can_mcan_tx_buffer_hdr tx_hdr = { .rtr = frame->rtr == CAN_REMOTEREQUEST, @@ -850,11 +860,12 @@ int can_mcan_get_max_filters(const struct device *dev, enum can_ide id_type) * Dual mode gets tricky, because we can only activate both filters. * If one of the IDs is not used anymore, we would need to mark it as unused. */ -int can_mcan_add_rx_filter_std(struct can_mcan_data *data, - struct can_mcan_msg_sram *msg_ram, +int can_mcan_add_rx_filter_std(const struct device *dev, can_rx_callback_t callback, void *user_data, const struct zcan_filter *filter) { + struct can_mcan_data *data = dev->data; + struct can_mcan_msg_sram *msg_ram = data->msg_ram; struct can_mcan_std_filter filter_element = { .id1 = filter->id, .id2 = filter->id_mask, @@ -912,11 +923,12 @@ static int can_mcan_get_free_ext(volatile struct can_mcan_ext_filter *filters) return -ENOSPC; } -static int can_mcan_add_rx_filter_ext(struct can_mcan_data *data, - struct can_mcan_msg_sram *msg_ram, +static int can_mcan_add_rx_filter_ext(const struct device *dev, can_rx_callback_t callback, void *user_data, const struct zcan_filter *filter) { + struct can_mcan_data *data = dev->data; + struct can_mcan_msg_sram *msg_ram = data->msg_ram; struct can_mcan_ext_filter filter_element = { .id2 = filter->id_mask, .id1 = filter->id, @@ -963,8 +975,7 @@ static int can_mcan_add_rx_filter_ext(struct can_mcan_data *data, return filter_id; } -int can_mcan_add_rx_filter(struct can_mcan_data *data, - struct can_mcan_msg_sram *msg_ram, +int can_mcan_add_rx_filter(const struct device *dev, can_rx_callback_t callback, void *user_data, const struct zcan_filter *filter) { @@ -975,11 +986,9 @@ int can_mcan_add_rx_filter(struct can_mcan_data *data, } if (filter->id_type == CAN_STANDARD_IDENTIFIER) { - filter_id = can_mcan_add_rx_filter_std(data, msg_ram, callback, - user_data, filter); + filter_id = can_mcan_add_rx_filter_std(dev, callback, user_data, filter); } else { - filter_id = can_mcan_add_rx_filter_ext(data, msg_ram, callback, - user_data, filter); + filter_id = can_mcan_add_rx_filter_ext(dev, callback, user_data, filter); if (filter_id >= 0) { filter_id += NUM_STD_FILTER_DATA; } @@ -988,9 +997,11 @@ int can_mcan_add_rx_filter(struct can_mcan_data *data, return filter_id; } -void can_mcan_remove_rx_filter(struct can_mcan_data *data, - struct can_mcan_msg_sram *msg_ram, int filter_id) +void can_mcan_remove_rx_filter(const struct device *dev, int filter_id) { + struct can_mcan_data *data = dev->data; + struct can_mcan_msg_sram *msg_ram = data->msg_ram; + k_mutex_lock(&data->inst_mutex, K_FOREVER); if (filter_id >= NUM_STD_FILTER_DATA) { filter_id -= NUM_STD_FILTER_DATA; @@ -1012,3 +1023,22 @@ void can_mcan_remove_rx_filter(struct can_mcan_data *data, k_mutex_unlock(&data->inst_mutex); } + +void can_mcan_set_state_change_callback(const struct device *dev, + can_state_change_callback_t callback, + void *user_data) +{ + struct can_mcan_data *data = dev->data; + + data->state_change_cb = callback; + data->state_change_cb_data = user_data; +} + +int can_mcan_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate) +{ + const struct can_mcan_config *cfg = dev->config; + + *max_bitrate = cfg->max_bitrate; + + return 0; +} diff --git a/drivers/can/can_mcan.h b/drivers/can/can_mcan.h index 3c99ea4752d..ce791f5d4f8 100644 --- a/drivers/can/can_mcan.h +++ b/drivers/can/can_mcan.h @@ -166,7 +166,7 @@ struct can_mcan_msg_sram { } __packed __aligned(4); struct can_mcan_data { - const struct device *dev; + struct can_mcan_msg_sram *msg_ram; struct k_mutex inst_mutex; struct k_sem tx_sem; struct k_mutex tx_mtx; @@ -184,6 +184,7 @@ struct can_mcan_data { uint8_t ext_filt_rtr; uint8_t ext_filt_rtr_mask; struct can_mcan_mm mm; + void *custom; } __aligned(4); struct can_mcan_config { @@ -203,47 +204,44 @@ struct can_mcan_config { #endif const struct device *phy; uint32_t max_bitrate; + const void *custom; }; struct can_mcan_reg; -int can_mcan_set_mode(const struct can_mcan_config *cfg, enum can_mode mode); +int can_mcan_set_mode(const struct device *dev, enum can_mode mode); -int can_mcan_set_timing(const struct can_mcan_config *cfg, +int can_mcan_set_timing(const struct device *dev, const struct can_timing *timing, const struct can_timing *timing_data); -int can_mcan_init(const struct device *dev, const struct can_mcan_config *cfg, - struct can_mcan_msg_sram *msg_ram, - struct can_mcan_data *data); +int can_mcan_init(const struct device *dev); -void can_mcan_line_0_isr(const struct can_mcan_config *cfg, - struct can_mcan_msg_sram *msg_ram, - struct can_mcan_data *data); +void can_mcan_line_0_isr(const struct device *dev); -void can_mcan_line_1_isr(const struct can_mcan_config *cfg, - struct can_mcan_msg_sram *msg_ram, - struct can_mcan_data *data); +void can_mcan_line_1_isr(const struct device *dev); -int can_mcan_recover(const struct can_mcan_config *cfg, k_timeout_t timeout); +int can_mcan_recover(const struct device *dev, k_timeout_t timeout); -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, +int can_mcan_send(const struct device *dev, const struct zcan_frame *frame, k_timeout_t timeout, can_tx_callback_t callback, void *user_data); int can_mcan_get_max_filters(const struct device *dev, enum can_ide id_type); -int can_mcan_add_rx_filter(struct can_mcan_data *data, - struct can_mcan_msg_sram *msg_ram, +int can_mcan_add_rx_filter(const struct device *dev, can_rx_callback_t callback, void *user_data, const struct zcan_filter *filter); -void can_mcan_remove_rx_filter(struct can_mcan_data *data, - struct can_mcan_msg_sram *msg_ram, int filter_id); +void can_mcan_remove_rx_filter(const struct device *dev, int filter_id); -int can_mcan_get_state(const struct can_mcan_config *cfg, enum can_state *state, +int can_mcan_get_state(const struct device *dev, enum can_state *state, struct can_bus_err_cnt *err_cnt); +void can_mcan_set_state_change_callback(const struct device *dev, + can_state_change_callback_t callback, + void *user_data); + +int can_mcan_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate); + #endif /* ZEPHYR_DRIVERS_CAN_MCAN_H_ */ diff --git a/drivers/can/can_mcux_mcan.c b/drivers/can/can_mcux_mcan.c index 9ba761f1b35..066fdb359da 100644 --- a/drivers/can/can_mcux_mcan.c +++ b/drivers/can/can_mcux_mcan.c @@ -6,7 +6,6 @@ #include #include -#include #include #include @@ -17,159 +16,61 @@ LOG_MODULE_REGISTER(can_mcux_mcan, CONFIG_CAN_LOG_LEVEL); #define DT_DRV_COMPAT nxp_lpc_mcan struct mcux_mcan_config { - struct can_mcan_config mcan; const struct device *clock_dev; clock_control_subsys_t clock_subsys; void (*irq_config_func)(const struct device *dev); }; struct mcux_mcan_data { - struct can_mcan_data mcan; struct can_mcan_msg_sram msg_ram __nocache; }; -static int mcux_mcan_set_mode(const struct device *dev, enum can_mode mode) -{ - const struct mcux_mcan_config *config = dev->config; - - return can_mcan_set_mode(&config->mcan, mode); -} - -static int mcux_mcan_set_timing(const struct device *dev, - const struct can_timing *timing, - const struct can_timing *timing_data) -{ - const struct mcux_mcan_config *config = dev->config; - - return can_mcan_set_timing(&config->mcan, timing, timing_data); -} - -static int mcux_mcan_send(const struct device *dev, const struct zcan_frame *msg, - k_timeout_t timeout, can_tx_callback_t callback, - void *user_data) -{ - const struct mcux_mcan_config *config = dev->config; - struct mcux_mcan_data *data = dev->data; - - return can_mcan_send(&config->mcan, &data->mcan, &data->msg_ram, - msg, timeout, callback, user_data); -} - -static int mcux_mcan_add_rx_filter(const struct device *dev, - can_rx_callback_t cb, - void *user_data, - const struct zcan_filter *filter) -{ - struct mcux_mcan_data *data = dev->data; - - return can_mcan_add_rx_filter(&data->mcan, &data->msg_ram, - cb, user_data, filter); -} - -static void mcux_mcan_remove_rx_filter(const struct device *dev, int filter_id) -{ - struct mcux_mcan_data *data = dev->data; - - can_mcan_remove_rx_filter(&data->mcan, &data->msg_ram, filter_id); -} - -static int mcux_mcan_get_state(const struct device *dev, enum can_state *state, - struct can_bus_err_cnt *err_cnt) -{ - const struct mcux_mcan_config *config = dev->config; - - return can_mcan_get_state(&config->mcan, state, err_cnt); -} - -static void mcux_mcan_set_state_change_callback(const struct device *dev, - can_state_change_callback_t cb, - void *user_data) -{ - struct mcux_mcan_data *data = dev->data; - - data->mcan.state_change_cb = cb; - data->mcan.state_change_cb_data = user_data; -} - static int mcux_mcan_get_core_clock(const struct device *dev, uint32_t *rate) { - const struct mcux_mcan_config *config = dev->config; + const struct can_mcan_config *mcan_config = dev->config; + const struct mcux_mcan_config *mcux_config = mcan_config->custom; - return clock_control_get_rate(config->clock_dev, config->clock_subsys, + return clock_control_get_rate(mcux_config->clock_dev, mcux_config->clock_subsys, rate); } -static int mcux_mcan_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate) -{ - const struct mcux_mcan_config *config = dev->config; - - *max_bitrate = config->mcan.max_bitrate; - - return 0; -} - -#ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY -static int mcux_mcan_recover(const struct device *dev, k_timeout_t timeout) -{ - const struct mcux_mcan_config *config = dev->config; - - return can_mcan_recover(&config->mcan, timeout); -} -#endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */ - -static void mcux_mcan_line_0_isr(const struct device *dev) -{ - const struct mcux_mcan_config *config = dev->config; - struct mcux_mcan_data *data = dev->data; - - can_mcan_line_0_isr(&config->mcan, &data->msg_ram, &data->mcan); -} - -static void mcux_mcan_line_1_isr(const struct device *dev) -{ - const struct mcux_mcan_config *config = dev->config; - struct mcux_mcan_data *data = dev->data; - - can_mcan_line_1_isr(&config->mcan, &data->msg_ram, &data->mcan); -} - static int mcux_mcan_init(const struct device *dev) { - const struct mcux_mcan_config *config = dev->config; - struct mcux_mcan_data *data = dev->data; + const struct can_mcan_config *mcan_config = dev->config; + const struct mcux_mcan_config *mcux_config = mcan_config->custom; int err; - err = clock_control_on(config->clock_dev, config->clock_subsys); + err = clock_control_on(mcux_config->clock_dev, mcux_config->clock_subsys); if (err) { LOG_ERR("failed to enable clock (err %d)", err); return -EINVAL; } - err = can_mcan_init(dev, &config->mcan, &data->msg_ram, &data->mcan); + err = can_mcan_init(dev); if (err) { LOG_ERR("failed to initialize mcan (err %d)", err); return err; } - config->irq_config_func(dev); + mcux_config->irq_config_func(dev); return 0; } static const struct can_driver_api mcux_mcan_driver_api = { - .set_mode = mcux_mcan_set_mode, - .set_timing = mcux_mcan_set_timing, - .send = mcux_mcan_send, - .add_rx_filter = mcux_mcan_add_rx_filter, - .remove_rx_filter = mcux_mcan_remove_rx_filter, + .set_mode = can_mcan_set_mode, + .set_timing = can_mcan_set_timing, + .send = can_mcan_send, + .add_rx_filter = can_mcan_add_rx_filter, + .remove_rx_filter = can_mcan_remove_rx_filter, #ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY - .recover = mcux_mcan_recover, + .recover = can_mcan_recover, #endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */ - .get_state = mcux_mcan_get_state, - .set_state_change_callback = mcux_mcan_set_state_change_callback, + .get_state = can_mcan_get_state, + .set_state_change_callback = can_mcan_set_state_change_callback, .get_core_clock = mcux_mcan_get_core_clock, .get_max_filters = can_mcan_get_max_filters, - .get_max_bitrate = mcux_mcan_get_max_bitrate, + .get_max_bitrate = can_mcan_get_max_bitrate, /* * MCUX MCAN timing limits are specified in the "Nominal bit timing and * prescaler register (NBTP)" table in the SoC reference manual. @@ -239,6 +140,7 @@ static const struct can_driver_api mcux_mcan_driver_api = { DT_INST_PROP(n, tx_delay_comp_offset), \ .phy = DEVICE_DT_GET_OR_NULL(DT_INST_PHANDLE(n, phys)), \ .max_bitrate = DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(n, 5000000), \ + .custom = &mcux_mcan_config_##n, \ } #else /* CONFIG_CAN_FD_MODE */ #define MCUX_MCAN_MCAN_INIT(n) \ @@ -252,6 +154,7 @@ static const struct can_driver_api mcux_mcan_driver_api = { .ts2 = DT_INST_PROP_OR(n, phase_seg2, 0), \ .phy = DEVICE_DT_GET_OR_NULL(DT_INST_PHANDLE(n, phys)), \ .max_bitrate = DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(n, 1000000), \ + .custom = &mcux_mcan_config_##n, \ } #endif /* !CONFIG_CAN_FD_MODE */ @@ -259,33 +162,40 @@ static const struct can_driver_api mcux_mcan_driver_api = { static void mcux_mcan_irq_config_##n(const struct device *dev); \ \ static const struct mcux_mcan_config mcux_mcan_config_##n = { \ - .mcan = MCUX_MCAN_MCAN_INIT(n), \ .clock_dev = DEVICE_DT_GET(DT_INST_CLOCKS_CTLR(n)), \ .clock_subsys = (clock_control_subsys_t) \ DT_INST_CLOCKS_CELL(n, name), \ .irq_config_func = mcux_mcan_irq_config_##n, \ }; \ \ + static const struct can_mcan_config can_mcan_config_##n = \ + MCUX_MCAN_MCAN_INIT(n); \ + \ static struct mcux_mcan_data mcux_mcan_data_##n; \ \ + static struct can_mcan_data can_mcan_data_##n = { \ + .msg_ram = &mcux_mcan_data_##n.msg_ram, \ + .custom = &mcux_mcan_data_##n, \ + }; \ + \ DEVICE_DT_INST_DEFINE(n, &mcux_mcan_init, NULL, \ - &mcux_mcan_data_##n, \ - &mcux_mcan_config_##n, \ + &can_mcan_data_##n, \ + &can_mcan_config_##n, \ POST_KERNEL, \ - CONFIG_KERNEL_INIT_PRIORITY_DEVICE, \ + CONFIG_CAN_INIT_PRIORITY, \ &mcux_mcan_driver_api); \ \ static void mcux_mcan_irq_config_##n(const struct device *dev) \ { \ IRQ_CONNECT(DT_INST_IRQ_BY_IDX(n, 0, irq), \ DT_INST_IRQ_BY_IDX(n, 0, priority), \ - mcux_mcan_line_0_isr, \ + can_mcan_line_0_isr, \ DEVICE_DT_INST_GET(n), 0); \ irq_enable(DT_INST_IRQ_BY_IDX(n, 0, irq)); \ \ IRQ_CONNECT(DT_INST_IRQ_BY_IDX(n, 1, irq), \ DT_INST_IRQ_BY_IDX(n, 1, priority), \ - mcux_mcan_line_1_isr, \ + can_mcan_line_1_isr, \ DEVICE_DT_INST_GET(n), 0); \ irq_enable(DT_INST_IRQ_BY_IDX(n, 1, irq)); \ } diff --git a/drivers/can/can_sam.c b/drivers/can/can_sam.c index b5c7c2880ca..86f55872def 100644 --- a/drivers/can/can_sam.c +++ b/drivers/can/can_sam.c @@ -1,51 +1,41 @@ /* + * Copyright (c) 2022 Vestas Wind Systems A/S * Copyright (c) 2021 Alexander Wachter * * SPDX-License-Identifier: Apache-2.0 */ -#include "can_mcan.h" - #include -#include #include #include #include #include +#include "can_mcan.h" + LOG_MODULE_REGISTER(can_sam, CONFIG_CAN_LOG_LEVEL); #define DT_DRV_COMPAT atmel_sam_can struct can_sam_config { - struct can_mcan_config mcan_cfg; void (*config_irq)(void); const struct pinctrl_dev_config *pcfg; uint8_t pmc_id; }; struct can_sam_data { - struct can_mcan_data mcan_data; struct can_mcan_msg_sram msg_ram; }; - static int can_sam_get_core_clock(const struct device *dev, uint32_t *rate) { + ARG_UNUSED(dev); + *rate = SOC_ATMEL_SAM_MCK_FREQ_HZ / (CONFIG_CAN_SAM_CKDIV + 1); + return 0; } -static void can_sam_set_state_change_callback(const struct device *dev, - can_state_change_callback_t cb, - void *user_data) -{ - struct can_sam_data *data = dev->data; - - data->mcan_data.state_change_cb_data = user_data; - data->mcan_data.state_change_cb = cb; -} - static void can_sam_clock_enable(const struct can_sam_config *cfg) { REG_PMC_PCK5 = PMC_PCK_CSS_PLLA_CLK | PMC_PCK_PRES(CONFIG_CAN_SAM_CKDIV); @@ -55,141 +45,41 @@ static void can_sam_clock_enable(const struct can_sam_config *cfg) static int can_sam_init(const struct device *dev) { - const struct can_sam_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - struct can_sam_data *data = dev->data; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = &data->msg_ram; + const struct can_mcan_config *mcan_cfg = dev->config; + const struct can_sam_config *sam_cfg = mcan_cfg->custom; int ret; - can_sam_clock_enable(cfg); + can_sam_clock_enable(sam_cfg); - ret = pinctrl_apply_state(cfg->pcfg, PINCTRL_STATE_DEFAULT); + ret = pinctrl_apply_state(sam_cfg->pcfg, PINCTRL_STATE_DEFAULT); if (ret < 0) { return ret; } - ret = can_mcan_init(dev, mcan_cfg, msg_ram, mcan_data); - if (ret) { + ret = can_mcan_init(dev); + if (ret != 0) { return ret; } - cfg->config_irq(); + sam_cfg->config_irq(); return ret; } -static int can_sam_get_state(const struct device *dev, enum can_state *state, - struct can_bus_err_cnt *err_cnt) -{ - const struct can_sam_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - - return can_mcan_get_state(mcan_cfg, state, err_cnt); -} - -static int can_sam_send(const struct device *dev, const struct zcan_frame *frame, - k_timeout_t timeout, can_tx_callback_t callback, void *user_data) -{ - const struct can_sam_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - struct can_sam_data *data = dev->data; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = &data->msg_ram; - - return can_mcan_send(mcan_cfg, mcan_data, msg_ram, frame, timeout, callback, user_data); -} - -static int can_sam_add_rx_filter(const struct device *dev, can_rx_callback_t cb, void *cb_arg, - const struct zcan_filter *filter) -{ - struct can_sam_data *data = dev->data; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = &data->msg_ram; - - return can_mcan_add_rx_filter(mcan_data, msg_ram, cb, cb_arg, filter); -} - -static void can_sam_remove_rx_filter(const struct device *dev, int filter_id) -{ - struct can_sam_data *data = dev->data; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = &data->msg_ram; - - can_mcan_remove_rx_filter(mcan_data, msg_ram, filter_id); -} - -static int can_sam_set_mode(const struct device *dev, enum can_mode mode) -{ - const struct can_sam_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - - return can_mcan_set_mode(mcan_cfg, mode); -} - -static int can_sam_set_timing(const struct device *dev, const struct can_timing *timing, - const struct can_timing *timing_data) -{ - const struct can_sam_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - - return can_mcan_set_timing(mcan_cfg, timing, timing_data); -} - -static int can_sam_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate) -{ - const struct can_sam_config *cfg = dev->config; - - *max_bitrate = cfg->mcan_cfg.max_bitrate; - - return 0; -} - +static const struct can_driver_api can_sam_driver_api = { + .set_mode = can_mcan_set_mode, + .set_timing = can_mcan_set_timing, + .send = can_mcan_send, + .add_rx_filter = can_mcan_add_rx_filter, + .remove_rx_filter = can_mcan_remove_rx_filter, + .get_state = can_mcan_get_state, #ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY -static int can_sam_recover(const struct device *dev, k_timeout_t timeout) -{ - const struct can_sam_config *cfg = dev->config; - - return can_mcan_recover(&cfg->mcan_cfg, timeout); -} + .recover = can_mcan_recover, #endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */ - -static void can_sam_line_0_isr(const struct device *dev) -{ - const struct can_sam_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - struct can_sam_data *data = dev->data; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = &data->msg_ram; - - can_mcan_line_0_isr(mcan_cfg, msg_ram, mcan_data); -} - -static void can_sam_line_1_isr(const struct device *dev) -{ - const struct can_sam_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - struct can_sam_data *data = dev->data; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = &data->msg_ram; - - can_mcan_line_1_isr(mcan_cfg, msg_ram, mcan_data); -} - -static const struct can_driver_api can_api_funcs = { - .set_mode = can_sam_set_mode, - .set_timing = can_sam_set_timing, - .send = can_sam_send, - .add_rx_filter = can_sam_add_rx_filter, - .remove_rx_filter = can_sam_remove_rx_filter, - .get_state = can_sam_get_state, -#ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY - .recover = can_sam_recover, -#endif .get_core_clock = can_sam_get_core_clock, .get_max_filters = can_mcan_get_max_filters, - .get_max_bitrate = can_sam_get_max_bitrate, - .set_state_change_callback = can_sam_set_state_change_callback, + .get_max_bitrate = can_mcan_get_max_bitrate, + .set_state_change_callback = can_mcan_set_state_change_callback, .timing_min = { .sjw = 0x1, .prop_seg = 0x00, @@ -219,7 +109,7 @@ static const struct can_driver_api can_api_funcs = { .phase_seg2 = 0x10, .prescaler = 0x20 } -#endif +#endif /* CONFIG_CAN_FD_MODE */ }; #define CAN_SAM_IRQ_CFG_FUNCTION(inst) \ @@ -227,11 +117,11 @@ static void config_can_##inst##_irq(void) { \ LOG_DBG("Enable CAN##inst## IRQ"); \ IRQ_CONNECT(DT_INST_IRQ_BY_NAME(inst, line_0, irq), \ - DT_INST_IRQ_BY_NAME(inst, line_0, priority), can_sam_line_0_isr, \ + DT_INST_IRQ_BY_NAME(inst, line_0, priority), can_mcan_line_0_isr, \ DEVICE_DT_INST_GET(inst), 0); \ irq_enable(DT_INST_IRQ_BY_NAME(inst, line_0, irq)); \ IRQ_CONNECT(DT_INST_IRQ_BY_NAME(inst, line_1, irq), \ - DT_INST_IRQ_BY_NAME(inst, line_1, priority), can_sam_line_1_isr, \ + DT_INST_IRQ_BY_NAME(inst, line_1, priority), can_mcan_line_1_isr, \ DEVICE_DT_INST_GET(inst), 0); \ irq_enable(DT_INST_IRQ_BY_NAME(inst, line_1, irq)); \ } @@ -253,6 +143,7 @@ static void config_can_##inst##_irq(void) .tx_delay_comp_offset = DT_INST_PROP(inst, tx_delay_comp_offset), \ .phy = DEVICE_DT_GET_OR_NULL(DT_INST_PHANDLE(inst, phys)), \ .max_bitrate = DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(inst, 5000000), \ + .custom = &can_sam_cfg_##inst, \ } #else /* CONFIG_CAN_FD_MODE */ #define CAN_SAM_MCAN_CFG(inst) \ @@ -264,23 +155,34 @@ static void config_can_##inst##_irq(void) .ts2 = DT_INST_PROP_OR(inst, phase_seg2, 0), \ .phy = DEVICE_DT_GET_OR_NULL(DT_INST_PHANDLE(inst, phys)), \ .max_bitrate = DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(inst, 1000000), \ + .custom = &can_sam_cfg_##inst, \ } #endif /* CONFIG_CAN_FD_MODE */ -#define CAN_SAM_CFG_INST(inst) \ -static const struct can_sam_config can_sam_cfg_##inst = { \ - .pmc_id = DT_INST_PROP(inst, peripheral_id), \ - .pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst), \ - .config_irq = config_can_##inst##_irq, \ - .mcan_cfg = CAN_SAM_MCAN_CFG(inst) \ -}; +#define CAN_SAM_CFG_INST(inst) \ + static const struct can_sam_config can_sam_cfg_##inst = { \ + .pmc_id = DT_INST_PROP(inst, peripheral_id), \ + .pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst), \ + .config_irq = config_can_##inst##_irq, \ + }; \ + \ + static const struct can_mcan_config can_mcan_cfg_##inst = \ + CAN_SAM_MCAN_CFG(inst); -#define CAN_SAM_DATA_INST(inst) static struct can_sam_data can_sam_dev_data_##inst; +#define CAN_SAM_DATA_INST(inst) \ + static struct can_sam_data can_sam_data_##inst; \ + \ + static struct can_mcan_data can_mcan_data_##inst = { \ + .msg_ram = &can_sam_data_##inst.msg_ram, \ + .custom = &can_sam_data_##inst, \ + }; \ -#define CAN_SAM_DEVICE_INST(inst) \ -DEVICE_DT_INST_DEFINE(inst, &can_sam_init, NULL, &can_sam_dev_data_##inst, \ - &can_sam_cfg_##inst, POST_KERNEL, CONFIG_CAN_INIT_PRIORITY, \ - &can_api_funcs); +#define CAN_SAM_DEVICE_INST(inst) \ + DEVICE_DT_INST_DEFINE(inst, &can_sam_init, NULL, \ + &can_mcan_data_##inst, \ + &can_mcan_cfg_##inst, \ + POST_KERNEL, CONFIG_CAN_INIT_PRIORITY, \ + &can_sam_driver_api); #define CAN_SAM_INST(inst) \ PINCTRL_DT_INST_DEFINE(inst); \ diff --git a/drivers/can/can_stm32fd.c b/drivers/can/can_stm32fd.c index 696fd1a8330..0ee8cba5dc8 100644 --- a/drivers/can/can_stm32fd.c +++ b/drivers/can/can_stm32fd.c @@ -1,18 +1,18 @@ /* + * Copyright (c) 2022 Vestas Wind Systems A/S * Copyright (c) 2020 Alexander Wachter * * SPDX-License-Identifier: Apache-2.0 */ #include -#include #include #include #include #include #include -#include "can_stm32fd.h" +#include "can_mcan.h" LOG_MODULE_REGISTER(can_stm32fd, CONFIG_CAN_LOG_LEVEL); @@ -38,11 +38,17 @@ LOG_MODULE_REGISTER(can_stm32fd, CONFIG_CAN_LOG_LEVEL); #define DT_DRV_COMPAT st_stm32_fdcan +struct can_stm32fd_config { + void (*config_irq)(void); + const struct pinctrl_dev_config *pcfg; +}; + static int can_stm32fd_get_core_clock(const struct device *dev, uint32_t *rate) { - ARG_UNUSED(dev); const uint32_t rate_tmp = LL_RCC_GetFDCANClockFreq(LL_RCC_FDCAN_CLKSOURCE); + ARG_UNUSED(dev); + if (rate_tmp == LL_RCC_PERIPH_FREQUENCY_NO) { LOG_ERR("Can't read core clock"); return -EIO; @@ -61,159 +67,44 @@ static void can_stm32fd_clock_enable(void) FDCAN_CONFIG->CKDIV = CAN_STM32FD_CLOCK_DIVISOR >> 1; } -static void can_stm32fd_set_state_change_callback(const struct device *dev, - can_state_change_callback_t cb, - void *user_data) -{ - struct can_stm32fd_data *data = dev->data; - - data->mcan_data.state_change_cb = cb; - data->mcan_data.state_change_cb_data = user_data; -} - static int can_stm32fd_init(const struct device *dev) { - const struct can_stm32fd_config *cfg = dev->config; - struct can_stm32fd_data *data = dev->data; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = cfg->msg_sram; + const struct can_mcan_config *mcan_cfg = dev->config; + const struct can_stm32fd_config *stm32fd_cfg = mcan_cfg->custom; int ret; /* Configure dt provided device signals when available */ - ret = pinctrl_apply_state(cfg->pcfg, PINCTRL_STATE_DEFAULT); + ret = pinctrl_apply_state(stm32fd_cfg->pcfg, PINCTRL_STATE_DEFAULT); if (ret < 0) { LOG_ERR("CAN pinctrl setup failed (%d)", ret); return ret; } can_stm32fd_clock_enable(); - ret = can_mcan_init(dev, mcan_cfg, msg_ram, mcan_data); - if (ret) { + ret = can_mcan_init(dev); + if (ret != 0) { return ret; } - cfg->config_irq(); + stm32fd_cfg->config_irq(); return ret; } -static int can_stm32fd_get_state(const struct device *dev, enum can_state *state, - struct can_bus_err_cnt *err_cnt) -{ - const struct can_stm32fd_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - - return can_mcan_get_state(mcan_cfg, state, err_cnt); -} - -static int can_stm32fd_send(const struct device *dev, const struct zcan_frame *frame, - k_timeout_t timeout, can_tx_callback_t callback, - void *user_data) -{ - const struct can_stm32fd_config *cfg = dev->config; - struct can_stm32fd_data *data = dev->data; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = cfg->msg_sram; - - return can_mcan_send(mcan_cfg, mcan_data, msg_ram, frame, timeout, - callback, user_data); -} - -static int can_stm32fd_add_rx_filter(const struct device *dev, can_rx_callback_t callback, - void *user_data, const struct zcan_filter *filter) -{ - const struct can_stm32fd_config *cfg = dev->config; - struct can_stm32fd_data *data = dev->data; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = cfg->msg_sram; - - return can_mcan_add_rx_filter(mcan_data, msg_ram, callback, user_data, filter); -} - -static void can_stm32fd_remove_rx_filter(const struct device *dev, int filter_id) -{ - const struct can_stm32fd_config *cfg = dev->config; - struct can_stm32fd_data *data = dev->data; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = cfg->msg_sram; - - can_mcan_remove_rx_filter(mcan_data, msg_ram, filter_id); -} - -static int can_stm32fd_set_mode(const struct device *dev, enum can_mode mode) -{ - const struct can_stm32fd_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - - return can_mcan_set_mode(mcan_cfg, mode); -} - -static int can_stm32fd_set_timing(const struct device *dev, - const struct can_timing *timing, - const struct can_timing *timing_data) -{ - const struct can_stm32fd_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - - return can_mcan_set_timing(mcan_cfg, timing, timing_data); -} - -static int can_stm32fd_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate) -{ - const struct can_stm32fd_config *cfg = dev->config; - - *max_bitrate = cfg->mcan_cfg.max_bitrate; - - return 0; -} - +static const struct can_driver_api can_stm32fd_driver_api = { + .set_mode = can_mcan_set_mode, + .set_timing = can_mcan_set_timing, + .send = can_mcan_send, + .add_rx_filter = can_mcan_add_rx_filter, + .remove_rx_filter = can_mcan_remove_rx_filter, + .get_state = can_mcan_get_state, #ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY -static int can_stm32fd_recover(const struct device *dev, k_timeout_t timeout) -{ - const struct can_stm32fd_config *cfg = dev->config; - - return can_mcan_recover(&cfg->mcan_cfg, timeout); -} + .recover = can_mcan_recover, #endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */ - -static void can_stm32fd_line_0_isr(const struct device *dev) -{ - const struct can_stm32fd_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - struct can_stm32fd_data *data = dev->data; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = cfg->msg_sram; - - can_mcan_line_0_isr(mcan_cfg, msg_ram, mcan_data); -} - -static void can_stm32fd_line_1_isr(const struct device *dev) -{ - const struct can_stm32fd_config *cfg = dev->config; - const struct can_mcan_config *mcan_cfg = &cfg->mcan_cfg; - struct can_stm32fd_data *data = dev->data; - struct can_mcan_data *mcan_data = &data->mcan_data; - struct can_mcan_msg_sram *msg_ram = cfg->msg_sram; - - can_mcan_line_1_isr(mcan_cfg, msg_ram, mcan_data); -} - -static const struct can_driver_api can_api_funcs = { - .set_mode = can_stm32fd_set_mode, - .set_timing = can_stm32fd_set_timing, - .send = can_stm32fd_send, - .add_rx_filter = can_stm32fd_add_rx_filter, - .remove_rx_filter = can_stm32fd_remove_rx_filter, - .get_state = can_stm32fd_get_state, -#ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY - .recover = can_stm32fd_recover, -#endif .get_core_clock = can_stm32fd_get_core_clock, - .get_max_bitrate = can_stm32fd_get_max_bitrate, + .get_max_bitrate = can_mcan_get_max_bitrate, .get_max_filters = can_mcan_get_max_filters, - .set_state_change_callback = can_stm32fd_set_state_change_callback, + .set_state_change_callback = can_mcan_set_state_change_callback, .timing_min = { .sjw = 0x01, .prop_seg = 0x00, @@ -243,7 +134,7 @@ static const struct can_driver_api can_api_funcs = { .phase_seg2 = 0x10, .prescaler = 0x20 } -#endif +#endif /* CONFIG_CAN_FD_MODE */ }; #define CAN_STM32FD_IRQ_CFG_FUNCTION(inst) \ @@ -252,85 +143,77 @@ static void config_can_##inst##_irq(void) \ LOG_DBG("Enable CAN" #inst " IRQ"); \ IRQ_CONNECT(DT_INST_IRQ_BY_NAME(inst, line_0, irq), \ DT_INST_IRQ_BY_NAME(inst, line_0, priority), \ - can_stm32fd_line_0_isr, DEVICE_DT_INST_GET(inst), 0); \ + can_mcan_line_0_isr, DEVICE_DT_INST_GET(inst), 0); \ irq_enable(DT_INST_IRQ_BY_NAME(inst, line_0, irq)); \ IRQ_CONNECT(DT_INST_IRQ_BY_NAME(inst, line_1, irq), \ DT_INST_IRQ_BY_NAME(inst, line_1, priority), \ - can_stm32fd_line_1_isr, DEVICE_DT_INST_GET(inst), 0); \ + can_mcan_line_1_isr, DEVICE_DT_INST_GET(inst), 0); \ irq_enable(DT_INST_IRQ_BY_NAME(inst, line_1, irq)); \ } #ifdef CONFIG_CAN_FD_MODE -#define CAN_STM32FD_CFG_INST(inst) \ - \ -PINCTRL_DT_INST_DEFINE(inst); \ - \ -static const struct can_stm32fd_config can_stm32fd_cfg_##inst = { \ - .msg_sram = (struct can_mcan_msg_sram *) \ - DT_INST_REG_ADDR_BY_NAME(inst, message_ram), \ - .config_irq = config_can_##inst##_irq, \ - .mcan_cfg = { \ - .can = (struct can_mcan_reg *) \ - DT_INST_REG_ADDR_BY_NAME(inst, m_can), \ - .bus_speed = DT_INST_PROP(inst, bus_speed), \ - .sjw = DT_INST_PROP(inst, sjw), \ - .sample_point = DT_INST_PROP_OR(inst, sample_point, 0), \ - .prop_ts1 = DT_INST_PROP_OR(inst, prop_seg, 0) + \ - DT_INST_PROP_OR(inst, phase_seg1, 0), \ - .ts2 = DT_INST_PROP_OR(inst, phase_seg2, 0), \ - .bus_speed_data = DT_INST_PROP(inst, bus_speed_data), \ - .sjw_data = DT_INST_PROP(inst, sjw_data), \ - .sample_point_data = \ - DT_INST_PROP_OR(inst, sample_point_data, 0), \ - .prop_ts1_data = DT_INST_PROP_OR(inst, prop_seg_data, 0) + \ - DT_INST_PROP_OR(inst, phase_seg1_data, 0), \ - .ts2_data = DT_INST_PROP_OR(inst, phase_seg2_data, 0), \ - .tx_delay_comp_offset = \ - DT_INST_PROP(inst, tx_delay_comp_offset), \ - .phy = DEVICE_DT_GET_OR_NULL(DT_INST_PHANDLE(inst, phys)), \ - .max_bitrate = \ - DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(inst, 5000000), \ - }, \ - .pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst), \ -}; - +#define CAN_STM32FD_CFG_INST(inst) \ + PINCTRL_DT_INST_DEFINE(inst); \ + \ + static const struct can_stm32fd_config can_stm32fd_cfg_##inst = { \ + .config_irq = config_can_##inst##_irq, \ + .pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst), \ + }; \ + \ + static const struct can_mcan_config can_mcan_cfg_##inst = { \ + .can = (struct can_mcan_reg *) DT_INST_REG_ADDR_BY_NAME(inst, m_can), \ + .bus_speed = DT_INST_PROP(inst, bus_speed), \ + .sjw = DT_INST_PROP(inst, sjw), \ + .sample_point = DT_INST_PROP_OR(inst, sample_point, 0), \ + .prop_ts1 = DT_INST_PROP_OR(inst, prop_seg, 0) + \ + DT_INST_PROP_OR(inst, phase_seg1, 0), \ + .ts2 = DT_INST_PROP_OR(inst, phase_seg2, 0), \ + .bus_speed_data = DT_INST_PROP(inst, bus_speed_data), \ + .sjw_data = DT_INST_PROP(inst, sjw_data), \ + .sample_point_data = DT_INST_PROP_OR(inst, sample_point_data, 0), \ + .prop_ts1_data = DT_INST_PROP_OR(inst, prop_seg_data, 0) + \ + DT_INST_PROP_OR(inst, phase_seg1_data, 0), \ + .ts2_data = DT_INST_PROP_OR(inst, phase_seg2_data, 0), \ + .tx_delay_comp_offset = DT_INST_PROP(inst, tx_delay_comp_offset), \ + .phy = DEVICE_DT_GET_OR_NULL(DT_INST_PHANDLE(inst, phys)), \ + .max_bitrate = DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(inst, 5000000), \ + .custom = &can_stm32fd_cfg_##inst, \ + }; #else /* CONFIG_CAN_FD_MODE */ - -#define CAN_STM32FD_CFG_INST(inst) \ - \ -PINCTRL_DT_INST_DEFINE(inst); \ - \ -static const struct can_stm32fd_config can_stm32fd_cfg_##inst = { \ - .msg_sram = (struct can_mcan_msg_sram *) \ - DT_INST_REG_ADDR_BY_NAME(inst, message_ram), \ - .config_irq = config_can_##inst##_irq, \ - .mcan_cfg = { \ - .can = (struct can_mcan_reg *) \ - DT_INST_REG_ADDR_BY_NAME(inst, m_can), \ - .bus_speed = DT_INST_PROP(inst, bus_speed), \ - .sjw = DT_INST_PROP(inst, sjw), \ - .sample_point = DT_INST_PROP_OR(inst, sample_point, 0), \ - .prop_ts1 = DT_INST_PROP_OR(inst, prop_seg, 0) + \ - DT_INST_PROP_OR(inst, phase_seg1, 0), \ - .ts2 = DT_INST_PROP_OR(inst, phase_seg2, 0), \ - .phy = DEVICE_DT_GET_OR_NULL(DT_INST_PHANDLE(inst, phys)), \ - .max_bitrate = \ - DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(inst, 1000000), \ - }, \ - .pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst), \ -}; - +#define CAN_STM32FD_CFG_INST(inst) \ + PINCTRL_DT_INST_DEFINE(inst); \ + \ + static const struct can_stm32fd_config can_stm32fd_cfg_##inst = { \ + .config_irq = config_can_##inst##_irq, \ + .pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst), \ + }; \ + \ + static const struct can_mcan_config can_mcan_cfg_##inst = { \ + .can = (struct can_mcan_reg *) DT_INST_REG_ADDR_BY_NAME(inst, m_can), \ + .bus_speed = DT_INST_PROP(inst, bus_speed), \ + .sjw = DT_INST_PROP(inst, sjw), \ + .sample_point = DT_INST_PROP_OR(inst, sample_point, 0), \ + .prop_ts1 = DT_INST_PROP_OR(inst, prop_seg, 0) + \ + DT_INST_PROP_OR(inst, phase_seg1, 0), \ + .ts2 = DT_INST_PROP_OR(inst, phase_seg2, 0), \ + .phy = DEVICE_DT_GET_OR_NULL(DT_INST_PHANDLE(inst, phys)), \ + .max_bitrate = DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(inst, 1000000), \ + .custom = &can_stm32fd_cfg_##inst, \ + }; #endif /* CONFIG_CAN_FD_MODE */ -#define CAN_STM32FD_DATA_INST(inst) \ -static struct can_stm32fd_data can_stm32fd_dev_data_##inst; +#define CAN_STM32FD_DATA_INST(inst) \ + static struct can_mcan_data can_mcan_dev_data_##inst = { \ + .msg_ram = (struct can_mcan_msg_sram *) \ + DT_INST_REG_ADDR_BY_NAME(inst, message_ram), \ + }; -#define CAN_STM32FD_DEVICE_INST(inst) \ -DEVICE_DT_INST_DEFINE(inst, &can_stm32fd_init, NULL, \ - &can_stm32fd_dev_data_##inst, &can_stm32fd_cfg_##inst, \ - POST_KERNEL, CONFIG_CAN_INIT_PRIORITY, \ - &can_api_funcs); +#define CAN_STM32FD_DEVICE_INST(inst) \ + DEVICE_DT_INST_DEFINE(inst, &can_stm32fd_init, NULL, \ + &can_mcan_dev_data_##inst, &can_mcan_cfg_##inst, \ + POST_KERNEL, CONFIG_CAN_INIT_PRIORITY, \ + &can_stm32fd_driver_api); #define CAN_STM32FD_INST(inst) \ CAN_STM32FD_IRQ_CFG_FUNCTION(inst) \ diff --git a/drivers/can/can_stm32fd.h b/drivers/can/can_stm32fd.h deleted file mode 100644 index 2837a529ec7..00000000000 --- a/drivers/can/can_stm32fd.h +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright (c) 2020 Alexander Wachter - * - * SPDX-License-Identifier: Apache-2.0 - * - */ - -#ifndef ZEPHYR_DRIVERS_CAN_STM32FD_H_ -#define ZEPHYR_DRIVERS_CAN_STM32FD_H_ - -#include "can_mcan.h" - -struct can_stm32fd_config { - struct can_mcan_msg_sram *msg_sram; - void (*config_irq)(void); - struct can_mcan_config mcan_cfg; - const struct pinctrl_dev_config *pcfg; -}; - -struct can_stm32fd_data { - struct can_mcan_data mcan_data; -}; - -#endif /*ZEPHYR_DRIVERS_CAN_STM32FD_H_*/ diff --git a/drivers/can/can_stm32h7.c b/drivers/can/can_stm32h7.c index 14afd2e099c..13c79a591b4 100644 --- a/drivers/can/can_stm32h7.c +++ b/drivers/can/can_stm32h7.c @@ -1,11 +1,11 @@ /* + * Copyright (c) 2022 Vestas Wind Systems A/S * Copyright (c) 2022 Blue Clover * * SPDX-License-Identifier: Apache-2.0 */ #include -#include #include #include #include @@ -20,23 +20,17 @@ LOG_MODULE_REGISTER(can_stm32h7, CONFIG_CAN_LOG_LEVEL); #define DT_DRV_COMPAT st_stm32h7_fdcan struct can_stm32h7_config { - struct can_mcan_msg_sram *msg_sram; void (*config_irq)(void); - struct can_mcan_config mcan_cfg; const struct pinctrl_dev_config *pcfg; struct stm32_pclken pclken; }; -struct can_stm32h7_data { - struct can_mcan_data mcan_data; -}; - static int can_stm32h7_get_core_clock(const struct device *dev, uint32_t *rate) { - ARG_UNUSED(dev); - const uint32_t rate_tmp = LL_RCC_GetFDCANClockFreq(LL_RCC_FDCAN_CLKSOURCE); + ARG_UNUSED(dev); + if (rate_tmp == LL_RCC_PERIPH_FREQUENCY_NO) { LOG_ERR("Can't read core clock"); return -EIO; @@ -51,13 +45,14 @@ static int can_stm32h7_get_core_clock(const struct device *dev, uint32_t *rate) static int can_stm32h7_clock_enable(const struct device *dev) { - int ret; - const struct can_stm32h7_config *cfg = dev->config; + const struct can_mcan_config *mcan_cfg = dev->config; + const struct can_stm32h7_config *stm32h7_cfg = mcan_cfg->custom; const struct device *clk = DEVICE_DT_GET(STM32_CLOCK_CONTROL_NODE); + int ret; LL_RCC_SetFDCANClockSource(LL_RCC_FDCAN_CLKSOURCE_PLL1Q); - ret = clock_control_on(clk, (clock_control_subsys_t *)&cfg->pclken); + ret = clock_control_on(clk, (clock_control_subsys_t *)&stm32h7_cfg->pclken); if (ret != 0) { LOG_ERR("failure enabling clock"); return ret; @@ -71,24 +66,14 @@ static int can_stm32h7_clock_enable(const struct device *dev) return 0; } -static void can_stm32h7_set_state_change_cb(const struct device *dev, - can_state_change_callback_t cb, - void *user_data) -{ - struct can_stm32h7_data *data = dev->data; - - data->mcan_data.state_change_cb = cb; - data->mcan_data.state_change_cb_data = user_data; -} - static int can_stm32h7_init(const struct device *dev) { - const struct can_stm32h7_config *cfg = dev->config; - struct can_stm32h7_data *data = dev->data; + const struct can_mcan_config *mcan_cfg = dev->config; + const struct can_stm32h7_config *stm32h7_cfg = mcan_cfg->custom; int ret; /* Configure dt provided device signals when available */ - ret = pinctrl_apply_state(cfg->pcfg, PINCTRL_STATE_DEFAULT); + ret = pinctrl_apply_state(stm32h7_cfg->pcfg, PINCTRL_STATE_DEFAULT); if (ret != 0) { LOG_ERR("CAN pinctrl setup failed (%d)", ret); return ret; @@ -99,122 +84,30 @@ static int can_stm32h7_init(const struct device *dev) return ret; } - ret = can_mcan_init(dev, &cfg->mcan_cfg, cfg->msg_sram, - &data->mcan_data); + ret = can_mcan_init(dev); if (ret != 0) { return ret; } - cfg->config_irq(); - - return 0; -} - -static int can_stm32h7_get_state(const struct device *dev, enum can_state *state, - struct can_bus_err_cnt *err_cnt) -{ - const struct can_stm32h7_config *cfg = dev->config; - - return can_mcan_get_state(&cfg->mcan_cfg, state, err_cnt); -} - -static int can_stm32h7_send(const struct device *dev, - const struct zcan_frame *frame, - k_timeout_t timeout, can_tx_callback_t callback, - void *user_data) -{ - const struct can_stm32h7_config *cfg = dev->config; - struct can_stm32h7_data *data = dev->data; - - return can_mcan_send(&cfg->mcan_cfg, &data->mcan_data, cfg->msg_sram, - frame, timeout, callback, user_data); -} - -static int can_stm32h7_add_rx_filter(const struct device *dev, - can_rx_callback_t callback, - void *user_data, - const struct zcan_filter *filter) -{ - const struct can_stm32h7_config *cfg = dev->config; - struct can_stm32h7_data *data = dev->data; - - return can_mcan_add_rx_filter(&data->mcan_data, cfg->msg_sram, - callback, user_data, filter); -} - -static void can_stm32h7_remove_rx_filter(const struct device *dev, - int filter_id) -{ - const struct can_stm32h7_config *cfg = dev->config; - struct can_stm32h7_data *data = dev->data; - - can_mcan_remove_rx_filter(&data->mcan_data, cfg->msg_sram, filter_id); -} - -static int can_stm32h7_set_mode(const struct device *dev, enum can_mode mode) -{ - const struct can_stm32h7_config *cfg = dev->config; - - return can_mcan_set_mode(&cfg->mcan_cfg, mode); -} - -static int can_stm32h7_set_timing(const struct device *dev, - const struct can_timing *timing, - const struct can_timing *timing_data) -{ - const struct can_stm32h7_config *cfg = dev->config; - - return can_mcan_set_timing(&cfg->mcan_cfg, timing, timing_data); -} - -static int can_stm32h7_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate) -{ - const struct can_stm32h7_config *cfg = dev->config; - - *max_bitrate = cfg->mcan_cfg.max_bitrate; + stm32h7_cfg->config_irq(); return 0; } +static const struct can_driver_api can_stm32h7_driver_api = { + .set_mode = can_mcan_set_mode, + .set_timing = can_mcan_set_timing, + .send = can_mcan_send, + .add_rx_filter = can_mcan_add_rx_filter, + .remove_rx_filter = can_mcan_remove_rx_filter, + .get_state = can_mcan_get_state, #ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY -static int can_stm32h7_recover(const struct device *dev, k_timeout_t timeout) -{ - const struct can_stm32h7_config *cfg = dev->config; - - return can_mcan_recover(&cfg->mcan_cfg, timeout); -} -#endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */ - -static void can_stm32h7_line_0_isr(const struct device *dev) -{ - const struct can_stm32h7_config *cfg = dev->config; - struct can_stm32h7_data *data = dev->data; - - can_mcan_line_0_isr(&cfg->mcan_cfg, cfg->msg_sram, &data->mcan_data); -} - -static void can_stm32h7_line_1_isr(const struct device *dev) -{ - const struct can_stm32h7_config *cfg = dev->config; - struct can_stm32h7_data *data = dev->data; - - can_mcan_line_1_isr(&cfg->mcan_cfg, cfg->msg_sram, &data->mcan_data); -} - -static const struct can_driver_api can_api_funcs = { - .set_mode = can_stm32h7_set_mode, - .set_timing = can_stm32h7_set_timing, - .send = can_stm32h7_send, - .add_rx_filter = can_stm32h7_add_rx_filter, - .remove_rx_filter = can_stm32h7_remove_rx_filter, - .get_state = can_stm32h7_get_state, -#ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY - .recover = can_stm32h7_recover, + .recover = can_mcan_recover, #endif .get_core_clock = can_stm32h7_get_core_clock, - .get_max_bitrate = can_stm32h7_get_max_bitrate, + .get_max_bitrate = can_mcan_get_max_bitrate, .get_max_filters = can_mcan_get_max_filters, - .set_state_change_callback = can_stm32h7_set_state_change_cb, + .set_state_change_callback = can_mcan_set_state_change_callback, /* Timing limits are per the STM32H7 Reference Manual (RM0433 Rev 7), * section 56.5.7, FDCAN nominal bit timing and prescaler register * (FDCAN_NBTP). @@ -276,6 +169,7 @@ static const struct can_driver_api can_api_funcs = { DT_INST_PROP(n, tx_delay_comp_offset), \ .phy = DEVICE_DT_GET_OR_NULL(DT_INST_PHANDLE(n, phys)), \ .max_bitrate = DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(n, 5000000), \ + .custom = &can_stm32h7_cfg_##n, \ } #else /* CONFIG_CAN_FD_MODE */ #define CAN_STM32H7_MCAN_MCAN_INIT(n) \ @@ -289,6 +183,7 @@ static const struct can_driver_api can_api_funcs = { .ts2 = DT_INST_PROP_OR(n, phase_seg2, 0), \ .phy = DEVICE_DT_GET_OR_NULL(DT_INST_PHANDLE(n, phys)), \ .max_bitrate = DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(n, 1000000), \ + .custom = &can_stm32h7_cfg_##n, \ } #endif /* !CONFIG_CAN_FD_MODE */ @@ -298,10 +193,7 @@ static const struct can_driver_api can_api_funcs = { PINCTRL_DT_INST_DEFINE(n); \ \ static const struct can_stm32h7_config can_stm32h7_cfg_##n = { \ - .msg_sram = (struct can_mcan_msg_sram *) \ - DT_INST_REG_ADDR_BY_NAME(n, message_ram), \ .config_irq = stm32h7_mcan_irq_config_##n, \ - .mcan_cfg = CAN_STM32H7_MCAN_MCAN_INIT(n), \ .pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(n), \ .pclken = { \ .enr = DT_INST_CLOCKS_CELL(n, bits), \ @@ -309,24 +201,30 @@ static const struct can_driver_api can_api_funcs = { }, \ }; \ \ - static struct can_stm32h7_data can_stm32h7_dev_data_##n; \ + static const struct can_mcan_config can_mcan_cfg_##n = \ + CAN_STM32H7_MCAN_MCAN_INIT(n); \ + \ + static struct can_mcan_data can_mcan_data_##n = { \ + .msg_ram = (struct can_mcan_msg_sram *) \ + DT_INST_REG_ADDR_BY_NAME(n, message_ram), \ + }; \ \ DEVICE_DT_INST_DEFINE(n, &can_stm32h7_init, NULL, \ - &can_stm32h7_dev_data_##n, \ - &can_stm32h7_cfg_##n, \ + &can_mcan_data_##n, \ + &can_mcan_cfg_##n, \ POST_KERNEL, CONFIG_CAN_INIT_PRIORITY, \ - &can_api_funcs); \ + &can_stm32h7_driver_api); \ \ static void stm32h7_mcan_irq_config_##n(void) \ { \ LOG_DBG("Enable CAN inst" #n " IRQ"); \ IRQ_CONNECT(DT_INST_IRQ_BY_NAME(n, line_0, irq), \ DT_INST_IRQ_BY_NAME(n, line_0, priority), \ - can_stm32h7_line_0_isr, DEVICE_DT_INST_GET(n), 0); \ + can_mcan_line_0_isr, DEVICE_DT_INST_GET(n), 0); \ irq_enable(DT_INST_IRQ_BY_NAME(n, line_0, irq)); \ IRQ_CONNECT(DT_INST_IRQ_BY_NAME(n, line_1, irq), \ DT_INST_IRQ_BY_NAME(n, line_1, priority), \ - can_stm32h7_line_1_isr, DEVICE_DT_INST_GET(n), 0); \ + can_mcan_line_1_isr, DEVICE_DT_INST_GET(n), 0); \ irq_enable(DT_INST_IRQ_BY_NAME(n, line_1, irq)); \ }