xref: /linux/drivers/net/can/dev/netlink.c (revision ab431bc39741e9d9bd3102688439e1864c857a74)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix
3  * Copyright (C) 2006 Andrey Volkov, Varma Electronics
4  * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>
5  * Copyright (C) 2021 Vincent Mailhol <mailhol.vincent@wanadoo.fr>
6  */
7 
8 #include <linux/can/dev.h>
9 #include <net/rtnetlink.h>
10 
11 static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = {
12 	[IFLA_CAN_STATE] = { .type = NLA_U32 },
13 	[IFLA_CAN_CTRLMODE] = { .len = sizeof(struct can_ctrlmode) },
14 	[IFLA_CAN_RESTART_MS] = { .type = NLA_U32 },
15 	[IFLA_CAN_RESTART] = { .type = NLA_U32 },
16 	[IFLA_CAN_BITTIMING] = { .len = sizeof(struct can_bittiming) },
17 	[IFLA_CAN_BITTIMING_CONST] = { .len = sizeof(struct can_bittiming_const) },
18 	[IFLA_CAN_CLOCK] = { .len = sizeof(struct can_clock) },
19 	[IFLA_CAN_BERR_COUNTER] = { .len = sizeof(struct can_berr_counter) },
20 	[IFLA_CAN_DATA_BITTIMING] = { .len = sizeof(struct can_bittiming) },
21 	[IFLA_CAN_DATA_BITTIMING_CONST] = { .len = sizeof(struct can_bittiming_const) },
22 	[IFLA_CAN_TERMINATION] = { .type = NLA_U16 },
23 	[IFLA_CAN_TDC] = { .type = NLA_NESTED },
24 	[IFLA_CAN_CTRLMODE_EXT] = { .type = NLA_NESTED },
25 };
26 
27 static const struct nla_policy can_tdc_policy[IFLA_CAN_TDC_MAX + 1] = {
28 	[IFLA_CAN_TDC_TDCV_MIN] = { .type = NLA_U32 },
29 	[IFLA_CAN_TDC_TDCV_MAX] = { .type = NLA_U32 },
30 	[IFLA_CAN_TDC_TDCO_MIN] = { .type = NLA_U32 },
31 	[IFLA_CAN_TDC_TDCO_MAX] = { .type = NLA_U32 },
32 	[IFLA_CAN_TDC_TDCF_MIN] = { .type = NLA_U32 },
33 	[IFLA_CAN_TDC_TDCF_MAX] = { .type = NLA_U32 },
34 	[IFLA_CAN_TDC_TDCV] = { .type = NLA_U32 },
35 	[IFLA_CAN_TDC_TDCO] = { .type = NLA_U32 },
36 	[IFLA_CAN_TDC_TDCF] = { .type = NLA_U32 },
37 };
38 
can_validate_bittiming(struct nlattr * data[],struct netlink_ext_ack * extack,int ifla_can_bittiming)39 static int can_validate_bittiming(struct nlattr *data[],
40 				  struct netlink_ext_ack *extack,
41 				  int ifla_can_bittiming)
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 
51 	/* sample point is in one-tenth of a percent */
52 	if (bt->sample_point >= 1000) {
53 		NL_SET_ERR_MSG(extack, "sample point must be between 0 and 100%");
54 		return -EINVAL;
55 	}
56 
57 	return 0;
58 }
59 
can_validate_tdc(struct nlattr * data_tdc,struct netlink_ext_ack * extack,u32 tdc_flags)60 static int can_validate_tdc(struct nlattr *data_tdc,
61 			    struct netlink_ext_ack *extack, u32 tdc_flags)
62 {
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 
can_validate_databittiming(struct nlattr * data[],struct netlink_ext_ack * extack,int ifla_can_data_bittiming,u32 flags)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;
127 	int err;
128 
129 	/* Make sure that valid CAN FD configurations always consist of
130 	 * - nominal/arbitration bittiming
131 	 * - data bittiming
132 	 * - control mode with CAN_CTRLMODE_FD set
133 	 * - TDC parameters are coherent (details in can_validate_tdc())
134 	 */
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 
can_validate(struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)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 
184 	if (!data)
185 		return 0;
186 
187 	if (data[IFLA_CAN_CTRLMODE]) {
188 		struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
189 
190 		flags = cm->flags & cm->mask;
191 	}
192 
193 	err = can_validate_bittiming(data, extack, IFLA_CAN_BITTIMING);
194 	if (err)
195 		return err;
196 
197 	err = can_validate_databittiming(data, extack,
198 					 IFLA_CAN_DATA_BITTIMING, flags);
199 	if (err)
200 		return err;
201 
202 	return 0;
203 }
204 
can_ctrlmode_changelink(struct net_device * dev,struct nlattr * data[],struct netlink_ext_ack * extack)205 static int can_ctrlmode_changelink(struct net_device *dev,
206 				   struct nlattr *data[],
207 				   struct netlink_ext_ack *extack)
208 {
209 	struct can_priv *priv = netdev_priv(dev);
210 	struct can_ctrlmode *cm;
211 	u32 ctrlstatic, maskedflags, notsupp, ctrlstatic_missing;
212 
213 	if (!data[IFLA_CAN_CTRLMODE])
214 		return 0;
215 
216 	/* Do not allow changing controller mode while running */
217 	if (dev->flags & IFF_UP)
218 		return -EBUSY;
219 
220 	cm = nla_data(data[IFLA_CAN_CTRLMODE]);
221 	ctrlstatic = can_get_static_ctrlmode(priv);
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;
231 	}
232 
233 	/* do not check for static fd-non-iso if 'fd' is disabled */
234 	if (!(maskedflags & CAN_CTRLMODE_FD))
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;
242 	}
243 
244 	/* If a top dependency flag is provided, reset all its dependencies */
245 	if (cm->mask & CAN_CTRLMODE_FD)
246 		priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
247 
248 	/* clear bits to be modified and copy the flag values */
249 	priv->ctrlmode &= ~cm->mask;
250 	priv->ctrlmode |= maskedflags;
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));
258 	}
259 
260 	can_set_default_mtu(dev);
261 
262 	return 0;
263 }
264 
can_tdc_changelink(struct data_bittiming_params * dbt_params,const struct nlattr * nla,struct netlink_ext_ack * extack)265 static int can_tdc_changelink(struct data_bittiming_params *dbt_params,
266 			      const struct nlattr *nla,
267 			      struct netlink_ext_ack *extack)
268 {
269 	struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
270 	struct can_tdc tdc = { 0 };
271 	const struct can_tdc_const *tdc_const = dbt_params->tdc_const;
272 	int err;
273 
274 	if (!tdc_const) {
275 		NL_SET_ERR_MSG(extack, "The device does not support TDC");
276 		return -EOPNOTSUPP;
277 	}
278 
279 	err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, nla,
280 			       can_tdc_policy, extack);
281 	if (err)
282 		return err;
283 
284 	if (tb_tdc[IFLA_CAN_TDC_TDCV]) {
285 		u32 tdcv = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCV]);
286 
287 		if (tdcv < tdc_const->tdcv_min || tdcv > tdc_const->tdcv_max)
288 			return -EINVAL;
289 
290 		tdc.tdcv = tdcv;
291 	}
292 
293 	if (tb_tdc[IFLA_CAN_TDC_TDCO]) {
294 		u32 tdco = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCO]);
295 
296 		if (tdco < tdc_const->tdco_min || tdco > tdc_const->tdco_max)
297 			return -EINVAL;
298 
299 		tdc.tdco = tdco;
300 	}
301 
302 	if (tb_tdc[IFLA_CAN_TDC_TDCF]) {
303 		u32 tdcf = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCF]);
304 
305 		if (tdcf < tdc_const->tdcf_min || tdcf > tdc_const->tdcf_max)
306 			return -EINVAL;
307 
308 		tdc.tdcf = tdcf;
309 	}
310 
311 	dbt_params->tdc = tdc;
312 
313 	return 0;
314 }
315 
can_dbt_changelink(struct net_device * dev,struct nlattr * data[],bool fd,struct netlink_ext_ack * extack)316 static int can_dbt_changelink(struct net_device *dev, struct nlattr *data[],
317 			      bool fd, struct netlink_ext_ack *extack)
318 {
319 	struct nlattr *data_bittiming, *data_tdc;
320 	struct can_priv *priv = netdev_priv(dev);
321 	struct data_bittiming_params *dbt_params;
322 	struct can_bittiming dbt;
323 	bool need_tdc_calc = false;
324 	u32 tdc_mask;
325 	int err;
326 
327 	if (fd) {
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 	}
335 
336 	if (!data_bittiming)
337 		return 0;
338 
339 	/* Do not allow changing bittiming while running */
340 	if (dev->flags & IFF_UP)
341 		return -EBUSY;
342 
343 	/* Calculate bittiming parameters based on data_bittiming_const
344 	 * if set, otherwise pass bitrate directly via do_set_bitrate().
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;
350 
351 	memcpy(&dbt, nla_data(data_bittiming), sizeof(dbt));
352 	err = can_get_bittiming(dev, &dbt, dbt_params->data_bittiming_const,
353 				dbt_params->data_bitrate_const,
354 				dbt_params->data_bitrate_const_cnt, extack);
355 	if (err)
356 		return err;
357 
358 	if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
359 		NL_SET_ERR_MSG_FMT(extack,
360 				   "CAN data bitrate %u bps surpasses transceiver capabilities of %u bps",
361 				   dbt.bitrate, priv->bitrate_max);
362 		return -EINVAL;
363 	}
364 
365 	memset(&dbt_params->tdc, 0, sizeof(dbt_params->tdc));
366 	if (data[IFLA_CAN_CTRLMODE]) {
367 		struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
368 
369 		need_tdc_calc = !(cm->mask & tdc_mask);
370 	}
371 	if (data_tdc) {
372 		/* TDC parameters are provided: use them */
373 		err = can_tdc_changelink(dbt_params, data_tdc, extack);
374 		if (err) {
375 			priv->ctrlmode &= ~tdc_mask;
376 			return err;
377 		}
378 	} else if (need_tdc_calc) {
379 		/* Neither of TDC parameters nor TDC flags are provided:
380 		 * do calculation
381 		 */
382 		can_calc_tdco(&dbt_params->tdc, dbt_params->tdc_const, &dbt,
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;
395 	}
396 
397 	return 0;
398 }
399 
can_changelink(struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)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 
412 	if (data[IFLA_CAN_BITTIMING]) {
413 		struct can_bittiming bt;
414 
415 		/* Do not allow changing bittiming while running */
416 		if (dev->flags & IFF_UP)
417 			return -EBUSY;
418 
419 		/* Calculate bittiming parameters based on
420 		 * bittiming_const if set, otherwise pass bitrate
421 		 * directly via do_set_bitrate(). Bail out if neither
422 		 * is given.
423 		 */
424 		if (!priv->bittiming_const && !priv->do_set_bittiming &&
425 		    !priv->bitrate_const)
426 			return -EOPNOTSUPP;
427 
428 		memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
429 		err = can_get_bittiming(dev, &bt,
430 					priv->bittiming_const,
431 					priv->bitrate_const,
432 					priv->bitrate_const_cnt,
433 					extack);
434 		if (err)
435 			return err;
436 
437 		if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) {
438 			NL_SET_ERR_MSG_FMT(extack,
439 					   "arbitration bitrate %u bps surpasses transceiver capabilities of %u bps",
440 					   bt.bitrate, priv->bitrate_max);
441 			return -EINVAL;
442 		}
443 
444 		memcpy(&priv->bittiming, &bt, sizeof(bt));
445 
446 		if (priv->do_set_bittiming) {
447 			/* Finally, set the bit-timing registers */
448 			err = priv->do_set_bittiming(dev);
449 			if (err)
450 				return err;
451 		}
452 	}
453 
454 	if (data[IFLA_CAN_RESTART_MS]) {
455 		unsigned int restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);
456 
457 		if (restart_ms != 0 && !priv->do_set_mode) {
458 			NL_SET_ERR_MSG(extack,
459 				       "Device doesn't support restart from Bus Off");
460 			return -EOPNOTSUPP;
461 		}
462 
463 		/* Do not allow changing restart delay while running */
464 		if (dev->flags & IFF_UP)
465 			return -EBUSY;
466 		priv->restart_ms = restart_ms;
467 	}
468 
469 	if (data[IFLA_CAN_RESTART]) {
470 		if (!priv->do_set_mode) {
471 			NL_SET_ERR_MSG(extack,
472 				       "Device doesn't support restart from Bus Off");
473 			return -EOPNOTSUPP;
474 		}
475 
476 		/* Do not allow a restart while not running */
477 		if (!(dev->flags & IFF_UP))
478 			return -EINVAL;
479 		err = can_restart_now(dev);
480 		if (err)
481 			return err;
482 	}
483 
484 	/* CAN FD */
485 	err = can_dbt_changelink(dev, data, true, extack);
486 	if (err)
487 		return err;
488 
489 	if (data[IFLA_CAN_TERMINATION]) {
490 		const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]);
491 		const unsigned int num_term = priv->termination_const_cnt;
492 		unsigned int i;
493 
494 		if (!priv->do_set_termination) {
495 			NL_SET_ERR_MSG(extack,
496 				       "Termination is not configurable on this device");
497 			return -EOPNOTSUPP;
498 		}
499 
500 		/* check whether given value is supported by the interface */
501 		for (i = 0; i < num_term; i++) {
502 			if (termval == priv->termination_const[i])
503 				break;
504 		}
505 		if (i >= num_term)
506 			return -EINVAL;
507 
508 		/* Finally, set the termination value */
509 		err = priv->do_set_termination(dev, termval);
510 		if (err)
511 			return err;
512 
513 		priv->termination = termval;
514 	}
515 
516 	return 0;
517 }
518 
can_tdc_get_size(struct data_bittiming_params * dbt_params,u32 tdc_flags)519 static size_t can_tdc_get_size(struct data_bittiming_params *dbt_params,
520 			       u32 tdc_flags)
521 {
522 	bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK;
523 	size_t size;
524 
525 	if (!dbt_params->tdc_const)
526 		return 0;
527 
528 	size = nla_total_size(0);			/* nest IFLA_CAN_TDC */
529 	if (tdc_manual) {
530 		size += nla_total_size(sizeof(u32));	/* IFLA_CAN_TDCV_MIN */
531 		size += nla_total_size(sizeof(u32));	/* IFLA_CAN_TDCV_MAX */
532 	}
533 	size += nla_total_size(sizeof(u32));		/* IFLA_CAN_TDCO_MIN */
534 	size += nla_total_size(sizeof(u32));		/* IFLA_CAN_TDCO_MAX */
535 	if (dbt_params->tdc_const->tdcf_max) {
536 		size += nla_total_size(sizeof(u32));	/* IFLA_CAN_TDCF_MIN */
537 		size += nla_total_size(sizeof(u32));	/* IFLA_CAN_TDCF_MAX */
538 	}
539 
540 	if (tdc_flags) {
541 		if (tdc_manual || dbt_params->do_get_auto_tdcv)
542 			size += nla_total_size(sizeof(u32));	/* IFLA_CAN_TDCV */
543 		size += nla_total_size(sizeof(u32));		/* IFLA_CAN_TDCO */
544 		if (dbt_params->tdc_const->tdcf_max)
545 			size += nla_total_size(sizeof(u32));	/* IFLA_CAN_TDCF */
546 	}
547 
548 	return size;
549 }
550 
can_data_bittiming_get_size(struct data_bittiming_params * dbt_params,u32 tdc_flags)551 static size_t can_data_bittiming_get_size(struct data_bittiming_params *dbt_params,
552 					  u32 tdc_flags)
553 {
554 	size_t size = 0;
555 
556 	if (dbt_params->data_bittiming.bitrate)		/* IFLA_CAN_DATA_BITTIMING */
557 		size += nla_total_size(sizeof(dbt_params->data_bittiming));
558 	if (dbt_params->data_bittiming_const)		/* IFLA_CAN_DATA_BITTIMING_CONST */
559 		size += nla_total_size(sizeof(*dbt_params->data_bittiming_const));
560 	if (dbt_params->data_bitrate_const)		/* IFLA_CAN_DATA_BITRATE_CONST */
561 		size += nla_total_size(sizeof(*dbt_params->data_bitrate_const) *
562 				       dbt_params->data_bitrate_const_cnt);
563 	size += can_tdc_get_size(dbt_params, tdc_flags);/* IFLA_CAN_TDC */
564 
565 	return size;
566 }
567 
can_ctrlmode_ext_get_size(void)568 static size_t can_ctrlmode_ext_get_size(void)
569 {
570 	return nla_total_size(0) +		/* nest IFLA_CAN_CTRLMODE_EXT */
571 		nla_total_size(sizeof(u32));	/* IFLA_CAN_CTRLMODE_SUPPORTED */
572 }
573 
can_get_size(const struct net_device * dev)574 static size_t can_get_size(const struct net_device *dev)
575 {
576 	struct can_priv *priv = netdev_priv(dev);
577 	size_t size = 0;
578 
579 	if (priv->bittiming.bitrate)				/* IFLA_CAN_BITTIMING */
580 		size += nla_total_size(sizeof(struct can_bittiming));
581 	if (priv->bittiming_const)				/* IFLA_CAN_BITTIMING_CONST */
582 		size += nla_total_size(sizeof(struct can_bittiming_const));
583 	size += nla_total_size(sizeof(struct can_clock));	/* IFLA_CAN_CLOCK */
584 	size += nla_total_size(sizeof(u32));			/* IFLA_CAN_STATE */
585 	size += nla_total_size(sizeof(struct can_ctrlmode));	/* IFLA_CAN_CTRLMODE */
586 	size += nla_total_size(sizeof(u32));			/* IFLA_CAN_RESTART_MS */
587 	if (priv->do_get_berr_counter)				/* IFLA_CAN_BERR_COUNTER */
588 		size += nla_total_size(sizeof(struct can_berr_counter));
589 	if (priv->termination_const) {
590 		size += nla_total_size(sizeof(priv->termination));		/* IFLA_CAN_TERMINATION */
591 		size += nla_total_size(sizeof(*priv->termination_const) *	/* IFLA_CAN_TERMINATION_CONST */
592 				       priv->termination_const_cnt);
593 	}
594 	if (priv->bitrate_const)				/* IFLA_CAN_BITRATE_CONST */
595 		size += nla_total_size(sizeof(*priv->bitrate_const) *
596 				       priv->bitrate_const_cnt);
597 	size += sizeof(priv->bitrate_max);			/* IFLA_CAN_BITRATE_MAX */
598 	size += can_ctrlmode_ext_get_size();			/* IFLA_CAN_CTRLMODE_EXT */
599 
600 	size += can_data_bittiming_get_size(&priv->fd,
601 					    priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK);
602 
603 	return size;
604 }
605 
can_bittiming_fill_info(struct sk_buff * skb,int ifla_can_bittiming,struct can_bittiming * bittiming)606 static int can_bittiming_fill_info(struct sk_buff *skb, int ifla_can_bittiming,
607 				   struct can_bittiming *bittiming)
608 {
609 	return bittiming->bitrate != CAN_BITRATE_UNSET &&
610 		bittiming->bitrate != CAN_BITRATE_UNKNOWN &&
611 		nla_put(skb, ifla_can_bittiming, sizeof(*bittiming), bittiming);
612 }
613 
can_bittiming_const_fill_info(struct sk_buff * skb,int ifla_can_bittiming_const,const struct can_bittiming_const * bittiming_const)614 static int can_bittiming_const_fill_info(struct sk_buff *skb,
615 					 int ifla_can_bittiming_const,
616 					 const struct can_bittiming_const *bittiming_const)
617 {
618 	return bittiming_const &&
619 		nla_put(skb, ifla_can_bittiming_const,
620 			sizeof(*bittiming_const), bittiming_const);
621 }
622 
can_bitrate_const_fill_info(struct sk_buff * skb,int ifla_can_bitrate_const,const u32 * bitrate_const,unsigned int cnt)623 static int can_bitrate_const_fill_info(struct sk_buff *skb,
624 				       int ifla_can_bitrate_const,
625 				       const u32 *bitrate_const, unsigned int cnt)
626 {
627 	return bitrate_const &&
628 		nla_put(skb, ifla_can_bitrate_const,
629 			sizeof(*bitrate_const) * cnt, bitrate_const);
630 }
631 
can_tdc_fill_info(struct sk_buff * skb,const struct net_device * dev,int ifla_can_tdc)632 static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev,
633 			     int ifla_can_tdc)
634 {
635 	struct can_priv *priv = netdev_priv(dev);
636 	struct data_bittiming_params *dbt_params;
637 	const struct can_tdc_const *tdc_const;
638 	struct can_tdc *tdc;
639 	struct nlattr *nest;
640 	bool tdc_is_enabled, tdc_manual;
641 
642 	if (ifla_can_tdc == IFLA_CAN_TDC) {
643 		dbt_params = &priv->fd;
644 		tdc_is_enabled = can_fd_tdc_is_enabled(priv);
645 		tdc_manual = priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL;
646 	} else {
647 		return -EOPNOTSUPP; /* Place holder for CAN XL */
648 	}
649 	tdc_const = dbt_params->tdc_const;
650 	tdc = &dbt_params->tdc;
651 
652 	if (!tdc_const)
653 		return 0;
654 
655 	nest = nla_nest_start(skb, ifla_can_tdc);
656 	if (!nest)
657 		return -EMSGSIZE;
658 
659 	if (tdc_manual &&
660 	    (nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MIN, tdc_const->tdcv_min) ||
661 	     nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MAX, tdc_const->tdcv_max)))
662 		goto err_cancel;
663 	if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MIN, tdc_const->tdco_min) ||
664 	    nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MAX, tdc_const->tdco_max))
665 		goto err_cancel;
666 	if (tdc_const->tdcf_max &&
667 	    (nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MIN, tdc_const->tdcf_min) ||
668 	     nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max)))
669 		goto err_cancel;
670 
671 	if (tdc_is_enabled) {
672 		u32 tdcv;
673 		int err = -EINVAL;
674 
675 		if (tdc_manual) {
676 			tdcv = tdc->tdcv;
677 			err = 0;
678 		} else if (dbt_params->do_get_auto_tdcv) {
679 			err = dbt_params->do_get_auto_tdcv(dev, &tdcv);
680 		}
681 		if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv))
682 			goto err_cancel;
683 		if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO, tdc->tdco))
684 			goto err_cancel;
685 		if (tdc_const->tdcf_max &&
686 		    nla_put_u32(skb, IFLA_CAN_TDC_TDCF, tdc->tdcf))
687 			goto err_cancel;
688 	}
689 
690 	nla_nest_end(skb, nest);
691 	return 0;
692 
693 err_cancel:
694 	nla_nest_cancel(skb, nest);
695 	return -EMSGSIZE;
696 }
697 
can_ctrlmode_ext_fill_info(struct sk_buff * skb,const struct can_priv * priv)698 static int can_ctrlmode_ext_fill_info(struct sk_buff *skb,
699 				      const struct can_priv *priv)
700 {
701 	struct nlattr *nest;
702 
703 	nest = nla_nest_start(skb, IFLA_CAN_CTRLMODE_EXT);
704 	if (!nest)
705 		return -EMSGSIZE;
706 
707 	if (nla_put_u32(skb, IFLA_CAN_CTRLMODE_SUPPORTED,
708 			priv->ctrlmode_supported)) {
709 		nla_nest_cancel(skb, nest);
710 		return -EMSGSIZE;
711 	}
712 
713 	nla_nest_end(skb, nest);
714 	return 0;
715 }
716 
can_fill_info(struct sk_buff * skb,const struct net_device * dev)717 static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
718 {
719 	struct can_priv *priv = netdev_priv(dev);
720 	struct can_ctrlmode cm = {.flags = priv->ctrlmode};
721 	struct can_berr_counter bec = { };
722 	enum can_state state = priv->state;
723 
724 	if (priv->do_get_state)
725 		priv->do_get_state(dev, &state);
726 
727 	if (can_bittiming_fill_info(skb, IFLA_CAN_BITTIMING,
728 				    &priv->bittiming) ||
729 
730 	    can_bittiming_const_fill_info(skb, IFLA_CAN_BITTIMING_CONST,
731 					  priv->bittiming_const) ||
732 
733 	    nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) ||
734 	    nla_put_u32(skb, IFLA_CAN_STATE, state) ||
735 	    nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) ||
736 	    nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) ||
737 
738 	    (priv->do_get_berr_counter &&
739 	     !priv->do_get_berr_counter(dev, &bec) &&
740 	     nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||
741 
742 	    can_bittiming_fill_info(skb, IFLA_CAN_DATA_BITTIMING,
743 				    &priv->fd.data_bittiming) ||
744 
745 	    can_bittiming_const_fill_info(skb, IFLA_CAN_DATA_BITTIMING_CONST,
746 					  priv->fd.data_bittiming_const) ||
747 
748 	    (priv->termination_const &&
749 	     (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) ||
750 	      nla_put(skb, IFLA_CAN_TERMINATION_CONST,
751 		      sizeof(*priv->termination_const) *
752 		      priv->termination_const_cnt,
753 		      priv->termination_const))) ||
754 
755 	    can_bitrate_const_fill_info(skb, IFLA_CAN_BITRATE_CONST,
756 					priv->bitrate_const,
757 					priv->bitrate_const_cnt) ||
758 
759 	    can_bitrate_const_fill_info(skb, IFLA_CAN_DATA_BITRATE_CONST,
760 					priv->fd.data_bitrate_const,
761 					priv->fd.data_bitrate_const_cnt) ||
762 
763 	    (nla_put(skb, IFLA_CAN_BITRATE_MAX,
764 		     sizeof(priv->bitrate_max),
765 		     &priv->bitrate_max)) ||
766 
767 	    can_tdc_fill_info(skb, dev, IFLA_CAN_TDC) ||
768 
769 	    can_ctrlmode_ext_fill_info(skb, priv)
770 	    )
771 
772 		return -EMSGSIZE;
773 
774 	return 0;
775 }
776 
can_get_xstats_size(const struct net_device * dev)777 static size_t can_get_xstats_size(const struct net_device *dev)
778 {
779 	return sizeof(struct can_device_stats);
780 }
781 
can_fill_xstats(struct sk_buff * skb,const struct net_device * dev)782 static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)
783 {
784 	struct can_priv *priv = netdev_priv(dev);
785 
786 	if (nla_put(skb, IFLA_INFO_XSTATS,
787 		    sizeof(priv->can_stats), &priv->can_stats))
788 		goto nla_put_failure;
789 	return 0;
790 
791 nla_put_failure:
792 	return -EMSGSIZE;
793 }
794 
can_newlink(struct net_device * dev,struct rtnl_newlink_params * params,struct netlink_ext_ack * extack)795 static int can_newlink(struct net_device *dev,
796 		       struct rtnl_newlink_params *params,
797 		       struct netlink_ext_ack *extack)
798 {
799 	return -EOPNOTSUPP;
800 }
801 
can_dellink(struct net_device * dev,struct list_head * head)802 static void can_dellink(struct net_device *dev, struct list_head *head)
803 {
804 }
805 
806 struct rtnl_link_ops can_link_ops __read_mostly = {
807 	.kind		= "can",
808 	.netns_refund	= true,
809 	.maxtype	= IFLA_CAN_MAX,
810 	.policy		= can_policy,
811 	.setup		= can_setup,
812 	.validate	= can_validate,
813 	.newlink	= can_newlink,
814 	.changelink	= can_changelink,
815 	.dellink	= can_dellink,
816 	.get_size	= can_get_size,
817 	.fill_info	= can_fill_info,
818 	.get_xstats_size = can_get_xstats_size,
819 	.fill_xstats	= can_fill_xstats,
820 };
821 
can_netlink_register(void)822 int can_netlink_register(void)
823 {
824 	return rtnl_link_register(&can_link_ops);
825 }
826 
can_netlink_unregister(void)827 void can_netlink_unregister(void)
828 {
829 	rtnl_link_unregister(&can_link_ops);
830 }
831