1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix 3 * Copyright (C) 2006 Andrey Volkov, Varma Electronics 4 * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com> 5 * Copyright (C) 2021 Vincent Mailhol <mailhol.vincent@wanadoo.fr> 6 */ 7 8 #include <linux/can/dev.h> 9 #include <net/rtnetlink.h> 10 11 static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = { 12 [IFLA_CAN_STATE] = { .type = NLA_U32 }, 13 [IFLA_CAN_CTRLMODE] = { .len = sizeof(struct can_ctrlmode) }, 14 [IFLA_CAN_RESTART_MS] = { .type = NLA_U32 }, 15 [IFLA_CAN_RESTART] = { .type = NLA_U32 }, 16 [IFLA_CAN_BITTIMING] = { .len = sizeof(struct can_bittiming) }, 17 [IFLA_CAN_BITTIMING_CONST] = { .len = sizeof(struct can_bittiming_const) }, 18 [IFLA_CAN_CLOCK] = { .len = sizeof(struct can_clock) }, 19 [IFLA_CAN_BERR_COUNTER] = { .len = sizeof(struct can_berr_counter) }, 20 [IFLA_CAN_DATA_BITTIMING] = { .len = sizeof(struct can_bittiming) }, 21 [IFLA_CAN_DATA_BITTIMING_CONST] = { .len = sizeof(struct can_bittiming_const) }, 22 [IFLA_CAN_TERMINATION] = { .type = NLA_U16 }, 23 [IFLA_CAN_TDC] = { .type = NLA_NESTED }, 24 [IFLA_CAN_CTRLMODE_EXT] = { .type = NLA_NESTED }, 25 }; 26 27 static const struct nla_policy can_tdc_policy[IFLA_CAN_TDC_MAX + 1] = { 28 [IFLA_CAN_TDC_TDCV_MIN] = { .type = NLA_U32 }, 29 [IFLA_CAN_TDC_TDCV_MAX] = { .type = NLA_U32 }, 30 [IFLA_CAN_TDC_TDCO_MIN] = { .type = NLA_U32 }, 31 [IFLA_CAN_TDC_TDCO_MAX] = { .type = NLA_U32 }, 32 [IFLA_CAN_TDC_TDCF_MIN] = { .type = NLA_U32 }, 33 [IFLA_CAN_TDC_TDCF_MAX] = { .type = NLA_U32 }, 34 [IFLA_CAN_TDC_TDCV] = { .type = NLA_U32 }, 35 [IFLA_CAN_TDC_TDCO] = { .type = NLA_U32 }, 36 [IFLA_CAN_TDC_TDCF] = { .type = NLA_U32 }, 37 }; 38 39 static int can_validate_bittiming(struct nlattr *data[], 40 struct netlink_ext_ack *extack, 41 int ifla_can_bittiming) 42 { 43 struct can_bittiming *bt; 44 45 if (!data[ifla_can_bittiming]) 46 return 0; 47 48 static_assert(__alignof__(*bt) <= NLA_ALIGNTO); 49 bt = nla_data(data[ifla_can_bittiming]); 50 51 /* sample point is in one-tenth of a percent */ 52 if (bt->sample_point >= 1000) { 53 NL_SET_ERR_MSG(extack, "sample point must be between 0 and 100%"); 54 return -EINVAL; 55 } 56 57 return 0; 58 } 59 60 static int can_validate_tdc(struct nlattr *data_tdc, 61 struct netlink_ext_ack *extack, u32 tdc_flags) 62 { 63 bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK; 64 bool tdc_auto = tdc_flags & CAN_CTRLMODE_TDC_AUTO_MASK; 65 int err; 66 67 if (tdc_auto && tdc_manual) { 68 NL_SET_ERR_MSG(extack, 69 "TDC manual and auto modes are mutually exclusive"); 70 return -EOPNOTSUPP; 71 } 72 73 /* If one of the CAN_CTRLMODE_TDC_* flag is set then TDC 74 * must be set and vice-versa 75 */ 76 if ((tdc_auto || tdc_manual) && !data_tdc) { 77 NL_SET_ERR_MSG(extack, "TDC parameters are missing"); 78 return -EOPNOTSUPP; 79 } 80 if (!(tdc_auto || tdc_manual) && data_tdc) { 81 NL_SET_ERR_MSG(extack, "TDC mode (auto or manual) is missing"); 82 return -EOPNOTSUPP; 83 } 84 85 /* If providing TDC parameters, at least TDCO is needed. TDCV 86 * is needed if and only if CAN_CTRLMODE_TDC_MANUAL is set 87 */ 88 if (data_tdc) { 89 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1]; 90 91 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, 92 data_tdc, can_tdc_policy, extack); 93 if (err) 94 return err; 95 96 if (tb_tdc[IFLA_CAN_TDC_TDCV]) { 97 if (tdc_auto) { 98 NL_SET_ERR_MSG(extack, 99 "TDCV is incompatible with TDC auto mode"); 100 return -EOPNOTSUPP; 101 } 102 } else { 103 if (tdc_manual) { 104 NL_SET_ERR_MSG(extack, 105 "TDC manual mode requires TDCV"); 106 return -EOPNOTSUPP; 107 } 108 } 109 110 if (!tb_tdc[IFLA_CAN_TDC_TDCO]) { 111 NL_SET_ERR_MSG(extack, "TDCO is missing"); 112 return -EOPNOTSUPP; 113 } 114 } 115 116 return 0; 117 } 118 119 static int can_validate_databittiming(struct nlattr *data[], 120 struct netlink_ext_ack *extack, 121 int ifla_can_data_bittiming, u32 flags) 122 { 123 struct nlattr *data_tdc; 124 const char *type; 125 u32 tdc_flags; 126 bool is_on; 127 int err; 128 129 /* Make sure that valid CAN FD configurations always consist of 130 * - nominal/arbitration bittiming 131 * - data bittiming 132 * - control mode with CAN_CTRLMODE_FD set 133 * - TDC parameters are coherent (details in can_validate_tdc()) 134 */ 135 136 if (ifla_can_data_bittiming == IFLA_CAN_DATA_BITTIMING) { 137 data_tdc = data[IFLA_CAN_TDC]; 138 tdc_flags = flags & CAN_CTRLMODE_FD_TDC_MASK; 139 is_on = flags & CAN_CTRLMODE_FD; 140 type = "FD"; 141 } else { 142 return -EOPNOTSUPP; /* Place holder for CAN XL */ 143 } 144 145 if (is_on) { 146 if (!data[IFLA_CAN_BITTIMING] || !data[ifla_can_data_bittiming]) { 147 NL_SET_ERR_MSG_FMT(extack, 148 "Provide both nominal and %s data bittiming", 149 type); 150 return -EOPNOTSUPP; 151 } 152 } else { 153 if (data[ifla_can_data_bittiming]) { 154 NL_SET_ERR_MSG_FMT(extack, 155 "%s data bittiming requires CAN %s", 156 type, type); 157 return -EOPNOTSUPP; 158 } 159 if (data_tdc) { 160 NL_SET_ERR_MSG_FMT(extack, 161 "%s TDC requires CAN %s", 162 type, type); 163 return -EOPNOTSUPP; 164 } 165 } 166 167 err = can_validate_bittiming(data, extack, ifla_can_data_bittiming); 168 if (err) 169 return err; 170 171 err = can_validate_tdc(data_tdc, extack, tdc_flags); 172 if (err) 173 return err; 174 175 return 0; 176 } 177 178 static int can_validate(struct nlattr *tb[], struct nlattr *data[], 179 struct netlink_ext_ack *extack) 180 { 181 u32 flags = 0; 182 int err; 183 184 if (!data) 185 return 0; 186 187 if (data[IFLA_CAN_CTRLMODE]) { 188 struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]); 189 190 flags = cm->flags & cm->mask; 191 } 192 193 err = can_validate_bittiming(data, extack, IFLA_CAN_BITTIMING); 194 if (err) 195 return err; 196 197 err = can_validate_databittiming(data, extack, 198 IFLA_CAN_DATA_BITTIMING, flags); 199 if (err) 200 return err; 201 202 return 0; 203 } 204 205 static int can_ctrlmode_changelink(struct net_device *dev, 206 struct nlattr *data[], 207 struct netlink_ext_ack *extack) 208 { 209 struct can_priv *priv = netdev_priv(dev); 210 struct can_ctrlmode *cm; 211 u32 ctrlstatic, maskedflags, notsupp, ctrlstatic_missing; 212 213 if (!data[IFLA_CAN_CTRLMODE]) 214 return 0; 215 216 /* Do not allow changing controller mode while running */ 217 if (dev->flags & IFF_UP) 218 return -EBUSY; 219 220 cm = nla_data(data[IFLA_CAN_CTRLMODE]); 221 ctrlstatic = can_get_static_ctrlmode(priv); 222 maskedflags = cm->flags & cm->mask; 223 notsupp = maskedflags & ~(priv->ctrlmode_supported | ctrlstatic); 224 ctrlstatic_missing = (maskedflags & ctrlstatic) ^ ctrlstatic; 225 226 if (notsupp) { 227 NL_SET_ERR_MSG_FMT(extack, 228 "requested control mode %s not supported", 229 can_get_ctrlmode_str(notsupp)); 230 return -EOPNOTSUPP; 231 } 232 233 /* do not check for static fd-non-iso if 'fd' is disabled */ 234 if (!(maskedflags & CAN_CTRLMODE_FD)) 235 ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO; 236 237 if (ctrlstatic_missing) { 238 NL_SET_ERR_MSG_FMT(extack, 239 "missing required %s static control mode", 240 can_get_ctrlmode_str(ctrlstatic_missing)); 241 return -EOPNOTSUPP; 242 } 243 244 /* If a top dependency flag is provided, reset all its dependencies */ 245 if (cm->mask & CAN_CTRLMODE_FD) 246 priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK; 247 248 /* clear bits to be modified and copy the flag values */ 249 priv->ctrlmode &= ~cm->mask; 250 priv->ctrlmode |= maskedflags; 251 252 /* Wipe potential leftovers from previous CAN FD config */ 253 if (!(priv->ctrlmode & CAN_CTRLMODE_FD)) { 254 memset(&priv->fd.data_bittiming, 0, 255 sizeof(priv->fd.data_bittiming)); 256 priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK; 257 memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc)); 258 } 259 260 can_set_default_mtu(dev); 261 262 return 0; 263 } 264 265 static int can_tdc_changelink(struct data_bittiming_params *dbt_params, 266 const struct nlattr *nla, 267 struct netlink_ext_ack *extack) 268 { 269 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1]; 270 struct can_tdc tdc = { 0 }; 271 const struct can_tdc_const *tdc_const = dbt_params->tdc_const; 272 int err; 273 274 if (!tdc_const) { 275 NL_SET_ERR_MSG(extack, "The device does not support TDC"); 276 return -EOPNOTSUPP; 277 } 278 279 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, nla, 280 can_tdc_policy, extack); 281 if (err) 282 return err; 283 284 if (tb_tdc[IFLA_CAN_TDC_TDCV]) { 285 u32 tdcv = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCV]); 286 287 if (tdcv < tdc_const->tdcv_min || tdcv > tdc_const->tdcv_max) 288 return -EINVAL; 289 290 tdc.tdcv = tdcv; 291 } 292 293 if (tb_tdc[IFLA_CAN_TDC_TDCO]) { 294 u32 tdco = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCO]); 295 296 if (tdco < tdc_const->tdco_min || tdco > tdc_const->tdco_max) 297 return -EINVAL; 298 299 tdc.tdco = tdco; 300 } 301 302 if (tb_tdc[IFLA_CAN_TDC_TDCF]) { 303 u32 tdcf = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCF]); 304 305 if (tdcf < tdc_const->tdcf_min || tdcf > tdc_const->tdcf_max) 306 return -EINVAL; 307 308 tdc.tdcf = tdcf; 309 } 310 311 dbt_params->tdc = tdc; 312 313 return 0; 314 } 315 316 static int can_dbt_changelink(struct net_device *dev, struct nlattr *data[], 317 bool fd, struct netlink_ext_ack *extack) 318 { 319 struct nlattr *data_bittiming, *data_tdc; 320 struct can_priv *priv = netdev_priv(dev); 321 struct data_bittiming_params *dbt_params; 322 struct can_bittiming dbt; 323 bool need_tdc_calc = false; 324 u32 tdc_mask; 325 int err; 326 327 if (fd) { 328 data_bittiming = data[IFLA_CAN_DATA_BITTIMING]; 329 data_tdc = data[IFLA_CAN_TDC]; 330 dbt_params = &priv->fd; 331 tdc_mask = CAN_CTRLMODE_FD_TDC_MASK; 332 } else { 333 return -EOPNOTSUPP; /* Place holder for CAN XL */ 334 } 335 336 if (!data_bittiming) 337 return 0; 338 339 /* Do not allow changing bittiming while running */ 340 if (dev->flags & IFF_UP) 341 return -EBUSY; 342 343 /* Calculate bittiming parameters based on data_bittiming_const 344 * if set, otherwise pass bitrate directly via do_set_bitrate(). 345 * Bail out if neither is given. 346 */ 347 if (!dbt_params->data_bittiming_const && !dbt_params->do_set_data_bittiming && 348 !dbt_params->data_bitrate_const) 349 return -EOPNOTSUPP; 350 351 memcpy(&dbt, nla_data(data_bittiming), sizeof(dbt)); 352 err = can_get_bittiming(dev, &dbt, dbt_params->data_bittiming_const, 353 dbt_params->data_bitrate_const, 354 dbt_params->data_bitrate_const_cnt, extack); 355 if (err) 356 return err; 357 358 if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) { 359 NL_SET_ERR_MSG_FMT(extack, 360 "CAN data bitrate %u bps surpasses transceiver capabilities of %u bps", 361 dbt.bitrate, priv->bitrate_max); 362 return -EINVAL; 363 } 364 365 memset(&dbt_params->tdc, 0, sizeof(dbt_params->tdc)); 366 if (data[IFLA_CAN_CTRLMODE]) { 367 struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]); 368 369 need_tdc_calc = !(cm->mask & tdc_mask); 370 } 371 if (data_tdc) { 372 /* TDC parameters are provided: use them */ 373 err = can_tdc_changelink(dbt_params, data_tdc, extack); 374 if (err) { 375 priv->ctrlmode &= ~tdc_mask; 376 return err; 377 } 378 } else if (need_tdc_calc) { 379 /* Neither of TDC parameters nor TDC flags are provided: 380 * do calculation 381 */ 382 can_calc_tdco(&dbt_params->tdc, dbt_params->tdc_const, &dbt, 383 tdc_mask, &priv->ctrlmode, priv->ctrlmode_supported); 384 } /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly 385 * turned off. TDC is disabled: do nothing 386 */ 387 388 memcpy(&dbt_params->data_bittiming, &dbt, sizeof(dbt)); 389 390 if (dbt_params->do_set_data_bittiming) { 391 /* Finally, set the bit-timing registers */ 392 err = dbt_params->do_set_data_bittiming(dev); 393 if (err) 394 return err; 395 } 396 397 return 0; 398 } 399 400 static int can_changelink(struct net_device *dev, struct nlattr *tb[], 401 struct nlattr *data[], 402 struct netlink_ext_ack *extack) 403 { 404 struct can_priv *priv = netdev_priv(dev); 405 int err; 406 407 /* We need synchronization with dev->stop() */ 408 ASSERT_RTNL(); 409 410 can_ctrlmode_changelink(dev, data, extack); 411 412 if (data[IFLA_CAN_BITTIMING]) { 413 struct can_bittiming bt; 414 415 /* Do not allow changing bittiming while running */ 416 if (dev->flags & IFF_UP) 417 return -EBUSY; 418 419 /* Calculate bittiming parameters based on 420 * bittiming_const if set, otherwise pass bitrate 421 * directly via do_set_bitrate(). Bail out if neither 422 * is given. 423 */ 424 if (!priv->bittiming_const && !priv->do_set_bittiming && 425 !priv->bitrate_const) 426 return -EOPNOTSUPP; 427 428 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt)); 429 err = can_get_bittiming(dev, &bt, 430 priv->bittiming_const, 431 priv->bitrate_const, 432 priv->bitrate_const_cnt, 433 extack); 434 if (err) 435 return err; 436 437 if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) { 438 NL_SET_ERR_MSG_FMT(extack, 439 "arbitration bitrate %u bps surpasses transceiver capabilities of %u bps", 440 bt.bitrate, priv->bitrate_max); 441 return -EINVAL; 442 } 443 444 memcpy(&priv->bittiming, &bt, sizeof(bt)); 445 446 if (priv->do_set_bittiming) { 447 /* Finally, set the bit-timing registers */ 448 err = priv->do_set_bittiming(dev); 449 if (err) 450 return err; 451 } 452 } 453 454 if (data[IFLA_CAN_RESTART_MS]) { 455 unsigned int restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]); 456 457 if (restart_ms != 0 && !priv->do_set_mode) { 458 NL_SET_ERR_MSG(extack, 459 "Device doesn't support restart from Bus Off"); 460 return -EOPNOTSUPP; 461 } 462 463 /* Do not allow changing restart delay while running */ 464 if (dev->flags & IFF_UP) 465 return -EBUSY; 466 priv->restart_ms = restart_ms; 467 } 468 469 if (data[IFLA_CAN_RESTART]) { 470 if (!priv->do_set_mode) { 471 NL_SET_ERR_MSG(extack, 472 "Device doesn't support restart from Bus Off"); 473 return -EOPNOTSUPP; 474 } 475 476 /* Do not allow a restart while not running */ 477 if (!(dev->flags & IFF_UP)) 478 return -EINVAL; 479 err = can_restart_now(dev); 480 if (err) 481 return err; 482 } 483 484 /* CAN FD */ 485 err = can_dbt_changelink(dev, data, true, extack); 486 if (err) 487 return err; 488 489 if (data[IFLA_CAN_TERMINATION]) { 490 const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]); 491 const unsigned int num_term = priv->termination_const_cnt; 492 unsigned int i; 493 494 if (!priv->do_set_termination) { 495 NL_SET_ERR_MSG(extack, 496 "Termination is not configurable on this device"); 497 return -EOPNOTSUPP; 498 } 499 500 /* check whether given value is supported by the interface */ 501 for (i = 0; i < num_term; i++) { 502 if (termval == priv->termination_const[i]) 503 break; 504 } 505 if (i >= num_term) 506 return -EINVAL; 507 508 /* Finally, set the termination value */ 509 err = priv->do_set_termination(dev, termval); 510 if (err) 511 return err; 512 513 priv->termination = termval; 514 } 515 516 return 0; 517 } 518 519 static size_t can_tdc_get_size(struct data_bittiming_params *dbt_params, 520 u32 tdc_flags) 521 { 522 bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK; 523 size_t size; 524 525 if (!dbt_params->tdc_const) 526 return 0; 527 528 size = nla_total_size(0); /* nest IFLA_CAN_TDC */ 529 if (tdc_manual) { 530 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MIN */ 531 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MAX */ 532 } 533 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */ 534 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */ 535 if (dbt_params->tdc_const->tdcf_max) { 536 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */ 537 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */ 538 } 539 540 if (tdc_flags) { 541 if (tdc_manual || dbt_params->do_get_auto_tdcv) 542 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */ 543 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */ 544 if (dbt_params->tdc_const->tdcf_max) 545 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */ 546 } 547 548 return size; 549 } 550 551 static size_t can_data_bittiming_get_size(struct data_bittiming_params *dbt_params, 552 u32 tdc_flags) 553 { 554 size_t size = 0; 555 556 if (dbt_params->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */ 557 size += nla_total_size(sizeof(dbt_params->data_bittiming)); 558 if (dbt_params->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */ 559 size += nla_total_size(sizeof(*dbt_params->data_bittiming_const)); 560 if (dbt_params->data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */ 561 size += nla_total_size(sizeof(*dbt_params->data_bitrate_const) * 562 dbt_params->data_bitrate_const_cnt); 563 size += can_tdc_get_size(dbt_params, tdc_flags);/* IFLA_CAN_TDC */ 564 565 return size; 566 } 567 568 static size_t can_ctrlmode_ext_get_size(void) 569 { 570 return nla_total_size(0) + /* nest IFLA_CAN_CTRLMODE_EXT */ 571 nla_total_size(sizeof(u32)); /* IFLA_CAN_CTRLMODE_SUPPORTED */ 572 } 573 574 static size_t can_get_size(const struct net_device *dev) 575 { 576 struct can_priv *priv = netdev_priv(dev); 577 size_t size = 0; 578 579 if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */ 580 size += nla_total_size(sizeof(struct can_bittiming)); 581 if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */ 582 size += nla_total_size(sizeof(struct can_bittiming_const)); 583 size += nla_total_size(sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */ 584 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_STATE */ 585 size += nla_total_size(sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */ 586 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */ 587 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */ 588 size += nla_total_size(sizeof(struct can_berr_counter)); 589 if (priv->termination_const) { 590 size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */ 591 size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */ 592 priv->termination_const_cnt); 593 } 594 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */ 595 size += nla_total_size(sizeof(*priv->bitrate_const) * 596 priv->bitrate_const_cnt); 597 size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */ 598 size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */ 599 600 size += can_data_bittiming_get_size(&priv->fd, 601 priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK); 602 603 return size; 604 } 605 606 static int can_bittiming_fill_info(struct sk_buff *skb, int ifla_can_bittiming, 607 struct can_bittiming *bittiming) 608 { 609 return bittiming->bitrate != CAN_BITRATE_UNSET && 610 bittiming->bitrate != CAN_BITRATE_UNKNOWN && 611 nla_put(skb, ifla_can_bittiming, sizeof(*bittiming), bittiming); 612 } 613 614 static int can_bittiming_const_fill_info(struct sk_buff *skb, 615 int ifla_can_bittiming_const, 616 const struct can_bittiming_const *bittiming_const) 617 { 618 return bittiming_const && 619 nla_put(skb, ifla_can_bittiming_const, 620 sizeof(*bittiming_const), bittiming_const); 621 } 622 623 static int can_bitrate_const_fill_info(struct sk_buff *skb, 624 int ifla_can_bitrate_const, 625 const u32 *bitrate_const, unsigned int cnt) 626 { 627 return bitrate_const && 628 nla_put(skb, ifla_can_bitrate_const, 629 sizeof(*bitrate_const) * cnt, bitrate_const); 630 } 631 632 static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev, 633 int ifla_can_tdc) 634 { 635 struct can_priv *priv = netdev_priv(dev); 636 struct data_bittiming_params *dbt_params; 637 const struct can_tdc_const *tdc_const; 638 struct can_tdc *tdc; 639 struct nlattr *nest; 640 bool tdc_is_enabled, tdc_manual; 641 642 if (ifla_can_tdc == IFLA_CAN_TDC) { 643 dbt_params = &priv->fd; 644 tdc_is_enabled = can_fd_tdc_is_enabled(priv); 645 tdc_manual = priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL; 646 } else { 647 return -EOPNOTSUPP; /* Place holder for CAN XL */ 648 } 649 tdc_const = dbt_params->tdc_const; 650 tdc = &dbt_params->tdc; 651 652 if (!tdc_const) 653 return 0; 654 655 nest = nla_nest_start(skb, ifla_can_tdc); 656 if (!nest) 657 return -EMSGSIZE; 658 659 if (tdc_manual && 660 (nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MIN, tdc_const->tdcv_min) || 661 nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MAX, tdc_const->tdcv_max))) 662 goto err_cancel; 663 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MIN, tdc_const->tdco_min) || 664 nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MAX, tdc_const->tdco_max)) 665 goto err_cancel; 666 if (tdc_const->tdcf_max && 667 (nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MIN, tdc_const->tdcf_min) || 668 nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max))) 669 goto err_cancel; 670 671 if (tdc_is_enabled) { 672 u32 tdcv; 673 int err = -EINVAL; 674 675 if (tdc_manual) { 676 tdcv = tdc->tdcv; 677 err = 0; 678 } else if (dbt_params->do_get_auto_tdcv) { 679 err = dbt_params->do_get_auto_tdcv(dev, &tdcv); 680 } 681 if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv)) 682 goto err_cancel; 683 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO, tdc->tdco)) 684 goto err_cancel; 685 if (tdc_const->tdcf_max && 686 nla_put_u32(skb, IFLA_CAN_TDC_TDCF, tdc->tdcf)) 687 goto err_cancel; 688 } 689 690 nla_nest_end(skb, nest); 691 return 0; 692 693 err_cancel: 694 nla_nest_cancel(skb, nest); 695 return -EMSGSIZE; 696 } 697 698 static int can_ctrlmode_ext_fill_info(struct sk_buff *skb, 699 const struct can_priv *priv) 700 { 701 struct nlattr *nest; 702 703 nest = nla_nest_start(skb, IFLA_CAN_CTRLMODE_EXT); 704 if (!nest) 705 return -EMSGSIZE; 706 707 if (nla_put_u32(skb, IFLA_CAN_CTRLMODE_SUPPORTED, 708 priv->ctrlmode_supported)) { 709 nla_nest_cancel(skb, nest); 710 return -EMSGSIZE; 711 } 712 713 nla_nest_end(skb, nest); 714 return 0; 715 } 716 717 static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) 718 { 719 struct can_priv *priv = netdev_priv(dev); 720 struct can_ctrlmode cm = {.flags = priv->ctrlmode}; 721 struct can_berr_counter bec = { }; 722 enum can_state state = priv->state; 723 724 if (priv->do_get_state) 725 priv->do_get_state(dev, &state); 726 727 if (can_bittiming_fill_info(skb, IFLA_CAN_BITTIMING, 728 &priv->bittiming) || 729 730 can_bittiming_const_fill_info(skb, IFLA_CAN_BITTIMING_CONST, 731 priv->bittiming_const) || 732 733 nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) || 734 nla_put_u32(skb, IFLA_CAN_STATE, state) || 735 nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) || 736 nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) || 737 738 (priv->do_get_berr_counter && 739 !priv->do_get_berr_counter(dev, &bec) && 740 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) || 741 742 can_bittiming_fill_info(skb, IFLA_CAN_DATA_BITTIMING, 743 &priv->fd.data_bittiming) || 744 745 can_bittiming_const_fill_info(skb, IFLA_CAN_DATA_BITTIMING_CONST, 746 priv->fd.data_bittiming_const) || 747 748 (priv->termination_const && 749 (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) || 750 nla_put(skb, IFLA_CAN_TERMINATION_CONST, 751 sizeof(*priv->termination_const) * 752 priv->termination_const_cnt, 753 priv->termination_const))) || 754 755 can_bitrate_const_fill_info(skb, IFLA_CAN_BITRATE_CONST, 756 priv->bitrate_const, 757 priv->bitrate_const_cnt) || 758 759 can_bitrate_const_fill_info(skb, IFLA_CAN_DATA_BITRATE_CONST, 760 priv->fd.data_bitrate_const, 761 priv->fd.data_bitrate_const_cnt) || 762 763 (nla_put(skb, IFLA_CAN_BITRATE_MAX, 764 sizeof(priv->bitrate_max), 765 &priv->bitrate_max)) || 766 767 can_tdc_fill_info(skb, dev, IFLA_CAN_TDC) || 768 769 can_ctrlmode_ext_fill_info(skb, priv) 770 ) 771 772 return -EMSGSIZE; 773 774 return 0; 775 } 776 777 static size_t can_get_xstats_size(const struct net_device *dev) 778 { 779 return sizeof(struct can_device_stats); 780 } 781 782 static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev) 783 { 784 struct can_priv *priv = netdev_priv(dev); 785 786 if (nla_put(skb, IFLA_INFO_XSTATS, 787 sizeof(priv->can_stats), &priv->can_stats)) 788 goto nla_put_failure; 789 return 0; 790 791 nla_put_failure: 792 return -EMSGSIZE; 793 } 794 795 static int can_newlink(struct net_device *dev, 796 struct rtnl_newlink_params *params, 797 struct netlink_ext_ack *extack) 798 { 799 return -EOPNOTSUPP; 800 } 801 802 static void can_dellink(struct net_device *dev, struct list_head *head) 803 { 804 } 805 806 struct rtnl_link_ops can_link_ops __read_mostly = { 807 .kind = "can", 808 .netns_refund = true, 809 .maxtype = IFLA_CAN_MAX, 810 .policy = can_policy, 811 .setup = can_setup, 812 .validate = can_validate, 813 .newlink = can_newlink, 814 .changelink = can_changelink, 815 .dellink = can_dellink, 816 .get_size = can_get_size, 817 .fill_info = can_fill_info, 818 .get_xstats_size = can_get_xstats_size, 819 .fill_xstats = can_fill_xstats, 820 }; 821 822 int can_netlink_register(void) 823 { 824 return rtnl_link_register(&can_link_ops); 825 } 826 827 void can_netlink_unregister(void) 828 { 829 rtnl_link_unregister(&can_link_ops); 830 } 831