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