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-2025 Vincent Mailhol <mailhol@kernel.org>
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 [IFLA_CAN_XL_DATA_BITTIMING] = { .len = sizeof(struct can_bittiming) },
26 [IFLA_CAN_XL_DATA_BITTIMING_CONST] = { .len = sizeof(struct can_bittiming_const) },
27 [IFLA_CAN_XL_TDC] = { .type = NLA_NESTED },
28 [IFLA_CAN_XL_PWM] = { .type = NLA_NESTED },
29 };
30
31 static const struct nla_policy can_tdc_policy[IFLA_CAN_TDC_MAX + 1] = {
32 [IFLA_CAN_TDC_TDCV_MIN] = { .type = NLA_U32 },
33 [IFLA_CAN_TDC_TDCV_MAX] = { .type = NLA_U32 },
34 [IFLA_CAN_TDC_TDCO_MIN] = { .type = NLA_U32 },
35 [IFLA_CAN_TDC_TDCO_MAX] = { .type = NLA_U32 },
36 [IFLA_CAN_TDC_TDCF_MIN] = { .type = NLA_U32 },
37 [IFLA_CAN_TDC_TDCF_MAX] = { .type = NLA_U32 },
38 [IFLA_CAN_TDC_TDCV] = { .type = NLA_U32 },
39 [IFLA_CAN_TDC_TDCO] = { .type = NLA_U32 },
40 [IFLA_CAN_TDC_TDCF] = { .type = NLA_U32 },
41 };
42
43 static const struct nla_policy can_pwm_policy[IFLA_CAN_PWM_MAX + 1] = {
44 [IFLA_CAN_PWM_PWMS_MIN] = { .type = NLA_U32 },
45 [IFLA_CAN_PWM_PWMS_MAX] = { .type = NLA_U32 },
46 [IFLA_CAN_PWM_PWML_MIN] = { .type = NLA_U32 },
47 [IFLA_CAN_PWM_PWML_MAX] = { .type = NLA_U32 },
48 [IFLA_CAN_PWM_PWMO_MIN] = { .type = NLA_U32 },
49 [IFLA_CAN_PWM_PWMO_MAX] = { .type = NLA_U32 },
50 [IFLA_CAN_PWM_PWMS] = { .type = NLA_U32 },
51 [IFLA_CAN_PWM_PWML] = { .type = NLA_U32 },
52 [IFLA_CAN_PWM_PWMO] = { .type = NLA_U32 },
53 };
54
can_validate_bittiming(struct nlattr * data[],struct netlink_ext_ack * extack,int ifla_can_bittiming)55 static int can_validate_bittiming(struct nlattr *data[],
56 struct netlink_ext_ack *extack,
57 int ifla_can_bittiming)
58 {
59 struct can_bittiming *bt;
60
61 if (!data[ifla_can_bittiming])
62 return 0;
63
64 static_assert(__alignof__(*bt) <= NLA_ALIGNTO);
65 bt = nla_data(data[ifla_can_bittiming]);
66
67 /* sample point is in one-tenth of a percent */
68 if (bt->sample_point >= 1000) {
69 NL_SET_ERR_MSG(extack, "sample point must be between 0 and 100%");
70 return -EINVAL;
71 }
72
73 return 0;
74 }
75
can_validate_tdc(struct nlattr * data_tdc,struct netlink_ext_ack * extack,u32 tdc_flags)76 static int can_validate_tdc(struct nlattr *data_tdc,
77 struct netlink_ext_ack *extack, u32 tdc_flags)
78 {
79 bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK;
80 bool tdc_auto = tdc_flags & CAN_CTRLMODE_TDC_AUTO_MASK;
81 int err;
82
83 if (tdc_auto && tdc_manual) {
84 NL_SET_ERR_MSG(extack,
85 "TDC manual and auto modes are mutually exclusive");
86 return -EOPNOTSUPP;
87 }
88
89 /* If one of the CAN_CTRLMODE_{,XL}_TDC_* flags is set then TDC
90 * must be set and vice-versa
91 */
92 if ((tdc_auto || tdc_manual) && !data_tdc) {
93 NL_SET_ERR_MSG(extack, "TDC parameters are missing");
94 return -EOPNOTSUPP;
95 }
96 if (!(tdc_auto || tdc_manual) && data_tdc) {
97 NL_SET_ERR_MSG(extack, "TDC mode (auto or manual) is missing");
98 return -EOPNOTSUPP;
99 }
100
101 /* If providing TDC parameters, at least TDCO is needed. TDCV is
102 * needed if and only if CAN_CTRLMODE_{,XL}_TDC_MANUAL is set
103 */
104 if (data_tdc) {
105 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
106
107 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX,
108 data_tdc, can_tdc_policy, extack);
109 if (err)
110 return err;
111
112 if (tb_tdc[IFLA_CAN_TDC_TDCV]) {
113 if (tdc_auto) {
114 NL_SET_ERR_MSG(extack,
115 "TDCV is incompatible with TDC auto mode");
116 return -EOPNOTSUPP;
117 }
118 } else {
119 if (tdc_manual) {
120 NL_SET_ERR_MSG(extack,
121 "TDC manual mode requires TDCV");
122 return -EOPNOTSUPP;
123 }
124 }
125
126 if (!tb_tdc[IFLA_CAN_TDC_TDCO]) {
127 NL_SET_ERR_MSG(extack, "TDCO is missing");
128 return -EOPNOTSUPP;
129 }
130 }
131
132 return 0;
133 }
134
can_validate_pwm(struct nlattr * data[],struct netlink_ext_ack * extack,u32 flags)135 static int can_validate_pwm(struct nlattr *data[],
136 struct netlink_ext_ack *extack, u32 flags)
137 {
138 struct nlattr *tb_pwm[IFLA_CAN_PWM_MAX + 1];
139 int err;
140
141 if (!data[IFLA_CAN_XL_PWM])
142 return 0;
143
144 if (!(flags & CAN_CTRLMODE_XL_TMS)) {
145 NL_SET_ERR_MSG(extack, "PWM requires TMS");
146 return -EOPNOTSUPP;
147 }
148
149 err = nla_parse_nested(tb_pwm, IFLA_CAN_PWM_MAX, data[IFLA_CAN_XL_PWM],
150 can_pwm_policy, extack);
151 if (err)
152 return err;
153
154 if (!tb_pwm[IFLA_CAN_PWM_PWMS] != !tb_pwm[IFLA_CAN_PWM_PWML]) {
155 NL_SET_ERR_MSG(extack,
156 "Provide either both PWMS and PWML, or none for automatic calculation");
157 return -EOPNOTSUPP;
158 }
159
160 if (tb_pwm[IFLA_CAN_PWM_PWMO] &&
161 (!tb_pwm[IFLA_CAN_PWM_PWMS] || !tb_pwm[IFLA_CAN_PWM_PWML])) {
162 NL_SET_ERR_MSG(extack, "PWMO requires both PWMS and PWML");
163 return -EOPNOTSUPP;
164 }
165
166 return 0;
167 }
168
can_validate_databittiming(struct nlattr * data[],struct netlink_ext_ack * extack,int ifla_can_data_bittiming,u32 flags)169 static int can_validate_databittiming(struct nlattr *data[],
170 struct netlink_ext_ack *extack,
171 int ifla_can_data_bittiming, u32 flags)
172 {
173 struct nlattr *data_tdc;
174 const char *type;
175 u32 tdc_flags;
176 bool is_on;
177 int err;
178
179 /* Make sure that valid CAN FD/XL configurations always consist of
180 * - nominal/arbitration bittiming
181 * - data bittiming
182 * - control mode with CAN_CTRLMODE_{FD,XL} set
183 * - TDC parameters are coherent (details in can_validate_tdc())
184 */
185
186 if (ifla_can_data_bittiming == IFLA_CAN_DATA_BITTIMING) {
187 data_tdc = data[IFLA_CAN_TDC];
188 tdc_flags = flags & CAN_CTRLMODE_FD_TDC_MASK;
189 is_on = flags & CAN_CTRLMODE_FD;
190 type = "FD";
191 } else {
192 data_tdc = data[IFLA_CAN_XL_TDC];
193 tdc_flags = flags & CAN_CTRLMODE_XL_TDC_MASK;
194 is_on = flags & CAN_CTRLMODE_XL;
195 type = "XL";
196 }
197
198 if (is_on) {
199 if (!data[IFLA_CAN_BITTIMING] || !data[ifla_can_data_bittiming]) {
200 NL_SET_ERR_MSG_FMT(extack,
201 "Provide both nominal and %s data bittiming",
202 type);
203 return -EOPNOTSUPP;
204 }
205 } else {
206 if (data[ifla_can_data_bittiming]) {
207 NL_SET_ERR_MSG_FMT(extack,
208 "%s data bittiming requires CAN %s",
209 type, type);
210 return -EOPNOTSUPP;
211 }
212 if (data_tdc) {
213 NL_SET_ERR_MSG_FMT(extack,
214 "%s TDC requires CAN %s",
215 type, type);
216 return -EOPNOTSUPP;
217 }
218 }
219
220 err = can_validate_bittiming(data, extack, ifla_can_data_bittiming);
221 if (err)
222 return err;
223
224 err = can_validate_tdc(data_tdc, extack, tdc_flags);
225 if (err)
226 return err;
227
228 return 0;
229 }
230
can_validate_xl_flags(struct netlink_ext_ack * extack,u32 masked_flags,u32 mask)231 static int can_validate_xl_flags(struct netlink_ext_ack *extack,
232 u32 masked_flags, u32 mask)
233 {
234 if (masked_flags & CAN_CTRLMODE_XL) {
235 if (masked_flags & CAN_CTRLMODE_XL_TMS) {
236 const u32 tms_conflicts_mask = CAN_CTRLMODE_FD |
237 CAN_CTRLMODE_XL_TDC_MASK;
238 u32 tms_conflicts = masked_flags & tms_conflicts_mask;
239
240 if (tms_conflicts) {
241 NL_SET_ERR_MSG_FMT(extack,
242 "TMS and %s are mutually exclusive",
243 can_get_ctrlmode_str(tms_conflicts));
244 return -EOPNOTSUPP;
245 }
246 }
247 } else {
248 if (mask & CAN_CTRLMODE_XL_TMS) {
249 NL_SET_ERR_MSG(extack, "TMS requires CAN XL");
250 return -EOPNOTSUPP;
251 }
252 }
253
254 return 0;
255 }
256
can_validate(struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)257 static int can_validate(struct nlattr *tb[], struct nlattr *data[],
258 struct netlink_ext_ack *extack)
259 {
260 u32 flags = 0;
261 int err;
262
263 if (!data)
264 return 0;
265
266 if (data[IFLA_CAN_CTRLMODE]) {
267 struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
268
269 flags = cm->flags & cm->mask;
270
271 if ((flags & CAN_CTRLMODE_LISTENONLY) &&
272 (flags & CAN_CTRLMODE_RESTRICTED)) {
273 NL_SET_ERR_MSG(extack,
274 "LISTEN-ONLY and RESTRICTED modes are mutually exclusive");
275 return -EOPNOTSUPP;
276 }
277
278 err = can_validate_xl_flags(extack, flags, cm->mask);
279 if (err)
280 return err;
281 }
282
283 err = can_validate_bittiming(data, extack, IFLA_CAN_BITTIMING);
284 if (err)
285 return err;
286
287 err = can_validate_databittiming(data, extack,
288 IFLA_CAN_DATA_BITTIMING, flags);
289 if (err)
290 return err;
291
292 err = can_validate_databittiming(data, extack,
293 IFLA_CAN_XL_DATA_BITTIMING, flags);
294 if (err)
295 return err;
296
297 err = can_validate_pwm(data, extack, flags);
298 if (err)
299 return err;
300
301 return 0;
302 }
303
can_ctrlmode_changelink(struct net_device * dev,struct nlattr * data[],struct netlink_ext_ack * extack)304 static int can_ctrlmode_changelink(struct net_device *dev,
305 struct nlattr *data[],
306 struct netlink_ext_ack *extack)
307 {
308 struct can_priv *priv = netdev_priv(dev);
309 struct can_ctrlmode *cm;
310 u32 ctrlstatic, maskedflags, deactivated, notsupp, ctrlstatic_missing;
311
312 if (!data[IFLA_CAN_CTRLMODE])
313 return 0;
314
315 /* Do not allow changing controller mode while running */
316 if (dev->flags & IFF_UP)
317 return -EBUSY;
318
319 cm = nla_data(data[IFLA_CAN_CTRLMODE]);
320 ctrlstatic = can_get_static_ctrlmode(priv);
321 maskedflags = cm->flags & cm->mask;
322 deactivated = ~cm->flags & cm->mask;
323 notsupp = maskedflags & ~(priv->ctrlmode_supported | ctrlstatic);
324 ctrlstatic_missing = (maskedflags & ctrlstatic) ^ ctrlstatic;
325
326 if (notsupp) {
327 NL_SET_ERR_MSG_FMT(extack,
328 "requested control mode %s not supported",
329 can_get_ctrlmode_str(notsupp));
330 return -EOPNOTSUPP;
331 }
332
333 /* do not check for static fd-non-iso if 'fd' is disabled */
334 if (!(maskedflags & CAN_CTRLMODE_FD))
335 ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO;
336
337 if (ctrlstatic_missing) {
338 NL_SET_ERR_MSG_FMT(extack,
339 "missing required %s static control mode",
340 can_get_ctrlmode_str(ctrlstatic_missing));
341 return -EOPNOTSUPP;
342 }
343
344 /* If FD was active and is not turned off, check for XL conflicts */
345 if (priv->ctrlmode & CAN_CTRLMODE_FD & ~deactivated) {
346 if (maskedflags & CAN_CTRLMODE_XL_TMS) {
347 NL_SET_ERR_MSG(extack,
348 "TMS can not be activated while CAN FD is on");
349 return -EOPNOTSUPP;
350 }
351 }
352
353 /* If a top dependency flag is provided, reset all its dependencies */
354 if (cm->mask & CAN_CTRLMODE_FD)
355 priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
356 if (cm->mask & CAN_CTRLMODE_XL)
357 priv->ctrlmode &= ~(CAN_CTRLMODE_XL_TDC_MASK |
358 CAN_CTRLMODE_XL_TMS);
359
360 /* clear bits to be modified and copy the flag values */
361 priv->ctrlmode &= ~cm->mask;
362 priv->ctrlmode |= maskedflags;
363
364 /* Wipe potential leftovers from previous CAN FD/XL config */
365 if (!(priv->ctrlmode & CAN_CTRLMODE_FD)) {
366 memset(&priv->fd.data_bittiming, 0,
367 sizeof(priv->fd.data_bittiming));
368 priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
369 memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc));
370 }
371 if (!(priv->ctrlmode & CAN_CTRLMODE_XL)) {
372 memset(&priv->xl.data_bittiming, 0,
373 sizeof(priv->fd.data_bittiming));
374 priv->ctrlmode &= ~CAN_CTRLMODE_XL_TDC_MASK;
375 memset(&priv->xl.tdc, 0, sizeof(priv->xl.tdc));
376 memset(&priv->xl.pwm, 0, sizeof(priv->xl.pwm));
377 }
378
379 can_set_default_mtu(dev);
380
381 return 0;
382 }
383
can_tdc_changelink(struct data_bittiming_params * dbt_params,const struct nlattr * nla,struct netlink_ext_ack * extack)384 static int can_tdc_changelink(struct data_bittiming_params *dbt_params,
385 const struct nlattr *nla,
386 struct netlink_ext_ack *extack)
387 {
388 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
389 struct can_tdc tdc = { 0 };
390 const struct can_tdc_const *tdc_const = dbt_params->tdc_const;
391 int err;
392
393 if (!tdc_const) {
394 NL_SET_ERR_MSG(extack, "The device does not support TDC");
395 return -EOPNOTSUPP;
396 }
397
398 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, nla,
399 can_tdc_policy, extack);
400 if (err)
401 return err;
402
403 if (tb_tdc[IFLA_CAN_TDC_TDCV]) {
404 u32 tdcv = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCV]);
405
406 if (tdcv < tdc_const->tdcv_min || tdcv > tdc_const->tdcv_max)
407 return -EINVAL;
408
409 tdc.tdcv = tdcv;
410 }
411
412 if (tb_tdc[IFLA_CAN_TDC_TDCO]) {
413 u32 tdco = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCO]);
414
415 if (tdco < tdc_const->tdco_min || tdco > tdc_const->tdco_max)
416 return -EINVAL;
417
418 tdc.tdco = tdco;
419 }
420
421 if (tb_tdc[IFLA_CAN_TDC_TDCF]) {
422 u32 tdcf = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCF]);
423
424 if (tdcf < tdc_const->tdcf_min || tdcf > tdc_const->tdcf_max)
425 return -EINVAL;
426
427 tdc.tdcf = tdcf;
428 }
429
430 dbt_params->tdc = tdc;
431
432 return 0;
433 }
434
can_dbt_changelink(struct net_device * dev,struct nlattr * data[],bool fd,struct netlink_ext_ack * extack)435 static int can_dbt_changelink(struct net_device *dev, struct nlattr *data[],
436 bool fd, struct netlink_ext_ack *extack)
437 {
438 struct nlattr *data_bittiming, *data_tdc;
439 struct can_priv *priv = netdev_priv(dev);
440 struct data_bittiming_params *dbt_params;
441 struct can_bittiming dbt;
442 bool need_tdc_calc = false;
443 u32 tdc_mask;
444 int err;
445
446 if (fd) {
447 data_bittiming = data[IFLA_CAN_DATA_BITTIMING];
448 data_tdc = data[IFLA_CAN_TDC];
449 dbt_params = &priv->fd;
450 tdc_mask = CAN_CTRLMODE_FD_TDC_MASK;
451 } else {
452 data_bittiming = data[IFLA_CAN_XL_DATA_BITTIMING];
453 data_tdc = data[IFLA_CAN_XL_TDC];
454 dbt_params = &priv->xl;
455 tdc_mask = CAN_CTRLMODE_XL_TDC_MASK;
456 }
457
458 if (!data_bittiming)
459 return 0;
460
461 /* Do not allow changing bittiming while running */
462 if (dev->flags & IFF_UP)
463 return -EBUSY;
464
465 /* Calculate bittiming parameters based on data_bittiming_const
466 * if set, otherwise pass bitrate directly via do_set_bitrate().
467 * Bail out if neither is given.
468 */
469 if (!dbt_params->data_bittiming_const && !dbt_params->do_set_data_bittiming &&
470 !dbt_params->data_bitrate_const)
471 return -EOPNOTSUPP;
472
473 memcpy(&dbt, nla_data(data_bittiming), sizeof(dbt));
474 err = can_get_bittiming(dev, &dbt, dbt_params->data_bittiming_const,
475 dbt_params->data_bitrate_const,
476 dbt_params->data_bitrate_const_cnt, extack);
477 if (err)
478 return err;
479
480 if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
481 NL_SET_ERR_MSG_FMT(extack,
482 "CAN data bitrate %u bps surpasses transceiver capabilities of %u bps",
483 dbt.bitrate, priv->bitrate_max);
484 return -EINVAL;
485 }
486
487 memset(&dbt_params->tdc, 0, sizeof(dbt_params->tdc));
488 if (data[IFLA_CAN_CTRLMODE]) {
489 struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
490
491 if (fd || !(priv->ctrlmode & CAN_CTRLMODE_XL_TMS))
492 need_tdc_calc = !(cm->mask & tdc_mask);
493 }
494 if (data_tdc) {
495 /* TDC parameters are provided: use them */
496 err = can_tdc_changelink(dbt_params, data_tdc, extack);
497 if (err) {
498 priv->ctrlmode &= ~tdc_mask;
499 return err;
500 }
501 } else if (need_tdc_calc) {
502 /* Neither of TDC parameters nor TDC flags are provided:
503 * do calculation
504 */
505 can_calc_tdco(&dbt_params->tdc, dbt_params->tdc_const, &dbt,
506 tdc_mask, &priv->ctrlmode, priv->ctrlmode_supported);
507 } /* else: both CAN_CTRLMODE_{,XL}_TDC_{AUTO,MANUAL} are explicitly
508 * turned off. TDC is disabled: do nothing
509 */
510
511 memcpy(&dbt_params->data_bittiming, &dbt, sizeof(dbt));
512
513 if (dbt_params->do_set_data_bittiming) {
514 /* Finally, set the bit-timing registers */
515 err = dbt_params->do_set_data_bittiming(dev);
516 if (err)
517 return err;
518 }
519
520 return 0;
521 }
522
can_pwm_changelink(struct net_device * dev,const struct nlattr * pwm_nla,struct netlink_ext_ack * extack)523 static int can_pwm_changelink(struct net_device *dev,
524 const struct nlattr *pwm_nla,
525 struct netlink_ext_ack *extack)
526 {
527 struct can_priv *priv = netdev_priv(dev);
528 const struct can_pwm_const *pwm_const = priv->xl.pwm_const;
529 struct nlattr *tb_pwm[IFLA_CAN_PWM_MAX + 1];
530 struct can_pwm pwm = { 0 };
531 int err;
532
533 if (!(priv->ctrlmode & CAN_CTRLMODE_XL_TMS))
534 return 0;
535
536 if (!pwm_const) {
537 NL_SET_ERR_MSG(extack, "The device does not support PWM");
538 return -EOPNOTSUPP;
539 }
540
541 if (!pwm_nla)
542 return can_calc_pwm(dev, extack);
543
544 err = nla_parse_nested(tb_pwm, IFLA_CAN_PWM_MAX, pwm_nla,
545 can_pwm_policy, extack);
546 if (err)
547 return err;
548
549 if (tb_pwm[IFLA_CAN_PWM_PWMS]) {
550 pwm.pwms = nla_get_u32(tb_pwm[IFLA_CAN_PWM_PWMS]);
551 if (pwm.pwms < pwm_const->pwms_min ||
552 pwm.pwms > pwm_const->pwms_max) {
553 NL_SET_ERR_MSG_FMT(extack,
554 "PWMS: %u tqmin is out of range: %u...%u",
555 pwm.pwms, pwm_const->pwms_min,
556 pwm_const->pwms_max);
557 return -EINVAL;
558 }
559 }
560
561 if (tb_pwm[IFLA_CAN_PWM_PWML]) {
562 pwm.pwml = nla_get_u32(tb_pwm[IFLA_CAN_PWM_PWML]);
563 if (pwm.pwml < pwm_const->pwml_min ||
564 pwm.pwml > pwm_const->pwml_max) {
565 NL_SET_ERR_MSG_FMT(extack,
566 "PWML: %u tqmin is out of range: %u...%u",
567 pwm.pwml, pwm_const->pwml_min,
568 pwm_const->pwml_max);
569 return -EINVAL;
570 }
571 }
572
573 if (tb_pwm[IFLA_CAN_PWM_PWMO]) {
574 pwm.pwmo = nla_get_u32(tb_pwm[IFLA_CAN_PWM_PWMO]);
575 if (pwm.pwmo < pwm_const->pwmo_min ||
576 pwm.pwmo > pwm_const->pwmo_max) {
577 NL_SET_ERR_MSG_FMT(extack,
578 "PWMO: %u tqmin is out of range: %u...%u",
579 pwm.pwmo, pwm_const->pwmo_min,
580 pwm_const->pwmo_max);
581 return -EINVAL;
582 }
583 }
584
585 err = can_validate_pwm_bittiming(dev, &pwm, extack);
586 if (err)
587 return err;
588
589 priv->xl.pwm = pwm;
590 return 0;
591 }
592
can_changelink(struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)593 static int can_changelink(struct net_device *dev, struct nlattr *tb[],
594 struct nlattr *data[],
595 struct netlink_ext_ack *extack)
596 {
597 struct can_priv *priv = netdev_priv(dev);
598 int err;
599
600 /* We need synchronization with dev->stop() */
601 ASSERT_RTNL();
602
603 can_ctrlmode_changelink(dev, data, extack);
604
605 if (data[IFLA_CAN_BITTIMING]) {
606 struct can_bittiming bt;
607
608 /* Do not allow changing bittiming while running */
609 if (dev->flags & IFF_UP)
610 return -EBUSY;
611
612 /* Calculate bittiming parameters based on
613 * bittiming_const if set, otherwise pass bitrate
614 * directly via do_set_bitrate(). Bail out if neither
615 * is given.
616 */
617 if (!priv->bittiming_const && !priv->do_set_bittiming &&
618 !priv->bitrate_const)
619 return -EOPNOTSUPP;
620
621 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
622 err = can_get_bittiming(dev, &bt,
623 priv->bittiming_const,
624 priv->bitrate_const,
625 priv->bitrate_const_cnt,
626 extack);
627 if (err)
628 return err;
629
630 if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) {
631 NL_SET_ERR_MSG_FMT(extack,
632 "arbitration bitrate %u bps surpasses transceiver capabilities of %u bps",
633 bt.bitrate, priv->bitrate_max);
634 return -EINVAL;
635 }
636
637 memcpy(&priv->bittiming, &bt, sizeof(bt));
638
639 if (priv->do_set_bittiming) {
640 /* Finally, set the bit-timing registers */
641 err = priv->do_set_bittiming(dev);
642 if (err)
643 return err;
644 }
645 }
646
647 if (data[IFLA_CAN_RESTART_MS]) {
648 unsigned int restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);
649
650 if (restart_ms != 0 && !priv->do_set_mode) {
651 NL_SET_ERR_MSG(extack,
652 "Device doesn't support restart from Bus Off");
653 return -EOPNOTSUPP;
654 }
655
656 /* Do not allow changing restart delay while running */
657 if (dev->flags & IFF_UP)
658 return -EBUSY;
659 priv->restart_ms = restart_ms;
660 }
661
662 if (data[IFLA_CAN_RESTART]) {
663 if (!priv->do_set_mode) {
664 NL_SET_ERR_MSG(extack,
665 "Device doesn't support restart from Bus Off");
666 return -EOPNOTSUPP;
667 }
668
669 /* Do not allow a restart while not running */
670 if (!(dev->flags & IFF_UP))
671 return -EINVAL;
672 err = can_restart_now(dev);
673 if (err)
674 return err;
675 }
676
677 /* CAN FD */
678 err = can_dbt_changelink(dev, data, true, extack);
679 if (err)
680 return err;
681
682 /* CAN XL */
683 err = can_dbt_changelink(dev, data, false, extack);
684 if (err)
685 return err;
686 err = can_pwm_changelink(dev, data[IFLA_CAN_XL_PWM], extack);
687 if (err)
688 return err;
689
690 if (data[IFLA_CAN_TERMINATION]) {
691 const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]);
692 const unsigned int num_term = priv->termination_const_cnt;
693 unsigned int i;
694
695 if (!priv->do_set_termination) {
696 NL_SET_ERR_MSG(extack,
697 "Termination is not configurable on this device");
698 return -EOPNOTSUPP;
699 }
700
701 /* check whether given value is supported by the interface */
702 for (i = 0; i < num_term; i++) {
703 if (termval == priv->termination_const[i])
704 break;
705 }
706 if (i >= num_term)
707 return -EINVAL;
708
709 /* Finally, set the termination value */
710 err = priv->do_set_termination(dev, termval);
711 if (err)
712 return err;
713
714 priv->termination = termval;
715 }
716
717 return 0;
718 }
719
can_tdc_get_size(struct data_bittiming_params * dbt_params,u32 tdc_flags)720 static size_t can_tdc_get_size(struct data_bittiming_params *dbt_params,
721 u32 tdc_flags)
722 {
723 bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK;
724 size_t size;
725
726 if (!dbt_params->tdc_const)
727 return 0;
728
729 size = nla_total_size(0); /* nest IFLA_CAN_TDC */
730 if (tdc_manual) {
731 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MIN */
732 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MAX */
733 }
734 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */
735 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */
736 if (dbt_params->tdc_const->tdcf_max) {
737 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */
738 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */
739 }
740
741 if (tdc_flags) {
742 if (tdc_manual || dbt_params->do_get_auto_tdcv)
743 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */
744 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */
745 if (dbt_params->tdc_const->tdcf_max)
746 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */
747 }
748
749 return size;
750 }
751
can_data_bittiming_get_size(struct data_bittiming_params * dbt_params,u32 tdc_flags)752 static size_t can_data_bittiming_get_size(struct data_bittiming_params *dbt_params,
753 u32 tdc_flags)
754 {
755 size_t size = 0;
756
757 if (dbt_params->data_bittiming.bitrate) /* IFLA_CAN_{,XL}_DATA_BITTIMING */
758 size += nla_total_size(sizeof(dbt_params->data_bittiming));
759 if (dbt_params->data_bittiming_const) /* IFLA_CAN_{,XL}_DATA_BITTIMING_CONST */
760 size += nla_total_size(sizeof(*dbt_params->data_bittiming_const));
761 if (dbt_params->data_bitrate_const) /* IFLA_CAN_{,XL}_DATA_BITRATE_CONST */
762 size += nla_total_size(sizeof(*dbt_params->data_bitrate_const) *
763 dbt_params->data_bitrate_const_cnt);
764 size += can_tdc_get_size(dbt_params, tdc_flags);/* IFLA_CAN_{,XL}_TDC */
765
766 return size;
767 }
768
can_ctrlmode_ext_get_size(void)769 static size_t can_ctrlmode_ext_get_size(void)
770 {
771 return nla_total_size(0) + /* nest IFLA_CAN_CTRLMODE_EXT */
772 nla_total_size(sizeof(u32)); /* IFLA_CAN_CTRLMODE_SUPPORTED */
773 }
774
can_pwm_get_size(const struct can_pwm_const * pwm_const,bool pwm_on)775 static size_t can_pwm_get_size(const struct can_pwm_const *pwm_const,
776 bool pwm_on)
777 {
778 size_t size;
779
780 if (!pwm_const || !pwm_on)
781 return 0;
782
783 size = nla_total_size(0); /* nest IFLA_CAN_PWM */
784
785 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_PWM_PWMS_MIN */
786 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_PWM_PWMS_MAX */
787 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_PWM_PWML_MIN */
788 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_PWM_PWML_MAX */
789 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_PWM_PWMO_MIN */
790 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_PWM_PWMO_MAX */
791
792 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_PWM_PWMS */
793 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_PWM_PWML */
794 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_PWM_PWMO */
795
796 return size;
797 }
798
can_get_size(const struct net_device * dev)799 static size_t can_get_size(const struct net_device *dev)
800 {
801 struct can_priv *priv = netdev_priv(dev);
802 size_t size = 0;
803
804 if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */
805 size += nla_total_size(sizeof(struct can_bittiming));
806 if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */
807 size += nla_total_size(sizeof(struct can_bittiming_const));
808 size += nla_total_size(sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */
809 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_STATE */
810 size += nla_total_size(sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */
811 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */
812 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */
813 size += nla_total_size(sizeof(struct can_berr_counter));
814 if (priv->termination_const) {
815 size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */
816 size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */
817 priv->termination_const_cnt);
818 }
819 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */
820 size += nla_total_size(sizeof(*priv->bitrate_const) *
821 priv->bitrate_const_cnt);
822 size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */
823 size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */
824
825 size += can_data_bittiming_get_size(&priv->fd,
826 priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK);
827
828 size += can_data_bittiming_get_size(&priv->xl,
829 priv->ctrlmode & CAN_CTRLMODE_XL_TDC_MASK);
830 size += can_pwm_get_size(priv->xl.pwm_const, /* IFLA_CAN_XL_PWM */
831 priv->ctrlmode & CAN_CTRLMODE_XL_TMS);
832
833 return size;
834 }
835
can_bittiming_fill_info(struct sk_buff * skb,int ifla_can_bittiming,struct can_bittiming * bittiming)836 static int can_bittiming_fill_info(struct sk_buff *skb, int ifla_can_bittiming,
837 struct can_bittiming *bittiming)
838 {
839 return bittiming->bitrate != CAN_BITRATE_UNSET &&
840 bittiming->bitrate != CAN_BITRATE_UNKNOWN &&
841 nla_put(skb, ifla_can_bittiming, sizeof(*bittiming), bittiming);
842 }
843
can_bittiming_const_fill_info(struct sk_buff * skb,int ifla_can_bittiming_const,const struct can_bittiming_const * bittiming_const)844 static int can_bittiming_const_fill_info(struct sk_buff *skb,
845 int ifla_can_bittiming_const,
846 const struct can_bittiming_const *bittiming_const)
847 {
848 return bittiming_const &&
849 nla_put(skb, ifla_can_bittiming_const,
850 sizeof(*bittiming_const), bittiming_const);
851 }
852
can_bitrate_const_fill_info(struct sk_buff * skb,int ifla_can_bitrate_const,const u32 * bitrate_const,unsigned int cnt)853 static int can_bitrate_const_fill_info(struct sk_buff *skb,
854 int ifla_can_bitrate_const,
855 const u32 *bitrate_const, unsigned int cnt)
856 {
857 return bitrate_const &&
858 nla_put(skb, ifla_can_bitrate_const,
859 sizeof(*bitrate_const) * cnt, bitrate_const);
860 }
861
can_tdc_fill_info(struct sk_buff * skb,const struct net_device * dev,int ifla_can_tdc)862 static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev,
863 int ifla_can_tdc)
864 {
865 struct can_priv *priv = netdev_priv(dev);
866 struct data_bittiming_params *dbt_params;
867 const struct can_tdc_const *tdc_const;
868 struct can_tdc *tdc;
869 struct nlattr *nest;
870 bool tdc_is_enabled, tdc_manual;
871
872 if (ifla_can_tdc == IFLA_CAN_TDC) {
873 dbt_params = &priv->fd;
874 tdc_is_enabled = can_fd_tdc_is_enabled(priv);
875 tdc_manual = priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL;
876 } else {
877 dbt_params = &priv->xl;
878 tdc_is_enabled = can_xl_tdc_is_enabled(priv);
879 tdc_manual = priv->ctrlmode & CAN_CTRLMODE_XL_TDC_MANUAL;
880 }
881 tdc_const = dbt_params->tdc_const;
882 tdc = &dbt_params->tdc;
883
884 if (!tdc_const)
885 return 0;
886
887 nest = nla_nest_start(skb, ifla_can_tdc);
888 if (!nest)
889 return -EMSGSIZE;
890
891 if (tdc_manual &&
892 (nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MIN, tdc_const->tdcv_min) ||
893 nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MAX, tdc_const->tdcv_max)))
894 goto err_cancel;
895 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MIN, tdc_const->tdco_min) ||
896 nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MAX, tdc_const->tdco_max))
897 goto err_cancel;
898 if (tdc_const->tdcf_max &&
899 (nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MIN, tdc_const->tdcf_min) ||
900 nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max)))
901 goto err_cancel;
902
903 if (tdc_is_enabled) {
904 u32 tdcv;
905 int err = -EINVAL;
906
907 if (tdc_manual) {
908 tdcv = tdc->tdcv;
909 err = 0;
910 } else if (dbt_params->do_get_auto_tdcv) {
911 err = dbt_params->do_get_auto_tdcv(dev, &tdcv);
912 }
913 if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv))
914 goto err_cancel;
915 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO, tdc->tdco))
916 goto err_cancel;
917 if (tdc_const->tdcf_max &&
918 nla_put_u32(skb, IFLA_CAN_TDC_TDCF, tdc->tdcf))
919 goto err_cancel;
920 }
921
922 nla_nest_end(skb, nest);
923 return 0;
924
925 err_cancel:
926 nla_nest_cancel(skb, nest);
927 return -EMSGSIZE;
928 }
929
can_pwm_fill_info(struct sk_buff * skb,const struct can_priv * priv)930 static int can_pwm_fill_info(struct sk_buff *skb, const struct can_priv *priv)
931 {
932 const struct can_pwm_const *pwm_const = priv->xl.pwm_const;
933 const struct can_pwm *pwm = &priv->xl.pwm;
934 struct nlattr *nest;
935
936 if (!pwm_const)
937 return 0;
938
939 nest = nla_nest_start(skb, IFLA_CAN_XL_PWM);
940 if (!nest)
941 return -EMSGSIZE;
942
943 if (nla_put_u32(skb, IFLA_CAN_PWM_PWMS_MIN, pwm_const->pwms_min) ||
944 nla_put_u32(skb, IFLA_CAN_PWM_PWMS_MAX, pwm_const->pwms_max) ||
945 nla_put_u32(skb, IFLA_CAN_PWM_PWML_MIN, pwm_const->pwml_min) ||
946 nla_put_u32(skb, IFLA_CAN_PWM_PWML_MAX, pwm_const->pwml_max) ||
947 nla_put_u32(skb, IFLA_CAN_PWM_PWMO_MIN, pwm_const->pwmo_min) ||
948 nla_put_u32(skb, IFLA_CAN_PWM_PWMO_MAX, pwm_const->pwmo_max))
949 goto err_cancel;
950
951 if (priv->ctrlmode & CAN_CTRLMODE_XL_TMS) {
952 if (nla_put_u32(skb, IFLA_CAN_PWM_PWMS, pwm->pwms) ||
953 nla_put_u32(skb, IFLA_CAN_PWM_PWML, pwm->pwml) ||
954 nla_put_u32(skb, IFLA_CAN_PWM_PWMO, pwm->pwmo))
955 goto err_cancel;
956 }
957
958 nla_nest_end(skb, nest);
959 return 0;
960
961 err_cancel:
962 nla_nest_cancel(skb, nest);
963 return -EMSGSIZE;
964 }
965
can_ctrlmode_ext_fill_info(struct sk_buff * skb,const struct can_priv * priv)966 static int can_ctrlmode_ext_fill_info(struct sk_buff *skb,
967 const struct can_priv *priv)
968 {
969 struct nlattr *nest;
970
971 nest = nla_nest_start(skb, IFLA_CAN_CTRLMODE_EXT);
972 if (!nest)
973 return -EMSGSIZE;
974
975 if (nla_put_u32(skb, IFLA_CAN_CTRLMODE_SUPPORTED,
976 priv->ctrlmode_supported)) {
977 nla_nest_cancel(skb, nest);
978 return -EMSGSIZE;
979 }
980
981 nla_nest_end(skb, nest);
982 return 0;
983 }
984
can_fill_info(struct sk_buff * skb,const struct net_device * dev)985 static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
986 {
987 struct can_priv *priv = netdev_priv(dev);
988 struct can_ctrlmode cm = {.flags = priv->ctrlmode};
989 struct can_berr_counter bec = { };
990 enum can_state state = priv->state;
991
992 if (priv->do_get_state)
993 priv->do_get_state(dev, &state);
994
995 if (can_bittiming_fill_info(skb, IFLA_CAN_BITTIMING,
996 &priv->bittiming) ||
997
998 can_bittiming_const_fill_info(skb, IFLA_CAN_BITTIMING_CONST,
999 priv->bittiming_const) ||
1000
1001 nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) ||
1002 nla_put_u32(skb, IFLA_CAN_STATE, state) ||
1003 nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) ||
1004 nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) ||
1005
1006 (priv->do_get_berr_counter &&
1007 !priv->do_get_berr_counter(dev, &bec) &&
1008 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||
1009
1010 can_bittiming_fill_info(skb, IFLA_CAN_DATA_BITTIMING,
1011 &priv->fd.data_bittiming) ||
1012
1013 can_bittiming_const_fill_info(skb, IFLA_CAN_DATA_BITTIMING_CONST,
1014 priv->fd.data_bittiming_const) ||
1015
1016 (priv->termination_const &&
1017 (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) ||
1018 nla_put(skb, IFLA_CAN_TERMINATION_CONST,
1019 sizeof(*priv->termination_const) *
1020 priv->termination_const_cnt,
1021 priv->termination_const))) ||
1022
1023 can_bitrate_const_fill_info(skb, IFLA_CAN_BITRATE_CONST,
1024 priv->bitrate_const,
1025 priv->bitrate_const_cnt) ||
1026
1027 can_bitrate_const_fill_info(skb, IFLA_CAN_DATA_BITRATE_CONST,
1028 priv->fd.data_bitrate_const,
1029 priv->fd.data_bitrate_const_cnt) ||
1030
1031 (nla_put(skb, IFLA_CAN_BITRATE_MAX,
1032 sizeof(priv->bitrate_max),
1033 &priv->bitrate_max)) ||
1034
1035 can_tdc_fill_info(skb, dev, IFLA_CAN_TDC) ||
1036
1037 can_ctrlmode_ext_fill_info(skb, priv) ||
1038
1039 can_bittiming_fill_info(skb, IFLA_CAN_XL_DATA_BITTIMING,
1040 &priv->xl.data_bittiming) ||
1041
1042 can_bittiming_const_fill_info(skb, IFLA_CAN_XL_DATA_BITTIMING_CONST,
1043 priv->xl.data_bittiming_const) ||
1044
1045 can_bitrate_const_fill_info(skb, IFLA_CAN_XL_DATA_BITRATE_CONST,
1046 priv->xl.data_bitrate_const,
1047 priv->xl.data_bitrate_const_cnt) ||
1048
1049 can_tdc_fill_info(skb, dev, IFLA_CAN_XL_TDC) ||
1050
1051 can_pwm_fill_info(skb, priv)
1052 )
1053 return -EMSGSIZE;
1054
1055 return 0;
1056 }
1057
can_get_xstats_size(const struct net_device * dev)1058 static size_t can_get_xstats_size(const struct net_device *dev)
1059 {
1060 return sizeof(struct can_device_stats);
1061 }
1062
can_fill_xstats(struct sk_buff * skb,const struct net_device * dev)1063 static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)
1064 {
1065 struct can_priv *priv = netdev_priv(dev);
1066
1067 if (nla_put(skb, IFLA_INFO_XSTATS,
1068 sizeof(priv->can_stats), &priv->can_stats))
1069 goto nla_put_failure;
1070 return 0;
1071
1072 nla_put_failure:
1073 return -EMSGSIZE;
1074 }
1075
can_newlink(struct net_device * dev,struct rtnl_newlink_params * params,struct netlink_ext_ack * extack)1076 static int can_newlink(struct net_device *dev,
1077 struct rtnl_newlink_params *params,
1078 struct netlink_ext_ack *extack)
1079 {
1080 return -EOPNOTSUPP;
1081 }
1082
can_dellink(struct net_device * dev,struct list_head * head)1083 static void can_dellink(struct net_device *dev, struct list_head *head)
1084 {
1085 }
1086
1087 struct rtnl_link_ops can_link_ops __read_mostly = {
1088 .kind = "can",
1089 .netns_refund = true,
1090 .maxtype = IFLA_CAN_MAX,
1091 .policy = can_policy,
1092 .setup = can_setup,
1093 .validate = can_validate,
1094 .newlink = can_newlink,
1095 .changelink = can_changelink,
1096 .dellink = can_dellink,
1097 .get_size = can_get_size,
1098 .fill_info = can_fill_info,
1099 .get_xstats_size = can_get_xstats_size,
1100 .fill_xstats = can_fill_xstats,
1101 };
1102
can_netlink_register(void)1103 int can_netlink_register(void)
1104 {
1105 return rtnl_link_register(&can_link_ops);
1106 }
1107
can_netlink_unregister(void)1108 void can_netlink_unregister(void)
1109 {
1110 rtnl_link_unregister(&can_link_ops);
1111 }
1112