Commit b803c4a4 authored by Vincent Mailhol's avatar Vincent Mailhol Committed by Marc Kleine-Budde
Browse files

can: dev: add struct data_bittiming_params to group FD parameters 



This is a preparation patch for the introduction of CAN XL.

CAN FD and CAN XL uses similar bittiming parameters. Add one level of
nesting for all the CAN FD parameters. Typically:

  priv->can.data_bittiming;

becomes:

  priv->can.fd.data_bittiming;

This way, the CAN XL equivalent (to be introduced later) would be:

  priv->can.xl.data_bittiming;

Add the new struct data_bittiming_params which contains all the data
bittiming parameters, including the TDC and the callback functions.

This done, update all the CAN FD drivers to make use of the new
layout.

Acked-by: default avatarOliver Hartkopp <socketcan@hartkopp.net>
Signed-off-by: default avatarVincent Mailhol <mailhol.vincent@wanadoo.fr>
Link: https://patch.msgid.link/20250501171213.2161572-2-mailhol.vincent@wanadoo.fr


[mkl: fix rcar_canfd]
Signed-off-by: default avatarMarc Kleine-Budde <mkl@pengutronix.de>
parent 851013e9

drivers/net/can/ctucanfd/ctucanfd_base.c

+4 −4
Original line number Diff line number Diff line
@@ -275,7 +275,7 @@ static int ctucan_set_bittiming(struct net_device *ndev) 
static int ctucan_set_data_bittiming(struct net_device *ndev)

{

	struct ctucan_priv *priv = netdev_priv(ndev);

	struct can_bittiming *dbt = &priv->can.data_bittiming;

	struct can_bittiming *dbt = &priv->can.fd.data_bittiming;



	/* Note that dbt may be modified here */

	return ctucan_set_btr(ndev, dbt, false);
@@ -290,7 +290,7 @@ static int ctucan_set_data_bittiming(struct net_device *ndev) 
static int ctucan_set_secondary_sample_point(struct net_device *ndev)

{

	struct ctucan_priv *priv = netdev_priv(ndev);

	struct can_bittiming *dbt = &priv->can.data_bittiming;

	struct can_bittiming *dbt = &priv->can.fd.data_bittiming;

	int ssp_offset = 0;

	u32 ssp_cfg = 0; /* No SSP by default */
@@ -1358,12 +1358,12 @@ int ctucan_probe_common(struct device *dev, void __iomem *addr, int irq, unsigne 
	priv->ntxbufs = ntxbufs;

	priv->dev = dev;

	priv->can.bittiming_const = &ctu_can_fd_bit_timing_max;

	priv->can.data_bittiming_const = &ctu_can_fd_bit_timing_data_max;

	priv->can.fd.data_bittiming_const = &ctu_can_fd_bit_timing_data_max;

	priv->can.do_set_mode = ctucan_do_set_mode;



	/* Needed for timing adjustment to be performed as soon as possible */

	priv->can.do_set_bittiming = ctucan_set_bittiming;

	priv->can.do_set_data_bittiming = ctucan_set_data_bittiming;

	priv->can.fd.do_set_data_bittiming = ctucan_set_data_bittiming;



	priv->can.do_get_berr_counter = ctucan_get_berr_counter;

	priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK

drivers/net/can/dev/dev.c

+6 −6
Original line number Diff line number Diff line
@@ -404,8 +404,8 @@ int open_candev(struct net_device *dev) 


	/* For CAN FD the data bitrate has to be >= the arbitration bitrate */

	if ((priv->ctrlmode & CAN_CTRLMODE_FD) &&

	    (!priv->data_bittiming.bitrate ||

	     priv->data_bittiming.bitrate < priv->bittiming.bitrate)) {

	    (!priv->fd.data_bittiming.bitrate ||

	     priv->fd.data_bittiming.bitrate < priv->bittiming.bitrate)) {

		netdev_err(dev, "incorrect/missing data bit-timing\n");

		return -EINVAL;

	}
@@ -543,16 +543,16 @@ int register_candev(struct net_device *dev) 
	if (!priv->bitrate_const != !priv->bitrate_const_cnt)

		return -EINVAL;



	if (!priv->data_bitrate_const != !priv->data_bitrate_const_cnt)

	if (!priv->fd.data_bitrate_const != !priv->fd.data_bitrate_const_cnt)

		return -EINVAL;



	/* We only support either fixed bit rates or bit timing const. */

	if ((priv->bitrate_const || priv->data_bitrate_const) &&

	    (priv->bittiming_const || priv->data_bittiming_const))

	if ((priv->bitrate_const || priv->fd.data_bitrate_const) &&

	    (priv->bittiming_const || priv->fd.data_bittiming_const))

		return -EINVAL;



	if (!can_bittiming_const_valid(priv->bittiming_const) ||

	    !can_bittiming_const_valid(priv->data_bittiming_const))

	    !can_bittiming_const_valid(priv->fd.data_bittiming_const))

		return -EINVAL;



	if (!priv->termination_const) {

drivers/net/can/dev/netlink.c

+37 −37
Original line number Diff line number Diff line
@@ -141,7 +141,7 @@ static int can_tdc_changelink(struct can_priv *priv, const struct nlattr *nla, 
{

	struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];

	struct can_tdc tdc = { 0 };

	const struct can_tdc_const *tdc_const = priv->tdc_const;

	const struct can_tdc_const *tdc_const = priv->fd.tdc_const;

	int err;



	if (!tdc_const || !can_tdc_is_enabled(priv))
@@ -179,7 +179,7 @@ static int can_tdc_changelink(struct can_priv *priv, const struct nlattr *nla, 
		tdc.tdcf = tdcf;

	}



	priv->tdc = tdc;

	priv->fd.tdc = tdc;



	return 0;

}
@@ -228,10 +228,10 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[], 
			dev->mtu = CANFD_MTU;

		} else {

			dev->mtu = CAN_MTU;

			memset(&priv->data_bittiming, 0,

			       sizeof(priv->data_bittiming));

			memset(&priv->fd.data_bittiming, 0,

			       sizeof(priv->fd.data_bittiming));

			priv->ctrlmode &= ~CAN_CTRLMODE_TDC_MASK;

			memset(&priv->tdc, 0, sizeof(priv->tdc));

			memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc));

		}



		tdc_mask = cm->mask & CAN_CTRLMODE_TDC_MASK;
@@ -312,16 +312,16 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[], 
		 * directly via do_set_bitrate(). Bail out if neither

		 * is given.

		 */

		if (!priv->data_bittiming_const && !priv->do_set_data_bittiming &&

		    !priv->data_bitrate_const)

		if (!priv->fd.data_bittiming_const && !priv->fd.do_set_data_bittiming &&

		    !priv->fd.data_bitrate_const)

			return -EOPNOTSUPP;



		memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]),

		       sizeof(dbt));

		err = can_get_bittiming(dev, &dbt,

					priv->data_bittiming_const,

					priv->data_bitrate_const,

					priv->data_bitrate_const_cnt,

					priv->fd.data_bittiming_const,

					priv->fd.data_bitrate_const,

					priv->fd.data_bitrate_const_cnt,

					extack);

		if (err)

			return err;
@@ -333,7 +333,7 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[], 
			return -EINVAL;

		}



		memset(&priv->tdc, 0, sizeof(priv->tdc));

		memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc));

		if (data[IFLA_CAN_TDC]) {

			/* TDC parameters are provided: use them */

			err = can_tdc_changelink(priv, data[IFLA_CAN_TDC],
@@ -346,17 +346,17 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[], 
			/* Neither of TDC parameters nor TDC flags are

			 * provided: do calculation

			 */

			can_calc_tdco(&priv->tdc, priv->tdc_const, &dbt,

			can_calc_tdco(&priv->fd.tdc, priv->fd.tdc_const, &dbt,

				      &priv->ctrlmode, priv->ctrlmode_supported);

		} /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly

		   * turned off. TDC is disabled: do nothing

		   */



		memcpy(&priv->data_bittiming, &dbt, sizeof(dbt));

		memcpy(&priv->fd.data_bittiming, &dbt, sizeof(dbt));



		if (priv->do_set_data_bittiming) {

		if (priv->fd.do_set_data_bittiming) {

			/* Finally, set the bit-timing registers */

			err = priv->do_set_data_bittiming(dev);

			err = priv->fd.do_set_data_bittiming(dev);

			if (err)

				return err;

		}
@@ -394,7 +394,7 @@ static size_t can_tdc_get_size(const struct net_device *dev) 
	struct can_priv *priv = netdev_priv(dev);

	size_t size;



	if (!priv->tdc_const)

	if (!priv->fd.tdc_const)

		return 0;



	size = nla_total_size(0);			/* nest IFLA_CAN_TDC */
@@ -404,17 +404,17 @@ static size_t can_tdc_get_size(const struct net_device *dev) 
	}

	size += nla_total_size(sizeof(u32));		/* IFLA_CAN_TDCO_MIN */

	size += nla_total_size(sizeof(u32));		/* IFLA_CAN_TDCO_MAX */

	if (priv->tdc_const->tdcf_max) {

	if (priv->fd.tdc_const->tdcf_max) {

		size += nla_total_size(sizeof(u32));	/* IFLA_CAN_TDCF_MIN */

		size += nla_total_size(sizeof(u32));	/* IFLA_CAN_TDCF_MAX */

	}



	if (can_tdc_is_enabled(priv)) {

		if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL ||

		    priv->do_get_auto_tdcv)

		    priv->fd.do_get_auto_tdcv)

			size += nla_total_size(sizeof(u32));	/* IFLA_CAN_TDCV */

		size += nla_total_size(sizeof(u32));		/* IFLA_CAN_TDCO */

		if (priv->tdc_const->tdcf_max)

		if (priv->fd.tdc_const->tdcf_max)

			size += nla_total_size(sizeof(u32));	/* IFLA_CAN_TDCF */

	}
@@ -442,9 +442,9 @@ static size_t can_get_size(const struct net_device *dev) 
	size += nla_total_size(sizeof(u32));			/* IFLA_CAN_RESTART_MS */

	if (priv->do_get_berr_counter)				/* IFLA_CAN_BERR_COUNTER */

		size += nla_total_size(sizeof(struct can_berr_counter));

	if (priv->data_bittiming.bitrate)			/* IFLA_CAN_DATA_BITTIMING */

	if (priv->fd.data_bittiming.bitrate)			/* IFLA_CAN_DATA_BITTIMING */

		size += nla_total_size(sizeof(struct can_bittiming));

	if (priv->data_bittiming_const)				/* IFLA_CAN_DATA_BITTIMING_CONST */

	if (priv->fd.data_bittiming_const)			/* IFLA_CAN_DATA_BITTIMING_CONST */

		size += nla_total_size(sizeof(struct can_bittiming_const));

	if (priv->termination_const) {

		size += nla_total_size(sizeof(priv->termination));		/* IFLA_CAN_TERMINATION */
@@ -454,9 +454,9 @@ static size_t can_get_size(const struct net_device *dev) 
	if (priv->bitrate_const)				/* IFLA_CAN_BITRATE_CONST */

		size += nla_total_size(sizeof(*priv->bitrate_const) *

				       priv->bitrate_const_cnt);

	if (priv->data_bitrate_const)				/* IFLA_CAN_DATA_BITRATE_CONST */

		size += nla_total_size(sizeof(*priv->data_bitrate_const) *

				       priv->data_bitrate_const_cnt);

	if (priv->fd.data_bitrate_const)			/* IFLA_CAN_DATA_BITRATE_CONST */

		size += nla_total_size(sizeof(*priv->fd.data_bitrate_const) *

				       priv->fd.data_bitrate_const_cnt);

	size += sizeof(priv->bitrate_max);			/* IFLA_CAN_BITRATE_MAX */

	size += can_tdc_get_size(dev);				/* IFLA_CAN_TDC */

	size += can_ctrlmode_ext_get_size();			/* IFLA_CAN_CTRLMODE_EXT */
@@ -468,8 +468,8 @@ static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev) 
{

	struct nlattr *nest;

	struct can_priv *priv = netdev_priv(dev);

	struct can_tdc *tdc = &priv->tdc;

	const struct can_tdc_const *tdc_const = priv->tdc_const;

	struct can_tdc *tdc = &priv->fd.tdc;

	const struct can_tdc_const *tdc_const = priv->fd.tdc_const;



	if (!tdc_const)

		return 0;
@@ -497,8 +497,8 @@ static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev) 
		if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL) {

			tdcv = tdc->tdcv;

			err = 0;

		} else if (priv->do_get_auto_tdcv) {

			err = priv->do_get_auto_tdcv(dev, &tdcv);

		} else if (priv->fd.do_get_auto_tdcv) {

			err = priv->fd.do_get_auto_tdcv(dev, &tdcv);

		}

		if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv))

			goto err_cancel;
@@ -564,14 +564,14 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) 
	     !priv->do_get_berr_counter(dev, &bec) &&

	     nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||



	    (priv->data_bittiming.bitrate &&

	    (priv->fd.data_bittiming.bitrate &&

	     nla_put(skb, IFLA_CAN_DATA_BITTIMING,

		     sizeof(priv->data_bittiming), &priv->data_bittiming)) ||

		     sizeof(priv->fd.data_bittiming), &priv->fd.data_bittiming)) ||



	    (priv->data_bittiming_const &&

	    (priv->fd.data_bittiming_const &&

	     nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST,

		     sizeof(*priv->data_bittiming_const),

		     priv->data_bittiming_const)) ||

		     sizeof(*priv->fd.data_bittiming_const),

		     priv->fd.data_bittiming_const)) ||



	    (priv->termination_const &&

	     (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) ||
@@ -586,11 +586,11 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) 
		     priv->bitrate_const_cnt,

		     priv->bitrate_const)) ||



	    (priv->data_bitrate_const &&

	    (priv->fd.data_bitrate_const &&

	     nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST,

		     sizeof(*priv->data_bitrate_const) *

		     priv->data_bitrate_const_cnt,

		     priv->data_bitrate_const)) ||

		     sizeof(*priv->fd.data_bitrate_const) *

		     priv->fd.data_bitrate_const_cnt,

		     priv->fd.data_bitrate_const)) ||



	    (nla_put(skb, IFLA_CAN_BITRATE_MAX,

		     sizeof(priv->bitrate_max),

drivers/net/can/flexcan/flexcan-core.c

+2 −2
Original line number Diff line number Diff line
@@ -1226,7 +1226,7 @@ static void flexcan_set_bittiming_cbt(const struct net_device *dev) 
{

	struct flexcan_priv *priv = netdev_priv(dev);

	struct can_bittiming *bt = &priv->can.bittiming;

	struct can_bittiming *dbt = &priv->can.data_bittiming;

	struct can_bittiming *dbt = &priv->can.fd.data_bittiming;

	struct flexcan_regs __iomem *regs = priv->regs;

	u32 reg_cbt, reg_fdctrl;
@@ -2239,7 +2239,7 @@ static int flexcan_probe(struct platform_device *pdev) 
		priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD |

			CAN_CTRLMODE_FD_NON_ISO;

		priv->can.bittiming_const = &flexcan_fd_bittiming_const;

		priv->can.data_bittiming_const =

		priv->can.fd.data_bittiming_const =

			&flexcan_fd_data_bittiming_const;

	} else {

		priv->can.bittiming_const = &flexcan_bittiming_const;

drivers/net/can/ifi_canfd/ifi_canfd.c

+5 −5
Original line number Diff line number Diff line
@@ -669,7 +669,7 @@ static void ifi_canfd_set_bittiming(struct net_device *ndev) 
{

	struct ifi_canfd_priv *priv = netdev_priv(ndev);

	const struct can_bittiming *bt = &priv->can.bittiming;

	const struct can_bittiming *dbt = &priv->can.data_bittiming;

	const struct can_bittiming *dbt = &priv->can.fd.data_bittiming;

	u16 brp, sjw, tseg1, tseg2, tdc;



	/* Configure bit timing */
@@ -1001,7 +1001,7 @@ static int ifi_canfd_plat_probe(struct platform_device *pdev) 
	priv->can.clock.freq = readl(addr + IFI_CANFD_CANCLOCK);



	priv->can.bittiming_const = &ifi_canfd_bittiming_const;

	priv->can.data_bittiming_const	= &ifi_canfd_bittiming_const;

	priv->can.fd.data_bittiming_const = &ifi_canfd_bittiming_const;

	priv->can.do_set_mode = ifi_canfd_set_mode;

	priv->can.do_get_berr_counter = ifi_canfd_get_berr_counter;