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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 1058 static size_t can_get_xstats_size(const struct net_device *dev) 1059 { 1060 return sizeof(struct can_device_stats); 1061 } 1062 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 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 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 1103 int can_netlink_register(void) 1104 { 1105 return rtnl_link_register(&can_link_ops); 1106 } 1107 1108 void can_netlink_unregister(void) 1109 { 1110 rtnl_link_unregister(&can_link_ops); 1111 } 1112