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(const struct can_bittiming * bt,struct netlink_ext_ack * extack)39 static int can_validate_bittiming(const struct can_bittiming *bt,
40 struct netlink_ext_ack *extack)
41 {
42 /* sample point is in one-tenth of a percent */
43 if (bt->sample_point >= 1000) {
44 NL_SET_ERR_MSG(extack, "sample point must be between 0 and 100%");
45
46 return -EINVAL;
47 }
48
49 return 0;
50 }
51
can_validate(struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)52 static int can_validate(struct nlattr *tb[], struct nlattr *data[],
53 struct netlink_ext_ack *extack)
54 {
55 bool is_can_fd = false;
56 int err;
57
58 /* Make sure that valid CAN FD configurations always consist of
59 * - nominal/arbitration bittiming
60 * - data bittiming
61 * - control mode with CAN_CTRLMODE_FD set
62 * - TDC parameters are coherent (details below)
63 */
64
65 if (!data)
66 return 0;
67
68 if (data[IFLA_CAN_CTRLMODE]) {
69 struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
70 u32 tdc_flags = cm->flags & CAN_CTRLMODE_FD_TDC_MASK;
71
72 is_can_fd = cm->flags & cm->mask & CAN_CTRLMODE_FD;
73
74 /* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually exclusive */
75 if (tdc_flags == CAN_CTRLMODE_FD_TDC_MASK)
76 return -EOPNOTSUPP;
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
89 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX,
90 data[IFLA_CAN_TDC],
91 can_tdc_policy, extack);
92 if (err)
93 return err;
94
95 if (tb_tdc[IFLA_CAN_TDC_TDCV]) {
96 if (tdc_flags & CAN_CTRLMODE_TDC_AUTO)
97 return -EOPNOTSUPP;
98 } else {
99 if (tdc_flags & CAN_CTRLMODE_TDC_MANUAL)
100 return -EOPNOTSUPP;
101 }
102
103 if (!tb_tdc[IFLA_CAN_TDC_TDCO])
104 return -EOPNOTSUPP;
105 }
106 }
107
108 if (data[IFLA_CAN_BITTIMING]) {
109 struct can_bittiming bt;
110
111 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
112 err = can_validate_bittiming(&bt, extack);
113 if (err)
114 return err;
115 }
116
117 if (is_can_fd) {
118 if (!data[IFLA_CAN_BITTIMING] || !data[IFLA_CAN_DATA_BITTIMING])
119 return -EOPNOTSUPP;
120 }
121
122 if (data[IFLA_CAN_DATA_BITTIMING] || data[IFLA_CAN_TDC]) {
123 if (!is_can_fd)
124 return -EOPNOTSUPP;
125 }
126
127 if (data[IFLA_CAN_DATA_BITTIMING]) {
128 struct can_bittiming bt;
129
130 memcpy(&bt, nla_data(data[IFLA_CAN_DATA_BITTIMING]), sizeof(bt));
131 err = can_validate_bittiming(&bt, extack);
132 if (err)
133 return err;
134 }
135
136 return 0;
137 }
138
can_tdc_changelink(struct can_priv * priv,const struct nlattr * nla,struct netlink_ext_ack * extack)139 static int can_tdc_changelink(struct can_priv *priv, const struct nlattr *nla,
140 struct netlink_ext_ack *extack)
141 {
142 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
143 struct can_tdc tdc = { 0 };
144 const struct can_tdc_const *tdc_const = priv->fd.tdc_const;
145 int err;
146
147 if (!tdc_const || !can_fd_tdc_is_enabled(priv))
148 return -EOPNOTSUPP;
149
150 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, nla,
151 can_tdc_policy, extack);
152 if (err)
153 return err;
154
155 if (tb_tdc[IFLA_CAN_TDC_TDCV]) {
156 u32 tdcv = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCV]);
157
158 if (tdcv < tdc_const->tdcv_min || tdcv > tdc_const->tdcv_max)
159 return -EINVAL;
160
161 tdc.tdcv = tdcv;
162 }
163
164 if (tb_tdc[IFLA_CAN_TDC_TDCO]) {
165 u32 tdco = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCO]);
166
167 if (tdco < tdc_const->tdco_min || tdco > tdc_const->tdco_max)
168 return -EINVAL;
169
170 tdc.tdco = tdco;
171 }
172
173 if (tb_tdc[IFLA_CAN_TDC_TDCF]) {
174 u32 tdcf = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCF]);
175
176 if (tdcf < tdc_const->tdcf_min || tdcf > tdc_const->tdcf_max)
177 return -EINVAL;
178
179 tdc.tdcf = tdcf;
180 }
181
182 priv->fd.tdc = tdc;
183
184 return 0;
185 }
186
can_changelink(struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)187 static int can_changelink(struct net_device *dev, struct nlattr *tb[],
188 struct nlattr *data[],
189 struct netlink_ext_ack *extack)
190 {
191 struct can_priv *priv = netdev_priv(dev);
192 bool fd_tdc_flag_provided = false;
193 int err;
194
195 /* We need synchronization with dev->stop() */
196 ASSERT_RTNL();
197
198 if (data[IFLA_CAN_CTRLMODE]) {
199 struct can_ctrlmode *cm;
200 u32 ctrlstatic;
201 u32 maskedflags;
202
203 /* Do not allow changing controller mode while running */
204 if (dev->flags & IFF_UP)
205 return -EBUSY;
206 cm = nla_data(data[IFLA_CAN_CTRLMODE]);
207 ctrlstatic = can_get_static_ctrlmode(priv);
208 maskedflags = cm->flags & cm->mask;
209
210 /* check whether provided bits are allowed to be passed */
211 if (maskedflags & ~(priv->ctrlmode_supported | ctrlstatic))
212 return -EOPNOTSUPP;
213
214 /* do not check for static fd-non-iso if 'fd' is disabled */
215 if (!(maskedflags & CAN_CTRLMODE_FD))
216 ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO;
217
218 /* make sure static options are provided by configuration */
219 if ((maskedflags & ctrlstatic) != ctrlstatic)
220 return -EOPNOTSUPP;
221
222 /* clear bits to be modified and copy the flag values */
223 priv->ctrlmode &= ~cm->mask;
224 priv->ctrlmode |= maskedflags;
225
226 /* CAN_CTRLMODE_FD can only be set when driver supports FD */
227 if (priv->ctrlmode & CAN_CTRLMODE_FD) {
228 dev->mtu = CANFD_MTU;
229 } else {
230 dev->mtu = CAN_MTU;
231 memset(&priv->fd.data_bittiming, 0,
232 sizeof(priv->fd.data_bittiming));
233 priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
234 memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc));
235 }
236
237 fd_tdc_flag_provided = cm->mask & CAN_CTRLMODE_FD_TDC_MASK;
238 /* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually
239 * exclusive: make sure to turn the other one off
240 */
241 if (fd_tdc_flag_provided)
242 priv->ctrlmode &= cm->flags | ~CAN_CTRLMODE_FD_TDC_MASK;
243 }
244
245 if (data[IFLA_CAN_BITTIMING]) {
246 struct can_bittiming bt;
247
248 /* Do not allow changing bittiming while running */
249 if (dev->flags & IFF_UP)
250 return -EBUSY;
251
252 /* Calculate bittiming parameters based on
253 * bittiming_const if set, otherwise pass bitrate
254 * directly via do_set_bitrate(). Bail out if neither
255 * is given.
256 */
257 if (!priv->bittiming_const && !priv->do_set_bittiming &&
258 !priv->bitrate_const)
259 return -EOPNOTSUPP;
260
261 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
262 err = can_get_bittiming(dev, &bt,
263 priv->bittiming_const,
264 priv->bitrate_const,
265 priv->bitrate_const_cnt,
266 extack);
267 if (err)
268 return err;
269
270 if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) {
271 NL_SET_ERR_MSG_FMT(extack,
272 "arbitration bitrate %u bps surpasses transceiver capabilities of %u bps",
273 bt.bitrate, priv->bitrate_max);
274 return -EINVAL;
275 }
276
277 memcpy(&priv->bittiming, &bt, sizeof(bt));
278
279 if (priv->do_set_bittiming) {
280 /* Finally, set the bit-timing registers */
281 err = priv->do_set_bittiming(dev);
282 if (err)
283 return err;
284 }
285 }
286
287 if (data[IFLA_CAN_RESTART_MS]) {
288 if (!priv->do_set_mode) {
289 NL_SET_ERR_MSG(extack,
290 "Device doesn't support restart from Bus Off");
291 return -EOPNOTSUPP;
292 }
293
294 /* Do not allow changing restart delay while running */
295 if (dev->flags & IFF_UP)
296 return -EBUSY;
297 priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);
298 }
299
300 if (data[IFLA_CAN_RESTART]) {
301 if (!priv->do_set_mode) {
302 NL_SET_ERR_MSG(extack,
303 "Device doesn't support restart from Bus Off");
304 return -EOPNOTSUPP;
305 }
306
307 /* Do not allow a restart while not running */
308 if (!(dev->flags & IFF_UP))
309 return -EINVAL;
310 err = can_restart_now(dev);
311 if (err)
312 return err;
313 }
314
315 if (data[IFLA_CAN_DATA_BITTIMING]) {
316 struct can_bittiming dbt;
317
318 /* Do not allow changing bittiming while running */
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
377 if (data[IFLA_CAN_TERMINATION]) {
378 const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]);
379 const unsigned int num_term = priv->termination_const_cnt;
380 unsigned int i;
381
382 if (!priv->do_set_termination)
383 return -EOPNOTSUPP;
384
385 /* check whether given value is supported by the interface */
386 for (i = 0; i < num_term; i++) {
387 if (termval == priv->termination_const[i])
388 break;
389 }
390 if (i >= num_term)
391 return -EINVAL;
392
393 /* Finally, set the termination value */
394 err = priv->do_set_termination(dev, termval);
395 if (err)
396 return err;
397
398 priv->termination = termval;
399 }
400
401 return 0;
402 }
403
can_tdc_get_size(const struct net_device * dev)404 static size_t can_tdc_get_size(const struct net_device *dev)
405 {
406 struct can_priv *priv = netdev_priv(dev);
407 size_t size;
408
409 if (!priv->fd.tdc_const)
410 return 0;
411
412 size = nla_total_size(0); /* nest IFLA_CAN_TDC */
413 if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL) {
414 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MIN */
415 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MAX */
416 }
417 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */
418 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */
419 if (priv->fd.tdc_const->tdcf_max) {
420 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */
421 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */
422 }
423
424 if (can_fd_tdc_is_enabled(priv)) {
425 if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL ||
426 priv->fd.do_get_auto_tdcv)
427 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */
428 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */
429 if (priv->fd.tdc_const->tdcf_max)
430 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */
431 }
432
433 return size;
434 }
435
can_ctrlmode_ext_get_size(void)436 static size_t can_ctrlmode_ext_get_size(void)
437 {
438 return nla_total_size(0) + /* nest IFLA_CAN_CTRLMODE_EXT */
439 nla_total_size(sizeof(u32)); /* IFLA_CAN_CTRLMODE_SUPPORTED */
440 }
441
can_get_size(const struct net_device * dev)442 static size_t can_get_size(const struct net_device *dev)
443 {
444 struct can_priv *priv = netdev_priv(dev);
445 size_t size = 0;
446
447 if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */
448 size += nla_total_size(sizeof(struct can_bittiming));
449 if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */
450 size += nla_total_size(sizeof(struct can_bittiming_const));
451 size += nla_total_size(sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */
452 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_STATE */
453 size += nla_total_size(sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */
454 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */
455 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */
456 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) {
462 size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */
463 size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */
464 priv->termination_const_cnt);
465 }
466 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */
467 size += nla_total_size(sizeof(*priv->bitrate_const) *
468 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 */
473 size += can_tdc_get_size(dev); /* IFLA_CAN_TDC */
474 size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */
475
476 return size;
477 }
478
can_tdc_fill_info(struct sk_buff * skb,const struct net_device * dev)479 static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev)
480 {
481 struct nlattr *nest;
482 struct can_priv *priv = netdev_priv(dev);
483 struct can_tdc *tdc = &priv->fd.tdc;
484 const struct can_tdc_const *tdc_const = priv->fd.tdc_const;
485
486 if (!tdc_const)
487 return 0;
488
489 nest = nla_nest_start(skb, IFLA_CAN_TDC);
490 if (!nest)
491 return -EMSGSIZE;
492
493 if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL &&
494 (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)))
496 goto err_cancel;
497 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MIN, tdc_const->tdco_min) ||
498 nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MAX, tdc_const->tdco_max))
499 goto err_cancel;
500 if (tdc_const->tdcf_max &&
501 (nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MIN, tdc_const->tdcf_min) ||
502 nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max)))
503 goto err_cancel;
504
505 if (can_fd_tdc_is_enabled(priv)) {
506 u32 tdcv;
507 int err = -EINVAL;
508
509 if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL) {
510 tdcv = tdc->tdcv;
511 err = 0;
512 } else if (priv->fd.do_get_auto_tdcv) {
513 err = priv->fd.do_get_auto_tdcv(dev, &tdcv);
514 }
515 if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv))
516 goto err_cancel;
517 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO, tdc->tdco))
518 goto err_cancel;
519 if (tdc_const->tdcf_max &&
520 nla_put_u32(skb, IFLA_CAN_TDC_TDCF, tdc->tdcf))
521 goto err_cancel;
522 }
523
524 nla_nest_end(skb, nest);
525 return 0;
526
527 err_cancel:
528 nla_nest_cancel(skb, nest);
529 return -EMSGSIZE;
530 }
531
can_ctrlmode_ext_fill_info(struct sk_buff * skb,const struct can_priv * priv)532 static int can_ctrlmode_ext_fill_info(struct sk_buff *skb,
533 const struct can_priv *priv)
534 {
535 struct nlattr *nest;
536
537 nest = nla_nest_start(skb, IFLA_CAN_CTRLMODE_EXT);
538 if (!nest)
539 return -EMSGSIZE;
540
541 if (nla_put_u32(skb, IFLA_CAN_CTRLMODE_SUPPORTED,
542 priv->ctrlmode_supported)) {
543 nla_nest_cancel(skb, nest);
544 return -EMSGSIZE;
545 }
546
547 nla_nest_end(skb, nest);
548 return 0;
549 }
550
can_fill_info(struct sk_buff * skb,const struct net_device * dev)551 static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
552 {
553 struct can_priv *priv = netdev_priv(dev);
554 struct can_ctrlmode cm = {.flags = priv->ctrlmode};
555 struct can_berr_counter bec = { };
556 enum can_state state = priv->state;
557
558 if (priv->do_get_state)
559 priv->do_get_state(dev, &state);
560
561 if ((priv->bittiming.bitrate != CAN_BITRATE_UNSET &&
562 priv->bittiming.bitrate != CAN_BITRATE_UNKNOWN &&
563 nla_put(skb, IFLA_CAN_BITTIMING,
564 sizeof(priv->bittiming), &priv->bittiming)) ||
565
566 (priv->bittiming_const &&
567 nla_put(skb, IFLA_CAN_BITTIMING_CONST,
568 sizeof(*priv->bittiming_const), priv->bittiming_const)) ||
569
570 nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) ||
571 nla_put_u32(skb, IFLA_CAN_STATE, state) ||
572 nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) ||
573 nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) ||
574
575 (priv->do_get_berr_counter &&
576 !priv->do_get_berr_counter(dev, &bec) &&
577 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||
578
579 (priv->fd.data_bittiming.bitrate &&
580 nla_put(skb, IFLA_CAN_DATA_BITTIMING,
581 sizeof(priv->fd.data_bittiming), &priv->fd.data_bittiming)) ||
582
583 (priv->fd.data_bittiming_const &&
584 nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST,
585 sizeof(*priv->fd.data_bittiming_const),
586 priv->fd.data_bittiming_const)) ||
587
588 (priv->termination_const &&
589 (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) ||
590 nla_put(skb, IFLA_CAN_TERMINATION_CONST,
591 sizeof(*priv->termination_const) *
592 priv->termination_const_cnt,
593 priv->termination_const))) ||
594
595 (priv->bitrate_const &&
596 nla_put(skb, IFLA_CAN_BITRATE_CONST,
597 sizeof(*priv->bitrate_const) *
598 priv->bitrate_const_cnt,
599 priv->bitrate_const)) ||
600
601 (priv->fd.data_bitrate_const &&
602 nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST,
603 sizeof(*priv->fd.data_bitrate_const) *
604 priv->fd.data_bitrate_const_cnt,
605 priv->fd.data_bitrate_const)) ||
606
607 (nla_put(skb, IFLA_CAN_BITRATE_MAX,
608 sizeof(priv->bitrate_max),
609 &priv->bitrate_max)) ||
610
611 can_tdc_fill_info(skb, dev) ||
612
613 can_ctrlmode_ext_fill_info(skb, priv)
614 )
615
616 return -EMSGSIZE;
617
618 return 0;
619 }
620
can_get_xstats_size(const struct net_device * dev)621 static size_t can_get_xstats_size(const struct net_device *dev)
622 {
623 return sizeof(struct can_device_stats);
624 }
625
can_fill_xstats(struct sk_buff * skb,const struct net_device * dev)626 static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)
627 {
628 struct can_priv *priv = netdev_priv(dev);
629
630 if (nla_put(skb, IFLA_INFO_XSTATS,
631 sizeof(priv->can_stats), &priv->can_stats))
632 goto nla_put_failure;
633 return 0;
634
635 nla_put_failure:
636 return -EMSGSIZE;
637 }
638
can_newlink(struct net_device * dev,struct rtnl_newlink_params * params,struct netlink_ext_ack * extack)639 static int can_newlink(struct net_device *dev,
640 struct rtnl_newlink_params *params,
641 struct netlink_ext_ack *extack)
642 {
643 return -EOPNOTSUPP;
644 }
645
can_dellink(struct net_device * dev,struct list_head * head)646 static void can_dellink(struct net_device *dev, struct list_head *head)
647 {
648 }
649
650 struct rtnl_link_ops can_link_ops __read_mostly = {
651 .kind = "can",
652 .netns_refund = true,
653 .maxtype = IFLA_CAN_MAX,
654 .policy = can_policy,
655 .setup = can_setup,
656 .validate = can_validate,
657 .newlink = can_newlink,
658 .changelink = can_changelink,
659 .dellink = can_dellink,
660 .get_size = can_get_size,
661 .fill_info = can_fill_info,
662 .get_xstats_size = can_get_xstats_size,
663 .fill_xstats = can_fill_xstats,
664 };
665
can_netlink_register(void)666 int can_netlink_register(void)
667 {
668 return rtnl_link_register(&can_link_ops);
669 }
670
can_netlink_unregister(void)671 void can_netlink_unregister(void)
672 {
673 rtnl_link_unregister(&can_link_ops);
674 }
675