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