drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c

   1 /*
   2  * Copyright (c) 2015, Mellanox Technologies. All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33 #include "en.h"
  34
  35 void mlx5e_ethtool_get_drvinfo(struct mlx5e_priv *priv,
  36                                struct ethtool_drvinfo *drvinfo)
  37 {
  38         struct mlx5_core_dev *mdev = priv->mdev;
  39
  40         strlcpy(drvinfo->driver, DRIVER_NAME, sizeof(drvinfo->driver));
  41         strlcpy(drvinfo->version, DRIVER_VERSION,
  42                 sizeof(drvinfo->version));
  43         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
  44                  "%d.%d.%04d (%.16s)",
  45                  fw_rev_maj(mdev), fw_rev_min(mdev), fw_rev_sub(mdev),
  46                  mdev->board_id);
  47         strlcpy(drvinfo->bus_info, pci_name(mdev->pdev),
  48                 sizeof(drvinfo->bus_info));
  49 }
  50
  51 static void mlx5e_get_drvinfo(struct net_device *dev,
  52                               struct ethtool_drvinfo *drvinfo)
  53 {
  54         struct mlx5e_priv *priv = netdev_priv(dev);
  55
  56         mlx5e_ethtool_get_drvinfo(priv, drvinfo);
  57 }
  58
  59 struct ptys2ethtool_config {
  60         __ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
  61         __ETHTOOL_DECLARE_LINK_MODE_MASK(advertised);
  62         u32 speed;
  63 };
  64
  65 static struct ptys2ethtool_config ptys2ethtool_table[MLX5E_LINK_MODES_NUMBER];
  66
  67 #define MLX5_BUILD_PTYS2ETHTOOL_CONFIG(reg_, speed_, ...)               \
  68         ({                                                              \
  69                 struct ptys2ethtool_config *cfg;                        \
  70                 const unsigned int modes[] = { __VA_ARGS__ };           \
  71                 unsigned int i;                                         \
  72                 cfg = &ptys2ethtool_table[reg_];                        \
  73                 cfg->speed = speed_;                                    \
  74                 bitmap_zero(cfg->supported,                             \
  75                             __ETHTOOL_LINK_MODE_MASK_NBITS);            \
  76                 bitmap_zero(cfg->advertised,                            \
  77                             __ETHTOOL_LINK_MODE_MASK_NBITS);            \
  78                 for (i = 0 ; i < ARRAY_SIZE(modes) ; ++i) {             \
  79                         __set_bit(modes[i], cfg->supported);            \
  80                         __set_bit(modes[i], cfg->advertised);           \
  81                 }                                                       \
  82         })
  83
  84 void mlx5e_build_ptys2ethtool_map(void)
  85 {
  86         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_1000BASE_CX_SGMII, SPEED_1000,
  87                                        ETHTOOL_LINK_MODE_1000baseKX_Full_BIT);
  88         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_1000BASE_KX, SPEED_1000,
  89                                        ETHTOOL_LINK_MODE_1000baseKX_Full_BIT);
  90         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_CX4, SPEED_10000,
  91                                        ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT);
  92         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_KX4, SPEED_10000,
  93                                        ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT);
  94         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_KR, SPEED_10000,
  95                                        ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);
  96         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_20GBASE_KR2, SPEED_20000,
  97                                        ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT);
  98         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_40GBASE_CR4, SPEED_40000,
  99                                        ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT);
 100         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_40GBASE_KR4, SPEED_40000,
 101                                        ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT);
 102         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_56GBASE_R4, SPEED_56000,
 103                                        ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT);
 104         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_CR, SPEED_10000,
 105                                        ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);
 106         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_SR, SPEED_10000,
 107                                        ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);
 108         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_ER, SPEED_10000,
 109                                        ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);
 110         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_40GBASE_SR4, SPEED_40000,
 111                                        ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT);
 112         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_40GBASE_LR4, SPEED_40000,
 113                                        ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT);
 114         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_50GBASE_SR2, SPEED_50000,
 115                                        ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT);
 116         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_100GBASE_CR4, SPEED_100000,
 117                                        ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT);
 118         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_100GBASE_SR4, SPEED_100000,
 119                                        ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT);
 120         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_100GBASE_KR4, SPEED_100000,
 121                                        ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT);
 122         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_100GBASE_LR4, SPEED_100000,
 123                                        ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT);
 124         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_T, SPEED_10000,
 125                                        ETHTOOL_LINK_MODE_10000baseT_Full_BIT);
 126         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_25GBASE_CR, SPEED_25000,
 127                                        ETHTOOL_LINK_MODE_25000baseCR_Full_BIT);
 128         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_25GBASE_KR, SPEED_25000,
 129                                        ETHTOOL_LINK_MODE_25000baseKR_Full_BIT);
 130         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_25GBASE_SR, SPEED_25000,
 131                                        ETHTOOL_LINK_MODE_25000baseSR_Full_BIT);
 132         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_50GBASE_CR2, SPEED_50000,
 133                                        ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT);
 134         MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_50GBASE_KR2, SPEED_50000,
 135                                        ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT);
 136 }
 137
 138 int mlx5e_ethtool_get_sset_count(struct mlx5e_priv *priv, int sset)
 139 {
 140         int i, num_stats = 0;
 141
 142         switch (sset) {
 143         case ETH_SS_STATS:
 144                 for (i = 0; i < mlx5e_num_stats_grps; i++)
 145                         num_stats += mlx5e_stats_grps[i].get_num_stats(priv);
 146                 return num_stats;
 147         case ETH_SS_PRIV_FLAGS:
 148                 return ARRAY_SIZE(mlx5e_priv_flags);
 149         case ETH_SS_TEST:
 150                 return mlx5e_self_test_num(priv);
 151         /* fallthrough */
 152         default:
 153                 return -EOPNOTSUPP;
 154         }
 155 }
 156
 157 static int mlx5e_get_sset_count(struct net_device *dev, int sset)
 158 {
 159         struct mlx5e_priv *priv = netdev_priv(dev);
 160
 161         return mlx5e_ethtool_get_sset_count(priv, sset);
 162 }
 163
 164 static void mlx5e_fill_stats_strings(struct mlx5e_priv *priv, u8 *data)
 165 {
 166         int i, idx = 0;
 167
 168         for (i = 0; i < mlx5e_num_stats_grps; i++)
 169                 idx = mlx5e_stats_grps[i].fill_strings(priv, data, idx);
 170 }
 171
 172 void mlx5e_ethtool_get_strings(struct mlx5e_priv *priv, u32 stringset, u8 *data)
 173 {
 174         int i;
 175
 176         switch (stringset) {
 177         case ETH_SS_PRIV_FLAGS:
 178                 for (i = 0; i < ARRAY_SIZE(mlx5e_priv_flags); i++)
 179                         strcpy(data + i * ETH_GSTRING_LEN, mlx5e_priv_flags[i]);
 180                 break;
 181
 182         case ETH_SS_TEST:
 183                 for (i = 0; i < mlx5e_self_test_num(priv); i++)
 184                         strcpy(data + i * ETH_GSTRING_LEN,
 185                                mlx5e_self_tests[i]);
 186                 break;
 187
 188         case ETH_SS_STATS:
 189                 mlx5e_fill_stats_strings(priv, data);
 190                 break;
 191         }
 192 }
 193
 194 static void mlx5e_get_strings(struct net_device *dev, u32 stringset, u8 *data)
 195 {
 196         struct mlx5e_priv *priv = netdev_priv(dev);
 197
 198         mlx5e_ethtool_get_strings(priv, stringset, data);
 199 }
 200
 201 void mlx5e_ethtool_get_ethtool_stats(struct mlx5e_priv *priv,
 202                                      struct ethtool_stats *stats, u64 *data)
 203 {
 204         int i, idx = 0;
 205
 206         mutex_lock(&priv->state_lock);
 207         mlx5e_update_stats(priv);
 208         mutex_unlock(&priv->state_lock);
 209
 210         for (i = 0; i < mlx5e_num_stats_grps; i++)
 211                 idx = mlx5e_stats_grps[i].fill_stats(priv, data, idx);
 212 }
 213
 214 static void mlx5e_get_ethtool_stats(struct net_device *dev,
 215                                     struct ethtool_stats *stats,
 216                                     u64 *data)
 217 {
 218         struct mlx5e_priv *priv = netdev_priv(dev);
 219
 220         mlx5e_ethtool_get_ethtool_stats(priv, stats, data);
 221 }
 222
 223 void mlx5e_ethtool_get_ringparam(struct mlx5e_priv *priv,
 224                                  struct ethtool_ringparam *param)
 225 {
 226         param->rx_max_pending = 1 << MLX5E_PARAMS_MAXIMUM_LOG_RQ_SIZE;
 227         param->tx_max_pending = 1 << MLX5E_PARAMS_MAXIMUM_LOG_SQ_SIZE;
 228         param->rx_pending     = 1 << priv->channels.params.log_rq_mtu_frames;
 229         param->tx_pending     = 1 << priv->channels.params.log_sq_size;
 230 }
 231
 232 static void mlx5e_get_ringparam(struct net_device *dev,
 233                                 struct ethtool_ringparam *param)
 234 {
 235         struct mlx5e_priv *priv = netdev_priv(dev);
 236
 237         mlx5e_ethtool_get_ringparam(priv, param);
 238 }
 239
 240 int mlx5e_ethtool_set_ringparam(struct mlx5e_priv *priv,
 241                                 struct ethtool_ringparam *param)
 242 {
 243         struct mlx5e_channels new_channels = {};
 244         u8 log_rq_size;
 245         u8 log_sq_size;
 246         int err = 0;
 247
 248         if (param->rx_jumbo_pending) {
 249                 netdev_info(priv->netdev, "%s: rx_jumbo_pending not supported\n",
 250                             __func__);
 251                 return -EINVAL;
 252         }
 253         if (param->rx_mini_pending) {
 254                 netdev_info(priv->netdev, "%s: rx_mini_pending not supported\n",
 255                             __func__);
 256                 return -EINVAL;
 257         }
 258
 259         if (param->rx_pending < (1 << MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE)) {
 260                 netdev_info(priv->netdev, "%s: rx_pending (%d) < min (%d)\n",
 261                             __func__, param->rx_pending,
 262                             1 << MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE);
 263                 return -EINVAL;
 264         }
 265
 266         if (param->tx_pending < (1 << MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE)) {
 267                 netdev_info(priv->netdev, "%s: tx_pending (%d) < min (%d)\n",
 268                             __func__, param->tx_pending,
 269                             1 << MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE);
 270                 return -EINVAL;
 271         }
 272
 273         log_rq_size = order_base_2(param->rx_pending);
 274         log_sq_size = order_base_2(param->tx_pending);
 275
 276         if (log_rq_size == priv->channels.params.log_rq_mtu_frames &&
 277             log_sq_size == priv->channels.params.log_sq_size)
 278                 return 0;
 279
 280         mutex_lock(&priv->state_lock);
 281
 282         new_channels.params = priv->channels.params;
 283         new_channels.params.log_rq_mtu_frames = log_rq_size;
 284         new_channels.params.log_sq_size = log_sq_size;
 285
 286         if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
 287                 priv->channels.params = new_channels.params;
 288                 goto unlock;
 289         }
 290
 291         err = mlx5e_open_channels(priv, &new_channels);
 292         if (err)
 293                 goto unlock;
 294
 295         mlx5e_switch_priv_channels(priv, &new_channels, NULL);
 296
 297 unlock:
 298         mutex_unlock(&priv->state_lock);
 299
 300         return err;
 301 }
 302
 303 static int mlx5e_set_ringparam(struct net_device *dev,
 304                                struct ethtool_ringparam *param)
 305 {
 306         struct mlx5e_priv *priv = netdev_priv(dev);
 307
 308         return mlx5e_ethtool_set_ringparam(priv, param);
 309 }
 310
 311 void mlx5e_ethtool_get_channels(struct mlx5e_priv *priv,
 312                                 struct ethtool_channels *ch)
 313 {
 314         ch->max_combined   = priv->profile->max_nch(priv->mdev);
 315         ch->combined_count = priv->channels.params.num_channels;
 316 }
 317
 318 static void mlx5e_get_channels(struct net_device *dev,
 319                                struct ethtool_channels *ch)
 320 {
 321         struct mlx5e_priv *priv = netdev_priv(dev);
 322
 323         mlx5e_ethtool_get_channels(priv, ch);
 324 }
 325
 326 int mlx5e_ethtool_set_channels(struct mlx5e_priv *priv,
 327                                struct ethtool_channels *ch)
 328 {
 329         unsigned int count = ch->combined_count;
 330         struct mlx5e_channels new_channels = {};
 331         bool arfs_enabled;
 332         int err = 0;
 333
 334         if (!count) {
 335                 netdev_info(priv->netdev, "%s: combined_count=0 not supported\n",
 336                             __func__);
 337                 return -EINVAL;
 338         }
 339
 340         if (priv->channels.params.num_channels == count)
 341                 return 0;
 342
 343         mutex_lock(&priv->state_lock);
 344
 345         new_channels.params = priv->channels.params;
 346         new_channels.params.num_channels = count;
 347         if (!netif_is_rxfh_configured(priv->netdev))
 348                 mlx5e_build_default_indir_rqt(new_channels.params.indirection_rqt,
 349                                               MLX5E_INDIR_RQT_SIZE, count);
 350
 351         if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
 352                 priv->channels.params = new_channels.params;
 353                 goto out;
 354         }
 355
 356         /* Create fresh channels with new parameters */
 357         err = mlx5e_open_channels(priv, &new_channels);
 358         if (err)
 359                 goto out;
 360
 361         arfs_enabled = priv->netdev->features & NETIF_F_NTUPLE;
 362         if (arfs_enabled)
 363                 mlx5e_arfs_disable(priv);
 364
 365         /* Switch to new channels, set new parameters and close old ones */
 366         mlx5e_switch_priv_channels(priv, &new_channels, NULL);
 367
 368         if (arfs_enabled) {
 369                 err = mlx5e_arfs_enable(priv);
 370                 if (err)
 371                         netdev_err(priv->netdev, "%s: mlx5e_arfs_enable failed: %d\n",
 372                                    __func__, err);
 373         }
 374
 375 out:
 376         mutex_unlock(&priv->state_lock);
 377
 378         return err;
 379 }
 380
 381 static int mlx5e_set_channels(struct net_device *dev,
 382                               struct ethtool_channels *ch)
 383 {
 384         struct mlx5e_priv *priv = netdev_priv(dev);
 385
 386         return mlx5e_ethtool_set_channels(priv, ch);
 387 }
 388
 389 int mlx5e_ethtool_get_coalesce(struct mlx5e_priv *priv,
 390                                struct ethtool_coalesce *coal)
 391 {
 392         if (!MLX5_CAP_GEN(priv->mdev, cq_moderation))
 393                 return -EOPNOTSUPP;
 394
 395         coal->rx_coalesce_usecs       = priv->channels.params.rx_cq_moderation.usec;
 396         coal->rx_max_coalesced_frames = priv->channels.params.rx_cq_moderation.pkts;
 397         coal->tx_coalesce_usecs       = priv->channels.params.tx_cq_moderation.usec;
 398         coal->tx_max_coalesced_frames = priv->channels.params.tx_cq_moderation.pkts;
 399         coal->use_adaptive_rx_coalesce = priv->channels.params.rx_dim_enabled;
 400
 401         return 0;
 402 }
 403
 404 static int mlx5e_get_coalesce(struct net_device *netdev,
 405                               struct ethtool_coalesce *coal)
 406 {
 407         struct mlx5e_priv *priv = netdev_priv(netdev);
 408
 409         return mlx5e_ethtool_get_coalesce(priv, coal);
 410 }
 411
 412 #define MLX5E_MAX_COAL_TIME             MLX5_MAX_CQ_PERIOD
 413 #define MLX5E_MAX_COAL_FRAMES           MLX5_MAX_CQ_COUNT
 414
 415 static void
 416 mlx5e_set_priv_channels_coalesce(struct mlx5e_priv *priv, struct ethtool_coalesce *coal)
 417 {
 418         struct mlx5_core_dev *mdev = priv->mdev;
 419         int tc;
 420         int i;
 421
 422         for (i = 0; i < priv->channels.num; ++i) {
 423                 struct mlx5e_channel *c = priv->channels.c[i];
 424
 425                 for (tc = 0; tc < c->num_tc; tc++) {
 426                         mlx5_core_modify_cq_moderation(mdev,
 427                                                 &c->sq[tc].cq.mcq,
 428                                                 coal->tx_coalesce_usecs,
 429                                                 coal->tx_max_coalesced_frames);
 430                 }
 431
 432                 mlx5_core_modify_cq_moderation(mdev, &c->rq.cq.mcq,
 433                                                coal->rx_coalesce_usecs,
 434                                                coal->rx_max_coalesced_frames);
 435         }
 436 }
 437
 438 int mlx5e_ethtool_set_coalesce(struct mlx5e_priv *priv,
 439                                struct ethtool_coalesce *coal)
 440 {
 441         struct mlx5_core_dev *mdev = priv->mdev;
 442         struct mlx5e_channels new_channels = {};
 443         int err = 0;
 444         bool reset;
 445
 446         if (!MLX5_CAP_GEN(mdev, cq_moderation))
 447                 return -EOPNOTSUPP;
 448
 449         if (coal->tx_coalesce_usecs > MLX5E_MAX_COAL_TIME ||
 450             coal->rx_coalesce_usecs > MLX5E_MAX_COAL_TIME) {
 451                 netdev_info(priv->netdev, "%s: maximum coalesce time supported is %lu usecs\n",
 452                             __func__, MLX5E_MAX_COAL_TIME);
 453                 return -ERANGE;
 454         }
 455
 456         if (coal->tx_max_coalesced_frames > MLX5E_MAX_COAL_FRAMES ||
 457             coal->rx_max_coalesced_frames > MLX5E_MAX_COAL_FRAMES) {
 458                 netdev_info(priv->netdev, "%s: maximum coalesced frames supported is %lu\n",
 459                             __func__, MLX5E_MAX_COAL_FRAMES);
 460                 return -ERANGE;
 461         }
 462
 463         mutex_lock(&priv->state_lock);
 464         new_channels.params = priv->channels.params;
 465
 466         new_channels.params.tx_cq_moderation.usec = coal->tx_coalesce_usecs;
 467         new_channels.params.tx_cq_moderation.pkts = coal->tx_max_coalesced_frames;
 468         new_channels.params.rx_cq_moderation.usec = coal->rx_coalesce_usecs;
 469         new_channels.params.rx_cq_moderation.pkts = coal->rx_max_coalesced_frames;
 470         new_channels.params.rx_dim_enabled        = !!coal->use_adaptive_rx_coalesce;
 471
 472         if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
 473                 priv->channels.params = new_channels.params;
 474                 goto out;
 475         }
 476         /* we are opened */
 477
 478         reset = !!coal->use_adaptive_rx_coalesce != priv->channels.params.rx_dim_enabled;
 479         if (!reset) {
 480                 mlx5e_set_priv_channels_coalesce(priv, coal);
 481                 priv->channels.params = new_channels.params;
 482                 goto out;
 483         }
 484
 485         /* open fresh channels with new coal parameters */
 486         err = mlx5e_open_channels(priv, &new_channels);
 487         if (err)
 488                 goto out;
 489
 490         mlx5e_switch_priv_channels(priv, &new_channels, NULL);
 491
 492 out:
 493         mutex_unlock(&priv->state_lock);
 494         return err;
 495 }
 496
 497 static int mlx5e_set_coalesce(struct net_device *netdev,
 498                               struct ethtool_coalesce *coal)
 499 {
 500         struct mlx5e_priv *priv    = netdev_priv(netdev);
 501
 502         return mlx5e_ethtool_set_coalesce(priv, coal);
 503 }
 504
 505 static void ptys2ethtool_supported_link(unsigned long *supported_modes,
 506                                         u32 eth_proto_cap)
 507 {
 508         unsigned long proto_cap = eth_proto_cap;
 509         int proto;
 510
 511         for_each_set_bit(proto, &proto_cap, MLX5E_LINK_MODES_NUMBER)
 512                 bitmap_or(supported_modes, supported_modes,
 513                           ptys2ethtool_table[proto].supported,
 514                           __ETHTOOL_LINK_MODE_MASK_NBITS);
 515 }
 516
 517 static void ptys2ethtool_adver_link(unsigned long *advertising_modes,
 518                                     u32 eth_proto_cap)
 519 {
 520         unsigned long proto_cap = eth_proto_cap;
 521         int proto;
 522
 523         for_each_set_bit(proto, &proto_cap, MLX5E_LINK_MODES_NUMBER)
 524                 bitmap_or(advertising_modes, advertising_modes,
 525                           ptys2ethtool_table[proto].advertised,
 526                           __ETHTOOL_LINK_MODE_MASK_NBITS);
 527 }
 528
 529 static void ptys2ethtool_supported_advertised_port(struct ethtool_link_ksettings *link_ksettings,
 530                                                    u32 eth_proto_cap,
 531                                                    u8 connector_type)
 532 {
 533         if (!connector_type || connector_type >= MLX5E_CONNECTOR_TYPE_NUMBER) {
 534                 if (eth_proto_cap & (MLX5E_PROT_MASK(MLX5E_10GBASE_CR)
 535                                    | MLX5E_PROT_MASK(MLX5E_10GBASE_SR)
 536                                    | MLX5E_PROT_MASK(MLX5E_40GBASE_CR4)
 537                                    | MLX5E_PROT_MASK(MLX5E_40GBASE_SR4)
 538                                    | MLX5E_PROT_MASK(MLX5E_100GBASE_SR4)
 539                                    | MLX5E_PROT_MASK(MLX5E_1000BASE_CX_SGMII))) {
 540                         ethtool_link_ksettings_add_link_mode(link_ksettings,
 541                                                              supported,
 542                                                              FIBRE);
 543                         ethtool_link_ksettings_add_link_mode(link_ksettings,
 544                                                              advertising,
 545                                                              FIBRE);
 546                 }
 547
 548                 if (eth_proto_cap & (MLX5E_PROT_MASK(MLX5E_100GBASE_KR4)
 549                                    | MLX5E_PROT_MASK(MLX5E_40GBASE_KR4)
 550                                    | MLX5E_PROT_MASK(MLX5E_10GBASE_KR)
 551                                    | MLX5E_PROT_MASK(MLX5E_10GBASE_KX4)
 552                                    | MLX5E_PROT_MASK(MLX5E_1000BASE_KX))) {
 553                         ethtool_link_ksettings_add_link_mode(link_ksettings,
 554                                                              supported,
 555                                                              Backplane);
 556                         ethtool_link_ksettings_add_link_mode(link_ksettings,
 557                                                              advertising,
 558                                                              Backplane);
 559                 }
 560                 return;
 561         }
 562
 563         switch (connector_type) {
 564         case MLX5E_PORT_TP:
 565                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 566                                                      supported, TP);
 567                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 568                                                      advertising, TP);
 569                 break;
 570         case MLX5E_PORT_AUI:
 571                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 572                                                      supported, AUI);
 573                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 574                                                      advertising, AUI);
 575                 break;
 576         case MLX5E_PORT_BNC:
 577                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 578                                                      supported, BNC);
 579                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 580                                                      advertising, BNC);
 581                 break;
 582         case MLX5E_PORT_MII:
 583                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 584                                                      supported, MII);
 585                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 586                                                      advertising, MII);
 587                 break;
 588         case MLX5E_PORT_FIBRE:
 589                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 590                                                      supported, FIBRE);
 591                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 592                                                      advertising, FIBRE);
 593                 break;
 594         case MLX5E_PORT_DA:
 595                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 596                                                      supported, Backplane);
 597                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 598                                                      advertising, Backplane);
 599                 break;
 600         case MLX5E_PORT_NONE:
 601         case MLX5E_PORT_OTHER:
 602         default:
 603                 break;
 604         }
 605 }
 606
 607 int mlx5e_get_max_linkspeed(struct mlx5_core_dev *mdev, u32 *speed)
 608 {
 609         u32 max_speed = 0;
 610         u32 proto_cap;
 611         int err;
 612         int i;
 613
 614         err = mlx5_query_port_proto_cap(mdev, &proto_cap, MLX5_PTYS_EN);
 615         if (err)
 616                 return err;
 617
 618         for (i = 0; i < MLX5E_LINK_MODES_NUMBER; ++i)
 619                 if (proto_cap & MLX5E_PROT_MASK(i))
 620                         max_speed = max(max_speed, ptys2ethtool_table[i].speed);
 621
 622         *speed = max_speed;
 623         return 0;
 624 }
 625
 626 static void get_speed_duplex(struct net_device *netdev,
 627                              u32 eth_proto_oper,
 628                              struct ethtool_link_ksettings *link_ksettings)
 629 {
 630         int i;
 631         u32 speed = SPEED_UNKNOWN;
 632         u8 duplex = DUPLEX_UNKNOWN;
 633
 634         if (!netif_carrier_ok(netdev))
 635                 goto out;
 636
 637         for (i = 0; i < MLX5E_LINK_MODES_NUMBER; ++i) {
 638                 if (eth_proto_oper & MLX5E_PROT_MASK(i)) {
 639                         speed = ptys2ethtool_table[i].speed;
 640                         duplex = DUPLEX_FULL;
 641                         break;
 642                 }
 643         }
 644 out:
 645         link_ksettings->base.speed = speed;
 646         link_ksettings->base.duplex = duplex;
 647 }
 648
 649 static void get_supported(u32 eth_proto_cap,
 650                           struct ethtool_link_ksettings *link_ksettings)
 651 {
 652         unsigned long *supported = link_ksettings->link_modes.supported;
 653
 654         ptys2ethtool_supported_link(supported, eth_proto_cap);
 655         ethtool_link_ksettings_add_link_mode(link_ksettings, supported, Pause);
 656 }
 657
 658 static void get_advertising(u32 eth_proto_cap, u8 tx_pause,
 659                             u8 rx_pause,
 660                             struct ethtool_link_ksettings *link_ksettings)
 661 {
 662         unsigned long *advertising = link_ksettings->link_modes.advertising;
 663
 664         ptys2ethtool_adver_link(advertising, eth_proto_cap);
 665         if (rx_pause)
 666                 ethtool_link_ksettings_add_link_mode(link_ksettings, advertising, Pause);
 667         if (tx_pause ^ rx_pause)
 668                 ethtool_link_ksettings_add_link_mode(link_ksettings, advertising, Asym_Pause);
 669 }
 670
 671 static int ptys2connector_type[MLX5E_CONNECTOR_TYPE_NUMBER] = {
 672                 [MLX5E_PORT_UNKNOWN]            = PORT_OTHER,
 673                 [MLX5E_PORT_NONE]               = PORT_NONE,
 674                 [MLX5E_PORT_TP]                 = PORT_TP,
 675                 [MLX5E_PORT_AUI]                = PORT_AUI,
 676                 [MLX5E_PORT_BNC]                = PORT_BNC,
 677                 [MLX5E_PORT_MII]                = PORT_MII,
 678                 [MLX5E_PORT_FIBRE]              = PORT_FIBRE,
 679                 [MLX5E_PORT_DA]                 = PORT_DA,
 680                 [MLX5E_PORT_OTHER]              = PORT_OTHER,
 681         };
 682
 683 static u8 get_connector_port(u32 eth_proto, u8 connector_type)
 684 {
 685         if (connector_type && connector_type < MLX5E_CONNECTOR_TYPE_NUMBER)
 686                 return ptys2connector_type[connector_type];
 687
 688         if (eth_proto &
 689             (MLX5E_PROT_MASK(MLX5E_10GBASE_SR)   |
 690              MLX5E_PROT_MASK(MLX5E_40GBASE_SR4)  |
 691              MLX5E_PROT_MASK(MLX5E_100GBASE_SR4) |
 692              MLX5E_PROT_MASK(MLX5E_1000BASE_CX_SGMII))) {
 693                 return PORT_FIBRE;
 694         }
 695
 696         if (eth_proto &
 697             (MLX5E_PROT_MASK(MLX5E_40GBASE_CR4) |
 698              MLX5E_PROT_MASK(MLX5E_10GBASE_CR)  |
 699              MLX5E_PROT_MASK(MLX5E_100GBASE_CR4))) {
 700                 return PORT_DA;
 701         }
 702
 703         if (eth_proto &
 704             (MLX5E_PROT_MASK(MLX5E_10GBASE_KX4) |
 705              MLX5E_PROT_MASK(MLX5E_10GBASE_KR)  |
 706              MLX5E_PROT_MASK(MLX5E_40GBASE_KR4) |
 707              MLX5E_PROT_MASK(MLX5E_100GBASE_KR4))) {
 708                 return PORT_NONE;
 709         }
 710
 711         return PORT_OTHER;
 712 }
 713
 714 static void get_lp_advertising(u32 eth_proto_lp,
 715                                struct ethtool_link_ksettings *link_ksettings)
 716 {
 717         unsigned long *lp_advertising = link_ksettings->link_modes.lp_advertising;
 718
 719         ptys2ethtool_adver_link(lp_advertising, eth_proto_lp);
 720 }
 721
 722 static int mlx5e_get_link_ksettings(struct net_device *netdev,
 723                                     struct ethtool_link_ksettings *link_ksettings)
 724 {
 725         struct mlx5e_priv *priv    = netdev_priv(netdev);
 726         struct mlx5_core_dev *mdev = priv->mdev;
 727         u32 out[MLX5_ST_SZ_DW(ptys_reg)] = {0};
 728         u32 rx_pause = 0;
 729         u32 tx_pause = 0;
 730         u32 eth_proto_cap;
 731         u32 eth_proto_admin;
 732         u32 eth_proto_lp;
 733         u32 eth_proto_oper;
 734         u8 an_disable_admin;
 735         u8 an_status;
 736         u8 connector_type;
 737         int err;
 738
 739         err = mlx5_query_port_ptys(mdev, out, sizeof(out), MLX5_PTYS_EN, 1);
 740         if (err) {
 741                 netdev_err(netdev, "%s: query port ptys failed: %d\n",
 742                            __func__, err);
 743                 goto err_query_ptys;
 744         }
 745
 746         eth_proto_cap    = MLX5_GET(ptys_reg, out, eth_proto_capability);
 747         eth_proto_admin  = MLX5_GET(ptys_reg, out, eth_proto_admin);
 748         eth_proto_oper   = MLX5_GET(ptys_reg, out, eth_proto_oper);
 749         eth_proto_lp     = MLX5_GET(ptys_reg, out, eth_proto_lp_advertise);
 750         an_disable_admin = MLX5_GET(ptys_reg, out, an_disable_admin);
 751         an_status        = MLX5_GET(ptys_reg, out, an_status);
 752         connector_type   = MLX5_GET(ptys_reg, out, connector_type);
 753
 754         mlx5_query_port_pause(mdev, &rx_pause, &tx_pause);
 755
 756         ethtool_link_ksettings_zero_link_mode(link_ksettings, supported);
 757         ethtool_link_ksettings_zero_link_mode(link_ksettings, advertising);
 758
 759         get_supported(eth_proto_cap, link_ksettings);
 760         get_advertising(eth_proto_admin, tx_pause, rx_pause, link_ksettings);
 761         get_speed_duplex(netdev, eth_proto_oper, link_ksettings);
 762
 763         eth_proto_oper = eth_proto_oper ? eth_proto_oper : eth_proto_cap;
 764
 765         link_ksettings->base.port = get_connector_port(eth_proto_oper,
 766                                                        connector_type);
 767         ptys2ethtool_supported_advertised_port(link_ksettings, eth_proto_admin,
 768                                                connector_type);
 769         get_lp_advertising(eth_proto_lp, link_ksettings);
 770
 771         if (an_status == MLX5_AN_COMPLETE)
 772                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 773                                                      lp_advertising, Autoneg);
 774
 775         link_ksettings->base.autoneg = an_disable_admin ? AUTONEG_DISABLE :
 776                                                           AUTONEG_ENABLE;
 777         ethtool_link_ksettings_add_link_mode(link_ksettings, supported,
 778                                              Autoneg);
 779         if (!an_disable_admin)
 780                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 781                                                      advertising, Autoneg);
 782
 783 err_query_ptys:
 784         return err;
 785 }
 786
 787 static u32 mlx5e_ethtool2ptys_adver_link(const unsigned long *link_modes)
 788 {
 789         u32 i, ptys_modes = 0;
 790
 791         for (i = 0; i < MLX5E_LINK_MODES_NUMBER; ++i) {
 792                 if (bitmap_intersects(ptys2ethtool_table[i].advertised,
 793                                       link_modes,
 794                                       __ETHTOOL_LINK_MODE_MASK_NBITS))
 795                         ptys_modes |= MLX5E_PROT_MASK(i);
 796         }
 797
 798         return ptys_modes;
 799 }
 800
 801 static u32 mlx5e_ethtool2ptys_speed_link(u32 speed)
 802 {
 803         u32 i, speed_links = 0;
 804
 805         for (i = 0; i < MLX5E_LINK_MODES_NUMBER; ++i) {
 806                 if (ptys2ethtool_table[i].speed == speed)
 807                         speed_links |= MLX5E_PROT_MASK(i);
 808         }
 809
 810         return speed_links;
 811 }
 812
 813 static int mlx5e_set_link_ksettings(struct net_device *netdev,
 814                                     const struct ethtool_link_ksettings *link_ksettings)
 815 {
 816         struct mlx5e_priv *priv    = netdev_priv(netdev);
 817         struct mlx5_core_dev *mdev = priv->mdev;
 818         u32 eth_proto_cap, eth_proto_admin;
 819         bool an_changes = false;
 820         u8 an_disable_admin;
 821         u8 an_disable_cap;
 822         bool an_disable;
 823         u32 link_modes;
 824         u8 an_status;
 825         u32 speed;
 826         int err;
 827
 828         speed = link_ksettings->base.speed;
 829
 830         link_modes = link_ksettings->base.autoneg == AUTONEG_ENABLE ?
 831                 mlx5e_ethtool2ptys_adver_link(link_ksettings->link_modes.advertising) :
 832                 mlx5e_ethtool2ptys_speed_link(speed);
 833
 834         err = mlx5_query_port_proto_cap(mdev, &eth_proto_cap, MLX5_PTYS_EN);
 835         if (err) {
 836                 netdev_err(netdev, "%s: query port eth proto cap failed: %d\n",
 837                            __func__, err);
 838                 goto out;
 839         }
 840
 841         link_modes = link_modes & eth_proto_cap;
 842         if (!link_modes) {
 843                 netdev_err(netdev, "%s: Not supported link mode(s) requested",
 844                            __func__);
 845                 err = -EINVAL;
 846                 goto out;
 847         }
 848
 849         err = mlx5_query_port_proto_admin(mdev, &eth_proto_admin, MLX5_PTYS_EN);
 850         if (err) {
 851                 netdev_err(netdev, "%s: query port eth proto admin failed: %d\n",
 852                            __func__, err);
 853                 goto out;
 854         }
 855
 856         mlx5_query_port_autoneg(mdev, MLX5_PTYS_EN, &an_status,
 857                                 &an_disable_cap, &an_disable_admin);
 858
 859         an_disable = link_ksettings->base.autoneg == AUTONEG_DISABLE;
 860         an_changes = ((!an_disable && an_disable_admin) ||
 861                       (an_disable && !an_disable_admin));
 862
 863         if (!an_changes && link_modes == eth_proto_admin)
 864                 goto out;
 865
 866         mlx5_set_port_ptys(mdev, an_disable, link_modes, MLX5_PTYS_EN);
 867         mlx5_toggle_port_link(mdev);
 868
 869 out:
 870         return err;
 871 }
 872
 873 static u32 mlx5e_get_rxfh_key_size(struct net_device *netdev)
 874 {
 875         struct mlx5e_priv *priv = netdev_priv(netdev);
 876
 877         return sizeof(priv->channels.params.toeplitz_hash_key);
 878 }
 879
 880 static u32 mlx5e_get_rxfh_indir_size(struct net_device *netdev)
 881 {
 882         return MLX5E_INDIR_RQT_SIZE;
 883 }
 884
 885 static int mlx5e_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
 886                           u8 *hfunc)
 887 {
 888         struct mlx5e_priv *priv = netdev_priv(netdev);
 889
 890         if (indir)
 891                 memcpy(indir, priv->channels.params.indirection_rqt,
 892                        sizeof(priv->channels.params.indirection_rqt));
 893
 894         if (key)
 895                 memcpy(key, priv->channels.params.toeplitz_hash_key,
 896                        sizeof(priv->channels.params.toeplitz_hash_key));
 897
 898         if (hfunc)
 899                 *hfunc = priv->channels.params.rss_hfunc;
 900
 901         return 0;
 902 }
 903
 904 static void mlx5e_modify_tirs_hash(struct mlx5e_priv *priv, void *in, int inlen)
 905 {
 906         void *tirc = MLX5_ADDR_OF(modify_tir_in, in, ctx);
 907         struct mlx5_core_dev *mdev = priv->mdev;
 908         int ctxlen = MLX5_ST_SZ_BYTES(tirc);
 909         int tt;
 910
 911         MLX5_SET(modify_tir_in, in, bitmask.hash, 1);
 912
 913         for (tt = 0; tt < MLX5E_NUM_INDIR_TIRS; tt++) {
 914                 memset(tirc, 0, ctxlen);
 915                 mlx5e_build_indir_tir_ctx_hash(&priv->channels.params, tt, tirc, false);
 916                 mlx5_core_modify_tir(mdev, priv->indir_tir[tt].tirn, in, inlen);
 917         }
 918
 919         if (!mlx5e_tunnel_inner_ft_supported(priv->mdev))
 920                 return;
 921
 922         for (tt = 0; tt < MLX5E_NUM_INDIR_TIRS; tt++) {
 923                 memset(tirc, 0, ctxlen);
 924                 mlx5e_build_indir_tir_ctx_hash(&priv->channels.params, tt, tirc, true);
 925                 mlx5_core_modify_tir(mdev, priv->inner_indir_tir[tt].tirn, in, inlen);
 926         }
 927 }
 928
 929 static int mlx5e_set_rxfh(struct net_device *dev, const u32 *indir,
 930                           const u8 *key, const u8 hfunc)
 931 {
 932         struct mlx5e_priv *priv = netdev_priv(dev);
 933         int inlen = MLX5_ST_SZ_BYTES(modify_tir_in);
 934         bool hash_changed = false;
 935         void *in;
 936
 937         if ((hfunc != ETH_RSS_HASH_NO_CHANGE) &&
 938             (hfunc != ETH_RSS_HASH_XOR) &&
 939             (hfunc != ETH_RSS_HASH_TOP))
 940                 return -EINVAL;
 941
 942         in = kvzalloc(inlen, GFP_KERNEL);
 943         if (!in)
 944                 return -ENOMEM;
 945
 946         mutex_lock(&priv->state_lock);
 947
 948         if (hfunc != ETH_RSS_HASH_NO_CHANGE &&
 949             hfunc != priv->channels.params.rss_hfunc) {
 950                 priv->channels.params.rss_hfunc = hfunc;
 951                 hash_changed = true;
 952         }
 953
 954         if (indir) {
 955                 memcpy(priv->channels.params.indirection_rqt, indir,
 956                        sizeof(priv->channels.params.indirection_rqt));
 957
 958                 if (test_bit(MLX5E_STATE_OPENED, &priv->state)) {
 959                         u32 rqtn = priv->indir_rqt.rqtn;
 960                         struct mlx5e_redirect_rqt_param rrp = {
 961                                 .is_rss = true,
 962                                 {
 963                                         .rss = {
 964                                                 .hfunc = priv->channels.params.rss_hfunc,
 965                                                 .channels  = &priv->channels,
 966                                         },
 967                                 },
 968                         };
 969
 970                         mlx5e_redirect_rqt(priv, rqtn, MLX5E_INDIR_RQT_SIZE, rrp);
 971                 }
 972         }
 973
 974         if (key) {
 975                 memcpy(priv->channels.params.toeplitz_hash_key, key,
 976                        sizeof(priv->channels.params.toeplitz_hash_key));
 977                 hash_changed = hash_changed ||
 978                                priv->channels.params.rss_hfunc == ETH_RSS_HASH_TOP;
 979         }
 980
 981         if (hash_changed)
 982                 mlx5e_modify_tirs_hash(priv, in, inlen);
 983
 984         mutex_unlock(&priv->state_lock);
 985
 986         kvfree(in);
 987
 988         return 0;
 989 }
 990
 991 static int mlx5e_get_rxnfc(struct net_device *netdev,
 992                            struct ethtool_rxnfc *info, u32 *rule_locs)
 993 {
 994         struct mlx5e_priv *priv = netdev_priv(netdev);
 995         int err = 0;
 996
 997         switch (info->cmd) {
 998         case ETHTOOL_GRXRINGS:
 999                 info->data = priv->channels.params.num_channels;
1000                 break;
1001         case ETHTOOL_GRXCLSRLCNT:
1002                 info->rule_cnt = priv->fs.ethtool.tot_num_rules;
1003                 break;
1004         case ETHTOOL_GRXCLSRULE:
1005                 err = mlx5e_ethtool_get_flow(priv, info, info->fs.location);
1006                 break;
1007         case ETHTOOL_GRXCLSRLALL:
1008                 err = mlx5e_ethtool_get_all_flows(priv, info, rule_locs);
1009                 break;
1010         default:
1011                 err = -EOPNOTSUPP;
1012                 break;
1013         }
1014
1015         return err;
1016 }
1017
1018 #define MLX5E_PFC_PREVEN_AUTO_TOUT_MSEC         100
1019 #define MLX5E_PFC_PREVEN_TOUT_MAX_MSEC          8000
1020 #define MLX5E_PFC_PREVEN_MINOR_PRECENT          85
1021 #define MLX5E_PFC_PREVEN_TOUT_MIN_MSEC          80
1022 #define MLX5E_DEVICE_STALL_MINOR_WATERMARK(critical_tout) \
1023         max_t(u16, MLX5E_PFC_PREVEN_TOUT_MIN_MSEC, \
1024               (critical_tout * MLX5E_PFC_PREVEN_MINOR_PRECENT) / 100)
1025
1026 static int mlx5e_get_pfc_prevention_tout(struct net_device *netdev,
1027                                          u16 *pfc_prevention_tout)
1028 {
1029         struct mlx5e_priv *priv    = netdev_priv(netdev);
1030         struct mlx5_core_dev *mdev = priv->mdev;
1031
1032         if (!MLX5_CAP_PCAM_FEATURE((priv)->mdev, pfcc_mask) ||
1033             !MLX5_CAP_DEBUG((priv)->mdev, stall_detect))
1034                 return -EOPNOTSUPP;
1035
1036         return mlx5_query_port_stall_watermark(mdev, pfc_prevention_tout, NULL);
1037 }
1038
1039 static int mlx5e_set_pfc_prevention_tout(struct net_device *netdev,
1040                                          u16 pfc_preven)
1041 {
1042         struct mlx5e_priv *priv = netdev_priv(netdev);
1043         struct mlx5_core_dev *mdev = priv->mdev;
1044         u16 critical_tout;
1045         u16 minor;
1046
1047         if (!MLX5_CAP_PCAM_FEATURE((priv)->mdev, pfcc_mask) ||
1048             !MLX5_CAP_DEBUG((priv)->mdev, stall_detect))
1049                 return -EOPNOTSUPP;
1050
1051         critical_tout = (pfc_preven == PFC_STORM_PREVENTION_AUTO) ?
1052                         MLX5E_PFC_PREVEN_AUTO_TOUT_MSEC :
1053                         pfc_preven;
1054
1055         if (critical_tout != PFC_STORM_PREVENTION_DISABLE &&
1056             (critical_tout > MLX5E_PFC_PREVEN_TOUT_MAX_MSEC ||
1057              critical_tout < MLX5E_PFC_PREVEN_TOUT_MIN_MSEC)) {
1058                 netdev_info(netdev, "%s: pfc prevention tout not in range (%d-%d)\n",
1059                             __func__, MLX5E_PFC_PREVEN_TOUT_MIN_MSEC,
1060                             MLX5E_PFC_PREVEN_TOUT_MAX_MSEC);
1061                 return -EINVAL;
1062         }
1063
1064         minor = MLX5E_DEVICE_STALL_MINOR_WATERMARK(critical_tout);
1065         return mlx5_set_port_stall_watermark(mdev, critical_tout,
1066                                              minor);
1067 }
1068
1069 static int mlx5e_get_tunable(struct net_device *dev,
1070                              const struct ethtool_tunable *tuna,
1071                              void *data)
1072 {
1073         int err;
1074
1075         switch (tuna->id) {
1076         case ETHTOOL_PFC_PREVENTION_TOUT:
1077                 err = mlx5e_get_pfc_prevention_tout(dev, data);
1078                 break;
1079         default:
1080                 err = -EINVAL;
1081                 break;
1082         }
1083
1084         return err;
1085 }
1086
1087 static int mlx5e_set_tunable(struct net_device *dev,
1088                              const struct ethtool_tunable *tuna,
1089                              const void *data)
1090 {
1091         struct mlx5e_priv *priv = netdev_priv(dev);
1092         int err;
1093
1094         mutex_lock(&priv->state_lock);
1095
1096         switch (tuna->id) {
1097         case ETHTOOL_PFC_PREVENTION_TOUT:
1098                 err = mlx5e_set_pfc_prevention_tout(dev, *(u16 *)data);
1099                 break;
1100         default:
1101                 err = -EINVAL;
1102                 break;
1103         }
1104
1105         mutex_unlock(&priv->state_lock);
1106         return err;
1107 }
1108
1109 static void mlx5e_get_pauseparam(struct net_device *netdev,
1110                                  struct ethtool_pauseparam *pauseparam)
1111 {
1112         struct mlx5e_priv *priv    = netdev_priv(netdev);
1113         struct mlx5_core_dev *mdev = priv->mdev;
1114         int err;
1115
1116         err = mlx5_query_port_pause(mdev, &pauseparam->rx_pause,
1117                                     &pauseparam->tx_pause);
1118         if (err) {
1119                 netdev_err(netdev, "%s: mlx5_query_port_pause failed:0x%x\n",
1120                            __func__, err);
1121         }
1122 }
1123
1124 static int mlx5e_set_pauseparam(struct net_device *netdev,
1125                                 struct ethtool_pauseparam *pauseparam)
1126 {
1127         struct mlx5e_priv *priv    = netdev_priv(netdev);
1128         struct mlx5_core_dev *mdev = priv->mdev;
1129         int err;
1130
1131         if (pauseparam->autoneg)
1132                 return -EINVAL;
1133
1134         err = mlx5_set_port_pause(mdev,
1135                                   pauseparam->rx_pause ? 1 : 0,
1136                                   pauseparam->tx_pause ? 1 : 0);
1137         if (err) {
1138                 netdev_err(netdev, "%s: mlx5_set_port_pause failed:0x%x\n",
1139                            __func__, err);
1140         }
1141
1142         return err;
1143 }
1144
1145 int mlx5e_ethtool_get_ts_info(struct mlx5e_priv *priv,
1146                               struct ethtool_ts_info *info)
1147 {
1148         struct mlx5_core_dev *mdev = priv->mdev;
1149         int ret;
1150
1151         ret = ethtool_op_get_ts_info(priv->netdev, info);
1152         if (ret)
1153                 return ret;
1154
1155         info->phc_index = mdev->clock.ptp ?
1156                           ptp_clock_index(mdev->clock.ptp) : -1;
1157
1158         if (!MLX5_CAP_GEN(priv->mdev, device_frequency_khz))
1159                 return 0;
1160
1161         info->so_timestamping |= SOF_TIMESTAMPING_TX_HARDWARE |
1162                                  SOF_TIMESTAMPING_RX_HARDWARE |
1163                                  SOF_TIMESTAMPING_RAW_HARDWARE;
1164
1165         info->tx_types = BIT(HWTSTAMP_TX_OFF) |
1166                          BIT(HWTSTAMP_TX_ON);
1167
1168         info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) |
1169                            BIT(HWTSTAMP_FILTER_ALL);
1170
1171         return 0;
1172 }
1173
1174 static int mlx5e_get_ts_info(struct net_device *dev,
1175                              struct ethtool_ts_info *info)
1176 {
1177         struct mlx5e_priv *priv = netdev_priv(dev);
1178
1179         return mlx5e_ethtool_get_ts_info(priv, info);
1180 }
1181
1182 static __u32 mlx5e_get_wol_supported(struct mlx5_core_dev *mdev)
1183 {
1184         __u32 ret = 0;
1185
1186         if (MLX5_CAP_GEN(mdev, wol_g))
1187                 ret |= WAKE_MAGIC;
1188
1189         if (MLX5_CAP_GEN(mdev, wol_s))
1190                 ret |= WAKE_MAGICSECURE;
1191
1192         if (MLX5_CAP_GEN(mdev, wol_a))
1193                 ret |= WAKE_ARP;
1194
1195         if (MLX5_CAP_GEN(mdev, wol_b))
1196                 ret |= WAKE_BCAST;
1197
1198         if (MLX5_CAP_GEN(mdev, wol_m))
1199                 ret |= WAKE_MCAST;
1200
1201         if (MLX5_CAP_GEN(mdev, wol_u))
1202                 ret |= WAKE_UCAST;
1203
1204         if (MLX5_CAP_GEN(mdev, wol_p))
1205                 ret |= WAKE_PHY;
1206
1207         return ret;
1208 }
1209
1210 static __u32 mlx5e_refomrat_wol_mode_mlx5_to_linux(u8 mode)
1211 {
1212         __u32 ret = 0;
1213
1214         if (mode & MLX5_WOL_MAGIC)
1215                 ret |= WAKE_MAGIC;
1216
1217         if (mode & MLX5_WOL_SECURED_MAGIC)
1218                 ret |= WAKE_MAGICSECURE;
1219
1220         if (mode & MLX5_WOL_ARP)
1221                 ret |= WAKE_ARP;
1222
1223         if (mode & MLX5_WOL_BROADCAST)
1224                 ret |= WAKE_BCAST;
1225
1226         if (mode & MLX5_WOL_MULTICAST)
1227                 ret |= WAKE_MCAST;
1228
1229         if (mode & MLX5_WOL_UNICAST)
1230                 ret |= WAKE_UCAST;
1231
1232         if (mode & MLX5_WOL_PHY_ACTIVITY)
1233                 ret |= WAKE_PHY;
1234
1235         return ret;
1236 }
1237
1238 static u8 mlx5e_refomrat_wol_mode_linux_to_mlx5(__u32 mode)
1239 {
1240         u8 ret = 0;
1241
1242         if (mode & WAKE_MAGIC)
1243                 ret |= MLX5_WOL_MAGIC;
1244
1245         if (mode & WAKE_MAGICSECURE)
1246                 ret |= MLX5_WOL_SECURED_MAGIC;
1247
1248         if (mode & WAKE_ARP)
1249                 ret |= MLX5_WOL_ARP;
1250
1251         if (mode & WAKE_BCAST)
1252                 ret |= MLX5_WOL_BROADCAST;
1253
1254         if (mode & WAKE_MCAST)
1255                 ret |= MLX5_WOL_MULTICAST;
1256
1257         if (mode & WAKE_UCAST)
1258                 ret |= MLX5_WOL_UNICAST;
1259
1260         if (mode & WAKE_PHY)
1261                 ret |= MLX5_WOL_PHY_ACTIVITY;
1262
1263         return ret;
1264 }
1265
1266 static void mlx5e_get_wol(struct net_device *netdev,
1267                           struct ethtool_wolinfo *wol)
1268 {
1269         struct mlx5e_priv *priv = netdev_priv(netdev);
1270         struct mlx5_core_dev *mdev = priv->mdev;
1271         u8 mlx5_wol_mode;
1272         int err;
1273
1274         memset(wol, 0, sizeof(*wol));
1275
1276         wol->supported = mlx5e_get_wol_supported(mdev);
1277         if (!wol->supported)
1278                 return;
1279
1280         err = mlx5_query_port_wol(mdev, &mlx5_wol_mode);
1281         if (err)
1282                 return;
1283
1284         wol->wolopts = mlx5e_refomrat_wol_mode_mlx5_to_linux(mlx5_wol_mode);
1285 }
1286
1287 static int mlx5e_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1288 {
1289         struct mlx5e_priv *priv = netdev_priv(netdev);
1290         struct mlx5_core_dev *mdev = priv->mdev;
1291         __u32 wol_supported = mlx5e_get_wol_supported(mdev);
1292         u32 mlx5_wol_mode;
1293
1294         if (!wol_supported)
1295                 return -EOPNOTSUPP;
1296
1297         if (wol->wolopts & ~wol_supported)
1298                 return -EINVAL;
1299
1300         mlx5_wol_mode = mlx5e_refomrat_wol_mode_linux_to_mlx5(wol->wolopts);
1301
1302         return mlx5_set_port_wol(mdev, mlx5_wol_mode);
1303 }
1304
1305 static u32 mlx5e_get_msglevel(struct net_device *dev)
1306 {
1307         return ((struct mlx5e_priv *)netdev_priv(dev))->msglevel;
1308 }
1309
1310 static void mlx5e_set_msglevel(struct net_device *dev, u32 val)
1311 {
1312         ((struct mlx5e_priv *)netdev_priv(dev))->msglevel = val;
1313 }
1314
1315 static int mlx5e_set_phys_id(struct net_device *dev,
1316                              enum ethtool_phys_id_state state)
1317 {
1318         struct mlx5e_priv *priv = netdev_priv(dev);
1319         struct mlx5_core_dev *mdev = priv->mdev;
1320         u16 beacon_duration;
1321
1322         if (!MLX5_CAP_GEN(mdev, beacon_led))
1323                 return -EOPNOTSUPP;
1324
1325         switch (state) {
1326         case ETHTOOL_ID_ACTIVE:
1327                 beacon_duration = MLX5_BEACON_DURATION_INF;
1328                 break;
1329         case ETHTOOL_ID_INACTIVE:
1330                 beacon_duration = MLX5_BEACON_DURATION_OFF;
1331                 break;
1332         default:
1333                 return -EOPNOTSUPP;
1334         }
1335
1336         return mlx5_set_port_beacon(mdev, beacon_duration);
1337 }
1338
1339 static int mlx5e_get_module_info(struct net_device *netdev,
1340                                  struct ethtool_modinfo *modinfo)
1341 {
1342         struct mlx5e_priv *priv = netdev_priv(netdev);
1343         struct mlx5_core_dev *dev = priv->mdev;
1344         int size_read = 0;
1345         u8 data[4];
1346
1347         size_read = mlx5_query_module_eeprom(dev, 0, 2, data);
1348         if (size_read < 2)
1349                 return -EIO;
1350
1351         /* data[0] = identifier byte */
1352         switch (data[0]) {
1353         case MLX5_MODULE_ID_QSFP:
1354                 modinfo->type       = ETH_MODULE_SFF_8436;
1355                 modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN;
1356                 break;
1357         case MLX5_MODULE_ID_QSFP_PLUS:
1358         case MLX5_MODULE_ID_QSFP28:
1359                 /* data[1] = revision id */
1360                 if (data[0] == MLX5_MODULE_ID_QSFP28 || data[1] >= 0x3) {
1361                         modinfo->type       = ETH_MODULE_SFF_8636;
1362                         modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN;
1363                 } else {
1364                         modinfo->type       = ETH_MODULE_SFF_8436;
1365                         modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN;
1366                 }
1367                 break;
1368         case MLX5_MODULE_ID_SFP:
1369                 modinfo->type       = ETH_MODULE_SFF_8472;
1370                 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
1371                 break;
1372         default:
1373                 netdev_err(priv->netdev, "%s: cable type not recognized:0x%x\n",
1374                            __func__, data[0]);
1375                 return -EINVAL;
1376         }
1377
1378         return 0;
1379 }
1380
1381 static int mlx5e_get_module_eeprom(struct net_device *netdev,
1382                                    struct ethtool_eeprom *ee,
1383                                    u8 *data)
1384 {
1385         struct mlx5e_priv *priv = netdev_priv(netdev);
1386         struct mlx5_core_dev *mdev = priv->mdev;
1387         int offset = ee->offset;
1388         int size_read;
1389         int i = 0;
1390
1391         if (!ee->len)
1392                 return -EINVAL;
1393
1394         memset(data, 0, ee->len);
1395
1396         while (i < ee->len) {
1397                 size_read = mlx5_query_module_eeprom(mdev, offset, ee->len - i,
1398                                                      data + i);
1399
1400                 if (!size_read)
1401                         /* Done reading */
1402                         return 0;
1403
1404                 if (size_read < 0) {
1405                         netdev_err(priv->netdev, "%s: mlx5_query_eeprom failed:0x%x\n",
1406                                    __func__, size_read);
1407                         return 0;
1408                 }
1409
1410                 i += size_read;
1411                 offset += size_read;
1412         }
1413
1414         return 0;
1415 }
1416
1417 typedef int (*mlx5e_pflag_handler)(struct net_device *netdev, bool enable);
1418
1419 static int set_pflag_cqe_based_moder(struct net_device *netdev, bool enable,
1420                                      bool is_rx_cq)
1421 {
1422         struct mlx5e_priv *priv = netdev_priv(netdev);
1423         struct mlx5_core_dev *mdev = priv->mdev;
1424         struct mlx5e_channels new_channels = {};
1425         bool mode_changed;
1426         u8 cq_period_mode, current_cq_period_mode;
1427         int err = 0;
1428
1429         cq_period_mode = enable ?
1430                 MLX5_CQ_PERIOD_MODE_START_FROM_CQE :
1431                 MLX5_CQ_PERIOD_MODE_START_FROM_EQE;
1432         current_cq_period_mode = is_rx_cq ?
1433                 priv->channels.params.rx_cq_moderation.cq_period_mode :
1434                 priv->channels.params.tx_cq_moderation.cq_period_mode;
1435         mode_changed = cq_period_mode != current_cq_period_mode;
1436
1437         if (cq_period_mode == MLX5_CQ_PERIOD_MODE_START_FROM_CQE &&
1438             !MLX5_CAP_GEN(mdev, cq_period_start_from_cqe))
1439                 return -EOPNOTSUPP;
1440
1441         if (!mode_changed)
1442                 return 0;
1443
1444         new_channels.params = priv->channels.params;
1445         if (is_rx_cq)
1446                 mlx5e_set_rx_cq_mode_params(&new_channels.params, cq_period_mode);
1447         else
1448                 mlx5e_set_tx_cq_mode_params(&new_channels.params, cq_period_mode);
1449
1450         if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
1451                 priv->channels.params = new_channels.params;
1452                 return 0;
1453         }
1454
1455         err = mlx5e_open_channels(priv, &new_channels);
1456         if (err)
1457                 return err;
1458
1459         mlx5e_switch_priv_channels(priv, &new_channels, NULL);
1460         return 0;
1461 }
1462
1463 static int set_pflag_tx_cqe_based_moder(struct net_device *netdev, bool enable)
1464 {
1465         return set_pflag_cqe_based_moder(netdev, enable, false);
1466 }
1467
1468 static int set_pflag_rx_cqe_based_moder(struct net_device *netdev, bool enable)
1469 {
1470         return set_pflag_cqe_based_moder(netdev, enable, true);
1471 }
1472
1473 int mlx5e_modify_rx_cqe_compression_locked(struct mlx5e_priv *priv, bool new_val)
1474 {
1475         bool curr_val = MLX5E_GET_PFLAG(&priv->channels.params, MLX5E_PFLAG_RX_CQE_COMPRESS);
1476         struct mlx5e_channels new_channels = {};
1477         int err = 0;
1478
1479         if (!MLX5_CAP_GEN(priv->mdev, cqe_compression))
1480                 return new_val ? -EOPNOTSUPP : 0;
1481
1482         if (curr_val == new_val)
1483                 return 0;
1484
1485         new_channels.params = priv->channels.params;
1486         MLX5E_SET_PFLAG(&new_channels.params, MLX5E_PFLAG_RX_CQE_COMPRESS, new_val);
1487
1488         if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
1489                 priv->channels.params = new_channels.params;
1490                 return 0;
1491         }
1492
1493         err = mlx5e_open_channels(priv, &new_channels);
1494         if (err)
1495                 return err;
1496
1497         mlx5e_switch_priv_channels(priv, &new_channels, NULL);
1498         mlx5e_dbg(DRV, priv, "MLX5E: RxCqeCmprss was turned %s\n",
1499                   MLX5E_GET_PFLAG(&priv->channels.params,
1500                                   MLX5E_PFLAG_RX_CQE_COMPRESS) ? "ON" : "OFF");
1501
1502         return 0;
1503 }
1504
1505 static int set_pflag_rx_cqe_compress(struct net_device *netdev,
1506                                      bool enable)
1507 {
1508         struct mlx5e_priv *priv = netdev_priv(netdev);
1509         struct mlx5_core_dev *mdev = priv->mdev;
1510
1511         if (!MLX5_CAP_GEN(mdev, cqe_compression))
1512                 return -EOPNOTSUPP;
1513
1514         if (enable && priv->tstamp.rx_filter != HWTSTAMP_FILTER_NONE) {
1515                 netdev_err(netdev, "Can't enable cqe compression while timestamping is enabled.\n");
1516                 return -EINVAL;
1517         }
1518
1519         mlx5e_modify_rx_cqe_compression_locked(priv, enable);
1520         priv->channels.params.rx_cqe_compress_def = enable;
1521
1522         return 0;
1523 }
1524
1525 static int set_pflag_rx_striding_rq(struct net_device *netdev, bool enable)
1526 {
1527         struct mlx5e_priv *priv = netdev_priv(netdev);
1528         struct mlx5_core_dev *mdev = priv->mdev;
1529         struct mlx5e_channels new_channels = {};
1530         int err;
1531
1532         if (enable) {
1533                 if (!mlx5e_check_fragmented_striding_rq_cap(mdev))
1534                         return -EOPNOTSUPP;
1535                 if (!mlx5e_striding_rq_possible(mdev, &priv->channels.params))
1536                         return -EINVAL;
1537         }
1538
1539         new_channels.params = priv->channels.params;
1540
1541         MLX5E_SET_PFLAG(&new_channels.params, MLX5E_PFLAG_RX_STRIDING_RQ, enable);
1542         mlx5e_set_rq_type(mdev, &new_channels.params);
1543
1544         if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
1545                 priv->channels.params = new_channels.params;
1546                 return 0;
1547         }
1548
1549         err = mlx5e_open_channels(priv, &new_channels);
1550         if (err)
1551                 return err;
1552
1553         mlx5e_switch_priv_channels(priv, &new_channels, NULL);
1554         return 0;
1555 }
1556
1557 static int mlx5e_handle_pflag(struct net_device *netdev,
1558                               u32 wanted_flags,
1559                               enum mlx5e_priv_flag flag,
1560                               mlx5e_pflag_handler pflag_handler)
1561 {
1562         struct mlx5e_priv *priv = netdev_priv(netdev);
1563         bool enable = !!(wanted_flags & flag);
1564         u32 changes = wanted_flags ^ priv->channels.params.pflags;
1565         int err;
1566
1567         if (!(changes & flag))
1568                 return 0;
1569
1570         err = pflag_handler(netdev, enable);
1571         if (err) {
1572                 netdev_err(netdev, "%s private flag 0x%x failed err %d\n",
1573                            enable ? "Enable" : "Disable", flag, err);
1574                 return err;
1575         }
1576
1577         MLX5E_SET_PFLAG(&priv->channels.params, flag, enable);
1578         return 0;
1579 }
1580
1581 static int mlx5e_set_priv_flags(struct net_device *netdev, u32 pflags)
1582 {
1583         struct mlx5e_priv *priv = netdev_priv(netdev);
1584         int err;
1585
1586         mutex_lock(&priv->state_lock);
1587         err = mlx5e_handle_pflag(netdev, pflags,
1588                                  MLX5E_PFLAG_RX_CQE_BASED_MODER,
1589                                  set_pflag_rx_cqe_based_moder);
1590         if (err)
1591                 goto out;
1592
1593         err = mlx5e_handle_pflag(netdev, pflags,
1594                                  MLX5E_PFLAG_TX_CQE_BASED_MODER,
1595                                  set_pflag_tx_cqe_based_moder);
1596         if (err)
1597                 goto out;
1598
1599         err = mlx5e_handle_pflag(netdev, pflags,
1600                                  MLX5E_PFLAG_RX_CQE_COMPRESS,
1601                                  set_pflag_rx_cqe_compress);
1602         if (err)
1603                 goto out;
1604
1605         err = mlx5e_handle_pflag(netdev, pflags,
1606                                  MLX5E_PFLAG_RX_STRIDING_RQ,
1607                                  set_pflag_rx_striding_rq);
1608
1609 out:
1610         mutex_unlock(&priv->state_lock);
1611         return err;
1612 }
1613
1614 static u32 mlx5e_get_priv_flags(struct net_device *netdev)
1615 {
1616         struct mlx5e_priv *priv = netdev_priv(netdev);
1617
1618         return priv->channels.params.pflags;
1619 }
1620
1621 static int mlx5e_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
1622 {
1623         int err = 0;
1624         struct mlx5e_priv *priv = netdev_priv(dev);
1625
1626         switch (cmd->cmd) {
1627         case ETHTOOL_SRXCLSRLINS:
1628                 err = mlx5e_ethtool_flow_replace(priv, &cmd->fs);
1629                 break;
1630         case ETHTOOL_SRXCLSRLDEL:
1631                 err = mlx5e_ethtool_flow_remove(priv, cmd->fs.location);
1632                 break;
1633         default:
1634                 err = -EOPNOTSUPP;
1635                 break;
1636         }
1637
1638         return err;
1639 }
1640
1641 int mlx5e_ethtool_flash_device(struct mlx5e_priv *priv,
1642                                struct ethtool_flash *flash)
1643 {
1644         struct mlx5_core_dev *mdev = priv->mdev;
1645         struct net_device *dev = priv->netdev;
1646         const struct firmware *fw;
1647         int err;
1648
1649         if (flash->region != ETHTOOL_FLASH_ALL_REGIONS)
1650                 return -EOPNOTSUPP;
1651
1652         err = request_firmware_direct(&fw, flash->data, &dev->dev);
1653         if (err)
1654                 return err;
1655
1656         dev_hold(dev);
1657         rtnl_unlock();
1658
1659         err = mlx5_firmware_flash(mdev, fw);
1660         release_firmware(fw);
1661
1662         rtnl_lock();
1663         dev_put(dev);
1664         return err;
1665 }
1666
1667 static int mlx5e_flash_device(struct net_device *dev,
1668                               struct ethtool_flash *flash)
1669 {
1670         struct mlx5e_priv *priv = netdev_priv(dev);
1671
1672         return mlx5e_ethtool_flash_device(priv, flash);
1673 }
1674
1675 const struct ethtool_ops mlx5e_ethtool_ops = {
1676         .get_drvinfo       = mlx5e_get_drvinfo,
1677         .get_link          = ethtool_op_get_link,
1678         .get_strings       = mlx5e_get_strings,
1679         .get_sset_count    = mlx5e_get_sset_count,
1680         .get_ethtool_stats = mlx5e_get_ethtool_stats,
1681         .get_ringparam     = mlx5e_get_ringparam,
1682         .set_ringparam     = mlx5e_set_ringparam,
1683         .get_channels      = mlx5e_get_channels,
1684         .set_channels      = mlx5e_set_channels,
1685         .get_coalesce      = mlx5e_get_coalesce,
1686         .set_coalesce      = mlx5e_set_coalesce,
1687         .get_link_ksettings  = mlx5e_get_link_ksettings,
1688         .set_link_ksettings  = mlx5e_set_link_ksettings,
1689         .get_rxfh_key_size   = mlx5e_get_rxfh_key_size,
1690         .get_rxfh_indir_size = mlx5e_get_rxfh_indir_size,
1691         .get_rxfh          = mlx5e_get_rxfh,
1692         .set_rxfh          = mlx5e_set_rxfh,
1693         .get_rxnfc         = mlx5e_get_rxnfc,
1694         .set_rxnfc         = mlx5e_set_rxnfc,
1695         .flash_device      = mlx5e_flash_device,
1696         .get_tunable       = mlx5e_get_tunable,
1697         .set_tunable       = mlx5e_set_tunable,
1698         .get_pauseparam    = mlx5e_get_pauseparam,
1699         .set_pauseparam    = mlx5e_set_pauseparam,
1700         .get_ts_info       = mlx5e_get_ts_info,
1701         .set_phys_id       = mlx5e_set_phys_id,
1702         .get_wol           = mlx5e_get_wol,
1703         .set_wol           = mlx5e_set_wol,
1704         .get_module_info   = mlx5e_get_module_info,
1705         .get_module_eeprom = mlx5e_get_module_eeprom,
1706         .get_priv_flags    = mlx5e_get_priv_flags,
1707         .set_priv_flags    = mlx5e_set_priv_flags,
1708         .self_test         = mlx5e_self_test,
1709         .get_msglevel      = mlx5e_get_msglevel,
1710         .set_msglevel      = mlx5e_set_msglevel,
1711
1712 };