drivers/net/can/dev/netlink.c

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