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
11static 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
31static 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
43static 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
55static 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(nla: 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
76static 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: tb_tdc, maxtype: IFLA_CAN_TDC_MAX,
108 nla: data_tdc, policy: 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
135static 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: tb_pwm, maxtype: IFLA_CAN_PWM_MAX, nla: data[IFLA_CAN_XL_PWM],
150 policy: 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
169static 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_bittiming: 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
231static 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
257static 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(nla: 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, masked_flags: flags, mask: cm->mask);
279 if (err)
280 return err;
281 }
282
283 err = can_validate_bittiming(data, extack, ifla_can_bittiming: IFLA_CAN_BITTIMING);
284 if (err)
285 return err;
286
287 err = can_validate_databittiming(data, extack,
288 ifla_can_data_bittiming: IFLA_CAN_DATA_BITTIMING, flags);
289 if (err)
290 return err;
291
292 err = can_validate_databittiming(data, extack,
293 ifla_can_data_bittiming: 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
304static 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(nla: 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 can_set_cap_info(dev);
381
382 return 0;
383}
384
385static int can_tdc_changelink(struct data_bittiming_params *dbt_params,
386 const struct nlattr *nla,
387 struct netlink_ext_ack *extack)
388{
389 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
390 struct can_tdc tdc = { 0 };
391 const struct can_tdc_const *tdc_const = dbt_params->tdc_const;
392 int err;
393
394 if (!tdc_const) {
395 NL_SET_ERR_MSG(extack, "The device does not support TDC");
396 return -EOPNOTSUPP;
397 }
398
399 err = nla_parse_nested(tb: tb_tdc, maxtype: IFLA_CAN_TDC_MAX, nla,
400 policy: can_tdc_policy, extack);
401 if (err)
402 return err;
403
404 if (tb_tdc[IFLA_CAN_TDC_TDCV]) {
405 u32 tdcv = nla_get_u32(nla: tb_tdc[IFLA_CAN_TDC_TDCV]);
406
407 if (tdcv < tdc_const->tdcv_min || tdcv > tdc_const->tdcv_max)
408 return -EINVAL;
409
410 tdc.tdcv = tdcv;
411 }
412
413 if (tb_tdc[IFLA_CAN_TDC_TDCO]) {
414 u32 tdco = nla_get_u32(nla: tb_tdc[IFLA_CAN_TDC_TDCO]);
415
416 if (tdco < tdc_const->tdco_min || tdco > tdc_const->tdco_max)
417 return -EINVAL;
418
419 tdc.tdco = tdco;
420 }
421
422 if (tb_tdc[IFLA_CAN_TDC_TDCF]) {
423 u32 tdcf = nla_get_u32(nla: tb_tdc[IFLA_CAN_TDC_TDCF]);
424
425 if (tdcf < tdc_const->tdcf_min || tdcf > tdc_const->tdcf_max)
426 return -EINVAL;
427
428 tdc.tdcf = tdcf;
429 }
430
431 dbt_params->tdc = tdc;
432
433 return 0;
434}
435
436static int can_dbt_changelink(struct net_device *dev, struct nlattr *data[],
437 bool fd, struct netlink_ext_ack *extack)
438{
439 struct nlattr *data_bittiming, *data_tdc;
440 struct can_priv *priv = netdev_priv(dev);
441 struct data_bittiming_params *dbt_params;
442 struct can_bittiming dbt;
443 bool need_tdc_calc = false;
444 u32 tdc_mask;
445 int err;
446
447 if (fd) {
448 data_bittiming = data[IFLA_CAN_DATA_BITTIMING];
449 data_tdc = data[IFLA_CAN_TDC];
450 dbt_params = &priv->fd;
451 tdc_mask = CAN_CTRLMODE_FD_TDC_MASK;
452 } else {
453 data_bittiming = data[IFLA_CAN_XL_DATA_BITTIMING];
454 data_tdc = data[IFLA_CAN_XL_TDC];
455 dbt_params = &priv->xl;
456 tdc_mask = CAN_CTRLMODE_XL_TDC_MASK;
457 }
458
459 if (!data_bittiming)
460 return 0;
461
462 /* Do not allow changing bittiming while running */
463 if (dev->flags & IFF_UP)
464 return -EBUSY;
465
466 /* Calculate bittiming parameters based on data_bittiming_const
467 * if set, otherwise pass bitrate directly via do_set_bitrate().
468 * Bail out if neither is given.
469 */
470 if (!dbt_params->data_bittiming_const && !dbt_params->do_set_data_bittiming &&
471 !dbt_params->data_bitrate_const)
472 return -EOPNOTSUPP;
473
474 memcpy(&dbt, nla_data(data_bittiming), sizeof(dbt));
475 err = can_get_bittiming(dev, bt: &dbt, btc: dbt_params->data_bittiming_const,
476 bitrate_const: dbt_params->data_bitrate_const,
477 bitrate_const_cnt: dbt_params->data_bitrate_const_cnt, extack);
478 if (err)
479 return err;
480
481 if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
482 NL_SET_ERR_MSG_FMT(extack,
483 "CAN data bitrate %u bps surpasses transceiver capabilities of %u bps",
484 dbt.bitrate, priv->bitrate_max);
485 return -EINVAL;
486 }
487
488 memset(&dbt_params->tdc, 0, sizeof(dbt_params->tdc));
489 if (data[IFLA_CAN_CTRLMODE]) {
490 struct can_ctrlmode *cm = nla_data(nla: data[IFLA_CAN_CTRLMODE]);
491
492 if (fd || !(priv->ctrlmode & CAN_CTRLMODE_XL_TMS))
493 need_tdc_calc = !(cm->mask & tdc_mask);
494 }
495 if (data_tdc) {
496 /* TDC parameters are provided: use them */
497 err = can_tdc_changelink(dbt_params, nla: data_tdc, extack);
498 if (err) {
499 priv->ctrlmode &= ~tdc_mask;
500 return err;
501 }
502 } else if (need_tdc_calc) {
503 /* Neither of TDC parameters nor TDC flags are provided:
504 * do calculation
505 */
506 can_calc_tdco(tdc: &dbt_params->tdc, tdc_const: dbt_params->tdc_const, dbt: &dbt,
507 tdc_mask, ctrlmode: &priv->ctrlmode, ctrlmode_supported: priv->ctrlmode_supported);
508 } /* else: both CAN_CTRLMODE_{,XL}_TDC_{AUTO,MANUAL} are explicitly
509 * turned off. TDC is disabled: do nothing
510 */
511
512 memcpy(&dbt_params->data_bittiming, &dbt, sizeof(dbt));
513
514 if (dbt_params->do_set_data_bittiming) {
515 /* Finally, set the bit-timing registers */
516 err = dbt_params->do_set_data_bittiming(dev);
517 if (err)
518 return err;
519 }
520
521 return 0;
522}
523
524static int can_pwm_changelink(struct net_device *dev,
525 const struct nlattr *pwm_nla,
526 struct netlink_ext_ack *extack)
527{
528 struct can_priv *priv = netdev_priv(dev);
529 const struct can_pwm_const *pwm_const = priv->xl.pwm_const;
530 struct nlattr *tb_pwm[IFLA_CAN_PWM_MAX + 1];
531 struct can_pwm pwm = { 0 };
532 int err;
533
534 if (!(priv->ctrlmode & CAN_CTRLMODE_XL_TMS))
535 return 0;
536
537 if (!pwm_const) {
538 NL_SET_ERR_MSG(extack, "The device does not support PWM");
539 return -EOPNOTSUPP;
540 }
541
542 if (!pwm_nla)
543 return can_calc_pwm(dev, extack);
544
545 err = nla_parse_nested(tb: tb_pwm, maxtype: IFLA_CAN_PWM_MAX, nla: pwm_nla,
546 policy: can_pwm_policy, extack);
547 if (err)
548 return err;
549
550 if (tb_pwm[IFLA_CAN_PWM_PWMS]) {
551 pwm.pwms = nla_get_u32(nla: tb_pwm[IFLA_CAN_PWM_PWMS]);
552 if (pwm.pwms < pwm_const->pwms_min ||
553 pwm.pwms > pwm_const->pwms_max) {
554 NL_SET_ERR_MSG_FMT(extack,
555 "PWMS: %u tqmin is out of range: %u...%u",
556 pwm.pwms, pwm_const->pwms_min,
557 pwm_const->pwms_max);
558 return -EINVAL;
559 }
560 }
561
562 if (tb_pwm[IFLA_CAN_PWM_PWML]) {
563 pwm.pwml = nla_get_u32(nla: tb_pwm[IFLA_CAN_PWM_PWML]);
564 if (pwm.pwml < pwm_const->pwml_min ||
565 pwm.pwml > pwm_const->pwml_max) {
566 NL_SET_ERR_MSG_FMT(extack,
567 "PWML: %u tqmin is out of range: %u...%u",
568 pwm.pwml, pwm_const->pwml_min,
569 pwm_const->pwml_max);
570 return -EINVAL;
571 }
572 }
573
574 if (tb_pwm[IFLA_CAN_PWM_PWMO]) {
575 pwm.pwmo = nla_get_u32(nla: tb_pwm[IFLA_CAN_PWM_PWMO]);
576 if (pwm.pwmo < pwm_const->pwmo_min ||
577 pwm.pwmo > pwm_const->pwmo_max) {
578 NL_SET_ERR_MSG_FMT(extack,
579 "PWMO: %u tqmin is out of range: %u...%u",
580 pwm.pwmo, pwm_const->pwmo_min,
581 pwm_const->pwmo_max);
582 return -EINVAL;
583 }
584 }
585
586 err = can_validate_pwm_bittiming(dev, pwm: &pwm, extack);
587 if (err)
588 return err;
589
590 priv->xl.pwm = pwm;
591 return 0;
592}
593
594static int can_changelink(struct net_device *dev, struct nlattr *tb[],
595 struct nlattr *data[],
596 struct netlink_ext_ack *extack)
597{
598 struct can_priv *priv = netdev_priv(dev);
599 int err;
600
601 /* We need synchronization with dev->stop() */
602 ASSERT_RTNL();
603
604 can_ctrlmode_changelink(dev, data, extack);
605
606 if (data[IFLA_CAN_BITTIMING]) {
607 struct can_bittiming bt;
608
609 /* Do not allow changing bittiming while running */
610 if (dev->flags & IFF_UP)
611 return -EBUSY;
612
613 /* Calculate bittiming parameters based on
614 * bittiming_const if set, otherwise pass bitrate
615 * directly via do_set_bitrate(). Bail out if neither
616 * is given.
617 */
618 if (!priv->bittiming_const && !priv->do_set_bittiming &&
619 !priv->bitrate_const)
620 return -EOPNOTSUPP;
621
622 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
623 err = can_get_bittiming(dev, bt: &bt,
624 btc: priv->bittiming_const,
625 bitrate_const: priv->bitrate_const,
626 bitrate_const_cnt: priv->bitrate_const_cnt,
627 extack);
628 if (err)
629 return err;
630
631 if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) {
632 NL_SET_ERR_MSG_FMT(extack,
633 "arbitration bitrate %u bps surpasses transceiver capabilities of %u bps",
634 bt.bitrate, priv->bitrate_max);
635 return -EINVAL;
636 }
637
638 memcpy(&priv->bittiming, &bt, sizeof(bt));
639
640 if (priv->do_set_bittiming) {
641 /* Finally, set the bit-timing registers */
642 err = priv->do_set_bittiming(dev);
643 if (err)
644 return err;
645 }
646 }
647
648 if (data[IFLA_CAN_RESTART_MS]) {
649 unsigned int restart_ms = nla_get_u32(nla: data[IFLA_CAN_RESTART_MS]);
650
651 if (restart_ms != 0 && !priv->do_set_mode) {
652 NL_SET_ERR_MSG(extack,
653 "Device doesn't support restart from Bus Off");
654 return -EOPNOTSUPP;
655 }
656
657 /* Do not allow changing restart delay while running */
658 if (dev->flags & IFF_UP)
659 return -EBUSY;
660 priv->restart_ms = restart_ms;
661 }
662
663 if (data[IFLA_CAN_RESTART]) {
664 if (!priv->do_set_mode) {
665 NL_SET_ERR_MSG(extack,
666 "Device doesn't support restart from Bus Off");
667 return -EOPNOTSUPP;
668 }
669
670 /* Do not allow a restart while not running */
671 if (!(dev->flags & IFF_UP))
672 return -EINVAL;
673 err = can_restart_now(dev);
674 if (err)
675 return err;
676 }
677
678 /* CAN FD */
679 err = can_dbt_changelink(dev, data, fd: true, extack);
680 if (err)
681 return err;
682
683 /* CAN XL */
684 err = can_dbt_changelink(dev, data, fd: false, extack);
685 if (err)
686 return err;
687 err = can_pwm_changelink(dev, pwm_nla: data[IFLA_CAN_XL_PWM], extack);
688 if (err)
689 return err;
690
691 if (data[IFLA_CAN_TERMINATION]) {
692 const u16 termval = nla_get_u16(nla: data[IFLA_CAN_TERMINATION]);
693 const unsigned int num_term = priv->termination_const_cnt;
694 unsigned int i;
695
696 if (!priv->do_set_termination) {
697 NL_SET_ERR_MSG(extack,
698 "Termination is not configurable on this device");
699 return -EOPNOTSUPP;
700 }
701
702 /* check whether given value is supported by the interface */
703 for (i = 0; i < num_term; i++) {
704 if (termval == priv->termination_const[i])
705 break;
706 }
707 if (i >= num_term)
708 return -EINVAL;
709
710 /* Finally, set the termination value */
711 err = priv->do_set_termination(dev, termval);
712 if (err)
713 return err;
714
715 priv->termination = termval;
716 }
717
718 return 0;
719}
720
721static size_t can_tdc_get_size(struct data_bittiming_params *dbt_params,
722 u32 tdc_flags)
723{
724 bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK;
725 size_t size;
726
727 if (!dbt_params->tdc_const)
728 return 0;
729
730 size = nla_total_size(payload: 0); /* nest IFLA_CAN_TDC */
731 if (tdc_manual) {
732 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_TDCV_MIN */
733 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_TDCV_MAX */
734 }
735 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_TDCO_MIN */
736 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_TDCO_MAX */
737 if (dbt_params->tdc_const->tdcf_max) {
738 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_TDCF_MIN */
739 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_TDCF_MAX */
740 }
741
742 if (tdc_flags) {
743 if (tdc_manual || dbt_params->do_get_auto_tdcv)
744 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_TDCV */
745 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_TDCO */
746 if (dbt_params->tdc_const->tdcf_max)
747 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_TDCF */
748 }
749
750 return size;
751}
752
753static size_t can_data_bittiming_get_size(struct data_bittiming_params *dbt_params,
754 u32 tdc_flags)
755{
756 size_t size = 0;
757
758 if (dbt_params->data_bittiming.bitrate) /* IFLA_CAN_{,XL}_DATA_BITTIMING */
759 size += nla_total_size(payload: sizeof(dbt_params->data_bittiming));
760 if (dbt_params->data_bittiming_const) /* IFLA_CAN_{,XL}_DATA_BITTIMING_CONST */
761 size += nla_total_size(payload: sizeof(*dbt_params->data_bittiming_const));
762 if (dbt_params->data_bitrate_const) /* IFLA_CAN_{,XL}_DATA_BITRATE_CONST */
763 size += nla_total_size(payload: sizeof(*dbt_params->data_bitrate_const) *
764 dbt_params->data_bitrate_const_cnt);
765 size += can_tdc_get_size(dbt_params, tdc_flags);/* IFLA_CAN_{,XL}_TDC */
766
767 return size;
768}
769
770static size_t can_ctrlmode_ext_get_size(void)
771{
772 return nla_total_size(payload: 0) + /* nest IFLA_CAN_CTRLMODE_EXT */
773 nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_CTRLMODE_SUPPORTED */
774}
775
776static size_t can_pwm_get_size(const struct can_pwm_const *pwm_const,
777 bool pwm_on)
778{
779 size_t size;
780
781 if (!pwm_const || !pwm_on)
782 return 0;
783
784 size = nla_total_size(payload: 0); /* nest IFLA_CAN_PWM */
785
786 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_PWM_PWMS_MIN */
787 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_PWM_PWMS_MAX */
788 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_PWM_PWML_MIN */
789 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_PWM_PWML_MAX */
790 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_PWM_PWMO_MIN */
791 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_PWM_PWMO_MAX */
792
793 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_PWM_PWMS */
794 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_PWM_PWML */
795 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_PWM_PWMO */
796
797 return size;
798}
799
800static size_t can_get_size(const struct net_device *dev)
801{
802 struct can_priv *priv = netdev_priv(dev);
803 size_t size = 0;
804
805 if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */
806 size += nla_total_size(payload: sizeof(struct can_bittiming));
807 if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */
808 size += nla_total_size(payload: sizeof(struct can_bittiming_const));
809 size += nla_total_size(payload: sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */
810 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_STATE */
811 size += nla_total_size(payload: sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */
812 size += nla_total_size(payload: sizeof(u32)); /* IFLA_CAN_RESTART_MS */
813 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */
814 size += nla_total_size(payload: sizeof(struct can_berr_counter));
815 if (priv->termination_const) {
816 size += nla_total_size(payload: sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */
817 size += nla_total_size(payload: sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */
818 priv->termination_const_cnt);
819 }
820 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */
821 size += nla_total_size(payload: sizeof(*priv->bitrate_const) *
822 priv->bitrate_const_cnt);
823 size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */
824 size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */
825
826 size += can_data_bittiming_get_size(dbt_params: &priv->fd,
827 tdc_flags: priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK);
828
829 size += can_data_bittiming_get_size(dbt_params: &priv->xl,
830 tdc_flags: priv->ctrlmode & CAN_CTRLMODE_XL_TDC_MASK);
831 size += can_pwm_get_size(pwm_const: priv->xl.pwm_const, /* IFLA_CAN_XL_PWM */
832 pwm_on: priv->ctrlmode & CAN_CTRLMODE_XL_TMS);
833
834 return size;
835}
836
837static int can_bittiming_fill_info(struct sk_buff *skb, int ifla_can_bittiming,
838 struct can_bittiming *bittiming)
839{
840 return bittiming->bitrate != CAN_BITRATE_UNSET &&
841 bittiming->bitrate != CAN_BITRATE_UNKNOWN &&
842 nla_put(skb, attrtype: ifla_can_bittiming, attrlen: sizeof(*bittiming), data: bittiming);
843}
844
845static int can_bittiming_const_fill_info(struct sk_buff *skb,
846 int ifla_can_bittiming_const,
847 const struct can_bittiming_const *bittiming_const)
848{
849 return bittiming_const &&
850 nla_put(skb, attrtype: ifla_can_bittiming_const,
851 attrlen: sizeof(*bittiming_const), data: bittiming_const);
852}
853
854static int can_bitrate_const_fill_info(struct sk_buff *skb,
855 int ifla_can_bitrate_const,
856 const u32 *bitrate_const, unsigned int cnt)
857{
858 return bitrate_const &&
859 nla_put(skb, attrtype: ifla_can_bitrate_const,
860 attrlen: sizeof(*bitrate_const) * cnt, data: bitrate_const);
861}
862
863static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev,
864 int ifla_can_tdc)
865{
866 struct can_priv *priv = netdev_priv(dev);
867 struct data_bittiming_params *dbt_params;
868 const struct can_tdc_const *tdc_const;
869 struct can_tdc *tdc;
870 struct nlattr *nest;
871 bool tdc_is_enabled, tdc_manual;
872
873 if (ifla_can_tdc == IFLA_CAN_TDC) {
874 dbt_params = &priv->fd;
875 tdc_is_enabled = can_fd_tdc_is_enabled(priv);
876 tdc_manual = priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL;
877 } else {
878 dbt_params = &priv->xl;
879 tdc_is_enabled = can_xl_tdc_is_enabled(priv);
880 tdc_manual = priv->ctrlmode & CAN_CTRLMODE_XL_TDC_MANUAL;
881 }
882 tdc_const = dbt_params->tdc_const;
883 tdc = &dbt_params->tdc;
884
885 if (!tdc_const)
886 return 0;
887
888 nest = nla_nest_start(skb, attrtype: ifla_can_tdc);
889 if (!nest)
890 return -EMSGSIZE;
891
892 if (tdc_manual &&
893 (nla_put_u32(skb, attrtype: IFLA_CAN_TDC_TDCV_MIN, value: tdc_const->tdcv_min) ||
894 nla_put_u32(skb, attrtype: IFLA_CAN_TDC_TDCV_MAX, value: tdc_const->tdcv_max)))
895 goto err_cancel;
896 if (nla_put_u32(skb, attrtype: IFLA_CAN_TDC_TDCO_MIN, value: tdc_const->tdco_min) ||
897 nla_put_u32(skb, attrtype: IFLA_CAN_TDC_TDCO_MAX, value: tdc_const->tdco_max))
898 goto err_cancel;
899 if (tdc_const->tdcf_max &&
900 (nla_put_u32(skb, attrtype: IFLA_CAN_TDC_TDCF_MIN, value: tdc_const->tdcf_min) ||
901 nla_put_u32(skb, attrtype: IFLA_CAN_TDC_TDCF_MAX, value: tdc_const->tdcf_max)))
902 goto err_cancel;
903
904 if (tdc_is_enabled) {
905 u32 tdcv;
906 int err = -EINVAL;
907
908 if (tdc_manual) {
909 tdcv = tdc->tdcv;
910 err = 0;
911 } else if (dbt_params->do_get_auto_tdcv) {
912 err = dbt_params->do_get_auto_tdcv(dev, &tdcv);
913 }
914 if (!err && nla_put_u32(skb, attrtype: IFLA_CAN_TDC_TDCV, value: tdcv))
915 goto err_cancel;
916 if (nla_put_u32(skb, attrtype: IFLA_CAN_TDC_TDCO, value: tdc->tdco))
917 goto err_cancel;
918 if (tdc_const->tdcf_max &&
919 nla_put_u32(skb, attrtype: IFLA_CAN_TDC_TDCF, value: tdc->tdcf))
920 goto err_cancel;
921 }
922
923 nla_nest_end(skb, start: nest);
924 return 0;
925
926err_cancel:
927 nla_nest_cancel(skb, start: nest);
928 return -EMSGSIZE;
929}
930
931static int can_pwm_fill_info(struct sk_buff *skb, const struct can_priv *priv)
932{
933 const struct can_pwm_const *pwm_const = priv->xl.pwm_const;
934 const struct can_pwm *pwm = &priv->xl.pwm;
935 struct nlattr *nest;
936
937 if (!pwm_const)
938 return 0;
939
940 nest = nla_nest_start(skb, attrtype: IFLA_CAN_XL_PWM);
941 if (!nest)
942 return -EMSGSIZE;
943
944 if (nla_put_u32(skb, attrtype: IFLA_CAN_PWM_PWMS_MIN, value: pwm_const->pwms_min) ||
945 nla_put_u32(skb, attrtype: IFLA_CAN_PWM_PWMS_MAX, value: pwm_const->pwms_max) ||
946 nla_put_u32(skb, attrtype: IFLA_CAN_PWM_PWML_MIN, value: pwm_const->pwml_min) ||
947 nla_put_u32(skb, attrtype: IFLA_CAN_PWM_PWML_MAX, value: pwm_const->pwml_max) ||
948 nla_put_u32(skb, attrtype: IFLA_CAN_PWM_PWMO_MIN, value: pwm_const->pwmo_min) ||
949 nla_put_u32(skb, attrtype: IFLA_CAN_PWM_PWMO_MAX, value: pwm_const->pwmo_max))
950 goto err_cancel;
951
952 if (priv->ctrlmode & CAN_CTRLMODE_XL_TMS) {
953 if (nla_put_u32(skb, attrtype: IFLA_CAN_PWM_PWMS, value: pwm->pwms) ||
954 nla_put_u32(skb, attrtype: IFLA_CAN_PWM_PWML, value: pwm->pwml) ||
955 nla_put_u32(skb, attrtype: IFLA_CAN_PWM_PWMO, value: pwm->pwmo))
956 goto err_cancel;
957 }
958
959 nla_nest_end(skb, start: nest);
960 return 0;
961
962err_cancel:
963 nla_nest_cancel(skb, start: nest);
964 return -EMSGSIZE;
965}
966
967static int can_ctrlmode_ext_fill_info(struct sk_buff *skb,
968 const struct can_priv *priv)
969{
970 struct nlattr *nest;
971
972 nest = nla_nest_start(skb, attrtype: IFLA_CAN_CTRLMODE_EXT);
973 if (!nest)
974 return -EMSGSIZE;
975
976 if (nla_put_u32(skb, attrtype: IFLA_CAN_CTRLMODE_SUPPORTED,
977 value: priv->ctrlmode_supported)) {
978 nla_nest_cancel(skb, start: nest);
979 return -EMSGSIZE;
980 }
981
982 nla_nest_end(skb, start: nest);
983 return 0;
984}
985
986static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
987{
988 struct can_priv *priv = netdev_priv(dev);
989 struct can_ctrlmode cm = {.flags = priv->ctrlmode};
990 struct can_berr_counter bec = { };
991 enum can_state state = priv->state;
992
993 if (priv->do_get_state)
994 priv->do_get_state(dev, &state);
995
996 if (can_bittiming_fill_info(skb, ifla_can_bittiming: IFLA_CAN_BITTIMING,
997 bittiming: &priv->bittiming) ||
998
999 can_bittiming_const_fill_info(skb, ifla_can_bittiming_const: IFLA_CAN_BITTIMING_CONST,
1000 bittiming_const: priv->bittiming_const) ||
1001
1002 nla_put(skb, attrtype: IFLA_CAN_CLOCK, attrlen: sizeof(priv->clock), data: &priv->clock) ||
1003 nla_put_u32(skb, attrtype: IFLA_CAN_STATE, value: state) ||
1004 nla_put(skb, attrtype: IFLA_CAN_CTRLMODE, attrlen: sizeof(cm), data: &cm) ||
1005 nla_put_u32(skb, attrtype: IFLA_CAN_RESTART_MS, value: priv->restart_ms) ||
1006
1007 (priv->do_get_berr_counter &&
1008 !priv->do_get_berr_counter(dev, &bec) &&
1009 nla_put(skb, attrtype: IFLA_CAN_BERR_COUNTER, attrlen: sizeof(bec), data: &bec)) ||
1010
1011 can_bittiming_fill_info(skb, ifla_can_bittiming: IFLA_CAN_DATA_BITTIMING,
1012 bittiming: &priv->fd.data_bittiming) ||
1013
1014 can_bittiming_const_fill_info(skb, ifla_can_bittiming_const: IFLA_CAN_DATA_BITTIMING_CONST,
1015 bittiming_const: priv->fd.data_bittiming_const) ||
1016
1017 (priv->termination_const &&
1018 (nla_put_u16(skb, attrtype: IFLA_CAN_TERMINATION, value: priv->termination) ||
1019 nla_put(skb, attrtype: IFLA_CAN_TERMINATION_CONST,
1020 attrlen: sizeof(*priv->termination_const) *
1021 priv->termination_const_cnt,
1022 data: priv->termination_const))) ||
1023
1024 can_bitrate_const_fill_info(skb, ifla_can_bitrate_const: IFLA_CAN_BITRATE_CONST,
1025 bitrate_const: priv->bitrate_const,
1026 cnt: priv->bitrate_const_cnt) ||
1027
1028 can_bitrate_const_fill_info(skb, ifla_can_bitrate_const: IFLA_CAN_DATA_BITRATE_CONST,
1029 bitrate_const: priv->fd.data_bitrate_const,
1030 cnt: priv->fd.data_bitrate_const_cnt) ||
1031
1032 (nla_put(skb, attrtype: IFLA_CAN_BITRATE_MAX,
1033 attrlen: sizeof(priv->bitrate_max),
1034 data: &priv->bitrate_max)) ||
1035
1036 can_tdc_fill_info(skb, dev, ifla_can_tdc: IFLA_CAN_TDC) ||
1037
1038 can_ctrlmode_ext_fill_info(skb, priv) ||
1039
1040 can_bittiming_fill_info(skb, ifla_can_bittiming: IFLA_CAN_XL_DATA_BITTIMING,
1041 bittiming: &priv->xl.data_bittiming) ||
1042
1043 can_bittiming_const_fill_info(skb, ifla_can_bittiming_const: IFLA_CAN_XL_DATA_BITTIMING_CONST,
1044 bittiming_const: priv->xl.data_bittiming_const) ||
1045
1046 can_bitrate_const_fill_info(skb, ifla_can_bitrate_const: IFLA_CAN_XL_DATA_BITRATE_CONST,
1047 bitrate_const: priv->xl.data_bitrate_const,
1048 cnt: priv->xl.data_bitrate_const_cnt) ||
1049
1050 can_tdc_fill_info(skb, dev, ifla_can_tdc: IFLA_CAN_XL_TDC) ||
1051
1052 can_pwm_fill_info(skb, priv)
1053 )
1054 return -EMSGSIZE;
1055
1056 return 0;
1057}
1058
1059static size_t can_get_xstats_size(const struct net_device *dev)
1060{
1061 return sizeof(struct can_device_stats);
1062}
1063
1064static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)
1065{
1066 struct can_priv *priv = netdev_priv(dev);
1067
1068 if (nla_put(skb, attrtype: IFLA_INFO_XSTATS,
1069 attrlen: sizeof(priv->can_stats), data: &priv->can_stats))
1070 goto nla_put_failure;
1071 return 0;
1072
1073nla_put_failure:
1074 return -EMSGSIZE;
1075}
1076
1077static int can_newlink(struct net_device *dev,
1078 struct rtnl_newlink_params *params,
1079 struct netlink_ext_ack *extack)
1080{
1081 return -EOPNOTSUPP;
1082}
1083
1084static void can_dellink(struct net_device *dev, struct list_head *head)
1085{
1086}
1087
1088struct rtnl_link_ops can_link_ops __read_mostly = {
1089 .kind = "can",
1090 .netns_refund = true,
1091 .maxtype = IFLA_CAN_MAX,
1092 .policy = can_policy,
1093 .setup = can_setup,
1094 .validate = can_validate,
1095 .newlink = can_newlink,
1096 .changelink = can_changelink,
1097 .dellink = can_dellink,
1098 .get_size = can_get_size,
1099 .fill_info = can_fill_info,
1100 .get_xstats_size = can_get_xstats_size,
1101 .fill_xstats = can_fill_xstats,
1102};
1103
1104int can_netlink_register(void)
1105{
1106 return rtnl_link_register(ops: &can_link_ops);
1107}
1108
1109void can_netlink_unregister(void)
1110{
1111 rtnl_link_unregister(ops: &can_link_ops);
1112}
1113

source code of linux/drivers/net/can/dev/netlink.c