lael-labs/linux

.mailmap+3−0

 Stanislav Fomichev <sdf@fomichev.me> <sdf@google.com>
 Stanislav Fomichev <sdf@fomichev.me> <stfomichev@gmail.com>
 Stefan Wahren <wahrenst@gmx.net> <stefan.wahren@i2se.com>
+Stéphane Grosjean <stephane.grosjean@hms-networks.com> <s.grosjean@peak-system.com>
+Stéphane Grosjean <stephane.grosjean@hms-networks.com> <stephane.grosjean@free.fr>
 Stéphane Witzmann <stephane.witzmann@ubpmes.univ-bpclermont.fr>
 Stephen Hemminger <stephen@networkplumber.org> <shemminger@linux-foundation.org>
 Stephen Hemminger <stephen@networkplumber.org> <shemminger@osdl.org>
 Veerabhadrarao Badiganti <quic_vbadigan@quicinc.com> <vbadigan@codeaurora.org>
 Venkateswara Naralasetty <quic_vnaralas@quicinc.com> <vnaralas@codeaurora.org>
 Vikash Garodia <quic_vgarodia@quicinc.com> <vgarodia@codeaurora.org>
+Vincent Mailhol <mailhol@kernel.org> <mailhol.vincent@wanadoo.fr>
 Vinod Koul <vkoul@kernel.org> <vinod.koul@intel.com>
 Vinod Koul <vkoul@kernel.org> <vinod.koul@linux.intel.com>
 Vinod Koul <vkoul@kernel.org> <vkoul@infradead.org>

MAINTAINERS+2−2

@@ -5415,7 +5415,7 @@ F: net/sched/sch_cake.c · 5414 unmodified lines
5415		5415
5416	CAN NETWORK DRIVERS	5416	CAN NETWORK DRIVERS
5417	M: Marc Kleine-Budde <mkl@pengutronix.de>	5417	M: Marc Kleine-Budde <mkl@pengutronix.de>
5418	M: Vincent Mailhol <mailhol.vincent@wanadoo.fr>	5418	M: Vincent Mailhol <mailhol@kernel.org>
5419	L: linux-can@vger.kernel.org	5419	L: linux-can@vger.kernel.org
5420	S: Maintained	5420	S: Maintained
5421	W: https://github.com/linux-can	5421	W: https://github.com/linux-can
@@ -9094,7 +9094,7 @@ S: Odd Fixes · 3672 unmodified lines
9094	F: drivers/net/ethernet/agere/	9094	F: drivers/net/ethernet/agere/
9095		9095
9096	ETAS ES58X CAN/USB DRIVER	9096	ETAS ES58X CAN/USB DRIVER
9097	M: Vincent Mailhol <mailhol.vincent@wanadoo.fr>	9097	M: Vincent Mailhol <mailhol@kernel.org>
9098	L: linux-can@vger.kernel.org	9098	L: linux-can@vger.kernel.org
9099	S: Maintained	9099	S: Maintained
9100	F: Documentation/networking/devlink/etas_es58x.rst	9100	F: Documentation/networking/devlink/etas_es58x.rst

drivers/net/can/dev/calc_bittiming.c+6−4

 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
 		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/dev.c+75−5

@@ -4,17 +4,17 @@ · 3 unmodified lines
4	* Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>	4	* Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>
5	*/	5	*/
6		6
7	#include <linux/kernel.h>
8	#include <linux/slab.h>
9	#include <linux/netdevice.h>
10	#include <linux/if_arp.h>
11	#include <linux/workqueue.h>
12	#include <linux/can.h>	7	#include <linux/can.h>
13	#include <linux/can/can-ml.h>	8	#include <linux/can/can-ml.h>
14	#include <linux/can/dev.h>	9	#include <linux/can/dev.h>
15	#include <linux/can/skb.h>	10	#include <linux/can/skb.h>
16	#include <linux/gpio/consumer.h>	11	#include <linux/gpio/consumer.h>
		12	#include <linux/if_arp.h>
		13	#include <linux/kernel.h>
		14	#include <linux/netdevice.h>
17	#include <linux/of.h>	15	#include <linux/of.h>
		16	#include <linux/slab.h>
		17	#include <linux/workqueue.h>
18		18
19	static void can_update_state_error_stats(struct net_device *dev,	19	static void can_update_state_error_stats(struct net_device *dev,
20	enum can_state new_state)	20	enum can_state new_state)
@@ -88,6 +88,39 @@ const char *can_get_state_str(const enum can_state state) · 67 unmodified lines
88	}	88	}
89	EXPORT_SYMBOL_GPL(can_get_state_str);	89	EXPORT_SYMBOL_GPL(can_get_state_str);
90		90
		91	const char *can_get_ctrlmode_str(u32 ctrlmode)
		92	{
		93	switch (ctrlmode & ~(ctrlmode - 1)) {
		94	case 0:
		95	return "none";
		96	case CAN_CTRLMODE_LOOPBACK:
		97	return "loopback";
		98	case CAN_CTRLMODE_LISTENONLY:
		99	return "listen-only";
		100	case CAN_CTRLMODE_3_SAMPLES:
		101	return "triple-sampling";
		102	case CAN_CTRLMODE_ONE_SHOT:
		103	return "one-shot";
		104	case CAN_CTRLMODE_BERR_REPORTING:
		105	return "berr-reporting";
		106	case CAN_CTRLMODE_FD:
		107	return "fd";
		108	case CAN_CTRLMODE_PRESUME_ACK:
		109	return "presume-ack";
		110	case CAN_CTRLMODE_FD_NON_ISO:
		111	return "fd-non-iso";
		112	case CAN_CTRLMODE_CC_LEN8_DLC:
		113	return "cc-len8-dlc";
		114	case CAN_CTRLMODE_TDC_AUTO:
		115	return "fd-tdc-auto";
		116	case CAN_CTRLMODE_TDC_MANUAL:
		117	return "fd-tdc-manual";
		118	default:
		119	return "<unknown>";
		120	}
		121	}
		122	EXPORT_SYMBOL_GPL(can_get_ctrlmode_str);
		123
91	static enum can_state can_state_err_to_state(u16 err)	124	static enum can_state can_state_err_to_state(u16 err)
92	{	125	{
93	if (err < CAN_ERROR_WARNING_THRESHOLD)	126	if (err < CAN_ERROR_WARNING_THRESHOLD)
@@ -240,6 +273,8 @@ void can_setup(struct net_device *dev) · 146 unmodified lines
240	{	273	{
241	dev->type = ARPHRD_CAN;	274	dev->type = ARPHRD_CAN;
242	dev->mtu = CAN_MTU;	275	dev->mtu = CAN_MTU;
		276	dev->min_mtu = CAN_MTU;
		277	dev->max_mtu = CAN_MTU;
243	dev->hard_header_len = 0;	278	dev->hard_header_len = 0;
244	dev->addr_len = 0;	279	dev->addr_len = 0;
245	dev->tx_queue_len = 10;	280	dev->tx_queue_len = 10;
@@ -309,6 +344,21 @@ void free_candev(struct net_device *dev) · 63 unmodified lines
309	}	344	}
310	EXPORT_SYMBOL_GPL(free_candev);	345	EXPORT_SYMBOL_GPL(free_candev);
311		346
		347	void can_set_default_mtu(struct net_device *dev)
		348	{
		349	struct can_priv *priv = netdev_priv(dev);
		350
		351	if (priv->ctrlmode & CAN_CTRLMODE_FD) {
		352	dev->mtu = CANFD_MTU;
		353	dev->min_mtu = CANFD_MTU;
		354	dev->max_mtu = CANFD_MTU;
		355	} else {
		356	dev->mtu = CAN_MTU;
		357	dev->min_mtu = CAN_MTU;
		358	dev->max_mtu = CAN_MTU;
		359	}
		360	}
		361
312	/* changing MTU and control mode for CAN/CANFD devices */	362	/* changing MTU and control mode for CAN/CANFD devices */
313	int can_change_mtu(struct net_device *dev, int new_mtu)	363	int can_change_mtu(struct net_device *dev, int new_mtu)
314	{	364	{
@@ -347,6 +397,26 @@ int can_change_mtu(struct net_device *dev, int new_mtu) · 32 unmodified lines
347	}	397	}
348	EXPORT_SYMBOL_GPL(can_change_mtu);	398	EXPORT_SYMBOL_GPL(can_change_mtu);
349		399
		400	/* helper to define static CAN controller features at device creation time */
		401	int can_set_static_ctrlmode(struct net_device *dev, u32 static_mode)
		402	{
		403	struct can_priv *priv = netdev_priv(dev);
		404
		405	/* alloc_candev() succeeded => netdev_priv() is valid at this point */
		406	if (priv->ctrlmode_supported & static_mode) {
		407	netdev_warn(dev,
		408	"Controller features can not be supported and static at the same time\n");
		409	return -EINVAL;
		410	}
		411	priv->ctrlmode = static_mode;
		412
		413	/* override MTU which was set by default in can_setup()? */
		414	can_set_default_mtu(dev);
		415
		416	return 0;
		417	}
		418	EXPORT_SYMBOL_GPL(can_set_static_ctrlmode);
		419
350	/* generic implementation of netdev_ops::ndo_eth_ioctl for CAN devices	420	/* generic implementation of netdev_ops::ndo_eth_ioctl for CAN devices
351	* supporting hardware timestamps	421	* supporting hardware timestamps
352	*/	422	*/

drivers/net/can/dev/netlink.c+373−219

@@ -36,116 +36,245 @@ static const struct nla_policy can_tdc_policy[IFLA_CAN_TDC_MAX + 1] = { · 35 unmodified lines
36	[IFLA_CAN_TDC_TDCF] = { .type = NLA_U32 },	36	[IFLA_CAN_TDC_TDCF] = { .type = NLA_U32 },
37	};	37	};
38		38
39	static int can_validate_bittiming(const struct can_bittiming *bt,	39	static int can_validate_bittiming(struct nlattr *data[],
40	struct netlink_ext_ack *extack)	40	struct netlink_ext_ack *extack,
		41	int ifla_can_bittiming)
41	{	42	{
		43	struct can_bittiming *bt;
		44
		45	if (!data[ifla_can_bittiming])
		46	return 0;
		47
		48	static_assert(__alignof__(*bt) <= NLA_ALIGNTO);
		49	bt = nla_data(data[ifla_can_bittiming]);
		50
42	/* sample point is in one-tenth of a percent */	51	/* sample point is in one-tenth of a percent */
43	if (bt->sample_point >= 1000) {	52	if (bt->sample_point >= 1000) {
44	NL_SET_ERR_MSG(extack, "sample point must be between 0 and 100%");	53	NL_SET_ERR_MSG(extack, "sample point must be between 0 and 100%");
45
46	return -EINVAL;	54	return -EINVAL;
47	}	55	}
48		56
49	return 0;	57	return 0;
50	}	58	}
51		59
52	static int can_validate(struct nlattr tb[], struct nlattr data[],	60	static int can_validate_tdc(struct nlattr *data_tdc,
53	struct netlink_ext_ack *extack)	61	struct netlink_ext_ack *extack, u32 tdc_flags)
54	{	62	{
55	bool is_can_fd = false;	63	bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK;
		64	bool tdc_auto = tdc_flags & CAN_CTRLMODE_TDC_AUTO_MASK;
		65	int err;
		66
		67	if (tdc_auto && tdc_manual) {
		68	NL_SET_ERR_MSG(extack,
		69	"TDC manual and auto modes are mutually exclusive");
		70	return -EOPNOTSUPP;
		71	}
		72
		73	/* If one of the CAN_CTRLMODE_TDC_* flag is set then TDC
		74	* must be set and vice-versa
		75	*/
		76	if ((tdc_auto \|\| tdc_manual) && !data_tdc) {
		77	NL_SET_ERR_MSG(extack, "TDC parameters are missing");
		78	return -EOPNOTSUPP;
		79	}
		80	if (!(tdc_auto \|\| tdc_manual) && data_tdc) {
		81	NL_SET_ERR_MSG(extack, "TDC mode (auto or manual) is missing");
		82	return -EOPNOTSUPP;
		83	}
		84
		85	/* If providing TDC parameters, at least TDCO is needed. TDCV
		86	* is needed if and only if CAN_CTRLMODE_TDC_MANUAL is set
		87	*/
		88	if (data_tdc) {
		89	struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
		90
		91	err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX,
		92	data_tdc, can_tdc_policy, extack);
		93	if (err)
		94	return err;
		95
		96	if (tb_tdc[IFLA_CAN_TDC_TDCV]) {
		97	if (tdc_auto) {
		98	NL_SET_ERR_MSG(extack,
		99	"TDCV is incompatible with TDC auto mode");
		100	return -EOPNOTSUPP;
		101	}
		102	} else {
		103	if (tdc_manual) {
		104	NL_SET_ERR_MSG(extack,
		105	"TDC manual mode requires TDCV");
		106	return -EOPNOTSUPP;
		107	}
		108	}
		109
		110	if (!tb_tdc[IFLA_CAN_TDC_TDCO]) {
		111	NL_SET_ERR_MSG(extack, "TDCO is missing");
		112	return -EOPNOTSUPP;
		113	}
		114	}
		115
		116	return 0;
		117	}
		118
		119	static int can_validate_databittiming(struct nlattr *data[],
		120	struct netlink_ext_ack *extack,
		121	int ifla_can_data_bittiming, u32 flags)
		122	{
		123	struct nlattr *data_tdc;
		124	const char *type;
		125	u32 tdc_flags;
		126	bool is_on;
56	int err;	127	int err;
57		128
58	/* Make sure that valid CAN FD configurations always consist of	129	/* Make sure that valid CAN FD configurations always consist of
59	* - nominal/arbitration bittiming	130	* - nominal/arbitration bittiming
60	* - data bittiming	131	* - data bittiming
61	* - control mode with CAN_CTRLMODE_FD set	132	* - control mode with CAN_CTRLMODE_FD set
62	* - TDC parameters are coherent (details below)	133	* - TDC parameters are coherent (details in can_validate_tdc())
63	*/	134	*/
64		135
		136	if (ifla_can_data_bittiming == IFLA_CAN_DATA_BITTIMING) {
		137	data_tdc = data[IFLA_CAN_TDC];
		138	tdc_flags = flags & CAN_CTRLMODE_FD_TDC_MASK;
		139	is_on = flags & CAN_CTRLMODE_FD;
		140	type = "FD";
		141	} else {
		142	return -EOPNOTSUPP; /* Place holder for CAN XL */
		143	}
		144
		145	if (is_on) {
		146	if (!data[IFLA_CAN_BITTIMING] \|\| !data[ifla_can_data_bittiming]) {
		147	NL_SET_ERR_MSG_FMT(extack,
		148	"Provide both nominal and %s data bittiming",
		149	type);
		150	return -EOPNOTSUPP;
		151	}
		152	} else {
		153	if (data[ifla_can_data_bittiming]) {
		154	NL_SET_ERR_MSG_FMT(extack,
		155	"%s data bittiming requires CAN %s",
		156	type, type);
		157	return -EOPNOTSUPP;
		158	}
		159	if (data_tdc) {
		160	NL_SET_ERR_MSG_FMT(extack,
		161	"%s TDC requires CAN %s",
		162	type, type);
		163	return -EOPNOTSUPP;
		164	}
		165	}
		166
		167	err = can_validate_bittiming(data, extack, ifla_can_data_bittiming);
		168	if (err)
		169	return err;
		170
		171	err = can_validate_tdc(data_tdc, extack, tdc_flags);
		172	if (err)
		173	return err;
		174
		175	return 0;
		176	}
		177
		178	static int can_validate(struct nlattr tb[], struct nlattr data[],
		179	struct netlink_ext_ack *extack)
		180	{
		181	u32 flags = 0;
		182	int err;
		183
65	if (!data)	184	if (!data)
66	return 0;	185	return 0;
67		186
68	if (data[IFLA_CAN_CTRLMODE]) {	187	if (data[IFLA_CAN_CTRLMODE]) {
69	struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);	188	struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
70	u32 tdc_flags = cm->flags & CAN_CTRLMODE_FD_TDC_MASK;
71		189
72	is_can_fd = cm->flags & cm->mask & CAN_CTRLMODE_FD;	190	flags = cm->flags & cm->mask;
		191	}
73		192
74	/* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually exclusive */	193	err = can_validate_bittiming(data, extack, IFLA_CAN_BITTIMING);
75	if (tdc_flags == CAN_CTRLMODE_FD_TDC_MASK)	194	if (err)
76	return -EOPNOTSUPP;	195	return err;
77	/* If one of the CAN_CTRLMODE_TDC_* flag is set then
78	* TDC must be set and vice-versa
79	*/
80	if (!!tdc_flags != !!data[IFLA_CAN_TDC])
81	return -EOPNOTSUPP;
82	/* If providing TDC parameters, at least TDCO is
83	* needed. TDCV is needed if and only if
84	* CAN_CTRLMODE_TDC_MANUAL is set
85	*/
86	if (data[IFLA_CAN_TDC]) {
87	struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
88		196
89	err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX,	197	err = can_validate_databittiming(data, extack,
90	data[IFLA_CAN_TDC],	198	IFLA_CAN_DATA_BITTIMING, flags);
91	can_tdc_policy, extack);	199	if (err)
92	if (err)	200	return err;
93	return err;
94		201
95	if (tb_tdc[IFLA_CAN_TDC_TDCV]) {	202	return 0;
96	if (tdc_flags & CAN_CTRLMODE_TDC_AUTO)	203	}
97	return -EOPNOTSUPP;
98	} else {
99	if (tdc_flags & CAN_CTRLMODE_TDC_MANUAL)
100	return -EOPNOTSUPP;
101	}
102		204
103	if (!tb_tdc[IFLA_CAN_TDC_TDCO])	205	static int can_ctrlmode_changelink(struct net_device *dev,
104	return -EOPNOTSUPP;	206	struct nlattr *data[],
105	}	207	struct netlink_ext_ack *extack)
106	}	208	{
		209	struct can_priv *priv = netdev_priv(dev);
		210	struct can_ctrlmode *cm;
		211	u32 ctrlstatic, maskedflags, notsupp, ctrlstatic_missing;
107		212
108	if (data[IFLA_CAN_BITTIMING]) {	213	if (!data[IFLA_CAN_CTRLMODE])
109	struct can_bittiming bt;	214	return 0;
110		215
111	memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));	216	/* Do not allow changing controller mode while running */
112	err = can_validate_bittiming(&bt, extack);	217	if (dev->flags & IFF_UP)
113	if (err)	218	return -EBUSY;
114	return err;
115	}
116		219
117	if (is_can_fd) {	220	cm = nla_data(data[IFLA_CAN_CTRLMODE]);
118	if (!data[IFLA_CAN_BITTIMING] \|\| !data[IFLA_CAN_DATA_BITTIMING])	221	ctrlstatic = can_get_static_ctrlmode(priv);
119	return -EOPNOTSUPP;	222	maskedflags = cm->flags & cm->mask;
		223	notsupp = maskedflags & ~(priv->ctrlmode_supported \| ctrlstatic);
		224	ctrlstatic_missing = (maskedflags & ctrlstatic) ^ ctrlstatic;
		225
		226	if (notsupp) {
		227	NL_SET_ERR_MSG_FMT(extack,
		228	"requested control mode %s not supported",
		229	can_get_ctrlmode_str(notsupp));
		230	return -EOPNOTSUPP;
120	}	231	}
121		232
122	if (data[IFLA_CAN_DATA_BITTIMING] \|\| data[IFLA_CAN_TDC]) {	233	/* do not check for static fd-non-iso if 'fd' is disabled */
123	if (!is_can_fd)	234	if (!(maskedflags & CAN_CTRLMODE_FD))
124	return -EOPNOTSUPP;	235	ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO;
		236
		237	if (ctrlstatic_missing) {
		238	NL_SET_ERR_MSG_FMT(extack,
		239	"missing required %s static control mode",
		240	can_get_ctrlmode_str(ctrlstatic_missing));
		241	return -EOPNOTSUPP;
125	}	242	}
126		243
127	if (data[IFLA_CAN_DATA_BITTIMING]) {	244	/* If a top dependency flag is provided, reset all its dependencies */
128	struct can_bittiming bt;	245	if (cm->mask & CAN_CTRLMODE_FD)
		246	priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
129		247
130	memcpy(&bt, nla_data(data[IFLA_CAN_DATA_BITTIMING]), sizeof(bt));	248	/* clear bits to be modified and copy the flag values */
131	err = can_validate_bittiming(&bt, extack);	249	priv->ctrlmode &= ~cm->mask;
132	if (err)	250	priv->ctrlmode \|= maskedflags;
133	return err;	251
		252	/* Wipe potential leftovers from previous CAN FD config */
		253	if (!(priv->ctrlmode & CAN_CTRLMODE_FD)) {
		254	memset(&priv->fd.data_bittiming, 0,
		255	sizeof(priv->fd.data_bittiming));
		256	priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
		257	memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc));
134	}	258	}
135		259
		260	can_set_default_mtu(dev);
		261
136	return 0;	262	return 0;
137	}	263	}
138		264
139	static int can_tdc_changelink(struct can_priv priv, const struct nlattr nla,	265	static int can_tdc_changelink(struct data_bittiming_params *dbt_params,
		266	const struct nlattr *nla,
140	struct netlink_ext_ack *extack)	267	struct netlink_ext_ack *extack)
141	{	268	{
142	struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];	269	struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
143	struct can_tdc tdc = { 0 };	270	struct can_tdc tdc = { 0 };
144	const struct can_tdc_const *tdc_const = priv->fd.tdc_const;	271	const struct can_tdc_const *tdc_const = dbt_params->tdc_const;
145	int err;	272	int err;
146		273
147	if (!tdc_const \|\| !can_fd_tdc_is_enabled(priv))	274	if (!tdc_const) {
		275	NL_SET_ERR_MSG(extack, "The device does not support TDC");
148	return -EOPNOTSUPP;	276	return -EOPNOTSUPP;
		277	}
149		278
150	err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, nla,	279	err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, nla,
151	can_tdc_policy, extack);	280	can_tdc_policy, extack);
@@ -179,69 +308,107 @@ static int can_tdc_changelink(struct can_priv priv, const struct nlattr nla, · 27 unmodified lines
179	tdc.tdcf = tdcf;	308	tdc.tdcf = tdcf;
180	}	309	}
181		310
182	priv->fd.tdc = tdc;	311	dbt_params->tdc = tdc;
183		312
184	return 0;	313	return 0;
185	}	314	}
186		315
187	static int can_changelink(struct net_device dev, struct nlattr tb[],	316	static int can_dbt_changelink(struct net_device dev, struct nlattr data[],
188	struct nlattr *data[],	317	bool fd, struct netlink_ext_ack *extack)
189	struct netlink_ext_ack *extack)
190	{	318	{
		319	struct nlattr data_bittiming, data_tdc;
191	struct can_priv *priv = netdev_priv(dev);	320	struct can_priv *priv = netdev_priv(dev);
192	bool fd_tdc_flag_provided = false;	321	struct data_bittiming_params *dbt_params;
		322	struct can_bittiming dbt;
		323	bool need_tdc_calc = false;
		324	u32 tdc_mask;
193	int err;	325	int err;
194		326
195	/* We need synchronization with dev->stop() */	327	if (fd) {
196	ASSERT_RTNL();	328	data_bittiming = data[IFLA_CAN_DATA_BITTIMING];
		329	data_tdc = data[IFLA_CAN_TDC];
		330	dbt_params = &priv->fd;
		331	tdc_mask = CAN_CTRLMODE_FD_TDC_MASK;
		332	} else {
		333	return -EOPNOTSUPP; /* Place holder for CAN XL */
		334	}
197		335
198	if (data[IFLA_CAN_CTRLMODE]) {	336	if (!data_bittiming)
199	struct can_ctrlmode *cm;	337	return 0;
200	u32 ctrlstatic;
201	u32 maskedflags;
202		338
203	/* Do not allow changing controller mode while running */	339	/* Do not allow changing bittiming while running */
204	if (dev->flags & IFF_UP)	340	if (dev->flags & IFF_UP)
205	return -EBUSY;	341	return -EBUSY;
206	cm = nla_data(data[IFLA_CAN_CTRLMODE]);
207	ctrlstatic = can_get_static_ctrlmode(priv);
208	maskedflags = cm->flags & cm->mask;
209		342
210	/* check whether provided bits are allowed to be passed */	343	/* Calculate bittiming parameters based on data_bittiming_const
211	if (maskedflags & ~(priv->ctrlmode_supported \| ctrlstatic))	344	* if set, otherwise pass bitrate directly via do_set_bitrate().
212	return -EOPNOTSUPP;	345	* Bail out if neither is given.
		346	*/
		347	if (!dbt_params->data_bittiming_const && !dbt_params->do_set_data_bittiming &&
		348	!dbt_params->data_bitrate_const)
		349	return -EOPNOTSUPP;
213		350
214	/* do not check for static fd-non-iso if 'fd' is disabled */	351	memcpy(&dbt, nla_data(data_bittiming), sizeof(dbt));
215	if (!(maskedflags & CAN_CTRLMODE_FD))	352	err = can_get_bittiming(dev, &dbt, dbt_params->data_bittiming_const,
216	ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO;	353	dbt_params->data_bitrate_const,
		354	dbt_params->data_bitrate_const_cnt, extack);
		355	if (err)
		356	return err;
217		357
218	/* make sure static options are provided by configuration */	358	if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
219	if ((maskedflags & ctrlstatic) != ctrlstatic)	359	NL_SET_ERR_MSG_FMT(extack,
220	return -EOPNOTSUPP;	360	"CAN data bitrate %u bps surpasses transceiver capabilities of %u bps",
		361	dbt.bitrate, priv->bitrate_max);
		362	return -EINVAL;
		363	}
221		364
222	/* clear bits to be modified and copy the flag values */	365	memset(&dbt_params->tdc, 0, sizeof(dbt_params->tdc));
223	priv->ctrlmode &= ~cm->mask;	366	if (data[IFLA_CAN_CTRLMODE]) {
224	priv->ctrlmode \|= maskedflags;	367	struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
225		368
226	/* CAN_CTRLMODE_FD can only be set when driver supports FD */	369	need_tdc_calc = !(cm->mask & tdc_mask);
227	if (priv->ctrlmode & CAN_CTRLMODE_FD) {	370	}
228	dev->mtu = CANFD_MTU;	371	if (data_tdc) {
229	} else {	372	/* TDC parameters are provided: use them */
230	dev->mtu = CAN_MTU;	373	err = can_tdc_changelink(dbt_params, data_tdc, extack);
231	memset(&priv->fd.data_bittiming, 0,	374	if (err) {
232	sizeof(priv->fd.data_bittiming));	375	priv->ctrlmode &= ~tdc_mask;
233	priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;	376	return err;
234	memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc));
235	}	377	}
236		378	} else if (need_tdc_calc) {
237	fd_tdc_flag_provided = cm->mask & CAN_CTRLMODE_FD_TDC_MASK;	379	/* Neither of TDC parameters nor TDC flags are provided:
238	/* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually	380	* do calculation
239	* exclusive: make sure to turn the other one off
240	*/	381	*/
241	if (fd_tdc_flag_provided)	382	can_calc_tdco(&dbt_params->tdc, dbt_params->tdc_const, &dbt,
242	priv->ctrlmode &= cm->flags \| ~CAN_CTRLMODE_FD_TDC_MASK;	383	tdc_mask, &priv->ctrlmode, priv->ctrlmode_supported);
		384	} /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly
		385	* turned off. TDC is disabled: do nothing
		386	*/
		387
		388	memcpy(&dbt_params->data_bittiming, &dbt, sizeof(dbt));
		389
		390	if (dbt_params->do_set_data_bittiming) {
		391	/* Finally, set the bit-timing registers */
		392	err = dbt_params->do_set_data_bittiming(dev);
		393	if (err)
		394	return err;
243	}	395	}
244		396
		397	return 0;
		398	}
		399
		400	static int can_changelink(struct net_device dev, struct nlattr tb[],
		401	struct nlattr *data[],
		402	struct netlink_ext_ack *extack)
		403	{
		404	struct can_priv *priv = netdev_priv(dev);
		405	int err;
		406
		407	/* We need synchronization with dev->stop() */
		408	ASSERT_RTNL();
		409
		410	can_ctrlmode_changelink(dev, data, extack);
		411
245	if (data[IFLA_CAN_BITTIMING]) {	412	if (data[IFLA_CAN_BITTIMING]) {
246	struct can_bittiming bt;	413	struct can_bittiming bt;
247		414
@@ -312,75 +479,21 @@ static int can_changelink(struct net_device dev, struct nlattr tb[], · 64 unmodified lines
312	return err;	479	return err;
313	}	480	}
314		481
315	if (data[IFLA_CAN_DATA_BITTIMING]) {	482	/* CAN FD */
316	struct can_bittiming dbt;	483	err = can_dbt_changelink(dev, data, true, extack);
317		484	if (err)
318	/* Do not allow changing bittiming while running */	485	return err;
319	if (dev->flags & IFF_UP)
320	return -EBUSY;
321
322	/* Calculate bittiming parameters based on
323	* data_bittiming_const if set, otherwise pass bitrate
324	* directly via do_set_bitrate(). Bail out if neither
325	* is given.
326	*/
327	if (!priv->fd.data_bittiming_const && !priv->fd.do_set_data_bittiming &&
328	!priv->fd.data_bitrate_const)
329	return -EOPNOTSUPP;
330
331	memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]),
332	sizeof(dbt));
333	err = can_get_bittiming(dev, &dbt,
334	priv->fd.data_bittiming_const,
335	priv->fd.data_bitrate_const,
336	priv->fd.data_bitrate_const_cnt,
337	extack);
338	if (err)
339	return err;
340
341	if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
342	NL_SET_ERR_MSG_FMT(extack,
343	"CANFD data bitrate %u bps surpasses transceiver capabilities of %u bps",
344	dbt.bitrate, priv->bitrate_max);
345	return -EINVAL;
346	}
347
348	memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc));
349	if (data[IFLA_CAN_TDC]) {
350	/* TDC parameters are provided: use them */
351	err = can_tdc_changelink(priv, data[IFLA_CAN_TDC],
352	extack);
353	if (err) {
354	priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
355	return err;
356	}
357	} else if (!fd_tdc_flag_provided) {
358	/* Neither of TDC parameters nor TDC flags are
359	* provided: do calculation
360	*/
361	can_calc_tdco(&priv->fd.tdc, priv->fd.tdc_const, &dbt,
362	&priv->ctrlmode, priv->ctrlmode_supported);
363	} /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly
364	* turned off. TDC is disabled: do nothing
365	*/
366
367	memcpy(&priv->fd.data_bittiming, &dbt, sizeof(dbt));
368
369	if (priv->fd.do_set_data_bittiming) {
370	/* Finally, set the bit-timing registers */
371	err = priv->fd.do_set_data_bittiming(dev);
372	if (err)
373	return err;
374	}
375	}
376		486
377	if (data[IFLA_CAN_TERMINATION]) {	487	if (data[IFLA_CAN_TERMINATION]) {
378	const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]);	488	const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]);
379	const unsigned int num_term = priv->termination_const_cnt;	489	const unsigned int num_term = priv->termination_const_cnt;
380	unsigned int i;	490	unsigned int i;
381		491
382	if (!priv->do_set_termination)	492	if (!priv->do_set_termination) {
		493	NL_SET_ERR_MSG(extack,
		494	"Termination is not configurable on this device");
383	return -EOPNOTSUPP;	495	return -EOPNOTSUPP;
		496	}
384		497
385	/* check whether given value is supported by the interface */	498	/* check whether given value is supported by the interface */
386	for (i = 0; i < num_term; i++) {	499	for (i = 0; i < num_term; i++) {
@@ -401,38 +514,55 @@ static int can_changelink(struct net_device dev, struct nlattr tb[], · 14 unmodified lines
401	return 0;	514	return 0;
402	}	515	}
403		516
404	static size_t can_tdc_get_size(const struct net_device *dev)	517	static size_t can_tdc_get_size(struct data_bittiming_params *dbt_params,
		518	u32 tdc_flags)
405	{	519	{
406	struct can_priv *priv = netdev_priv(dev);	520	bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK;
407	size_t size;	521	size_t size;
408		522
409	if (!priv->fd.tdc_const)	523	if (!dbt_params->tdc_const)
410	return 0;	524	return 0;
411		525
412	size = nla_total_size(0); /* nest IFLA_CAN_TDC */	526	size = nla_total_size(0); /* nest IFLA_CAN_TDC */
413	if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL) {	527	if (tdc_manual) {
414	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MIN */	528	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MIN */
415	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MAX */	529	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MAX */
416	}	530	}
417	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */	531	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */
418	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */	532	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */
419	if (priv->fd.tdc_const->tdcf_max) {	533	if (dbt_params->tdc_const->tdcf_max) {
420	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */	534	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */
421	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */	535	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */
422	}	536	}
423		537
424	if (can_fd_tdc_is_enabled(priv)) {	538	if (tdc_flags) {
425	if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL \|\|	539	if (tdc_manual \|\| dbt_params->do_get_auto_tdcv)
426	priv->fd.do_get_auto_tdcv)
427	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */	540	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */
428	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */	541	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */
429	if (priv->fd.tdc_const->tdcf_max)	542	if (dbt_params->tdc_const->tdcf_max)
430	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */	543	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */
431	}	544	}
432		545
433	return size;	546	return size;
434	}	547	}
435		548
		549	static size_t can_data_bittiming_get_size(struct data_bittiming_params *dbt_params,
		550	u32 tdc_flags)
		551	{
		552	size_t size = 0;
		553
		554	if (dbt_params->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */
		555	size += nla_total_size(sizeof(dbt_params->data_bittiming));
		556	if (dbt_params->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */
		557	size += nla_total_size(sizeof(*dbt_params->data_bittiming_const));
		558	if (dbt_params->data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */
		559	size += nla_total_size(sizeof(dbt_params->data_bitrate_const)
		560	dbt_params->data_bitrate_const_cnt);
		561	size += can_tdc_get_size(dbt_params, tdc_flags);/* IFLA_CAN_TDC */
		562
		563	return size;
		564	}
		565
436	static size_t can_ctrlmode_ext_get_size(void)	566	static size_t can_ctrlmode_ext_get_size(void)
437	{	567	{
438	return nla_total_size(0) + /* nest IFLA_CAN_CTRLMODE_EXT */	568	return nla_total_size(0) + /* nest IFLA_CAN_CTRLMODE_EXT */
@@ -454,10 +584,6 @@ static size_t can_get_size(const struct net_device *dev) · 15 unmodified lines
454	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */	584	size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */
455	if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */	585	if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */
456	size += nla_total_size(sizeof(struct can_berr_counter));	586	size += nla_total_size(sizeof(struct can_berr_counter));
457	if (priv->fd.data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */
458	size += nla_total_size(sizeof(struct can_bittiming));
459	if (priv->fd.data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */
460	size += nla_total_size(sizeof(struct can_bittiming_const));
461	if (priv->termination_const) {	587	if (priv->termination_const) {
462	size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */	588	size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */
463	size += nla_total_size(sizeof(priv->termination_const) /* IFLA_CAN_TERMINATION_CONST */	589	size += nla_total_size(sizeof(priv->termination_const) /* IFLA_CAN_TERMINATION_CONST */
@@ -466,31 +592,69 @@ static size_t can_get_size(const struct net_device *dev) · 2 unmodified lines
466	if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */	592	if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */
467	size += nla_total_size(sizeof(priv->bitrate_const)	593	size += nla_total_size(sizeof(priv->bitrate_const)
468	priv->bitrate_const_cnt);	594	priv->bitrate_const_cnt);
469	if (priv->fd.data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */
470	size += nla_total_size(sizeof(priv->fd.data_bitrate_const)
471	priv->fd.data_bitrate_const_cnt);
472	size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */	595	size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */
473	size += can_tdc_get_size(dev); /* IFLA_CAN_TDC */
474	size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */	596	size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */
475		597
		598	size += can_data_bittiming_get_size(&priv->fd,
		599	priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK);
		600
476	return size;	601	return size;
477	}	602	}
478		603
479	static int can_tdc_fill_info(struct sk_buff skb, const struct net_device dev)	604	static int can_bittiming_fill_info(struct sk_buff *skb, int ifla_can_bittiming,
		605	struct can_bittiming *bittiming)
		606	{
		607	return bittiming->bitrate != CAN_BITRATE_UNSET &&
		608	bittiming->bitrate != CAN_BITRATE_UNKNOWN &&
		609	nla_put(skb, ifla_can_bittiming, sizeof(*bittiming), bittiming);
		610	}
		611
		612	static int can_bittiming_const_fill_info(struct sk_buff *skb,
		613	int ifla_can_bittiming_const,
		614	const struct can_bittiming_const *bittiming_const)
		615	{
		616	return bittiming_const &&
		617	nla_put(skb, ifla_can_bittiming_const,
		618	sizeof(*bittiming_const), bittiming_const);
		619	}
		620
		621	static int can_bitrate_const_fill_info(struct sk_buff *skb,
		622	int ifla_can_bitrate_const,
		623	const u32 *bitrate_const, unsigned int cnt)
		624	{
		625	return bitrate_const &&
		626	nla_put(skb, ifla_can_bitrate_const,
		627	sizeof(bitrate_const) cnt, bitrate_const);
		628	}
		629
		630	static int can_tdc_fill_info(struct sk_buff skb, const struct net_device dev,
		631	int ifla_can_tdc)
480	{	632	{
481	struct nlattr *nest;
482	struct can_priv *priv = netdev_priv(dev);	633	struct can_priv *priv = netdev_priv(dev);
483	struct can_tdc *tdc = &priv->fd.tdc;	634	struct data_bittiming_params *dbt_params;
484	const struct can_tdc_const *tdc_const = priv->fd.tdc_const;	635	const struct can_tdc_const *tdc_const;
		636	struct can_tdc *tdc;
		637	struct nlattr *nest;
		638	bool tdc_is_enabled, tdc_manual;
		639
		640	if (ifla_can_tdc == IFLA_CAN_TDC) {
		641	dbt_params = &priv->fd;
		642	tdc_is_enabled = can_fd_tdc_is_enabled(priv);
		643	tdc_manual = priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL;
		644	} else {
		645	return -EOPNOTSUPP; /* Place holder for CAN XL */
		646	}
		647	tdc_const = dbt_params->tdc_const;
		648	tdc = &dbt_params->tdc;
485		649
486	if (!tdc_const)	650	if (!tdc_const)
487	return 0;	651	return 0;
488		652
489	nest = nla_nest_start(skb, IFLA_CAN_TDC);	653	nest = nla_nest_start(skb, ifla_can_tdc);
490	if (!nest)	654	if (!nest)
491	return -EMSGSIZE;	655	return -EMSGSIZE;
492		656
493	if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL &&	657	if (tdc_manual &&
494	(nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MIN, tdc_const->tdcv_min) \|\|	658	(nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MIN, tdc_const->tdcv_min) \|\|
495	nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MAX, tdc_const->tdcv_max)))	659	nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MAX, tdc_const->tdcv_max)))
496	goto err_cancel;	660	goto err_cancel;
@@ -502,15 +666,15 @@ static int can_tdc_fill_info(struct sk_buff skb, const struct net_device dev) · 5 unmodified lines
502	nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max)))	666	nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max)))
503	goto err_cancel;	667	goto err_cancel;
504		668
505	if (can_fd_tdc_is_enabled(priv)) {	669	if (tdc_is_enabled) {
506	u32 tdcv;	670	u32 tdcv;
507	int err = -EINVAL;	671	int err = -EINVAL;
508		672
509	if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL) {	673	if (tdc_manual) {
510	tdcv = tdc->tdcv;	674	tdcv = tdc->tdcv;
511	err = 0;	675	err = 0;
512	} else if (priv->fd.do_get_auto_tdcv) {	676	} else if (dbt_params->do_get_auto_tdcv) {
513	err = priv->fd.do_get_auto_tdcv(dev, &tdcv);	677	err = dbt_params->do_get_auto_tdcv(dev, &tdcv);
514	}	678	}
515	if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv))	679	if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv))
516	goto err_cancel;	680	goto err_cancel;
@@ -558,14 +722,11 @@ static int can_fill_info(struct sk_buff skb, const struct net_device dev) · 41 unmodified lines
558	if (priv->do_get_state)	722	if (priv->do_get_state)
559	priv->do_get_state(dev, &state);	723	priv->do_get_state(dev, &state);
560		724
561	if ((priv->bittiming.bitrate != CAN_BITRATE_UNSET &&	725	if (can_bittiming_fill_info(skb, IFLA_CAN_BITTIMING,
562	priv->bittiming.bitrate != CAN_BITRATE_UNKNOWN &&	726	&priv->bittiming) \|\|
563	nla_put(skb, IFLA_CAN_BITTIMING,
564	sizeof(priv->bittiming), &priv->bittiming)) \|\|
565		727
566	(priv->bittiming_const &&	728	can_bittiming_const_fill_info(skb, IFLA_CAN_BITTIMING_CONST,
567	nla_put(skb, IFLA_CAN_BITTIMING_CONST,	729	priv->bittiming_const) \|\|
568	sizeof(*priv->bittiming_const), priv->bittiming_const)) \|\|
569		730
570	nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) \|\|	731	nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) \|\|
571	nla_put_u32(skb, IFLA_CAN_STATE, state) \|\|	732	nla_put_u32(skb, IFLA_CAN_STATE, state) \|\|
@@ -576,14 +737,11 @@ static int can_fill_info(struct sk_buff skb, const struct net_device dev) · 4 unmodified lines
576	!priv->do_get_berr_counter(dev, &bec) &&	737	!priv->do_get_berr_counter(dev, &bec) &&
577	nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) \|\|	738	nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) \|\|
578		739
579	(priv->fd.data_bittiming.bitrate &&	740	can_bittiming_fill_info(skb, IFLA_CAN_DATA_BITTIMING,
580	nla_put(skb, IFLA_CAN_DATA_BITTIMING,	741	&priv->fd.data_bittiming) \|\|
581	sizeof(priv->fd.data_bittiming), &priv->fd.data_bittiming)) \|\|
582		742
583	(priv->fd.data_bittiming_const &&	743	can_bittiming_const_fill_info(skb, IFLA_CAN_DATA_BITTIMING_CONST,
584	nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST,	744	priv->fd.data_bittiming_const) \|\|
585	sizeof(*priv->fd.data_bittiming_const),
586	priv->fd.data_bittiming_const)) \|\|
587		745
588	(priv->termination_const &&	746	(priv->termination_const &&
589	(nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) \|\|	747	(nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) \|\|
@@ -592,23 +750,19 @@ static int can_fill_info(struct sk_buff skb, const struct net_device dev) · 2 unmodified lines
592	priv->termination_const_cnt,	750	priv->termination_const_cnt,
593	priv->termination_const))) \|\|	751	priv->termination_const))) \|\|
594		752
595	(priv->bitrate_const &&	753	can_bitrate_const_fill_info(skb, IFLA_CAN_BITRATE_CONST,
596	nla_put(skb, IFLA_CAN_BITRATE_CONST,	754	priv->bitrate_const,
597	sizeof(priv->bitrate_const)	755	priv->bitrate_const_cnt) \|\|
598	priv->bitrate_const_cnt,
599	priv->bitrate_const)) \|\|
600		756
601	(priv->fd.data_bitrate_const &&	757	can_bitrate_const_fill_info(skb, IFLA_CAN_DATA_BITRATE_CONST,
602	nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST,	758	priv->fd.data_bitrate_const,
603	sizeof(priv->fd.data_bitrate_const)	759	priv->fd.data_bitrate_const_cnt) \|\|
604	priv->fd.data_bitrate_const_cnt,
605	priv->fd.data_bitrate_const)) \|\|
606		760
607	(nla_put(skb, IFLA_CAN_BITRATE_MAX,	761	(nla_put(skb, IFLA_CAN_BITRATE_MAX,
608	sizeof(priv->bitrate_max),	762	sizeof(priv->bitrate_max),
609	&priv->bitrate_max)) \|\|	763	&priv->bitrate_max)) \|\|
610		764
611	can_tdc_fill_info(skb, dev) \|\|	765	can_tdc_fill_info(skb, dev, IFLA_CAN_TDC) \|\|
612		766
613	can_ctrlmode_ext_fill_info(skb, priv)	767	can_ctrlmode_ext_fill_info(skb, priv)
614	)	768	)

drivers/net/can/m_can/m_can.c+2−4

 	cdev->tx_coalesce_usecs_irq = ec->tx_coalesce_usecs_irq;
 	if (cdev->rx_coalesce_usecs_irq)
-		cdev->irq_timer_wait =
+		cdev->irq_timer_wait = us_to_ktime(cdev->rx_coalesce_usecs_irq);
-			ns_to_ktime(cdev->rx_coalesce_usecs_irq * NSEC_PER_USEC);
 	else
-		cdev->irq_timer_wait =
+		cdev->irq_timer_wait = us_to_ktime(cdev->tx_coalesce_usecs_irq);
-			ns_to_ktime(cdev->tx_coalesce_usecs_irq * NSEC_PER_USEC);
 	return 0;
 }

drivers/net/can/peak_canfd/peak_canfd.c+2−2

 // SPDX-License-Identifier: GPL-2.0-only
 /* Copyright (C) 2007, 2011 Wolfgang Grandegger <wg@grandegger.com>
- * Copyright (C) 2012 Stephane Grosjean <s.grosjean@peak-system.com>
  *
- * Copyright (C) 2016  PEAK System-Technik GmbH
+ * Copyright (C) 2016-2025 PEAK System-Technik GmbH
+ * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
  */
 #include <linux/can.h>

drivers/net/can/peak_canfd/peak_canfd_user.h+2−2

@@ -1,8 +1,8 @@
1	/* SPDX-License-Identifier: GPL-2.0-only */	1	/* SPDX-License-Identifier: GPL-2.0-only */
2	/* CAN driver for PEAK System micro-CAN based adapters	2	/* CAN driver for PEAK System micro-CAN based adapters
3	*	3	*
4	* Copyright (C) 2003-2011 PEAK System-Technik GmbH	4	* Copyright (C) 2003-2025 PEAK System-Technik GmbH
5	* Copyright (C) 2011-2013 Stephane Grosjean <s.grosjean@peak-system.com>	5	* Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
6	*/	6	*/
7	#ifndef PEAK_CANFD_USER_H	7	#ifndef PEAK_CANFD_USER_H
8	#define PEAK_CANFD_USER_H	8	#define PEAK_CANFD_USER_H

drivers/net/can/peak_canfd/peak_pciefd_main.c+3−3

 // SPDX-License-Identifier: GPL-2.0-only
 /* Copyright (C) 2007, 2011 Wolfgang Grandegger <wg@grandegger.com>
- * Copyright (C) 2012 Stephane Grosjean <s.grosjean@peak-system.com>
  *
  * Derived from the PCAN project file driver/src/pcan_pci.c:
  *
- * Copyright (C) 2001-2006  PEAK System-Technik GmbH
+ * Copyright (C) 2001-2025 PEAK System-Technik GmbH
+ * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
  */
 #include <linux/kernel.h>
 #include "peak_canfd_user.h"
-MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
+MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>");
 MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCIe/M.2 FD family cards");
 MODULE_LICENSE("GPL v2");

drivers/net/can/rcar/rcar_can.c+149−143

@@ -5,6 +5,8 @@ · 4 unmodified lines
5	* Copyright (C) 2013 Renesas Solutions Corp.	5	* Copyright (C) 2013 Renesas Solutions Corp.
6	*/	6	*/
7		7
		8	#include <linux/bitfield.h>
		9	#include <linux/bits.h>
8	#include <linux/module.h>	10	#include <linux/module.h>
9	#include <linux/kernel.h>	11	#include <linux/kernel.h>
10	#include <linux/types.h>	12	#include <linux/types.h>
@@ -16,6 +18,7 @@ · 5 unmodified lines
16	#include <linux/can/dev.h>	18	#include <linux/can/dev.h>
17	#include <linux/clk.h>	19	#include <linux/clk.h>
18	#include <linux/of.h>	20	#include <linux/of.h>
		21	#include <linux/pm_runtime.h>
19		22
20	#define RCAR_CAN_DRV_NAME "rcar_can"	23	#define RCAR_CAN_DRV_NAME "rcar_can"
21		24
@@ -92,7 +95,6 @@ struct rcar_can_priv { · 70 unmodified lines
92	struct net_device *ndev;	95	struct net_device *ndev;
93	struct napi_struct napi;	96	struct napi_struct napi;
94	struct rcar_can_regs __iomem *regs;	97	struct rcar_can_regs __iomem *regs;
95	struct clk *clk;
96	struct clk *can_clk;	98	struct clk *can_clk;
97	u32 tx_head;	99	u32 tx_head;
98	u32 tx_tail;	100	u32 tx_tail;
@@ -113,100 +115,102 @@ static const struct can_bittiming_const rcar_can_bittiming_const = { · 14 unmodified lines
113	};	115	};
114		116
115	/* Control Register bits */	117	/* Control Register bits */
116	#define RCAR_CAN_CTLR_BOM (3 << 11) /* Bus-Off Recovery Mode Bits */	118	#define RCAR_CAN_CTLR_BOM GENMASK(12, 11) /* Bus-Off Recovery Mode Bits */
117	#define RCAR_CAN_CTLR_BOM_ENT (1 << 11) /* Entry to halt mode */	119	#define RCAR_CAN_CTLR_BOM_ENT 1 /* Entry to halt mode */
118	/* at bus-off entry */	120	/* at bus-off entry */
119	#define RCAR_CAN_CTLR_SLPM (1 << 10)	121	#define RCAR_CAN_CTLR_SLPM BIT(10) /* Sleep Mode */
120	#define RCAR_CAN_CTLR_CANM (3 << 8) /* Operating Mode Select Bit */	122	#define RCAR_CAN_CTLR_CANM GENMASK(9, 8) /* Operating Mode Select Bit */
121	#define RCAR_CAN_CTLR_CANM_HALT (1 << 9)	123	#define RCAR_CAN_CTLR_CANM_OPER 0 /* Operation Mode */
122	#define RCAR_CAN_CTLR_CANM_RESET (1 << 8)	124	#define RCAR_CAN_CTLR_CANM_RESET 1 /* Reset Mode */
123	#define RCAR_CAN_CTLR_CANM_FORCE_RESET (3 << 8)	125	#define RCAR_CAN_CTLR_CANM_HALT 2 /* Halt Mode */
124	#define RCAR_CAN_CTLR_MLM (1 << 3) /* Message Lost Mode Select */	126	#define RCAR_CAN_CTLR_CANM_FORCE_RESET 3 /* Reset Mode (forcible) */
125	#define RCAR_CAN_CTLR_IDFM (3 << 1) /* ID Format Mode Select Bits */	127	#define RCAR_CAN_CTLR_MLM BIT(3) /* Message Lost Mode Select */
126	#define RCAR_CAN_CTLR_IDFM_MIXED (1 << 2) /* Mixed ID mode */	128	#define RCAR_CAN_CTLR_IDFM GENMASK(2, 1) /* ID Format Mode Select Bits */
127	#define RCAR_CAN_CTLR_MBM (1 << 0) /* Mailbox Mode select */	129	#define RCAR_CAN_CTLR_IDFM_STD 0 /* Standard ID mode */
		130	#define RCAR_CAN_CTLR_IDFM_EXT 1 /* Extended ID mode */
		131	#define RCAR_CAN_CTLR_IDFM_MIXED 2 /* Mixed ID mode */
		132	#define RCAR_CAN_CTLR_MBM BIT(0) /* Mailbox Mode select */
128		133
129	/* Status Register bits */	134	/* Status Register bits */
130	#define RCAR_CAN_STR_RSTST (1 << 8) /* Reset Status Bit */	135	#define RCAR_CAN_STR_RSTST BIT(8) /* Reset Status Bit */
131		136
132	/* FIFO Received ID Compare Registers 0 and 1 bits */	137	/* FIFO Received ID Compare Registers 0 and 1 bits */
133	#define RCAR_CAN_FIDCR_IDE (1 << 31) /* ID Extension Bit */	138	#define RCAR_CAN_FIDCR_IDE BIT(31) /* ID Extension Bit */
134	#define RCAR_CAN_FIDCR_RTR (1 << 30) /* Remote Transmission Request Bit */	139	#define RCAR_CAN_FIDCR_RTR BIT(30) /* Remote Transmission Request Bit */
135		140
136	/* Receive FIFO Control Register bits */	141	/* Receive FIFO Control Register bits */
137	#define RCAR_CAN_RFCR_RFEST (1 << 7) /* Receive FIFO Empty Status Flag */	142	#define RCAR_CAN_RFCR_RFEST BIT(7) /* Receive FIFO Empty Status Flag */
138	#define RCAR_CAN_RFCR_RFE (1 << 0) /* Receive FIFO Enable */	143	#define RCAR_CAN_RFCR_RFE BIT(0) /* Receive FIFO Enable */
139		144
140	/* Transmit FIFO Control Register bits */	145	/* Transmit FIFO Control Register bits */
141	#define RCAR_CAN_TFCR_TFUST (7 << 1) /* Transmit FIFO Unsent Message */	146	#define RCAR_CAN_TFCR_TFUST GENMASK(3, 1) /* Transmit FIFO Unsent Message */
142	/* Number Status Bits */	147	/* Number Status Bits */
143	#define RCAR_CAN_TFCR_TFUST_SHIFT 1 /* Offset of Transmit FIFO Unsent */	148	#define RCAR_CAN_TFCR_TFE BIT(0) /* Transmit FIFO Enable */
144	/* Message Number Status Bits */	149
145	#define RCAR_CAN_TFCR_TFE (1 << 0) /* Transmit FIFO Enable */	150	#define RCAR_CAN_N_RX_MKREGS1 2 /* Number of mask registers */
146		151	/* for Rx mailboxes 0-31 */
147	#define RCAR_CAN_N_RX_MKREGS1 2 /* Number of mask registers */
148	/* for Rx mailboxes 0-31 */
149	#define RCAR_CAN_N_RX_MKREGS2 8	152	#define RCAR_CAN_N_RX_MKREGS2 8
150		153
151	/* Bit Configuration Register settings */	154	/* Bit Configuration Register settings */
152	#define RCAR_CAN_BCR_TSEG1(x) (((x) & 0x0f) << 20)	155	#define RCAR_CAN_BCR_TSEG1 GENMASK(23, 20)
153	#define RCAR_CAN_BCR_BPR(x) (((x) & 0x3ff) << 8)	156	#define RCAR_CAN_BCR_BRP GENMASK(17, 8)
154	#define RCAR_CAN_BCR_SJW(x) (((x) & 0x3) << 4)	157	#define RCAR_CAN_BCR_SJW GENMASK(5, 4)
155	#define RCAR_CAN_BCR_TSEG2(x) ((x) & 0x07)	158	#define RCAR_CAN_BCR_TSEG2 GENMASK(2, 0)
156		159
157	/* Mailbox and Mask Registers bits */	160	/* Mailbox and Mask Registers bits */
158	#define RCAR_CAN_IDE (1 << 31)	161	#define RCAR_CAN_IDE BIT(31) /* ID Extension */
159	#define RCAR_CAN_RTR (1 << 30)	162	#define RCAR_CAN_RTR BIT(30) /* Remote Transmission Request */
160	#define RCAR_CAN_SID_SHIFT 18	163	#define RCAR_CAN_SID GENMASK(28, 18) /* Standard ID */
		164	#define RCAR_CAN_EID GENMASK(28, 0) /* Extended ID */
161		165
162	/* Mailbox Interrupt Enable Register 1 bits */	166	/* Mailbox Interrupt Enable Register 1 bits */
163	#define RCAR_CAN_MIER1_RXFIE (1 << 28) /* Receive FIFO Interrupt Enable */	167	#define RCAR_CAN_MIER1_RXFIE BIT(28) /* Receive FIFO Interrupt Enable */
164	#define RCAR_CAN_MIER1_TXFIE (1 << 24) /* Transmit FIFO Interrupt Enable */	168	#define RCAR_CAN_MIER1_TXFIE BIT(24) /* Transmit FIFO Interrupt Enable */
165		169
166	/* Interrupt Enable Register bits */	170	/* Interrupt Enable Register bits */
167	#define RCAR_CAN_IER_ERSIE (1 << 5) /* Error (ERS) Interrupt Enable Bit */	171	#define RCAR_CAN_IER_ERSIE BIT(5) /* Error (ERS) Interrupt Enable Bit */
168	#define RCAR_CAN_IER_RXFIE (1 << 4) /* Reception FIFO Interrupt */	172	#define RCAR_CAN_IER_RXFIE BIT(4) /* Reception FIFO Interrupt */
169	/* Enable Bit */	173	/* Enable Bit */
170	#define RCAR_CAN_IER_TXFIE (1 << 3) /* Transmission FIFO Interrupt */	174	#define RCAR_CAN_IER_TXFIE BIT(3) /* Transmission FIFO Interrupt */
171	/* Enable Bit */	175	/* Enable Bit */
172	/* Interrupt Status Register bits */	176	/* Interrupt Status Register bits */
173	#define RCAR_CAN_ISR_ERSF (1 << 5) /* Error (ERS) Interrupt Status Bit */	177	#define RCAR_CAN_ISR_ERSF BIT(5) /* Error (ERS) Interrupt Status Bit */
174	#define RCAR_CAN_ISR_RXFF (1 << 4) /* Reception FIFO Interrupt */	178	#define RCAR_CAN_ISR_RXFF BIT(4) /* Reception FIFO Interrupt */
175	/* Status Bit */	179	/* Status Bit */
176	#define RCAR_CAN_ISR_TXFF (1 << 3) /* Transmission FIFO Interrupt */	180	#define RCAR_CAN_ISR_TXFF BIT(3) /* Transmission FIFO Interrupt */
177	/* Status Bit */	181	/* Status Bit */
178		182
179	/* Error Interrupt Enable Register bits */	183	/* Error Interrupt Enable Register bits */
180	#define RCAR_CAN_EIER_BLIE (1 << 7) /* Bus Lock Interrupt Enable */	184	#define RCAR_CAN_EIER_BLIE BIT(7) /* Bus Lock Interrupt Enable */
181	#define RCAR_CAN_EIER_OLIE (1 << 6) /* Overload Frame Transmit */	185	#define RCAR_CAN_EIER_OLIE BIT(6) /* Overload Frame Transmit */
182	/* Interrupt Enable */	186	/* Interrupt Enable */
183	#define RCAR_CAN_EIER_ORIE (1 << 5) /* Receive Overrun Interrupt Enable */	187	#define RCAR_CAN_EIER_ORIE BIT(5) /* Receive Overrun Interrupt Enable */
184	#define RCAR_CAN_EIER_BORIE (1 << 4) /* Bus-Off Recovery Interrupt Enable */	188	#define RCAR_CAN_EIER_BORIE BIT(4) /* Bus-Off Recovery Interrupt Enable */
185	#define RCAR_CAN_EIER_BOEIE (1 << 3) /* Bus-Off Entry Interrupt Enable */	189	#define RCAR_CAN_EIER_BOEIE BIT(3) /* Bus-Off Entry Interrupt Enable */
186	#define RCAR_CAN_EIER_EPIE (1 << 2) /* Error Passive Interrupt Enable */	190	#define RCAR_CAN_EIER_EPIE BIT(2) /* Error Passive Interrupt Enable */
187	#define RCAR_CAN_EIER_EWIE (1 << 1) /* Error Warning Interrupt Enable */	191	#define RCAR_CAN_EIER_EWIE BIT(1) /* Error Warning Interrupt Enable */
188	#define RCAR_CAN_EIER_BEIE (1 << 0) /* Bus Error Interrupt Enable */	192	#define RCAR_CAN_EIER_BEIE BIT(0) /* Bus Error Interrupt Enable */
189		193
190	/* Error Interrupt Factor Judge Register bits */	194	/* Error Interrupt Factor Judge Register bits */
191	#define RCAR_CAN_EIFR_BLIF (1 << 7) /* Bus Lock Detect Flag */	195	#define RCAR_CAN_EIFR_BLIF BIT(7) /* Bus Lock Detect Flag */
192	#define RCAR_CAN_EIFR_OLIF (1 << 6) /* Overload Frame Transmission */	196	#define RCAR_CAN_EIFR_OLIF BIT(6) /* Overload Frame Transmission */
193	/* Detect Flag */	197	/* Detect Flag */
194	#define RCAR_CAN_EIFR_ORIF (1 << 5) /* Receive Overrun Detect Flag */	198	#define RCAR_CAN_EIFR_ORIF BIT(5) /* Receive Overrun Detect Flag */
195	#define RCAR_CAN_EIFR_BORIF (1 << 4) /* Bus-Off Recovery Detect Flag */	199	#define RCAR_CAN_EIFR_BORIF BIT(4) /* Bus-Off Recovery Detect Flag */
196	#define RCAR_CAN_EIFR_BOEIF (1 << 3) /* Bus-Off Entry Detect Flag */	200	#define RCAR_CAN_EIFR_BOEIF BIT(3) /* Bus-Off Entry Detect Flag */
197	#define RCAR_CAN_EIFR_EPIF (1 << 2) /* Error Passive Detect Flag */	201	#define RCAR_CAN_EIFR_EPIF BIT(2) /* Error Passive Detect Flag */
198	#define RCAR_CAN_EIFR_EWIF (1 << 1) /* Error Warning Detect Flag */	202	#define RCAR_CAN_EIFR_EWIF BIT(1) /* Error Warning Detect Flag */
199	#define RCAR_CAN_EIFR_BEIF (1 << 0) /* Bus Error Detect Flag */	203	#define RCAR_CAN_EIFR_BEIF BIT(0) /* Bus Error Detect Flag */
200		204
201	/* Error Code Store Register bits */	205	/* Error Code Store Register bits */
202	#define RCAR_CAN_ECSR_EDPM (1 << 7) /* Error Display Mode Select Bit */	206	#define RCAR_CAN_ECSR_EDPM BIT(7) /* Error Display Mode Select Bit */
203	#define RCAR_CAN_ECSR_ADEF (1 << 6) /* ACK Delimiter Error Flag */	207	#define RCAR_CAN_ECSR_ADEF BIT(6) /* ACK Delimiter Error Flag */
204	#define RCAR_CAN_ECSR_BE0F (1 << 5) /* Bit Error (dominant) Flag */	208	#define RCAR_CAN_ECSR_BE0F BIT(5) /* Bit Error (dominant) Flag */
205	#define RCAR_CAN_ECSR_BE1F (1 << 4) /* Bit Error (recessive) Flag */	209	#define RCAR_CAN_ECSR_BE1F BIT(4) /* Bit Error (recessive) Flag */
206	#define RCAR_CAN_ECSR_CEF (1 << 3) /* CRC Error Flag */	210	#define RCAR_CAN_ECSR_CEF BIT(3) /* CRC Error Flag */
207	#define RCAR_CAN_ECSR_AEF (1 << 2) /* ACK Error Flag */	211	#define RCAR_CAN_ECSR_AEF BIT(2) /* ACK Error Flag */
208	#define RCAR_CAN_ECSR_FEF (1 << 1) /* Form Error Flag */	212	#define RCAR_CAN_ECSR_FEF BIT(1) /* Form Error Flag */
209	#define RCAR_CAN_ECSR_SEF (1 << 0) /* Stuff Error Flag */	213	#define RCAR_CAN_ECSR_SEF BIT(0) /* Stuff Error Flag */
210		214
211	#define RCAR_CAN_NAPI_WEIGHT 4	215	#define RCAR_CAN_NAPI_WEIGHT 4
212	#define MAX_STR_READS 0x100	216	#define MAX_STR_READS 0x100
@@ -248,35 +252,35 @@ static void rcar_can_error(struct net_device *ndev) · 35 unmodified lines
248	if (ecsr & RCAR_CAN_ECSR_ADEF) {	252	if (ecsr & RCAR_CAN_ECSR_ADEF) {
249	netdev_dbg(priv->ndev, "ACK Delimiter Error\n");	253	netdev_dbg(priv->ndev, "ACK Delimiter Error\n");
250	tx_errors++;	254	tx_errors++;
251	writeb(~RCAR_CAN_ECSR_ADEF, &priv->regs->ecsr);	255	writeb((u8)~RCAR_CAN_ECSR_ADEF, &priv->regs->ecsr);
252	if (skb)	256	if (skb)
253	cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL;	257	cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL;
254	}	258	}
255	if (ecsr & RCAR_CAN_ECSR_BE0F) {	259	if (ecsr & RCAR_CAN_ECSR_BE0F) {
256	netdev_dbg(priv->ndev, "Bit Error (dominant)\n");	260	netdev_dbg(priv->ndev, "Bit Error (dominant)\n");
257	tx_errors++;	261	tx_errors++;
258	writeb(~RCAR_CAN_ECSR_BE0F, &priv->regs->ecsr);	262	writeb((u8)~RCAR_CAN_ECSR_BE0F, &priv->regs->ecsr);
259	if (skb)	263	if (skb)
260	cf->data[2] \|= CAN_ERR_PROT_BIT0;	264	cf->data[2] \|= CAN_ERR_PROT_BIT0;
261	}	265	}
262	if (ecsr & RCAR_CAN_ECSR_BE1F) {	266	if (ecsr & RCAR_CAN_ECSR_BE1F) {
263	netdev_dbg(priv->ndev, "Bit Error (recessive)\n");	267	netdev_dbg(priv->ndev, "Bit Error (recessive)\n");
264	tx_errors++;	268	tx_errors++;
265	writeb(~RCAR_CAN_ECSR_BE1F, &priv->regs->ecsr);	269	writeb((u8)~RCAR_CAN_ECSR_BE1F, &priv->regs->ecsr);
266	if (skb)	270	if (skb)
267	cf->data[2] \|= CAN_ERR_PROT_BIT1;	271	cf->data[2] \|= CAN_ERR_PROT_BIT1;
268	}	272	}
269	if (ecsr & RCAR_CAN_ECSR_CEF) {	273	if (ecsr & RCAR_CAN_ECSR_CEF) {
270	netdev_dbg(priv->ndev, "CRC Error\n");	274	netdev_dbg(priv->ndev, "CRC Error\n");
271	rx_errors++;	275	rx_errors++;
272	writeb(~RCAR_CAN_ECSR_CEF, &priv->regs->ecsr);	276	writeb((u8)~RCAR_CAN_ECSR_CEF, &priv->regs->ecsr);
273	if (skb)	277	if (skb)
274	cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;	278	cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
275	}	279	}
276	if (ecsr & RCAR_CAN_ECSR_AEF) {	280	if (ecsr & RCAR_CAN_ECSR_AEF) {
277	netdev_dbg(priv->ndev, "ACK Error\n");	281	netdev_dbg(priv->ndev, "ACK Error\n");
278	tx_errors++;	282	tx_errors++;
279	writeb(~RCAR_CAN_ECSR_AEF, &priv->regs->ecsr);	283	writeb((u8)~RCAR_CAN_ECSR_AEF, &priv->regs->ecsr);
280	if (skb) {	284	if (skb) {
281	cf->can_id \|= CAN_ERR_ACK;	285	cf->can_id \|= CAN_ERR_ACK;
282	cf->data[3] = CAN_ERR_PROT_LOC_ACK;	286	cf->data[3] = CAN_ERR_PROT_LOC_ACK;
@@ -285,14 +289,14 @@ static void rcar_can_error(struct net_device *ndev) · 2 unmodified lines
285	if (ecsr & RCAR_CAN_ECSR_FEF) {	289	if (ecsr & RCAR_CAN_ECSR_FEF) {
286	netdev_dbg(priv->ndev, "Form Error\n");	290	netdev_dbg(priv->ndev, "Form Error\n");
287	rx_errors++;	291	rx_errors++;
288	writeb(~RCAR_CAN_ECSR_FEF, &priv->regs->ecsr);	292	writeb((u8)~RCAR_CAN_ECSR_FEF, &priv->regs->ecsr);
289	if (skb)	293	if (skb)
290	cf->data[2] \|= CAN_ERR_PROT_FORM;	294	cf->data[2] \|= CAN_ERR_PROT_FORM;
291	}	295	}
292	if (ecsr & RCAR_CAN_ECSR_SEF) {	296	if (ecsr & RCAR_CAN_ECSR_SEF) {
293	netdev_dbg(priv->ndev, "Stuff Error\n");	297	netdev_dbg(priv->ndev, "Stuff Error\n");
294	rx_errors++;	298	rx_errors++;
295	writeb(~RCAR_CAN_ECSR_SEF, &priv->regs->ecsr);	299	writeb((u8)~RCAR_CAN_ECSR_SEF, &priv->regs->ecsr);
296	if (skb)	300	if (skb)
297	cf->data[2] \|= CAN_ERR_PROT_STUFF;	301	cf->data[2] \|= CAN_ERR_PROT_STUFF;
298	}	302	}
@@ -300,14 +304,14 @@ static void rcar_can_error(struct net_device *ndev) · 1 unmodified line
300	priv->can.can_stats.bus_error++;	304	priv->can.can_stats.bus_error++;
301	ndev->stats.rx_errors += rx_errors;	305	ndev->stats.rx_errors += rx_errors;
302	ndev->stats.tx_errors += tx_errors;	306	ndev->stats.tx_errors += tx_errors;
303	writeb(~RCAR_CAN_EIFR_BEIF, &priv->regs->eifr);	307	writeb((u8)~RCAR_CAN_EIFR_BEIF, &priv->regs->eifr);
304	}	308	}
305	if (eifr & RCAR_CAN_EIFR_EWIF) {	309	if (eifr & RCAR_CAN_EIFR_EWIF) {
306	netdev_dbg(priv->ndev, "Error warning interrupt\n");	310	netdev_dbg(priv->ndev, "Error warning interrupt\n");
307	priv->can.state = CAN_STATE_ERROR_WARNING;	311	priv->can.state = CAN_STATE_ERROR_WARNING;
308	priv->can.can_stats.error_warning++;	312	priv->can.can_stats.error_warning++;
309	/* Clear interrupt condition */	313	/* Clear interrupt condition */
310	writeb(~RCAR_CAN_EIFR_EWIF, &priv->regs->eifr);	314	writeb((u8)~RCAR_CAN_EIFR_EWIF, &priv->regs->eifr);
311	if (skb)	315	if (skb)
312	cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_WARNING :	316	cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_WARNING :
313	CAN_ERR_CRTL_RX_WARNING;	317	CAN_ERR_CRTL_RX_WARNING;
@@ -317,7 +321,7 @@ static void rcar_can_error(struct net_device *ndev) · 3 unmodified lines
317	priv->can.state = CAN_STATE_ERROR_PASSIVE;	321	priv->can.state = CAN_STATE_ERROR_PASSIVE;
318	priv->can.can_stats.error_passive++;	322	priv->can.can_stats.error_passive++;
319	/* Clear interrupt condition */	323	/* Clear interrupt condition */
320	writeb(~RCAR_CAN_EIFR_EPIF, &priv->regs->eifr);	324	writeb((u8)~RCAR_CAN_EIFR_EPIF, &priv->regs->eifr);
321	if (skb)	325	if (skb)
322	cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_PASSIVE :	326	cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_PASSIVE :
323	CAN_ERR_CRTL_RX_PASSIVE;	327	CAN_ERR_CRTL_RX_PASSIVE;
@@ -329,7 +333,7 @@ static void rcar_can_error(struct net_device *ndev) · 5 unmodified lines
329	writeb(priv->ier, &priv->regs->ier);	333	writeb(priv->ier, &priv->regs->ier);
330	priv->can.state = CAN_STATE_BUS_OFF;	334	priv->can.state = CAN_STATE_BUS_OFF;
331	/* Clear interrupt condition */	335	/* Clear interrupt condition */
332	writeb(~RCAR_CAN_EIFR_BOEIF, &priv->regs->eifr);	336	writeb((u8)~RCAR_CAN_EIFR_BOEIF, &priv->regs->eifr);
333	priv->can.can_stats.bus_off++;	337	priv->can.can_stats.bus_off++;
334	can_bus_off(ndev);	338	can_bus_off(ndev);
335	if (skb)	339	if (skb)
@@ -343,7 +347,7 @@ static void rcar_can_error(struct net_device *ndev) · 7 unmodified lines
343	netdev_dbg(priv->ndev, "Receive overrun error interrupt\n");	347	netdev_dbg(priv->ndev, "Receive overrun error interrupt\n");
344	ndev->stats.rx_over_errors++;	348	ndev->stats.rx_over_errors++;
345	ndev->stats.rx_errors++;	349	ndev->stats.rx_errors++;
346	writeb(~RCAR_CAN_EIFR_ORIF, &priv->regs->eifr);	350	writeb((u8)~RCAR_CAN_EIFR_ORIF, &priv->regs->eifr);
347	if (skb) {	351	if (skb) {
348	cf->can_id \|= CAN_ERR_CRTL;	352	cf->can_id \|= CAN_ERR_CRTL;
349	cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;	353	cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
@@ -354,7 +358,7 @@ static void rcar_can_error(struct net_device *ndev) · 4 unmodified lines
354	"Overload Frame Transmission error interrupt\n");	358	"Overload Frame Transmission error interrupt\n");
355	ndev->stats.rx_over_errors++;	359	ndev->stats.rx_over_errors++;
356	ndev->stats.rx_errors++;	360	ndev->stats.rx_errors++;
357	writeb(~RCAR_CAN_EIFR_OLIF, &priv->regs->eifr);	361	writeb((u8)~RCAR_CAN_EIFR_OLIF, &priv->regs->eifr);
358	if (skb) {	362	if (skb) {
359	cf->can_id \|= CAN_ERR_PROT;	363	cf->can_id \|= CAN_ERR_PROT;
360	cf->data[2] \|= CAN_ERR_PROT_OVERLOAD;	364	cf->data[2] \|= CAN_ERR_PROT_OVERLOAD;
@@ -372,10 +376,9 @@ static void rcar_can_tx_done(struct net_device *ndev) · 11 unmodified lines
372	u8 isr;	376	u8 isr;
373		377
374	while (1) {	378	while (1) {
375	u8 unsent = readb(&priv->regs->tfcr);	379	u8 unsent = FIELD_GET(RCAR_CAN_TFCR_TFUST,
		380	readb(&priv->regs->tfcr));
376		381
377	unsent = (unsent & RCAR_CAN_TFCR_TFUST) >>
378	RCAR_CAN_TFCR_TFUST_SHIFT;
379	if (priv->tx_head - priv->tx_tail <= unsent)	382	if (priv->tx_head - priv->tx_tail <= unsent)
380	break;	383	break;
381	stats->tx_packets++;	384	stats->tx_packets++;
@@ -420,15 +423,16 @@ static irqreturn_t rcar_can_interrupt(int irq, void *dev_id) · 38 unmodified lines
420	return IRQ_HANDLED;	423	return IRQ_HANDLED;
421	}	424	}
422		425
423	static void rcar_can_set_bittiming(struct net_device *dev)	426	static void rcar_can_set_bittiming(struct net_device *ndev)
424	{	427	{
425	struct rcar_can_priv *priv = netdev_priv(dev);	428	struct rcar_can_priv *priv = netdev_priv(ndev);
426	struct can_bittiming *bt = &priv->can.bittiming;	429	struct can_bittiming *bt = &priv->can.bittiming;
427	u32 bcr;	430	u32 bcr;
428		431
429	bcr = RCAR_CAN_BCR_TSEG1(bt->phase_seg1 + bt->prop_seg - 1) \|	432	bcr = FIELD_PREP(RCAR_CAN_BCR_TSEG1, bt->phase_seg1 + bt->prop_seg - 1) \|
430	RCAR_CAN_BCR_BPR(bt->brp - 1) \| RCAR_CAN_BCR_SJW(bt->sjw - 1) \|	433	FIELD_PREP(RCAR_CAN_BCR_BRP, bt->brp - 1) \|
431	RCAR_CAN_BCR_TSEG2(bt->phase_seg2 - 1);	434	FIELD_PREP(RCAR_CAN_BCR_SJW, bt->sjw - 1) \|
		435	FIELD_PREP(RCAR_CAN_BCR_TSEG2, bt->phase_seg2 - 1);
432	/* Don't overwrite CLKR with 32-bit BCR access; CLKR has 8-bit access.	436	/* Don't overwrite CLKR with 32-bit BCR access; CLKR has 8-bit access.
433	* All the registers are big-endian but they get byte-swapped on 32-bit	437	* All the registers are big-endian but they get byte-swapped on 32-bit
434	* read/write (but not on 8-bit, contrary to the manuals)...	438	* read/write (but not on 8-bit, contrary to the manuals)...
@@ -452,16 +456,17 @@ static void rcar_can_start(struct net_device *ndev) · 17 unmodified lines
452	ctlr &= ~RCAR_CAN_CTLR_SLPM;	456	ctlr &= ~RCAR_CAN_CTLR_SLPM;
453	writew(ctlr, &priv->regs->ctlr);	457	writew(ctlr, &priv->regs->ctlr);
454	/* Go to reset mode */	458	/* Go to reset mode */
455	ctlr \|= RCAR_CAN_CTLR_CANM_FORCE_RESET;	459	ctlr \|= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_FORCE_RESET);
456	writew(ctlr, &priv->regs->ctlr);	460	writew(ctlr, &priv->regs->ctlr);
457	for (i = 0; i < MAX_STR_READS; i++) {	461	for (i = 0; i < MAX_STR_READS; i++) {
458	if (readw(&priv->regs->str) & RCAR_CAN_STR_RSTST)	462	if (readw(&priv->regs->str) & RCAR_CAN_STR_RSTST)
459	break;	463	break;
460	}	464	}
461	rcar_can_set_bittiming(ndev);	465	rcar_can_set_bittiming(ndev);
462	ctlr \|= RCAR_CAN_CTLR_IDFM_MIXED; /* Select mixed ID mode */	466	/* Select mixed ID mode */
463	ctlr \|= RCAR_CAN_CTLR_BOM_ENT; /* Entry to halt mode automatically */	467	ctlr \|= FIELD_PREP(RCAR_CAN_CTLR_IDFM, RCAR_CAN_CTLR_IDFM_MIXED);
464	/* at bus-off */	468	/* Entry to halt mode automatically at bus-off */
		469	ctlr \|= FIELD_PREP(RCAR_CAN_CTLR_BOM, RCAR_CAN_CTLR_BOM_ENT);
465	ctlr \|= RCAR_CAN_CTLR_MBM; /* Select FIFO mailbox mode */	470	ctlr \|= RCAR_CAN_CTLR_MBM; /* Select FIFO mailbox mode */
466	ctlr \|= RCAR_CAN_CTLR_MLM; /* Overrun mode */	471	ctlr \|= RCAR_CAN_CTLR_MLM; /* Overrun mode */
467	writew(ctlr, &priv->regs->ctlr);	472	writew(ctlr, &priv->regs->ctlr);
@@ -491,7 +496,9 @@ static void rcar_can_start(struct net_device *ndev) · 23 unmodified lines
491	priv->can.state = CAN_STATE_ERROR_ACTIVE;	496	priv->can.state = CAN_STATE_ERROR_ACTIVE;
492		497
493	/* Go to operation mode */	498	/* Go to operation mode */
494	writew(ctlr & ~RCAR_CAN_CTLR_CANM, &priv->regs->ctlr);	499	ctlr &= ~RCAR_CAN_CTLR_CANM;
		500	ctlr \|= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_OPER);
		501	writew(ctlr, &priv->regs->ctlr);
495	for (i = 0; i < MAX_STR_READS; i++) {	502	for (i = 0; i < MAX_STR_READS; i++) {
496	if (!(readw(&priv->regs->str) & RCAR_CAN_STR_RSTST))	503	if (!(readw(&priv->regs->str) & RCAR_CAN_STR_RSTST))
497	break;	504	break;
@@ -506,29 +513,28 @@ static int rcar_can_open(struct net_device *ndev) · 8 unmodified lines
506	struct rcar_can_priv *priv = netdev_priv(ndev);	513	struct rcar_can_priv *priv = netdev_priv(ndev);
507	int err;	514	int err;
508		515
509	err = clk_prepare_enable(priv->clk);	516	err = pm_runtime_resume_and_get(ndev->dev.parent);
510	if (err) {	517	if (err) {
511	netdev_err(ndev,	518	netdev_err(ndev, "pm_runtime_resume_and_get() failed %pe\n",
512	"failed to enable peripheral clock, error %d\n",	519	ERR_PTR(err));
513	err);
514	goto out;	520	goto out;
515	}	521	}
516	err = clk_prepare_enable(priv->can_clk);	522	err = clk_prepare_enable(priv->can_clk);
517	if (err) {	523	if (err) {
518	netdev_err(ndev, "failed to enable CAN clock, error %d\n",	524	netdev_err(ndev, "failed to enable CAN clock: %pe\n",
519	err);	525	ERR_PTR(err));
520	goto out_clock;	526	goto out_rpm;
521	}	527	}
522	err = open_candev(ndev);	528	err = open_candev(ndev);
523	if (err) {	529	if (err) {
524	netdev_err(ndev, "open_candev() failed, error %d\n", err);	530	netdev_err(ndev, "open_candev() failed %pe\n", ERR_PTR(err));
525	goto out_can_clock;	531	goto out_can_clock;
526	}	532	}
527	napi_enable(&priv->napi);	533	napi_enable(&priv->napi);
528	err = request_irq(ndev->irq, rcar_can_interrupt, 0, ndev->name, ndev);	534	err = request_irq(ndev->irq, rcar_can_interrupt, 0, ndev->name, ndev);
529	if (err) {	535	if (err) {
530	netdev_err(ndev, "request_irq(%d) failed, error %d\n",	536	netdev_err(ndev, "request_irq(%d) failed %pe\n", ndev->irq,
531	ndev->irq, err);	537	ERR_PTR(err));
532	goto out_close;	538	goto out_close;
533	}	539	}
534	rcar_can_start(ndev);	540	rcar_can_start(ndev);
@@ -539,8 +545,8 @@ out_close: · 4 unmodified lines
539	close_candev(ndev);	545	close_candev(ndev);
540	out_can_clock:	546	out_can_clock:
541	clk_disable_unprepare(priv->can_clk);	547	clk_disable_unprepare(priv->can_clk);
542	out_clock:	548	out_rpm:
543	clk_disable_unprepare(priv->clk);	549	pm_runtime_put(ndev->dev.parent);
544	out:	550	out:
545	return err;	551	return err;
546	}	552	}
@@ -553,7 +559,7 @@ static void rcar_can_stop(struct net_device *ndev) · 6 unmodified lines
553		559
554	/* Go to (force) reset mode */	560	/* Go to (force) reset mode */
555	ctlr = readw(&priv->regs->ctlr);	561	ctlr = readw(&priv->regs->ctlr);
556	ctlr \|= RCAR_CAN_CTLR_CANM_FORCE_RESET;	562	ctlr \|= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_FORCE_RESET);
557	writew(ctlr, &priv->regs->ctlr);	563	writew(ctlr, &priv->regs->ctlr);
558	for (i = 0; i < MAX_STR_READS; i++) {	564	for (i = 0; i < MAX_STR_READS; i++) {
559	if (readw(&priv->regs->str) & RCAR_CAN_STR_RSTST)	565	if (readw(&priv->regs->str) & RCAR_CAN_STR_RSTST)
@@ -578,7 +584,7 @@ static int rcar_can_close(struct net_device *ndev) · 18 unmodified lines
578	free_irq(ndev->irq, ndev);	584	free_irq(ndev->irq, ndev);
579	napi_disable(&priv->napi);	585	napi_disable(&priv->napi);
580	clk_disable_unprepare(priv->can_clk);	586	clk_disable_unprepare(priv->can_clk);
581	clk_disable_unprepare(priv->clk);	587	pm_runtime_put(ndev->dev.parent);
582	close_candev(ndev);	588	close_candev(ndev);
583	return 0;	589	return 0;
584	}	590	}
@@ -594,9 +600,10 @@ static netdev_tx_t rcar_can_start_xmit(struct sk_buff *skb, · 9 unmodified lines
594	return NETDEV_TX_OK;	600	return NETDEV_TX_OK;
595		601
596	if (cf->can_id & CAN_EFF_FLAG) /* Extended frame format */	602	if (cf->can_id & CAN_EFF_FLAG) /* Extended frame format */
597	data = (cf->can_id & CAN_EFF_MASK) \| RCAR_CAN_IDE;	603	data = FIELD_PREP(RCAR_CAN_EID, cf->can_id & CAN_EFF_MASK) \|
		604	RCAR_CAN_IDE;
598	else /* Standard frame format */	605	else /* Standard frame format */
599	data = (cf->can_id & CAN_SFF_MASK) << RCAR_CAN_SID_SHIFT;	606	data = FIELD_PREP(RCAR_CAN_SID, cf->can_id & CAN_SFF_MASK);
600		607
601	if (cf->can_id & CAN_RTR_FLAG) { /* Remote transmission request */	608	if (cf->can_id & CAN_RTR_FLAG) { /* Remote transmission request */
602	data \|= RCAR_CAN_RTR;	609	data \|= RCAR_CAN_RTR;
@@ -651,9 +658,9 @@ static void rcar_can_rx_pkt(struct rcar_can_priv *priv) · 48 unmodified lines
651		658
652	data = readl(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].id);	659	data = readl(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].id);
653	if (data & RCAR_CAN_IDE)	660	if (data & RCAR_CAN_IDE)
654	cf->can_id = (data & CAN_EFF_MASK) \| CAN_EFF_FLAG;	661	cf->can_id = FIELD_GET(RCAR_CAN_EID, data) \| CAN_EFF_FLAG;
655	else	662	else
656	cf->can_id = (data >> RCAR_CAN_SID_SHIFT) & CAN_SFF_MASK;	663	cf->can_id = FIELD_GET(RCAR_CAN_SID, data);
657		664
658	dlc = readb(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].dlc);	665	dlc = readb(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].dlc);
659	cf->len = can_cc_dlc2len(dlc);	666	cf->len = can_cc_dlc2len(dlc);
@@ -715,18 +722,21 @@ static int rcar_can_do_set_mode(struct net_device *ndev, enum can_mode mode) · 55 unmodified lines
715	}	722	}
716	}	723	}
717		724
718	static int rcar_can_get_berr_counter(const struct net_device *dev,	725	static int rcar_can_get_berr_counter(const struct net_device *ndev,
719	struct can_berr_counter *bec)	726	struct can_berr_counter *bec)
720	{	727	{
721	struct rcar_can_priv *priv = netdev_priv(dev);	728	struct rcar_can_priv *priv = netdev_priv(ndev);
722	int err;	729	int err;
723		730
724	err = clk_prepare_enable(priv->clk);	731	err = pm_runtime_resume_and_get(ndev->dev.parent);
725	if (err)	732	if (err)
726	return err;	733	return err;
		734
727	bec->txerr = readb(&priv->regs->tecr);	735	bec->txerr = readb(&priv->regs->tecr);
728	bec->rxerr = readb(&priv->regs->recr);	736	bec->rxerr = readb(&priv->regs->recr);
729	clk_disable_unprepare(priv->clk);	737
		738	pm_runtime_put(ndev->dev.parent);
		739
730	return 0;	740	return 0;
731	}	741	}
732		742
@@ -738,6 +748,7 @@ static const char * const clock_names[] = { · 5 unmodified lines
738		748
739	static int rcar_can_probe(struct platform_device *pdev)	749	static int rcar_can_probe(struct platform_device *pdev)
740	{	750	{
		751	struct device *dev = &pdev->dev;
741	struct rcar_can_priv *priv;	752	struct rcar_can_priv *priv;
742	struct net_device *ndev;	753	struct net_device *ndev;
743	void __iomem *addr;	754	void __iomem *addr;
@@ -745,7 +756,7 @@ static int rcar_can_probe(struct platform_device *pdev) · 1 unmodified line
745	int err = -ENODEV;	756	int err = -ENODEV;
746	int irq;	757	int irq;
747		758
748	of_property_read_u32(pdev->dev.of_node, "renesas,can-clock-select",	759	of_property_read_u32(dev->of_node, "renesas,can-clock-select",
749	&clock_select);	760	&clock_select);
750		761
751	irq = platform_get_irq(pdev, 0);	762	irq = platform_get_irq(pdev, 0);
@@ -762,30 +773,21 @@ static int rcar_can_probe(struct platform_device *pdev) · 10 unmodified lines
762		773
763	ndev = alloc_candev(sizeof(struct rcar_can_priv), RCAR_CAN_FIFO_DEPTH);	774	ndev = alloc_candev(sizeof(struct rcar_can_priv), RCAR_CAN_FIFO_DEPTH);
764	if (!ndev) {	775	if (!ndev) {
765	dev_err(&pdev->dev, "alloc_candev() failed\n");
766	err = -ENOMEM;	776	err = -ENOMEM;
767	goto fail;	777	goto fail;
768	}	778	}
769		779
770	priv = netdev_priv(ndev);	780	priv = netdev_priv(ndev);
771		781
772	priv->clk = devm_clk_get(&pdev->dev, "clkp1");
773	if (IS_ERR(priv->clk)) {
774	err = PTR_ERR(priv->clk);
775	dev_err(&pdev->dev, "cannot get peripheral clock, error %d\n",
776	err);
777	goto fail_clk;
778	}
779
780	if (!(BIT(clock_select) & RCAR_SUPPORTED_CLOCKS)) {	782	if (!(BIT(clock_select) & RCAR_SUPPORTED_CLOCKS)) {
781	err = -EINVAL;	783	err = -EINVAL;
782	dev_err(&pdev->dev, "invalid CAN clock selected\n");	784	dev_err(dev, "invalid CAN clock selected\n");
783	goto fail_clk;	785	goto fail_clk;
784	}	786	}
785	priv->can_clk = devm_clk_get(&pdev->dev, clock_names[clock_select]);	787	priv->can_clk = devm_clk_get(dev, clock_names[clock_select]);
786	if (IS_ERR(priv->can_clk)) {	788	if (IS_ERR(priv->can_clk)) {
		789	dev_err(dev, "cannot get CAN clock: %pe\n", priv->can_clk);
787	err = PTR_ERR(priv->can_clk);	790	err = PTR_ERR(priv->can_clk);
788	dev_err(&pdev->dev, "cannot get CAN clock, error %d\n", err);
789	goto fail_clk;	791	goto fail_clk;
790	}	792	}
791		793
@@ -802,21 +804,24 @@ static int rcar_can_probe(struct platform_device *pdev) · 10 unmodified lines
802	priv->can.do_get_berr_counter = rcar_can_get_berr_counter;	804	priv->can.do_get_berr_counter = rcar_can_get_berr_counter;
803	priv->can.ctrlmode_supported = CAN_CTRLMODE_BERR_REPORTING;	805	priv->can.ctrlmode_supported = CAN_CTRLMODE_BERR_REPORTING;
804	platform_set_drvdata(pdev, ndev);	806	platform_set_drvdata(pdev, ndev);
805	SET_NETDEV_DEV(ndev, &pdev->dev);	807	SET_NETDEV_DEV(ndev, dev);
806		808
807	netif_napi_add_weight(ndev, &priv->napi, rcar_can_rx_poll,	809	netif_napi_add_weight(ndev, &priv->napi, rcar_can_rx_poll,
808	RCAR_CAN_NAPI_WEIGHT);	810	RCAR_CAN_NAPI_WEIGHT);
		811
		812	pm_runtime_enable(dev);
		813
809	err = register_candev(ndev);	814	err = register_candev(ndev);
810	if (err) {	815	if (err) {
811	dev_err(&pdev->dev, "register_candev() failed, error %d\n",	816	dev_err(dev, "register_candev() failed %pe\n", ERR_PTR(err));
812	err);	817	goto fail_rpm;
813	goto fail_candev;
814	}	818	}
815		819
816	dev_info(&pdev->dev, "device registered (IRQ%d)\n", ndev->irq);	820	dev_info(dev, "device registered (IRQ%d)\n", ndev->irq);
817		821
818	return 0;	822	return 0;
819	fail_candev:	823	fail_rpm:
		824	pm_runtime_disable(dev);
820	netif_napi_del(&priv->napi);	825	netif_napi_del(&priv->napi);
821	fail_clk:	826	fail_clk:
822	free_candev(ndev);	827	free_candev(ndev);
@@ -830,6 +835,7 @@ static void rcar_can_remove(struct platform_device *pdev) · 7 unmodified lines
830	struct rcar_can_priv *priv = netdev_priv(ndev);	835	struct rcar_can_priv *priv = netdev_priv(ndev);
831		836
832	unregister_candev(ndev);	837	unregister_candev(ndev);
		838	pm_runtime_disable(&pdev->dev);
833	netif_napi_del(&priv->napi);	839	netif_napi_del(&priv->napi);
834	free_candev(ndev);	840	free_candev(ndev);
835	}	841	}
@@ -847,28 +853,28 @@ static int rcar_can_suspend(struct device *dev) · 11 unmodified lines
847	netif_device_detach(ndev);	853	netif_device_detach(ndev);
848		854
849	ctlr = readw(&priv->regs->ctlr);	855	ctlr = readw(&priv->regs->ctlr);
850	ctlr \|= RCAR_CAN_CTLR_CANM_HALT;	856	ctlr \|= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_HALT);
851	writew(ctlr, &priv->regs->ctlr);	857	writew(ctlr, &priv->regs->ctlr);
852	ctlr \|= RCAR_CAN_CTLR_SLPM;	858	ctlr \|= RCAR_CAN_CTLR_SLPM;
853	writew(ctlr, &priv->regs->ctlr);	859	writew(ctlr, &priv->regs->ctlr);
854	priv->can.state = CAN_STATE_SLEEPING;	860	priv->can.state = CAN_STATE_SLEEPING;
855		861
856	clk_disable(priv->clk);	862	pm_runtime_put(dev);
857	return 0;	863	return 0;
858	}	864	}
859		865
860	static int rcar_can_resume(struct device *dev)	866	static int rcar_can_resume(struct device *dev)
861	{	867	{
862	struct net_device *ndev = dev_get_drvdata(dev);	868	struct net_device *ndev = dev_get_drvdata(dev);
863	struct rcar_can_priv *priv = netdev_priv(ndev);
864	int err;	869	int err;
865		870
866	if (!netif_running(ndev))	871	if (!netif_running(ndev))
867	return 0;	872	return 0;
868		873
869	err = clk_enable(priv->clk);	874	err = pm_runtime_resume_and_get(dev);
870	if (err) {	875	if (err) {
871	netdev_err(ndev, "clk_enable() failed, error %d\n", err);	876	netdev_err(ndev, "pm_runtime_resume_and_get() failed %pe\n",
		877	ERR_PTR(err));
872	return err;	878	return err;
873	}	879	}
874		880

drivers/net/can/rcar/rcar_canfd.c+47−37

@@ -103,22 +103,13 @@ · 102 unmodified lines
103	/* Channel register bits */	103	/* Channel register bits */
104		104
105	/* RSCFDnCmCFG - Classical CAN only */	105	/* RSCFDnCmCFG - Classical CAN only */
106	#define RCANFD_CFG_SJW(x) (((x) & 0x3) << 24)	106	#define RCANFD_CFG_SJW GENMASK(25, 24)
107	#define RCANFD_CFG_TSEG2(x) (((x) & 0x7) << 20)	107	#define RCANFD_CFG_TSEG2 GENMASK(22, 20)
108	#define RCANFD_CFG_TSEG1(x) (((x) & 0xf) << 16)	108	#define RCANFD_CFG_TSEG1 GENMASK(19, 16)
109	#define RCANFD_CFG_BRP(x) (((x) & 0x3ff) << 0)	109	#define RCANFD_CFG_BRP GENMASK(9, 0)
110		110
111	/* RSCFDnCFDCmNCFG - CAN FD only */	111	/* RSCFDnCFDCmNCFG - CAN FD only */
112	#define RCANFD_NCFG_NTSEG2(gpriv, x) \	112	#define RCANFD_NCFG_NBRP GENMASK(9, 0)
113	(((x) & ((gpriv)->info->nom_bittiming->tseg2_max - 1)) << (gpriv)->info->sh->ntseg2)
114
115	#define RCANFD_NCFG_NTSEG1(gpriv, x) \
116	(((x) & ((gpriv)->info->nom_bittiming->tseg1_max - 1)) << (gpriv)->info->sh->ntseg1)
117
118	#define RCANFD_NCFG_NSJW(gpriv, x) \
119	(((x) & ((gpriv)->info->nom_bittiming->sjw_max - 1)) << (gpriv)->info->sh->nsjw)
120
121	#define RCANFD_NCFG_NBRP(x) (((x) & 0x3ff) << 0)
122		113
123	/* RSCFDnCFDCmCTR / RSCFDnCmCTR */	114	/* RSCFDnCFDCmCTR / RSCFDnCmCTR */
124	#define RCANFD_CCTR_CTME BIT(24)	115	#define RCANFD_CCTR_CTME BIT(24)
@@ -178,15 +169,7 @@ · 53 unmodified lines
178	#define RCANFD_CERFL_ERR(x) ((x) & (0x7fff)) /* above bits 14:0 */	169	#define RCANFD_CERFL_ERR(x) ((x) & (0x7fff)) /* above bits 14:0 */
179		170
180	/* RSCFDnCFDCmDCFG */	171	/* RSCFDnCFDCmDCFG */
181	#define RCANFD_DCFG_DSJW(gpriv, x) (((x) & ((gpriv)->info->data_bittiming->sjw_max - 1)) << 24)	172	#define RCANFD_DCFG_DBRP GENMASK(7, 0)
182
183	#define RCANFD_DCFG_DTSEG2(gpriv, x) \
184	(((x) & ((gpriv)->info->data_bittiming->tseg2_max - 1)) << (gpriv)->info->sh->dtseg2)
185
186	#define RCANFD_DCFG_DTSEG1(gpriv, x) \
187	(((x) & ((gpriv)->info->data_bittiming->tseg1_max - 1)) << (gpriv)->info->sh->dtseg1)
188
189	#define RCANFD_DCFG_DBRP(x) (((x) & 0xff) << 0)
190		173
191	/* RSCFDnCFDCmFDCFG */	174	/* RSCFDnCFDCmFDCFG */
192	#define RCANFD_GEN4_FDCFG_CLOE BIT(30)	175	#define RCANFD_GEN4_FDCFG_CLOE BIT(30)
@@ -1389,6 +1372,41 @@ static irqreturn_t rcar_canfd_channel_interrupt(int irq, void *dev_id) · 1196 unmodified lines
1389	return IRQ_HANDLED;	1372	return IRQ_HANDLED;
1390	}	1373	}
1391		1374
		1375	static inline u32 rcar_canfd_compute_nominal_bit_rate_cfg(struct rcar_canfd_channel *priv,
		1376	u16 tseg1, u16 tseg2, u16 sjw, u16 brp)
		1377	{
		1378	struct rcar_canfd_global *gpriv = priv->gpriv;
		1379	const struct rcar_canfd_hw_info *info = gpriv->info;
		1380	u32 ntseg1, ntseg2, nsjw, nbrp;
		1381
		1382	if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) \|\| gpriv->info->shared_can_regs) {
		1383	ntseg1 = (tseg1 & (info->nom_bittiming->tseg1_max - 1)) << info->sh->ntseg1;
		1384	ntseg2 = (tseg2 & (info->nom_bittiming->tseg2_max - 1)) << info->sh->ntseg2;
		1385	nsjw = (sjw & (info->nom_bittiming->sjw_max - 1)) << info->sh->nsjw;
		1386	nbrp = FIELD_PREP(RCANFD_NCFG_NBRP, brp);
		1387	} else {
		1388	ntseg1 = FIELD_PREP(RCANFD_CFG_TSEG1, tseg1);
		1389	ntseg2 = FIELD_PREP(RCANFD_CFG_TSEG2, tseg2);
		1390	nsjw = FIELD_PREP(RCANFD_CFG_SJW, sjw);
		1391	nbrp = FIELD_PREP(RCANFD_CFG_BRP, brp);
		1392	}
		1393
		1394	return (ntseg1 \| ntseg2 \| nsjw \| nbrp);
		1395	}
		1396
		1397	static inline u32 rcar_canfd_compute_data_bit_rate_cfg(const struct rcar_canfd_hw_info *info,
		1398	u16 tseg1, u16 tseg2, u16 sjw, u16 brp)
		1399	{
		1400	u32 dtseg1, dtseg2, dsjw, dbrp;
		1401
		1402	dtseg1 = (tseg1 & (info->data_bittiming->tseg1_max - 1)) << info->sh->dtseg1;
		1403	dtseg2 = (tseg2 & (info->data_bittiming->tseg2_max - 1)) << info->sh->dtseg2;
		1404	dsjw = (sjw & (info->data_bittiming->sjw_max - 1)) << 24;
		1405	dbrp = FIELD_PREP(RCANFD_DCFG_DBRP, brp);
		1406
		1407	return (dtseg1 \| dtseg2 \| dsjw \| dbrp);
		1408	}
		1409
1392	static void rcar_canfd_set_bittiming(struct net_device *ndev)	1410	static void rcar_canfd_set_bittiming(struct net_device *ndev)
1393	{	1411	{
1394	u32 mask = RCANFD_FDCFG_TDCO \| RCANFD_FDCFG_TDCE \| RCANFD_FDCFG_TDCOC;	1412	u32 mask = RCANFD_FDCFG_TDCO \| RCANFD_FDCFG_TDCE \| RCANFD_FDCFG_TDCOC;
@@ -1407,15 +1425,7 @@ static void rcar_canfd_set_bittiming(struct net_device *ndev) · 12 unmodified lines
1407	sjw = bt->sjw - 1;	1425	sjw = bt->sjw - 1;
1408	tseg1 = bt->prop_seg + bt->phase_seg1 - 1;	1426	tseg1 = bt->prop_seg + bt->phase_seg1 - 1;
1409	tseg2 = bt->phase_seg2 - 1;	1427	tseg2 = bt->phase_seg2 - 1;
1410		1428	cfg = rcar_canfd_compute_nominal_bit_rate_cfg(priv, tseg1, tseg2, sjw, brp);
1411	if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) \|\| gpriv->info->shared_can_regs) {
1412	cfg = (RCANFD_NCFG_NTSEG1(gpriv, tseg1) \| RCANFD_NCFG_NBRP(brp) \|
1413	RCANFD_NCFG_NSJW(gpriv, sjw) \| RCANFD_NCFG_NTSEG2(gpriv, tseg2));
1414	} else {
1415	cfg = (RCANFD_CFG_TSEG1(tseg1) \| RCANFD_CFG_BRP(brp) \|
1416	RCANFD_CFG_SJW(sjw) \| RCANFD_CFG_TSEG2(tseg2));
1417	}
1418
1419	rcar_canfd_write(priv->base, RCANFD_CCFG(ch), cfg);	1429	rcar_canfd_write(priv->base, RCANFD_CCFG(ch), cfg);
1420		1430
1421	if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD))	1431	if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD))
@@ -1426,10 +1436,7 @@ static void rcar_canfd_set_bittiming(struct net_device *ndev) · 4 unmodified lines
1426	sjw = dbt->sjw - 1;	1436	sjw = dbt->sjw - 1;
1427	tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1;	1437	tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1;
1428	tseg2 = dbt->phase_seg2 - 1;	1438	tseg2 = dbt->phase_seg2 - 1;
1429		1439	cfg = rcar_canfd_compute_data_bit_rate_cfg(gpriv->info, tseg1, tseg2, sjw, brp);
1430	cfg = (RCANFD_DCFG_DTSEG1(gpriv, tseg1) \| RCANFD_DCFG_DBRP(brp) \|
1431	RCANFD_DCFG_DSJW(gpriv, sjw) \| RCANFD_DCFG_DTSEG2(gpriv, tseg2));
1432
1433	writel(cfg, &gpriv->fcbase[ch].dcfg);	1440	writel(cfg, &gpriv->fcbase[ch].dcfg);
1434		1441
1435	/* Transceiver Delay Compensation */	1442	/* Transceiver Delay Compensation */
@@ -1913,7 +1920,10 @@ static int rcar_canfd_channel_probe(struct rcar_canfd_global *gpriv, u32 ch, · 477 unmodified lines
1913	priv->can.fd.do_get_auto_tdcv = rcar_canfd_get_auto_tdcv;	1920	priv->can.fd.do_get_auto_tdcv = rcar_canfd_get_auto_tdcv;
1914	} else {	1921	} else {
1915	/* Controller starts in Classical CAN only mode */	1922	/* Controller starts in Classical CAN only mode */
1916	priv->can.bittiming_const = &rcar_canfd_bittiming_const;	1923	if (gpriv->info->shared_can_regs)
		1924	priv->can.bittiming_const = gpriv->info->nom_bittiming;
		1925	else
		1926	priv->can.bittiming_const = &rcar_canfd_bittiming_const;
1917	priv->can.ctrlmode_supported = CAN_CTRLMODE_BERR_REPORTING;	1927	priv->can.ctrlmode_supported = CAN_CTRLMODE_BERR_REPORTING;
1918	}	1928	}
1919		1929

drivers/net/can/sja1000/peak_pci.c+3−3

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright (C) 2007, 2011 Wolfgang Grandegger <wg@grandegger.com>
- * Copyright (C) 2012 Stephane Grosjean <s.grosjean@peak-system.com>
  *
  * Derived from the PCAN project file driver/src/pcan_pci.c:
  *
- * Copyright (C) 2001-2006  PEAK System-Technik GmbH
+ * Copyright (C) 2001-2025 PEAK System-Technik GmbH
+ * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
  */
 #include <linux/kernel.h>
 #include "sja1000.h"
-MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
+MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>");
 MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCI family cards");
 MODULE_LICENSE("GPL v2");

drivers/net/can/sja1000/peak_pcmcia.c+4−4

 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>
- *
  * CAN driver for PEAK-System PCAN-PC Card
  * Derived from the PCAN project file driver/src/pcan_pccard.c
- * Copyright (C) 2006-2010 PEAK System-Technik GmbH
+ *
+ * Copyright (C) 2006-2025 PEAK System-Technik GmbH
+ * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/can/dev.h>
 #include "sja1000.h"
-MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
+MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>");
 MODULE_DESCRIPTION("CAN driver for PEAK-System PCAN-PC Cards");
 MODULE_LICENSE("GPL v2");

drivers/net/can/usb/esd_usb.c+43−21

 #include <linux/can.h>
 #include <linux/can/dev.h>
 #include <linux/can/error.h>
+#include <linux/err.h>
 #include <linux/ethtool.h>
 #include <linux/module.h>
 #include <linux/netdevice.h>
 	int net_count;
 	u32 version;
 	int rxinitdone;
+	int in_usb_disconnect;
 	void *rxbuf[ESD_USB_MAX_RX_URBS];
 	dma_addr_t rxbuf_dma[ESD_USB_MAX_RX_URBS];
 };
 static void esd_usb_read_bulk_callback(struct urb *urb)
 {
 	struct esd_usb *dev = urb->context;
-	int retval;
+	int err;
 	int pos = 0;
 	int i;
 	default:
 		dev_info(dev->udev->dev.parent,
-			 "Rx URB aborted (%d)\n", urb->status);
+			 "Rx URB aborted (%pe)\n", ERR_PTR(urb->status));
 		goto resubmit_urb;
 	}
 			  urb->transfer_buffer, ESD_USB_RX_BUFFER_SIZE,
 			  esd_usb_read_bulk_callback, dev);
-	retval = usb_submit_urb(urb, GFP_ATOMIC);
+	err = usb_submit_urb(urb, GFP_ATOMIC);
-	if (retval == -ENODEV) {
+	if (err == -ENODEV) {
 		for (i = 0; i < dev->net_count; i++) {
 			if (dev->nets[i])
 				netif_device_detach(dev->nets[i]->netdev);
 		}
-	} else if (retval) {
+	} else if (err) {
 		dev_err(dev->udev->dev.parent,
-			"failed resubmitting read bulk urb: %d\n", retval);
+			"failed resubmitting read bulk urb: %pe\n", ERR_PTR(err));
 	}
 }
 		return;
 	if (urb->status)
-		netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
+		netdev_info(netdev, "Tx URB aborted (%pe)\n", ERR_PTR(urb->status));
 	netif_trans_update(netdev);
 }
 	if (err == -ENODEV)
 		netif_device_detach(netdev);
 	if (err)
-		netdev_err(netdev, "couldn't start device: %d\n", err);
+		netdev_err(netdev, "couldn't start device: %pe\n", ERR_PTR(err));
 	kfree(msg);
 	return err;
 	/* finally start device */
 	err = esd_usb_start(priv);
 	if (err) {
-		netdev_warn(netdev, "couldn't start device: %d\n", err);
 		close_candev(netdev);
 		return err;
 	}
 		if (err == -ENODEV)
 			netif_device_detach(netdev);
 		else
-			netdev_warn(netdev, "failed tx_urb %d\n", err);
+			netdev_warn(netdev, "failed tx_urb %pe\n", ERR_PTR(err));
 		goto releasebuf;
 	}
 	return ret;
 }
-static int esd_usb_close(struct net_device *netdev)
+/* Stop interface */
+static int esd_usb_stop(struct esd_usb_net_priv *priv)
 {
-	struct esd_usb_net_priv *priv = netdev_priv(netdev);
 	union esd_usb_msg *msg;
+	int err;
 	int i;
 	msg = kmalloc(sizeof(*msg), GFP_KERNEL);
 	msg->filter.option = ESD_USB_ID_ENABLE; /* start with segment 0 */
 	for (i = 0; i <= ESD_USB_MAX_ID_SEGMENT; i++)
 		msg->filter.mask[i] = 0;
-	if (esd_usb_send_msg(priv->usb, msg) < 0)
+	err = esd_usb_send_msg(priv->usb, msg);
-		netdev_err(netdev, "sending idadd message failed\n");
+	if (err < 0) {
+		netdev_err(priv->netdev, "sending idadd message failed: %pe\n", ERR_PTR(err));
+		goto bail;
+	}
 	/* set CAN controller to reset mode */
 	msg->hdr.len = sizeof(struct esd_usb_set_baudrate_msg) / sizeof(u32); /* # of 32bit words */
 	msg->setbaud.net = priv->index;
 	msg->setbaud.rsvd = 0;
 	msg->setbaud.baud = cpu_to_le32(ESD_USB_NO_BAUDRATE);
-	if (esd_usb_send_msg(priv->usb, msg) < 0)
+	err = esd_usb_send_msg(priv->usb, msg);
-		netdev_err(netdev, "sending setbaud message failed\n");
+	if (err < 0)
+		netdev_err(priv->netdev, "sending setbaud message failed: %pe\n", ERR_PTR(err));
+bail:
+	kfree(msg);
+	return err;
+}
+static int esd_usb_close(struct net_device *netdev)
+{
+	struct esd_usb_net_priv *priv = netdev_priv(netdev);
+	int err = 0;
+	if (!priv->usb->in_usb_disconnect) {
+		/* It's moot to try this in usb_disconnect()! */
+		err = esd_usb_stop(priv);
+	}
 	priv->can.state = CAN_STATE_STOPPED;
 	close_candev(netdev);
-	kfree(msg);
+	return err;
-	return 0;
 }
 static const struct net_device_ops esd_usb_netdev_ops = {
 	err = register_candev(netdev);
 	if (err) {
-		dev_err(&intf->dev, "couldn't register CAN device: %d\n", err);
+		dev_err(&intf->dev, "couldn't register CAN device: %pe\n", ERR_PTR(err));
 		free_candev(netdev);
 		err = -ENOMEM;
 		goto done;
 	}
 	dev->nets[index] = priv;
-	netdev_info(netdev, "device %s registered\n", netdev->name);
+	netdev_info(netdev, "registered\n");
 done:
 	return err;
 	usb_set_intfdata(intf, NULL);
 	if (dev) {
+		dev->in_usb_disconnect = 1;
 		for (i = 0; i < dev->net_count; i++) {
 			if (dev->nets[i]) {
 				netdev = dev->nets[i]->netdev;
+				netdev_info(netdev, "unregister\n");
 				unregister_netdev(netdev);
 				free_candev(netdev);
 			}

drivers/net/can/usb/peak_usb/pcan_usb.c+3−3

@@ -3,8 +3,8 @@ · 2 unmodified lines
3	* CAN driver for PEAK System PCAN-USB adapter	3	* CAN driver for PEAK System PCAN-USB adapter
4	* Derived from the PCAN project file driver/src/pcan_usb.c	4	* Derived from the PCAN project file driver/src/pcan_usb.c
5	*	5	*
6	* Copyright (C) 2003-2010 PEAK System-Technik GmbH	6	* Copyright (C) 2003-2025 PEAK System-Technik GmbH
7	* Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com>	7	* Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
8	*	8	*
9	* Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>	9	* Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
10	*/	10	*/
@@ -919,7 +919,7 @@ static int pcan_usb_init(struct peak_usb_device *dev) · 908 unmodified lines
919	CAN_CTRLMODE_LOOPBACK;	919	CAN_CTRLMODE_LOOPBACK;
920	} else {	920	} else {
921	dev_info(dev->netdev->dev.parent,	921	dev_info(dev->netdev->dev.parent,
922	"Firmware update available. Please contact support@peak-system.com\n");	922	"Firmware update available. Please contact support.peak@hms-networks.com\n");
923	}	923	}
924		924
925	return 0;	925	return 0;

drivers/net/can/usb/peak_usb/pcan_usb_core.c+3−3

@@ -3,8 +3,8 @@ · 2 unmodified lines
3	* CAN driver for PEAK System USB adapters	3	* CAN driver for PEAK System USB adapters
4	* Derived from the PCAN project file driver/src/pcan_usb_core.c	4	* Derived from the PCAN project file driver/src/pcan_usb_core.c
5	*	5	*
6	* Copyright (C) 2003-2010 PEAK System-Technik GmbH	6	* Copyright (C) 2003-2025 PEAK System-Technik GmbH
7	* Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>	7	* Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
8	*	8	*
9	* Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>	9	* Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
10	*/	10	*/
@@ -24,7 +24,7 @@ · 13 unmodified lines
24		24
25	#include "pcan_usb_core.h"	25	#include "pcan_usb_core.h"
26		26
27	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");	27	MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>");
28	MODULE_DESCRIPTION("CAN driver for PEAK-System USB adapters");	28	MODULE_DESCRIPTION("CAN driver for PEAK-System USB adapters");
29	MODULE_LICENSE("GPL v2");	29	MODULE_LICENSE("GPL v2");
30		30

drivers/net/can/usb/peak_usb/pcan_usb_core.h+2−2

@@ -3,8 +3,8 @@ · 2 unmodified lines
3	* CAN driver for PEAK System USB adapters	3	* CAN driver for PEAK System USB adapters
4	* Derived from the PCAN project file driver/src/pcan_usb_core.c	4	* Derived from the PCAN project file driver/src/pcan_usb_core.c
5	*	5	*
6	* Copyright (C) 2003-2010 PEAK System-Technik GmbH	6	* Copyright (C) 2003-2025 PEAK System-Technik GmbH
7	* Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>	7	* Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
8	*	8	*
9	* Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>	9	* Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
10	*/	10	*/

drivers/net/can/usb/peak_usb/pcan_usb_fd.c+2−1

 /*
  * CAN driver for PEAK System PCAN-USB FD / PCAN-USB Pro FD adapter
  *
- * Copyright (C) 2013-2014 Stephane Grosjean <s.grosjean@peak-system.com>
+ * Copyright (C) 2013-2025 PEAK System-Technik GmbH
+ * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
  */
 #include <linux/ethtool.h>
 #include <linux/module.h>

drivers/net/can/usb/peak_usb/pcan_usb_pro.c+2−2

@@ -3,8 +3,8 @@ · 2 unmodified lines
3	* CAN driver for PEAK System PCAN-USB Pro adapter	3	* CAN driver for PEAK System PCAN-USB Pro adapter
4	* Derived from the PCAN project file driver/src/pcan_usbpro.c	4	* Derived from the PCAN project file driver/src/pcan_usbpro.c
5	*	5	*
6	* Copyright (C) 2003-2011 PEAK System-Technik GmbH	6	* Copyright (C) 2003-2025 PEAK System-Technik GmbH
7	* Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com>	7	* Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
8	*/	8	*/
9	#include <linux/ethtool.h>	9	#include <linux/ethtool.h>
10	#include <linux/module.h>	10	#include <linux/module.h>

drivers/net/can/usb/peak_usb/pcan_usb_pro.h+2−2

@@ -3,8 +3,8 @@ · 2 unmodified lines
3	* CAN driver for PEAK System PCAN-USB Pro adapter	3	* CAN driver for PEAK System PCAN-USB Pro adapter
4	* Derived from the PCAN project file driver/src/pcan_usbpro_fw.h	4	* Derived from the PCAN project file driver/src/pcan_usbpro_fw.h
5	*	5	*
6	* Copyright (C) 2003-2011 PEAK System-Technik GmbH	6	* Copyright (C) 2003-2025 PEAK System-Technik GmbH
7	* Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com>	7	* Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
8	*/	8	*/
9	#ifndef PCAN_USB_PRO_H	9	#ifndef PCAN_USB_PRO_H
10	#define PCAN_USB_PRO_H	10	#define PCAN_USB_PRO_H

drivers/net/can/vcan.c+1−1

@@ -156,7 +156,7 @@ static const struct ethtool_ops vcan_ethtool_ops = { · 155 unmodified lines
156	static void vcan_setup(struct net_device *dev)	156	static void vcan_setup(struct net_device *dev)
157	{	157	{
158	dev->type = ARPHRD_CAN;	158	dev->type = ARPHRD_CAN;
159	dev->mtu = CANFD_MTU;	159	dev->mtu = CANXL_MTU;
160	dev->hard_header_len = 0;	160	dev->hard_header_len = 0;
161	dev->addr_len = 0;	161	dev->addr_len = 0;
162	dev->tx_queue_len = 0;	162	dev->tx_queue_len = 0;

drivers/net/can/vxcan.c+1−1

@@ -156,7 +156,7 @@ static void vxcan_setup(struct net_device *dev) · 155 unmodified lines
156	struct can_ml_priv *can_ml;	156	struct can_ml_priv *can_ml;
157		157
158	dev->type = ARPHRD_CAN;	158	dev->type = ARPHRD_CAN;
159	dev->mtu = CANFD_MTU;	159	dev->mtu = CANXL_MTU;
160	dev->hard_header_len = 0;	160	dev->hard_header_len = 0;
161	dev->addr_len = 0;	161	dev->addr_len = 0;
162	dev->tx_queue_len = 0;	162	dev->tx_queue_len = 0;

include/linux/can/bittiming.h+46−2

@@ -16,6 +16,10 @@ · 15 unmodified lines
16		16
17	#define CAN_CTRLMODE_FD_TDC_MASK \	17	#define CAN_CTRLMODE_FD_TDC_MASK \
18	(CAN_CTRLMODE_TDC_AUTO \| CAN_CTRLMODE_TDC_MANUAL)	18	(CAN_CTRLMODE_TDC_AUTO \| CAN_CTRLMODE_TDC_MANUAL)
		19	#define CAN_CTRLMODE_TDC_AUTO_MASK \
		20	(CAN_CTRLMODE_TDC_AUTO)
		21	#define CAN_CTRLMODE_TDC_MANUAL_MASK \
		22	(CAN_CTRLMODE_TDC_MANUAL)
19		23
20	/*	24	/*
21	* struct can_tdc - CAN FD Transmission Delay Compensation parameters	25	* struct can_tdc - CAN FD Transmission Delay Compensation parameters
@@ -114,13 +118,24 @@ struct can_tdc_const { · 92 unmodified lines
114	u32 tdcf_max;	118	u32 tdcf_max;
115	};	119	};
116		120
		121	struct data_bittiming_params {
		122	const struct can_bittiming_const *data_bittiming_const;
		123	struct can_bittiming data_bittiming;
		124	const struct can_tdc_const *tdc_const;
		125	struct can_tdc tdc;
		126	const u32 *data_bitrate_const;
		127	unsigned int data_bitrate_const_cnt;
		128	int (do_set_data_bittiming)(struct net_device dev);
		129	int (do_get_auto_tdcv)(const struct net_device dev, u32 *tdcv);
		130	};
		131
117	#ifdef CONFIG_CAN_CALC_BITTIMING	132	#ifdef CONFIG_CAN_CALC_BITTIMING
118	int can_calc_bittiming(const struct net_device dev, struct can_bittiming bt,	133	int can_calc_bittiming(const struct net_device dev, struct can_bittiming bt,
119	const struct can_bittiming_const btc, struct netlink_ext_ack extack);	134	const struct can_bittiming_const btc, struct netlink_ext_ack extack);
120		135
121	void can_calc_tdco(struct can_tdc tdc, const struct can_tdc_const tdc_const,	136	void can_calc_tdco(struct can_tdc tdc, const struct can_tdc_const tdc_const,
122	const struct can_bittiming *dbt,	137	const struct can_bittiming *dbt,
123	u32 *ctrlmode, u32 ctrlmode_supported);	138	u32 tdc_mask, u32 *ctrlmode, u32 ctrlmode_supported);
124	#else /* !CONFIG_CAN_CALC_BITTIMING */	139	#else /* !CONFIG_CAN_CALC_BITTIMING */
125	static inline int	140	static inline int
126	can_calc_bittiming(const struct net_device dev, struct can_bittiming bt,	141	can_calc_bittiming(const struct net_device dev, struct can_bittiming bt,
@@ -133,7 +148,7 @@ can_calc_bittiming(const struct net_device dev, struct can_bittiming bt, · 6 unmodified lines
133	static inline void	148	static inline void
134	can_calc_tdco(struct can_tdc tdc, const struct can_tdc_const tdc_const,	149	can_calc_tdco(struct can_tdc tdc, const struct can_tdc_const tdc_const,
135	const struct can_bittiming *dbt,	150	const struct can_bittiming *dbt,
136	u32 *ctrlmode, u32 ctrlmode_supported)	151	u32 tdc_mask, u32 *ctrlmode, u32 ctrlmode_supported)
137	{	152	{
138	}	153	}
139	#endif /* CONFIG_CAN_CALC_BITTIMING */	154	#endif /* CONFIG_CAN_CALC_BITTIMING */
@@ -149,6 +164,35 @@ int can_get_bittiming(const struct net_device dev, struct can_bittiming bt, · 9 unmodified lines
149	const unsigned int bitrate_const_cnt,	164	const unsigned int bitrate_const_cnt,
150	struct netlink_ext_ack *extack);	165	struct netlink_ext_ack *extack);
151		166
		167	/*
		168	* can_get_relative_tdco() - TDCO relative to the sample point
		169	*
		170	* struct can_tdc::tdco represents the absolute offset from TDCV. Some
		171	* controllers use instead an offset relative to the Sample Point (SP)
		172	* such that:
		173	*
		174	* SSP = TDCV + absolute TDCO
		175	* = TDCV + SP + relative TDCO
		176	*
		177	* -+----------- one bit ----------+-- TX pin
		178	* \|<--- Sample Point --->\|
		179	*
		180	* --+----------- one bit ----------+-- RX pin
		181	* \|<-------- TDCV -------->\|
		182	* \|<------------------------>\| absolute TDCO
		183	* \|<--- Sample Point --->\|
		184	* \| \|<->\| relative TDCO
		185	* \|<------------- Secondary Sample Point ------------>\|
		186	*/
		187	static inline s32 can_get_relative_tdco(const struct data_bittiming_params *dbt_params)
		188	{
		189	const struct can_bittiming *dbt = &dbt_params->data_bittiming;
		190	s32 sample_point_in_tc = (CAN_SYNC_SEG + dbt->prop_seg +
		191	dbt->phase_seg1) * dbt->brp;
		192
		193	return (s32)dbt_params->tdc.tdco - sample_point_in_tc;
		194	}
		195
152	/*	196	/*
153	* can_bit_time() - Duration of one bit	197	* can_bit_time() - Duration of one bit
154	*	198	*

include/linux/can/dev.h+5−61

@@ -38,17 +38,6 @@ enum can_termination_gpio { · 37 unmodified lines
38	CAN_TERMINATION_GPIO_MAX,	38	CAN_TERMINATION_GPIO_MAX,
39	};	39	};
40		40
41	struct data_bittiming_params {
42	const struct can_bittiming_const *data_bittiming_const;
43	struct can_bittiming data_bittiming;
44	const struct can_tdc_const *tdc_const;
45	struct can_tdc tdc;
46	const u32 *data_bitrate_const;
47	unsigned int data_bitrate_const_cnt;
48	int (do_set_data_bittiming)(struct net_device dev);
49	int (do_get_auto_tdcv)(const struct net_device dev, u32 *tdcv);
50	};
51
52	/*	41	/*
53	* CAN common private data	42	* CAN common private data
54	*/	43	*/
@@ -96,56 +85,6 @@ static inline bool can_fd_tdc_is_enabled(const struct can_priv *priv) · 41 unmodified lines
96	return !!(priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK);	85	return !!(priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK);
97	}	86	}
98		87
99	/*
100	* can_get_relative_tdco() - TDCO relative to the sample point
101	*
102	* struct can_tdc::tdco represents the absolute offset from TDCV. Some
103	* controllers use instead an offset relative to the Sample Point (SP)
104	* such that:
105	*
106	* SSP = TDCV + absolute TDCO
107	* = TDCV + SP + relative TDCO
108	*
109	* -+----------- one bit ----------+-- TX pin
110	* \|<--- Sample Point --->\|
111	*
112	* --+----------- one bit ----------+-- RX pin
113	* \|<-------- TDCV -------->\|
114	* \|<------------------------>\| absolute TDCO
115	* \|<--- Sample Point --->\|
116	* \| \|<->\| relative TDCO
117	* \|<------------- Secondary Sample Point ------------>\|
118	*/
119	static inline s32 can_get_relative_tdco(const struct can_priv *priv)
120	{
121	const struct can_bittiming *dbt = &priv->fd.data_bittiming;
122	s32 sample_point_in_tc = (CAN_SYNC_SEG + dbt->prop_seg +
123	dbt->phase_seg1) * dbt->brp;
124
125	return (s32)priv->fd.tdc.tdco - sample_point_in_tc;
126	}
127
128	/* helper to define static CAN controller features at device creation time */
129	static inline int __must_check can_set_static_ctrlmode(struct net_device *dev,
130	u32 static_mode)
131	{
132	struct can_priv *priv = netdev_priv(dev);
133
134	/* alloc_candev() succeeded => netdev_priv() is valid at this point */
135	if (priv->ctrlmode_supported & static_mode) {
136	netdev_warn(dev,
137	"Controller features can not be supported and static at the same time\n");
138	return -EINVAL;
139	}
140	priv->ctrlmode = static_mode;
141
142	/* override MTU which was set by default in can_setup()? */
143	if (static_mode & CAN_CTRLMODE_FD)
144	dev->mtu = CANFD_MTU;
145
146	return 0;
147	}
148
149	static inline u32 can_get_static_ctrlmode(struct can_priv *priv)	88	static inline u32 can_get_static_ctrlmode(struct can_priv *priv)
150	{	89	{
151	return priv->ctrlmode & ~priv->ctrlmode_supported;	90	return priv->ctrlmode & ~priv->ctrlmode_supported;
@@ -187,7 +126,10 @@ struct can_priv safe_candev_priv(struct net_device dev); · 35 unmodified lines
187		126
188	int open_candev(struct net_device *dev);	127	int open_candev(struct net_device *dev);
189	void close_candev(struct net_device *dev);	128	void close_candev(struct net_device *dev);
		129	void can_set_default_mtu(struct net_device *dev);
190	int can_change_mtu(struct net_device *dev, int new_mtu);	130	int can_change_mtu(struct net_device *dev, int new_mtu);
		131	int __must_check can_set_static_ctrlmode(struct net_device *dev,
		132	u32 static_mode);
191	int can_eth_ioctl_hwts(struct net_device netdev, struct ifreq ifr, int cmd);	133	int can_eth_ioctl_hwts(struct net_device netdev, struct ifreq ifr, int cmd);
192	int can_ethtool_op_get_ts_info_hwts(struct net_device *dev,	134	int can_ethtool_op_get_ts_info_hwts(struct net_device *dev,
193	struct kernel_ethtool_ts_info *info);	135	struct kernel_ethtool_ts_info *info);
@@ -199,6 +141,8 @@ int can_restart_now(struct net_device *dev); · 5 unmodified lines
199	void can_bus_off(struct net_device *dev);	141	void can_bus_off(struct net_device *dev);
200		142
201	const char *can_get_state_str(const enum can_state state);	143	const char *can_get_state_str(const enum can_state state);
		144	const char *can_get_ctrlmode_str(u32 ctrlmode);
		145
202	void can_state_get_by_berr_counter(const struct net_device *dev,	146	void can_state_get_by_berr_counter(const struct net_device *dev,
203	const struct can_berr_counter *bec,	147	const struct can_berr_counter *bec,
204	enum can_state *tx_state,	148	enum can_state *tx_state,

include/linux/can/dev/peak_canfd.h+2−2

@@ -2,8 +2,8 @@ · 1 unmodified line
2	/*	2	/*
3	* CAN driver for PEAK System micro-CAN based adapters	3	* CAN driver for PEAK System micro-CAN based adapters
4	*	4	*
5	* Copyright (C) 2003-2011 PEAK System-Technik GmbH	5	* Copyright (C) 2003-2025 PEAK System-Technik GmbH
6	* Copyright (C) 2011-2013 Stephane Grosjean <s.grosjean@peak-system.com>	6	* Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com>
7	*/	7	*/
8	#ifndef PUCAN_H	8	#ifndef PUCAN_H
9	#define PUCAN_H	9	#define PUCAN_H

include/uapi/linux/can/netlink.h+7−7

@@ -101,8 +101,8 @@ struct can_ctrlmode { · 100 unmodified lines
101	#define CAN_CTRLMODE_PRESUME_ACK 0x40 /* Ignore missing CAN ACKs */	101	#define CAN_CTRLMODE_PRESUME_ACK 0x40 /* Ignore missing CAN ACKs */
102	#define CAN_CTRLMODE_FD_NON_ISO 0x80 /* CAN FD in non-ISO mode */	102	#define CAN_CTRLMODE_FD_NON_ISO 0x80 /* CAN FD in non-ISO mode */
103	#define CAN_CTRLMODE_CC_LEN8_DLC 0x100 /* Classic CAN DLC option */	103	#define CAN_CTRLMODE_CC_LEN8_DLC 0x100 /* Classic CAN DLC option */
104	#define CAN_CTRLMODE_TDC_AUTO 0x200 /* CAN transiver automatically calculates TDCV */	104	#define CAN_CTRLMODE_TDC_AUTO 0x200 /* FD transceiver automatically calculates TDCV */
105	#define CAN_CTRLMODE_TDC_MANUAL 0x400 /* TDCV is manually set up by user */	105	#define CAN_CTRLMODE_TDC_MANUAL 0x400 /* FD TDCV is manually set up by user */
106		106
107	/*	107	/*
108	* CAN device statistics	108	* CAN device statistics
@@ -129,14 +129,14 @@ enum { · 20 unmodified lines
129	IFLA_CAN_RESTART_MS,	129	IFLA_CAN_RESTART_MS,
130	IFLA_CAN_RESTART,	130	IFLA_CAN_RESTART,
131	IFLA_CAN_BERR_COUNTER,	131	IFLA_CAN_BERR_COUNTER,
132	IFLA_CAN_DATA_BITTIMING,	132	IFLA_CAN_DATA_BITTIMING, /* FD */
133	IFLA_CAN_DATA_BITTIMING_CONST,	133	IFLA_CAN_DATA_BITTIMING_CONST, /* FD */
134	IFLA_CAN_TERMINATION,	134	IFLA_CAN_TERMINATION,
135	IFLA_CAN_TERMINATION_CONST,	135	IFLA_CAN_TERMINATION_CONST,
136	IFLA_CAN_BITRATE_CONST,	136	IFLA_CAN_BITRATE_CONST,
137	IFLA_CAN_DATA_BITRATE_CONST,	137	IFLA_CAN_DATA_BITRATE_CONST, /* FD */
138	IFLA_CAN_BITRATE_MAX,	138	IFLA_CAN_BITRATE_MAX,
139	IFLA_CAN_TDC,	139	IFLA_CAN_TDC, /* FD */
140	IFLA_CAN_CTRLMODE_EXT,	140	IFLA_CAN_CTRLMODE_EXT,
141		141
142	/* add new constants above here */	142	/* add new constants above here */
@@ -145,7 +145,7 @@ enum { · 2 unmodified lines
145	};	145	};
146		146
147	/*	147	/*
148	* CAN FD Transmitter Delay Compensation (TDC)	148	* CAN FD/XL Transmitter Delay Compensation (TDC)
149	*	149	*
150	* Please refer to struct can_tdc_const and can_tdc in	150	* Please refer to struct can_tdc_const and can_tdc in
151	* include/linux/can/bittiming.h for further details.	151	* include/linux/can/bittiming.h for further details.

net/can/af_can.c+1−1

@@ -221,7 +221,7 @@ int can_send(struct sk_buff *skb, int loop) · 220 unmodified lines
221	}	221	}
222		222
223	/* Make sure the CAN frame can pass the selected CAN netdevice. */	223	/* Make sure the CAN frame can pass the selected CAN netdevice. */
224	if (unlikely(skb->len > skb->dev->mtu)) {	224	if (unlikely(skb->len > READ_ONCE(skb->dev->mtu))) {
225	err = -EMSGSIZE;	225	err = -EMSGSIZE;
226	goto inval_skb;	226	goto inval_skb;
227	}	227	}

net/can/isotp.c+1−1

@@ -1313,7 +1313,7 @@ static int isotp_bind(struct socket sock, struct sockaddr uaddr, int len) · 1312 unmodified lines
1313	err = -ENODEV;	1313	err = -ENODEV;
1314	goto out;	1314	goto out;
1315	}	1315	}
1316	if (dev->mtu < so->ll.mtu) {	1316	if (READ_ONCE(dev->mtu) < so->ll.mtu) {
1317	dev_put(dev);	1317	dev_put(dev);
1318	err = -EINVAL;	1318	err = -EINVAL;
1319	goto out;	1319	goto out;

net/can/raw.c+39−28

  */
 struct uniqframe {
-	int skbcnt;
 	const struct sk_buff *skb;
+	int skbcnt;
 	unsigned int join_rx_count;
 };
 struct raw_sock {
 	struct sock sk;
-	int bound;
-	int ifindex;
 	struct net_device *dev;
 	netdevice_tracker dev_tracker;
 	struct list_head notifier;
-	int loopback;
+	int ifindex;
-	int recv_own_msgs;
+	unsigned int bound:1;
-	int fd_frames;
+	unsigned int loopback:1;
-	int xl_frames;
+	unsigned int recv_own_msgs:1;
+	unsigned int fd_frames:1;
+	unsigned int xl_frames:1;
+	unsigned int join_filters:1;
 	struct can_raw_vcid_options raw_vcid_opts;
 	canid_t tx_vcid_shifted;
 	canid_t rx_vcid_shifted;
 	canid_t rx_vcid_mask_shifted;
-	int join_filters;
+	can_err_mask_t err_mask;
 	int count;                 /* number of active filters */
 	struct can_filter dfilter; /* default/single filter */
 	struct can_filter *filter; /* pointer to filter(s) */
-	can_err_mask_t err_mask;
 	struct uniqframe __percpu *uniq;
 };
 	struct can_filter sfilter;         /* single filter */
 	struct net_device *dev = NULL;
 	can_err_mask_t err_mask = 0;
-	int fd_frames;
 	int count = 0;
+	int flag;
 	int err = 0;
 	if (level != SOL_CAN_RAW)
 		break;
 	case CAN_RAW_LOOPBACK:
-		if (optlen != sizeof(ro->loopback))
+		if (optlen != sizeof(flag))
 			return -EINVAL;
-		if (copy_from_sockptr(&ro->loopback, optval, optlen))
+		if (copy_from_sockptr(&flag, optval, optlen))
 			return -EFAULT;
+		ro->loopback = !!flag;
 		break;
 	case CAN_RAW_RECV_OWN_MSGS:
-		if (optlen != sizeof(ro->recv_own_msgs))
+		if (optlen != sizeof(flag))
 			return -EINVAL;
-		if (copy_from_sockptr(&ro->recv_own_msgs, optval, optlen))
+		if (copy_from_sockptr(&flag, optval, optlen))
 			return -EFAULT;
+		ro->recv_own_msgs = !!flag;
 		break;
 	case CAN_RAW_FD_FRAMES:
-		if (optlen != sizeof(fd_frames))
+		if (optlen != sizeof(flag))
 			return -EINVAL;
-		if (copy_from_sockptr(&fd_frames, optval, optlen))
+		if (copy_from_sockptr(&flag, optval, optlen))
 			return -EFAULT;
 		/* Enabling CAN XL includes CAN FD */
-		if (ro->xl_frames && !fd_frames)
+		if (ro->xl_frames && !flag)
 			return -EINVAL;
-		ro->fd_frames = fd_frames;
+		ro->fd_frames = !!flag;
 		break;
 	case CAN_RAW_XL_FRAMES:
-		if (optlen != sizeof(ro->xl_frames))
+		if (optlen != sizeof(flag))
 			return -EINVAL;
-		if (copy_from_sockptr(&ro->xl_frames, optval, optlen))
+		if (copy_from_sockptr(&flag, optval, optlen))
 			return -EFAULT;
+		ro->xl_frames = !!flag;
 		/* Enabling CAN XL includes CAN FD */
 		if (ro->xl_frames)
 			ro->fd_frames = ro->xl_frames;
 		break;
 	case CAN_RAW_JOIN_FILTERS:
-		if (optlen != sizeof(ro->join_filters))
+		if (optlen != sizeof(flag))
 			return -EINVAL;
-		if (copy_from_sockptr(&ro->join_filters, optval, optlen))
+		if (copy_from_sockptr(&flag, optval, optlen))
 			return -EFAULT;
+		ro->join_filters = !!flag;
 		break;
 	default:
 {
 	struct sock *sk = sock->sk;
 	struct raw_sock *ro = raw_sk(sk);
+	int flag;
 	int len;
 	void *val;
 	case CAN_RAW_LOOPBACK:
 		if (len > sizeof(int))
 			len = sizeof(int);
-		val = &ro->loopback;
+		flag = ro->loopback;
+		val = &flag;
 		break;
 	case CAN_RAW_RECV_OWN_MSGS:
 		if (len > sizeof(int))
 			len = sizeof(int);
-		val = &ro->recv_own_msgs;
+		flag = ro->recv_own_msgs;
+		val = &flag;
 		break;
 	case CAN_RAW_FD_FRAMES:
 		if (len > sizeof(int))
 			len = sizeof(int);
-		val = &ro->fd_frames;
+		flag = ro->fd_frames;
+		val = &flag;
 		break;
 	case CAN_RAW_XL_FRAMES:
 		if (len > sizeof(int))
 			len = sizeof(int);
-		val = &ro->xl_frames;
+		flag = ro->xl_frames;
+		val = &flag;
 		break;
 	case CAN_RAW_XL_VCID_OPTS: {
 	case CAN_RAW_JOIN_FILTERS:
 		if (len > sizeof(int))
 			len = sizeof(int);
-		val = &ro->join_filters;
+		flag = ro->join_filters;
+		val = &flag;
 		break;
 	default:
 	err = -EINVAL;
 	/* check for valid CAN (CC/FD/XL) frame content */
-	txmtu = raw_check_txframe(ro, skb, dev->mtu);
+	txmtu = raw_check_txframe(ro, skb, READ_ONCE(dev->mtu));
 	if (!txmtu)
 		goto free_skb;

Merge tag 'linux-can-next-for-6.18-20250924' of git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can-next

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code