663 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix3 * Copyright (C) 2006 Andrey Volkov, Varma Electronics4 * 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 11static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = {12 [IFLA_CAN_STATE] = { .type = NLA_U32 },13 [IFLA_CAN_CTRLMODE] = { .len = sizeof(struct can_ctrlmode) },14 [IFLA_CAN_RESTART_MS] = { .type = NLA_U32 },15 [IFLA_CAN_RESTART] = { .type = NLA_U32 },16 [IFLA_CAN_BITTIMING] = { .len = sizeof(struct can_bittiming) },17 [IFLA_CAN_BITTIMING_CONST] = { .len = sizeof(struct can_bittiming_const) },18 [IFLA_CAN_CLOCK] = { .len = sizeof(struct can_clock) },19 [IFLA_CAN_BERR_COUNTER] = { .len = sizeof(struct can_berr_counter) },20 [IFLA_CAN_DATA_BITTIMING] = { .len = sizeof(struct can_bittiming) },21 [IFLA_CAN_DATA_BITTIMING_CONST] = { .len = sizeof(struct can_bittiming_const) },22 [IFLA_CAN_TERMINATION] = { .type = NLA_U16 },23 [IFLA_CAN_TDC] = { .type = NLA_NESTED },24 [IFLA_CAN_CTRLMODE_EXT] = { .type = NLA_NESTED },25};26 27static 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 39static 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 52static 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 of59 * - nominal/arbitration bittiming60 * - data bittiming61 * - control mode with CAN_CTRLMODE_FD set62 * - 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_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_TDC_MASK)76 return -EOPNOTSUPP;77 /* If one of the CAN_CTRLMODE_TDC_* flag is set then78 * TDC must be set and vice-versa79 */80 if (!!tdc_flags != !!data[IFLA_CAN_TDC])81 return -EOPNOTSUPP;82 /* If providing TDC parameters, at least TDCO is83 * needed. TDCV is needed if and only if84 * CAN_CTRLMODE_TDC_MANUAL is set85 */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 139static 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->tdc_const;145 int err;146 147 if (!tdc_const || !can_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->tdc = tdc;183 184 return 0;185}186 187static 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 u32 tdc_mask = 0;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->data_bittiming, 0,232 sizeof(priv->data_bittiming));233 priv->ctrlmode &= ~CAN_CTRLMODE_TDC_MASK;234 memset(&priv->tdc, 0, sizeof(priv->tdc));235 }236 237 tdc_mask = cm->mask & CAN_CTRLMODE_TDC_MASK;238 /* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually239 * exclusive: make sure to turn the other one off240 */241 if (tdc_mask)242 priv->ctrlmode &= cm->flags | ~CAN_CTRLMODE_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 on253 * bittiming_const if set, otherwise pass bitrate254 * directly via do_set_bitrate(). Bail out if neither255 * 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 /* Do not allow changing restart delay while running */289 if (dev->flags & IFF_UP)290 return -EBUSY;291 priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);292 }293 294 if (data[IFLA_CAN_RESTART]) {295 /* Do not allow a restart while not running */296 if (!(dev->flags & IFF_UP))297 return -EINVAL;298 err = can_restart_now(dev);299 if (err)300 return err;301 }302 303 if (data[IFLA_CAN_DATA_BITTIMING]) {304 struct can_bittiming dbt;305 306 /* Do not allow changing bittiming while running */307 if (dev->flags & IFF_UP)308 return -EBUSY;309 310 /* Calculate bittiming parameters based on311 * data_bittiming_const if set, otherwise pass bitrate312 * directly via do_set_bitrate(). Bail out if neither313 * is given.314 */315 if (!priv->data_bittiming_const && !priv->do_set_data_bittiming &&316 !priv->data_bitrate_const)317 return -EOPNOTSUPP;318 319 memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]),320 sizeof(dbt));321 err = can_get_bittiming(dev, &dbt,322 priv->data_bittiming_const,323 priv->data_bitrate_const,324 priv->data_bitrate_const_cnt,325 extack);326 if (err)327 return err;328 329 if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {330 NL_SET_ERR_MSG_FMT(extack,331 "CANFD data bitrate %u bps surpasses transceiver capabilities of %u bps",332 dbt.bitrate, priv->bitrate_max);333 return -EINVAL;334 }335 336 memset(&priv->tdc, 0, sizeof(priv->tdc));337 if (data[IFLA_CAN_TDC]) {338 /* TDC parameters are provided: use them */339 err = can_tdc_changelink(priv, data[IFLA_CAN_TDC],340 extack);341 if (err) {342 priv->ctrlmode &= ~CAN_CTRLMODE_TDC_MASK;343 return err;344 }345 } else if (!tdc_mask) {346 /* Neither of TDC parameters nor TDC flags are347 * provided: do calculation348 */349 can_calc_tdco(&priv->tdc, priv->tdc_const, &dbt,350 &priv->ctrlmode, priv->ctrlmode_supported);351 } /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly352 * turned off. TDC is disabled: do nothing353 */354 355 memcpy(&priv->data_bittiming, &dbt, sizeof(dbt));356 357 if (priv->do_set_data_bittiming) {358 /* Finally, set the bit-timing registers */359 err = priv->do_set_data_bittiming(dev);360 if (err)361 return err;362 }363 }364 365 if (data[IFLA_CAN_TERMINATION]) {366 const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]);367 const unsigned int num_term = priv->termination_const_cnt;368 unsigned int i;369 370 if (!priv->do_set_termination)371 return -EOPNOTSUPP;372 373 /* check whether given value is supported by the interface */374 for (i = 0; i < num_term; i++) {375 if (termval == priv->termination_const[i])376 break;377 }378 if (i >= num_term)379 return -EINVAL;380 381 /* Finally, set the termination value */382 err = priv->do_set_termination(dev, termval);383 if (err)384 return err;385 386 priv->termination = termval;387 }388 389 return 0;390}391 392static size_t can_tdc_get_size(const struct net_device *dev)393{394 struct can_priv *priv = netdev_priv(dev);395 size_t size;396 397 if (!priv->tdc_const)398 return 0;399 400 size = nla_total_size(0); /* nest IFLA_CAN_TDC */401 if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL) {402 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MIN */403 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MAX */404 }405 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */406 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */407 if (priv->tdc_const->tdcf_max) {408 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */409 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */410 }411 412 if (can_tdc_is_enabled(priv)) {413 if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL ||414 priv->do_get_auto_tdcv)415 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */416 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */417 if (priv->tdc_const->tdcf_max)418 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */419 }420 421 return size;422}423 424static size_t can_ctrlmode_ext_get_size(void)425{426 return nla_total_size(0) + /* nest IFLA_CAN_CTRLMODE_EXT */427 nla_total_size(sizeof(u32)); /* IFLA_CAN_CTRLMODE_SUPPORTED */428}429 430static size_t can_get_size(const struct net_device *dev)431{432 struct can_priv *priv = netdev_priv(dev);433 size_t size = 0;434 435 if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */436 size += nla_total_size(sizeof(struct can_bittiming));437 if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */438 size += nla_total_size(sizeof(struct can_bittiming_const));439 size += nla_total_size(sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */440 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_STATE */441 size += nla_total_size(sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */442 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */443 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */444 size += nla_total_size(sizeof(struct can_berr_counter));445 if (priv->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */446 size += nla_total_size(sizeof(struct can_bittiming));447 if (priv->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */448 size += nla_total_size(sizeof(struct can_bittiming_const));449 if (priv->termination_const) {450 size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */451 size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */452 priv->termination_const_cnt);453 }454 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */455 size += nla_total_size(sizeof(*priv->bitrate_const) *456 priv->bitrate_const_cnt);457 if (priv->data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */458 size += nla_total_size(sizeof(*priv->data_bitrate_const) *459 priv->data_bitrate_const_cnt);460 size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */461 size += can_tdc_get_size(dev); /* IFLA_CAN_TDC */462 size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */463 464 return size;465}466 467static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev)468{469 struct nlattr *nest;470 struct can_priv *priv = netdev_priv(dev);471 struct can_tdc *tdc = &priv->tdc;472 const struct can_tdc_const *tdc_const = priv->tdc_const;473 474 if (!tdc_const)475 return 0;476 477 nest = nla_nest_start(skb, IFLA_CAN_TDC);478 if (!nest)479 return -EMSGSIZE;480 481 if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL &&482 (nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MIN, tdc_const->tdcv_min) ||483 nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MAX, tdc_const->tdcv_max)))484 goto err_cancel;485 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MIN, tdc_const->tdco_min) ||486 nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MAX, tdc_const->tdco_max))487 goto err_cancel;488 if (tdc_const->tdcf_max &&489 (nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MIN, tdc_const->tdcf_min) ||490 nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max)))491 goto err_cancel;492 493 if (can_tdc_is_enabled(priv)) {494 u32 tdcv;495 int err = -EINVAL;496 497 if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL) {498 tdcv = tdc->tdcv;499 err = 0;500 } else if (priv->do_get_auto_tdcv) {501 err = priv->do_get_auto_tdcv(dev, &tdcv);502 }503 if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv))504 goto err_cancel;505 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO, tdc->tdco))506 goto err_cancel;507 if (tdc_const->tdcf_max &&508 nla_put_u32(skb, IFLA_CAN_TDC_TDCF, tdc->tdcf))509 goto err_cancel;510 }511 512 nla_nest_end(skb, nest);513 return 0;514 515err_cancel:516 nla_nest_cancel(skb, nest);517 return -EMSGSIZE;518}519 520static int can_ctrlmode_ext_fill_info(struct sk_buff *skb,521 const struct can_priv *priv)522{523 struct nlattr *nest;524 525 nest = nla_nest_start(skb, IFLA_CAN_CTRLMODE_EXT);526 if (!nest)527 return -EMSGSIZE;528 529 if (nla_put_u32(skb, IFLA_CAN_CTRLMODE_SUPPORTED,530 priv->ctrlmode_supported)) {531 nla_nest_cancel(skb, nest);532 return -EMSGSIZE;533 }534 535 nla_nest_end(skb, nest);536 return 0;537}538 539static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)540{541 struct can_priv *priv = netdev_priv(dev);542 struct can_ctrlmode cm = {.flags = priv->ctrlmode};543 struct can_berr_counter bec = { };544 enum can_state state = priv->state;545 546 if (priv->do_get_state)547 priv->do_get_state(dev, &state);548 549 if ((priv->bittiming.bitrate != CAN_BITRATE_UNSET &&550 priv->bittiming.bitrate != CAN_BITRATE_UNKNOWN &&551 nla_put(skb, IFLA_CAN_BITTIMING,552 sizeof(priv->bittiming), &priv->bittiming)) ||553 554 (priv->bittiming_const &&555 nla_put(skb, IFLA_CAN_BITTIMING_CONST,556 sizeof(*priv->bittiming_const), priv->bittiming_const)) ||557 558 nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) ||559 nla_put_u32(skb, IFLA_CAN_STATE, state) ||560 nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) ||561 nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) ||562 563 (priv->do_get_berr_counter &&564 !priv->do_get_berr_counter(dev, &bec) &&565 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||566 567 (priv->data_bittiming.bitrate &&568 nla_put(skb, IFLA_CAN_DATA_BITTIMING,569 sizeof(priv->data_bittiming), &priv->data_bittiming)) ||570 571 (priv->data_bittiming_const &&572 nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST,573 sizeof(*priv->data_bittiming_const),574 priv->data_bittiming_const)) ||575 576 (priv->termination_const &&577 (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) ||578 nla_put(skb, IFLA_CAN_TERMINATION_CONST,579 sizeof(*priv->termination_const) *580 priv->termination_const_cnt,581 priv->termination_const))) ||582 583 (priv->bitrate_const &&584 nla_put(skb, IFLA_CAN_BITRATE_CONST,585 sizeof(*priv->bitrate_const) *586 priv->bitrate_const_cnt,587 priv->bitrate_const)) ||588 589 (priv->data_bitrate_const &&590 nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST,591 sizeof(*priv->data_bitrate_const) *592 priv->data_bitrate_const_cnt,593 priv->data_bitrate_const)) ||594 595 (nla_put(skb, IFLA_CAN_BITRATE_MAX,596 sizeof(priv->bitrate_max),597 &priv->bitrate_max)) ||598 599 can_tdc_fill_info(skb, dev) ||600 601 can_ctrlmode_ext_fill_info(skb, priv)602 )603 604 return -EMSGSIZE;605 606 return 0;607}608 609static size_t can_get_xstats_size(const struct net_device *dev)610{611 return sizeof(struct can_device_stats);612}613 614static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)615{616 struct can_priv *priv = netdev_priv(dev);617 618 if (nla_put(skb, IFLA_INFO_XSTATS,619 sizeof(priv->can_stats), &priv->can_stats))620 goto nla_put_failure;621 return 0;622 623nla_put_failure:624 return -EMSGSIZE;625}626 627static int can_newlink(struct net *src_net, struct net_device *dev,628 struct nlattr *tb[], struct nlattr *data[],629 struct netlink_ext_ack *extack)630{631 return -EOPNOTSUPP;632}633 634static void can_dellink(struct net_device *dev, struct list_head *head)635{636}637 638struct rtnl_link_ops can_link_ops __read_mostly = {639 .kind = "can",640 .netns_refund = true,641 .maxtype = IFLA_CAN_MAX,642 .policy = can_policy,643 .setup = can_setup,644 .validate = can_validate,645 .newlink = can_newlink,646 .changelink = can_changelink,647 .dellink = can_dellink,648 .get_size = can_get_size,649 .fill_info = can_fill_info,650 .get_xstats_size = can_get_xstats_size,651 .fill_xstats = can_fill_xstats,652};653 654int can_netlink_register(void)655{656 return rtnl_link_register(&can_link_ops);657}658 659void can_netlink_unregister(void)660{661 rtnl_link_unregister(&can_link_ops);662}663