dts: bindings: can: remove deprecated properties for initial timing (0c13f388) · Commits · Wenxi XU / zephyr

drivers/can/can_mcan.c

+16 −37

Original line number	Diff line number	Diff line
		@@ -1457,28 +1457,17 @@ int can_mcan_init(const struct device *dev)
		return err;
		}

		if (config->common.sample_point) {
		err = can_calc_timing(dev, &timing, config->common.bus_speed,
		config->common.sample_point);
		if (err == -EINVAL) {
		LOG_ERR("Can't find timing for given param");
		return -EIO;
		}

		LOG_DBG("Presc: %d, TS1: %d, TS2: %d", timing.prescaler, timing.phase_seg1,
		timing.phase_seg2);
		LOG_DBG("Sample-point err : %d", err);
		} else if (config->prop_ts1) {
		timing.sjw = config->sjw;
		timing.prop_seg = 0U;
		timing.phase_seg1 = config->prop_ts1;
		timing.phase_seg2 = config->ts2;
		err = can_calc_prescaler(dev, &timing, config->common.bus_speed);
		if (err != 0) {
		LOG_WRN("Bitrate error: %d", err);
		}
		}
		#ifdef CONFIG_CAN_FD_MODE
		if (config->common.sample_point_data) {
		err = can_calc_timing_data(dev, &timing_data, config->common.bus_speed_data,
		config->common.sample_point_data);
		if (err == -EINVAL) {
		@@ -1487,16 +1476,6 @@ int can_mcan_init(const struct device *dev)
		}

		LOG_DBG("Sample-point err data phase: %d", err);
		} else if (config->prop_ts1_data) {
		timing_data.sjw = config->sjw_data;
		timing_data.prop_seg = 0U;
		timing_data.phase_seg1 = config->prop_ts1_data;
		timing_data.phase_seg2 = config->ts2_data;
		err = can_calc_prescaler(dev, &timing_data, config->common.bus_speed_data);
		if (err != 0) {
		LOG_WRN("Dataphase bitrate error: %d", err);
		}
		}
		#endif /* CONFIG_CAN_FD_MODE */

		err = can_set_timing(dev, &timing);

drivers/can/can_mcp2515.c

+10 −41

Original line number	Diff line number	Diff line
		@@ -17,23 +17,6 @@ LOG_MODULE_REGISTER(can_mcp2515, CONFIG_CAN_LOG_LEVEL);

		#include "can_mcp2515.h"

		#define SP_IS_SET(inst) DT_INST_NODE_HAS_PROP(inst, sample_point) \|\|

		/* Macro to exclude the sample point algorithm from compilation if not used
		* Without the macro, the algorithm would always waste ROM
		*/
		#define USE_SP_ALGO (DT_INST_FOREACH_STATUS_OKAY(SP_IS_SET) 0)

		#define SP_AND_TIMING_NOT_SET(inst) \
		(!DT_INST_NODE_HAS_PROP(inst, sample_point) && \
		!(DT_INST_NODE_HAS_PROP(inst, prop_seg) && \
		DT_INST_NODE_HAS_PROP(inst, phase_seg1) && \
		DT_INST_NODE_HAS_PROP(inst, phase_seg2))) \|\|

		#if DT_INST_FOREACH_STATUS_OKAY(SP_AND_TIMING_NOT_SET) 0
		#error You must either set a sampling-point or timings (phase-seg* and prop-seg)
		#endif

		/* Timeout for changing mode */
		#define MCP2515_MODE_CHANGE_TIMEOUT_USEC 1000
		#define MCP2515_MODE_CHANGE_RETRIES 100
		@@ -1009,26 +992,16 @@ static int mcp2515_init(const struct device *dev)
		(void)memset(dev_data->filter, 0, sizeof(dev_data->filter));
		dev_data->old_state = CAN_STATE_ERROR_ACTIVE;

		if (dev_cfg->common.sample_point && USE_SP_ALGO) {
		ret = can_calc_timing(dev, &timing, dev_cfg->common.bus_speed,
		dev_cfg->common.sample_point);
		if (ret == -EINVAL) {
		LOG_ERR("Can't find timing for given param");
		return -EIO;
		}

		LOG_DBG("Presc: %d, BS1: %d, BS2: %d",
		timing.prescaler, timing.phase_seg1, timing.phase_seg2);
		LOG_DBG("Sample-point err : %d", ret);
		} else {
		timing.sjw = dev_cfg->tq_sjw;
		timing.prop_seg = dev_cfg->tq_prop;
		timing.phase_seg1 = dev_cfg->tq_bs1;
		timing.phase_seg2 = dev_cfg->tq_bs2;
		ret = can_calc_prescaler(dev, &timing, dev_cfg->common.bus_speed);
		if (ret) {
		LOG_WRN("Bitrate error: %d", ret);
		}
		}

		k_usleep(MCP2515_OSC_STARTUP_US);

		@@ -1058,10 +1031,6 @@ static int mcp2515_init(const struct device *dev)
		.int_gpio = GPIO_DT_SPEC_INST_GET(inst, int_gpios), \
		.int_thread_stack_size = CONFIG_CAN_MCP2515_INT_THREAD_STACK_SIZE, \
		.int_thread_priority = CONFIG_CAN_MCP2515_INT_THREAD_PRIO, \
		.tq_sjw = DT_INST_PROP(inst, sjw), \
		.tq_prop = DT_INST_PROP_OR(inst, prop_seg, 0), \
		.tq_bs1 = DT_INST_PROP_OR(inst, phase_seg1, 0), \
		.tq_bs2 = DT_INST_PROP_OR(inst, phase_seg2, 0), \
		.osc_freq = DT_INST_PROP(inst, osc_freq), \
		}; \
		\

drivers/can/can_mcp2515.h

+0 −4

Original line number	Diff line number	Diff line
		@@ -59,10 +59,6 @@ struct mcp2515_config {
		int int_thread_priority;

		/* CAN timing */
		uint8_t tq_sjw;
		uint8_t tq_prop;
		uint8_t tq_bs1;
		uint8_t tq_bs2;
		uint32_t osc_freq;
		};

drivers/can/can_mcp251xfd.c

+13 −90

Original line number	Diff line number	Diff line
		@@ -19,14 +19,6 @@
		#include <zephyr/logging/log.h>
		LOG_MODULE_REGISTER(can_mcp251xfd, CONFIG_CAN_LOG_LEVEL);

		#define SP_IS_SET(inst) DT_INST_NODE_HAS_PROP(inst, sample_point) \|\|

		/*
		* Macro to exclude the sample point algorithm from compilation if not used
		* Without the macro, the algorithm would always waste ROM
		*/
		#define USE_SP_ALGO (DT_INST_FOREACH_STATUS_OKAY(SP_IS_SET) 0)

		static void mcp251xfd_canframe_to_txobj(const struct can_frame *src, int mailbox_idx,
		struct mcp251xfd_txobj *dst)
		{
		@@ -1296,68 +1288,6 @@ static void mcp251xfd_tef_fifo_handler(const struct device dev, void data)
		k_sem_give(&dev_data->tx_sem);
		}

		#if defined(CONFIG_CAN_FD_MODE)
		static int mcp251xfd_init_timing_struct_data(struct can_timing *timing,
		const struct device *dev,
		const struct mcp251xfd_timing_params *timing_params)
		{
		const struct mcp251xfd_config *dev_cfg = dev->config;
		int ret;

		if (USE_SP_ALGO && dev_cfg->common.sample_point_data > 0) {
		ret = can_calc_timing_data(dev, timing, dev_cfg->common.bus_speed_data,
		dev_cfg->common.sample_point_data);
		if (ret < 0) {
		return ret;
		}
		LOG_DBG("Data phase Presc: %d, BS1: %d, BS2: %d", timing->prescaler,
		timing->phase_seg1, timing->phase_seg2);
		LOG_DBG("Data phase Sample-point err : %d", ret);
		} else {
		timing->sjw = timing_params->sjw;
		timing->prop_seg = timing_params->prop_seg;
		timing->phase_seg1 = timing_params->phase_seg1;
		timing->phase_seg2 = timing_params->phase_seg2;
		ret = can_calc_prescaler(dev, timing, dev_cfg->common.bus_speed_data);
		if (ret > 0) {
		LOG_WRN("Data phase Bitrate error: %d", ret);
		}
		}

		return ret;
		}
		#endif

		static int mcp251xfd_init_timing_struct(struct can_timing *timing,
		const struct device *dev,
		const struct mcp251xfd_timing_params *timing_params)
		{
		const struct mcp251xfd_config *dev_cfg = dev->config;
		int ret;

		if (USE_SP_ALGO && dev_cfg->common.sample_point > 0) {
		ret = can_calc_timing(dev, timing, dev_cfg->common.bus_speed,
		dev_cfg->common.sample_point);
		if (ret < 0) {
		return ret;
		}
		LOG_DBG("Presc: %d, BS1: %d, BS2: %d", timing->prescaler, timing->phase_seg1,
		timing->phase_seg2);
		LOG_DBG("Sample-point err : %d", ret);
		} else {
		timing->sjw = timing_params->sjw;
		timing->prop_seg = timing_params->prop_seg;
		timing->phase_seg1 = timing_params->phase_seg1;
		timing->phase_seg2 = timing_params->phase_seg2;
		ret = can_calc_prescaler(dev, timing, dev_cfg->common.bus_speed);
		if (ret > 0) {
		LOG_WRN("Bitrate error: %d", ret);
		}
		}

		return ret;
		}

		static inline int mcp251xfd_init_con_reg(const struct device *dev)
		{
		uint32_t *reg;
		@@ -1593,18 +1523,28 @@ static int mcp251xfd_init(const struct device *dev)
		goto done;
		}

		ret = mcp251xfd_init_timing_struct(&timing, dev, &dev_cfg->timing_params);
		ret = can_calc_timing(dev, &timing, dev_cfg->common.bus_speed,
		dev_cfg->common.sample_point);
		if (ret < 0) {
		LOG_ERR("Can't find timing for given param");
		goto done;
		}

		LOG_DBG("Presc: %d, BS1: %d, BS2: %d", timing.prescaler, timing.phase_seg1,
		timing.phase_seg2);
		LOG_DBG("Sample-point err : %d", ret);

		#if defined(CONFIG_CAN_FD_MODE)
		ret = mcp251xfd_init_timing_struct_data(&timing_data, dev, &dev_cfg->timing_params_data);
		ret = can_calc_timing_data(dev, &timing_data, dev_cfg->common.bus_speed_data,
		dev_cfg->common.sample_point_data);
		if (ret < 0) {
		LOG_ERR("Can't find data timing for given param");
		goto done;
		}

		LOG_DBG("Data phase Presc: %d, BS1: %d, BS2: %d", timing_data.prescaler,
		timing_data.phase_seg1, timing_data.phase_seg2);
		LOG_DBG("Data phase Sample-point err : %d", ret);
		#endif

		reg = mcp251xfd_read_crc(dev, MCP251XFD_REG_CON, MCP251XFD_REG_SIZE);
		@@ -1745,23 +1685,6 @@ static const struct can_driver_api mcp251xfd_api_funcs = {
		#endif
		};

		#define MCP251XFD_SET_TIMING_MACRO(inst, type) \
		.timing_params##type = { \
		.sjw = DT_INST_PROP(inst, sjw##type), \
		.prop_seg = DT_INST_PROP_OR(inst, prop_seg##type, 0), \
		.phase_seg1 = DT_INST_PROP_OR(inst, phase_seg1##type, 0), \
		.phase_seg2 = DT_INST_PROP_OR(inst, phase_seg2##type, 0), \
		}

		#if defined(CONFIG_CAN_FD_MODE)
		#define MCP251XFD_SET_TIMING(inst) \
		MCP251XFD_SET_TIMING_MACRO(inst,), \
		MCP251XFD_SET_TIMING_MACRO(inst, _data)
		#else
		#define MCP251XFD_SET_TIMING(inst) \
		MCP251XFD_SET_TIMING_MACRO(inst,)
		#endif

		#define MCP251XFD_SET_CLOCK(inst) \
		COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, clocks), \
		(.clk_dev = DEVICE_DT_GET(DT_INST_CLOCKS_CTLR(inst)), \
		@@ -1786,7 +1709,7 @@ static const struct can_driver_api mcp251xfd_api_funcs = {
		.timestamp_prescaler = DT_INST_PROP(inst, timestamp_prescaler), \
		\
		.osc_freq = DT_INST_PROP(inst, osc_freq), \
		MCP251XFD_SET_TIMING(inst), \
		\
		.rx_fifo = {.ram_start_addr = MCP251XFD_RX_FIFO_START_ADDR, \
		.reg_fifocon_addr = MCP251XFD_REG_FIFOCON(MCP251XFD_RX_FIFO_IDX), \
		.capacity = MCP251XFD_RX_FIFO_ITEMS, \

drivers/can/can_mcp251xfd.h

+0 −13

Original line number	Diff line number	Diff line
		@@ -511,13 +511,6 @@ struct mcp251xfd_data {

		};

		struct mcp251xfd_timing_params {
		uint8_t sjw;
		uint8_t prop_seg;
		uint8_t phase_seg1;
		uint8_t phase_seg2;
		};

		struct mcp251xfd_config {
		const struct can_driver_config common;

		@@ -534,12 +527,6 @@ struct mcp251xfd_config {

		uint16_t timestamp_prescaler;

		/* CAN Timing */
		struct mcp251xfd_timing_params timing_params;
		#if defined(CONFIG_CAN_FD_MODE)
		struct mcp251xfd_timing_params timing_params_data;
		#endif

		const struct device *clk_dev;
		uint8_t clk_id;

Admin message