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 <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_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 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->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
 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         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 mutually
 239                  * exclusive: make sure to turn the other one off
 240                  */
 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 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                 /* 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 on
 311                  * data_bittiming_const if set, otherwise pass bitrate
 312                  * directly via do_set_bitrate(). Bail out if neither
 313                  * 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 are
 347                          * provided: do calculation
 348                          */
 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 explicitly
 352                    * turned off. TDC is disabled: do nothing
 353                    */
 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
 392 static 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
 424 static 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
 430 static 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
 467 static 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
 515 err_cancel:
 516         nla_nest_cancel(skb, nest);
 517         return -EMSGSIZE;
 518 }
 519
 520 static 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
 539 static 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
 609 static size_t can_get_xstats_size(const struct net_device *dev)
 610 {
 611         return sizeof(struct can_device_stats);
 612 }
 613
 614 static 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
 623 nla_put_failure:
 624         return -EMSGSIZE;
 625 }
 626
 627 static 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
 634 static void can_dellink(struct net_device *dev, struct list_head *head)
 635 {
 636 }
 637
 638 struct 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
 654 int can_netlink_register(void)
 655 {
 656         return rtnl_link_register(&can_link_ops);
 657 }
 658
 659 void can_netlink_unregister(void)
 660 {
 661         rtnl_link_unregister(&can_link_ops);
 662 }