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(const struct can_bittiming *bt, 40 struct netlink_ext_ack *extack) 41 { 42 /* sample point is in one-tenth of a percent */ 43 if (bt->sample_point >= 1000) { 44 NL_SET_ERR_MSG(extack, "sample point must be between 0 and 100%"); 45 46 return -EINVAL; 47 } 48 49 return 0; 50 } 51 52 static int can_validate(struct nlattr *tb[], struct nlattr *data[], 53 struct netlink_ext_ack *extack) 54 { 55 bool is_can_fd = false; 56 int err; 57 58 /* Make sure that valid CAN FD configurations always consist of 59 * - nominal/arbitration bittiming 60 * - data bittiming 61 * - control mode with CAN_CTRLMODE_FD set 62 * - TDC parameters are coherent (details below) 63 */ 64 65 if (!data) 66 return 0; 67 68 if (data[IFLA_CAN_CTRLMODE]) { 69 struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]); 70 u32 tdc_flags = cm->flags & CAN_CTRLMODE_FD_TDC_MASK; 71 72 is_can_fd = cm->flags & cm->mask & CAN_CTRLMODE_FD; 73 74 /* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually exclusive */ 75 if (tdc_flags == CAN_CTRLMODE_FD_TDC_MASK) 76 return -EOPNOTSUPP; 77 /* If one of the CAN_CTRLMODE_TDC_* flag is set then 78 * TDC must be set and vice-versa 79 */ 80 if (!!tdc_flags != !!data[IFLA_CAN_TDC]) 81 return -EOPNOTSUPP; 82 /* If providing TDC parameters, at least TDCO is 83 * needed. TDCV is needed if and only if 84 * CAN_CTRLMODE_TDC_MANUAL is set 85 */ 86 if (data[IFLA_CAN_TDC]) { 87 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1]; 88 89 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, 90 data[IFLA_CAN_TDC], 91 can_tdc_policy, extack); 92 if (err) 93 return err; 94 95 if (tb_tdc[IFLA_CAN_TDC_TDCV]) { 96 if (tdc_flags & CAN_CTRLMODE_TDC_AUTO) 97 return -EOPNOTSUPP; 98 } else { 99 if (tdc_flags & CAN_CTRLMODE_TDC_MANUAL) 100 return -EOPNOTSUPP; 101 } 102 103 if (!tb_tdc[IFLA_CAN_TDC_TDCO]) 104 return -EOPNOTSUPP; 105 } 106 } 107 108 if (data[IFLA_CAN_BITTIMING]) { 109 struct can_bittiming bt; 110 111 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt)); 112 err = can_validate_bittiming(&bt, extack); 113 if (err) 114 return err; 115 } 116 117 if (is_can_fd) { 118 if (!data[IFLA_CAN_BITTIMING] || !data[IFLA_CAN_DATA_BITTIMING]) 119 return -EOPNOTSUPP; 120 } 121 122 if (data[IFLA_CAN_DATA_BITTIMING] || data[IFLA_CAN_TDC]) { 123 if (!is_can_fd) 124 return -EOPNOTSUPP; 125 } 126 127 if (data[IFLA_CAN_DATA_BITTIMING]) { 128 struct can_bittiming bt; 129 130 memcpy(&bt, nla_data(data[IFLA_CAN_DATA_BITTIMING]), sizeof(bt)); 131 err = can_validate_bittiming(&bt, extack); 132 if (err) 133 return err; 134 } 135 136 return 0; 137 } 138 139 static int can_tdc_changelink(struct can_priv *priv, const struct nlattr *nla, 140 struct netlink_ext_ack *extack) 141 { 142 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1]; 143 struct can_tdc tdc = { 0 }; 144 const struct can_tdc_const *tdc_const = priv->fd.tdc_const; 145 int err; 146 147 if (!tdc_const || !can_fd_tdc_is_enabled(priv)) 148 return -EOPNOTSUPP; 149 150 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, nla, 151 can_tdc_policy, extack); 152 if (err) 153 return err; 154 155 if (tb_tdc[IFLA_CAN_TDC_TDCV]) { 156 u32 tdcv = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCV]); 157 158 if (tdcv < tdc_const->tdcv_min || tdcv > tdc_const->tdcv_max) 159 return -EINVAL; 160 161 tdc.tdcv = tdcv; 162 } 163 164 if (tb_tdc[IFLA_CAN_TDC_TDCO]) { 165 u32 tdco = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCO]); 166 167 if (tdco < tdc_const->tdco_min || tdco > tdc_const->tdco_max) 168 return -EINVAL; 169 170 tdc.tdco = tdco; 171 } 172 173 if (tb_tdc[IFLA_CAN_TDC_TDCF]) { 174 u32 tdcf = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCF]); 175 176 if (tdcf < tdc_const->tdcf_min || tdcf > tdc_const->tdcf_max) 177 return -EINVAL; 178 179 tdc.tdcf = tdcf; 180 } 181 182 priv->fd.tdc = tdc; 183 184 return 0; 185 } 186 187 static int can_changelink(struct net_device *dev, struct nlattr *tb[], 188 struct nlattr *data[], 189 struct netlink_ext_ack *extack) 190 { 191 struct can_priv *priv = netdev_priv(dev); 192 bool fd_tdc_flag_provided = false; 193 int err; 194 195 /* We need synchronization with dev->stop() */ 196 ASSERT_RTNL(); 197 198 if (data[IFLA_CAN_CTRLMODE]) { 199 struct can_ctrlmode *cm; 200 u32 ctrlstatic; 201 u32 maskedflags; 202 203 /* Do not allow changing controller mode while running */ 204 if (dev->flags & IFF_UP) 205 return -EBUSY; 206 cm = nla_data(data[IFLA_CAN_CTRLMODE]); 207 ctrlstatic = can_get_static_ctrlmode(priv); 208 maskedflags = cm->flags & cm->mask; 209 210 /* check whether provided bits are allowed to be passed */ 211 if (maskedflags & ~(priv->ctrlmode_supported | ctrlstatic)) 212 return -EOPNOTSUPP; 213 214 /* do not check for static fd-non-iso if 'fd' is disabled */ 215 if (!(maskedflags & CAN_CTRLMODE_FD)) 216 ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO; 217 218 /* make sure static options are provided by configuration */ 219 if ((maskedflags & ctrlstatic) != ctrlstatic) 220 return -EOPNOTSUPP; 221 222 /* clear bits to be modified and copy the flag values */ 223 priv->ctrlmode &= ~cm->mask; 224 priv->ctrlmode |= maskedflags; 225 226 /* CAN_CTRLMODE_FD can only be set when driver supports FD */ 227 if (priv->ctrlmode & CAN_CTRLMODE_FD) { 228 dev->mtu = CANFD_MTU; 229 } else { 230 dev->mtu = CAN_MTU; 231 memset(&priv->fd.data_bittiming, 0, 232 sizeof(priv->fd.data_bittiming)); 233 priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK; 234 memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc)); 235 } 236 237 fd_tdc_flag_provided = cm->mask & CAN_CTRLMODE_FD_TDC_MASK; 238 /* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually 239 * exclusive: make sure to turn the other one off 240 */ 241 if (fd_tdc_flag_provided) 242 priv->ctrlmode &= cm->flags | ~CAN_CTRLMODE_FD_TDC_MASK; 243 } 244 245 if (data[IFLA_CAN_BITTIMING]) { 246 struct can_bittiming bt; 247 248 /* Do not allow changing bittiming while running */ 249 if (dev->flags & IFF_UP) 250 return -EBUSY; 251 252 /* Calculate bittiming parameters based on 253 * bittiming_const if set, otherwise pass bitrate 254 * directly via do_set_bitrate(). Bail out if neither 255 * is given. 256 */ 257 if (!priv->bittiming_const && !priv->do_set_bittiming && 258 !priv->bitrate_const) 259 return -EOPNOTSUPP; 260 261 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt)); 262 err = can_get_bittiming(dev, &bt, 263 priv->bittiming_const, 264 priv->bitrate_const, 265 priv->bitrate_const_cnt, 266 extack); 267 if (err) 268 return err; 269 270 if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) { 271 NL_SET_ERR_MSG_FMT(extack, 272 "arbitration bitrate %u bps surpasses transceiver capabilities of %u bps", 273 bt.bitrate, priv->bitrate_max); 274 return -EINVAL; 275 } 276 277 memcpy(&priv->bittiming, &bt, sizeof(bt)); 278 279 if (priv->do_set_bittiming) { 280 /* Finally, set the bit-timing registers */ 281 err = priv->do_set_bittiming(dev); 282 if (err) 283 return err; 284 } 285 } 286 287 if (data[IFLA_CAN_RESTART_MS]) { 288 if (!priv->do_set_mode) { 289 NL_SET_ERR_MSG(extack, 290 "Device doesn't support restart from Bus Off"); 291 return -EOPNOTSUPP; 292 } 293 294 /* Do not allow changing restart delay while running */ 295 if (dev->flags & IFF_UP) 296 return -EBUSY; 297 priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]); 298 } 299 300 if (data[IFLA_CAN_RESTART]) { 301 if (!priv->do_set_mode) { 302 NL_SET_ERR_MSG(extack, 303 "Device doesn't support restart from Bus Off"); 304 return -EOPNOTSUPP; 305 } 306 307 /* Do not allow a restart while not running */ 308 if (!(dev->flags & IFF_UP)) 309 return -EINVAL; 310 err = can_restart_now(dev); 311 if (err) 312 return err; 313 } 314 315 if (data[IFLA_CAN_DATA_BITTIMING]) { 316 struct can_bittiming dbt; 317 318 /* Do not allow changing bittiming while running */ 319 if (dev->flags & IFF_UP) 320 return -EBUSY; 321 322 /* Calculate bittiming parameters based on 323 * data_bittiming_const if set, otherwise pass bitrate 324 * directly via do_set_bitrate(). Bail out if neither 325 * is given. 326 */ 327 if (!priv->fd.data_bittiming_const && !priv->fd.do_set_data_bittiming && 328 !priv->fd.data_bitrate_const) 329 return -EOPNOTSUPP; 330 331 memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]), 332 sizeof(dbt)); 333 err = can_get_bittiming(dev, &dbt, 334 priv->fd.data_bittiming_const, 335 priv->fd.data_bitrate_const, 336 priv->fd.data_bitrate_const_cnt, 337 extack); 338 if (err) 339 return err; 340 341 if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) { 342 NL_SET_ERR_MSG_FMT(extack, 343 "CANFD data bitrate %u bps surpasses transceiver capabilities of %u bps", 344 dbt.bitrate, priv->bitrate_max); 345 return -EINVAL; 346 } 347 348 memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc)); 349 if (data[IFLA_CAN_TDC]) { 350 /* TDC parameters are provided: use them */ 351 err = can_tdc_changelink(priv, data[IFLA_CAN_TDC], 352 extack); 353 if (err) { 354 priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK; 355 return err; 356 } 357 } else if (!fd_tdc_flag_provided) { 358 /* Neither of TDC parameters nor TDC flags are 359 * provided: do calculation 360 */ 361 can_calc_tdco(&priv->fd.tdc, priv->fd.tdc_const, &dbt, 362 &priv->ctrlmode, priv->ctrlmode_supported); 363 } /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly 364 * turned off. TDC is disabled: do nothing 365 */ 366 367 memcpy(&priv->fd.data_bittiming, &dbt, sizeof(dbt)); 368 369 if (priv->fd.do_set_data_bittiming) { 370 /* Finally, set the bit-timing registers */ 371 err = priv->fd.do_set_data_bittiming(dev); 372 if (err) 373 return err; 374 } 375 } 376 377 if (data[IFLA_CAN_TERMINATION]) { 378 const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]); 379 const unsigned int num_term = priv->termination_const_cnt; 380 unsigned int i; 381 382 if (!priv->do_set_termination) 383 return -EOPNOTSUPP; 384 385 /* check whether given value is supported by the interface */ 386 for (i = 0; i < num_term; i++) { 387 if (termval == priv->termination_const[i]) 388 break; 389 } 390 if (i >= num_term) 391 return -EINVAL; 392 393 /* Finally, set the termination value */ 394 err = priv->do_set_termination(dev, termval); 395 if (err) 396 return err; 397 398 priv->termination = termval; 399 } 400 401 return 0; 402 } 403 404 static size_t can_tdc_get_size(const struct net_device *dev) 405 { 406 struct can_priv *priv = netdev_priv(dev); 407 size_t size; 408 409 if (!priv->fd.tdc_const) 410 return 0; 411 412 size = nla_total_size(0); /* nest IFLA_CAN_TDC */ 413 if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL) { 414 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MIN */ 415 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MAX */ 416 } 417 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */ 418 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */ 419 if (priv->fd.tdc_const->tdcf_max) { 420 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */ 421 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */ 422 } 423 424 if (can_fd_tdc_is_enabled(priv)) { 425 if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL || 426 priv->fd.do_get_auto_tdcv) 427 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */ 428 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */ 429 if (priv->fd.tdc_const->tdcf_max) 430 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */ 431 } 432 433 return size; 434 } 435 436 static size_t can_ctrlmode_ext_get_size(void) 437 { 438 return nla_total_size(0) + /* nest IFLA_CAN_CTRLMODE_EXT */ 439 nla_total_size(sizeof(u32)); /* IFLA_CAN_CTRLMODE_SUPPORTED */ 440 } 441 442 static size_t can_get_size(const struct net_device *dev) 443 { 444 struct can_priv *priv = netdev_priv(dev); 445 size_t size = 0; 446 447 if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */ 448 size += nla_total_size(sizeof(struct can_bittiming)); 449 if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */ 450 size += nla_total_size(sizeof(struct can_bittiming_const)); 451 size += nla_total_size(sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */ 452 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_STATE */ 453 size += nla_total_size(sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */ 454 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */ 455 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */ 456 size += nla_total_size(sizeof(struct can_berr_counter)); 457 if (priv->fd.data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */ 458 size += nla_total_size(sizeof(struct can_bittiming)); 459 if (priv->fd.data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */ 460 size += nla_total_size(sizeof(struct can_bittiming_const)); 461 if (priv->termination_const) { 462 size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */ 463 size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */ 464 priv->termination_const_cnt); 465 } 466 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */ 467 size += nla_total_size(sizeof(*priv->bitrate_const) * 468 priv->bitrate_const_cnt); 469 if (priv->fd.data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */ 470 size += nla_total_size(sizeof(*priv->fd.data_bitrate_const) * 471 priv->fd.data_bitrate_const_cnt); 472 size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */ 473 size += can_tdc_get_size(dev); /* IFLA_CAN_TDC */ 474 size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */ 475 476 return size; 477 } 478 479 static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev) 480 { 481 struct nlattr *nest; 482 struct can_priv *priv = netdev_priv(dev); 483 struct can_tdc *tdc = &priv->fd.tdc; 484 const struct can_tdc_const *tdc_const = priv->fd.tdc_const; 485 486 if (!tdc_const) 487 return 0; 488 489 nest = nla_nest_start(skb, IFLA_CAN_TDC); 490 if (!nest) 491 return -EMSGSIZE; 492 493 if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL && 494 (nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MIN, tdc_const->tdcv_min) || 495 nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MAX, tdc_const->tdcv_max))) 496 goto err_cancel; 497 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MIN, tdc_const->tdco_min) || 498 nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MAX, tdc_const->tdco_max)) 499 goto err_cancel; 500 if (tdc_const->tdcf_max && 501 (nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MIN, tdc_const->tdcf_min) || 502 nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max))) 503 goto err_cancel; 504 505 if (can_fd_tdc_is_enabled(priv)) { 506 u32 tdcv; 507 int err = -EINVAL; 508 509 if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL) { 510 tdcv = tdc->tdcv; 511 err = 0; 512 } else if (priv->fd.do_get_auto_tdcv) { 513 err = priv->fd.do_get_auto_tdcv(dev, &tdcv); 514 } 515 if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv)) 516 goto err_cancel; 517 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO, tdc->tdco)) 518 goto err_cancel; 519 if (tdc_const->tdcf_max && 520 nla_put_u32(skb, IFLA_CAN_TDC_TDCF, tdc->tdcf)) 521 goto err_cancel; 522 } 523 524 nla_nest_end(skb, nest); 525 return 0; 526 527 err_cancel: 528 nla_nest_cancel(skb, nest); 529 return -EMSGSIZE; 530 } 531 532 static int can_ctrlmode_ext_fill_info(struct sk_buff *skb, 533 const struct can_priv *priv) 534 { 535 struct nlattr *nest; 536 537 nest = nla_nest_start(skb, IFLA_CAN_CTRLMODE_EXT); 538 if (!nest) 539 return -EMSGSIZE; 540 541 if (nla_put_u32(skb, IFLA_CAN_CTRLMODE_SUPPORTED, 542 priv->ctrlmode_supported)) { 543 nla_nest_cancel(skb, nest); 544 return -EMSGSIZE; 545 } 546 547 nla_nest_end(skb, nest); 548 return 0; 549 } 550 551 static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) 552 { 553 struct can_priv *priv = netdev_priv(dev); 554 struct can_ctrlmode cm = {.flags = priv->ctrlmode}; 555 struct can_berr_counter bec = { }; 556 enum can_state state = priv->state; 557 558 if (priv->do_get_state) 559 priv->do_get_state(dev, &state); 560 561 if ((priv->bittiming.bitrate != CAN_BITRATE_UNSET && 562 priv->bittiming.bitrate != CAN_BITRATE_UNKNOWN && 563 nla_put(skb, IFLA_CAN_BITTIMING, 564 sizeof(priv->bittiming), &priv->bittiming)) || 565 566 (priv->bittiming_const && 567 nla_put(skb, IFLA_CAN_BITTIMING_CONST, 568 sizeof(*priv->bittiming_const), priv->bittiming_const)) || 569 570 nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) || 571 nla_put_u32(skb, IFLA_CAN_STATE, state) || 572 nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) || 573 nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) || 574 575 (priv->do_get_berr_counter && 576 !priv->do_get_berr_counter(dev, &bec) && 577 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) || 578 579 (priv->fd.data_bittiming.bitrate && 580 nla_put(skb, IFLA_CAN_DATA_BITTIMING, 581 sizeof(priv->fd.data_bittiming), &priv->fd.data_bittiming)) || 582 583 (priv->fd.data_bittiming_const && 584 nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST, 585 sizeof(*priv->fd.data_bittiming_const), 586 priv->fd.data_bittiming_const)) || 587 588 (priv->termination_const && 589 (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) || 590 nla_put(skb, IFLA_CAN_TERMINATION_CONST, 591 sizeof(*priv->termination_const) * 592 priv->termination_const_cnt, 593 priv->termination_const))) || 594 595 (priv->bitrate_const && 596 nla_put(skb, IFLA_CAN_BITRATE_CONST, 597 sizeof(*priv->bitrate_const) * 598 priv->bitrate_const_cnt, 599 priv->bitrate_const)) || 600 601 (priv->fd.data_bitrate_const && 602 nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST, 603 sizeof(*priv->fd.data_bitrate_const) * 604 priv->fd.data_bitrate_const_cnt, 605 priv->fd.data_bitrate_const)) || 606 607 (nla_put(skb, IFLA_CAN_BITRATE_MAX, 608 sizeof(priv->bitrate_max), 609 &priv->bitrate_max)) || 610 611 can_tdc_fill_info(skb, dev) || 612 613 can_ctrlmode_ext_fill_info(skb, priv) 614 ) 615 616 return -EMSGSIZE; 617 618 return 0; 619 } 620 621 static size_t can_get_xstats_size(const struct net_device *dev) 622 { 623 return sizeof(struct can_device_stats); 624 } 625 626 static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev) 627 { 628 struct can_priv *priv = netdev_priv(dev); 629 630 if (nla_put(skb, IFLA_INFO_XSTATS, 631 sizeof(priv->can_stats), &priv->can_stats)) 632 goto nla_put_failure; 633 return 0; 634 635 nla_put_failure: 636 return -EMSGSIZE; 637 } 638 639 static int can_newlink(struct net_device *dev, 640 struct rtnl_newlink_params *params, 641 struct netlink_ext_ack *extack) 642 { 643 return -EOPNOTSUPP; 644 } 645 646 static void can_dellink(struct net_device *dev, struct list_head *head) 647 { 648 } 649 650 struct rtnl_link_ops can_link_ops __read_mostly = { 651 .kind = "can", 652 .netns_refund = true, 653 .maxtype = IFLA_CAN_MAX, 654 .policy = can_policy, 655 .setup = can_setup, 656 .validate = can_validate, 657 .newlink = can_newlink, 658 .changelink = can_changelink, 659 .dellink = can_dellink, 660 .get_size = can_get_size, 661 .fill_info = can_fill_info, 662 .get_xstats_size = can_get_xstats_size, 663 .fill_xstats = can_fill_xstats, 664 }; 665 666 int can_netlink_register(void) 667 { 668 return rtnl_link_register(&can_link_ops); 669 } 670 671 void can_netlink_unregister(void) 672 { 673 rtnl_link_unregister(&can_link_ops); 674 } 675