can: netlink: preparation before introduction of CAN XL step 3/3
Vincent Mailhol
maintainerv4 cover can: netlink: preparation before introduction of CAN XL step 3/3
In November last year, I sent an RFC to introduce CAN XL [1]. That RFC, despite positive feedback, was put on hold due to some unanswered question concerning the PWM encoding [2].
While stuck, some small preparation work was done in parallel in [3] by refactoring the struct can_priv and doing some trivial clean-up and renaming. Initially, [3] received zero feedback but was eventually merged after splitting it in smaller parts and resending it.
Finally, in July this year, we clarified the remaining mysteries about PWM calculation, thus unlocking the series. Summer being a bit busy because of some personal matters brings us to now.
After doing all the refactoring and adding all the CAN XL features, the final result is more than 30 patches, definitively too much for a single series. So I am splitting the remaining changes three:
- can: rework the CAN MTU logic [4]
- can: netlink: preparation before introduction of CAN XL (this series)
- CAN XL (will come right after the two preparation series get merged)
And thus, this series continues and finishes the preparation work done in [3] and [4]. It contains all the refactoring needed to smoothly introduce CAN XL. The goal is to:
- split the functions in smaller pieces: CAN XL will introduce a fair amount of code. And some functions which are already fairly long (86 lines for can_validate(), 215 lines for can_changelink()) would grow to disproportionate sizes if the CAN XL logic were to be inlined in those functions.
- repurpose the existing code to handle both CAN FD and CAN XL: a huge part of CAN XL simply reuses the CAN FD logic. All the existing CAN FD logic is made more generic to handle both CAN FD and XL.
In more details:
- Patch #1 moves struct data_bittiming_params from dev.h to bittiming.h and patch #2 makes can_get_relative_tdco() FD agnostic before also moving it to bittiming.h.
- Patch #3 adds some comments to netlink.h tagging which IFLA symbols are FD specific.
- Patches #4 to #6 are refactoring can_validate() and can_validate_bittiming().
- Patches #7 to #11 are refactoring can_changelink() and can_tdc_changelink().
- Patches #12 and #13 are refactoring can_get_size() and
can_tdc_get_size().
- Patches #14 to #17 are refactoring can_fill_info() and
can_tdc_fill_info().
- Patch #18 makes can_calc_tdco() FD agnostic.
- Patch #19 adds can_get_ctrlmode_str() which converts control mode flags into strings. This is done in preparation of patch #20.
- Patch #20 is the final patch and improves the user experience by providing detailed error messages whenever invalid parameters are provided. All those error messages came into handy when debugging the upcoming CAN XL patches.
Aside from the last patch, the other changes do not impact any of the existing functionalities.
The follow up series which introduces CAN XL is nearly completed but will be sent only once this one is approved: one thing at a time, I do not want to overwhelm people (including myself).
[1] https://lore.kernel.org/linux-can/[email protected]/
[2] https://lore.kernel.org/linux-can/[email protected]/
[3] https://lore.kernel.org/linux-can/[email protected]/
[4] https://lore.kernel.org/linux-can/[email protected]/
To: Marc Kleine-Budde <[email protected]>
To: Oliver Hartkopp <[email protected]>
Cc: Vincent Mailhol <[email protected]>
Cc: Stéphane Grosjean <[email protected]>
Cc: Robert Nawrath <[email protected]>
Cc: Minh Le <[email protected]>
Cc: Duy Nguyen <[email protected]>
Cc: [email protected]
Cc: [email protected]
---
Changes in v4:
- v3 was based on Linus tree and, despite
b4 prep --check-deps
giving no warnings, did not apply soomthly to net-next. Rebase on net-next.
Link to v3: https://lore.kernel.org/r/[email protected]
Changes in v3:
- Rebase on top of the "can: rework the CAN MTU logic" series.
- Add a static_assert() in can_validate_databittiming() to prove that the nla attributes were already correctly aligned.
- Replace the ! operator by ~ to fix a bug in patch #7:
"can: netlink: refactor CAN_CTRLMODE_TDC_{AUTO,MANUAL} flag reset logic".
Link to v2: https://lore.kernel.org/r/[email protected]
Changes in v2:
- Move can_validate()'s comment block to can_validate_databittiming(). Consequently,
[PATCH 07/21] can: netlink: remove comment in can_validate()
from v1 is removed.
- Change any occurrences of WARN_ON(1) into return -EOPNOTSUPP to
suppress the three gcc warnings which were reported by the kernel
test robot:
Link: https://lore.kernel.org/linux-can/[email protected]/
Link: https://lore.kernel.org/linux-can/[email protected]/
Link: https://lore.kernel.org/linux-can/[email protected]/ - Small rewrite of patch #12 "can: netlink: make can_tdc_get_size() FD agnostic" description to add more details.
Link to v1: https://lore.kernel.org/r/[email protected]
---
Vincent Mailhol (20):
can: dev: move struct data_bittiming_params to linux/can/bittiming.h
can: dev: make can_get_relative_tdco() FD agnostic and move it to bittiming.h
can: netlink: document which symbols are FD specific
can: netlink: refactor can_validate_bittiming()
can: netlink: add can_validate_tdc()
can: netlink: add can_validate_databittiming()
can: netlink: refactor CAN_CTRLMODE_TDC_{AUTO,MANUAL} flag reset logic
can: netlink: remove useless check in can_tdc_changelink()
can: netlink: make can_tdc_changelink() FD agnostic
can: netlink: add can_dtb_changelink()
can: netlink: add can_ctrlmode_changelink()
can: netlink: make can_tdc_get_size() FD agnostic
can: netlink: add can_data_bittiming_get_size()
can: netlink: add can_bittiming_fill_info()
can: netlink: add can_bittiming_const_fill_info()
can: netlink: add can_bitrate_const_fill_info()
can: netlink: make can_tdc_fill_info() FD agnostic
can: calc_bittiming: make can_calc_tdco() FD agnostic
can: dev: add can_get_ctrlmode_str()
can: netlink: add userland error messages
drivers/net/can/dev/calc_bittiming.c | 10 +- drivers/net/can/dev/dev.c | 33 ++ drivers/net/can/dev/netlink.c | 627 ++++++++++++++++++++++------------- include/linux/can/bittiming.h | 48 ++- include/linux/can/dev.h | 42 +-- include/uapi/linux/can/netlink.h | 14 +- 6 files changed, 485 insertions(+), 289 deletions(-)
---
base-commit: 9b277fca90c39c8b749e659bf5c23e924c46c93b
change-id: 20250831-canxl-netlink-prep-9dbf8498fd9d
prerequisite-change-id: 20250915-can-fix-mtu-050a94b563a0:v3
prerequisite-patch-id: 64b7803b5453bdd2ada5f2918901ad092e4ea1cf
prerequisite-patch-id: 6aecc3f1db1cd342e3b204310464179ca66b52ba
prerequisite-patch-id: 10e3a79796f2966733349c4cfcc1a61a49bc20af
prerequisite-patch-id: 5ddc3c20a99f60bddb62d58eb192facf0eb25b75
Best regards,
Signature · 1 line
Vincent Mailhol <[email protected]>
Vincent Mailhol
maintainerPATCH v4 1/20 can: dev: move struct data_bittiming_params to linux/can/bittiming.h
In commit b803c4a4f788 ("can: dev: add struct data_bittiming_params to group FD parameters"), struct data_bittiming_params was put into linux/can/dev.h.
This structure being a collection of bittiming parameters, on second thought, bittiming.h is actually a better location. This way, users of struct data_bittiming_params will not have to forcefully include linux/can/dev.h thus removing some complexity and reducing the risk of circular dependencies in headers.
Move struct data_bittiming_params from linux/can/dev.h to linux/can/bittiming.h.
--- include/linux/can/bittiming.h | 11 +++++++++++ include/linux/can/dev.h | 11 ----------- 2 files changed, 11 insertions(+), 11 deletions(-)
include/linux/can/bittiming.h +11 -0
@@ -114,6 +114,17 @@ struct can_tdc_const {u32 tdcf_max; }; +struct data_bittiming_params { +const struct can_bittiming_const *data_bittiming_const; +struct can_bittiming data_bittiming; +const struct can_tdc_const *tdc_const; +struct can_tdc tdc; +const u32 *data_bitrate_const; +unsigned int data_bitrate_const_cnt; +int (*do_set_data_bittiming)(struct net_device *dev); +int (*do_get_auto_tdcv)(const struct net_device *dev,u32 *tdcv); +}; +#ifdef CONFIG_CAN_CALC_BITTIMING int can_calc_bittiming (const struct net_device *dev,struct can_bittiming *bt,const struct can_bittiming_const *btc,struct netlink_ext_ack *extack);
include/linux/can/dev.h +0 -11
@@ -38,17 +38,6 @@ enum can_termination_gpio { CAN_TERMINATION_GPIO_MAX, }; -struct data_bittiming_params { -const struct can_bittiming_const *data_bittiming_const; -struct can_bittiming data_bittiming; -const struct can_tdc_const *tdc_const; -struct can_tdc tdc; -const u32 *data_bitrate_const; -unsigned int data_bitrate_const_cnt; -int (*do_set_data_bittiming)(struct net_device *dev); -int (*do_get_auto_tdcv)(const struct net_device *dev,u32 *tdcv); -}; -/* * CAN common private data */
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 2/20 can: dev: make can_get_relative_tdco() FD agnostic and move it to bittiming.h
In reply to Vincent Mailholcan_get_relative_tdco() needs to access can_priv->fd making it specific to CAN FD. Change the function parameter from struct can_priv to struct data_bittiming_params. This way, the function becomes CAN FD agnostic and can be reused later on for the CAN XL TDC.
Now that we dropped the dependency on struct can_priv, also move can_get_relative_tdco() back to bittiming.h where it was meant to belong to.
---
Changelog:
RFC -> v1:
- Just pass the IFLA index instead of passing each argument individually. Instead, derive these as local variables depending on whethe the IFLA index is IFLA_CAN_TDC or IFLA_CAN_XL_TDC.
--- include/linux/can/bittiming.h | 29 +++++++++++++++++++++++++++++ include/linux/can/dev.h | 29 ----------------------------- 2 files changed, 29 insertions(+), 29 deletions(-)
include/linux/can/bittiming.h +29 -0
@@ -160,6 +160,35 @@ int can_get_bittiming(const struct net_device *dev, struct can_bittiming *bt,const unsigned int bitrate_const_cnt, struct netlink_ext_ack *extack); +/* +* can_get_relative_tdco() - TDCO relative to the sample point +* +* struct can_tdc::tdco represents the absolute offset from TDCV. Some +* controllers use instead an offset relative to the Sample Point (SP) +* such that: +* +* SSP = TDCV + absolute TDCO +* = TDCV + SP + relative TDCO +* +* -+----------- one bit ----------+-- TX pin +* |<--- Sample Point --->| +* +* --+----------- one bit ----------+-- RX pin +* |<-------- TDCV -------->| +* |<------------------------>| absolute TDCO +* |<--- Sample Point --->| +* | |<->| relative TDCO +* |<------------- Secondary Sample Point ------------>| +*/ +static inline s32 can_get_relative_tdco (const struct data_bittiming_params *dbt_params) +{ +const struct can_bittiming *dbt = &dbt_params->data_bittiming; +s32 sample_point_in_tc = (CAN_SYNC_SEG + dbt->prop_seg + + dbt->phase_seg1) * dbt->brp; + +return (s32 )dbt_params->tdc.tdco - sample_point_in_tc; +} +/* * can_bit_time() - Duration of one bit *
include/linux/can/dev.h +0 -29
@@ -85,35 +85,6 @@ static inline bool can_fd_tdc_is_enabled(const struct can_priv *priv)return !!(priv->ctrlmode &CAN_CTRLMODE_FD_TDC_MASK ); } -/* -* can_get_relative_tdco() - TDCO relative to the sample point -* -* struct can_tdc::tdco represents the absolute offset from TDCV. Some -* controllers use instead an offset relative to the Sample Point (SP) -* such that: -* -* SSP = TDCV + absolute TDCO -* = TDCV + SP + relative TDCO -* -* -+----------- one bit ----------+-- TX pin -* |<--- Sample Point --->| -* -* --+----------- one bit ----------+-- RX pin -* |<-------- TDCV -------->| -* |<------------------------>| absolute TDCO -* |<--- Sample Point --->| -* | |<->| relative TDCO -* |<------------- Secondary Sample Point ------------>| -*/ -static inline s32 can_get_relative_tdco (const struct can_priv *priv) -{ -const struct can_bittiming *dbt = &priv->fd.data_bittiming; -s32 sample_point_in_tc = (CAN_SYNC_SEG + dbt->prop_seg + - dbt->phase_seg1) * dbt->brp; - -return (s32 )priv->fd.tdc.tdco - sample_point_in_tc; -} -static inline u32 can_get_static_ctrlmode (struct can_priv *priv) {return priv->ctrlmode & ~priv->ctrlmode_supported;
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 3/20 can: netlink: document which symbols are FD specific
In reply to Vincent MailholThe CAN XL netlink interface will also have data bitrate and TDC parameters. The current FD parameters do not have a prefix in their names to differentiate them.
Because the netlink interface is part of the UAPI, it is unfortunately not feasible to rename the existing symbols to add an FD_ prefix. The best alternative is to add a comment for each of the symbols to notify the reader of which parts are CAN FD specific.
While at it, fix a typo: transiver -> transceiver.
--- include/uapi/linux/can/netlink.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
include/uapi/linux/can/netlink.h +7 -7
@@ -101,8 +101,8 @@ struct can_ctrlmode {#define CAN_CTRLMODE_PRESUME_ACK 0x40/* Ignore missing CAN ACKs */ #define CAN_CTRLMODE_FD_NON_ISO 0x80/* CAN FD in non-ISO mode */ #define CAN_CTRLMODE_CC_LEN8_DLC 0x100/* Classic CAN DLC option */ -#define CAN_CTRLMODE_TDC_AUTO 0x200/* CAN transiver automatically calculates TDCV */ -#define CAN_CTRLMODE_TDC_MANUAL 0x400/* TDCV is manually set up by user */ +#define CAN_CTRLMODE_TDC_AUTO 0x200/* FD transceiver automatically calculates TDCV */ +#define CAN_CTRLMODE_TDC_MANUAL 0x400/* FD TDCV is manually set up by user */ /* * CAN device statistics
@@ -129,14 +129,14 @@ enum {IFLA_CAN_RESTART_MS ,IFLA_CAN_RESTART ,IFLA_CAN_BERR_COUNTER , -IFLA_CAN_DATA_BITTIMING , -IFLA_CAN_DATA_BITTIMING_CONST , +IFLA_CAN_DATA_BITTIMING ,/* FD */ +IFLA_CAN_DATA_BITTIMING_CONST ,/* FD */ IFLA_CAN_TERMINATION ,IFLA_CAN_TERMINATION_CONST ,IFLA_CAN_BITRATE_CONST , -IFLA_CAN_DATA_BITRATE_CONST , +IFLA_CAN_DATA_BITRATE_CONST ,/* FD */ IFLA_CAN_BITRATE_MAX , -IFLA_CAN_TDC , +IFLA_CAN_TDC ,/* FD */ IFLA_CAN_CTRLMODE_EXT , /* add new constants above here */
@@ -145,7 +145,7 @@ enum { };/* -* CAN FD Transmitter Delay Compensation (TDC) +* CAN FD/XL Transmitter Delay Compensation (TDC) * * Please refer to struct can_tdc_const and can_tdc in * include/linux/can/bittiming.h for further details.
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 4/20 can: netlink: refactor can_validate_bittiming()
In reply to Vincent MailholWhenever can_validate_bittiming() is called, it is always preceded by some boilerplate code which was copy pasted all over the place. Move that repeated code directly inside can_validate_bittiming().
Finally, the mempcy() is not needed: the nla attributes are four bytes aligned which is just enough for struct can_bittiming. Add a static_assert() to document that the alignment is correct and just use the pointer returned by nla_data() as-is.
---
Changelog:
v2 -> v3:
- add a static_assert() to prove that the alignment is correct.
--- drivers/net/can/dev/netlink.c | 36 +++++++++++++++++------------------- 1 file changed, 17 insertions(+), 19 deletions(-)
drivers/net/can/dev/netlink.c +17 -19
@@ -36,13 +36,21 @@ static const struct nla_policy can_tdc_policy[IFLA_CAN_TDC_MAX + 1] = { [IFLA_CAN_TDC_TDCF] = { .type = NLA_U32 }, }; -static int can_validate_bittiming (const struct can_bittiming *bt, -struct netlink_ext_ack *extack) +static int can_validate_bittiming (struct nlattr *data[], +struct netlink_ext_ack *extack, +int ifla_can_bittiming) { +struct can_bittiming *bt; + +if (!data[ifla_can_bittiming]) +return 0 ; + + static_assert(__alignof__(*bt) <= NLA_ALIGNTO); + bt =nla_data (data[ifla_can_bittiming]); +/* sample point is in one-tenth of a percent */ if (bt->sample_point >=1000 ) {NL_SET_ERR_MSG (extack,"sample point must be between 0 and 100%" ); -return -EINVAL ; }
@@ -105,14 +113,9 @@ static int can_validate(struct nlattr *tb[], struct nlattr *data[], } } -if (data[IFLA_CAN_BITTIMING ]) { -struct can_bittiming bt; - -memcpy (&bt,nla_data (data[IFLA_CAN_BITTIMING ]),sizeof (bt)); - err =can_validate_bittiming (&bt, extack); -if (err) -return err; - } + err =can_validate_bittiming (data, extack,IFLA_CAN_BITTIMING ); +if (err) +return err;if (is_can_fd) {if (!data[IFLA_CAN_BITTIMING ] || !data[IFLA_CAN_DATA_BITTIMING ])
@@ -124,14 +127,9 @@ static int can_validate(struct nlattr *tb[], struct nlattr *data[],return -EOPNOTSUPP ; } -if (data[IFLA_CAN_DATA_BITTIMING ]) { -struct can_bittiming bt; - -memcpy (&bt,nla_data (data[IFLA_CAN_DATA_BITTIMING ]),sizeof (bt)); - err =can_validate_bittiming (&bt, extack); -if (err) -return err; - } + err =can_validate_bittiming (data, extack,IFLA_CAN_DATA_BITTIMING ); +if (err) +return err;return 0 ; }
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 5/20 can: netlink: add can_validate_tdc()
In reply to Vincent MailholFactorise the TDC validation out of can_validate() and move it in the new can_validate_tdc() function. This is a preparation patch for the introduction of CAN XL because this TDC validation will be reused later on.
---
Changelog:
RFC -> v1:
- fix bug on tdc flags mutual exclusivity:
'if (tdc_auto == tdc_manual)' -> 'if (tdc_auto && tdc_manual)' --- drivers/net/can/dev/netlink.c | 82 +++++++++++++++++++++++++------------------ include/linux/can/bittiming.h | 4 +++ 2 files changed, 52 insertions(+), 34 deletions(-)
drivers/net/can/dev/netlink.c +48 -34
@@ -57,6 +57,49 @@ static int can_validate_bittiming(struct nlattr *data[],return 0 ; } +static int can_validate_tdc (struct nlattr *data_tdc, +struct netlink_ext_ack *extack,u32 tdc_flags) +{ +bool tdc_manual = tdc_flags &CAN_CTRLMODE_TDC_MANUAL_MASK ; +bool tdc_auto = tdc_flags &CAN_CTRLMODE_TDC_AUTO_MASK ; +int err; + +/* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually exclusive */ +if (tdc_auto && tdc_manual) +return -EOPNOTSUPP ; + +/* If one of the CAN_CTRLMODE_TDC_* flag is set then TDC +* must be set and vice-versa +*/ +if ((tdc_auto || tdc_manual) != !!data_tdc) +return -EOPNOTSUPP ; + +/* If providing TDC parameters, at least TDCO is needed. TDCV +* is needed if and only if CAN_CTRLMODE_TDC_MANUAL is set +*/ +if (data_tdc) { +struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX +1 ]; + + err =nla_parse_nested (tb_tdc,IFLA_CAN_TDC_MAX , + data_tdc, can_tdc_policy, extack); +if (err) +return err; + +if (tb_tdc[IFLA_CAN_TDC_TDCV ]) { +if (tdc_auto) +return -EOPNOTSUPP ; + }else { +if (tdc_manual) +return -EOPNOTSUPP ; + } + +if (!tb_tdc[IFLA_CAN_TDC_TDCO ]) +return -EOPNOTSUPP ; + } + +return 0 ; +} +static int can_validate (struct nlattr *tb[],struct nlattr *data[],struct netlink_ext_ack *extack) {
@@ -67,7 +110,7 @@ static int can_validate(struct nlattr *tb[], struct nlattr *data[],* - nominal/arbitration bittiming * - data bittiming * - control mode with CAN_CTRLMODE_FD set -* - TDC parameters are coherent (details below) +* - TDC parameters are coherent (details in can_validate_tdc()) */ if (!data)
@@ -75,42 +118,13 @@ static int can_validate(struct nlattr *tb[], struct nlattr *data[],if (data[IFLA_CAN_CTRLMODE ]) {struct can_ctrlmode *cm =nla_data (data[IFLA_CAN_CTRLMODE ]); -u32 tdc_flags = cm->flags &CAN_CTRLMODE_FD_TDC_MASK ; is_can_fd = cm->flags & cm->mask &CAN_CTRLMODE_FD ; -/* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually exclusive */ -if (tdc_flags ==CAN_CTRLMODE_FD_TDC_MASK ) -return -EOPNOTSUPP ; -/* If one of the CAN_CTRLMODE_TDC_* flag is set then -* TDC must be set and vice-versa -*/ -if (!!tdc_flags != !!data[IFLA_CAN_TDC ]) -return -EOPNOTSUPP ; -/* If providing TDC parameters, at least TDCO is -* needed. TDCV is needed if and only if -* CAN_CTRLMODE_TDC_MANUAL is set -*/ -if (data[IFLA_CAN_TDC ]) { -struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX +1 ]; - - err =nla_parse_nested (tb_tdc,IFLA_CAN_TDC_MAX , - data[IFLA_CAN_TDC ], - can_tdc_policy, extack); -if (err) -return err; - -if (tb_tdc[IFLA_CAN_TDC_TDCV ]) { -if (tdc_flags &CAN_CTRLMODE_TDC_AUTO ) -return -EOPNOTSUPP ; - }else { -if (tdc_flags &CAN_CTRLMODE_TDC_MANUAL ) -return -EOPNOTSUPP ; - } - -if (!tb_tdc[IFLA_CAN_TDC_TDCO ]) -return -EOPNOTSUPP ; - } + err =can_validate_tdc (data[IFLA_CAN_TDC ], extack, + cm->flags &CAN_CTRLMODE_FD_TDC_MASK ); +if (err) +return err; } err =can_validate_bittiming (data, extack,IFLA_CAN_BITTIMING );
include/linux/can/bittiming.h +4 -0
@@ -16,6 +16,10 @@#define CAN_CTRLMODE_FD_TDC_MASK \ (CAN_CTRLMODE_TDC_AUTO | CAN_CTRLMODE_TDC_MANUAL) +#define CAN_CTRLMODE_TDC_AUTO_MASK \ + (CAN_CTRLMODE_TDC_AUTO) +#define CAN_CTRLMODE_TDC_MANUAL_MASK \ + (CAN_CTRLMODE_TDC_MANUAL)/* * struct can_tdc - CAN FD Transmission Delay Compensation parameters
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 6/20 can: netlink: add can_validate_databittiming()
In reply to Vincent MailholFactorise the databittiming validation out of can_validate() and move it in the new add can_validate_databittiming() function. Also move can_validate()'s comment because it is specific to CAN FD. This is a preparation patch for the introduction of CAN XL as this databittiming validation will be reused later on.
---
Changelog:
v1 -> v2:
- Move can_validate()'s comment block to can_validate_databittiming(). Consequently, the next patch
can: netlink: remove comment in can_validate()
is removed.
- Change WARN_ON(1) into return -EOPNOTSUPP to suppress a gcc
warning.
Link: https://lore.kernel.org/linux-can/[email protected]/
---
drivers/net/can/dev/netlink.c | 64 +++++++++++++++++++++++++++++--------------
1 file changed, 44 insertions(+), 20 deletions(-)drivers/net/can/dev/netlink.c +44 -20
@@ -100,10 +100,13 @@ static int can_validate_tdc(struct nlattr *data_tdc,return 0 ; } -static int can_validate (struct nlattr *tb[],struct nlattr *data[], -struct netlink_ext_ack *extack) +static int can_validate_databittiming (struct nlattr *data[], +struct netlink_ext_ack *extack, +int ifla_can_data_bittiming,u32 flags) { -bool is_can_fd = false; +struct nlattr *data_tdc; +u32 tdc_flags; +bool is_on;int err;/* Make sure that valid CAN FD configurations always consist of
@@ -113,35 +116,56 @@ static int can_validate(struct nlattr *tb[], struct nlattr *data[],* - TDC parameters are coherent (details in can_validate_tdc()) */ +if (ifla_can_data_bittiming ==IFLA_CAN_DATA_BITTIMING ) { + data_tdc = data[IFLA_CAN_TDC ]; + tdc_flags = flags &CAN_CTRLMODE_FD_TDC_MASK ; + is_on = flags &CAN_CTRLMODE_FD ; + }else { +return -EOPNOTSUPP ;/* Place holder for CAN XL */ + } + +if (is_on) { +if (!data[IFLA_CAN_BITTIMING ] || !data[ifla_can_data_bittiming]) +return -EOPNOTSUPP ; + } + +if (data[ifla_can_data_bittiming] || data_tdc) { +if (!is_on) +return -EOPNOTSUPP ; + } + + err =can_validate_bittiming (data, extack, ifla_can_data_bittiming); +if (err) +return err; + + err =can_validate_tdc (data_tdc, extack, tdc_flags); +if (err) +return err; + +return 0 ; +} + +static int can_validate (struct nlattr *tb[],struct nlattr *data[], +struct netlink_ext_ack *extack) +{ +u32 flags =0 ; +int err; +if (!data)return 0 ;if (data[IFLA_CAN_CTRLMODE ]) {struct can_ctrlmode *cm =nla_data (data[IFLA_CAN_CTRLMODE ]); - is_can_fd = cm->flags & cm->mask &CAN_CTRLMODE_FD ; - - err =can_validate_tdc (data[IFLA_CAN_TDC ], extack, - cm->flags &CAN_CTRLMODE_FD_TDC_MASK ); -if (err) -return err; + flags = cm->flags & cm->mask; } err =can_validate_bittiming (data, extack,IFLA_CAN_BITTIMING );if (err)return err; -if (is_can_fd) { -if (!data[IFLA_CAN_BITTIMING ] || !data[IFLA_CAN_DATA_BITTIMING ]) -return -EOPNOTSUPP ; - } - -if (data[IFLA_CAN_DATA_BITTIMING ] || data[IFLA_CAN_TDC ]) { -if (!is_can_fd) -return -EOPNOTSUPP ; - } - - err =can_validate_bittiming (data, extack,IFLA_CAN_DATA_BITTIMING ); + err =can_validate_databittiming (data, extack, +IFLA_CAN_DATA_BITTIMING , flags);if (err)return err;
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 7/20 can: netlink: refactor CAN_CTRLMODE_TDC_{AUTO,MANUAL} flag reset logic
In reply to Vincent MailholCAN_CTRLMODE_TDC_AUTO and CAN_CTRLMODE_TDC_MANUAL are mutually exclusive. This means that whenever the user switches from auto to manual mode (or vice versa), the other flag which was set previously needs to be cleared.
Currently, this is handled with a masking operation. It can be done in a simpler manner by clearing any of the previous TDC flags before copying netlink attributes. The code becomes easier to understand and will make it easier to add the new upcoming CAN XL flags which will have a similar reset logic as the current TDC flags.
---
Changelog:
v2 -> v3:
- Fix a bug in the masking. Replace
priv->ctrlmode &= !CAN_CTRLMODE_FD_TDC_MASK;
by
priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
---
drivers/net/can/dev/netlink.c | 9 ++++-----
1 file changed, 4 insertions(+), 5 deletions(-)drivers/net/can/dev/netlink.c +4 -5
@@ -255,6 +255,10 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[],if ((maskedflags & ctrlstatic) != ctrlstatic)return -EOPNOTSUPP ; +/* If a top dependency flag is provided, reset all its dependencies */ +if (cm->mask &CAN_CTRLMODE_FD ) + priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK ; +/* clear bits to be modified and copy the flag values */ priv->ctrlmode &= ~cm->mask; priv->ctrlmode |= maskedflags;
@@ -270,11 +274,6 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[],can_set_default_mtu (dev); fd_tdc_flag_provided = cm->mask &CAN_CTRLMODE_FD_TDC_MASK ; -/* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually -* exclusive: make sure to turn the other one off -*/ -if (fd_tdc_flag_provided) - priv->ctrlmode &= cm->flags | ~CAN_CTRLMODE_FD_TDC_MASK ; }if (data[IFLA_CAN_BITTIMING ]) {
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 8/20 can: netlink: remove useless check in can_tdc_changelink()
In reply to Vincent Mailholcan_tdc_changelink() return -EOPNOTSUPP under this condition:
!tdc_const || !can_fd_tdc_is_enabled(priv)
But this function is only called if the data[IFLA_CAN_TDC] parameters are provided. At this point, can_validate_tdc() already checked that either of the tdc auto or tdc manual control modes were provided, that is to say, can_fd_tdc_is_enabled(priv) must be true.
Because the right hand operand of this condition is always true, remove it.
--- drivers/net/can/dev/netlink.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/net/can/dev/netlink.c +1 -1
@@ -180,7 +180,7 @@ static int can_tdc_changelink(struct can_priv *priv, const struct nlattr *nla,const struct can_tdc_const *tdc_const = priv->fd.tdc_const;int err; -if (!tdc_const || !can_fd_tdc_is_enabled (priv)) +if (!tdc_const)return -EOPNOTSUPP ; err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, nla,
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 9/20 can: netlink: make can_tdc_changelink() FD agnostic
In reply to Vincent Mailholcan_tdc_changelink() needs to access can_priv->fd making it specific to CAN FD. Change the function parameter from struct can_priv to struct data_bittiming_params. This way, the function becomes CAN FD agnostic and can be reused later on for the CAN XL TDC.
--- drivers/net/can/dev/netlink.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
drivers/net/can/dev/netlink.c +6 -5
@@ -172,12 +172,13 @@ static int can_validate(struct nlattr *tb[], struct nlattr *data[],return 0 ; } -static int can_tdc_changelink (struct can_priv *priv,const struct nlattr *nla, +static int can_tdc_changelink (struct data_bittiming_params *dbt_params, +const struct nlattr *nla,struct netlink_ext_ack *extack) {struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX +1 ];struct can_tdc tdc = {0 }; -const struct can_tdc_const *tdc_const = priv->fd.tdc_const; +const struct can_tdc_const *tdc_const = dbt_params->tdc_const;int err;if (!tdc_const)
@@ -215,7 +216,7 @@ static int can_tdc_changelink(struct can_priv *priv, const struct nlattr *nla, tdc.tdcf = tdcf; } - priv->fd.tdc = tdc; + dbt_params->tdc = tdc;return 0 ; }
@@ -382,8 +383,8 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[],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 ], - extack); + err =can_tdc_changelink (&priv->fd, + data[IFLA_CAN_TDC ], extack);if (err) { priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK ;return err;
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 10/20 can: netlink: add can_dtb_changelink()
In reply to Vincent MailholFactorise the databittiming parsing out of can_changelink() and move it in the new can_dtb_changelink() function. This is a preparation patch for the introduction of CAN XL because the databittiming changelink logic will be reused later on.
---
Changelog:
v1 -> v2:
- Change WARN_ON(1) into return -EOPNOTSUPP to suppress a gcc
warning.
Link: https://lore.kernel.org/linux-can/[email protected]/RFC -> v1:
- In the RFC, can_dbt_changelink() required 8 parameters. Instead, just pass a boolean and then get the FD/XL specific parameters in an "if (fd) {} else {}" conditional.
--- drivers/net/can/dev/netlink.c | 152 ++++++++++++++++++++++++------------------ 1 file changed, 88 insertions(+), 64 deletions(-)
drivers/net/can/dev/netlink.c +88 -64
@@ -221,12 +221,95 @@ static int can_tdc_changelink(struct data_bittiming_params *dbt_params,return 0 ; } +static int can_dbt_changelink (struct net_device *dev,struct nlattr *data[], +bool fd,struct netlink_ext_ack *extack) +{ +struct nlattr *data_bittiming, *data_tdc; +struct can_priv *priv =netdev_priv (dev); +struct data_bittiming_params *dbt_params; +struct can_bittiming dbt; +bool need_tdc_calc = false; +u32 tdc_mask; +int err; + +if (fd) { + data_bittiming = data[IFLA_CAN_DATA_BITTIMING ]; + data_tdc = data[IFLA_CAN_TDC ]; + dbt_params = &priv->fd; + tdc_mask =CAN_CTRLMODE_FD_TDC_MASK ; + }else { +return -EOPNOTSUPP ;/* Place holder for CAN XL */ + } + +if (!data_bittiming) +return 0 ; + +/* Do not allow changing bittiming while running */ +if (dev->flags &IFF_UP ) +return -EBUSY ; + +/* Calculate bittiming parameters based on data_bittiming_const +* if set, otherwise pass bitrate directly via do_set_bitrate(). +* Bail out if neither is given. +*/ +if (!dbt_params->data_bittiming_const && !dbt_params->do_set_data_bittiming && + !dbt_params->data_bitrate_const) +return -EOPNOTSUPP ; + +memcpy (&dbt,nla_data (data_bittiming),sizeof (dbt)); + err =can_get_bittiming (dev, &dbt, dbt_params->data_bittiming_const, + dbt_params->data_bitrate_const, + dbt_params->data_bitrate_const_cnt, extack); +if (err) +return err; + +if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) { +NL_SET_ERR_MSG_FMT (extack, +"CAN data bitrate %u bps surpasses transceiver capabilities of %u bps" , + dbt.bitrate, priv->bitrate_max); +return -EINVAL ; + } + +memset (&dbt_params->tdc,0 ,sizeof (dbt_params->tdc)); +if (data[IFLA_CAN_CTRLMODE ]) { +struct can_ctrlmode *cm =nla_data (data[IFLA_CAN_CTRLMODE ]); + + need_tdc_calc = !(cm->mask & tdc_mask); + } +if (data_tdc) { +/* TDC parameters are provided: use them */ + err =can_tdc_changelink (dbt_params, data_tdc, extack); +if (err) { + priv->ctrlmode &= ~tdc_mask; +return err; + } + }else if (need_tdc_calc) { +/* Neither of TDC parameters nor TDC flags are provided: +* do calculation +*/ +can_calc_tdco (&dbt_params->tdc, dbt_params->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 (&dbt_params->data_bittiming, &dbt,sizeof (dbt)); + +if (dbt_params->do_set_data_bittiming) { +/* Finally, set the bit-timing registers */ + err = dbt_params->do_set_data_bittiming (dev); +if (err) +return err; + } + +return 0 ; +} +static int can_changelink (struct net_device *dev,struct nlattr *tb[],struct nlattr *data[],struct netlink_ext_ack *extack) {struct can_priv *priv =netdev_priv (dev); -bool fd_tdc_flag_provided = false;int err;/* We need synchronization with dev->stop() */
@@ -273,8 +356,6 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[], }can_set_default_mtu (dev); - - fd_tdc_flag_provided = cm->mask &CAN_CTRLMODE_FD_TDC_MASK ; }if (data[IFLA_CAN_BITTIMING ]) {
@@ -347,67 +428,10 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[],return err; } -if (data[IFLA_CAN_DATA_BITTIMING ]) { -struct can_bittiming dbt; - -/* Do not allow changing bittiming while running */ -if (dev->flags &IFF_UP ) -return -EBUSY ; - -/* Calculate bittiming parameters based on -* data_bittiming_const if set, otherwise pass bitrate -* directly via do_set_bitrate(). Bail out if neither -* is given. -*/ -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->fd.data_bittiming_const, - priv->fd.data_bitrate_const, - priv->fd.data_bitrate_const_cnt, - extack); -if (err) -return err; - -if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) { -NL_SET_ERR_MSG_FMT (extack, -"CANFD data bitrate %u bps surpasses transceiver capabilities of %u bps" , - dbt.bitrate, priv->bitrate_max); -return -EINVAL ; - } - -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->fd, - data[IFLA_CAN_TDC ], extack); -if (err) { - priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK ; -return err; - } - }else if (!fd_tdc_flag_provided) { -/* Neither of TDC parameters nor TDC flags are -* provided: do calculation -*/ -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->fd.data_bittiming, &dbt,sizeof (dbt)); - -if (priv->fd.do_set_data_bittiming) { -/* Finally, set the bit-timing registers */ - err = priv->fd.do_set_data_bittiming (dev); -if (err) -return err; - } - } +/* CAN FD */ + err =can_dbt_changelink (dev, data, true, extack); +if (err) +return err;if (data[IFLA_CAN_TERMINATION ]) {const u16 termval =nla_get_u16 (data[IFLA_CAN_TERMINATION ]);
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 11/20 can: netlink: add can_ctrlmode_changelink()
In reply to Vincent MailholSplit the control mode change link logic into a new function:can_ctrlmode_changelink(). The purpose is to increase code readability by preventing can_changelink() from becoming too big.
--- drivers/net/can/dev/netlink.c | 96 ++++++++++++++++++++++++------------------- 1 file changed, 54 insertions(+), 42 deletions(-)
drivers/net/can/dev/netlink.c +54 -42
@@ -172,6 +172,59 @@ static int can_validate(struct nlattr *tb[], struct nlattr *data[],return 0 ; } +static int can_ctrlmode_changelink (struct net_device *dev, +struct nlattr *data[], +struct netlink_ext_ack *extack) +{ +struct can_priv *priv =netdev_priv (dev); +struct can_ctrlmode *cm; +u32 maskedflags; +u32 ctrlstatic; + +if (!data[IFLA_CAN_CTRLMODE ]) +return 0 ; + +/* Do not allow changing controller mode while running */ +if (dev->flags &IFF_UP ) +return -EBUSY ; + + cm =nla_data (data[IFLA_CAN_CTRLMODE ]); + maskedflags = cm->flags & cm->mask; + ctrlstatic =can_get_static_ctrlmode (priv); + +/* check whether provided bits are allowed to be passed */ +if (maskedflags & ~(priv->ctrlmode_supported | ctrlstatic)) +return -EOPNOTSUPP ; + +/* do not check for static fd-non-iso if 'fd' is disabled */ +if (!(maskedflags &CAN_CTRLMODE_FD )) + ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO ; + +/* make sure static options are provided by configuration */ +if ((maskedflags & ctrlstatic) != ctrlstatic) +return -EOPNOTSUPP ; + +/* If a top dependency flag is provided, reset all its dependencies */ +if (cm->mask &CAN_CTRLMODE_FD ) + priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK ; + +/* clear bits to be modified and copy the flag values */ + priv->ctrlmode &= ~cm->mask; + priv->ctrlmode |= maskedflags; + +/* Wipe potential leftovers from previous CAN FD config */ +if (!(priv->ctrlmode &CAN_CTRLMODE_FD )) { +memset (&priv->fd.data_bittiming,0 , +sizeof (priv->fd.data_bittiming)); + priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK ; +memset (&priv->fd.tdc,0 ,sizeof (priv->fd.tdc)); + } + +can_set_default_mtu (dev); + +return 0 ; +} +static int can_tdc_changelink (struct data_bittiming_params *dbt_params,const struct nlattr *nla,struct netlink_ext_ack *extack)
@@ -315,48 +368,7 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[],/* We need synchronization with dev->stop() */ ASSERT_RTNL (); -if (data[IFLA_CAN_CTRLMODE ]) { -struct can_ctrlmode *cm; -u32 ctrlstatic; -u32 maskedflags; - -/* Do not allow changing controller mode while running */ -if (dev->flags &IFF_UP ) -return -EBUSY ; - cm =nla_data (data[IFLA_CAN_CTRLMODE ]); - ctrlstatic =can_get_static_ctrlmode (priv); - maskedflags = cm->flags & cm->mask; - -/* check whether provided bits are allowed to be passed */ -if (maskedflags & ~(priv->ctrlmode_supported | ctrlstatic)) -return -EOPNOTSUPP ; - -/* do not check for static fd-non-iso if 'fd' is disabled */ -if (!(maskedflags &CAN_CTRLMODE_FD )) - ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO ; - -/* make sure static options are provided by configuration */ -if ((maskedflags & ctrlstatic) != ctrlstatic) -return -EOPNOTSUPP ; - -/* If a top dependency flag is provided, reset all its dependencies */ -if (cm->mask &CAN_CTRLMODE_FD ) - priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK ; - -/* clear bits to be modified and copy the flag values */ - priv->ctrlmode &= ~cm->mask; - priv->ctrlmode |= maskedflags; - -/* Wipe potential leftovers from previous CAN FD config */ -if (!(priv->ctrlmode &CAN_CTRLMODE_FD )) { -memset (&priv->fd.data_bittiming,0 , -sizeof (priv->fd.data_bittiming)); - priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK ; -memset (&priv->fd.tdc,0 ,sizeof (priv->fd.tdc)); - } - -can_set_default_mtu (dev); - } +can_ctrlmode_changelink (dev, data, extack);if (data[IFLA_CAN_BITTIMING ]) {struct can_bittiming bt;
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 12/20 can: netlink: make can_tdc_get_size() FD agnostic
In reply to Vincent Mailholcan_tdc_get_size() needs to access can_priv->fd making it specific to CAN FD. Change the function parameter from struct can_priv to struct data_bittiming_params.
can_tdc_get_size() also uses the CAN_CTRLMODE_TDC_MANUAL macro making it specific to CAN FD. Add the tdc mask to the function parameter list. The value of the tdc manual flag can then be derived from that mask and stored in a local variable.
This way, the function becomes CAN FD agnostic and can be reused later on for the CAN XL TDC.
---
Changelog:
v1 -> v2:
- Small rewrite of the patch description adding one more paragraph with further details.
--- drivers/net/can/dev/netlink.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-)
drivers/net/can/dev/netlink.c +11 -10
@@ -472,32 +472,32 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[],return 0 ; } -static size_t can_tdc_get_size (const struct net_device *dev) +static size_t can_tdc_get_size (struct data_bittiming_params *dbt_params, +u32 tdc_flags) { -struct can_priv *priv =netdev_priv (dev); +bool tdc_manual = tdc_flags &CAN_CTRLMODE_TDC_MANUAL_MASK ;size_t size; -if (!priv->fd.tdc_const) +if (!dbt_params->tdc_const)return 0 ; size =nla_total_size (0 );/* nest IFLA_CAN_TDC */ -if (priv->ctrlmode_supported &CAN_CTRLMODE_TDC_MANUAL ) { +if (tdc_manual) { size +=nla_total_size (sizeof (u32));/* IFLA_CAN_TDCV_MIN */ size +=nla_total_size (sizeof (u32));/* IFLA_CAN_TDCV_MAX */ } size +=nla_total_size (sizeof (u32));/* IFLA_CAN_TDCO_MIN */ size +=nla_total_size (sizeof (u32));/* IFLA_CAN_TDCO_MAX */ -if (priv->fd.tdc_const->tdcf_max) { +if (dbt_params->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_fd_tdc_is_enabled (priv)) { -if (priv->ctrlmode &CAN_CTRLMODE_TDC_MANUAL || - priv->fd.do_get_auto_tdcv) +if (tdc_flags) { +if (tdc_manual || dbt_params->do_get_auto_tdcv) size +=nla_total_size (sizeof (u32));/* IFLA_CAN_TDCV */ size +=nla_total_size (sizeof (u32));/* IFLA_CAN_TDCO */ -if (priv->fd.tdc_const->tdcf_max) +if (dbt_params->tdc_const->tdcf_max) size +=nla_total_size (sizeof (u32));/* IFLA_CAN_TDCF */ }
@@ -541,7 +541,8 @@ static size_t can_get_size(const struct net_device *dev) 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_tdc_get_size (&priv->fd,/* IFLA_CAN_TDC */ + priv->ctrlmode &CAN_CTRLMODE_FD_TDC_MASK ); size +=can_ctrlmode_ext_get_size ();/* IFLA_CAN_CTRLMODE_EXT */ return size;
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 13/20 can: netlink: add can_data_bittiming_get_size()
In reply to Vincent MailholAdd the can_data_bittiming_get_size() function to factorise the logic to retrieve the size of below data bittiming parameters:
- data_bittiming
- data_bittiming_const
- data_bitrate_const
- tdc parameters
This function will be reused later on for CAN XL.
--- drivers/net/can/dev/netlink.c | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-)
drivers/net/can/dev/netlink.c +20 -9
@@ -504,6 +504,23 @@ static size_t can_tdc_get_size(struct data_bittiming_params *dbt_params,return size; } +static size_t can_data_bittiming_get_size (struct data_bittiming_params *dbt_params, +u32 tdc_flags) +{ +size_t size =0 ; + +if (dbt_params->data_bittiming.bitrate)/* IFLA_CAN_DATA_BITTIMING */ + size +=nla_total_size (sizeof (dbt_params->data_bittiming)); +if (dbt_params->data_bittiming_const)/* IFLA_CAN_DATA_BITTIMING_CONST */ + size +=nla_total_size (sizeof (*dbt_params->data_bittiming_const)); +if (dbt_params->data_bitrate_const)/* IFLA_CAN_DATA_BITRATE_CONST */ + size +=nla_total_size (sizeof (*dbt_params->data_bitrate_const) * + dbt_params->data_bitrate_const_cnt); + size +=can_tdc_get_size (dbt_params, tdc_flags);/* IFLA_CAN_TDC */ + +return size; +} +static size_t can_ctrlmode_ext_get_size (void ) { return nla_total_size(0) + /* nest IFLA_CAN_CTRLMODE_EXT */
@@ -525,10 +542,6 @@ 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->fd.data_bittiming.bitrate)/* IFLA_CAN_DATA_BITTIMING */ - size +=nla_total_size (sizeof (struct can_bittiming )); -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 */ size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */
@@ -537,14 +550,12 @@ 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->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 (&priv->fd,/* IFLA_CAN_TDC */ - priv->ctrlmode &CAN_CTRLMODE_FD_TDC_MASK ); size +=can_ctrlmode_ext_get_size ();/* IFLA_CAN_CTRLMODE_EXT */ + size +=can_data_bittiming_get_size (&priv->fd, + priv->ctrlmode &CAN_CTRLMODE_FD_TDC_MASK ); +return size; }
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 14/20 can: netlink: add can_bittiming_fill_info()
In reply to Vincent MailholAdd can_bittiming_fill_info() to factorise the logic when filling the bittiming information for Classical CAN and CAN FD. This function will be reused later on for CAN XL.
--- drivers/net/can/dev/netlink.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-)
drivers/net/can/dev/netlink.c +12 -7
@@ -559,6 +559,14 @@ static size_t can_get_size(const struct net_device *dev)return size; } +static int can_bittiming_fill_info (struct sk_buff *skb,int ifla_can_bittiming, +struct can_bittiming *bittiming) +{ +return bittiming->bitrate !=CAN_BITRATE_UNSET && + bittiming->bitrate !=CAN_BITRATE_UNKNOWN && +nla_put (skb, ifla_can_bittiming,sizeof (*bittiming), bittiming); +} +static int can_tdc_fill_info (struct sk_buff *skb,const struct net_device *dev) {struct nlattr *nest;
@@ -641,10 +649,8 @@ 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 ((priv->bittiming.bitrate != CAN_BITRATE_UNSET && - priv->bittiming.bitrate != CAN_BITRATE_UNKNOWN && - nla_put(skb, IFLA_CAN_BITTIMING, - sizeof(priv->bittiming), &priv->bittiming)) || + if (can_bittiming_fill_info(skb, IFLA_CAN_BITTIMING, + &priv->bittiming) || (priv->bittiming_const && nla_put(skb, IFLA_CAN_BITTIMING_CONST,
@@ -659,9 +665,8 @@ 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->fd.data_bittiming.bitrate && - nla_put(skb, IFLA_CAN_DATA_BITTIMING, - sizeof(priv->fd.data_bittiming), &priv->fd.data_bittiming)) || + can_bittiming_fill_info(skb, IFLA_CAN_DATA_BITTIMING, + &priv->fd.data_bittiming) || (priv->fd.data_bittiming_const && nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST,
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 15/20 can: netlink: add can_bittiming_const_fill_info()
In reply to Vincent MailholAdd function can_bittiming_const_fill_info() to factorise the logic when filling the bittiming constant information for Classical CAN and CAN FD. This function will be reused later on for CAN XL.
--- drivers/net/can/dev/netlink.c | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-)
drivers/net/can/dev/netlink.c +13 -7
@@ -567,6 +567,15 @@ static int can_bittiming_fill_info(struct sk_buff *skb, int ifla_can_bittiming,nla_put (skb, ifla_can_bittiming,sizeof (*bittiming), bittiming); } +static int can_bittiming_const_fill_info (struct sk_buff *skb, +int ifla_can_bittiming_const, +const struct can_bittiming_const *bittiming_const) +{ +return bittiming_const && +nla_put (skb, ifla_can_bittiming_const, +sizeof (*bittiming_const), bittiming_const); +} +static int can_tdc_fill_info (struct sk_buff *skb,const struct net_device *dev) {struct nlattr *nest;
@@ -652,9 +661,8 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) if (can_bittiming_fill_info(skb, IFLA_CAN_BITTIMING, &priv->bittiming) || - (priv->bittiming_const && - nla_put(skb, IFLA_CAN_BITTIMING_CONST, - sizeof(*priv->bittiming_const), priv->bittiming_const)) || + can_bittiming_const_fill_info(skb, IFLA_CAN_BITTIMING_CONST, + priv->bittiming_const) || nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) || nla_put_u32(skb, IFLA_CAN_STATE, state) ||
@@ -668,10 +676,8 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)can_bittiming_fill_info (skb,IFLA_CAN_DATA_BITTIMING , &priv->fd.data_bittiming) || - (priv->fd.data_bittiming_const && -nla_put (skb,IFLA_CAN_DATA_BITTIMING_CONST , -sizeof (*priv->fd.data_bittiming_const), - priv->fd.data_bittiming_const)) || +can_bittiming_const_fill_info (skb,IFLA_CAN_DATA_BITTIMING_CONST , + priv->fd.data_bittiming_const) || (priv->termination_const && (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) ||
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 16/20 can: netlink: add can_bitrate_const_fill_info()
In reply to Vincent MailholAdd can_bitrate_const_fill_info() to factorise the logic when filling the bitrate constant information for Classical CAN and CAN FD. This function will be reused later on for CAN XL.
--- drivers/net/can/dev/netlink.c | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-)
drivers/net/can/dev/netlink.c +15 -10
@@ -576,6 +576,15 @@ static int can_bittiming_const_fill_info(struct sk_buff *skb, sizeof(*bittiming_const), bittiming_const); } +static int can_bitrate_const_fill_info (struct sk_buff *skb, +int ifla_can_bitrate_const, +const u32 *bitrate_const,unsigned int cnt) +{ +return bitrate_const && +nla_put (skb, ifla_can_bitrate_const, +sizeof (*bitrate_const) * cnt, bitrate_const); +} +static int can_tdc_fill_info (struct sk_buff *skb,const struct net_device *dev) {struct nlattr *nest;
@@ -686,17 +695,13 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) priv->termination_const_cnt, priv->termination_const))) || - (priv->bitrate_const && -nla_put (skb,IFLA_CAN_BITRATE_CONST , -sizeof (*priv->bitrate_const) * - priv->bitrate_const_cnt, - priv->bitrate_const)) || +can_bitrate_const_fill_info (skb,IFLA_CAN_BITRATE_CONST , + priv->bitrate_const, + priv->bitrate_const_cnt) || - (priv->fd.data_bitrate_const && -nla_put (skb,IFLA_CAN_DATA_BITRATE_CONST , -sizeof (*priv->fd.data_bitrate_const) * - priv->fd.data_bitrate_const_cnt, - priv->fd.data_bitrate_const)) || +can_bitrate_const_fill_info (skb,IFLA_CAN_DATA_BITRATE_CONST , + priv->fd.data_bitrate_const, + priv->fd.data_bitrate_const_cnt) || (nla_put(skb, IFLA_CAN_BITRATE_MAX, sizeof(priv->bitrate_max),
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 17/20 can: netlink: make can_tdc_fill_info() FD agnostic
In reply to Vincent Mailholcan_tdc_fill_info() depends on some variables which are specific to CAN FD. Move these to the function parameters list so that, later on, this function can be reused for the CAN XL TDC.
---
Changelog:
v1 -> v2:
- Change WARN_ON(1) into return -EOPNOTSUPP to suppress a gcc
warning.
Link: https://lore.kernel.org/linux-can/[email protected]/RFC -> v1:
- Just pass the IFLA index instead of passing each argument individually. Instead, derive these as local variables depending on whethe the IFLA index is IFLA_CAN_TDC or IFLA_CAN_XL_TDC.
--- drivers/net/can/dev/netlink.c | 35 ++++++++++++++++++++++++----------- 1 file changed, 24 insertions(+), 11 deletions(-)
drivers/net/can/dev/netlink.c +24 -11
@@ -585,21 +585,34 @@ static int can_bitrate_const_fill_info(struct sk_buff *skb, sizeof(*bitrate_const) * cnt, bitrate_const); } -static int can_tdc_fill_info (struct sk_buff *skb,const struct net_device *dev) +static int can_tdc_fill_info (struct sk_buff *skb,const struct net_device *dev, +int ifla_can_tdc) { -struct nlattr *nest;struct can_priv *priv =netdev_priv (dev); -struct can_tdc *tdc = &priv->fd.tdc; -const struct can_tdc_const *tdc_const = priv->fd.tdc_const; +struct data_bittiming_params *dbt_params; +const struct can_tdc_const *tdc_const; +struct can_tdc *tdc; +struct nlattr *nest; +bool tdc_is_enabled, tdc_manual; + +if (ifla_can_tdc ==IFLA_CAN_TDC ) { + dbt_params = &priv->fd; + tdc_is_enabled =can_fd_tdc_is_enabled (priv); + tdc_manual = priv->ctrlmode &CAN_CTRLMODE_TDC_MANUAL ; + }else { +return -EOPNOTSUPP ;/* Place holder for CAN XL */ + } + tdc_const = dbt_params->tdc_const; + tdc = &dbt_params->tdc;if (!tdc_const)return 0 ; - nest =nla_nest_start (skb,IFLA_CAN_TDC ); + nest =nla_nest_start (skb, ifla_can_tdc);if (!nest)return -EMSGSIZE ; -if (priv->ctrlmode_supported &CAN_CTRLMODE_TDC_MANUAL && +if (tdc_manual && (nla_put_u32 (skb,IFLA_CAN_TDC_TDCV_MIN , tdc_const->tdcv_min) ||nla_put_u32 (skb,IFLA_CAN_TDC_TDCV_MAX , tdc_const->tdcv_max))) goto err_cancel;
@@ -611,15 +624,15 @@ static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev) nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max))) goto err_cancel; -if (can_fd_tdc_is_enabled (priv)) { +if (tdc_is_enabled) {u32 tdcv;int err = -EINVAL ; -if (priv->ctrlmode &CAN_CTRLMODE_TDC_MANUAL ) { +if (tdc_manual) { tdcv = tdc->tdcv; err =0 ; - }else if (priv->fd.do_get_auto_tdcv) { - err = priv->fd.do_get_auto_tdcv (dev, &tdcv); + }else if (dbt_params->do_get_auto_tdcv) { + err = dbt_params->do_get_auto_tdcv (dev, &tdcv); }if (!err &&nla_put_u32 (skb,IFLA_CAN_TDC_TDCV , tdcv)) goto err_cancel;
@@ -707,7 +720,7 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) sizeof(priv->bitrate_max), &priv->bitrate_max)) || -can_tdc_fill_info (skb, dev) || +can_tdc_fill_info (skb, dev,IFLA_CAN_TDC ) ||can_ctrlmode_ext_fill_info (skb, priv) )
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 18/20 can: calc_bittiming: make can_calc_tdco() FD agnostic
In reply to Vincent Mailholcan_calc_tdco() uses the CAN_CTRLMODE_FD_TDC_MASK and CAN_CTRLMODE_TDC_AUTO macros making it specific to CAN FD. Add the tdc mask to the function parameter list. The value of the tdc auto flag can then be derived from that mask and stored in a local variable. This way, the function becomes CAN FD agnostic and can be reused later on for the CAN XL TDC.
---
Changelog:
RFC -> v1:
- new patch. I overlooked this in the RFC and the CAN XL's TDC was broken because of that.
--- drivers/net/can/dev/calc_bittiming.c | 10 ++++++---- drivers/net/can/dev/netlink.c | 2 +- include/linux/can/bittiming.h | 4 ++-- 3 files changed, 9 insertions(+), 7 deletions(-)
drivers/net/can/dev/calc_bittiming.c +6 -4
@@ -173,13 +173,15 @@ int can_calc_bittiming(const struct net_device *dev, struct can_bittiming *bt,void can_calc_tdco (struct can_tdc *tdc,const struct can_tdc_const *tdc_const,const struct can_bittiming *dbt, -u32 *ctrlmode,u32 ctrlmode_supported) +u32 tdc_mask,u32 *ctrlmode,u32 ctrlmode_supported) { -if (!tdc_const || !(ctrlmode_supported &CAN_CTRLMODE_TDC_AUTO )) +u32 tdc_auto = tdc_mask &CAN_CTRLMODE_TDC_AUTO_MASK ; + +if (!tdc_const || !(ctrlmode_supported & tdc_auto))return ; - *ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK ; + *ctrlmode &= ~tdc_mask;/* As specified in ISO 11898-1 section 11.3.3 "Transmitter * delay compensation" (TDC) is only applicable if data BRP is
@@ -193,6 +195,6 @@ void can_calc_tdco(struct can_tdc *tdc, const struct can_tdc_const *tdc_const,if (sample_point_in_tc < tdc_const->tdco_min)return ; tdc->tdco =min (sample_point_in_tc, tdc_const->tdco_max); - *ctrlmode |=CAN_CTRLMODE_TDC_AUTO ; + *ctrlmode |= tdc_auto; } }
drivers/net/can/dev/netlink.c +1 -1
@@ -341,7 +341,7 @@ static int can_dbt_changelink(struct net_device *dev, struct nlattr *data[],* do calculation */ can_calc_tdco (&dbt_params->tdc, dbt_params->tdc_const, &dbt, - &priv->ctrlmode, priv->ctrlmode_supported); + tdc_mask, &priv->ctrlmode, priv->ctrlmode_supported); }/* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly * turned off. TDC is disabled: do nothing */
include/linux/can/bittiming.h +2 -2
@@ -135,7 +135,7 @@ int can_calc_bittiming(const struct net_device *dev, struct can_bittiming *bt,void can_calc_tdco (struct can_tdc *tdc,const struct can_tdc_const *tdc_const,const struct can_bittiming *dbt, -u32 *ctrlmode,u32 ctrlmode_supported); +u32 tdc_mask,u32 *ctrlmode,u32 ctrlmode_supported);#else /* !CONFIG_CAN_CALC_BITTIMING */ static inline int can_calc_bittiming(const struct net_device *dev, struct can_bittiming *bt,
@@ -148,7 +148,7 @@ can_calc_bittiming(const struct net_device *dev, struct can_bittiming *bt,static inline void can_calc_tdco (struct can_tdc *tdc,const struct can_tdc_const *tdc_const,const struct can_bittiming *dbt, -u32 *ctrlmode,u32 ctrlmode_supported) +u32 tdc_mask,u32 *ctrlmode,u32 ctrlmode_supported) { }#endif /* CONFIG_CAN_CALC_BITTIMING */
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 19/20 can: dev: add can_get_ctrlmode_str()
In reply to Vincent MailholIn an effort to give more human readable messages when errors occur because of conflicting options, it can be useful to convert the CAN control mode flags into text.
Add a function which converts the first set CAN control mode into a human readable string. The reason to only convert the first one is to simplify edge cases: imagine that there are several invalid control modes, we would just return the first invalid one to the user, thus not having to handle complex string concatenation. The user can then solve the first problem, call the netlink interface again and see the next issue.
People who wish to enumerate all the control modes can still do so by, for example, using this new function in a for_each_set_bit() loop.
--- drivers/net/can/dev/dev.c | 33 +++++++++++++++++++++++++++++++++ include/linux/can/dev.h | 2 ++ 2 files changed, 35 insertions(+)
drivers/net/can/dev/dev.c +33 -0
@@ -88,6 +88,39 @@ const char *can_get_state_str(const enum can_state state) }EXPORT_SYMBOL_GPL (can_get_state_str); +const char *can_get_ctrlmode_str (u32 ctrlmode) +{ +switch (ctrlmode & ~(ctrlmode -1 )) { +case 0 : +return "none" ; +case CAN_CTRLMODE_LOOPBACK : +return "loopback" ; +case CAN_CTRLMODE_LISTENONLY : +return "listen-only" ; +case CAN_CTRLMODE_3_SAMPLES : +return "triple-sampling" ; +case CAN_CTRLMODE_ONE_SHOT : +return "one-shot" ; +case CAN_CTRLMODE_BERR_REPORTING : +return "berr-reporting" ; +case CAN_CTRLMODE_FD : +return "fd" ; +case CAN_CTRLMODE_PRESUME_ACK : +return "presume-ack" ; +case CAN_CTRLMODE_FD_NON_ISO : +return "fd-non-iso" ; +case CAN_CTRLMODE_CC_LEN8_DLC : +return "cc-len8-dlc" ; +case CAN_CTRLMODE_TDC_AUTO : +return "fd-tdc-auto" ; +case CAN_CTRLMODE_TDC_MANUAL : +return "fd-tdc-manual" ; +default : +return "<unknown>" ; + } +} +EXPORT_SYMBOL_GPL (can_get_ctrlmode_str); +static enum can_state can_state_err_to_state (u16 err) {if (err <CAN_ERROR_WARNING_THRESHOLD )
include/linux/can/dev.h +2 -0
@@ -141,6 +141,8 @@ int can_restart_now(struct net_device *dev);void can_bus_off (struct net_device *dev);const char *can_get_state_str (const enum can_state state); +const char *can_get_ctrlmode_str (u32 ctrlmode); + void can_state_get_by_berr_counter(const struct net_device *dev, const struct can_berr_counter *bec, enum can_state *tx_state,
Signature · 1 line
2.49.1
Vincent Mailhol
maintainerPATCH v4 20/20 can: netlink: add userland error messages
In reply to Vincent MailholUse NL_SET_ERR_MSG() and NL_SET_ERR_MSG_FMT() to return meaningful error messages to the userland whenever a -EOPNOTSUPP error is returned due to a failed validation of the CAN netlink arguments.
--- drivers/net/can/dev/netlink.c | 82 ++++++++++++++++++++++++++++++++----------- 1 file changed, 62 insertions(+), 20 deletions(-)
drivers/net/can/dev/netlink.c +62 -20
@@ -64,15 +64,23 @@ static int can_validate_tdc(struct nlattr *data_tdc,bool tdc_auto = tdc_flags &CAN_CTRLMODE_TDC_AUTO_MASK ;int err; -/* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually exclusive */ -if (tdc_auto && tdc_manual) +if (tdc_auto && tdc_manual) { +NL_SET_ERR_MSG (extack, +"TDC manual and auto modes are mutually exclusive" );return -EOPNOTSUPP ; + }/* If one of the CAN_CTRLMODE_TDC_* flag is set then TDC * must be set and vice-versa */ -if ((tdc_auto || tdc_manual) != !!data_tdc) +if ((tdc_auto || tdc_manual) && !data_tdc) { +NL_SET_ERR_MSG (extack,"TDC parameters are missing" );return -EOPNOTSUPP ; + } +if (!(tdc_auto || tdc_manual) && data_tdc) { +NL_SET_ERR_MSG (extack,"TDC mode (auto or manual) is missing" ); +return -EOPNOTSUPP ; + }/* If providing TDC parameters, at least TDCO is needed. TDCV * is needed if and only if CAN_CTRLMODE_TDC_MANUAL is set
@@ -86,15 +94,23 @@ static int can_validate_tdc(struct nlattr *data_tdc,return err;if (tb_tdc[IFLA_CAN_TDC_TDCV ]) { -if (tdc_auto) +if (tdc_auto) { +NL_SET_ERR_MSG (extack, +"TDCV is incompatible with TDC auto mode" );return -EOPNOTSUPP ; + } }else { -if (tdc_manual) +if (tdc_manual) { +NL_SET_ERR_MSG (extack, +"TDC manual mode requires TDCV" );return -EOPNOTSUPP ; + } } -if (!tb_tdc[IFLA_CAN_TDC_TDCO ]) +if (!tb_tdc[IFLA_CAN_TDC_TDCO ]) { +NL_SET_ERR_MSG (extack,"TDCO is missing" );return -EOPNOTSUPP ; + } }return 0 ;
@@ -105,6 +121,7 @@ static int can_validate_databittiming(struct nlattr *data[], int ifla_can_data_bittiming, u32 flags) {struct nlattr *data_tdc; +const char *type;u32 tdc_flags;bool is_on;int err;
@@ -120,18 +137,31 @@ static int can_validate_databittiming(struct nlattr *data[], data_tdc = data[IFLA_CAN_TDC ]; tdc_flags = flags &CAN_CTRLMODE_FD_TDC_MASK ; is_on = flags &CAN_CTRLMODE_FD ; + type ="FD" ; }else {return -EOPNOTSUPP ;/* Place holder for CAN XL */ }if (is_on) { -if (!data[IFLA_CAN_BITTIMING ] || !data[ifla_can_data_bittiming]) +if (!data[IFLA_CAN_BITTIMING ] || !data[ifla_can_data_bittiming]) { +NL_SET_ERR_MSG_FMT (extack, +"Provide both nominal and %s data bittiming" , + type);return -EOPNOTSUPP ; - } - -if (data[ifla_can_data_bittiming] || data_tdc) { -if (!is_on) + } + }else { +if (data[ifla_can_data_bittiming]) { +NL_SET_ERR_MSG_FMT (extack, +"%s data bittiming requires CAN %s" , + type, type);return -EOPNOTSUPP ; + } +if (data_tdc) { +NL_SET_ERR_MSG_FMT (extack, +"%s TDC requires CAN %s" , + type, type); +return -EOPNOTSUPP ; + } } err =can_validate_bittiming (data, extack, ifla_can_data_bittiming);
@@ -178,8 +208,7 @@ static int can_ctrlmode_changelink(struct net_device *dev, {struct can_priv *priv =netdev_priv (dev);struct can_ctrlmode *cm; -u32 maskedflags; -u32 ctrlstatic; +u32 ctrlstatic, maskedflags, notsupp, ctrlstatic_missing;if (!data[IFLA_CAN_CTRLMODE ])return 0 ;
@@ -189,20 +218,28 @@ static int can_ctrlmode_changelink(struct net_device *dev,return -EBUSY ; cm =nla_data (data[IFLA_CAN_CTRLMODE ]); - maskedflags = cm->flags & cm->mask; ctrlstatic =can_get_static_ctrlmode (priv); + maskedflags = cm->flags & cm->mask; + notsupp = maskedflags & ~(priv->ctrlmode_supported | ctrlstatic); + ctrlstatic_missing = (maskedflags & ctrlstatic) ^ ctrlstatic; -/* check whether provided bits are allowed to be passed */ -if (maskedflags & ~(priv->ctrlmode_supported | ctrlstatic)) +if (notsupp) { +NL_SET_ERR_MSG_FMT (extack, +"requested control mode %s not supported" , +can_get_ctrlmode_str (notsupp));return -EOPNOTSUPP ; + }/* do not check for static fd-non-iso if 'fd' is disabled */ if (!(maskedflags &CAN_CTRLMODE_FD )) ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO ; -/* make sure static options are provided by configuration */ -if ((maskedflags & ctrlstatic) != ctrlstatic) +if (ctrlstatic_missing) { +NL_SET_ERR_MSG_FMT (extack, +"missing required %s static control mode" , +can_get_ctrlmode_str (ctrlstatic_missing));return -EOPNOTSUPP ; + }/* If a top dependency flag is provided, reset all its dependencies */ if (cm->mask &CAN_CTRLMODE_FD )
@@ -234,8 +271,10 @@ static int can_tdc_changelink(struct data_bittiming_params *dbt_params,const struct can_tdc_const *tdc_const = dbt_params->tdc_const;int err; -if (!tdc_const) +if (!tdc_const) { +NL_SET_ERR_MSG (extack,"The device does not support TDC" );return -EOPNOTSUPP ; + } err =nla_parse_nested (tb_tdc,IFLA_CAN_TDC_MAX , nla, can_tdc_policy, extack);
@@ -450,8 +489,11 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[],const unsigned int num_term = priv->termination_const_cnt;unsigned int i; -if (!priv->do_set_termination) +if (!priv->do_set_termination) { +NL_SET_ERR_MSG (extack, +"Termination is not configurable on this device" );return -EOPNOTSUPP ; + }/* check whether given value is supported by the interface */ for (i =0 ; i < num_term; i++) {
Signature · 1 line
2.49.1
Marc Kleine-Budde
maintainerQuoted 3 lines · Vincent Mailhol
In November last year, I sent an RFC to introduce CAN XL [1]. That RFC, despite positive feedback, was put on hold due to some unanswered question concerning the PWM encoding [2].
Added linux-can-next.
Thanks,
Marc
Signature · 4 lines
Pengutronix e.K. | Marc Kleine-Budde | Embedded Linux | https://www.pengutronix.de | Vertretung Nürnberg | Phone: +49-5121-206917-129 | Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-9 |