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