net/ethtool/linkmodes.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include "netlink.h"
   4 #include "common.h"
   5 #include "bitset.h"
   6
   7 struct linkmodes_req_info {
   8         struct ethnl_req_info           base;
   9 };
  10
  11 struct linkmodes_reply_data {
  12         struct ethnl_reply_data         base;
  13         struct ethtool_link_ksettings   ksettings;
  14         struct ethtool_link_settings    *lsettings;
  15         bool                            peer_empty;
  16 };
  17
  18 #define LINKMODES_REPDATA(__reply_base) \
  19         container_of(__reply_base, struct linkmodes_reply_data, base)
  20
  21 const struct nla_policy ethnl_linkmodes_get_policy[] = {
  22         [ETHTOOL_A_LINKMODES_HEADER]            =
  23                 NLA_POLICY_NESTED(ethnl_header_policy),
  24 };
  25
  26 static int linkmodes_prepare_data(const struct ethnl_req_info *req_base,
  27                                   struct ethnl_reply_data *reply_base,
  28                                   struct genl_info *info)
  29 {
  30         struct linkmodes_reply_data *data = LINKMODES_REPDATA(reply_base);
  31         struct net_device *dev = reply_base->dev;
  32         int ret;
  33
  34         data->lsettings = &data->ksettings.base;
  35
  36         ret = ethnl_ops_begin(dev);
  37         if (ret < 0)
  38                 return ret;
  39
  40         ret = __ethtool_get_link_ksettings(dev, &data->ksettings);
  41         if (ret < 0 && info) {
  42                 GENL_SET_ERR_MSG(info, "failed to retrieve link settings");
  43                 goto out;
  44         }
  45
  46         data->peer_empty =
  47                 bitmap_empty(data->ksettings.link_modes.lp_advertising,
  48                              __ETHTOOL_LINK_MODE_MASK_NBITS);
  49
  50 out:
  51         ethnl_ops_complete(dev);
  52         return ret;
  53 }
  54
  55 static int linkmodes_reply_size(const struct ethnl_req_info *req_base,
  56                                 const struct ethnl_reply_data *reply_base)
  57 {
  58         const struct linkmodes_reply_data *data = LINKMODES_REPDATA(reply_base);
  59         const struct ethtool_link_ksettings *ksettings = &data->ksettings;
  60         const struct ethtool_link_settings *lsettings = &ksettings->base;
  61         bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
  62         int len, ret;
  63
  64         len = nla_total_size(sizeof(u8)) /* LINKMODES_AUTONEG */
  65                 + nla_total_size(sizeof(u32)) /* LINKMODES_SPEED */
  66                 + nla_total_size(sizeof(u8)) /* LINKMODES_DUPLEX */
  67                 + 0;
  68         ret = ethnl_bitset_size(ksettings->link_modes.advertising,
  69                                 ksettings->link_modes.supported,
  70                                 __ETHTOOL_LINK_MODE_MASK_NBITS,
  71                                 link_mode_names, compact);
  72         if (ret < 0)
  73                 return ret;
  74         len += ret;
  75         if (!data->peer_empty) {
  76                 ret = ethnl_bitset_size(ksettings->link_modes.lp_advertising,
  77                                         NULL, __ETHTOOL_LINK_MODE_MASK_NBITS,
  78                                         link_mode_names, compact);
  79                 if (ret < 0)
  80                         return ret;
  81                 len += ret;
  82         }
  83
  84         if (lsettings->master_slave_cfg != MASTER_SLAVE_CFG_UNSUPPORTED)
  85                 len += nla_total_size(sizeof(u8));
  86
  87         if (lsettings->master_slave_state != MASTER_SLAVE_STATE_UNSUPPORTED)
  88                 len += nla_total_size(sizeof(u8));
  89
  90         return len;
  91 }
  92
  93 static int linkmodes_fill_reply(struct sk_buff *skb,
  94                                 const struct ethnl_req_info *req_base,
  95                                 const struct ethnl_reply_data *reply_base)
  96 {
  97         const struct linkmodes_reply_data *data = LINKMODES_REPDATA(reply_base);
  98         const struct ethtool_link_ksettings *ksettings = &data->ksettings;
  99         const struct ethtool_link_settings *lsettings = &ksettings->base;
 100         bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
 101         int ret;
 102
 103         if (nla_put_u8(skb, ETHTOOL_A_LINKMODES_AUTONEG, lsettings->autoneg))
 104                 return -EMSGSIZE;
 105
 106         ret = ethnl_put_bitset(skb, ETHTOOL_A_LINKMODES_OURS,
 107                                ksettings->link_modes.advertising,
 108                                ksettings->link_modes.supported,
 109                                __ETHTOOL_LINK_MODE_MASK_NBITS, link_mode_names,
 110                                compact);
 111         if (ret < 0)
 112                 return -EMSGSIZE;
 113         if (!data->peer_empty) {
 114                 ret = ethnl_put_bitset(skb, ETHTOOL_A_LINKMODES_PEER,
 115                                        ksettings->link_modes.lp_advertising,
 116                                        NULL, __ETHTOOL_LINK_MODE_MASK_NBITS,
 117                                        link_mode_names, compact);
 118                 if (ret < 0)
 119                         return -EMSGSIZE;
 120         }
 121
 122         if (nla_put_u32(skb, ETHTOOL_A_LINKMODES_SPEED, lsettings->speed) ||
 123             nla_put_u8(skb, ETHTOOL_A_LINKMODES_DUPLEX, lsettings->duplex))
 124                 return -EMSGSIZE;
 125
 126         if (lsettings->master_slave_cfg != MASTER_SLAVE_CFG_UNSUPPORTED &&
 127             nla_put_u8(skb, ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG,
 128                        lsettings->master_slave_cfg))
 129                 return -EMSGSIZE;
 130
 131         if (lsettings->master_slave_state != MASTER_SLAVE_STATE_UNSUPPORTED &&
 132             nla_put_u8(skb, ETHTOOL_A_LINKMODES_MASTER_SLAVE_STATE,
 133                        lsettings->master_slave_state))
 134                 return -EMSGSIZE;
 135
 136         return 0;
 137 }
 138
 139 const struct ethnl_request_ops ethnl_linkmodes_request_ops = {
 140         .request_cmd            = ETHTOOL_MSG_LINKMODES_GET,
 141         .reply_cmd              = ETHTOOL_MSG_LINKMODES_GET_REPLY,
 142         .hdr_attr               = ETHTOOL_A_LINKMODES_HEADER,
 143         .req_info_size          = sizeof(struct linkmodes_req_info),
 144         .reply_data_size        = sizeof(struct linkmodes_reply_data),
 145
 146         .prepare_data           = linkmodes_prepare_data,
 147         .reply_size             = linkmodes_reply_size,
 148         .fill_reply             = linkmodes_fill_reply,
 149 };
 150
 151 /* LINKMODES_SET */
 152
 153 struct link_mode_info {
 154         int                             speed;
 155         u8                              lanes;
 156         u8                              duplex;
 157 };
 158
 159 #define __LINK_MODE_LANES_CR            1
 160 #define __LINK_MODE_LANES_CR2           2
 161 #define __LINK_MODE_LANES_CR4           4
 162 #define __LINK_MODE_LANES_CR8           8
 163 #define __LINK_MODE_LANES_DR            1
 164 #define __LINK_MODE_LANES_DR2           2
 165 #define __LINK_MODE_LANES_DR4           4
 166 #define __LINK_MODE_LANES_DR8           8
 167 #define __LINK_MODE_LANES_KR            1
 168 #define __LINK_MODE_LANES_KR2           2
 169 #define __LINK_MODE_LANES_KR4           4
 170 #define __LINK_MODE_LANES_KR8           8
 171 #define __LINK_MODE_LANES_SR            1
 172 #define __LINK_MODE_LANES_SR2           2
 173 #define __LINK_MODE_LANES_SR4           4
 174 #define __LINK_MODE_LANES_SR8           8
 175 #define __LINK_MODE_LANES_ER            1
 176 #define __LINK_MODE_LANES_KX            1
 177 #define __LINK_MODE_LANES_KX4           4
 178 #define __LINK_MODE_LANES_LR            1
 179 #define __LINK_MODE_LANES_LR4           4
 180 #define __LINK_MODE_LANES_LR4_ER4       4
 181 #define __LINK_MODE_LANES_LR_ER_FR      1
 182 #define __LINK_MODE_LANES_LR2_ER2_FR2   2
 183 #define __LINK_MODE_LANES_LR4_ER4_FR4   4
 184 #define __LINK_MODE_LANES_LR8_ER8_FR8   8
 185 #define __LINK_MODE_LANES_LRM           1
 186 #define __LINK_MODE_LANES_MLD2          2
 187 #define __LINK_MODE_LANES_T             1
 188 #define __LINK_MODE_LANES_T1            1
 189 #define __LINK_MODE_LANES_X             1
 190 #define __LINK_MODE_LANES_FX            1
 191
 192 #define __DEFINE_LINK_MODE_PARAMS(_speed, _type, _duplex)       \
 193         [ETHTOOL_LINK_MODE(_speed, _type, _duplex)] = {         \
 194                 .speed  = SPEED_ ## _speed, \
 195                 .lanes  = __LINK_MODE_LANES_ ## _type, \
 196                 .duplex = __DUPLEX_ ## _duplex \
 197         }
 198 #define __DUPLEX_Half DUPLEX_HALF
 199 #define __DUPLEX_Full DUPLEX_FULL
 200 #define __DEFINE_SPECIAL_MODE_PARAMS(_mode) \
 201         [ETHTOOL_LINK_MODE_ ## _mode ## _BIT] = { \
 202                 .speed  = SPEED_UNKNOWN, \
 203                 .lanes  = 0, \
 204                 .duplex = DUPLEX_UNKNOWN, \
 205         }
 206
 207 static const struct link_mode_info link_mode_params[] = {
 208         __DEFINE_LINK_MODE_PARAMS(10, T, Half),
 209         __DEFINE_LINK_MODE_PARAMS(10, T, Full),
 210         __DEFINE_LINK_MODE_PARAMS(100, T, Half),
 211         __DEFINE_LINK_MODE_PARAMS(100, T, Full),
 212         __DEFINE_LINK_MODE_PARAMS(1000, T, Half),
 213         __DEFINE_LINK_MODE_PARAMS(1000, T, Full),
 214         __DEFINE_SPECIAL_MODE_PARAMS(Autoneg),
 215         __DEFINE_SPECIAL_MODE_PARAMS(TP),
 216         __DEFINE_SPECIAL_MODE_PARAMS(AUI),
 217         __DEFINE_SPECIAL_MODE_PARAMS(MII),
 218         __DEFINE_SPECIAL_MODE_PARAMS(FIBRE),
 219         __DEFINE_SPECIAL_MODE_PARAMS(BNC),
 220         __DEFINE_LINK_MODE_PARAMS(10000, T, Full),
 221         __DEFINE_SPECIAL_MODE_PARAMS(Pause),
 222         __DEFINE_SPECIAL_MODE_PARAMS(Asym_Pause),
 223         __DEFINE_LINK_MODE_PARAMS(2500, X, Full),
 224         __DEFINE_SPECIAL_MODE_PARAMS(Backplane),
 225         __DEFINE_LINK_MODE_PARAMS(1000, KX, Full),
 226         __DEFINE_LINK_MODE_PARAMS(10000, KX4, Full),
 227         __DEFINE_LINK_MODE_PARAMS(10000, KR, Full),
 228         [ETHTOOL_LINK_MODE_10000baseR_FEC_BIT] = {
 229                 .speed  = SPEED_10000,
 230                 .duplex = DUPLEX_FULL,
 231         },
 232         __DEFINE_LINK_MODE_PARAMS(20000, MLD2, Full),
 233         __DEFINE_LINK_MODE_PARAMS(20000, KR2, Full),
 234         __DEFINE_LINK_MODE_PARAMS(40000, KR4, Full),
 235         __DEFINE_LINK_MODE_PARAMS(40000, CR4, Full),
 236         __DEFINE_LINK_MODE_PARAMS(40000, SR4, Full),
 237         __DEFINE_LINK_MODE_PARAMS(40000, LR4, Full),
 238         __DEFINE_LINK_MODE_PARAMS(56000, KR4, Full),
 239         __DEFINE_LINK_MODE_PARAMS(56000, CR4, Full),
 240         __DEFINE_LINK_MODE_PARAMS(56000, SR4, Full),
 241         __DEFINE_LINK_MODE_PARAMS(56000, LR4, Full),
 242         __DEFINE_LINK_MODE_PARAMS(25000, CR, Full),
 243         __DEFINE_LINK_MODE_PARAMS(25000, KR, Full),
 244         __DEFINE_LINK_MODE_PARAMS(25000, SR, Full),
 245         __DEFINE_LINK_MODE_PARAMS(50000, CR2, Full),
 246         __DEFINE_LINK_MODE_PARAMS(50000, KR2, Full),
 247         __DEFINE_LINK_MODE_PARAMS(100000, KR4, Full),
 248         __DEFINE_LINK_MODE_PARAMS(100000, SR4, Full),
 249         __DEFINE_LINK_MODE_PARAMS(100000, CR4, Full),
 250         __DEFINE_LINK_MODE_PARAMS(100000, LR4_ER4, Full),
 251         __DEFINE_LINK_MODE_PARAMS(50000, SR2, Full),
 252         __DEFINE_LINK_MODE_PARAMS(1000, X, Full),
 253         __DEFINE_LINK_MODE_PARAMS(10000, CR, Full),
 254         __DEFINE_LINK_MODE_PARAMS(10000, SR, Full),
 255         __DEFINE_LINK_MODE_PARAMS(10000, LR, Full),
 256         __DEFINE_LINK_MODE_PARAMS(10000, LRM, Full),
 257         __DEFINE_LINK_MODE_PARAMS(10000, ER, Full),
 258         __DEFINE_LINK_MODE_PARAMS(2500, T, Full),
 259         __DEFINE_LINK_MODE_PARAMS(5000, T, Full),
 260         __DEFINE_SPECIAL_MODE_PARAMS(FEC_NONE),
 261         __DEFINE_SPECIAL_MODE_PARAMS(FEC_RS),
 262         __DEFINE_SPECIAL_MODE_PARAMS(FEC_BASER),
 263         __DEFINE_LINK_MODE_PARAMS(50000, KR, Full),
 264         __DEFINE_LINK_MODE_PARAMS(50000, SR, Full),
 265         __DEFINE_LINK_MODE_PARAMS(50000, CR, Full),
 266         __DEFINE_LINK_MODE_PARAMS(50000, LR_ER_FR, Full),
 267         __DEFINE_LINK_MODE_PARAMS(50000, DR, Full),
 268         __DEFINE_LINK_MODE_PARAMS(100000, KR2, Full),
 269         __DEFINE_LINK_MODE_PARAMS(100000, SR2, Full),
 270         __DEFINE_LINK_MODE_PARAMS(100000, CR2, Full),
 271         __DEFINE_LINK_MODE_PARAMS(100000, LR2_ER2_FR2, Full),
 272         __DEFINE_LINK_MODE_PARAMS(100000, DR2, Full),
 273         __DEFINE_LINK_MODE_PARAMS(200000, KR4, Full),
 274         __DEFINE_LINK_MODE_PARAMS(200000, SR4, Full),
 275         __DEFINE_LINK_MODE_PARAMS(200000, LR4_ER4_FR4, Full),
 276         __DEFINE_LINK_MODE_PARAMS(200000, DR4, Full),
 277         __DEFINE_LINK_MODE_PARAMS(200000, CR4, Full),
 278         __DEFINE_LINK_MODE_PARAMS(100, T1, Full),
 279         __DEFINE_LINK_MODE_PARAMS(1000, T1, Full),
 280         __DEFINE_LINK_MODE_PARAMS(400000, KR8, Full),
 281         __DEFINE_LINK_MODE_PARAMS(400000, SR8, Full),
 282         __DEFINE_LINK_MODE_PARAMS(400000, LR8_ER8_FR8, Full),
 283         __DEFINE_LINK_MODE_PARAMS(400000, DR8, Full),
 284         __DEFINE_LINK_MODE_PARAMS(400000, CR8, Full),
 285         __DEFINE_SPECIAL_MODE_PARAMS(FEC_LLRS),
 286         __DEFINE_LINK_MODE_PARAMS(100000, KR, Full),
 287         __DEFINE_LINK_MODE_PARAMS(100000, SR, Full),
 288         __DEFINE_LINK_MODE_PARAMS(100000, LR_ER_FR, Full),
 289         __DEFINE_LINK_MODE_PARAMS(100000, DR, Full),
 290         __DEFINE_LINK_MODE_PARAMS(100000, CR, Full),
 291         __DEFINE_LINK_MODE_PARAMS(200000, KR2, Full),
 292         __DEFINE_LINK_MODE_PARAMS(200000, SR2, Full),
 293         __DEFINE_LINK_MODE_PARAMS(200000, LR2_ER2_FR2, Full),
 294         __DEFINE_LINK_MODE_PARAMS(200000, DR2, Full),
 295         __DEFINE_LINK_MODE_PARAMS(200000, CR2, Full),
 296         __DEFINE_LINK_MODE_PARAMS(400000, KR4, Full),
 297         __DEFINE_LINK_MODE_PARAMS(400000, SR4, Full),
 298         __DEFINE_LINK_MODE_PARAMS(400000, LR4_ER4_FR4, Full),
 299         __DEFINE_LINK_MODE_PARAMS(400000, DR4, Full),
 300         __DEFINE_LINK_MODE_PARAMS(400000, CR4, Full),
 301         __DEFINE_LINK_MODE_PARAMS(100, FX, Half),
 302         __DEFINE_LINK_MODE_PARAMS(100, FX, Full),
 303 };
 304
 305 const struct nla_policy ethnl_linkmodes_set_policy[] = {
 306         [ETHTOOL_A_LINKMODES_HEADER]            =
 307                 NLA_POLICY_NESTED(ethnl_header_policy),
 308         [ETHTOOL_A_LINKMODES_AUTONEG]           = { .type = NLA_U8 },
 309         [ETHTOOL_A_LINKMODES_OURS]              = { .type = NLA_NESTED },
 310         [ETHTOOL_A_LINKMODES_SPEED]             = { .type = NLA_U32 },
 311         [ETHTOOL_A_LINKMODES_DUPLEX]            = { .type = NLA_U8 },
 312         [ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG]  = { .type = NLA_U8 },
 313         [ETHTOOL_A_LINKMODES_LANES]             = NLA_POLICY_RANGE(NLA_U32, 1, 8),
 314 };
 315
 316 /* Set advertised link modes to all supported modes matching requested speed,
 317  * lanes and duplex values. Called when autonegotiation is on, speed, lanes or
 318  * duplex is requested but no link mode change. This is done in userspace with
 319  * ioctl() interface, move it into kernel for netlink.
 320  * Returns true if advertised modes bitmap was modified.
 321  */
 322 static bool ethnl_auto_linkmodes(struct ethtool_link_ksettings *ksettings,
 323                                  bool req_speed, bool req_lanes, bool req_duplex)
 324 {
 325         unsigned long *advertising = ksettings->link_modes.advertising;
 326         unsigned long *supported = ksettings->link_modes.supported;
 327         DECLARE_BITMAP(old_adv, __ETHTOOL_LINK_MODE_MASK_NBITS);
 328         unsigned int i;
 329
 330         BUILD_BUG_ON(ARRAY_SIZE(link_mode_params) !=
 331                      __ETHTOOL_LINK_MODE_MASK_NBITS);
 332
 333         bitmap_copy(old_adv, advertising, __ETHTOOL_LINK_MODE_MASK_NBITS);
 334
 335         for (i = 0; i < __ETHTOOL_LINK_MODE_MASK_NBITS; i++) {
 336                 const struct link_mode_info *info = &link_mode_params[i];
 337
 338                 if (info->speed == SPEED_UNKNOWN)
 339                         continue;
 340                 if (test_bit(i, supported) &&
 341                     (!req_speed || info->speed == ksettings->base.speed) &&
 342                     (!req_lanes || info->lanes == ksettings->lanes) &&
 343                     (!req_duplex || info->duplex == ksettings->base.duplex))
 344                         set_bit(i, advertising);
 345                 else
 346                         clear_bit(i, advertising);
 347         }
 348
 349         return !bitmap_equal(old_adv, advertising,
 350                              __ETHTOOL_LINK_MODE_MASK_NBITS);
 351 }
 352
 353 static bool ethnl_validate_master_slave_cfg(u8 cfg)
 354 {
 355         switch (cfg) {
 356         case MASTER_SLAVE_CFG_MASTER_PREFERRED:
 357         case MASTER_SLAVE_CFG_SLAVE_PREFERRED:
 358         case MASTER_SLAVE_CFG_MASTER_FORCE:
 359         case MASTER_SLAVE_CFG_SLAVE_FORCE:
 360                 return true;
 361         }
 362
 363         return false;
 364 }
 365
 366 static int ethnl_check_linkmodes(struct genl_info *info, struct nlattr **tb)
 367 {
 368         const struct nlattr *master_slave_cfg, *lanes_cfg;
 369
 370         master_slave_cfg = tb[ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG];
 371         if (master_slave_cfg &&
 372             !ethnl_validate_master_slave_cfg(nla_get_u8(master_slave_cfg))) {
 373                 NL_SET_ERR_MSG_ATTR(info->extack, master_slave_cfg,
 374                                     "master/slave value is invalid");
 375                 return -EOPNOTSUPP;
 376         }
 377
 378         lanes_cfg = tb[ETHTOOL_A_LINKMODES_LANES];
 379         if (lanes_cfg && !is_power_of_2(nla_get_u32(lanes_cfg))) {
 380                 NL_SET_ERR_MSG_ATTR(info->extack, lanes_cfg,
 381                                     "lanes value is invalid");
 382                 return -EINVAL;
 383         }
 384
 385         return 0;
 386 }
 387
 388 static int ethnl_update_linkmodes(struct genl_info *info, struct nlattr **tb,
 389                                   struct ethtool_link_ksettings *ksettings,
 390                                   bool *mod, const struct net_device *dev)
 391 {
 392         struct ethtool_link_settings *lsettings = &ksettings->base;
 393         bool req_speed, req_lanes, req_duplex;
 394         const struct nlattr *master_slave_cfg, *lanes_cfg;
 395         int ret;
 396
 397         master_slave_cfg = tb[ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG];
 398         if (master_slave_cfg) {
 399                 if (lsettings->master_slave_cfg == MASTER_SLAVE_CFG_UNSUPPORTED) {
 400                         NL_SET_ERR_MSG_ATTR(info->extack, master_slave_cfg,
 401                                             "master/slave configuration not supported by device");
 402                         return -EOPNOTSUPP;
 403                 }
 404         }
 405
 406         *mod = false;
 407         req_speed = tb[ETHTOOL_A_LINKMODES_SPEED];
 408         req_lanes = tb[ETHTOOL_A_LINKMODES_LANES];
 409         req_duplex = tb[ETHTOOL_A_LINKMODES_DUPLEX];
 410
 411         ethnl_update_u8(&lsettings->autoneg, tb[ETHTOOL_A_LINKMODES_AUTONEG],
 412                         mod);
 413
 414         lanes_cfg = tb[ETHTOOL_A_LINKMODES_LANES];
 415         if (lanes_cfg) {
 416                 /* If autoneg is off and lanes parameter is not supported by the
 417                  * driver, return an error.
 418                  */
 419                 if (!lsettings->autoneg &&
 420                     !dev->ethtool_ops->cap_link_lanes_supported) {
 421                         NL_SET_ERR_MSG_ATTR(info->extack, lanes_cfg,
 422                                             "lanes configuration not supported by device");
 423                         return -EOPNOTSUPP;
 424                 }
 425         } else if (!lsettings->autoneg) {
 426                 /* If autoneg is off and lanes parameter is not passed from user,
 427                  * set the lanes parameter to 0.
 428                  */
 429                 ksettings->lanes = 0;
 430         }
 431
 432         ret = ethnl_update_bitset(ksettings->link_modes.advertising,
 433                                   __ETHTOOL_LINK_MODE_MASK_NBITS,
 434                                   tb[ETHTOOL_A_LINKMODES_OURS], link_mode_names,
 435                                   info->extack, mod);
 436         if (ret < 0)
 437                 return ret;
 438         ethnl_update_u32(&lsettings->speed, tb[ETHTOOL_A_LINKMODES_SPEED],
 439                          mod);
 440         ethnl_update_u32(&ksettings->lanes, lanes_cfg, mod);
 441         ethnl_update_u8(&lsettings->duplex, tb[ETHTOOL_A_LINKMODES_DUPLEX],
 442                         mod);
 443         ethnl_update_u8(&lsettings->master_slave_cfg, master_slave_cfg, mod);
 444
 445         if (!tb[ETHTOOL_A_LINKMODES_OURS] && lsettings->autoneg &&
 446             (req_speed || req_lanes || req_duplex) &&
 447             ethnl_auto_linkmodes(ksettings, req_speed, req_lanes, req_duplex))
 448                 *mod = true;
 449
 450         return 0;
 451 }
 452
 453 int ethnl_set_linkmodes(struct sk_buff *skb, struct genl_info *info)
 454 {
 455         struct ethtool_link_ksettings ksettings = {};
 456         struct ethnl_req_info req_info = {};
 457         struct nlattr **tb = info->attrs;
 458         struct net_device *dev;
 459         bool mod = false;
 460         int ret;
 461
 462         ret = ethnl_check_linkmodes(info, tb);
 463         if (ret < 0)
 464                 return ret;
 465
 466         ret = ethnl_parse_header_dev_get(&req_info,
 467                                          tb[ETHTOOL_A_LINKMODES_HEADER],
 468                                          genl_info_net(info), info->extack,
 469                                          true);
 470         if (ret < 0)
 471                 return ret;
 472         dev = req_info.dev;
 473         ret = -EOPNOTSUPP;
 474         if (!dev->ethtool_ops->get_link_ksettings ||
 475             !dev->ethtool_ops->set_link_ksettings)
 476                 goto out_dev;
 477
 478         rtnl_lock();
 479         ret = ethnl_ops_begin(dev);
 480         if (ret < 0)
 481                 goto out_rtnl;
 482
 483         ret = __ethtool_get_link_ksettings(dev, &ksettings);
 484         if (ret < 0) {
 485                 GENL_SET_ERR_MSG(info, "failed to retrieve link settings");
 486                 goto out_ops;
 487         }
 488
 489         ret = ethnl_update_linkmodes(info, tb, &ksettings, &mod, dev);
 490         if (ret < 0)
 491                 goto out_ops;
 492
 493         if (mod) {
 494                 ret = dev->ethtool_ops->set_link_ksettings(dev, &ksettings);
 495                 if (ret < 0)
 496                         GENL_SET_ERR_MSG(info, "link settings update failed");
 497                 else
 498                         ethtool_notify(dev, ETHTOOL_MSG_LINKMODES_NTF, NULL);
 499         }
 500
 501 out_ops:
 502         ethnl_ops_complete(dev);
 503 out_rtnl:
 504         rtnl_unlock();
 505 out_dev:
 506         dev_put(dev);
 507         return ret;
 508 }