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 if (!priv->do_set_mode) { 456 NL_SET_ERR_MSG(extack, 457 "Device doesn't support restart from Bus Off"); 458 return -EOPNOTSUPP; 459 } 460 461 /* Do not allow changing restart delay while running */ 462 if (dev->flags & IFF_UP) 463 return -EBUSY; 464 priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]); 465 } 466 467 if (data[IFLA_CAN_RESTART]) { 468 if (!priv->do_set_mode) { 469 NL_SET_ERR_MSG(extack, 470 "Device doesn't support restart from Bus Off"); 471 return -EOPNOTSUPP; 472 } 473 474 /* Do not allow a restart while not running */ 475 if (!(dev->flags & IFF_UP)) 476 return -EINVAL; 477 err = can_restart_now(dev); 478 if (err) 479 return err; 480 } 481 482 /* CAN FD */ 483 err = can_dbt_changelink(dev, data, true, extack); 484 if (err) 485 return err; 486 487 if (data[IFLA_CAN_TERMINATION]) { 488 const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]); 489 const unsigned int num_term = priv->termination_const_cnt; 490 unsigned int i; 491 492 if (!priv->do_set_termination) { 493 NL_SET_ERR_MSG(extack, 494 "Termination is not configurable on this device"); 495 return -EOPNOTSUPP; 496 } 497 498 /* check whether given value is supported by the interface */ 499 for (i = 0; i < num_term; i++) { 500 if (termval == priv->termination_const[i]) 501 break; 502 } 503 if (i >= num_term) 504 return -EINVAL; 505 506 /* Finally, set the termination value */ 507 err = priv->do_set_termination(dev, termval); 508 if (err) 509 return err; 510 511 priv->termination = termval; 512 } 513 514 return 0; 515 } 516 517 static size_t can_tdc_get_size(struct data_bittiming_params *dbt_params, 518 u32 tdc_flags) 519 { 520 bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK; 521 size_t size; 522 523 if (!dbt_params->tdc_const) 524 return 0; 525 526 size = nla_total_size(0); /* nest IFLA_CAN_TDC */ 527 if (tdc_manual) { 528 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MIN */ 529 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MAX */ 530 } 531 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */ 532 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */ 533 if (dbt_params->tdc_const->tdcf_max) { 534 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */ 535 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */ 536 } 537 538 if (tdc_flags) { 539 if (tdc_manual || dbt_params->do_get_auto_tdcv) 540 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */ 541 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */ 542 if (dbt_params->tdc_const->tdcf_max) 543 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */ 544 } 545 546 return size; 547 } 548 549 static size_t can_data_bittiming_get_size(struct data_bittiming_params *dbt_params, 550 u32 tdc_flags) 551 { 552 size_t size = 0; 553 554 if (dbt_params->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */ 555 size += nla_total_size(sizeof(dbt_params->data_bittiming)); 556 if (dbt_params->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */ 557 size += nla_total_size(sizeof(*dbt_params->data_bittiming_const)); 558 if (dbt_params->data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */ 559 size += nla_total_size(sizeof(*dbt_params->data_bitrate_const) * 560 dbt_params->data_bitrate_const_cnt); 561 size += can_tdc_get_size(dbt_params, tdc_flags);/* IFLA_CAN_TDC */ 562 563 return size; 564 } 565 566 static size_t can_ctrlmode_ext_get_size(void) 567 { 568 return nla_total_size(0) + /* nest IFLA_CAN_CTRLMODE_EXT */ 569 nla_total_size(sizeof(u32)); /* IFLA_CAN_CTRLMODE_SUPPORTED */ 570 } 571 572 static size_t can_get_size(const struct net_device *dev) 573 { 574 struct can_priv *priv = netdev_priv(dev); 575 size_t size = 0; 576 577 if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */ 578 size += nla_total_size(sizeof(struct can_bittiming)); 579 if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */ 580 size += nla_total_size(sizeof(struct can_bittiming_const)); 581 size += nla_total_size(sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */ 582 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_STATE */ 583 size += nla_total_size(sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */ 584 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */ 585 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */ 586 size += nla_total_size(sizeof(struct can_berr_counter)); 587 if (priv->termination_const) { 588 size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */ 589 size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */ 590 priv->termination_const_cnt); 591 } 592 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */ 593 size += nla_total_size(sizeof(*priv->bitrate_const) * 594 priv->bitrate_const_cnt); 595 size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */ 596 size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */ 597 598 size += can_data_bittiming_get_size(&priv->fd, 599 priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK); 600 601 return size; 602 } 603 604 static int can_bittiming_fill_info(struct sk_buff *skb, int ifla_can_bittiming, 605 struct can_bittiming *bittiming) 606 { 607 return bittiming->bitrate != CAN_BITRATE_UNSET && 608 bittiming->bitrate != CAN_BITRATE_UNKNOWN && 609 nla_put(skb, ifla_can_bittiming, sizeof(*bittiming), bittiming); 610 } 611 612 static int can_bittiming_const_fill_info(struct sk_buff *skb, 613 int ifla_can_bittiming_const, 614 const struct can_bittiming_const *bittiming_const) 615 { 616 return bittiming_const && 617 nla_put(skb, ifla_can_bittiming_const, 618 sizeof(*bittiming_const), bittiming_const); 619 } 620 621 static int can_bitrate_const_fill_info(struct sk_buff *skb, 622 int ifla_can_bitrate_const, 623 const u32 *bitrate_const, unsigned int cnt) 624 { 625 return bitrate_const && 626 nla_put(skb, ifla_can_bitrate_const, 627 sizeof(*bitrate_const) * cnt, bitrate_const); 628 } 629 630 static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev, 631 int ifla_can_tdc) 632 { 633 struct can_priv *priv = netdev_priv(dev); 634 struct data_bittiming_params *dbt_params; 635 const struct can_tdc_const *tdc_const; 636 struct can_tdc *tdc; 637 struct nlattr *nest; 638 bool tdc_is_enabled, tdc_manual; 639 640 if (ifla_can_tdc == IFLA_CAN_TDC) { 641 dbt_params = &priv->fd; 642 tdc_is_enabled = can_fd_tdc_is_enabled(priv); 643 tdc_manual = priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL; 644 } else { 645 return -EOPNOTSUPP; /* Place holder for CAN XL */ 646 } 647 tdc_const = dbt_params->tdc_const; 648 tdc = &dbt_params->tdc; 649 650 if (!tdc_const) 651 return 0; 652 653 nest = nla_nest_start(skb, ifla_can_tdc); 654 if (!nest) 655 return -EMSGSIZE; 656 657 if (tdc_manual && 658 (nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MIN, tdc_const->tdcv_min) || 659 nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MAX, tdc_const->tdcv_max))) 660 goto err_cancel; 661 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MIN, tdc_const->tdco_min) || 662 nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MAX, tdc_const->tdco_max)) 663 goto err_cancel; 664 if (tdc_const->tdcf_max && 665 (nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MIN, tdc_const->tdcf_min) || 666 nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max))) 667 goto err_cancel; 668 669 if (tdc_is_enabled) { 670 u32 tdcv; 671 int err = -EINVAL; 672 673 if (tdc_manual) { 674 tdcv = tdc->tdcv; 675 err = 0; 676 } else if (dbt_params->do_get_auto_tdcv) { 677 err = dbt_params->do_get_auto_tdcv(dev, &tdcv); 678 } 679 if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv)) 680 goto err_cancel; 681 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO, tdc->tdco)) 682 goto err_cancel; 683 if (tdc_const->tdcf_max && 684 nla_put_u32(skb, IFLA_CAN_TDC_TDCF, tdc->tdcf)) 685 goto err_cancel; 686 } 687 688 nla_nest_end(skb, nest); 689 return 0; 690 691 err_cancel: 692 nla_nest_cancel(skb, nest); 693 return -EMSGSIZE; 694 } 695 696 static int can_ctrlmode_ext_fill_info(struct sk_buff *skb, 697 const struct can_priv *priv) 698 { 699 struct nlattr *nest; 700 701 nest = nla_nest_start(skb, IFLA_CAN_CTRLMODE_EXT); 702 if (!nest) 703 return -EMSGSIZE; 704 705 if (nla_put_u32(skb, IFLA_CAN_CTRLMODE_SUPPORTED, 706 priv->ctrlmode_supported)) { 707 nla_nest_cancel(skb, nest); 708 return -EMSGSIZE; 709 } 710 711 nla_nest_end(skb, nest); 712 return 0; 713 } 714 715 static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) 716 { 717 struct can_priv *priv = netdev_priv(dev); 718 struct can_ctrlmode cm = {.flags = priv->ctrlmode}; 719 struct can_berr_counter bec = { }; 720 enum can_state state = priv->state; 721 722 if (priv->do_get_state) 723 priv->do_get_state(dev, &state); 724 725 if (can_bittiming_fill_info(skb, IFLA_CAN_BITTIMING, 726 &priv->bittiming) || 727 728 can_bittiming_const_fill_info(skb, IFLA_CAN_BITTIMING_CONST, 729 priv->bittiming_const) || 730 731 nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) || 732 nla_put_u32(skb, IFLA_CAN_STATE, state) || 733 nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) || 734 nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) || 735 736 (priv->do_get_berr_counter && 737 !priv->do_get_berr_counter(dev, &bec) && 738 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) || 739 740 can_bittiming_fill_info(skb, IFLA_CAN_DATA_BITTIMING, 741 &priv->fd.data_bittiming) || 742 743 can_bittiming_const_fill_info(skb, IFLA_CAN_DATA_BITTIMING_CONST, 744 priv->fd.data_bittiming_const) || 745 746 (priv->termination_const && 747 (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) || 748 nla_put(skb, IFLA_CAN_TERMINATION_CONST, 749 sizeof(*priv->termination_const) * 750 priv->termination_const_cnt, 751 priv->termination_const))) || 752 753 can_bitrate_const_fill_info(skb, IFLA_CAN_BITRATE_CONST, 754 priv->bitrate_const, 755 priv->bitrate_const_cnt) || 756 757 can_bitrate_const_fill_info(skb, IFLA_CAN_DATA_BITRATE_CONST, 758 priv->fd.data_bitrate_const, 759 priv->fd.data_bitrate_const_cnt) || 760 761 (nla_put(skb, IFLA_CAN_BITRATE_MAX, 762 sizeof(priv->bitrate_max), 763 &priv->bitrate_max)) || 764 765 can_tdc_fill_info(skb, dev, IFLA_CAN_TDC) || 766 767 can_ctrlmode_ext_fill_info(skb, priv) 768 ) 769 770 return -EMSGSIZE; 771 772 return 0; 773 } 774 775 static size_t can_get_xstats_size(const struct net_device *dev) 776 { 777 return sizeof(struct can_device_stats); 778 } 779 780 static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev) 781 { 782 struct can_priv *priv = netdev_priv(dev); 783 784 if (nla_put(skb, IFLA_INFO_XSTATS, 785 sizeof(priv->can_stats), &priv->can_stats)) 786 goto nla_put_failure; 787 return 0; 788 789 nla_put_failure: 790 return -EMSGSIZE; 791 } 792 793 static int can_newlink(struct net_device *dev, 794 struct rtnl_newlink_params *params, 795 struct netlink_ext_ack *extack) 796 { 797 return -EOPNOTSUPP; 798 } 799 800 static void can_dellink(struct net_device *dev, struct list_head *head) 801 { 802 } 803 804 struct rtnl_link_ops can_link_ops __read_mostly = { 805 .kind = "can", 806 .netns_refund = true, 807 .maxtype = IFLA_CAN_MAX, 808 .policy = can_policy, 809 .setup = can_setup, 810 .validate = can_validate, 811 .newlink = can_newlink, 812 .changelink = can_changelink, 813 .dellink = can_dellink, 814 .get_size = can_get_size, 815 .fill_info = can_fill_info, 816 .get_xstats_size = can_get_xstats_size, 817 .fill_xstats = can_fill_xstats, 818 }; 819 820 int can_netlink_register(void) 821 { 822 return rtnl_link_register(&can_link_ops); 823 } 824 825 void can_netlink_unregister(void) 826 { 827 rtnl_link_unregister(&can_link_ops); 828 } 829