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, EFX_NIC_DMA_ADDR_MAC_STATS_BUF,
 444                            mac_stats_size,
 445                            sa->socket_id, &port->mac_stats_dma_mem);
 446         if (rc != 0)
 447                 goto fail_mac_stats_dma_alloc;
 448
 449         port->mac_stats_reset_pending = B_FALSE;
 450
 451         kvarg_stats_update_period_ms = SFC_MAC_STATS_UPDATE_PERIOD_MS_DEF;
 452
 453         rc = sfc_kvargs_process(sa, SFC_KVARG_STATS_UPDATE_PERIOD_MS,
 454                                 sfc_kvarg_long_handler,
 455                                 &kvarg_stats_update_period_ms);
 456         if ((rc == 0) &&
 457             ((kvarg_stats_update_period_ms < 0) ||
 458              (kvarg_stats_update_period_ms > UINT16_MAX))) {
 459                 sfc_err(sa, "wrong '" SFC_KVARG_STATS_UPDATE_PERIOD_MS "' "
 460                             "was set (%ld);", kvarg_stats_update_period_ms);
 461                 sfc_err(sa, "it must not be less than 0 "
 462                             "or greater than %" PRIu16, UINT16_MAX);
 463                 rc = EINVAL;
 464                 goto fail_kvarg_stats_update_period_ms;
 465         } else if (rc != 0) {
 466                 goto fail_kvarg_stats_update_period_ms;
 467         }
 468
 469         port->mac_stats_update_period_ms = kvarg_stats_update_period_ms;
 470
 471         sfc_log_init(sa, "done");
 472         return 0;
 473
 474 fail_kvarg_stats_update_period_ms:
 475         sfc_dma_free(sa, &port->mac_stats_dma_mem);
 476
 477 fail_mac_stats_dma_alloc:
 478         rte_free(port->mac_stats_buf);
 479
 480 fail_mac_stats_buf_alloc:
 481         rte_free(port->mcast_addrs);
 482
 483 fail_mcast_addr_list_buf_alloc:
 484         sfc_log_init(sa, "failed %d", rc);
 485         return rc;
 486 }
 487
 488 void
 489 sfc_port_detach(struct sfc_adapter *sa)
 490 {
 491         struct sfc_port *port = &sa->port;
 492
 493         sfc_log_init(sa, "entry");
 494
 495         sfc_dma_free(sa, &port->mac_stats_dma_mem);
 496         rte_free(port->mac_stats_buf);
 497
 498         rte_free(port->mcast_addrs);
 499
 500         sfc_log_init(sa, "done");
 501 }
 502
 503 static boolean_t
 504 sfc_get_requested_all_ucast(struct sfc_port *port)
 505 {
 506         return port->promisc;
 507 }
 508
 509 static boolean_t
 510 sfc_get_requested_all_mcast(struct sfc_port *port)
 511 {
 512         return port->promisc || port->allmulti;
 513 }
 514
 515 int
 516 sfc_set_rx_mode_unchecked(struct sfc_adapter *sa)
 517 {
 518         struct sfc_port *port = &sa->port;
 519         boolean_t requested_all_ucast = sfc_get_requested_all_ucast(port);
 520         boolean_t requested_all_mcast = sfc_get_requested_all_mcast(port);
 521         int rc;
 522
 523         rc = efx_mac_filter_set(sa->nic, requested_all_ucast, B_TRUE,
 524                                 requested_all_mcast, B_TRUE);
 525         if (rc != 0)
 526                 return rc;
 527
 528         return 0;
 529 }
 530
 531 int
 532 sfc_set_rx_mode(struct sfc_adapter *sa)
 533 {
 534         struct sfc_port *port = &sa->port;
 535         boolean_t old_all_ucast;
 536         boolean_t old_all_mcast;
 537         boolean_t requested_all_ucast = sfc_get_requested_all_ucast(port);
 538         boolean_t requested_all_mcast = sfc_get_requested_all_mcast(port);
 539         boolean_t actual_all_ucast;
 540         boolean_t actual_all_mcast;
 541         int rc;
 542
 543         efx_mac_filter_get_all_ucast_mcast(sa->nic, &old_all_ucast,
 544                                            &old_all_mcast);
 545
 546         rc = sfc_set_rx_mode_unchecked(sa);
 547         if (rc != 0)
 548                 return rc;
 549
 550         efx_mac_filter_get_all_ucast_mcast(sa->nic, &actual_all_ucast,
 551                                            &actual_all_mcast);
 552
 553         if (actual_all_ucast != requested_all_ucast ||
 554             actual_all_mcast != requested_all_mcast) {
 555                 /*
 556                  * MAC filter set succeeded but not all requested modes
 557                  * were applied. The rollback is necessary to bring back the
 558                  * consistent old state.
 559                  */
 560                 (void)efx_mac_filter_set(sa->nic, old_all_ucast, B_TRUE,
 561                                          old_all_mcast, B_TRUE);
 562
 563                 return EPERM;
 564         }
 565
 566         return 0;
 567 }
 568
 569 void
 570 sfc_port_link_mode_to_info(efx_link_mode_t link_mode,
 571                            struct rte_eth_link *link_info)
 572 {
 573         SFC_ASSERT(link_mode < EFX_LINK_NMODES);
 574
 575         memset(link_info, 0, sizeof(*link_info));
 576         if ((link_mode == EFX_LINK_DOWN) || (link_mode == EFX_LINK_UNKNOWN))
 577                 link_info->link_status = RTE_ETH_LINK_DOWN;
 578         else
 579                 link_info->link_status = RTE_ETH_LINK_UP;
 580
 581         switch (link_mode) {
 582         case EFX_LINK_10HDX:
 583                 link_info->link_speed  = RTE_ETH_SPEED_NUM_10M;
 584                 link_info->link_duplex = RTE_ETH_LINK_HALF_DUPLEX;
 585                 break;
 586         case EFX_LINK_10FDX:
 587                 link_info->link_speed  = RTE_ETH_SPEED_NUM_10M;
 588                 link_info->link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
 589                 break;
 590         case EFX_LINK_100HDX:
 591                 link_info->link_speed  = RTE_ETH_SPEED_NUM_100M;
 592                 link_info->link_duplex = RTE_ETH_LINK_HALF_DUPLEX;
 593                 break;
 594         case EFX_LINK_100FDX:
 595                 link_info->link_speed  = RTE_ETH_SPEED_NUM_100M;
 596                 link_info->link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
 597                 break;
 598         case EFX_LINK_1000HDX:
 599                 link_info->link_speed  = RTE_ETH_SPEED_NUM_1G;
 600                 link_info->link_duplex = RTE_ETH_LINK_HALF_DUPLEX;
 601                 break;
 602         case EFX_LINK_1000FDX:
 603                 link_info->link_speed  = RTE_ETH_SPEED_NUM_1G;
 604                 link_info->link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
 605                 break;
 606         case EFX_LINK_10000FDX:
 607                 link_info->link_speed  = RTE_ETH_SPEED_NUM_10G;
 608                 link_info->link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
 609                 break;
 610         case EFX_LINK_25000FDX:
 611                 link_info->link_speed  = RTE_ETH_SPEED_NUM_25G;
 612                 link_info->link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
 613                 break;
 614         case EFX_LINK_40000FDX:
 615                 link_info->link_speed  = RTE_ETH_SPEED_NUM_40G;
 616                 link_info->link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
 617                 break;
 618         case EFX_LINK_50000FDX:
 619                 link_info->link_speed  = RTE_ETH_SPEED_NUM_50G;
 620                 link_info->link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
 621                 break;
 622         case EFX_LINK_100000FDX:
 623                 link_info->link_speed  = RTE_ETH_SPEED_NUM_100G;
 624                 link_info->link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
 625                 break;
 626         default:
 627                 SFC_ASSERT(B_FALSE);
 628                 /* FALLTHROUGH */
 629         case EFX_LINK_UNKNOWN:
 630         case EFX_LINK_DOWN:
 631                 link_info->link_speed  = RTE_ETH_SPEED_NUM_NONE;
 632                 link_info->link_duplex = 0;
 633                 break;
 634         }
 635
 636         link_info->link_autoneg = RTE_ETH_LINK_AUTONEG;
 637 }
 638
 639 int
 640 sfc_port_get_mac_stats(struct sfc_adapter *sa, struct rte_eth_xstat *xstats,
 641                        unsigned int xstats_count, unsigned int *nb_written)
 642 {
 643         struct sfc_port *port = &sa->port;
 644         uint64_t *mac_stats;
 645         unsigned int i;
 646         int nstats = 0;
 647         int ret;
 648
 649         sfc_adapter_lock(sa);
 650
 651         ret = sfc_port_update_mac_stats(sa, B_FALSE);
 652         if (ret != 0) {
 653                 SFC_ASSERT(ret > 0);
 654                 ret = -ret;
 655                 goto unlock;
 656         }
 657
 658         mac_stats = port->mac_stats_buf;
 659
 660         for (i = 0; i < EFX_MAC_NSTATS; ++i) {
 661                 if (EFX_MAC_STAT_SUPPORTED(port->mac_stats_mask, i)) {
 662                         if (nstats < (int)xstats_count) {
 663                                 xstats[nstats].id = nstats;
 664                                 xstats[nstats].value = mac_stats[i];
 665                                 (*nb_written)++;
 666                         }
 667                         nstats++;
 668                 }
 669         }
 670         ret = nstats;
 671
 672 unlock:
 673         sfc_adapter_unlock(sa);
 674
 675         return ret;
 676 }
 677
 678 int
 679 sfc_port_get_mac_stats_by_id(struct sfc_adapter *sa, const uint64_t *ids,
 680                              uint64_t *values, unsigned int n)
 681 {
 682         struct sfc_port *port = &sa->port;
 683         uint64_t *mac_stats;
 684         unsigned int i;
 685         int ret;
 686         int rc;
 687
 688         sfc_adapter_lock(sa);
 689
 690         rc = sfc_port_update_mac_stats(sa, B_FALSE);
 691         if (rc != 0) {
 692                 SFC_ASSERT(rc > 0);
 693                 ret = -rc;
 694                 goto unlock;
 695         }
 696
 697         mac_stats = port->mac_stats_buf;
 698
 699         SFC_ASSERT(port->mac_stats_nb_supported <=
 700                    RTE_DIM(port->mac_stats_by_id));
 701
 702         for (i = 0; i < n; i++) {
 703                 if (ids[i] < port->mac_stats_nb_supported)
 704                         values[i] = mac_stats[port->mac_stats_by_id[ids[i]]];
 705         }
 706
 707         ret = 0;
 708
 709 unlock:
 710         sfc_adapter_unlock(sa);
 711
 712         return ret;
 713 }