Add CAN FD infrastructure for CAN driver
v4 cover Add CAN FD infrastructure for CAN driver
This is the patch series to extend the CAN driver infrastructure with CAN FD.
Changes v3->v4:
- fix a comment in patch 4 pointed out by Stephane
- added patches 6 & 7
Patch 6 fixes a semantic issue and is probably a stable candidate.
Patch 7 can be applied later - when patch 6 emerges in the -next trees.
Regarding the discussion for patch 5: Does anyone have a better idea for it?
Regards,
Oliver
*** BLURB HERE ***
Oliver Hartkopp (7):
can: preserve skbuff protocol in can_put_echo_skb
can: netlink send bittiming data only when a bitrate is available
can: provide a separate bittiming_const parameter to bittiming
functions
can: introduce the data bitrate configuration for CAN FD
can: allow to change the device mtu for CAN FD capable devices
can: fix bitrate check semantics at interface open time
can: add bittiming check at interface open for CAN FD
drivers/net/can/dev.c | 144 +++++++++++++++++++++++++++++++++------ include/linux/can/dev.h | 7 +- include/uapi/linux/can/netlink.h | 3 + 3 files changed, 131 insertions(+), 23 deletions(-)
Signature · 1 line
1.9.0
PATCH v4 1/7 can: preserve skbuff protocol in can_put_echo_skb
The skbuff protocol value was formerly fixed/sanitized to ETH_P_CAN in can_put_echo_skb(). With CAN FD this value has to be preserved. This patch changes the hard assignment of the protocol value to a check of valid protocol values for CAN and CAN FD.
--- drivers/net/can/dev.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
drivers/net/can/dev.c +3 -2
@@ -317,7 +317,9 @@ void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,BUG_ON (idx >= priv->echo_skb_max);/* check flag whether this packet has to be looped back */ -if (!(dev->flags &IFF_ECHO ) || skb->pkt_type !=PACKET_LOOPBACK ) { +if (!(dev->flags &IFF_ECHO ) || skb->pkt_type !=PACKET_LOOPBACK || + (skb->protocol !=htons (ETH_P_CAN ) && + skb->protocol !=htons (ETH_P_CANFD ))) {kfree_skb (skb);return ; }
@@ -329,7 +331,6 @@ void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,return ;/* make settings for echo to reduce code in irq context */ - skb->protocol =htons (ETH_P_CAN ); skb->pkt_type =PACKET_BROADCAST ; skb->ip_summed =CHECKSUM_UNNECESSARY ; skb->dev = dev;
Signature · 1 line
1.9.0
PATCH v4 2/7 can: netlink send bittiming data only when a bitrate is available
In reply to Oliver HartkoppThis is also a preparation for the CAN FD specific bittiming configurations which are not existing in non-FD drivers.
--- drivers/net/can/dev.c | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)
drivers/net/can/dev.c +9 -3
@@ -719,7 +719,8 @@ static size_t can_get_size(const struct net_device *dev)struct can_priv *priv =netdev_priv (dev);size_t size =0 ; - size +=nla_total_size (sizeof (struct can_bittiming ));/* IFLA_CAN_BITTIMING */ +if (priv->bittiming.bitrate)/* IFLA_CAN_BITTIMING */ + size +=nla_total_size (sizeof (struct can_bittiming ));if (priv->bittiming_const)/* IFLA_CAN_BITTIMING_CONST */ size +=nla_total_size (sizeof (struct can_bittiming_const )); size +=nla_total_size (sizeof (struct can_clock ));/* IFLA_CAN_CLOCK */
@@ -741,15 +742,20 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)if (priv->do_get_state) priv->do_get_state (dev, &state); -if (nla_put (skb,IFLA_CAN_BITTIMING , -sizeof (priv->bittiming), &priv->bittiming) || + +if ((priv->bittiming.bitrate && +nla_put (skb,IFLA_CAN_BITTIMING , +sizeof (priv->bittiming), &priv->bittiming)) || + (priv->bittiming_const &&nla_put (skb,IFLA_CAN_BITTIMING_CONST ,sizeof (*priv->bittiming_const), priv->bittiming_const)) || +nla_put (skb,IFLA_CAN_CLOCK ,sizeof (cm), &priv->clock) ||nla_put_u32 (skb,IFLA_CAN_STATE , state) ||nla_put (skb,IFLA_CAN_CTRLMODE ,sizeof (cm), &cm) ||nla_put_u32 (skb,IFLA_CAN_RESTART_MS , priv->restart_ms) || + (priv->do_get_berr_counter && !priv->do_get_berr_counter (dev, &bec) &&nla_put (skb,IFLA_CAN_BERR_COUNTER ,sizeof (bec), &bec)))
Signature · 1 line
1.9.0
PATCH v4 3/7 can: provide a separate bittiming_const parameter to bittiming functions
In reply to Oliver HartkoppAs the bittiming calculation functions are to be used with different bittiming_const structures for CAN and CAN FD the direct reference to priv->bittiming_const inside these functions has to be removed.
--- drivers/net/can/dev.c | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-)
drivers/net/can/dev.c +14 -13
@@ -99,10 +99,10 @@ static int can_update_spt(const struct can_bittiming_const *btc,return 1000 * (tseg +1 - *tseg2) / (tseg +1 ); } -static int can_calc_bittiming (struct net_device *dev,struct can_bittiming *bt) +static int can_calc_bittiming (struct net_device *dev,struct can_bittiming *bt, +const struct can_bittiming_const *btc) {struct can_priv *priv =netdev_priv (dev); -const struct can_bittiming_const *btc = priv->bittiming_const;long rate, best_rate =0 ;long best_error =1000000000 , error =0 ;int best_tseg =0 , best_brp =0 , brp =0 ;
@@ -110,7 +110,7 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt)int spt_error =1000 , spt =0 , sampl_pt;u64 v64; -if (!priv->bittiming_const) +if (!btc)return -ENOTSUPP ;/* Use CIA recommended sample points */
@@ -204,7 +204,8 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt) return 0; }#else /* !CONFIG_CAN_CALC_BITTIMING */ -static int can_calc_bittiming (struct net_device *dev,struct can_bittiming *bt) +static int can_calc_bittiming (struct net_device *dev,struct can_bittiming *bt, +const struct can_bittiming_const *btc) {netdev_err (dev,"bit-timing calculation not available\n" );return -EINVAL ;
@@ -217,14 +218,14 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt)* prescaler value brp. You can find more information in the header * file linux/can/netlink.h. */ -static int can_fixup_bittiming (struct net_device *dev,struct can_bittiming *bt) +static int can_fixup_bittiming (struct net_device *dev,struct can_bittiming *bt, +const struct can_bittiming_const *btc) {struct can_priv *priv =netdev_priv (dev); -const struct can_bittiming_const *btc = priv->bittiming_const;int tseg1, alltseg;u64 brp64; -if (!priv->bittiming_const) +if (!btc)return -ENOTSUPP ; tseg1 = bt->prop_seg + bt->phase_seg1;
@@ -254,21 +255,21 @@ static int can_fixup_bittiming(struct net_device *dev, struct can_bittiming *bt)return 0 ; } -static int can_get_bittiming (struct net_device *dev,struct can_bittiming *bt) +static int can_get_bittiming (struct net_device *dev,struct can_bittiming *bt, +const struct can_bittiming_const *btc) { -struct can_priv *priv =netdev_priv (dev);int err;/* Check if the CAN device has bit-timing parameters */ -if (priv->bittiming_const) { +if (btc) {/* Non-expert mode? Check if the bitrate has been pre-defined */ if (!bt->tq)/* Determine bit-timing parameters */ - err =can_calc_bittiming (dev, bt); + err =can_calc_bittiming (dev, bt, btc);else /* Check bit-timing params and calculate proper brp */ - err =can_fixup_bittiming (dev, bt); + err =can_fixup_bittiming (dev, bt, btc);if (err)return err; }
@@ -669,7 +670,7 @@ static int can_changelink(struct net_device *dev,memcpy (&bt,nla_data (data[IFLA_CAN_BITTIMING ]),sizeof (bt));if ((!bt.bitrate && !bt.tq) || (bt.bitrate && bt.tq))return -EINVAL ; - err =can_get_bittiming (dev, &bt); + err =can_get_bittiming (dev, &bt, priv->bittiming_const);if (err)return err;memcpy (&priv->bittiming, &bt,sizeof (bt));
Signature · 1 line
1.9.0
PATCH v4 4/7 can: introduce the data bitrate configuration for CAN FD
In reply to Oliver HartkoppAs CAN FD offers a second bitrate for the data section of the CAN frame the infrastructure for storing and configuring this second bitrate is introduced.
--- drivers/net/can/dev.c | 42 +++++++++++++++++++++++++++++++++++++++- include/linux/can/dev.h | 6 ++++-- include/uapi/linux/can/netlink.h | 2 ++ 3 files changed, 47 insertions(+), 3 deletions(-)
drivers/net/can/dev.c +41 -1
@@ -650,6 +650,10 @@ static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = { = { .len = sizeof(struct can_bittiming_const) }, [IFLA_CAN_CLOCK] = { .len = sizeof(struct can_clock) }, [IFLA_CAN_BERR_COUNTER] = { .len = sizeof(struct can_berr_counter) }, + [IFLA_CAN_DATA_BITTIMING ] + = { .len = sizeof(struct can_bittiming) }, + [IFLA_CAN_DATA_BITTIMING_CONST ] + = { .len = sizeof(struct can_bittiming_const) }, }; static int can_changelink(struct net_device *dev,
@@ -683,6 +687,29 @@ static int can_changelink(struct net_device *dev, } } +if (data[IFLA_CAN_DATA_BITTIMING ]) { +struct can_bittiming bt; + +/* Do not allow changing bittiming while running */ +if (dev->flags &IFF_UP ) +return -EBUSY ; +memcpy (&bt,nla_data (data[IFLA_CAN_DATA_BITTIMING ]), +sizeof (bt)); +if ((!bt.bitrate && !bt.tq) || (bt.bitrate && bt.tq)) +return -EINVAL ; + err =can_get_bittiming (dev, &bt, priv->data_bittiming_const); +if (err) +return err; +memcpy (&priv->data_bittiming, &bt,sizeof (bt)); + +if (priv->do_set_data_bittiming) { +/* Finally, set the bit-timing registers */ + err = priv->do_set_data_bittiming (dev); +if (err) +return err; + } + } +if (data[IFLA_CAN_CTRLMODE ]) {struct can_ctrlmode *cm;
@@ -730,6 +757,10 @@ 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 */ + size +=nla_total_size (sizeof (struct can_bittiming )); +if (priv->data_bittiming_const)/* IFLA_CAN_DATA_BITTIMING_CONST */ + size +=nla_total_size (sizeof (struct can_bittiming_const ));return size; }
@@ -759,8 +790,17 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) (priv->do_get_berr_counter && !priv->do_get_berr_counter (dev, &bec) && - nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec))) +nla_put (skb,IFLA_CAN_BERR_COUNTER ,sizeof (bec), &bec)) || + + (priv->data_bittiming.bitrate && +nla_put (skb,IFLA_CAN_DATA_BITTIMING , +sizeof (priv->data_bittiming), &priv->data_bittiming)) || + + (priv->data_bittiming_const && +nla_put (skb,IFLA_CAN_DATA_BITTIMING_CONST , + sizeof(*priv->data_bittiming_const), priv->data_bittiming_const))) return -EMSGSIZE; +return 0 ; }
include/linux/can/dev.h +4 -2
@@ -33,8 +33,9 @@ enum can_mode {struct can_priv {struct can_device_stats can_stats; -struct can_bittiming bittiming; -const struct can_bittiming_const *bittiming_const; +struct can_bittiming bittiming, data_bittiming; +const struct can_bittiming_const *bittiming_const, + *data_bittiming_const;struct can_clock clock;enum can_state state;
@@ -45,6 +46,7 @@ struct can_priv {struct timer_list restart_timer;int (*do_set_bittiming)(struct net_device *dev); +int (*do_set_data_bittiming)(struct net_device *dev);int (*do_set_mode)(struct net_device *dev,enum can_mode mode);int (*do_get_state)(const struct net_device *dev,enum can_state *state);
include/uapi/linux/can/netlink.h +2 -0
@@ -122,6 +122,8 @@ enum {IFLA_CAN_RESTART_MS ,IFLA_CAN_RESTART ,IFLA_CAN_BERR_COUNTER , +IFLA_CAN_DATA_BITTIMING , +IFLA_CAN_DATA_BITTIMING_CONST , __IFLA_CAN_MAX };
Signature · 1 line
1.9.0
PATCH v4 5/7 can: allow to change the device mtu for CAN FD capable devices
In reply to Oliver HartkoppThe configuration for CAN FD depends on CAN_CTRLMODE_FD enabled in the driver specific ctrlmode_supported capabilities.
The configuration can be done either with the 'fd { on | off }' option in the 'ip' tool from iproute2 or by setting the CAN netdevice MTU to CAN_MTU (16) or to CANFD_MTU (72).
--- drivers/net/can/dev.c | 40 ++++++++++++++++++++++++++++++++++++++++ include/linux/can/dev.h | 1 + include/uapi/linux/can/netlink.h | 1 + 3 files changed, 42 insertions(+)
drivers/net/can/dev.c +40 -0
@@ -598,6 +598,40 @@ void free_candev(struct net_device *dev)EXPORT_SYMBOL_GPL (free_candev);/* +* changing MTU and control mode for CAN/CANFD devices +*/ +int can_change_mtu (struct net_device *dev,int new_mtu) +{ +struct can_priv *priv =netdev_priv (dev); + +/* Do not allow changing the MTU while running */ +if (dev->flags &IFF_UP ) +return -EBUSY ; + +/* allow change of MTU according to the CANFD ability of the device */ +switch (new_mtu) { + +case CAN_MTU : + priv->ctrlmode &= ~CAN_CTRLMODE_FD ; +break ; + +case CANFD_MTU : +if (!(priv->ctrlmode_supported &CAN_CTRLMODE_FD )) +return -EINVAL ; + + priv->ctrlmode |=CAN_CTRLMODE_FD ; +break ; + +default : +return -EINVAL ; + } + + dev->mtu = new_mtu; +return 0 ; +} +EXPORT_SYMBOL_GPL (can_change_mtu); + +/* * Common open function when the device gets opened. * * This function should be called in the open function of the device
@@ -721,6 +755,12 @@ static int can_changelink(struct net_device *dev,return -EOPNOTSUPP ; priv->ctrlmode &= ~cm->mask; priv->ctrlmode |= cm->flags; + +/* CAN_CTRLMODE_FD can only be set when driver supports FD */ +if (priv->ctrlmode &CAN_CTRLMODE_FD ) + dev->mtu =CANFD_MTU ; +else + dev->mtu =CAN_MTU ; }if (data[IFLA_CAN_RESTART_MS ]) {
include/linux/can/dev.h +1 -0
@@ -113,6 +113,7 @@ struct can_priv *safe_candev_priv(struct net_device *dev);int open_candev (struct net_device *dev);void close_candev (struct net_device *dev); +int can_change_mtu (struct net_device *dev,int new_mtu);int register_candev (struct net_device *dev);void unregister_candev (struct net_device *dev);
include/uapi/linux/can/netlink.h +1 -0
@@ -96,6 +96,7 @@ struct can_ctrlmode {#define CAN_CTRLMODE_3_SAMPLES 0x04/* Triple sampling mode */ #define CAN_CTRLMODE_ONE_SHOT 0x08/* One-Shot mode */ #define CAN_CTRLMODE_BERR_REPORTING 0x10/* Bus-error reporting */ +#define CAN_CTRLMODE_FD 0x20/* CAN FD mode */ /* * CAN device statistics
Signature · 1 line
1.9.0
PATCH v4 6/7 can: fix bitrate check semantics at interface open time
In reply to Oliver HartkoppWhen the expert mode is used to configure the bit-timing with 'tq' and friends, the bitrate is provided by can_fixup_bittiming(). When the bitrate calculation is used, can_calc_bittiming() provides 'tq' and friends. So in any case both values need to be not zero.
--- drivers/net/can/dev.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
drivers/net/can/dev.c +8 -2
@@ -641,8 +641,14 @@ int open_candev(struct net_device *dev) {struct can_priv *priv =netdev_priv (dev); -if (!priv->bittiming.tq && !priv->bittiming.bitrate) { -netdev_err (dev,"bit-timing not yet defined\n" ); +/* +* When the expert mode is used to configure the bit-timing with +* 'tq' and friends, the bitrate is provided by can_fixup_bittiming(). +* When the bitrate calculation is used, can_calc_bittiming() provides +* 'tq' and friends. So in any case both values need to be not zero. +*/ +if (!priv->bittiming.tq || !priv->bittiming.bitrate) { +netdev_err (dev,"incorrect/missing bit-timing\n" );return -EINVAL ; }
Signature · 1 line
1.9.0
PATCH v4 7/7 can: add bittiming check at interface open for CAN FD
In reply to Oliver HartkoppAdditionally to have the second (data) bitrate available the data bitrate has to be greater or equal to the arbitration bitrate in CAN FD.
--- drivers/net/can/dev.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/net/can/dev.c +8 -0
@@ -652,6 +652,14 @@ int open_candev(struct net_device *dev)return -EINVAL ; } +/* For CAN FD the data bitrate has to be >= the arbitration bitrate */ +if ((priv->ctrlmode_supported &CAN_CTRLMODE_FD ) && + (!priv->data_bittiming.tq || !priv->data_bittiming.bitrate || + (priv->data_bittiming.bitrate < priv->bittiming.bitrate))) { +netdev_err (dev,"incorrect/missing data bit-timing\n" ); +return -EINVAL ; + } +/* Switch carrier on if device was stopped while in bus-off state */ if (!netif_carrier_ok (dev))netif_carrier_on (dev);
Signature · 1 line
1.9.0
Re: [PATCH v4 7/7] can: add bittiming check at interface open for CAN FD
Quoted 13 lines · Oliver Hartkopp
Additionally to have the second (data) bitrate available the data bitrate has to be greater or equal to the arbitration bitrate in CAN FD.
Signed-off-by Oliver Hartkopp <[email protected]>--- drivers/net/can/dev.c | 8 ++++++++ 1 file changed, 8 insertions(+)drivers/net/can/dev.c +0
-0
drivers/net/can/dev.c int open_candev(struct net_device *dev) · line 656
Quoted 5 lines
drivers/net/can/dev.c +2
-0@@ -652,6 +652,14 @@ int open_candev(struct net_device *dev)return -EINVAL ; } +/* For CAN FD the data bitrate has to be >= the arbitration bitrate */ + if ((priv->ctrlmode_supported & CAN_CTRLMODE_FD) &&
Oops.
This has to be the 'living'
priv->ctrlmode
instead of the 'constant'
priv->ctrlmode_supported
Will send an update when there's some more feedback or ACKs ...
Regards,
Oliver
Quoted 10 lines
drivers/net/can/dev.c +6
-0+ (!priv->data_bittiming.tq || !priv->data_bittiming.bitrate || + (priv->data_bittiming.bitrate < priv->bittiming.bitrate))) { +netdev_err (dev,"incorrect/missing data bit-timing\n" ); +return -EINVAL ; + } +/* Switch carrier on if device was stopped while in bus-off state */ if (!netif_carrier_ok (dev))netif_carrier_on (dev);
Re: [PATCH v4 7/7] can: add bittiming check at interface open for CAN FD
In reply to Oliver HartkoppHi Oliver,
Quoted 13 lines · Oliver Hartkopp
Additionally to have the second (data) bitrate available the data bitrate has to be greater or equal to the arbitration bitrate in CAN FD.
Signed-off-by Oliver Hartkopp <[email protected]>--- drivers/net/can/dev.c | 8 ++++++++ 1 file changed, 8 insertions(+)drivers/net/can/dev.c +0
-0
drivers/net/can/dev.c int open_candev(struct net_device *dev) · line 658
Quoted 7 lines
drivers/net/can/dev.c +4
-0@@ -652,6 +652,14 @@ int open_candev(struct net_device *dev)return -EINVAL ; } +/* For CAN FD the data bitrate has to be >= the arbitration bitrate */ +if ((priv->ctrlmode_supported &CAN_CTRLMODE_FD ) && + (!priv->data_bittiming.tq || !priv->data_bittiming.bitrate || + (priv->data_bittiming.bitrate < priv->bittiming.bitrate))) {
This prevents to configure a data bitrate slower than the arbitration bitrate. Such configuration is useless, but is it really "incorrect" or wrong?
drivers/net/can/dev.c int open_candev(struct net_device *dev) · line 665
Quoted 7 lines
drivers/net/can/dev.c +4
-0+netdev_err (dev,"incorrect/missing data bit-timing\n" ); +return -EINVAL ; + } +/* Switch carrier on if device was stopped while in bus-off state */ if (!netif_carrier_ok (dev))netif_carrier_on (dev);
Kind regards,
Kurt
Re: [PATCH v4 7/7] can: add bittiming check at interface open for CAN FD
Quoted 7 lines · Kurt Van Dijck
drivers/net/can/dev.c int open_candev(struct net_device *dev) · line 658
Quoted 4 lines
drivers/net/can/dev.c +4
-0+/* For CAN FD the data bitrate has to be >= the arbitration bitrate */ +if ((priv->ctrlmode_supported &CAN_CTRLMODE_FD ) && + (!priv->data_bittiming.tq || !priv->data_bittiming.bitrate || + (priv->data_bittiming.bitrate < priv->bittiming.bitrate))) {This prevents to configure a data bitrate slower than the arbitration bitrate. Such configuration is useless, but is it really "incorrect" or wrong?
Yes it is.
There was a definition that the data bitrate has to be greater or equal the arbitration bitrate.
In the Bosch whitepaper about CAN FD Florian Hartwich always states about the higher bitrate - but at least the data bitrate must not be lower than the arbitration bitrate.
Regards,
Oliver