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