kernel/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 static void mlx5e_get_drvinfo(struct net_device *dev,
  36                               struct ethtool_drvinfo *drvinfo)
  37 {
  38         struct mlx5e_priv *priv = netdev_priv(dev);
  39         struct mlx5_core_dev *mdev = priv->mdev;
  40
  41         strlcpy(drvinfo->driver, DRIVER_NAME, sizeof(drvinfo->driver));
  42         strlcpy(drvinfo->version, DRIVER_VERSION " (" DRIVER_RELDATE ")",
  43                 sizeof(drvinfo->version));
  44         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
  45                  "%d.%d.%d",
  46                  fw_rev_maj(mdev), fw_rev_min(mdev), fw_rev_sub(mdev));
  47         strlcpy(drvinfo->bus_info, pci_name(mdev->pdev),
  48                 sizeof(drvinfo->bus_info));
  49 }
  50
  51 static const struct {
  52         u32 supported;
  53         u32 advertised;
  54         u32 speed;
  55 } ptys2ethtool_table[MLX5E_LINK_MODES_NUMBER] = {
  56         [MLX5E_1000BASE_CX_SGMII] = {
  57                 .supported  = SUPPORTED_1000baseKX_Full,
  58                 .advertised = ADVERTISED_1000baseKX_Full,
  59                 .speed      = 1000,
  60         },
  61         [MLX5E_1000BASE_KX] = {
  62                 .supported  = SUPPORTED_1000baseKX_Full,
  63                 .advertised = ADVERTISED_1000baseKX_Full,
  64                 .speed      = 1000,
  65         },
  66         [MLX5E_10GBASE_CX4] = {
  67                 .supported  = SUPPORTED_10000baseKX4_Full,
  68                 .advertised = ADVERTISED_10000baseKX4_Full,
  69                 .speed      = 10000,
  70         },
  71         [MLX5E_10GBASE_KX4] = {
  72                 .supported  = SUPPORTED_10000baseKX4_Full,
  73                 .advertised = ADVERTISED_10000baseKX4_Full,
  74                 .speed      = 10000,
  75         },
  76         [MLX5E_10GBASE_KR] = {
  77                 .supported  = SUPPORTED_10000baseKR_Full,
  78                 .advertised = ADVERTISED_10000baseKR_Full,
  79                 .speed      = 10000,
  80         },
  81         [MLX5E_20GBASE_KR2] = {
  82                 .supported  = SUPPORTED_20000baseKR2_Full,
  83                 .advertised = ADVERTISED_20000baseKR2_Full,
  84                 .speed      = 20000,
  85         },
  86         [MLX5E_40GBASE_CR4] = {
  87                 .supported  = SUPPORTED_40000baseCR4_Full,
  88                 .advertised = ADVERTISED_40000baseCR4_Full,
  89                 .speed      = 40000,
  90         },
  91         [MLX5E_40GBASE_KR4] = {
  92                 .supported  = SUPPORTED_40000baseKR4_Full,
  93                 .advertised = ADVERTISED_40000baseKR4_Full,
  94                 .speed      = 40000,
  95         },
  96         [MLX5E_56GBASE_R4] = {
  97                 .supported  = SUPPORTED_56000baseKR4_Full,
  98                 .advertised = ADVERTISED_56000baseKR4_Full,
  99                 .speed      = 56000,
 100         },
 101         [MLX5E_10GBASE_CR] = {
 102                 .supported  = SUPPORTED_10000baseKR_Full,
 103                 .advertised = ADVERTISED_10000baseKR_Full,
 104                 .speed      = 10000,
 105         },
 106         [MLX5E_10GBASE_SR] = {
 107                 .supported  = SUPPORTED_10000baseKR_Full,
 108                 .advertised = ADVERTISED_10000baseKR_Full,
 109                 .speed      = 10000,
 110         },
 111         [MLX5E_10GBASE_ER] = {
 112                 .supported  = SUPPORTED_10000baseKR_Full,
 113                 .advertised = ADVERTISED_10000baseKR_Full,
 114                 .speed      = 10000,
 115         },
 116         [MLX5E_40GBASE_SR4] = {
 117                 .supported  = SUPPORTED_40000baseSR4_Full,
 118                 .advertised = ADVERTISED_40000baseSR4_Full,
 119                 .speed      = 40000,
 120         },
 121         [MLX5E_40GBASE_LR4] = {
 122                 .supported  = SUPPORTED_40000baseLR4_Full,
 123                 .advertised = ADVERTISED_40000baseLR4_Full,
 124                 .speed      = 40000,
 125         },
 126         [MLX5E_100GBASE_CR4] = {
 127                 .speed      = 100000,
 128         },
 129         [MLX5E_100GBASE_SR4] = {
 130                 .speed      = 100000,
 131         },
 132         [MLX5E_100GBASE_KR4] = {
 133                 .speed      = 100000,
 134         },
 135         [MLX5E_100GBASE_LR4] = {
 136                 .speed      = 100000,
 137         },
 138         [MLX5E_100BASE_TX]   = {
 139                 .speed      = 100,
 140         },
 141         [MLX5E_100BASE_T]    = {
 142                 .supported  = SUPPORTED_100baseT_Full,
 143                 .advertised = ADVERTISED_100baseT_Full,
 144                 .speed      = 100,
 145         },
 146         [MLX5E_10GBASE_T]    = {
 147                 .supported  = SUPPORTED_10000baseT_Full,
 148                 .advertised = ADVERTISED_10000baseT_Full,
 149                 .speed      = 1000,
 150         },
 151         [MLX5E_25GBASE_CR]   = {
 152                 .speed      = 25000,
 153         },
 154         [MLX5E_25GBASE_KR]   = {
 155                 .speed      = 25000,
 156         },
 157         [MLX5E_25GBASE_SR]   = {
 158                 .speed      = 25000,
 159         },
 160         [MLX5E_50GBASE_CR2]  = {
 161                 .speed      = 50000,
 162         },
 163         [MLX5E_50GBASE_KR2]  = {
 164                 .speed      = 50000,
 165         },
 166 };
 167
 168 static int mlx5e_get_sset_count(struct net_device *dev, int sset)
 169 {
 170         struct mlx5e_priv *priv = netdev_priv(dev);
 171
 172         switch (sset) {
 173         case ETH_SS_STATS:
 174                 return NUM_VPORT_COUNTERS + NUM_PPORT_COUNTERS +
 175                        priv->params.num_channels * NUM_RQ_STATS +
 176                        priv->params.num_channels * priv->params.num_tc *
 177                                                    NUM_SQ_STATS;
 178         /* fallthrough */
 179         default:
 180                 return -EOPNOTSUPP;
 181         }
 182 }
 183
 184 static void mlx5e_get_strings(struct net_device *dev,
 185                               uint32_t stringset, uint8_t *data)
 186 {
 187         int i, j, tc, idx = 0;
 188         struct mlx5e_priv *priv = netdev_priv(dev);
 189
 190         switch (stringset) {
 191         case ETH_SS_PRIV_FLAGS:
 192                 break;
 193
 194         case ETH_SS_TEST:
 195                 break;
 196
 197         case ETH_SS_STATS:
 198                 /* VPORT counters */
 199                 for (i = 0; i < NUM_VPORT_COUNTERS; i++)
 200                         strcpy(data + (idx++) * ETH_GSTRING_LEN,
 201                                vport_strings[i]);
 202
 203                 /* PPORT counters */
 204                 for (i = 0; i < NUM_PPORT_COUNTERS; i++)
 205                         strcpy(data + (idx++) * ETH_GSTRING_LEN,
 206                                pport_strings[i]);
 207
 208                 /* per channel counters */
 209                 for (i = 0; i < priv->params.num_channels; i++)
 210                         for (j = 0; j < NUM_RQ_STATS; j++)
 211                                 sprintf(data + (idx++) * ETH_GSTRING_LEN,
 212                                         "rx%d_%s", i, rq_stats_strings[j]);
 213
 214                 for (i = 0; i < priv->params.num_channels; i++)
 215                         for (tc = 0; tc < priv->params.num_tc; tc++)
 216                                 for (j = 0; j < NUM_SQ_STATS; j++)
 217                                         sprintf(data +
 218                                                 (idx++) * ETH_GSTRING_LEN,
 219                                                 "tx%d_%d_%s", i, tc,
 220                                                 sq_stats_strings[j]);
 221                 break;
 222         }
 223 }
 224
 225 static void mlx5e_get_ethtool_stats(struct net_device *dev,
 226                                     struct ethtool_stats *stats, u64 *data)
 227 {
 228         struct mlx5e_priv *priv = netdev_priv(dev);
 229         int i, j, tc, idx = 0;
 230
 231         if (!data)
 232                 return;
 233
 234         mutex_lock(&priv->state_lock);
 235         if (test_bit(MLX5E_STATE_OPENED, &priv->state))
 236                 mlx5e_update_stats(priv);
 237         mutex_unlock(&priv->state_lock);
 238
 239         for (i = 0; i < NUM_VPORT_COUNTERS; i++)
 240                 data[idx++] = ((u64 *)&priv->stats.vport)[i];
 241
 242         for (i = 0; i < NUM_PPORT_COUNTERS; i++)
 243                 data[idx++] = be64_to_cpu(((__be64 *)&priv->stats.pport)[i]);
 244
 245         /* per channel counters */
 246         for (i = 0; i < priv->params.num_channels; i++)
 247                 for (j = 0; j < NUM_RQ_STATS; j++)
 248                         data[idx++] = !test_bit(MLX5E_STATE_OPENED,
 249                                                 &priv->state) ? 0 :
 250                                        ((u64 *)&priv->channel[i]->rq.stats)[j];
 251
 252         for (i = 0; i < priv->params.num_channels; i++)
 253                 for (tc = 0; tc < priv->params.num_tc; tc++)
 254                         for (j = 0; j < NUM_SQ_STATS; j++)
 255                                 data[idx++] = !test_bit(MLX5E_STATE_OPENED,
 256                                                         &priv->state) ? 0 :
 257                                 ((u64 *)&priv->channel[i]->sq[tc].stats)[j];
 258 }
 259
 260 static void mlx5e_get_ringparam(struct net_device *dev,
 261                                 struct ethtool_ringparam *param)
 262 {
 263         struct mlx5e_priv *priv = netdev_priv(dev);
 264
 265         param->rx_max_pending = 1 << MLX5E_PARAMS_MAXIMUM_LOG_RQ_SIZE;
 266         param->tx_max_pending = 1 << MLX5E_PARAMS_MAXIMUM_LOG_SQ_SIZE;
 267         param->rx_pending     = 1 << priv->params.log_rq_size;
 268         param->tx_pending     = 1 << priv->params.log_sq_size;
 269 }
 270
 271 static int mlx5e_set_ringparam(struct net_device *dev,
 272                                struct ethtool_ringparam *param)
 273 {
 274         struct mlx5e_priv *priv = netdev_priv(dev);
 275         bool was_opened;
 276         u16 min_rx_wqes;
 277         u8 log_rq_size;
 278         u8 log_sq_size;
 279         int err = 0;
 280
 281         if (param->rx_jumbo_pending) {
 282                 netdev_info(dev, "%s: rx_jumbo_pending not supported\n",
 283                             __func__);
 284                 return -EINVAL;
 285         }
 286         if (param->rx_mini_pending) {
 287                 netdev_info(dev, "%s: rx_mini_pending not supported\n",
 288                             __func__);
 289                 return -EINVAL;
 290         }
 291         if (param->rx_pending < (1 << MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE)) {
 292                 netdev_info(dev, "%s: rx_pending (%d) < min (%d)\n",
 293                             __func__, param->rx_pending,
 294                             1 << MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE);
 295                 return -EINVAL;
 296         }
 297         if (param->rx_pending > (1 << MLX5E_PARAMS_MAXIMUM_LOG_RQ_SIZE)) {
 298                 netdev_info(dev, "%s: rx_pending (%d) > max (%d)\n",
 299                             __func__, param->rx_pending,
 300                             1 << MLX5E_PARAMS_MAXIMUM_LOG_RQ_SIZE);
 301                 return -EINVAL;
 302         }
 303         if (param->tx_pending < (1 << MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE)) {
 304                 netdev_info(dev, "%s: tx_pending (%d) < min (%d)\n",
 305                             __func__, param->tx_pending,
 306                             1 << MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE);
 307                 return -EINVAL;
 308         }
 309         if (param->tx_pending > (1 << MLX5E_PARAMS_MAXIMUM_LOG_SQ_SIZE)) {
 310                 netdev_info(dev, "%s: tx_pending (%d) > max (%d)\n",
 311                             __func__, param->tx_pending,
 312                             1 << MLX5E_PARAMS_MAXIMUM_LOG_SQ_SIZE);
 313                 return -EINVAL;
 314         }
 315
 316         log_rq_size = order_base_2(param->rx_pending);
 317         log_sq_size = order_base_2(param->tx_pending);
 318         min_rx_wqes = min_t(u16, param->rx_pending - 1,
 319                             MLX5E_PARAMS_DEFAULT_MIN_RX_WQES);
 320
 321         if (log_rq_size == priv->params.log_rq_size &&
 322             log_sq_size == priv->params.log_sq_size &&
 323             min_rx_wqes == priv->params.min_rx_wqes)
 324                 return 0;
 325
 326         mutex_lock(&priv->state_lock);
 327
 328         was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state);
 329         if (was_opened)
 330                 mlx5e_close_locked(dev);
 331
 332         priv->params.log_rq_size = log_rq_size;
 333         priv->params.log_sq_size = log_sq_size;
 334         priv->params.min_rx_wqes = min_rx_wqes;
 335
 336         if (was_opened)
 337                 err = mlx5e_open_locked(dev);
 338
 339         mutex_unlock(&priv->state_lock);
 340
 341         return err;
 342 }
 343
 344 static void mlx5e_get_channels(struct net_device *dev,
 345                                struct ethtool_channels *ch)
 346 {
 347         struct mlx5e_priv *priv = netdev_priv(dev);
 348
 349         ch->max_combined   = mlx5e_get_max_num_channels(priv->mdev);
 350         ch->combined_count = priv->params.num_channels;
 351 }
 352
 353 static int mlx5e_set_channels(struct net_device *dev,
 354                               struct ethtool_channels *ch)
 355 {
 356         struct mlx5e_priv *priv = netdev_priv(dev);
 357         int ncv = mlx5e_get_max_num_channels(priv->mdev);
 358         unsigned int count = ch->combined_count;
 359         bool was_opened;
 360         int err = 0;
 361
 362         if (!count) {
 363                 netdev_info(dev, "%s: combined_count=0 not supported\n",
 364                             __func__);
 365                 return -EINVAL;
 366         }
 367         if (ch->rx_count || ch->tx_count) {
 368                 netdev_info(dev, "%s: separate rx/tx count not supported\n",
 369                             __func__);
 370                 return -EINVAL;
 371         }
 372         if (count > ncv) {
 373                 netdev_info(dev, "%s: count (%d) > max (%d)\n",
 374                             __func__, count, ncv);
 375                 return -EINVAL;
 376         }
 377
 378         if (priv->params.num_channels == count)
 379                 return 0;
 380
 381         mutex_lock(&priv->state_lock);
 382
 383         was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state);
 384         if (was_opened)
 385                 mlx5e_close_locked(dev);
 386
 387         priv->params.num_channels = count;
 388
 389         if (was_opened)
 390                 err = mlx5e_open_locked(dev);
 391
 392         mutex_unlock(&priv->state_lock);
 393
 394         return err;
 395 }
 396
 397 static int mlx5e_get_coalesce(struct net_device *netdev,
 398                               struct ethtool_coalesce *coal)
 399 {
 400         struct mlx5e_priv *priv = netdev_priv(netdev);
 401
 402         if (!MLX5_CAP_GEN(priv->mdev, cq_moderation))
 403                 return -ENOTSUPP;
 404
 405         coal->rx_coalesce_usecs       = priv->params.rx_cq_moderation_usec;
 406         coal->rx_max_coalesced_frames = priv->params.rx_cq_moderation_pkts;
 407         coal->tx_coalesce_usecs       = priv->params.tx_cq_moderation_usec;
 408         coal->tx_max_coalesced_frames = priv->params.tx_cq_moderation_pkts;
 409
 410         return 0;
 411 }
 412
 413 static int mlx5e_set_coalesce(struct net_device *netdev,
 414                               struct ethtool_coalesce *coal)
 415 {
 416         struct mlx5e_priv *priv    = netdev_priv(netdev);
 417         struct mlx5_core_dev *mdev = priv->mdev;
 418         struct mlx5e_channel *c;
 419         int tc;
 420         int i;
 421
 422         if (!MLX5_CAP_GEN(mdev, cq_moderation))
 423                 return -ENOTSUPP;
 424
 425         mutex_lock(&priv->state_lock);
 426         priv->params.tx_cq_moderation_usec = coal->tx_coalesce_usecs;
 427         priv->params.tx_cq_moderation_pkts = coal->tx_max_coalesced_frames;
 428         priv->params.rx_cq_moderation_usec = coal->rx_coalesce_usecs;
 429         priv->params.rx_cq_moderation_pkts = coal->rx_max_coalesced_frames;
 430
 431         if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
 432                 goto out;
 433
 434         for (i = 0; i < priv->params.num_channels; ++i) {
 435                 c = priv->channel[i];
 436
 437                 for (tc = 0; tc < c->num_tc; tc++) {
 438                         mlx5_core_modify_cq_moderation(mdev,
 439                                                 &c->sq[tc].cq.mcq,
 440                                                 coal->tx_coalesce_usecs,
 441                                                 coal->tx_max_coalesced_frames);
 442                 }
 443
 444                 mlx5_core_modify_cq_moderation(mdev, &c->rq.cq.mcq,
 445                                                coal->rx_coalesce_usecs,
 446                                                coal->rx_max_coalesced_frames);
 447         }
 448
 449 out:
 450         mutex_unlock(&priv->state_lock);
 451         return 0;
 452 }
 453
 454 static u32 ptys2ethtool_supported_link(u32 eth_proto_cap)
 455 {
 456         int i;
 457         u32 supported_modes = 0;
 458
 459         for (i = 0; i < MLX5E_LINK_MODES_NUMBER; ++i) {
 460                 if (eth_proto_cap & MLX5E_PROT_MASK(i))
 461                         supported_modes |= ptys2ethtool_table[i].supported;
 462         }
 463         return supported_modes;
 464 }
 465
 466 static u32 ptys2ethtool_adver_link(u32 eth_proto_cap)
 467 {
 468         int i;
 469         u32 advertising_modes = 0;
 470
 471         for (i = 0; i < MLX5E_LINK_MODES_NUMBER; ++i) {
 472                 if (eth_proto_cap & MLX5E_PROT_MASK(i))
 473                         advertising_modes |= ptys2ethtool_table[i].advertised;
 474         }
 475         return advertising_modes;
 476 }
 477
 478 static u32 ptys2ethtool_supported_port(u32 eth_proto_cap)
 479 {
 480         if (eth_proto_cap & (MLX5E_PROT_MASK(MLX5E_10GBASE_CR)
 481                            | MLX5E_PROT_MASK(MLX5E_10GBASE_SR)
 482                            | MLX5E_PROT_MASK(MLX5E_40GBASE_CR4)
 483                            | MLX5E_PROT_MASK(MLX5E_40GBASE_SR4)
 484                            | MLX5E_PROT_MASK(MLX5E_100GBASE_SR4)
 485                            | MLX5E_PROT_MASK(MLX5E_1000BASE_CX_SGMII))) {
 486                 return SUPPORTED_FIBRE;
 487         }
 488
 489         if (eth_proto_cap & (MLX5E_PROT_MASK(MLX5E_100GBASE_KR4)
 490                            | MLX5E_PROT_MASK(MLX5E_40GBASE_KR4)
 491                            | MLX5E_PROT_MASK(MLX5E_10GBASE_KR)
 492                            | MLX5E_PROT_MASK(MLX5E_10GBASE_KX4)
 493                            | MLX5E_PROT_MASK(MLX5E_1000BASE_KX))) {
 494                 return SUPPORTED_Backplane;
 495         }
 496         return 0;
 497 }
 498
 499 static void get_speed_duplex(struct net_device *netdev,
 500                              u32 eth_proto_oper,
 501                              struct ethtool_cmd *cmd)
 502 {
 503         int i;
 504         u32 speed = SPEED_UNKNOWN;
 505         u8 duplex = DUPLEX_UNKNOWN;
 506
 507         if (!netif_carrier_ok(netdev))
 508                 goto out;
 509
 510         for (i = 0; i < MLX5E_LINK_MODES_NUMBER; ++i) {
 511                 if (eth_proto_oper & MLX5E_PROT_MASK(i)) {
 512                         speed = ptys2ethtool_table[i].speed;
 513                         duplex = DUPLEX_FULL;
 514                         break;
 515                 }
 516         }
 517 out:
 518         ethtool_cmd_speed_set(cmd, speed);
 519         cmd->duplex = duplex;
 520 }
 521
 522 static void get_supported(u32 eth_proto_cap, u32 *supported)
 523 {
 524         *supported |= ptys2ethtool_supported_port(eth_proto_cap);
 525         *supported |= ptys2ethtool_supported_link(eth_proto_cap);
 526         *supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
 527 }
 528
 529 static void get_advertising(u32 eth_proto_cap, u8 tx_pause,
 530                             u8 rx_pause, u32 *advertising)
 531 {
 532         *advertising |= ptys2ethtool_adver_link(eth_proto_cap);
 533         *advertising |= tx_pause ? ADVERTISED_Pause : 0;
 534         *advertising |= (tx_pause ^ rx_pause) ? ADVERTISED_Asym_Pause : 0;
 535 }
 536
 537 static u8 get_connector_port(u32 eth_proto)
 538 {
 539         if (eth_proto & (MLX5E_PROT_MASK(MLX5E_10GBASE_SR)
 540                          | MLX5E_PROT_MASK(MLX5E_40GBASE_SR4)
 541                          | MLX5E_PROT_MASK(MLX5E_100GBASE_SR4)
 542                          | MLX5E_PROT_MASK(MLX5E_1000BASE_CX_SGMII))) {
 543                         return PORT_FIBRE;
 544         }
 545
 546         if (eth_proto & (MLX5E_PROT_MASK(MLX5E_40GBASE_CR4)
 547                          | MLX5E_PROT_MASK(MLX5E_10GBASE_CR)
 548                          | MLX5E_PROT_MASK(MLX5E_100GBASE_CR4))) {
 549                         return PORT_DA;
 550         }
 551
 552         if (eth_proto & (MLX5E_PROT_MASK(MLX5E_10GBASE_KX4)
 553                          | MLX5E_PROT_MASK(MLX5E_10GBASE_KR)
 554                          | MLX5E_PROT_MASK(MLX5E_40GBASE_KR4)
 555                          | MLX5E_PROT_MASK(MLX5E_100GBASE_KR4))) {
 556                         return PORT_NONE;
 557         }
 558
 559         return PORT_OTHER;
 560 }
 561
 562 static void get_lp_advertising(u32 eth_proto_lp, u32 *lp_advertising)
 563 {
 564         *lp_advertising = ptys2ethtool_adver_link(eth_proto_lp);
 565 }
 566
 567 static int mlx5e_get_settings(struct net_device *netdev,
 568                               struct ethtool_cmd *cmd)
 569 {
 570         struct mlx5e_priv *priv    = netdev_priv(netdev);
 571         struct mlx5_core_dev *mdev = priv->mdev;
 572         u32 out[MLX5_ST_SZ_DW(ptys_reg)];
 573         u32 eth_proto_cap;
 574         u32 eth_proto_admin;
 575         u32 eth_proto_lp;
 576         u32 eth_proto_oper;
 577         int err;
 578
 579         err = mlx5_query_port_ptys(mdev, out, sizeof(out), MLX5_PTYS_EN, 1);
 580
 581         if (err) {
 582                 netdev_err(netdev, "%s: query port ptys failed: %d\n",
 583                            __func__, err);
 584                 goto err_query_ptys;
 585         }
 586
 587         eth_proto_cap   = MLX5_GET(ptys_reg, out, eth_proto_capability);
 588         eth_proto_admin = MLX5_GET(ptys_reg, out, eth_proto_admin);
 589         eth_proto_oper  = MLX5_GET(ptys_reg, out, eth_proto_oper);
 590         eth_proto_lp    = MLX5_GET(ptys_reg, out, eth_proto_lp_advertise);
 591
 592         cmd->supported   = 0;
 593         cmd->advertising = 0;
 594
 595         get_supported(eth_proto_cap, &cmd->supported);
 596         get_advertising(eth_proto_admin, 0, 0, &cmd->advertising);
 597         get_speed_duplex(netdev, eth_proto_oper, cmd);
 598
 599         eth_proto_oper = eth_proto_oper ? eth_proto_oper : eth_proto_cap;
 600
 601         cmd->port = get_connector_port(eth_proto_oper);
 602         get_lp_advertising(eth_proto_lp, &cmd->lp_advertising);
 603
 604         cmd->transceiver = XCVR_INTERNAL;
 605
 606 err_query_ptys:
 607         return err;
 608 }
 609
 610 static u32 mlx5e_ethtool2ptys_adver_link(u32 link_modes)
 611 {
 612         u32 i, ptys_modes = 0;
 613
 614         for (i = 0; i < MLX5E_LINK_MODES_NUMBER; ++i) {
 615                 if (ptys2ethtool_table[i].advertised & link_modes)
 616                         ptys_modes |= MLX5E_PROT_MASK(i);
 617         }
 618
 619         return ptys_modes;
 620 }
 621
 622 static u32 mlx5e_ethtool2ptys_speed_link(u32 speed)
 623 {
 624         u32 i, speed_links = 0;
 625
 626         for (i = 0; i < MLX5E_LINK_MODES_NUMBER; ++i) {
 627                 if (ptys2ethtool_table[i].speed == speed)
 628                         speed_links |= MLX5E_PROT_MASK(i);
 629         }
 630
 631         return speed_links;
 632 }
 633
 634 static int mlx5e_set_settings(struct net_device *netdev,
 635                               struct ethtool_cmd *cmd)
 636 {
 637         struct mlx5e_priv *priv    = netdev_priv(netdev);
 638         struct mlx5_core_dev *mdev = priv->mdev;
 639         u32 link_modes;
 640         u32 speed;
 641         u32 eth_proto_cap, eth_proto_admin;
 642         enum mlx5_port_status ps;
 643         int err;
 644
 645         speed = ethtool_cmd_speed(cmd);
 646
 647         link_modes = cmd->autoneg == AUTONEG_ENABLE ?
 648                 mlx5e_ethtool2ptys_adver_link(cmd->advertising) :
 649                 mlx5e_ethtool2ptys_speed_link(speed);
 650
 651         err = mlx5_query_port_proto_cap(mdev, &eth_proto_cap, MLX5_PTYS_EN);
 652         if (err) {
 653                 netdev_err(netdev, "%s: query port eth proto cap failed: %d\n",
 654                            __func__, err);
 655                 goto out;
 656         }
 657
 658         link_modes = link_modes & eth_proto_cap;
 659         if (!link_modes) {
 660                 netdev_err(netdev, "%s: Not supported link mode(s) requested",
 661                            __func__);
 662                 err = -EINVAL;
 663                 goto out;
 664         }
 665
 666         err = mlx5_query_port_proto_admin(mdev, &eth_proto_admin, MLX5_PTYS_EN);
 667         if (err) {
 668                 netdev_err(netdev, "%s: query port eth proto admin failed: %d\n",
 669                            __func__, err);
 670                 goto out;
 671         }
 672
 673         if (link_modes == eth_proto_admin)
 674                 goto out;
 675
 676         mlx5_query_port_admin_status(mdev, &ps);
 677         if (ps == MLX5_PORT_UP)
 678                 mlx5_set_port_admin_status(mdev, MLX5_PORT_DOWN);
 679         mlx5_set_port_proto(mdev, link_modes, MLX5_PTYS_EN);
 680         if (ps == MLX5_PORT_UP)
 681                 mlx5_set_port_admin_status(mdev, MLX5_PORT_UP);
 682
 683 out:
 684         return err;
 685 }
 686
 687 static u32 mlx5e_get_rxfh_key_size(struct net_device *netdev)
 688 {
 689         struct mlx5e_priv *priv = netdev_priv(netdev);
 690
 691         return sizeof(priv->params.toeplitz_hash_key);
 692 }
 693
 694 static u32 mlx5e_get_rxfh_indir_size(struct net_device *netdev)
 695 {
 696         return MLX5E_INDIR_RQT_SIZE;
 697 }
 698
 699 static int mlx5e_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
 700                           u8 *hfunc)
 701 {
 702         struct mlx5e_priv *priv = netdev_priv(netdev);
 703
 704         if (indir)
 705                 memcpy(indir, priv->params.indirection_rqt,
 706                        sizeof(priv->params.indirection_rqt));
 707
 708         if (key)
 709                 memcpy(key, priv->params.toeplitz_hash_key,
 710                        sizeof(priv->params.toeplitz_hash_key));
 711
 712         if (hfunc)
 713                 *hfunc = priv->params.rss_hfunc;
 714
 715         return 0;
 716 }
 717
 718 static int mlx5e_set_rxfh(struct net_device *dev, const u32 *indir,
 719                           const u8 *key, const u8 hfunc)
 720 {
 721         struct mlx5e_priv *priv = netdev_priv(dev);
 722         bool close_open;
 723         int err = 0;
 724
 725         if ((hfunc != ETH_RSS_HASH_NO_CHANGE) &&
 726             (hfunc != ETH_RSS_HASH_XOR) &&
 727             (hfunc != ETH_RSS_HASH_TOP))
 728                 return -EINVAL;
 729
 730         mutex_lock(&priv->state_lock);
 731
 732         if (indir) {
 733                 memcpy(priv->params.indirection_rqt, indir,
 734                        sizeof(priv->params.indirection_rqt));
 735                 mlx5e_redirect_rqt(priv, MLX5E_INDIRECTION_RQT);
 736         }
 737
 738         close_open = (key || (hfunc != ETH_RSS_HASH_NO_CHANGE)) &&
 739                      test_bit(MLX5E_STATE_OPENED, &priv->state);
 740         if (close_open)
 741                 mlx5e_close_locked(dev);
 742
 743         if (key)
 744                 memcpy(priv->params.toeplitz_hash_key, key,
 745                        sizeof(priv->params.toeplitz_hash_key));
 746
 747         if (hfunc != ETH_RSS_HASH_NO_CHANGE)
 748                 priv->params.rss_hfunc = hfunc;
 749
 750         if (close_open)
 751                 err = mlx5e_open_locked(priv->netdev);
 752
 753         mutex_unlock(&priv->state_lock);
 754
 755         return err;
 756 }
 757
 758 static int mlx5e_get_rxnfc(struct net_device *netdev,
 759                            struct ethtool_rxnfc *info, u32 *rule_locs)
 760 {
 761         struct mlx5e_priv *priv = netdev_priv(netdev);
 762         int err = 0;
 763
 764         switch (info->cmd) {
 765         case ETHTOOL_GRXRINGS:
 766                 info->data = priv->params.num_channels;
 767                 break;
 768         default:
 769                 err = -EOPNOTSUPP;
 770                 break;
 771         }
 772
 773         return err;
 774 }
 775
 776 static int mlx5e_get_tunable(struct net_device *dev,
 777                              const struct ethtool_tunable *tuna,
 778                              void *data)
 779 {
 780         const struct mlx5e_priv *priv = netdev_priv(dev);
 781         int err = 0;
 782
 783         switch (tuna->id) {
 784         case ETHTOOL_TX_COPYBREAK:
 785                 *(u32 *)data = priv->params.tx_max_inline;
 786                 break;
 787         default:
 788                 err = -EINVAL;
 789                 break;
 790         }
 791
 792         return err;
 793 }
 794
 795 static int mlx5e_set_tunable(struct net_device *dev,
 796                              const struct ethtool_tunable *tuna,
 797                              const void *data)
 798 {
 799         struct mlx5e_priv *priv = netdev_priv(dev);
 800         struct mlx5_core_dev *mdev = priv->mdev;
 801         bool was_opened;
 802         u32 val;
 803         int err = 0;
 804
 805         switch (tuna->id) {
 806         case ETHTOOL_TX_COPYBREAK:
 807                 val = *(u32 *)data;
 808                 if (val > mlx5e_get_max_inline_cap(mdev)) {
 809                         err = -EINVAL;
 810                         break;
 811                 }
 812
 813                 mutex_lock(&priv->state_lock);
 814
 815                 was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state);
 816                 if (was_opened)
 817                         mlx5e_close_locked(dev);
 818
 819                 priv->params.tx_max_inline = val;
 820
 821                 if (was_opened)
 822                         err = mlx5e_open_locked(dev);
 823
 824                 mutex_unlock(&priv->state_lock);
 825                 break;
 826         default:
 827                 err = -EINVAL;
 828                 break;
 829         }
 830
 831         return err;
 832 }
 833
 834 static void mlx5e_get_pauseparam(struct net_device *netdev,
 835                                  struct ethtool_pauseparam *pauseparam)
 836 {
 837         struct mlx5e_priv *priv    = netdev_priv(netdev);
 838         struct mlx5_core_dev *mdev = priv->mdev;
 839         int err;
 840
 841         err = mlx5_query_port_pause(mdev, &pauseparam->rx_pause,
 842                                     &pauseparam->tx_pause);
 843         if (err) {
 844                 netdev_err(netdev, "%s: mlx5_query_port_pause failed:0x%x\n",
 845                            __func__, err);
 846         }
 847 }
 848
 849 static int mlx5e_set_pauseparam(struct net_device *netdev,
 850                                 struct ethtool_pauseparam *pauseparam)
 851 {
 852         struct mlx5e_priv *priv    = netdev_priv(netdev);
 853         struct mlx5_core_dev *mdev = priv->mdev;
 854         int err;
 855
 856         if (pauseparam->autoneg)
 857                 return -EINVAL;
 858
 859         err = mlx5_set_port_pause(mdev,
 860                                   pauseparam->rx_pause ? 1 : 0,
 861                                   pauseparam->tx_pause ? 1 : 0);
 862         if (err) {
 863                 netdev_err(netdev, "%s: mlx5_set_port_pause failed:0x%x\n",
 864                            __func__, err);
 865         }
 866
 867         return err;
 868 }
 869
 870 const struct ethtool_ops mlx5e_ethtool_ops = {
 871         .get_drvinfo       = mlx5e_get_drvinfo,
 872         .get_link          = ethtool_op_get_link,
 873         .get_strings       = mlx5e_get_strings,
 874         .get_sset_count    = mlx5e_get_sset_count,
 875         .get_ethtool_stats = mlx5e_get_ethtool_stats,
 876         .get_ringparam     = mlx5e_get_ringparam,
 877         .set_ringparam     = mlx5e_set_ringparam,
 878         .get_channels      = mlx5e_get_channels,
 879         .set_channels      = mlx5e_set_channels,
 880         .get_coalesce      = mlx5e_get_coalesce,
 881         .set_coalesce      = mlx5e_set_coalesce,
 882         .get_settings      = mlx5e_get_settings,
 883         .set_settings      = mlx5e_set_settings,
 884         .get_rxfh_key_size   = mlx5e_get_rxfh_key_size,
 885         .get_rxfh_indir_size = mlx5e_get_rxfh_indir_size,
 886         .get_rxfh          = mlx5e_get_rxfh,
 887         .set_rxfh          = mlx5e_set_rxfh,
 888         .get_rxnfc         = mlx5e_get_rxnfc,
 889         .get_tunable       = mlx5e_get_tunable,
 890         .set_tunable       = mlx5e_set_tunable,
 891         .get_pauseparam    = mlx5e_get_pauseparam,
 892         .set_pauseparam    = mlx5e_set_pauseparam,
 893 };