sys/dev/mlx5/mlx5_en/mlx5_en_ethtool.c

   1 /*-
   2  * Copyright (c) 2015 Mellanox Technologies. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS `AS IS' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  *
  25  * $FreeBSD$
  26  */
  27
  28 #include "en.h"
  29 #include <net/sff8472.h>
  30
  31 void
  32 mlx5e_create_stats(struct sysctl_ctx_list *ctx,
  33     struct sysctl_oid_list *parent, const char *buffer,
  34     const char **desc, unsigned num, u64 * arg)
  35 {
  36         struct sysctl_oid *node;
  37         unsigned x;
  38
  39         sysctl_ctx_init(ctx);
  40
  41         node = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO,
  42             buffer, CTLFLAG_RD, NULL, "Statistics");
  43         if (node == NULL)
  44                 return;
  45         for (x = 0; x != num; x++) {
  46                 SYSCTL_ADD_UQUAD(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
  47                     desc[2 * x], CTLFLAG_RD, arg + x, desc[2 * x + 1]);
  48         }
  49 }
  50
  51 static void
  52 mlx5e_ethtool_sync_tx_completion_fact(struct mlx5e_priv *priv)
  53 {
  54         /*
  55          * Limit the maximum distance between completion events to
  56          * half of the currently set TX queue size.
  57          *
  58          * The maximum number of queue entries a single IP packet can
  59          * consume is given by MLX5_SEND_WQE_MAX_WQEBBS.
  60          *
  61          * The worst case max value is then given as below:
  62          */
  63         uint64_t max = priv->params_ethtool.tx_queue_size /
  64             (2 * MLX5_SEND_WQE_MAX_WQEBBS);
  65
  66         /*
  67          * Update the maximum completion factor value in case the
  68          * tx_queue_size field changed. Ensure we don't overflow
  69          * 16-bits.
  70          */
  71         if (max < 1)
  72                 max = 1;
  73         else if (max > 65535)
  74                 max = 65535;
  75         priv->params_ethtool.tx_completion_fact_max = max;
  76
  77         /*
  78          * Verify that the current TX completion factor is within the
  79          * given limits:
  80          */
  81         if (priv->params_ethtool.tx_completion_fact < 1)
  82                 priv->params_ethtool.tx_completion_fact = 1;
  83         else if (priv->params_ethtool.tx_completion_fact > max)
  84                 priv->params_ethtool.tx_completion_fact = max;
  85 }
  86
  87 #define MLX5_PARAM_OFFSET(n)                            \
  88     __offsetof(struct mlx5e_priv, params_ethtool.n)
  89
  90 static int
  91 mlx5e_ethtool_handler(SYSCTL_HANDLER_ARGS)
  92 {
  93         struct mlx5e_priv *priv = arg1;
  94         uint64_t value;
  95         int mode_modify;
  96         int was_opened;
  97         int error;
  98
  99         PRIV_LOCK(priv);
 100         value = priv->params_ethtool.arg[arg2];
 101         if (req != NULL) {
 102                 error = sysctl_handle_64(oidp, &value, 0, req);
 103                 if (error || req->newptr == NULL ||
 104                     value == priv->params_ethtool.arg[arg2])
 105                         goto done;
 106
 107                 /* assign new value */
 108                 priv->params_ethtool.arg[arg2] = value;
 109         } else {
 110                 error = 0;
 111         }
 112         /* check if device is gone */
 113         if (priv->gone) {
 114                 error = ENXIO;
 115                 goto done;
 116         }
 117         was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state);
 118         mode_modify = MLX5_CAP_GEN(priv->mdev, cq_period_mode_modify);
 119
 120         switch (MLX5_PARAM_OFFSET(arg[arg2])) {
 121         case MLX5_PARAM_OFFSET(rx_coalesce_usecs):
 122                 /* import RX coal time */
 123                 if (priv->params_ethtool.rx_coalesce_usecs < 1)
 124                         priv->params_ethtool.rx_coalesce_usecs = 0;
 125                 else if (priv->params_ethtool.rx_coalesce_usecs >
 126                     MLX5E_FLD_MAX(cqc, cq_period)) {
 127                         priv->params_ethtool.rx_coalesce_usecs =
 128                             MLX5E_FLD_MAX(cqc, cq_period);
 129                 }
 130                 priv->params.rx_cq_moderation_usec =
 131                     priv->params_ethtool.rx_coalesce_usecs;
 132
 133                 /* check to avoid down and up the network interface */
 134                 if (was_opened)
 135                         error = mlx5e_refresh_channel_params(priv);
 136                 break;
 137
 138         case MLX5_PARAM_OFFSET(rx_coalesce_pkts):
 139                 /* import RX coal pkts */
 140                 if (priv->params_ethtool.rx_coalesce_pkts < 1)
 141                         priv->params_ethtool.rx_coalesce_pkts = 0;
 142                 else if (priv->params_ethtool.rx_coalesce_pkts >
 143                     MLX5E_FLD_MAX(cqc, cq_max_count)) {
 144                         priv->params_ethtool.rx_coalesce_pkts =
 145                             MLX5E_FLD_MAX(cqc, cq_max_count);
 146                 }
 147                 priv->params.rx_cq_moderation_pkts =
 148                     priv->params_ethtool.rx_coalesce_pkts;
 149
 150                 /* check to avoid down and up the network interface */
 151                 if (was_opened)
 152                         error = mlx5e_refresh_channel_params(priv);
 153                 break;
 154
 155         case MLX5_PARAM_OFFSET(tx_coalesce_usecs):
 156                 /* import TX coal time */
 157                 if (priv->params_ethtool.tx_coalesce_usecs < 1)
 158                         priv->params_ethtool.tx_coalesce_usecs = 0;
 159                 else if (priv->params_ethtool.tx_coalesce_usecs >
 160                     MLX5E_FLD_MAX(cqc, cq_period)) {
 161                         priv->params_ethtool.tx_coalesce_usecs =
 162                             MLX5E_FLD_MAX(cqc, cq_period);
 163                 }
 164                 priv->params.tx_cq_moderation_usec =
 165                     priv->params_ethtool.tx_coalesce_usecs;
 166
 167                 /* check to avoid down and up the network interface */
 168                 if (was_opened)
 169                         error = mlx5e_refresh_channel_params(priv);
 170                 break;
 171
 172         case MLX5_PARAM_OFFSET(tx_coalesce_pkts):
 173                 /* import TX coal pkts */
 174                 if (priv->params_ethtool.tx_coalesce_pkts < 1)
 175                         priv->params_ethtool.tx_coalesce_pkts = 0;
 176                 else if (priv->params_ethtool.tx_coalesce_pkts >
 177                     MLX5E_FLD_MAX(cqc, cq_max_count)) {
 178                         priv->params_ethtool.tx_coalesce_pkts =
 179                             MLX5E_FLD_MAX(cqc, cq_max_count);
 180                 }
 181                 priv->params.tx_cq_moderation_pkts =
 182                     priv->params_ethtool.tx_coalesce_pkts;
 183
 184                 /* check to avoid down and up the network interface */
 185                 if (was_opened)
 186                         error = mlx5e_refresh_channel_params(priv);
 187                 break;
 188
 189         case MLX5_PARAM_OFFSET(tx_queue_size):
 190                 /* network interface must be down */
 191                 if (was_opened)
 192                         mlx5e_close_locked(priv->ifp);
 193
 194                 /* import TX queue size */
 195                 if (priv->params_ethtool.tx_queue_size <
 196                     (1 << MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE)) {
 197                         priv->params_ethtool.tx_queue_size =
 198                             (1 << MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE);
 199                 } else if (priv->params_ethtool.tx_queue_size >
 200                     priv->params_ethtool.tx_queue_size_max) {
 201                         priv->params_ethtool.tx_queue_size =
 202                             priv->params_ethtool.tx_queue_size_max;
 203                 }
 204                 /* store actual TX queue size */
 205                 priv->params.log_sq_size =
 206                     order_base_2(priv->params_ethtool.tx_queue_size);
 207                 priv->params_ethtool.tx_queue_size =
 208                     1 << priv->params.log_sq_size;
 209
 210                 /* verify TX completion factor */
 211                 mlx5e_ethtool_sync_tx_completion_fact(priv);
 212
 213                 /* restart network interface, if any */
 214                 if (was_opened)
 215                         mlx5e_open_locked(priv->ifp);
 216                 break;
 217
 218         case MLX5_PARAM_OFFSET(rx_queue_size):
 219                 /* network interface must be down */
 220                 if (was_opened)
 221                         mlx5e_close_locked(priv->ifp);
 222
 223                 /* import RX queue size */
 224                 if (priv->params_ethtool.rx_queue_size <
 225                     (1 << MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE)) {
 226                         priv->params_ethtool.rx_queue_size =
 227                             (1 << MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE);
 228                 } else if (priv->params_ethtool.rx_queue_size >
 229                     priv->params_ethtool.rx_queue_size_max) {
 230                         priv->params_ethtool.rx_queue_size =
 231                             priv->params_ethtool.rx_queue_size_max;
 232                 }
 233                 /* store actual RX queue size */
 234                 priv->params.log_rq_size =
 235                     order_base_2(priv->params_ethtool.rx_queue_size);
 236                 priv->params_ethtool.rx_queue_size =
 237                     1 << priv->params.log_rq_size;
 238
 239                 /* update least number of RX WQEs */
 240                 priv->params.min_rx_wqes = min(
 241                     priv->params_ethtool.rx_queue_size - 1,
 242                     MLX5E_PARAMS_DEFAULT_MIN_RX_WQES);
 243
 244                 /* restart network interface, if any */
 245                 if (was_opened)
 246                         mlx5e_open_locked(priv->ifp);
 247                 break;
 248
 249         case MLX5_PARAM_OFFSET(channels):
 250                 /* network interface must be down */
 251                 if (was_opened)
 252                         mlx5e_close_locked(priv->ifp);
 253
 254                 /* import number of channels */
 255                 if (priv->params_ethtool.channels < 1)
 256                         priv->params_ethtool.channels = 1;
 257                 else if (priv->params_ethtool.channels >
 258                     (u64) priv->mdev->priv.eq_table.num_comp_vectors) {
 259                         priv->params_ethtool.channels =
 260                             (u64) priv->mdev->priv.eq_table.num_comp_vectors;
 261                 }
 262                 priv->params.num_channels = priv->params_ethtool.channels;
 263
 264                 /* restart network interface, if any */
 265                 if (was_opened)
 266                         mlx5e_open_locked(priv->ifp);
 267                 break;
 268
 269         case MLX5_PARAM_OFFSET(rx_coalesce_mode):
 270                 /* network interface must be down */
 271                 if (was_opened != 0 && mode_modify == 0)
 272                         mlx5e_close_locked(priv->ifp);
 273
 274                 /* import RX coalesce mode */
 275                 if (priv->params_ethtool.rx_coalesce_mode != 0)
 276                         priv->params_ethtool.rx_coalesce_mode = 1;
 277                 priv->params.rx_cq_moderation_mode =
 278                     priv->params_ethtool.rx_coalesce_mode;
 279
 280                 /* restart network interface, if any */
 281                 if (was_opened != 0) {
 282                         if (mode_modify == 0)
 283                                 mlx5e_open_locked(priv->ifp);
 284                         else
 285                                 error = mlx5e_refresh_channel_params(priv);
 286                 }
 287                 break;
 288
 289         case MLX5_PARAM_OFFSET(tx_coalesce_mode):
 290                 /* network interface must be down */
 291                 if (was_opened != 0 && mode_modify == 0)
 292                         mlx5e_close_locked(priv->ifp);
 293
 294                 /* import TX coalesce mode */
 295                 if (priv->params_ethtool.tx_coalesce_mode != 0)
 296                         priv->params_ethtool.tx_coalesce_mode = 1;
 297                 priv->params.tx_cq_moderation_mode =
 298                     priv->params_ethtool.tx_coalesce_mode;
 299
 300                 /* restart network interface, if any */
 301                 if (was_opened != 0) {
 302                         if (mode_modify == 0)
 303                                 mlx5e_open_locked(priv->ifp);
 304                         else
 305                                 error = mlx5e_refresh_channel_params(priv);
 306                 }
 307                 break;
 308
 309         case MLX5_PARAM_OFFSET(hw_lro):
 310                 /* network interface must be down */
 311                 if (was_opened)
 312                         mlx5e_close_locked(priv->ifp);
 313
 314                 /* import HW LRO mode */
 315                 if (priv->params_ethtool.hw_lro != 0) {
 316                         if ((priv->ifp->if_capenable & IFCAP_LRO) &&
 317                             MLX5_CAP_ETH(priv->mdev, lro_cap)) {
 318                                 priv->params.hw_lro_en = 1;
 319                                 priv->params_ethtool.hw_lro = 1;
 320                         } else {
 321                                 priv->params.hw_lro_en = 0;
 322                                 priv->params_ethtool.hw_lro = 0;
 323                                 error = EINVAL;
 324
 325                                 if_printf(priv->ifp, "Can't enable HW LRO: "
 326                                     "The HW or SW LRO feature is disabled\n");
 327                         }
 328                 } else {
 329                         priv->params.hw_lro_en = 0;
 330                 }
 331                 /* restart network interface, if any */
 332                 if (was_opened)
 333                         mlx5e_open_locked(priv->ifp);
 334                 break;
 335
 336         case MLX5_PARAM_OFFSET(cqe_zipping):
 337                 /* network interface must be down */
 338                 if (was_opened)
 339                         mlx5e_close_locked(priv->ifp);
 340
 341                 /* import CQE zipping mode */
 342                 if (priv->params_ethtool.cqe_zipping &&
 343                     MLX5_CAP_GEN(priv->mdev, cqe_compression)) {
 344                         priv->params.cqe_zipping_en = true;
 345                         priv->params_ethtool.cqe_zipping = 1;
 346                 } else {
 347                         priv->params.cqe_zipping_en = false;
 348                         priv->params_ethtool.cqe_zipping = 0;
 349                 }
 350                 /* restart network interface, if any */
 351                 if (was_opened)
 352                         mlx5e_open_locked(priv->ifp);
 353                 break;
 354
 355         case MLX5_PARAM_OFFSET(tx_bufring_disable):
 356                 /* rangecheck input value */
 357                 priv->params_ethtool.tx_bufring_disable =
 358                     priv->params_ethtool.tx_bufring_disable ? 1 : 0;
 359
 360                 /* reconfigure the sendqueues, if any */
 361                 if (was_opened) {
 362                         mlx5e_close_locked(priv->ifp);
 363                         mlx5e_open_locked(priv->ifp);
 364                 }
 365                 break;
 366
 367         case MLX5_PARAM_OFFSET(tx_completion_fact):
 368                 /* network interface must be down */
 369                 if (was_opened)
 370                         mlx5e_close_locked(priv->ifp);
 371
 372                 /* verify parameter */
 373                 mlx5e_ethtool_sync_tx_completion_fact(priv);
 374
 375                 /* restart network interface, if any */
 376                 if (was_opened)
 377                         mlx5e_open_locked(priv->ifp);
 378                 break;
 379
 380         case MLX5_PARAM_OFFSET(diag_pci_enable):
 381                 priv->params_ethtool.diag_pci_enable =
 382                     priv->params_ethtool.diag_pci_enable ? 1 : 0;
 383
 384                 error = -mlx5_core_set_diagnostics_full(priv->mdev,
 385                     priv->params_ethtool.diag_pci_enable,
 386                     priv->params_ethtool.diag_general_enable);
 387                 break;
 388
 389         case MLX5_PARAM_OFFSET(diag_general_enable):
 390                 priv->params_ethtool.diag_general_enable =
 391                     priv->params_ethtool.diag_general_enable ? 1 : 0;
 392
 393                 error = -mlx5_core_set_diagnostics_full(priv->mdev,
 394                     priv->params_ethtool.diag_pci_enable,
 395                     priv->params_ethtool.diag_general_enable);
 396                 break;
 397
 398         default:
 399                 break;
 400         }
 401 done:
 402         PRIV_UNLOCK(priv);
 403         return (error);
 404 }
 405
 406 /*
 407  * Read the first three bytes of the eeprom in order to get the needed info
 408  * for the whole reading.
 409  * Byte 0 - Identifier byte
 410  * Byte 1 - Revision byte
 411  * Byte 2 - Status byte
 412  */
 413 static int
 414 mlx5e_get_eeprom_info(struct mlx5e_priv *priv, struct mlx5e_eeprom *eeprom)
 415 {
 416         struct mlx5_core_dev *dev = priv->mdev;
 417         u32 data = 0;
 418         int size_read = 0;
 419         int ret;
 420
 421         ret = mlx5_query_module_num(dev, &eeprom->module_num);
 422         if (ret) {
 423                 if_printf(priv->ifp, "%s:%d: Failed query module error=%d\n",
 424                     __func__, __LINE__, ret);
 425                 return (ret);
 426         }
 427
 428         /* Read the first three bytes to get Identifier, Revision and Status */
 429         ret = mlx5_query_eeprom(dev, eeprom->i2c_addr, eeprom->page_num,
 430             eeprom->device_addr, MLX5E_EEPROM_INFO_BYTES, eeprom->module_num, &data,
 431             &size_read);
 432         if (ret) {
 433                 if_printf(priv->ifp, "%s:%d: Failed query eeprom module error=0x%x\n",
 434                     __func__, __LINE__, ret);
 435                 return (ret);
 436         }
 437
 438         switch (data & MLX5_EEPROM_IDENTIFIER_BYTE_MASK) {
 439         case SFF_8024_ID_QSFP:
 440                 eeprom->type = MLX5E_ETH_MODULE_SFF_8436;
 441                 eeprom->len = MLX5E_ETH_MODULE_SFF_8436_LEN;
 442                 break;
 443         case SFF_8024_ID_QSFPPLUS:
 444         case SFF_8024_ID_QSFP28:
 445                 if ((data & MLX5_EEPROM_IDENTIFIER_BYTE_MASK) == SFF_8024_ID_QSFP28 ||
 446                     ((data & MLX5_EEPROM_REVISION_ID_BYTE_MASK) >> 8) >= 0x3) {
 447                         eeprom->type = MLX5E_ETH_MODULE_SFF_8636;
 448                         eeprom->len = MLX5E_ETH_MODULE_SFF_8636_LEN;
 449                 } else {
 450                         eeprom->type = MLX5E_ETH_MODULE_SFF_8436;
 451                         eeprom->len = MLX5E_ETH_MODULE_SFF_8436_LEN;
 452                 }
 453                 if ((data & MLX5_EEPROM_PAGE_3_VALID_BIT_MASK) == 0)
 454                         eeprom->page_valid = 1;
 455                 break;
 456         case SFF_8024_ID_SFP:
 457                 eeprom->type = MLX5E_ETH_MODULE_SFF_8472;
 458                 eeprom->len = MLX5E_ETH_MODULE_SFF_8472_LEN;
 459                 break;
 460         default:
 461                 if_printf(priv->ifp, "%s:%d: Not recognized cable type = 0x%x(%s)\n",
 462                     __func__, __LINE__, data & MLX5_EEPROM_IDENTIFIER_BYTE_MASK,
 463                     sff_8024_id[data & MLX5_EEPROM_IDENTIFIER_BYTE_MASK]);
 464                 return (EINVAL);
 465         }
 466         return (0);
 467 }
 468
 469 /* Read both low and high pages of the eeprom */
 470 static int
 471 mlx5e_get_eeprom(struct mlx5e_priv *priv, struct mlx5e_eeprom *ee)
 472 {
 473         struct mlx5_core_dev *dev = priv->mdev;
 474         int size_read = 0;
 475         int ret;
 476
 477         if (ee->len == 0)
 478                 return (EINVAL);
 479
 480         /* Read low page of the eeprom */
 481         while (ee->device_addr < ee->len) {
 482                 ret = mlx5_query_eeprom(dev, ee->i2c_addr, ee->page_num, ee->device_addr,
 483                     ee->len - ee->device_addr, ee->module_num,
 484                     ee->data + (ee->device_addr / 4), &size_read);
 485                 if (ret) {
 486                         if_printf(priv->ifp, "%s:%d: Failed reading eeprom, "
 487                             "error = 0x%02x\n", __func__, __LINE__, ret);
 488                         return (ret);
 489                 }
 490                 ee->device_addr += size_read;
 491         }
 492
 493         /* Read high page of the eeprom */
 494         if (ee->page_valid) {
 495                 ee->device_addr = MLX5E_EEPROM_HIGH_PAGE_OFFSET;
 496                 ee->page_num = MLX5E_EEPROM_HIGH_PAGE;
 497                 size_read = 0;
 498                 while (ee->device_addr < MLX5E_EEPROM_PAGE_LENGTH) {
 499                         ret = mlx5_query_eeprom(dev, ee->i2c_addr, ee->page_num,
 500                             ee->device_addr, MLX5E_EEPROM_PAGE_LENGTH - ee->device_addr,
 501                             ee->module_num, ee->data + (ee->len / 4) +
 502                             ((ee->device_addr - MLX5E_EEPROM_HIGH_PAGE_OFFSET) / 4),
 503                             &size_read);
 504                         if (ret) {
 505                                 if_printf(priv->ifp, "%s:%d: Failed reading eeprom, "
 506                                     "error = 0x%02x\n", __func__, __LINE__, ret);
 507                                 return (ret);
 508                         }
 509                         ee->device_addr += size_read;
 510                 }
 511         }
 512         return (0);
 513 }
 514
 515 static void
 516 mlx5e_print_eeprom(struct mlx5e_eeprom *eeprom)
 517 {
 518         int row;
 519         int index_in_row;
 520         int byte_to_write = 0;
 521         int line_length = 16;
 522
 523         printf("\nOffset\t\tValues\n");
 524         printf("------\t\t------");
 525         while (byte_to_write < eeprom->len) {
 526                 printf("\n0x%04X\t\t", byte_to_write);
 527                 for (index_in_row = 0; index_in_row < line_length; index_in_row++) {
 528                         printf("%02X ", ((u8 *)eeprom->data)[byte_to_write]);
 529                         byte_to_write++;
 530                 }
 531         }
 532
 533         if (eeprom->page_valid) {
 534                 row = MLX5E_EEPROM_HIGH_PAGE_OFFSET;
 535                 printf("\n\nUpper Page 0x03\n");
 536                 printf("\nOffset\t\tValues\n");
 537                 printf("------\t\t------");
 538                 while (row < MLX5E_EEPROM_PAGE_LENGTH) {
 539                         printf("\n0x%04X\t\t", row);
 540                         for (index_in_row = 0; index_in_row < line_length; index_in_row++) {
 541                                 printf("%02X ", ((u8 *)eeprom->data)[byte_to_write]);
 542                                 byte_to_write++;
 543                                 row++;
 544                         }
 545                 }
 546         }
 547 }
 548
 549 /*
 550  * Read cable EEPROM module information by first inspecting the first
 551  * three bytes to get the initial information for a whole reading.
 552  * Information will be printed to dmesg.
 553  */
 554 static int
 555 mlx5e_read_eeprom(SYSCTL_HANDLER_ARGS)
 556 {
 557         struct mlx5e_priv *priv = arg1;
 558         struct mlx5e_eeprom eeprom;
 559         int error;
 560         int result = 0;
 561
 562         PRIV_LOCK(priv);
 563         error = sysctl_handle_int(oidp, &result, 0, req);
 564         if (error || !req->newptr)
 565                 goto done;
 566
 567         /* Check if device is gone */
 568         if (priv->gone) {
 569                 error = ENXIO;
 570                 goto done;
 571         }
 572
 573         if (result == 1) {
 574                 eeprom.i2c_addr = MLX5E_I2C_ADDR_LOW;
 575                 eeprom.device_addr = 0;
 576                 eeprom.page_num = MLX5E_EEPROM_LOW_PAGE;
 577                 eeprom.page_valid = 0;
 578
 579                 /* Read three first bytes to get important info */
 580                 error = mlx5e_get_eeprom_info(priv, &eeprom);
 581                 if (error) {
 582                         if_printf(priv->ifp, "%s:%d: Failed reading eeprom's "
 583                             "initial information\n", __func__, __LINE__);
 584                         error = 0;
 585                         goto done;
 586                 }
 587                 /*
 588                  * Allocate needed length buffer and additional space for
 589                  * page 0x03
 590                  */
 591                 eeprom.data = malloc(eeprom.len + MLX5E_EEPROM_PAGE_LENGTH,
 592                     M_MLX5EN, M_WAITOK | M_ZERO);
 593
 594                 /* Read the whole eeprom information */
 595                 error = mlx5e_get_eeprom(priv, &eeprom);
 596                 if (error) {
 597                         if_printf(priv->ifp, "%s:%d: Failed reading eeprom\n",
 598                             __func__, __LINE__);
 599                         error = 0;
 600                         /*
 601                          * Continue printing partial information in case of
 602                          * an error
 603                          */
 604                 }
 605                 mlx5e_print_eeprom(&eeprom);
 606                 free(eeprom.data, M_MLX5EN);
 607         }
 608 done:
 609         PRIV_UNLOCK(priv);
 610         return (error);
 611 }
 612
 613 static const char *mlx5e_params_desc[] = {
 614         MLX5E_PARAMS(MLX5E_STATS_DESC)
 615 };
 616
 617 static const char *mlx5e_port_stats_debug_desc[] = {
 618         MLX5E_PORT_STATS_DEBUG(MLX5E_STATS_DESC)
 619 };
 620
 621 static int
 622 mlx5e_ethtool_debug_stats(SYSCTL_HANDLER_ARGS)
 623 {
 624         struct mlx5e_priv *priv = arg1;
 625         int error;
 626         int sys_debug;
 627
 628         sys_debug = priv->sysctl_debug;
 629         error = sysctl_handle_int(oidp, &priv->sysctl_debug, 0, req);
 630         if (error || !req->newptr)
 631                 return (error);
 632         priv->sysctl_debug = !!priv->sysctl_debug;
 633         if (sys_debug == priv->sysctl_debug)
 634                 return (error);
 635         if (priv->sysctl_debug)
 636                 mlx5e_create_stats(&priv->stats.port_stats_debug.ctx,
 637                     SYSCTL_CHILDREN(priv->sysctl_ifnet), "debug_stats",
 638                     mlx5e_port_stats_debug_desc, MLX5E_PORT_STATS_DEBUG_NUM,
 639                     priv->stats.port_stats_debug.arg);
 640         else
 641                 sysctl_ctx_free(&priv->stats.port_stats_debug.ctx);
 642         return (error);
 643 }
 644
 645 static void
 646 mlx5e_create_diagnostics(struct mlx5e_priv *priv)
 647 {
 648         struct mlx5_core_diagnostics_entry entry;
 649         struct sysctl_ctx_list *ctx;
 650         struct sysctl_oid *node;
 651         int x;
 652
 653         /* sysctl context we are using */
 654         ctx = &priv->sysctl_ctx;
 655
 656         /* create root node */
 657         node = SYSCTL_ADD_NODE(ctx,
 658             SYSCTL_CHILDREN(priv->sysctl_ifnet), OID_AUTO,
 659             "diagnostics", CTLFLAG_RD, NULL, "Diagnostics");
 660         if (node == NULL)
 661                 return;
 662
 663         /* create PCI diagnostics */
 664         for (x = 0; x != MLX5_CORE_PCI_DIAGNOSTICS_NUM; x++) {
 665                 entry = mlx5_core_pci_diagnostics_table[x];
 666                 if (mlx5_core_supports_diagnostics(priv->mdev, entry.counter_id) == 0)
 667                         continue;
 668                 SYSCTL_ADD_UQUAD(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
 669                     entry.desc, CTLFLAG_RD, priv->params_pci.array + x,
 670                     "PCI diagnostics counter");
 671         }
 672
 673         /* create general diagnostics */
 674         for (x = 0; x != MLX5_CORE_GENERAL_DIAGNOSTICS_NUM; x++) {
 675                 entry = mlx5_core_general_diagnostics_table[x];
 676                 if (mlx5_core_supports_diagnostics(priv->mdev, entry.counter_id) == 0)
 677                         continue;
 678                 SYSCTL_ADD_UQUAD(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
 679                     entry.desc, CTLFLAG_RD, priv->params_general.array + x,
 680                     "General diagnostics counter");
 681         }
 682 }
 683
 684 void
 685 mlx5e_create_ethtool(struct mlx5e_priv *priv)
 686 {
 687         struct sysctl_oid *node;
 688         const char *pnameunit;
 689         unsigned x;
 690
 691         /* set some defaults */
 692         priv->params_ethtool.tx_queue_size_max = 1 << MLX5E_PARAMS_MAXIMUM_LOG_SQ_SIZE;
 693         priv->params_ethtool.rx_queue_size_max = 1 << MLX5E_PARAMS_MAXIMUM_LOG_RQ_SIZE;
 694         priv->params_ethtool.tx_queue_size = 1 << priv->params.log_sq_size;
 695         priv->params_ethtool.rx_queue_size = 1 << priv->params.log_rq_size;
 696         priv->params_ethtool.channels = priv->params.num_channels;
 697         priv->params_ethtool.coalesce_pkts_max = MLX5E_FLD_MAX(cqc, cq_max_count);
 698         priv->params_ethtool.coalesce_usecs_max = MLX5E_FLD_MAX(cqc, cq_period);
 699         priv->params_ethtool.rx_coalesce_mode = priv->params.rx_cq_moderation_mode;
 700         priv->params_ethtool.rx_coalesce_usecs = priv->params.rx_cq_moderation_usec;
 701         priv->params_ethtool.rx_coalesce_pkts = priv->params.rx_cq_moderation_pkts;
 702         priv->params_ethtool.tx_coalesce_mode = priv->params.tx_cq_moderation_mode;
 703         priv->params_ethtool.tx_coalesce_usecs = priv->params.tx_cq_moderation_usec;
 704         priv->params_ethtool.tx_coalesce_pkts = priv->params.tx_cq_moderation_pkts;
 705         priv->params_ethtool.hw_lro = priv->params.hw_lro_en;
 706         priv->params_ethtool.cqe_zipping = priv->params.cqe_zipping_en;
 707         mlx5e_ethtool_sync_tx_completion_fact(priv);
 708
 709         /* create root node */
 710         node = SYSCTL_ADD_NODE(&priv->sysctl_ctx,
 711             SYSCTL_CHILDREN(priv->sysctl_ifnet), OID_AUTO,
 712             "conf", CTLFLAG_RW, NULL, "Configuration");
 713         if (node == NULL)
 714                 return;
 715         for (x = 0; x != MLX5E_PARAMS_NUM; x++) {
 716                 /* check for read-only parameter */
 717                 if (strstr(mlx5e_params_desc[2 * x], "_max") != NULL ||
 718                     strstr(mlx5e_params_desc[2 * x], "_mtu") != NULL) {
 719                         SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(node), OID_AUTO,
 720                             mlx5e_params_desc[2 * x], CTLTYPE_U64 | CTLFLAG_RD |
 721                             CTLFLAG_MPSAFE, priv, x, &mlx5e_ethtool_handler, "QU",
 722                             mlx5e_params_desc[2 * x + 1]);
 723                 } else {
 724 #if (__FreeBSD_version < 1100000)
 725                         char path[64];
 726 #endif
 727                         /*
 728                          * NOTE: In FreeBSD-11 and newer the
 729                          * CTLFLAG_RWTUN flag will take care of
 730                          * loading default sysctl value from the
 731                          * kernel environment, if any:
 732                          */
 733                         SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(node), OID_AUTO,
 734                             mlx5e_params_desc[2 * x], CTLTYPE_U64 | CTLFLAG_RWTUN |
 735                             CTLFLAG_MPSAFE, priv, x, &mlx5e_ethtool_handler, "QU",
 736                             mlx5e_params_desc[2 * x + 1]);
 737
 738 #if (__FreeBSD_version < 1100000)
 739                         /* compute path for sysctl */
 740                         snprintf(path, sizeof(path), "dev.mce.%d.conf.%s",
 741                             device_get_unit(priv->mdev->pdev->dev.bsddev),
 742                             mlx5e_params_desc[2 * x]);
 743
 744                         /* try to fetch tunable, if any */
 745                         if (TUNABLE_QUAD_FETCH(path, &priv->params_ethtool.arg[x]))
 746                                 mlx5e_ethtool_handler(NULL, priv, x, NULL);
 747 #endif
 748                 }
 749         }
 750
 751         SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(node), OID_AUTO,
 752             "debug_stats", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, priv,
 753             0, &mlx5e_ethtool_debug_stats, "I", "Extended debug statistics");
 754
 755         pnameunit = device_get_nameunit(priv->mdev->pdev->dev.bsddev);
 756
 757         SYSCTL_ADD_STRING(&priv->sysctl_ctx, SYSCTL_CHILDREN(node),
 758             OID_AUTO, "device_name", CTLFLAG_RD,
 759             __DECONST(void *, pnameunit), 0,
 760             "PCI device name");
 761
 762         /* EEPROM support */
 763         SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(node), OID_AUTO, "eeprom_info",
 764             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, priv, 0,
 765             mlx5e_read_eeprom, "I", "EEPROM information");
 766
 767         /* Diagnostics support */
 768         mlx5e_create_diagnostics(priv);
 769 }