drivers/net/sfc/sfc_port.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright(c) 2019-2021 Xilinx, Inc.
   4  * Copyright(c) 2016-2019 Solarflare Communications Inc.
   5  *
   6  * This software was jointly developed between OKTET Labs (under contract
   7  * for Solarflare) and Solarflare Communications, Inc.
   8  */
   9
  10 #include <rte_bitmap.h>
  11
  12 #include "efx.h"
  13
  14 #include "sfc.h"
  15 #include "sfc_debug.h"
  16 #include "sfc_log.h"
  17 #include "sfc_kvargs.h"
  18
  19 /** Default MAC statistics update period is 1 second */
  20 #define SFC_MAC_STATS_UPDATE_PERIOD_MS_DEF      MS_PER_S
  21
  22 /** The number of microseconds to sleep on attempt to get statistics update */
  23 #define SFC_MAC_STATS_UPDATE_RETRY_INTERVAL_US  10
  24
  25 /** The number of attempts to await arrival of freshly generated statistics */
  26 #define SFC_MAC_STATS_UPDATE_NB_ATTEMPTS        50
  27
  28 /**
  29  * Update MAC statistics in the buffer.
  30  *
  31  * @param       sa              Adapter
  32  * @param       force_upload    Flag to upload MAC stats in any case
  33  *
  34  * @return Status code
  35  * @retval      0       Success
  36  * @retval      EAGAIN  Try again
  37  * @retval      ENOMEM  Memory allocation failure
  38  */
  39 int
  40 sfc_port_update_mac_stats(struct sfc_adapter *sa, boolean_t force_upload)
  41 {
  42         struct sfc_port *port = &sa->port;
  43         efsys_mem_t *esmp = &port->mac_stats_dma_mem;
  44         uint32_t *genp = NULL;
  45         uint32_t gen_old;
  46         unsigned int nb_attempts = 0;
  47         int rc;
  48
  49         SFC_ASSERT(sfc_adapter_is_locked(sa));
  50
  51         if (sa->state != SFC_ETHDEV_STARTED)
  52                 return 0;
  53
  54         /*
  55          * If periodic statistics DMA'ing is off or if not supported,
  56          * make a manual request and keep an eye on timer if need be
  57          */
  58         if (!port->mac_stats_periodic_dma_supported ||
  59             (port->mac_stats_update_period_ms == 0) || force_upload) {
  60                 if (port->mac_stats_update_period_ms != 0) {
  61                         uint64_t timestamp = sfc_get_system_msecs();
  62
  63                         if ((timestamp -
  64                              port->mac_stats_last_request_timestamp) <
  65                             port->mac_stats_update_period_ms)
  66                                 return 0;
  67
  68                         port->mac_stats_last_request_timestamp = timestamp;
  69                 }
  70
  71                 rc = efx_mac_stats_upload(sa->nic, esmp);
  72                 if (rc != 0)
  73                         return rc;
  74
  75                 genp = &port->mac_stats_update_generation;
  76                 gen_old = *genp;
  77         }
  78
  79         do {
  80                 if (nb_attempts > 0)
  81                         rte_delay_us(SFC_MAC_STATS_UPDATE_RETRY_INTERVAL_US);
  82
  83                 rc = efx_mac_stats_update(sa->nic, esmp,
  84                                           port->mac_stats_buf, genp);
  85                 if (rc != 0)
  86                         return rc;
  87
  88         } while ((genp != NULL) && (*genp == gen_old) &&
  89                  (++nb_attempts < SFC_MAC_STATS_UPDATE_NB_ATTEMPTS));
  90
  91         return 0;
  92 }
  93
  94 static void
  95 sfc_port_reset_sw_stats(struct sfc_adapter *sa)
  96 {
  97         struct sfc_port *port = &sa->port;
  98
  99         /*
 100          * Reset diff stats explicitly since check which does not allow
 101          * the statistics to grow backward could deny it.
 102          */
 103         port->ipackets = 0;
 104 }
 105
 106 int
 107 sfc_port_reset_mac_stats(struct sfc_adapter *sa)
 108 {
 109         int rc;
 110
 111         SFC_ASSERT(sfc_adapter_is_locked(sa));
 112
 113         rc = efx_mac_stats_clear(sa->nic);
 114         if (rc == 0)
 115                 sfc_port_reset_sw_stats(sa);
 116
 117         return rc;
 118 }
 119
 120 static int
 121 sfc_port_init_dev_link(struct sfc_adapter *sa)
 122 {
 123         struct rte_eth_link *dev_link = &sa->eth_dev->data->dev_link;
 124         int rc;
 125         efx_link_mode_t link_mode;
 126         struct rte_eth_link current_link;
 127
 128         rc = efx_port_poll(sa->nic, &link_mode);
 129         if (rc != 0)
 130                 return rc;
 131
 132         sfc_port_link_mode_to_info(link_mode, &current_link);
 133
 134         EFX_STATIC_ASSERT(sizeof(*dev_link) == sizeof(rte_atomic64_t));
 135         rte_atomic64_set((rte_atomic64_t *)dev_link,
 136                          *(uint64_t *)&current_link);
 137
 138         return 0;
 139 }
 140
 141 #if EFSYS_OPT_LOOPBACK
 142
 143 static efx_link_mode_t
 144 sfc_port_phy_caps_to_max_link_speed(uint32_t phy_caps)
 145 {
 146         if (phy_caps & (1u << EFX_PHY_CAP_100000FDX))
 147                 return EFX_LINK_100000FDX;
 148         if (phy_caps & (1u << EFX_PHY_CAP_50000FDX))
 149                 return EFX_LINK_50000FDX;
 150         if (phy_caps & (1u << EFX_PHY_CAP_40000FDX))
 151                 return EFX_LINK_40000FDX;
 152         if (phy_caps & (1u << EFX_PHY_CAP_25000FDX))
 153                 return EFX_LINK_25000FDX;
 154         if (phy_caps & (1u << EFX_PHY_CAP_10000FDX))
 155                 return EFX_LINK_10000FDX;
 156         if (phy_caps & (1u << EFX_PHY_CAP_1000FDX))
 157                 return EFX_LINK_1000FDX;
 158         return EFX_LINK_UNKNOWN;
 159 }
 160
 161 #endif
 162
 163 static void
 164 sfc_port_fill_mac_stats_info(struct sfc_adapter *sa)
 165 {
 166         unsigned int mac_stats_nb_supported = 0;
 167         struct sfc_port *port = &sa->port;
 168         unsigned int stat_idx;
 169
 170         efx_mac_stats_get_mask(sa->nic, port->mac_stats_mask,
 171                                sizeof(port->mac_stats_mask));
 172
 173         for (stat_idx = 0; stat_idx < EFX_MAC_NSTATS; ++stat_idx) {
 174                 if (!EFX_MAC_STAT_SUPPORTED(port->mac_stats_mask, stat_idx))
 175                         continue;
 176
 177                 port->mac_stats_by_id[mac_stats_nb_supported] = stat_idx;
 178                 mac_stats_nb_supported++;
 179         }
 180
 181         port->mac_stats_nb_supported = mac_stats_nb_supported;
 182 }
 183
 184 int
 185 sfc_port_start(struct sfc_adapter *sa)
 186 {
 187         struct sfc_port *port = &sa->port;
 188         int rc;
 189         uint32_t phy_adv_cap;
 190         const uint32_t phy_pause_caps =
 191                 ((1u << EFX_PHY_CAP_PAUSE) | (1u << EFX_PHY_CAP_ASYM));
 192
 193         sfc_log_init(sa, "entry");
 194
 195         sfc_log_init(sa, "init filters");
 196         rc = efx_filter_init(sa->nic);
 197         if (rc != 0)
 198                 goto fail_filter_init;
 199
 200         sfc_log_init(sa, "init port");
 201         rc = efx_port_init(sa->nic);
 202         if (rc != 0)
 203                 goto fail_port_init;
 204
 205 #if EFSYS_OPT_LOOPBACK
 206         if (sa->eth_dev->data->dev_conf.lpbk_mode != 0) {
 207                 efx_link_mode_t link_mode;
 208
 209                 link_mode =
 210                         sfc_port_phy_caps_to_max_link_speed(port->phy_adv_cap);
 211                 sfc_log_init(sa, "set loopback link_mode=%u type=%u", link_mode,
 212                              sa->eth_dev->data->dev_conf.lpbk_mode);
 213                 rc = efx_port_loopback_set(sa->nic, link_mode,
 214                         sa->eth_dev->data->dev_conf.lpbk_mode);
 215                 if (rc != 0)
 216                         goto fail_loopback_set;
 217         }
 218 #endif
 219
 220         sfc_log_init(sa, "set flow control to %#x autoneg=%u",
 221                      port->flow_ctrl, port->flow_ctrl_autoneg);
 222         rc = efx_mac_fcntl_set(sa->nic, port->flow_ctrl,
 223                                port->flow_ctrl_autoneg);
 224         if (rc != 0)
 225                 goto fail_mac_fcntl_set;
 226
 227         /* Preserve pause capabilities set by above efx_mac_fcntl_set()  */
 228         efx_phy_adv_cap_get(sa->nic, EFX_PHY_CAP_CURRENT, &phy_adv_cap);
 229         SFC_ASSERT((port->phy_adv_cap & phy_pause_caps) == 0);
 230         phy_adv_cap = port->phy_adv_cap | (phy_adv_cap & phy_pause_caps);
 231
 232         /*
 233          * No controls for FEC yet. Use default FEC mode.
 234          * I.e. advertise everything supported (*_FEC=1), but do not request
 235          * anything explicitly (*_FEC_REQUESTED=0).
 236          */
 237         phy_adv_cap |= port->phy_adv_cap_mask &
 238                 (1u << EFX_PHY_CAP_BASER_FEC |
 239                  1u << EFX_PHY_CAP_RS_FEC |
 240                  1u << EFX_PHY_CAP_25G_BASER_FEC);
 241
 242         sfc_log_init(sa, "set phy adv caps to %#x", phy_adv_cap);
 243         rc = efx_phy_adv_cap_set(sa->nic, phy_adv_cap);
 244         if (rc != 0)
 245                 goto fail_phy_adv_cap_set;
 246
 247         sfc_log_init(sa, "set MAC PDU %u", (unsigned int)port->pdu);
 248         rc = efx_mac_pdu_set(sa->nic, port->pdu);
 249         if (rc != 0)
 250                 goto fail_mac_pdu_set;
 251
 252         if (!sfc_sa2shared(sa)->isolated) {
 253                 struct rte_ether_addr *addr = &port->default_mac_addr;
 254
 255                 sfc_log_init(sa, "set MAC address");
 256                 rc = efx_mac_addr_set(sa->nic, addr->addr_bytes);
 257                 if (rc != 0)
 258                         goto fail_mac_addr_set;
 259
 260                 sfc_log_init(sa, "set MAC filters");
 261                 port->promisc = (sa->eth_dev->data->promiscuous != 0) ?
 262                                 B_TRUE : B_FALSE;
 263                 port->allmulti = (sa->eth_dev->data->all_multicast != 0) ?
 264                                  B_TRUE : B_FALSE;
 265                 rc = sfc_set_rx_mode_unchecked(sa);
 266                 if (rc != 0)
 267                         goto fail_mac_filter_set;
 268
 269                 sfc_log_init(sa, "set multicast address list");
 270                 rc = efx_mac_multicast_list_set(sa->nic, port->mcast_addrs,
 271                                                 port->nb_mcast_addrs);
 272                 if (rc != 0)
 273                         goto fail_mcast_address_list_set;
 274         }
 275
 276         if (port->mac_stats_reset_pending) {
 277                 rc = sfc_port_reset_mac_stats(sa);
 278                 if (rc != 0)
 279                         sfc_err(sa, "statistics reset failed (requested "
 280                                     "before the port was started)");
 281
 282                 port->mac_stats_reset_pending = B_FALSE;
 283         }
 284
 285         sfc_port_fill_mac_stats_info(sa);
 286
 287         port->mac_stats_update_generation = 0;
 288
 289         if (port->mac_stats_update_period_ms != 0) {
 290                 /*
 291                  * Update MAC stats using periodic DMA;
 292                  * any positive update interval different from
 293                  * 1000 ms can be set only on SFN8xxx provided
 294                  * that FW version is 6.2.1.1033 or higher
 295                  */
 296                 sfc_log_init(sa, "request MAC stats DMA'ing");
 297                 rc = efx_mac_stats_periodic(sa->nic, &port->mac_stats_dma_mem,
 298                                             port->mac_stats_update_period_ms,
 299                                             B_FALSE);
 300                 if (rc == 0) {
 301                         port->mac_stats_periodic_dma_supported = B_TRUE;
 302                 } else if (rc == EOPNOTSUPP) {
 303                         port->mac_stats_periodic_dma_supported = B_FALSE;
 304                         port->mac_stats_last_request_timestamp = 0;
 305                 } else {
 306                         goto fail_mac_stats_periodic;
 307                 }
 308         }
 309
 310         if ((port->mac_stats_update_period_ms != 0) &&
 311             port->mac_stats_periodic_dma_supported) {
 312                 /*
 313                  * Request an explicit MAC stats upload immediately to
 314                  * preclude bogus figures readback if the user decides
 315                  * to read stats before periodic DMA is really started
 316                  */
 317                 rc = efx_mac_stats_upload(sa->nic, &port->mac_stats_dma_mem);
 318                 if (rc != 0)
 319                         goto fail_mac_stats_upload;
 320         }
 321
 322         sfc_log_init(sa, "disable MAC drain");
 323         rc = efx_mac_drain(sa->nic, B_FALSE);
 324         if (rc != 0)
 325                 goto fail_mac_drain;
 326
 327         /* Synchronize link status knowledge */
 328         rc = sfc_port_init_dev_link(sa);
 329         if (rc != 0)
 330                 goto fail_port_init_dev_link;
 331
 332         sfc_log_init(sa, "done");
 333         return 0;
 334
 335 fail_port_init_dev_link:
 336         (void)efx_mac_drain(sa->nic, B_TRUE);
 337
 338 fail_mac_drain:
 339 fail_mac_stats_upload:
 340         (void)efx_mac_stats_periodic(sa->nic, &port->mac_stats_dma_mem,
 341                                      0, B_FALSE);
 342
 343 fail_mac_stats_periodic:
 344 fail_mcast_address_list_set:
 345 fail_mac_filter_set:
 346 fail_mac_addr_set:
 347 fail_mac_pdu_set:
 348 fail_phy_adv_cap_set:
 349 fail_mac_fcntl_set:
 350 #if EFSYS_OPT_LOOPBACK
 351 fail_loopback_set:
 352 #endif
 353         efx_port_fini(sa->nic);
 354
 355 fail_port_init:
 356         efx_filter_fini(sa->nic);
 357
 358 fail_filter_init:
 359         sfc_log_init(sa, "failed %d", rc);
 360         return rc;
 361 }
 362
 363 void
 364 sfc_port_stop(struct sfc_adapter *sa)
 365 {
 366         sfc_log_init(sa, "entry");
 367
 368         efx_mac_drain(sa->nic, B_TRUE);
 369
 370         (void)efx_mac_stats_periodic(sa->nic, &sa->port.mac_stats_dma_mem,
 371                                      0, B_FALSE);
 372
 373         sfc_port_update_mac_stats(sa, B_TRUE);
 374
 375         efx_port_fini(sa->nic);
 376         efx_filter_fini(sa->nic);
 377
 378         sfc_log_init(sa, "done");
 379 }
 380
 381 int
 382 sfc_port_configure(struct sfc_adapter *sa)
 383 {
 384         const struct rte_eth_dev_data *dev_data = sa->eth_dev->data;
 385         struct sfc_port *port = &sa->port;
 386
 387         sfc_log_init(sa, "entry");
 388
 389         port->pdu = EFX_MAC_PDU(dev_data->mtu);
 390
 391         return 0;
 392 }
 393
 394 void
 395 sfc_port_close(struct sfc_adapter *sa)
 396 {
 397         sfc_log_init(sa, "entry");
 398 }
 399
 400 int
 401 sfc_port_attach(struct sfc_adapter *sa)
 402 {
 403         struct sfc_port *port = &sa->port;
 404         const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic);
 405         const struct rte_ether_addr *from;
 406         uint32_t mac_nstats;
 407         size_t mac_stats_size;
 408         long kvarg_stats_update_period_ms;
 409         int rc;
 410
 411         sfc_log_init(sa, "entry");
 412
 413         efx_phy_adv_cap_get(sa->nic, EFX_PHY_CAP_PERM, &port->phy_adv_cap_mask);
 414
 415         /* Enable flow control by default */
 416         port->flow_ctrl = EFX_FCNTL_RESPOND | EFX_FCNTL_GENERATE;
 417         port->flow_ctrl_autoneg = B_TRUE;
 418
 419         RTE_BUILD_BUG_ON(sizeof(encp->enc_mac_addr) != sizeof(*from));
 420         from = (const struct rte_ether_addr *)(encp->enc_mac_addr);
 421         rte_ether_addr_copy(from, &port->default_mac_addr);
 422
 423         port->max_mcast_addrs = EFX_MAC_MULTICAST_LIST_MAX;
 424         port->nb_mcast_addrs = 0;
 425         port->mcast_addrs = rte_calloc_socket("mcast_addr_list_buf",
 426                                               port->max_mcast_addrs,
 427                                               EFX_MAC_ADDR_LEN, 0,
 428                                               sa->socket_id);
 429         if (port->mcast_addrs == NULL) {
 430                 rc = ENOMEM;
 431                 goto fail_mcast_addr_list_buf_alloc;
 432         }
 433
 434         rc = ENOMEM;
 435         port->mac_stats_buf = rte_calloc_socket("mac_stats_buf", EFX_MAC_NSTATS,
 436                                                 sizeof(uint64_t), 0,
 437                                                 sa->socket_id);
 438         if (port->mac_stats_buf == NULL)
 439                 goto fail_mac_stats_buf_alloc;
 440
 441         mac_nstats = efx_nic_cfg_get(sa->nic)->enc_mac_stats_nstats;
 442         mac_stats_size = RTE_ALIGN(mac_nstats * sizeof(uint64_t), EFX_BUF_SIZE);
 443         rc = sfc_dma_alloc(sa, "mac_stats", 0, mac_stats_size,
 444                            sa->socket_id, &port->mac_stats_dma_mem);
 445         if (rc != 0)
 446                 goto fail_mac_stats_dma_alloc;
 447
 448         port->mac_stats_reset_pending = B_FALSE;
 449
 450         kvarg_stats_update_period_ms = SFC_MAC_STATS_UPDATE_PERIOD_MS_DEF;
 451
 452         rc = sfc_kvargs_process(sa, SFC_KVARG_STATS_UPDATE_PERIOD_MS,
 453                                 sfc_kvarg_long_handler,
 454                                 &kvarg_stats_update_period_ms);
 455         if ((rc == 0) &&
 456             ((kvarg_stats_update_period_ms < 0) ||
 457              (kvarg_stats_update_period_ms > UINT16_MAX))) {
 458                 sfc_err(sa, "wrong '" SFC_KVARG_STATS_UPDATE_PERIOD_MS "' "
 459                             "was set (%ld);", kvarg_stats_update_period_ms);
 460                 sfc_err(sa, "it must not be less than 0 "
 461                             "or greater than %" PRIu16, UINT16_MAX);
 462                 rc = EINVAL;
 463                 goto fail_kvarg_stats_update_period_ms;
 464         } else if (rc != 0) {
 465                 goto fail_kvarg_stats_update_period_ms;
 466         }
 467
 468         port->mac_stats_update_period_ms = kvarg_stats_update_period_ms;
 469
 470         sfc_log_init(sa, "done");
 471         return 0;
 472
 473 fail_kvarg_stats_update_period_ms:
 474         sfc_dma_free(sa, &port->mac_stats_dma_mem);
 475
 476 fail_mac_stats_dma_alloc:
 477         rte_free(port->mac_stats_buf);
 478
 479 fail_mac_stats_buf_alloc:
 480         rte_free(port->mcast_addrs);
 481
 482 fail_mcast_addr_list_buf_alloc:
 483         sfc_log_init(sa, "failed %d", rc);
 484         return rc;
 485 }
 486
 487 void
 488 sfc_port_detach(struct sfc_adapter *sa)
 489 {
 490         struct sfc_port *port = &sa->port;
 491
 492         sfc_log_init(sa, "entry");
 493
 494         sfc_dma_free(sa, &port->mac_stats_dma_mem);
 495         rte_free(port->mac_stats_buf);
 496
 497         rte_free(port->mcast_addrs);
 498
 499         sfc_log_init(sa, "done");
 500 }
 501
 502 static boolean_t
 503 sfc_get_requested_all_ucast(struct sfc_port *port)
 504 {
 505         return port->promisc;
 506 }
 507
 508 static boolean_t
 509 sfc_get_requested_all_mcast(struct sfc_port *port)
 510 {
 511         return port->promisc || port->allmulti;
 512 }
 513
 514 int
 515 sfc_set_rx_mode_unchecked(struct sfc_adapter *sa)
 516 {
 517         struct sfc_port *port = &sa->port;
 518         boolean_t requested_all_ucast = sfc_get_requested_all_ucast(port);
 519         boolean_t requested_all_mcast = sfc_get_requested_all_mcast(port);
 520         int rc;
 521
 522         rc = efx_mac_filter_set(sa->nic, requested_all_ucast, B_TRUE,
 523                                 requested_all_mcast, B_TRUE);
 524         if (rc != 0)
 525                 return rc;
 526
 527         return 0;
 528 }
 529
 530 int
 531 sfc_set_rx_mode(struct sfc_adapter *sa)
 532 {
 533         struct sfc_port *port = &sa->port;
 534         boolean_t old_all_ucast;
 535         boolean_t old_all_mcast;
 536         boolean_t requested_all_ucast = sfc_get_requested_all_ucast(port);
 537         boolean_t requested_all_mcast = sfc_get_requested_all_mcast(port);
 538         boolean_t actual_all_ucast;
 539         boolean_t actual_all_mcast;
 540         int rc;
 541
 542         efx_mac_filter_get_all_ucast_mcast(sa->nic, &old_all_ucast,
 543                                            &old_all_mcast);
 544
 545         rc = sfc_set_rx_mode_unchecked(sa);
 546         if (rc != 0)
 547                 return rc;
 548
 549         efx_mac_filter_get_all_ucast_mcast(sa->nic, &actual_all_ucast,
 550                                            &actual_all_mcast);
 551
 552         if (actual_all_ucast != requested_all_ucast ||
 553             actual_all_mcast != requested_all_mcast) {
 554                 /*
 555                  * MAC filter set succeeded but not all requested modes
 556                  * were applied. The rollback is necessary to bring back the
 557                  * consistent old state.
 558                  */
 559                 (void)efx_mac_filter_set(sa->nic, old_all_ucast, B_TRUE,
 560                                          old_all_mcast, B_TRUE);
 561
 562                 return EPERM;
 563         }
 564
 565         return 0;
 566 }
 567
 568 void
 569 sfc_port_link_mode_to_info(efx_link_mode_t link_mode,
 570                            struct rte_eth_link *link_info)
 571 {
 572         SFC_ASSERT(link_mode < EFX_LINK_NMODES);
 573
 574         memset(link_info, 0, sizeof(*link_info));
 575         if ((link_mode == EFX_LINK_DOWN) || (link_mode == EFX_LINK_UNKNOWN))
 576                 link_info->link_status = ETH_LINK_DOWN;
 577         else
 578                 link_info->link_status = ETH_LINK_UP;
 579
 580         switch (link_mode) {
 581         case EFX_LINK_10HDX:
 582                 link_info->link_speed  = ETH_SPEED_NUM_10M;
 583                 link_info->link_duplex = ETH_LINK_HALF_DUPLEX;
 584                 break;
 585         case EFX_LINK_10FDX:
 586                 link_info->link_speed  = ETH_SPEED_NUM_10M;
 587                 link_info->link_duplex = ETH_LINK_FULL_DUPLEX;
 588                 break;
 589         case EFX_LINK_100HDX:
 590                 link_info->link_speed  = ETH_SPEED_NUM_100M;
 591                 link_info->link_duplex = ETH_LINK_HALF_DUPLEX;
 592                 break;
 593         case EFX_LINK_100FDX:
 594                 link_info->link_speed  = ETH_SPEED_NUM_100M;
 595                 link_info->link_duplex = ETH_LINK_FULL_DUPLEX;
 596                 break;
 597         case EFX_LINK_1000HDX:
 598                 link_info->link_speed  = ETH_SPEED_NUM_1G;
 599                 link_info->link_duplex = ETH_LINK_HALF_DUPLEX;
 600                 break;
 601         case EFX_LINK_1000FDX:
 602                 link_info->link_speed  = ETH_SPEED_NUM_1G;
 603                 link_info->link_duplex = ETH_LINK_FULL_DUPLEX;
 604                 break;
 605         case EFX_LINK_10000FDX:
 606                 link_info->link_speed  = ETH_SPEED_NUM_10G;
 607                 link_info->link_duplex = ETH_LINK_FULL_DUPLEX;
 608                 break;
 609         case EFX_LINK_25000FDX:
 610                 link_info->link_speed  = ETH_SPEED_NUM_25G;
 611                 link_info->link_duplex = ETH_LINK_FULL_DUPLEX;
 612                 break;
 613         case EFX_LINK_40000FDX:
 614                 link_info->link_speed  = ETH_SPEED_NUM_40G;
 615                 link_info->link_duplex = ETH_LINK_FULL_DUPLEX;
 616                 break;
 617         case EFX_LINK_50000FDX:
 618                 link_info->link_speed  = ETH_SPEED_NUM_50G;
 619                 link_info->link_duplex = ETH_LINK_FULL_DUPLEX;
 620                 break;
 621         case EFX_LINK_100000FDX:
 622                 link_info->link_speed  = ETH_SPEED_NUM_100G;
 623                 link_info->link_duplex = ETH_LINK_FULL_DUPLEX;
 624                 break;
 625         default:
 626                 SFC_ASSERT(B_FALSE);
 627                 /* FALLTHROUGH */
 628         case EFX_LINK_UNKNOWN:
 629         case EFX_LINK_DOWN:
 630                 link_info->link_speed  = ETH_SPEED_NUM_NONE;
 631                 link_info->link_duplex = 0;
 632                 break;
 633         }
 634
 635         link_info->link_autoneg = ETH_LINK_AUTONEG;
 636 }
 637
 638 int
 639 sfc_port_get_mac_stats(struct sfc_adapter *sa, struct rte_eth_xstat *xstats,
 640                        unsigned int xstats_count, unsigned int *nb_written)
 641 {
 642         struct sfc_port *port = &sa->port;
 643         uint64_t *mac_stats;
 644         unsigned int i;
 645         int nstats = 0;
 646         int ret;
 647
 648         sfc_adapter_lock(sa);
 649
 650         ret = sfc_port_update_mac_stats(sa, B_FALSE);
 651         if (ret != 0) {
 652                 SFC_ASSERT(ret > 0);
 653                 ret = -ret;
 654                 goto unlock;
 655         }
 656
 657         mac_stats = port->mac_stats_buf;
 658
 659         for (i = 0; i < EFX_MAC_NSTATS; ++i) {
 660                 if (EFX_MAC_STAT_SUPPORTED(port->mac_stats_mask, i)) {
 661                         if (nstats < (int)xstats_count) {
 662                                 xstats[nstats].id = nstats;
 663                                 xstats[nstats].value = mac_stats[i];
 664                                 (*nb_written)++;
 665                         }
 666                         nstats++;
 667                 }
 668         }
 669         ret = nstats;
 670
 671 unlock:
 672         sfc_adapter_unlock(sa);
 673
 674         return ret;
 675 }
 676
 677 int
 678 sfc_port_get_mac_stats_by_id(struct sfc_adapter *sa, const uint64_t *ids,
 679                              uint64_t *values, unsigned int n)
 680 {
 681         struct sfc_port *port = &sa->port;
 682         uint64_t *mac_stats;
 683         unsigned int i;
 684         int ret;
 685         int rc;
 686
 687         sfc_adapter_lock(sa);
 688
 689         rc = sfc_port_update_mac_stats(sa, B_FALSE);
 690         if (rc != 0) {
 691                 SFC_ASSERT(rc > 0);
 692                 ret = -rc;
 693                 goto unlock;
 694         }
 695
 696         mac_stats = port->mac_stats_buf;
 697
 698         SFC_ASSERT(port->mac_stats_nb_supported <=
 699                    RTE_DIM(port->mac_stats_by_id));
 700
 701         for (i = 0; i < n; i++) {
 702                 if (ids[i] < port->mac_stats_nb_supported)
 703                         values[i] = mac_stats[port->mac_stats_by_id[ids[i]]];
 704         }
 705
 706         ret = 0;
 707
 708 unlock:
 709         sfc_adapter_unlock(sa);
 710
 711         return ret;
 712 }