1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) 2016-2017 Solarflare Communications Inc. 5 * All rights reserved. 6 * 7 * This software was jointly developed between OKTET Labs (under contract 8 * for Solarflare) and Solarflare Communications, Inc. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions are met: 12 * 13 * 1. Redistributions of source code must retain the above copyright notice, 14 * this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright notice, 16 * this list of conditions and the following disclaimer in the documentation 17 * and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 29 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* sysconf() */ 33 #include <unistd.h> 34 35 #include <rte_errno.h> 36 #include <rte_alarm.h> 37 38 #include "efx.h" 39 40 #include "sfc.h" 41 #include "sfc_log.h" 42 #include "sfc_ev.h" 43 #include "sfc_rx.h" 44 #include "sfc_tx.h" 45 46 47 int 48 sfc_dma_alloc(const struct sfc_adapter *sa, const char *name, uint16_t id, 49 size_t len, int socket_id, efsys_mem_t *esmp) 50 { 51 const struct rte_memzone *mz; 52 53 sfc_log_init(sa, "name=%s id=%u len=%lu socket_id=%d", 54 name, id, len, socket_id); 55 56 mz = rte_eth_dma_zone_reserve(sa->eth_dev, name, id, len, 57 sysconf(_SC_PAGESIZE), socket_id); 58 if (mz == NULL) { 59 sfc_err(sa, "cannot reserve DMA zone for %s:%u %#x@%d: %s", 60 name, (unsigned int)id, (unsigned int)len, socket_id, 61 rte_strerror(rte_errno)); 62 return ENOMEM; 63 } 64 65 esmp->esm_addr = mz->iova; 66 if (esmp->esm_addr == RTE_BAD_IOVA) { 67 (void)rte_memzone_free(mz); 68 return EFAULT; 69 } 70 71 esmp->esm_mz = mz; 72 esmp->esm_base = mz->addr; 73 74 return 0; 75 } 76 77 void 78 sfc_dma_free(const struct sfc_adapter *sa, efsys_mem_t *esmp) 79 { 80 int rc; 81 82 sfc_log_init(sa, "name=%s", esmp->esm_mz->name); 83 84 rc = rte_memzone_free(esmp->esm_mz); 85 if (rc != 0) 86 sfc_err(sa, "rte_memzone_free(() failed: %d", rc); 87 88 memset(esmp, 0, sizeof(*esmp)); 89 } 90 91 static uint32_t 92 sfc_phy_cap_from_link_speeds(uint32_t speeds) 93 { 94 uint32_t phy_caps = 0; 95 96 if (~speeds & ETH_LINK_SPEED_FIXED) { 97 phy_caps |= (1 << EFX_PHY_CAP_AN); 98 /* 99 * If no speeds are specified in the mask, any supported 100 * may be negotiated 101 */ 102 if (speeds == ETH_LINK_SPEED_AUTONEG) 103 phy_caps |= 104 (1 << EFX_PHY_CAP_1000FDX) | 105 (1 << EFX_PHY_CAP_10000FDX) | 106 (1 << EFX_PHY_CAP_40000FDX); 107 } 108 if (speeds & ETH_LINK_SPEED_1G) 109 phy_caps |= (1 << EFX_PHY_CAP_1000FDX); 110 if (speeds & ETH_LINK_SPEED_10G) 111 phy_caps |= (1 << EFX_PHY_CAP_10000FDX); 112 if (speeds & ETH_LINK_SPEED_40G) 113 phy_caps |= (1 << EFX_PHY_CAP_40000FDX); 114 115 return phy_caps; 116 } 117 118 /* 119 * Check requested device level configuration. 120 * Receive and transmit configuration is checked in corresponding 121 * modules. 122 */ 123 static int 124 sfc_check_conf(struct sfc_adapter *sa) 125 { 126 const struct rte_eth_conf *conf = &sa->eth_dev->data->dev_conf; 127 int rc = 0; 128 129 sa->port.phy_adv_cap = 130 sfc_phy_cap_from_link_speeds(conf->link_speeds) & 131 sa->port.phy_adv_cap_mask; 132 if ((sa->port.phy_adv_cap & ~(1 << EFX_PHY_CAP_AN)) == 0) { 133 sfc_err(sa, "No link speeds from mask %#x are supported", 134 conf->link_speeds); 135 rc = EINVAL; 136 } 137 138 if (conf->lpbk_mode != 0) { 139 sfc_err(sa, "Loopback not supported"); 140 rc = EINVAL; 141 } 142 143 if (conf->dcb_capability_en != 0) { 144 sfc_err(sa, "Priority-based flow control not supported"); 145 rc = EINVAL; 146 } 147 148 if (conf->fdir_conf.mode != RTE_FDIR_MODE_NONE) { 149 sfc_err(sa, "Flow Director not supported"); 150 rc = EINVAL; 151 } 152 153 if ((conf->intr_conf.lsc != 0) && 154 (sa->intr.type != EFX_INTR_LINE) && 155 (sa->intr.type != EFX_INTR_MESSAGE)) { 156 sfc_err(sa, "Link status change interrupt not supported"); 157 rc = EINVAL; 158 } 159 160 if (conf->intr_conf.rxq != 0) { 161 sfc_err(sa, "Receive queue interrupt not supported"); 162 rc = EINVAL; 163 } 164 165 return rc; 166 } 167 168 /* 169 * Find out maximum number of receive and transmit queues which could be 170 * advertised. 171 * 172 * NIC is kept initialized on success to allow other modules acquire 173 * defaults and capabilities. 174 */ 175 static int 176 sfc_estimate_resource_limits(struct sfc_adapter *sa) 177 { 178 const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic); 179 efx_drv_limits_t limits; 180 int rc; 181 uint32_t evq_allocated; 182 uint32_t rxq_allocated; 183 uint32_t txq_allocated; 184 185 memset(&limits, 0, sizeof(limits)); 186 187 /* Request at least one Rx and Tx queue */ 188 limits.edl_min_rxq_count = 1; 189 limits.edl_min_txq_count = 1; 190 /* Management event queue plus event queue for each Tx and Rx queue */ 191 limits.edl_min_evq_count = 192 1 + limits.edl_min_rxq_count + limits.edl_min_txq_count; 193 194 /* Divide by number of functions to guarantee that all functions 195 * will get promised resources 196 */ 197 /* FIXME Divide by number of functions (not 2) below */ 198 limits.edl_max_evq_count = encp->enc_evq_limit / 2; 199 SFC_ASSERT(limits.edl_max_evq_count >= limits.edl_min_rxq_count); 200 201 /* Split equally between receive and transmit */ 202 limits.edl_max_rxq_count = 203 MIN(encp->enc_rxq_limit, (limits.edl_max_evq_count - 1) / 2); 204 SFC_ASSERT(limits.edl_max_rxq_count >= limits.edl_min_rxq_count); 205 206 limits.edl_max_txq_count = 207 MIN(encp->enc_txq_limit, 208 limits.edl_max_evq_count - 1 - limits.edl_max_rxq_count); 209 210 if (sa->tso) 211 limits.edl_max_txq_count = 212 MIN(limits.edl_max_txq_count, 213 encp->enc_fw_assisted_tso_v2_n_contexts / 214 encp->enc_hw_pf_count); 215 216 SFC_ASSERT(limits.edl_max_txq_count >= limits.edl_min_rxq_count); 217 218 /* Configure the minimum required resources needed for the 219 * driver to operate, and the maximum desired resources that the 220 * driver is capable of using. 221 */ 222 efx_nic_set_drv_limits(sa->nic, &limits); 223 224 sfc_log_init(sa, "init nic"); 225 rc = efx_nic_init(sa->nic); 226 if (rc != 0) 227 goto fail_nic_init; 228 229 /* Find resource dimensions assigned by firmware to this function */ 230 rc = efx_nic_get_vi_pool(sa->nic, &evq_allocated, &rxq_allocated, 231 &txq_allocated); 232 if (rc != 0) 233 goto fail_get_vi_pool; 234 235 /* It still may allocate more than maximum, ensure limit */ 236 evq_allocated = MIN(evq_allocated, limits.edl_max_evq_count); 237 rxq_allocated = MIN(rxq_allocated, limits.edl_max_rxq_count); 238 txq_allocated = MIN(txq_allocated, limits.edl_max_txq_count); 239 240 /* Subtract management EVQ not used for traffic */ 241 SFC_ASSERT(evq_allocated > 0); 242 evq_allocated--; 243 244 /* Right now we use separate EVQ for Rx and Tx */ 245 sa->rxq_max = MIN(rxq_allocated, evq_allocated / 2); 246 sa->txq_max = MIN(txq_allocated, evq_allocated - sa->rxq_max); 247 248 /* Keep NIC initialized */ 249 return 0; 250 251 fail_get_vi_pool: 252 fail_nic_init: 253 efx_nic_fini(sa->nic); 254 return rc; 255 } 256 257 static int 258 sfc_set_drv_limits(struct sfc_adapter *sa) 259 { 260 const struct rte_eth_dev_data *data = sa->eth_dev->data; 261 efx_drv_limits_t lim; 262 263 memset(&lim, 0, sizeof(lim)); 264 265 /* Limits are strict since take into account initial estimation */ 266 lim.edl_min_evq_count = lim.edl_max_evq_count = 267 1 + data->nb_rx_queues + data->nb_tx_queues; 268 lim.edl_min_rxq_count = lim.edl_max_rxq_count = data->nb_rx_queues; 269 lim.edl_min_txq_count = lim.edl_max_txq_count = data->nb_tx_queues; 270 271 return efx_nic_set_drv_limits(sa->nic, &lim); 272 } 273 274 static int 275 sfc_try_start(struct sfc_adapter *sa) 276 { 277 const efx_nic_cfg_t *encp; 278 int rc; 279 280 sfc_log_init(sa, "entry"); 281 282 SFC_ASSERT(sfc_adapter_is_locked(sa)); 283 SFC_ASSERT(sa->state == SFC_ADAPTER_STARTING); 284 285 sfc_log_init(sa, "set resource limits"); 286 rc = sfc_set_drv_limits(sa); 287 if (rc != 0) 288 goto fail_set_drv_limits; 289 290 sfc_log_init(sa, "init nic"); 291 rc = efx_nic_init(sa->nic); 292 if (rc != 0) 293 goto fail_nic_init; 294 295 encp = efx_nic_cfg_get(sa->nic); 296 if (encp->enc_tunnel_encapsulations_supported != 0) { 297 sfc_log_init(sa, "apply tunnel config"); 298 rc = efx_tunnel_reconfigure(sa->nic); 299 if (rc != 0) 300 goto fail_tunnel_reconfigure; 301 } 302 303 rc = sfc_intr_start(sa); 304 if (rc != 0) 305 goto fail_intr_start; 306 307 rc = sfc_ev_start(sa); 308 if (rc != 0) 309 goto fail_ev_start; 310 311 rc = sfc_port_start(sa); 312 if (rc != 0) 313 goto fail_port_start; 314 315 rc = sfc_rx_start(sa); 316 if (rc != 0) 317 goto fail_rx_start; 318 319 rc = sfc_tx_start(sa); 320 if (rc != 0) 321 goto fail_tx_start; 322 323 rc = sfc_flow_start(sa); 324 if (rc != 0) 325 goto fail_flows_insert; 326 327 sfc_log_init(sa, "done"); 328 return 0; 329 330 fail_flows_insert: 331 sfc_tx_stop(sa); 332 333 fail_tx_start: 334 sfc_rx_stop(sa); 335 336 fail_rx_start: 337 sfc_port_stop(sa); 338 339 fail_port_start: 340 sfc_ev_stop(sa); 341 342 fail_ev_start: 343 sfc_intr_stop(sa); 344 345 fail_intr_start: 346 fail_tunnel_reconfigure: 347 efx_nic_fini(sa->nic); 348 349 fail_nic_init: 350 fail_set_drv_limits: 351 sfc_log_init(sa, "failed %d", rc); 352 return rc; 353 } 354 355 int 356 sfc_start(struct sfc_adapter *sa) 357 { 358 unsigned int start_tries = 3; 359 int rc; 360 361 sfc_log_init(sa, "entry"); 362 363 SFC_ASSERT(sfc_adapter_is_locked(sa)); 364 365 switch (sa->state) { 366 case SFC_ADAPTER_CONFIGURED: 367 break; 368 case SFC_ADAPTER_STARTED: 369 sfc_info(sa, "already started"); 370 return 0; 371 default: 372 rc = EINVAL; 373 goto fail_bad_state; 374 } 375 376 sa->state = SFC_ADAPTER_STARTING; 377 378 do { 379 rc = sfc_try_start(sa); 380 } while ((--start_tries > 0) && 381 (rc == EIO || rc == EAGAIN || rc == ENOENT || rc == EINVAL)); 382 383 if (rc != 0) 384 goto fail_try_start; 385 386 sa->state = SFC_ADAPTER_STARTED; 387 sfc_log_init(sa, "done"); 388 return 0; 389 390 fail_try_start: 391 sa->state = SFC_ADAPTER_CONFIGURED; 392 fail_bad_state: 393 sfc_log_init(sa, "failed %d", rc); 394 return rc; 395 } 396 397 void 398 sfc_stop(struct sfc_adapter *sa) 399 { 400 sfc_log_init(sa, "entry"); 401 402 SFC_ASSERT(sfc_adapter_is_locked(sa)); 403 404 switch (sa->state) { 405 case SFC_ADAPTER_STARTED: 406 break; 407 case SFC_ADAPTER_CONFIGURED: 408 sfc_info(sa, "already stopped"); 409 return; 410 default: 411 sfc_err(sa, "stop in unexpected state %u", sa->state); 412 SFC_ASSERT(B_FALSE); 413 return; 414 } 415 416 sa->state = SFC_ADAPTER_STOPPING; 417 418 sfc_flow_stop(sa); 419 sfc_tx_stop(sa); 420 sfc_rx_stop(sa); 421 sfc_port_stop(sa); 422 sfc_ev_stop(sa); 423 sfc_intr_stop(sa); 424 efx_nic_fini(sa->nic); 425 426 sa->state = SFC_ADAPTER_CONFIGURED; 427 sfc_log_init(sa, "done"); 428 } 429 430 static int 431 sfc_restart(struct sfc_adapter *sa) 432 { 433 int rc; 434 435 SFC_ASSERT(sfc_adapter_is_locked(sa)); 436 437 if (sa->state != SFC_ADAPTER_STARTED) 438 return EINVAL; 439 440 sfc_stop(sa); 441 442 rc = sfc_start(sa); 443 if (rc != 0) 444 sfc_err(sa, "restart failed"); 445 446 return rc; 447 } 448 449 static void 450 sfc_restart_if_required(void *arg) 451 { 452 struct sfc_adapter *sa = arg; 453 454 /* If restart is scheduled, clear the flag and do it */ 455 if (rte_atomic32_cmpset((volatile uint32_t *)&sa->restart_required, 456 1, 0)) { 457 sfc_adapter_lock(sa); 458 if (sa->state == SFC_ADAPTER_STARTED) 459 (void)sfc_restart(sa); 460 sfc_adapter_unlock(sa); 461 } 462 } 463 464 void 465 sfc_schedule_restart(struct sfc_adapter *sa) 466 { 467 int rc; 468 469 /* Schedule restart alarm if it is not scheduled yet */ 470 if (!rte_atomic32_test_and_set(&sa->restart_required)) 471 return; 472 473 rc = rte_eal_alarm_set(1, sfc_restart_if_required, sa); 474 if (rc == -ENOTSUP) 475 sfc_warn(sa, "alarms are not supported, restart is pending"); 476 else if (rc != 0) 477 sfc_err(sa, "cannot arm restart alarm (rc=%d)", rc); 478 else 479 sfc_info(sa, "restart scheduled"); 480 } 481 482 int 483 sfc_configure(struct sfc_adapter *sa) 484 { 485 int rc; 486 487 sfc_log_init(sa, "entry"); 488 489 SFC_ASSERT(sfc_adapter_is_locked(sa)); 490 491 SFC_ASSERT(sa->state == SFC_ADAPTER_INITIALIZED || 492 sa->state == SFC_ADAPTER_CONFIGURED); 493 sa->state = SFC_ADAPTER_CONFIGURING; 494 495 rc = sfc_check_conf(sa); 496 if (rc != 0) 497 goto fail_check_conf; 498 499 rc = sfc_intr_configure(sa); 500 if (rc != 0) 501 goto fail_intr_configure; 502 503 rc = sfc_port_configure(sa); 504 if (rc != 0) 505 goto fail_port_configure; 506 507 rc = sfc_rx_configure(sa); 508 if (rc != 0) 509 goto fail_rx_configure; 510 511 rc = sfc_tx_configure(sa); 512 if (rc != 0) 513 goto fail_tx_configure; 514 515 sa->state = SFC_ADAPTER_CONFIGURED; 516 sfc_log_init(sa, "done"); 517 return 0; 518 519 fail_tx_configure: 520 sfc_rx_close(sa); 521 522 fail_rx_configure: 523 sfc_port_close(sa); 524 525 fail_port_configure: 526 sfc_intr_close(sa); 527 528 fail_intr_configure: 529 fail_check_conf: 530 sa->state = SFC_ADAPTER_INITIALIZED; 531 sfc_log_init(sa, "failed %d", rc); 532 return rc; 533 } 534 535 void 536 sfc_close(struct sfc_adapter *sa) 537 { 538 sfc_log_init(sa, "entry"); 539 540 SFC_ASSERT(sfc_adapter_is_locked(sa)); 541 542 SFC_ASSERT(sa->state == SFC_ADAPTER_CONFIGURED); 543 sa->state = SFC_ADAPTER_CLOSING; 544 545 sfc_tx_close(sa); 546 sfc_rx_close(sa); 547 sfc_port_close(sa); 548 sfc_intr_close(sa); 549 550 sa->state = SFC_ADAPTER_INITIALIZED; 551 sfc_log_init(sa, "done"); 552 } 553 554 static int 555 sfc_mem_bar_init(struct sfc_adapter *sa) 556 { 557 struct rte_eth_dev *eth_dev = sa->eth_dev; 558 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev); 559 efsys_bar_t *ebp = &sa->mem_bar; 560 unsigned int i; 561 struct rte_mem_resource *res; 562 563 for (i = 0; i < RTE_DIM(pci_dev->mem_resource); i++) { 564 res = &pci_dev->mem_resource[i]; 565 if ((res->len != 0) && (res->phys_addr != 0)) { 566 /* Found first memory BAR */ 567 SFC_BAR_LOCK_INIT(ebp, eth_dev->data->name); 568 ebp->esb_rid = i; 569 ebp->esb_dev = pci_dev; 570 ebp->esb_base = res->addr; 571 return 0; 572 } 573 } 574 575 return EFAULT; 576 } 577 578 static void 579 sfc_mem_bar_fini(struct sfc_adapter *sa) 580 { 581 efsys_bar_t *ebp = &sa->mem_bar; 582 583 SFC_BAR_LOCK_DESTROY(ebp); 584 memset(ebp, 0, sizeof(*ebp)); 585 } 586 587 #if EFSYS_OPT_RX_SCALE 588 /* 589 * A fixed RSS key which has a property of being symmetric 590 * (symmetrical flows are distributed to the same CPU) 591 * and also known to give a uniform distribution 592 * (a good distribution of traffic between different CPUs) 593 */ 594 static const uint8_t default_rss_key[EFX_RSS_KEY_SIZE] = { 595 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 596 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 597 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 598 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 599 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 600 }; 601 #endif 602 603 #if EFSYS_OPT_RX_SCALE 604 static int 605 sfc_set_rss_defaults(struct sfc_adapter *sa) 606 { 607 int rc; 608 609 rc = efx_intr_init(sa->nic, sa->intr.type, NULL); 610 if (rc != 0) 611 goto fail_intr_init; 612 613 rc = efx_ev_init(sa->nic); 614 if (rc != 0) 615 goto fail_ev_init; 616 617 rc = efx_rx_init(sa->nic); 618 if (rc != 0) 619 goto fail_rx_init; 620 621 rc = efx_rx_scale_default_support_get(sa->nic, &sa->rss_support); 622 if (rc != 0) 623 goto fail_scale_support_get; 624 625 rc = efx_rx_hash_default_support_get(sa->nic, &sa->hash_support); 626 if (rc != 0) 627 goto fail_hash_support_get; 628 629 efx_rx_fini(sa->nic); 630 efx_ev_fini(sa->nic); 631 efx_intr_fini(sa->nic); 632 633 sa->rss_hash_types = sfc_rte_to_efx_hash_type(SFC_RSS_OFFLOADS); 634 635 rte_memcpy(sa->rss_key, default_rss_key, sizeof(sa->rss_key)); 636 637 return 0; 638 639 fail_hash_support_get: 640 fail_scale_support_get: 641 fail_rx_init: 642 efx_ev_fini(sa->nic); 643 644 fail_ev_init: 645 efx_intr_fini(sa->nic); 646 647 fail_intr_init: 648 return rc; 649 } 650 #else 651 static int 652 sfc_set_rss_defaults(__rte_unused struct sfc_adapter *sa) 653 { 654 return 0; 655 } 656 #endif 657 658 int 659 sfc_attach(struct sfc_adapter *sa) 660 { 661 const efx_nic_cfg_t *encp; 662 efx_nic_t *enp = sa->nic; 663 int rc; 664 665 sfc_log_init(sa, "entry"); 666 667 SFC_ASSERT(sfc_adapter_is_locked(sa)); 668 669 efx_mcdi_new_epoch(enp); 670 671 sfc_log_init(sa, "reset nic"); 672 rc = efx_nic_reset(enp); 673 if (rc != 0) 674 goto fail_nic_reset; 675 676 /* 677 * Probed NIC is sufficient for tunnel init. 678 * Initialize tunnel support to be able to use libefx 679 * efx_tunnel_config_udp_{add,remove}() in any state and 680 * efx_tunnel_reconfigure() on start up. 681 */ 682 rc = efx_tunnel_init(enp); 683 if (rc != 0) 684 goto fail_tunnel_init; 685 686 encp = efx_nic_cfg_get(sa->nic); 687 688 if (sa->dp_tx->features & SFC_DP_TX_FEAT_TSO) { 689 sa->tso = encp->enc_fw_assisted_tso_v2_enabled; 690 if (!sa->tso) 691 sfc_warn(sa, 692 "TSO support isn't available on this adapter"); 693 } 694 695 sfc_log_init(sa, "estimate resource limits"); 696 rc = sfc_estimate_resource_limits(sa); 697 if (rc != 0) 698 goto fail_estimate_rsrc_limits; 699 700 sa->txq_max_entries = encp->enc_txq_max_ndescs; 701 SFC_ASSERT(rte_is_power_of_2(sa->txq_max_entries)); 702 703 rc = sfc_intr_attach(sa); 704 if (rc != 0) 705 goto fail_intr_attach; 706 707 rc = sfc_ev_attach(sa); 708 if (rc != 0) 709 goto fail_ev_attach; 710 711 rc = sfc_port_attach(sa); 712 if (rc != 0) 713 goto fail_port_attach; 714 715 rc = sfc_set_rss_defaults(sa); 716 if (rc != 0) 717 goto fail_set_rss_defaults; 718 719 rc = sfc_filter_attach(sa); 720 if (rc != 0) 721 goto fail_filter_attach; 722 723 sfc_log_init(sa, "fini nic"); 724 efx_nic_fini(enp); 725 726 sfc_flow_init(sa); 727 728 sa->state = SFC_ADAPTER_INITIALIZED; 729 730 sfc_log_init(sa, "done"); 731 return 0; 732 733 fail_filter_attach: 734 fail_set_rss_defaults: 735 sfc_port_detach(sa); 736 737 fail_port_attach: 738 sfc_ev_detach(sa); 739 740 fail_ev_attach: 741 sfc_intr_detach(sa); 742 743 fail_intr_attach: 744 efx_nic_fini(sa->nic); 745 746 fail_estimate_rsrc_limits: 747 fail_tunnel_init: 748 efx_tunnel_fini(sa->nic); 749 750 fail_nic_reset: 751 752 sfc_log_init(sa, "failed %d", rc); 753 return rc; 754 } 755 756 void 757 sfc_detach(struct sfc_adapter *sa) 758 { 759 sfc_log_init(sa, "entry"); 760 761 SFC_ASSERT(sfc_adapter_is_locked(sa)); 762 763 sfc_flow_fini(sa); 764 765 sfc_filter_detach(sa); 766 sfc_port_detach(sa); 767 sfc_ev_detach(sa); 768 sfc_intr_detach(sa); 769 efx_tunnel_fini(sa->nic); 770 771 sa->state = SFC_ADAPTER_UNINITIALIZED; 772 } 773 774 int 775 sfc_probe(struct sfc_adapter *sa) 776 { 777 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(sa->eth_dev); 778 efx_nic_t *enp; 779 int rc; 780 781 sfc_log_init(sa, "entry"); 782 783 SFC_ASSERT(sfc_adapter_is_locked(sa)); 784 785 sa->socket_id = rte_socket_id(); 786 rte_atomic32_init(&sa->restart_required); 787 788 sfc_log_init(sa, "init mem bar"); 789 rc = sfc_mem_bar_init(sa); 790 if (rc != 0) 791 goto fail_mem_bar_init; 792 793 sfc_log_init(sa, "get family"); 794 rc = efx_family(pci_dev->id.vendor_id, pci_dev->id.device_id, 795 &sa->family); 796 if (rc != 0) 797 goto fail_family; 798 sfc_log_init(sa, "family is %u", sa->family); 799 800 sfc_log_init(sa, "create nic"); 801 rte_spinlock_init(&sa->nic_lock); 802 rc = efx_nic_create(sa->family, (efsys_identifier_t *)sa, 803 &sa->mem_bar, &sa->nic_lock, &enp); 804 if (rc != 0) 805 goto fail_nic_create; 806 sa->nic = enp; 807 808 rc = sfc_mcdi_init(sa); 809 if (rc != 0) 810 goto fail_mcdi_init; 811 812 sfc_log_init(sa, "probe nic"); 813 rc = efx_nic_probe(enp); 814 if (rc != 0) 815 goto fail_nic_probe; 816 817 sfc_log_init(sa, "done"); 818 return 0; 819 820 fail_nic_probe: 821 sfc_mcdi_fini(sa); 822 823 fail_mcdi_init: 824 sfc_log_init(sa, "destroy nic"); 825 sa->nic = NULL; 826 efx_nic_destroy(enp); 827 828 fail_nic_create: 829 fail_family: 830 sfc_mem_bar_fini(sa); 831 832 fail_mem_bar_init: 833 sfc_log_init(sa, "failed %d", rc); 834 return rc; 835 } 836 837 void 838 sfc_unprobe(struct sfc_adapter *sa) 839 { 840 efx_nic_t *enp = sa->nic; 841 842 sfc_log_init(sa, "entry"); 843 844 SFC_ASSERT(sfc_adapter_is_locked(sa)); 845 846 sfc_log_init(sa, "unprobe nic"); 847 efx_nic_unprobe(enp); 848 849 sfc_mcdi_fini(sa); 850 851 /* 852 * Make sure there is no pending alarm to restart since we are 853 * going to free device private which is passed as the callback 854 * opaque data. A new alarm cannot be scheduled since MCDI is 855 * shut down. 856 */ 857 rte_eal_alarm_cancel(sfc_restart_if_required, sa); 858 859 sfc_log_init(sa, "destroy nic"); 860 sa->nic = NULL; 861 efx_nic_destroy(enp); 862 863 sfc_mem_bar_fini(sa); 864 865 sfc_flow_fini(sa); 866 sa->state = SFC_ADAPTER_UNINITIALIZED; 867 } 868