drivers/net/sfc/sfc.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright(c) 2019-2020 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 /* sysconf() */
  11 #include <unistd.h>
  12
  13 #include <rte_errno.h>
  14 #include <rte_alarm.h>
  15
  16 #include "efx.h"
  17
  18 #include "sfc.h"
  19 #include "sfc_debug.h"
  20 #include "sfc_log.h"
  21 #include "sfc_ev.h"
  22 #include "sfc_rx.h"
  23 #include "sfc_tx.h"
  24 #include "sfc_kvargs.h"
  25 #include "sfc_tweak.h"
  26
  27
  28 int
  29 sfc_dma_alloc(const struct sfc_adapter *sa, const char *name, uint16_t id,
  30               size_t len, int socket_id, efsys_mem_t *esmp)
  31 {
  32         const struct rte_memzone *mz;
  33
  34         sfc_log_init(sa, "name=%s id=%u len=%zu socket_id=%d",
  35                      name, id, len, socket_id);
  36
  37         mz = rte_eth_dma_zone_reserve(sa->eth_dev, name, id, len,
  38                                       sysconf(_SC_PAGESIZE), socket_id);
  39         if (mz == NULL) {
  40                 sfc_err(sa, "cannot reserve DMA zone for %s:%u %#x@%d: %s",
  41                         name, (unsigned int)id, (unsigned int)len, socket_id,
  42                         rte_strerror(rte_errno));
  43                 return ENOMEM;
  44         }
  45
  46         esmp->esm_addr = mz->iova;
  47         if (esmp->esm_addr == RTE_BAD_IOVA) {
  48                 (void)rte_memzone_free(mz);
  49                 return EFAULT;
  50         }
  51
  52         esmp->esm_mz = mz;
  53         esmp->esm_base = mz->addr;
  54
  55         sfc_info(sa,
  56                  "DMA name=%s id=%u len=%lu socket_id=%d => virt=%p iova=%lx",
  57                  name, id, len, socket_id, esmp->esm_base,
  58                  (unsigned long)esmp->esm_addr);
  59
  60         return 0;
  61 }
  62
  63 void
  64 sfc_dma_free(const struct sfc_adapter *sa, efsys_mem_t *esmp)
  65 {
  66         int rc;
  67
  68         sfc_log_init(sa, "name=%s", esmp->esm_mz->name);
  69
  70         rc = rte_memzone_free(esmp->esm_mz);
  71         if (rc != 0)
  72                 sfc_err(sa, "rte_memzone_free(() failed: %d", rc);
  73
  74         memset(esmp, 0, sizeof(*esmp));
  75 }
  76
  77 static uint32_t
  78 sfc_phy_cap_from_link_speeds(uint32_t speeds)
  79 {
  80         uint32_t phy_caps = 0;
  81
  82         if (~speeds & ETH_LINK_SPEED_FIXED) {
  83                 phy_caps |= (1 << EFX_PHY_CAP_AN);
  84                 /*
  85                  * If no speeds are specified in the mask, any supported
  86                  * may be negotiated
  87                  */
  88                 if (speeds == ETH_LINK_SPEED_AUTONEG)
  89                         phy_caps |=
  90                                 (1 << EFX_PHY_CAP_1000FDX) |
  91                                 (1 << EFX_PHY_CAP_10000FDX) |
  92                                 (1 << EFX_PHY_CAP_25000FDX) |
  93                                 (1 << EFX_PHY_CAP_40000FDX) |
  94                                 (1 << EFX_PHY_CAP_50000FDX) |
  95                                 (1 << EFX_PHY_CAP_100000FDX);
  96         }
  97         if (speeds & ETH_LINK_SPEED_1G)
  98                 phy_caps |= (1 << EFX_PHY_CAP_1000FDX);
  99         if (speeds & ETH_LINK_SPEED_10G)
 100                 phy_caps |= (1 << EFX_PHY_CAP_10000FDX);
 101         if (speeds & ETH_LINK_SPEED_25G)
 102                 phy_caps |= (1 << EFX_PHY_CAP_25000FDX);
 103         if (speeds & ETH_LINK_SPEED_40G)
 104                 phy_caps |= (1 << EFX_PHY_CAP_40000FDX);
 105         if (speeds & ETH_LINK_SPEED_50G)
 106                 phy_caps |= (1 << EFX_PHY_CAP_50000FDX);
 107         if (speeds & ETH_LINK_SPEED_100G)
 108                 phy_caps |= (1 << EFX_PHY_CAP_100000FDX);
 109
 110         return phy_caps;
 111 }
 112
 113 /*
 114  * Check requested device level configuration.
 115  * Receive and transmit configuration is checked in corresponding
 116  * modules.
 117  */
 118 static int
 119 sfc_check_conf(struct sfc_adapter *sa)
 120 {
 121         const struct rte_eth_conf *conf = &sa->eth_dev->data->dev_conf;
 122         int rc = 0;
 123
 124         sa->port.phy_adv_cap =
 125                 sfc_phy_cap_from_link_speeds(conf->link_speeds) &
 126                 sa->port.phy_adv_cap_mask;
 127         if ((sa->port.phy_adv_cap & ~(1 << EFX_PHY_CAP_AN)) == 0) {
 128                 sfc_err(sa, "No link speeds from mask %#x are supported",
 129                         conf->link_speeds);
 130                 rc = EINVAL;
 131         }
 132
 133 #if !EFSYS_OPT_LOOPBACK
 134         if (conf->lpbk_mode != 0) {
 135                 sfc_err(sa, "Loopback not supported");
 136                 rc = EINVAL;
 137         }
 138 #endif
 139
 140         if (conf->dcb_capability_en != 0) {
 141                 sfc_err(sa, "Priority-based flow control not supported");
 142                 rc = EINVAL;
 143         }
 144
 145         if (conf->fdir_conf.mode != RTE_FDIR_MODE_NONE) {
 146                 sfc_err(sa, "Flow Director not supported");
 147                 rc = EINVAL;
 148         }
 149
 150         if ((conf->intr_conf.lsc != 0) &&
 151             (sa->intr.type != EFX_INTR_LINE) &&
 152             (sa->intr.type != EFX_INTR_MESSAGE)) {
 153                 sfc_err(sa, "Link status change interrupt not supported");
 154                 rc = EINVAL;
 155         }
 156
 157         if (conf->intr_conf.rxq != 0 &&
 158             (sa->priv.dp_rx->features & SFC_DP_RX_FEAT_INTR) == 0) {
 159                 sfc_err(sa, "Receive queue interrupt not supported");
 160                 rc = EINVAL;
 161         }
 162
 163         return rc;
 164 }
 165
 166 /*
 167  * Find out maximum number of receive and transmit queues which could be
 168  * advertised.
 169  *
 170  * NIC is kept initialized on success to allow other modules acquire
 171  * defaults and capabilities.
 172  */
 173 static int
 174 sfc_estimate_resource_limits(struct sfc_adapter *sa)
 175 {
 176         const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic);
 177         efx_drv_limits_t limits;
 178         int rc;
 179         uint32_t evq_allocated;
 180         uint32_t rxq_allocated;
 181         uint32_t txq_allocated;
 182
 183         memset(&limits, 0, sizeof(limits));
 184
 185         /* Request at least one Rx and Tx queue */
 186         limits.edl_min_rxq_count = 1;
 187         limits.edl_min_txq_count = 1;
 188         /* Management event queue plus event queue for each Tx and Rx queue */
 189         limits.edl_min_evq_count =
 190                 1 + limits.edl_min_rxq_count + limits.edl_min_txq_count;
 191
 192         /* Divide by number of functions to guarantee that all functions
 193          * will get promised resources
 194          */
 195         /* FIXME Divide by number of functions (not 2) below */
 196         limits.edl_max_evq_count = encp->enc_evq_limit / 2;
 197         SFC_ASSERT(limits.edl_max_evq_count >= limits.edl_min_rxq_count);
 198
 199         /* Split equally between receive and transmit */
 200         limits.edl_max_rxq_count =
 201                 MIN(encp->enc_rxq_limit, (limits.edl_max_evq_count - 1) / 2);
 202         SFC_ASSERT(limits.edl_max_rxq_count >= limits.edl_min_rxq_count);
 203
 204         limits.edl_max_txq_count =
 205                 MIN(encp->enc_txq_limit,
 206                     limits.edl_max_evq_count - 1 - limits.edl_max_rxq_count);
 207
 208         if (sa->tso && encp->enc_fw_assisted_tso_v2_enabled)
 209                 limits.edl_max_txq_count =
 210                         MIN(limits.edl_max_txq_count,
 211                             encp->enc_fw_assisted_tso_v2_n_contexts /
 212                             encp->enc_hw_pf_count);
 213
 214         SFC_ASSERT(limits.edl_max_txq_count >= limits.edl_min_rxq_count);
 215
 216         /* Configure the minimum required resources needed for the
 217          * driver to operate, and the maximum desired resources that the
 218          * driver is capable of using.
 219          */
 220         efx_nic_set_drv_limits(sa->nic, &limits);
 221
 222         sfc_log_init(sa, "init nic");
 223         rc = efx_nic_init(sa->nic);
 224         if (rc != 0)
 225                 goto fail_nic_init;
 226
 227         /* Find resource dimensions assigned by firmware to this function */
 228         rc = efx_nic_get_vi_pool(sa->nic, &evq_allocated, &rxq_allocated,
 229                                  &txq_allocated);
 230         if (rc != 0)
 231                 goto fail_get_vi_pool;
 232
 233         /* It still may allocate more than maximum, ensure limit */
 234         evq_allocated = MIN(evq_allocated, limits.edl_max_evq_count);
 235         rxq_allocated = MIN(rxq_allocated, limits.edl_max_rxq_count);
 236         txq_allocated = MIN(txq_allocated, limits.edl_max_txq_count);
 237
 238         /* Subtract management EVQ not used for traffic */
 239         SFC_ASSERT(evq_allocated > 0);
 240         evq_allocated--;
 241
 242         /* Right now we use separate EVQ for Rx and Tx */
 243         sa->rxq_max = MIN(rxq_allocated, evq_allocated / 2);
 244         sa->txq_max = MIN(txq_allocated, evq_allocated - sa->rxq_max);
 245
 246         /* Keep NIC initialized */
 247         return 0;
 248
 249 fail_get_vi_pool:
 250         efx_nic_fini(sa->nic);
 251 fail_nic_init:
 252         return rc;
 253 }
 254
 255 static int
 256 sfc_set_drv_limits(struct sfc_adapter *sa)
 257 {
 258         const struct rte_eth_dev_data *data = sa->eth_dev->data;
 259         efx_drv_limits_t lim;
 260
 261         memset(&lim, 0, sizeof(lim));
 262
 263         /* Limits are strict since take into account initial estimation */
 264         lim.edl_min_evq_count = lim.edl_max_evq_count =
 265                 1 + data->nb_rx_queues + data->nb_tx_queues;
 266         lim.edl_min_rxq_count = lim.edl_max_rxq_count = data->nb_rx_queues;
 267         lim.edl_min_txq_count = lim.edl_max_txq_count = data->nb_tx_queues;
 268
 269         return efx_nic_set_drv_limits(sa->nic, &lim);
 270 }
 271
 272 static int
 273 sfc_set_fw_subvariant(struct sfc_adapter *sa)
 274 {
 275         struct sfc_adapter_shared *sas = sfc_sa2shared(sa);
 276         const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic);
 277         uint64_t tx_offloads = sa->eth_dev->data->dev_conf.txmode.offloads;
 278         unsigned int txq_index;
 279         efx_nic_fw_subvariant_t req_fw_subvariant;
 280         efx_nic_fw_subvariant_t cur_fw_subvariant;
 281         int rc;
 282
 283         if (!encp->enc_fw_subvariant_no_tx_csum_supported) {
 284                 sfc_info(sa, "no-Tx-checksum subvariant not supported");
 285                 return 0;
 286         }
 287
 288         for (txq_index = 0; txq_index < sas->txq_count; ++txq_index) {
 289                 struct sfc_txq_info *txq_info = &sas->txq_info[txq_index];
 290
 291                 if (txq_info->state & SFC_TXQ_INITIALIZED)
 292                         tx_offloads |= txq_info->offloads;
 293         }
 294
 295         if (tx_offloads & (DEV_TX_OFFLOAD_IPV4_CKSUM |
 296                            DEV_TX_OFFLOAD_TCP_CKSUM |
 297                            DEV_TX_OFFLOAD_UDP_CKSUM |
 298                            DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM))
 299                 req_fw_subvariant = EFX_NIC_FW_SUBVARIANT_DEFAULT;
 300         else
 301                 req_fw_subvariant = EFX_NIC_FW_SUBVARIANT_NO_TX_CSUM;
 302
 303         rc = efx_nic_get_fw_subvariant(sa->nic, &cur_fw_subvariant);
 304         if (rc != 0) {
 305                 sfc_err(sa, "failed to get FW subvariant: %d", rc);
 306                 return rc;
 307         }
 308         sfc_info(sa, "FW subvariant is %u vs required %u",
 309                  cur_fw_subvariant, req_fw_subvariant);
 310
 311         if (cur_fw_subvariant == req_fw_subvariant)
 312                 return 0;
 313
 314         rc = efx_nic_set_fw_subvariant(sa->nic, req_fw_subvariant);
 315         if (rc != 0) {
 316                 sfc_err(sa, "failed to set FW subvariant %u: %d",
 317                         req_fw_subvariant, rc);
 318                 return rc;
 319         }
 320         sfc_info(sa, "FW subvariant set to %u", req_fw_subvariant);
 321
 322         return 0;
 323 }
 324
 325 static int
 326 sfc_try_start(struct sfc_adapter *sa)
 327 {
 328         const efx_nic_cfg_t *encp;
 329         int rc;
 330
 331         sfc_log_init(sa, "entry");
 332
 333         SFC_ASSERT(sfc_adapter_is_locked(sa));
 334         SFC_ASSERT(sa->state == SFC_ADAPTER_STARTING);
 335
 336         sfc_log_init(sa, "set FW subvariant");
 337         rc = sfc_set_fw_subvariant(sa);
 338         if (rc != 0)
 339                 goto fail_set_fw_subvariant;
 340
 341         sfc_log_init(sa, "set resource limits");
 342         rc = sfc_set_drv_limits(sa);
 343         if (rc != 0)
 344                 goto fail_set_drv_limits;
 345
 346         sfc_log_init(sa, "init nic");
 347         rc = efx_nic_init(sa->nic);
 348         if (rc != 0)
 349                 goto fail_nic_init;
 350
 351         encp = efx_nic_cfg_get(sa->nic);
 352
 353         /*
 354          * Refresh (since it may change on NIC reset/restart) a copy of
 355          * supported tunnel encapsulations in shared memory to be used
 356          * on supported Rx packet type classes get.
 357          */
 358         sa->priv.shared->tunnel_encaps =
 359                 encp->enc_tunnel_encapsulations_supported;
 360
 361         if (encp->enc_tunnel_encapsulations_supported != 0) {
 362                 sfc_log_init(sa, "apply tunnel config");
 363                 rc = efx_tunnel_reconfigure(sa->nic);
 364                 if (rc != 0)
 365                         goto fail_tunnel_reconfigure;
 366         }
 367
 368         rc = sfc_intr_start(sa);
 369         if (rc != 0)
 370                 goto fail_intr_start;
 371
 372         rc = sfc_ev_start(sa);
 373         if (rc != 0)
 374                 goto fail_ev_start;
 375
 376         rc = sfc_port_start(sa);
 377         if (rc != 0)
 378                 goto fail_port_start;
 379
 380         rc = sfc_rx_start(sa);
 381         if (rc != 0)
 382                 goto fail_rx_start;
 383
 384         rc = sfc_tx_start(sa);
 385         if (rc != 0)
 386                 goto fail_tx_start;
 387
 388         rc = sfc_flow_start(sa);
 389         if (rc != 0)
 390                 goto fail_flows_insert;
 391
 392         sfc_log_init(sa, "done");
 393         return 0;
 394
 395 fail_flows_insert:
 396         sfc_tx_stop(sa);
 397
 398 fail_tx_start:
 399         sfc_rx_stop(sa);
 400
 401 fail_rx_start:
 402         sfc_port_stop(sa);
 403
 404 fail_port_start:
 405         sfc_ev_stop(sa);
 406
 407 fail_ev_start:
 408         sfc_intr_stop(sa);
 409
 410 fail_intr_start:
 411 fail_tunnel_reconfigure:
 412         efx_nic_fini(sa->nic);
 413
 414 fail_nic_init:
 415 fail_set_drv_limits:
 416 fail_set_fw_subvariant:
 417         sfc_log_init(sa, "failed %d", rc);
 418         return rc;
 419 }
 420
 421 int
 422 sfc_start(struct sfc_adapter *sa)
 423 {
 424         unsigned int start_tries = 3;
 425         int rc;
 426
 427         sfc_log_init(sa, "entry");
 428
 429         SFC_ASSERT(sfc_adapter_is_locked(sa));
 430
 431         switch (sa->state) {
 432         case SFC_ADAPTER_CONFIGURED:
 433                 break;
 434         case SFC_ADAPTER_STARTED:
 435                 sfc_notice(sa, "already started");
 436                 return 0;
 437         default:
 438                 rc = EINVAL;
 439                 goto fail_bad_state;
 440         }
 441
 442         sa->state = SFC_ADAPTER_STARTING;
 443
 444         rc = 0;
 445         do {
 446                 /*
 447                  * FIXME Try to recreate vSwitch on start retry.
 448                  * vSwitch is absent after MC reboot like events and
 449                  * we should recreate it. May be we need proper
 450                  * indication instead of guessing.
 451                  */
 452                 if (rc != 0) {
 453                         sfc_sriov_vswitch_destroy(sa);
 454                         rc = sfc_sriov_vswitch_create(sa);
 455                         if (rc != 0)
 456                                 goto fail_sriov_vswitch_create;
 457                 }
 458                 rc = sfc_try_start(sa);
 459         } while ((--start_tries > 0) &&
 460                  (rc == EIO || rc == EAGAIN || rc == ENOENT || rc == EINVAL));
 461
 462         if (rc != 0)
 463                 goto fail_try_start;
 464
 465         sa->state = SFC_ADAPTER_STARTED;
 466         sfc_log_init(sa, "done");
 467         return 0;
 468
 469 fail_try_start:
 470 fail_sriov_vswitch_create:
 471         sa->state = SFC_ADAPTER_CONFIGURED;
 472 fail_bad_state:
 473         sfc_log_init(sa, "failed %d", rc);
 474         return rc;
 475 }
 476
 477 void
 478 sfc_stop(struct sfc_adapter *sa)
 479 {
 480         sfc_log_init(sa, "entry");
 481
 482         SFC_ASSERT(sfc_adapter_is_locked(sa));
 483
 484         switch (sa->state) {
 485         case SFC_ADAPTER_STARTED:
 486                 break;
 487         case SFC_ADAPTER_CONFIGURED:
 488                 sfc_notice(sa, "already stopped");
 489                 return;
 490         default:
 491                 sfc_err(sa, "stop in unexpected state %u", sa->state);
 492                 SFC_ASSERT(B_FALSE);
 493                 return;
 494         }
 495
 496         sa->state = SFC_ADAPTER_STOPPING;
 497
 498         sfc_flow_stop(sa);
 499         sfc_tx_stop(sa);
 500         sfc_rx_stop(sa);
 501         sfc_port_stop(sa);
 502         sfc_ev_stop(sa);
 503         sfc_intr_stop(sa);
 504         efx_nic_fini(sa->nic);
 505
 506         sa->state = SFC_ADAPTER_CONFIGURED;
 507         sfc_log_init(sa, "done");
 508 }
 509
 510 static int
 511 sfc_restart(struct sfc_adapter *sa)
 512 {
 513         int rc;
 514
 515         SFC_ASSERT(sfc_adapter_is_locked(sa));
 516
 517         if (sa->state != SFC_ADAPTER_STARTED)
 518                 return EINVAL;
 519
 520         sfc_stop(sa);
 521
 522         rc = sfc_start(sa);
 523         if (rc != 0)
 524                 sfc_err(sa, "restart failed");
 525
 526         return rc;
 527 }
 528
 529 static void
 530 sfc_restart_if_required(void *arg)
 531 {
 532         struct sfc_adapter *sa = arg;
 533
 534         /* If restart is scheduled, clear the flag and do it */
 535         if (rte_atomic32_cmpset((volatile uint32_t *)&sa->restart_required,
 536                                 1, 0)) {
 537                 sfc_adapter_lock(sa);
 538                 if (sa->state == SFC_ADAPTER_STARTED)
 539                         (void)sfc_restart(sa);
 540                 sfc_adapter_unlock(sa);
 541         }
 542 }
 543
 544 void
 545 sfc_schedule_restart(struct sfc_adapter *sa)
 546 {
 547         int rc;
 548
 549         /* Schedule restart alarm if it is not scheduled yet */
 550         if (!rte_atomic32_test_and_set(&sa->restart_required))
 551                 return;
 552
 553         rc = rte_eal_alarm_set(1, sfc_restart_if_required, sa);
 554         if (rc == -ENOTSUP)
 555                 sfc_warn(sa, "alarms are not supported, restart is pending");
 556         else if (rc != 0)
 557                 sfc_err(sa, "cannot arm restart alarm (rc=%d)", rc);
 558         else
 559                 sfc_notice(sa, "restart scheduled");
 560 }
 561
 562 int
 563 sfc_configure(struct sfc_adapter *sa)
 564 {
 565         int rc;
 566
 567         sfc_log_init(sa, "entry");
 568
 569         SFC_ASSERT(sfc_adapter_is_locked(sa));
 570
 571         SFC_ASSERT(sa->state == SFC_ADAPTER_INITIALIZED ||
 572                    sa->state == SFC_ADAPTER_CONFIGURED);
 573         sa->state = SFC_ADAPTER_CONFIGURING;
 574
 575         rc = sfc_check_conf(sa);
 576         if (rc != 0)
 577                 goto fail_check_conf;
 578
 579         rc = sfc_intr_configure(sa);
 580         if (rc != 0)
 581                 goto fail_intr_configure;
 582
 583         rc = sfc_port_configure(sa);
 584         if (rc != 0)
 585                 goto fail_port_configure;
 586
 587         rc = sfc_rx_configure(sa);
 588         if (rc != 0)
 589                 goto fail_rx_configure;
 590
 591         rc = sfc_tx_configure(sa);
 592         if (rc != 0)
 593                 goto fail_tx_configure;
 594
 595         sa->state = SFC_ADAPTER_CONFIGURED;
 596         sfc_log_init(sa, "done");
 597         return 0;
 598
 599 fail_tx_configure:
 600         sfc_rx_close(sa);
 601
 602 fail_rx_configure:
 603         sfc_port_close(sa);
 604
 605 fail_port_configure:
 606         sfc_intr_close(sa);
 607
 608 fail_intr_configure:
 609 fail_check_conf:
 610         sa->state = SFC_ADAPTER_INITIALIZED;
 611         sfc_log_init(sa, "failed %d", rc);
 612         return rc;
 613 }
 614
 615 void
 616 sfc_close(struct sfc_adapter *sa)
 617 {
 618         sfc_log_init(sa, "entry");
 619
 620         SFC_ASSERT(sfc_adapter_is_locked(sa));
 621
 622         SFC_ASSERT(sa->state == SFC_ADAPTER_CONFIGURED);
 623         sa->state = SFC_ADAPTER_CLOSING;
 624
 625         sfc_tx_close(sa);
 626         sfc_rx_close(sa);
 627         sfc_port_close(sa);
 628         sfc_intr_close(sa);
 629
 630         sa->state = SFC_ADAPTER_INITIALIZED;
 631         sfc_log_init(sa, "done");
 632 }
 633
 634 static efx_rc_t
 635 sfc_find_mem_bar(efsys_pci_config_t *configp, int bar_index,
 636                  efsys_bar_t *barp)
 637 {
 638         efsys_bar_t result;
 639         struct rte_pci_device *dev;
 640
 641         memset(&result, 0, sizeof(result));
 642
 643         if (bar_index < 0 || bar_index >= PCI_MAX_RESOURCE)
 644                 return EINVAL;
 645
 646         dev = configp->espc_dev;
 647
 648         result.esb_rid = bar_index;
 649         result.esb_dev = dev;
 650         result.esb_base = dev->mem_resource[bar_index].addr;
 651
 652         *barp = result;
 653
 654         return 0;
 655 }
 656
 657 static int
 658 sfc_mem_bar_init(struct sfc_adapter *sa, const efx_bar_region_t *mem_ebrp)
 659 {
 660         struct rte_eth_dev *eth_dev = sa->eth_dev;
 661         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 662         efsys_bar_t *ebp = &sa->mem_bar;
 663         struct rte_mem_resource *res =
 664                 &pci_dev->mem_resource[mem_ebrp->ebr_index];
 665
 666         SFC_BAR_LOCK_INIT(ebp, eth_dev->data->name);
 667         ebp->esb_rid = mem_ebrp->ebr_index;
 668         ebp->esb_dev = pci_dev;
 669         ebp->esb_base = res->addr;
 670         return 0;
 671 }
 672
 673 static void
 674 sfc_mem_bar_fini(struct sfc_adapter *sa)
 675 {
 676         efsys_bar_t *ebp = &sa->mem_bar;
 677
 678         SFC_BAR_LOCK_DESTROY(ebp);
 679         memset(ebp, 0, sizeof(*ebp));
 680 }
 681
 682 /*
 683  * A fixed RSS key which has a property of being symmetric
 684  * (symmetrical flows are distributed to the same CPU)
 685  * and also known to give a uniform distribution
 686  * (a good distribution of traffic between different CPUs)
 687  */
 688 static const uint8_t default_rss_key[EFX_RSS_KEY_SIZE] = {
 689         0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a,
 690         0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a,
 691         0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a,
 692         0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a,
 693         0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a,
 694 };
 695
 696 static int
 697 sfc_rss_attach(struct sfc_adapter *sa)
 698 {
 699         struct sfc_rss *rss = &sfc_sa2shared(sa)->rss;
 700         int rc;
 701
 702         rc = efx_intr_init(sa->nic, sa->intr.type, NULL);
 703         if (rc != 0)
 704                 goto fail_intr_init;
 705
 706         rc = efx_ev_init(sa->nic);
 707         if (rc != 0)
 708                 goto fail_ev_init;
 709
 710         rc = efx_rx_init(sa->nic);
 711         if (rc != 0)
 712                 goto fail_rx_init;
 713
 714         rc = efx_rx_scale_default_support_get(sa->nic, &rss->context_type);
 715         if (rc != 0)
 716                 goto fail_scale_support_get;
 717
 718         rc = efx_rx_hash_default_support_get(sa->nic, &rss->hash_support);
 719         if (rc != 0)
 720                 goto fail_hash_support_get;
 721
 722         rc = sfc_rx_hash_init(sa);
 723         if (rc != 0)
 724                 goto fail_rx_hash_init;
 725
 726         efx_rx_fini(sa->nic);
 727         efx_ev_fini(sa->nic);
 728         efx_intr_fini(sa->nic);
 729
 730         rte_memcpy(rss->key, default_rss_key, sizeof(rss->key));
 731         rss->dummy_rss_context = EFX_RSS_CONTEXT_DEFAULT;
 732
 733         return 0;
 734
 735 fail_rx_hash_init:
 736 fail_hash_support_get:
 737 fail_scale_support_get:
 738         efx_rx_fini(sa->nic);
 739
 740 fail_rx_init:
 741         efx_ev_fini(sa->nic);
 742
 743 fail_ev_init:
 744         efx_intr_fini(sa->nic);
 745
 746 fail_intr_init:
 747         return rc;
 748 }
 749
 750 static void
 751 sfc_rss_detach(struct sfc_adapter *sa)
 752 {
 753         sfc_rx_hash_fini(sa);
 754 }
 755
 756 int
 757 sfc_attach(struct sfc_adapter *sa)
 758 {
 759         const efx_nic_cfg_t *encp;
 760         efx_nic_t *enp = sa->nic;
 761         int rc;
 762
 763         sfc_log_init(sa, "entry");
 764
 765         SFC_ASSERT(sfc_adapter_is_locked(sa));
 766
 767         efx_mcdi_new_epoch(enp);
 768
 769         sfc_log_init(sa, "reset nic");
 770         rc = efx_nic_reset(enp);
 771         if (rc != 0)
 772                 goto fail_nic_reset;
 773
 774         rc = sfc_sriov_attach(sa);
 775         if (rc != 0)
 776                 goto fail_sriov_attach;
 777
 778         /*
 779          * Probed NIC is sufficient for tunnel init.
 780          * Initialize tunnel support to be able to use libefx
 781          * efx_tunnel_config_udp_{add,remove}() in any state and
 782          * efx_tunnel_reconfigure() on start up.
 783          */
 784         rc = efx_tunnel_init(enp);
 785         if (rc != 0)
 786                 goto fail_tunnel_init;
 787
 788         encp = efx_nic_cfg_get(sa->nic);
 789
 790         /*
 791          * Make a copy of supported tunnel encapsulations in shared
 792          * memory to be used on supported Rx packet type classes get.
 793          */
 794         sa->priv.shared->tunnel_encaps =
 795                 encp->enc_tunnel_encapsulations_supported;
 796
 797         if (sfc_dp_tx_offload_capa(sa->priv.dp_tx) & DEV_TX_OFFLOAD_TCP_TSO) {
 798                 sa->tso = encp->enc_fw_assisted_tso_v2_enabled ||
 799                           encp->enc_tso_v3_enabled;
 800                 if (!sa->tso)
 801                         sfc_info(sa, "TSO support isn't available on this adapter");
 802         }
 803
 804         if (sa->tso &&
 805             (sfc_dp_tx_offload_capa(sa->priv.dp_tx) &
 806              (DEV_TX_OFFLOAD_VXLAN_TNL_TSO |
 807               DEV_TX_OFFLOAD_GENEVE_TNL_TSO)) != 0) {
 808                 sa->tso_encap = encp->enc_fw_assisted_tso_v2_encap_enabled ||
 809                                 encp->enc_tso_v3_enabled;
 810                 if (!sa->tso_encap)
 811                         sfc_info(sa, "Encapsulated TSO support isn't available on this adapter");
 812         }
 813
 814         sfc_log_init(sa, "estimate resource limits");
 815         rc = sfc_estimate_resource_limits(sa);
 816         if (rc != 0)
 817                 goto fail_estimate_rsrc_limits;
 818
 819         sa->evq_max_entries = encp->enc_evq_max_nevs;
 820         SFC_ASSERT(rte_is_power_of_2(sa->evq_max_entries));
 821
 822         sa->evq_min_entries = encp->enc_evq_min_nevs;
 823         SFC_ASSERT(rte_is_power_of_2(sa->evq_min_entries));
 824
 825         sa->rxq_max_entries = encp->enc_rxq_max_ndescs;
 826         SFC_ASSERT(rte_is_power_of_2(sa->rxq_max_entries));
 827
 828         sa->rxq_min_entries = encp->enc_rxq_min_ndescs;
 829         SFC_ASSERT(rte_is_power_of_2(sa->rxq_min_entries));
 830
 831         sa->txq_max_entries = encp->enc_txq_max_ndescs;
 832         SFC_ASSERT(rte_is_power_of_2(sa->txq_max_entries));
 833
 834         sa->txq_min_entries = encp->enc_txq_min_ndescs;
 835         SFC_ASSERT(rte_is_power_of_2(sa->txq_min_entries));
 836
 837         rc = sfc_intr_attach(sa);
 838         if (rc != 0)
 839                 goto fail_intr_attach;
 840
 841         rc = sfc_ev_attach(sa);
 842         if (rc != 0)
 843                 goto fail_ev_attach;
 844
 845         rc = sfc_port_attach(sa);
 846         if (rc != 0)
 847                 goto fail_port_attach;
 848
 849         rc = sfc_rss_attach(sa);
 850         if (rc != 0)
 851                 goto fail_rss_attach;
 852
 853         rc = sfc_filter_attach(sa);
 854         if (rc != 0)
 855                 goto fail_filter_attach;
 856
 857         sfc_log_init(sa, "fini nic");
 858         efx_nic_fini(enp);
 859
 860         sfc_flow_init(sa);
 861
 862         /*
 863          * Create vSwitch to be able to use VFs when PF is not started yet
 864          * as DPDK port. VFs should be able to talk to each other even
 865          * if PF is down.
 866          */
 867         rc = sfc_sriov_vswitch_create(sa);
 868         if (rc != 0)
 869                 goto fail_sriov_vswitch_create;
 870
 871         sa->state = SFC_ADAPTER_INITIALIZED;
 872
 873         sfc_log_init(sa, "done");
 874         return 0;
 875
 876 fail_sriov_vswitch_create:
 877         sfc_flow_fini(sa);
 878         sfc_filter_detach(sa);
 879
 880 fail_filter_attach:
 881         sfc_rss_detach(sa);
 882
 883 fail_rss_attach:
 884         sfc_port_detach(sa);
 885
 886 fail_port_attach:
 887         sfc_ev_detach(sa);
 888
 889 fail_ev_attach:
 890         sfc_intr_detach(sa);
 891
 892 fail_intr_attach:
 893         efx_nic_fini(sa->nic);
 894
 895 fail_estimate_rsrc_limits:
 896 fail_tunnel_init:
 897         efx_tunnel_fini(sa->nic);
 898         sfc_sriov_detach(sa);
 899
 900 fail_sriov_attach:
 901 fail_nic_reset:
 902
 903         sfc_log_init(sa, "failed %d", rc);
 904         return rc;
 905 }
 906
 907 void
 908 sfc_detach(struct sfc_adapter *sa)
 909 {
 910         sfc_log_init(sa, "entry");
 911
 912         SFC_ASSERT(sfc_adapter_is_locked(sa));
 913
 914         sfc_sriov_vswitch_destroy(sa);
 915
 916         sfc_flow_fini(sa);
 917
 918         sfc_filter_detach(sa);
 919         sfc_rss_detach(sa);
 920         sfc_port_detach(sa);
 921         sfc_ev_detach(sa);
 922         sfc_intr_detach(sa);
 923         efx_tunnel_fini(sa->nic);
 924         sfc_sriov_detach(sa);
 925
 926         sa->state = SFC_ADAPTER_UNINITIALIZED;
 927 }
 928
 929 static int
 930 sfc_kvarg_fv_variant_handler(__rte_unused const char *key,
 931                              const char *value_str, void *opaque)
 932 {
 933         uint32_t *value = opaque;
 934
 935         if (strcasecmp(value_str, SFC_KVARG_FW_VARIANT_DONT_CARE) == 0)
 936                 *value = EFX_FW_VARIANT_DONT_CARE;
 937         else if (strcasecmp(value_str, SFC_KVARG_FW_VARIANT_FULL_FEATURED) == 0)
 938                 *value = EFX_FW_VARIANT_FULL_FEATURED;
 939         else if (strcasecmp(value_str, SFC_KVARG_FW_VARIANT_LOW_LATENCY) == 0)
 940                 *value = EFX_FW_VARIANT_LOW_LATENCY;
 941         else if (strcasecmp(value_str, SFC_KVARG_FW_VARIANT_PACKED_STREAM) == 0)
 942                 *value = EFX_FW_VARIANT_PACKED_STREAM;
 943         else if (strcasecmp(value_str, SFC_KVARG_FW_VARIANT_DPDK) == 0)
 944                 *value = EFX_FW_VARIANT_DPDK;
 945         else
 946                 return -EINVAL;
 947
 948         return 0;
 949 }
 950
 951 static int
 952 sfc_get_fw_variant(struct sfc_adapter *sa, efx_fw_variant_t *efv)
 953 {
 954         efx_nic_fw_info_t enfi;
 955         int rc;
 956
 957         rc = efx_nic_get_fw_version(sa->nic, &enfi);
 958         if (rc != 0)
 959                 return rc;
 960         else if (!enfi.enfi_dpcpu_fw_ids_valid)
 961                 return ENOTSUP;
 962
 963         /*
 964          * Firmware variant can be uniquely identified by the RxDPCPU
 965          * firmware id
 966          */
 967         switch (enfi.enfi_rx_dpcpu_fw_id) {
 968         case EFX_RXDP_FULL_FEATURED_FW_ID:
 969                 *efv = EFX_FW_VARIANT_FULL_FEATURED;
 970                 break;
 971
 972         case EFX_RXDP_LOW_LATENCY_FW_ID:
 973                 *efv = EFX_FW_VARIANT_LOW_LATENCY;
 974                 break;
 975
 976         case EFX_RXDP_PACKED_STREAM_FW_ID:
 977                 *efv = EFX_FW_VARIANT_PACKED_STREAM;
 978                 break;
 979
 980         case EFX_RXDP_DPDK_FW_ID:
 981                 *efv = EFX_FW_VARIANT_DPDK;
 982                 break;
 983
 984         default:
 985                 /*
 986                  * Other firmware variants are not considered, since they are
 987                  * not supported in the device parameters
 988                  */
 989                 *efv = EFX_FW_VARIANT_DONT_CARE;
 990                 break;
 991         }
 992
 993         return 0;
 994 }
 995
 996 static const char *
 997 sfc_fw_variant2str(efx_fw_variant_t efv)
 998 {
 999         switch (efv) {
1000         case EFX_RXDP_FULL_FEATURED_FW_ID:
1001                 return SFC_KVARG_FW_VARIANT_FULL_FEATURED;
1002         case EFX_RXDP_LOW_LATENCY_FW_ID:
1003                 return SFC_KVARG_FW_VARIANT_LOW_LATENCY;
1004         case EFX_RXDP_PACKED_STREAM_FW_ID:
1005                 return SFC_KVARG_FW_VARIANT_PACKED_STREAM;
1006         case EFX_RXDP_DPDK_FW_ID:
1007                 return SFC_KVARG_FW_VARIANT_DPDK;
1008         default:
1009                 return "unknown";
1010         }
1011 }
1012
1013 static int
1014 sfc_kvarg_rxd_wait_timeout_ns(struct sfc_adapter *sa)
1015 {
1016         int rc;
1017         long value;
1018
1019         value = SFC_RXD_WAIT_TIMEOUT_NS_DEF;
1020
1021         rc = sfc_kvargs_process(sa, SFC_KVARG_RXD_WAIT_TIMEOUT_NS,
1022                                 sfc_kvarg_long_handler, &value);
1023         if (rc != 0)
1024                 return rc;
1025
1026         if (value < 0 ||
1027             (unsigned long)value > EFX_RXQ_ES_SUPER_BUFFER_HOL_BLOCK_MAX) {
1028                 sfc_err(sa, "wrong '" SFC_KVARG_RXD_WAIT_TIMEOUT_NS "' "
1029                             "was set (%ld);", value);
1030                 sfc_err(sa, "it must not be less than 0 or greater than %u",
1031                             EFX_RXQ_ES_SUPER_BUFFER_HOL_BLOCK_MAX);
1032                 return EINVAL;
1033         }
1034
1035         sa->rxd_wait_timeout_ns = value;
1036         return 0;
1037 }
1038
1039 static int
1040 sfc_nic_probe(struct sfc_adapter *sa)
1041 {
1042         efx_nic_t *enp = sa->nic;
1043         efx_fw_variant_t preferred_efv;
1044         efx_fw_variant_t efv;
1045         int rc;
1046
1047         preferred_efv = EFX_FW_VARIANT_DONT_CARE;
1048         rc = sfc_kvargs_process(sa, SFC_KVARG_FW_VARIANT,
1049                                 sfc_kvarg_fv_variant_handler,
1050                                 &preferred_efv);
1051         if (rc != 0) {
1052                 sfc_err(sa, "invalid %s parameter value", SFC_KVARG_FW_VARIANT);
1053                 return rc;
1054         }
1055
1056         rc = sfc_kvarg_rxd_wait_timeout_ns(sa);
1057         if (rc != 0)
1058                 return rc;
1059
1060         rc = efx_nic_probe(enp, preferred_efv);
1061         if (rc == EACCES) {
1062                 /* Unprivileged functions cannot set FW variant */
1063                 rc = efx_nic_probe(enp, EFX_FW_VARIANT_DONT_CARE);
1064         }
1065         if (rc != 0)
1066                 return rc;
1067
1068         rc = sfc_get_fw_variant(sa, &efv);
1069         if (rc == ENOTSUP) {
1070                 sfc_warn(sa, "FW variant can not be obtained");
1071                 return 0;
1072         }
1073         if (rc != 0)
1074                 return rc;
1075
1076         /* Check that firmware variant was changed to the requested one */
1077         if (preferred_efv != EFX_FW_VARIANT_DONT_CARE && preferred_efv != efv) {
1078                 sfc_warn(sa, "FW variant has not changed to the requested %s",
1079                          sfc_fw_variant2str(preferred_efv));
1080         }
1081
1082         sfc_notice(sa, "running FW variant is %s", sfc_fw_variant2str(efv));
1083
1084         return 0;
1085 }
1086
1087 static efx_rc_t
1088 sfc_pci_config_readd(efsys_pci_config_t *configp, uint32_t offset,
1089                      efx_dword_t *edp)
1090 {
1091         int rc;
1092
1093         rc = rte_pci_read_config(configp->espc_dev, edp->ed_u32, sizeof(*edp),
1094                                  offset);
1095
1096         return (rc < 0 || rc != sizeof(*edp)) ? EIO : 0;
1097 }
1098
1099 static int
1100 sfc_family(struct sfc_adapter *sa, efx_bar_region_t *mem_ebrp)
1101 {
1102         struct rte_eth_dev *eth_dev = sa->eth_dev;
1103         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
1104         efsys_pci_config_t espcp;
1105         static const efx_pci_ops_t ops = {
1106                 .epo_config_readd = sfc_pci_config_readd,
1107                 .epo_find_mem_bar = sfc_find_mem_bar,
1108         };
1109         int rc;
1110
1111         espcp.espc_dev = pci_dev;
1112
1113         rc = efx_family_probe_bar(pci_dev->id.vendor_id,
1114                                   pci_dev->id.device_id,
1115                                   &espcp, &ops, &sa->family, mem_ebrp);
1116
1117         return rc;
1118 }
1119
1120 int
1121 sfc_probe(struct sfc_adapter *sa)
1122 {
1123         efx_bar_region_t mem_ebrp;
1124         efx_nic_t *enp;
1125         int rc;
1126
1127         sfc_log_init(sa, "entry");
1128
1129         SFC_ASSERT(sfc_adapter_is_locked(sa));
1130
1131         sa->socket_id = rte_socket_id();
1132         rte_atomic32_init(&sa->restart_required);
1133
1134         sfc_log_init(sa, "get family");
1135         rc = sfc_family(sa, &mem_ebrp);
1136         if (rc != 0)
1137                 goto fail_family;
1138         sfc_log_init(sa,
1139                      "family is %u, membar is %u, function control window offset is %lu",
1140                      sa->family, mem_ebrp.ebr_index, mem_ebrp.ebr_offset);
1141
1142         sfc_log_init(sa, "init mem bar");
1143         rc = sfc_mem_bar_init(sa, &mem_ebrp);
1144         if (rc != 0)
1145                 goto fail_mem_bar_init;
1146
1147         sfc_log_init(sa, "create nic");
1148         rte_spinlock_init(&sa->nic_lock);
1149         rc = efx_nic_create(sa->family, (efsys_identifier_t *)sa,
1150                             &sa->mem_bar, mem_ebrp.ebr_offset,
1151                             &sa->nic_lock, &enp);
1152         if (rc != 0)
1153                 goto fail_nic_create;
1154         sa->nic = enp;
1155
1156         rc = sfc_mcdi_init(sa);
1157         if (rc != 0)
1158                 goto fail_mcdi_init;
1159
1160         sfc_log_init(sa, "probe nic");
1161         rc = sfc_nic_probe(sa);
1162         if (rc != 0)
1163                 goto fail_nic_probe;
1164
1165         sfc_log_init(sa, "done");
1166         return 0;
1167
1168 fail_nic_probe:
1169         sfc_mcdi_fini(sa);
1170
1171 fail_mcdi_init:
1172         sfc_log_init(sa, "destroy nic");
1173         sa->nic = NULL;
1174         efx_nic_destroy(enp);
1175
1176 fail_nic_create:
1177         sfc_mem_bar_fini(sa);
1178
1179 fail_mem_bar_init:
1180 fail_family:
1181         sfc_log_init(sa, "failed %d", rc);
1182         return rc;
1183 }
1184
1185 void
1186 sfc_unprobe(struct sfc_adapter *sa)
1187 {
1188         efx_nic_t *enp = sa->nic;
1189
1190         sfc_log_init(sa, "entry");
1191
1192         SFC_ASSERT(sfc_adapter_is_locked(sa));
1193
1194         sfc_log_init(sa, "unprobe nic");
1195         efx_nic_unprobe(enp);
1196
1197         sfc_mcdi_fini(sa);
1198
1199         /*
1200          * Make sure there is no pending alarm to restart since we are
1201          * going to free device private which is passed as the callback
1202          * opaque data. A new alarm cannot be scheduled since MCDI is
1203          * shut down.
1204          */
1205         rte_eal_alarm_cancel(sfc_restart_if_required, sa);
1206
1207         sfc_log_init(sa, "destroy nic");
1208         sa->nic = NULL;
1209         efx_nic_destroy(enp);
1210
1211         sfc_mem_bar_fini(sa);
1212
1213         sfc_flow_fini(sa);
1214         sa->state = SFC_ADAPTER_UNINITIALIZED;
1215 }
1216
1217 uint32_t
1218 sfc_register_logtype(const struct rte_pci_addr *pci_addr,
1219                      const char *lt_prefix_str, uint32_t ll_default)
1220 {
1221         size_t lt_prefix_str_size = strlen(lt_prefix_str);
1222         size_t lt_str_size_max;
1223         char *lt_str = NULL;
1224         int ret;
1225
1226         if (SIZE_MAX - PCI_PRI_STR_SIZE - 1 > lt_prefix_str_size) {
1227                 ++lt_prefix_str_size; /* Reserve space for prefix separator */
1228                 lt_str_size_max = lt_prefix_str_size + PCI_PRI_STR_SIZE + 1;
1229         } else {
1230                 return sfc_logtype_driver;
1231         }
1232
1233         lt_str = rte_zmalloc("logtype_str", lt_str_size_max, 0);
1234         if (lt_str == NULL)
1235                 return sfc_logtype_driver;
1236
1237         strncpy(lt_str, lt_prefix_str, lt_prefix_str_size);
1238         lt_str[lt_prefix_str_size - 1] = '.';
1239         rte_pci_device_name(pci_addr, lt_str + lt_prefix_str_size,
1240                             lt_str_size_max - lt_prefix_str_size);
1241         lt_str[lt_str_size_max - 1] = '\0';
1242
1243         ret = rte_log_register_type_and_pick_level(lt_str, ll_default);
1244         rte_free(lt_str);
1245
1246         if (ret < 0)
1247                 return sfc_logtype_driver;
1248
1249         return ret;
1250 }