drivers/net/sfc/sfc_port.c

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