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