drivers/net/sfc/sfc.c

   1 /*-
   2  * Copyright (c) 2016 Solarflare Communications Inc.
   3  * All rights reserved.
   4  *
   5  * This software was jointly developed between OKTET Labs (under contract
   6  * for Solarflare) and Solarflare Communications, Inc.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright notice,
  12  *    this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright notice,
  14  *    this list of conditions and the following disclaimer in the documentation
  15  *    and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  18  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  19  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  24  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  25  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  27  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 /* sysconf() */
  31 #include <unistd.h>
  32
  33 #include <rte_errno.h>
  34
  35 #include "efx.h"
  36
  37 #include "sfc.h"
  38 #include "sfc_log.h"
  39 #include "sfc_ev.h"
  40 #include "sfc_rx.h"
  41 #include "sfc_tx.h"
  42
  43
  44 int
  45 sfc_dma_alloc(const struct sfc_adapter *sa, const char *name, uint16_t id,
  46               size_t len, int socket_id, efsys_mem_t *esmp)
  47 {
  48         const struct rte_memzone *mz;
  49
  50         sfc_log_init(sa, "name=%s id=%u len=%lu socket_id=%d",
  51                      name, id, len, socket_id);
  52
  53         mz = rte_eth_dma_zone_reserve(sa->eth_dev, name, id, len,
  54                                       sysconf(_SC_PAGESIZE), socket_id);
  55         if (mz == NULL) {
  56                 sfc_err(sa, "cannot reserve DMA zone for %s:%u %#x@%d: %s",
  57                         name, (unsigned int)id, (unsigned int)len, socket_id,
  58                         rte_strerror(rte_errno));
  59                 return ENOMEM;
  60         }
  61
  62         esmp->esm_addr = rte_mem_phy2mch(mz->memseg_id, mz->phys_addr);
  63         if (esmp->esm_addr == RTE_BAD_PHYS_ADDR) {
  64                 (void)rte_memzone_free(mz);
  65                 return EFAULT;
  66         }
  67
  68         esmp->esm_mz = mz;
  69         esmp->esm_base = mz->addr;
  70
  71         return 0;
  72 }
  73
  74 void
  75 sfc_dma_free(const struct sfc_adapter *sa, efsys_mem_t *esmp)
  76 {
  77         int rc;
  78
  79         sfc_log_init(sa, "name=%s", esmp->esm_mz->name);
  80
  81         rc = rte_memzone_free(esmp->esm_mz);
  82         if (rc != 0)
  83                 sfc_err(sa, "rte_memzone_free(() failed: %d", rc);
  84
  85         memset(esmp, 0, sizeof(*esmp));
  86 }
  87
  88 static uint32_t
  89 sfc_phy_cap_from_link_speeds(uint32_t speeds)
  90 {
  91         uint32_t phy_caps = 0;
  92
  93         if (~speeds & ETH_LINK_SPEED_FIXED) {
  94                 phy_caps |= (1 << EFX_PHY_CAP_AN);
  95                 /*
  96                  * If no speeds are specified in the mask, any supported
  97                  * may be negotiated
  98                  */
  99                 if (speeds == ETH_LINK_SPEED_AUTONEG)
 100                         phy_caps |=
 101                                 (1 << EFX_PHY_CAP_1000FDX) |
 102                                 (1 << EFX_PHY_CAP_10000FDX) |
 103                                 (1 << EFX_PHY_CAP_40000FDX);
 104         }
 105         if (speeds & ETH_LINK_SPEED_1G)
 106                 phy_caps |= (1 << EFX_PHY_CAP_1000FDX);
 107         if (speeds & ETH_LINK_SPEED_10G)
 108                 phy_caps |= (1 << EFX_PHY_CAP_10000FDX);
 109         if (speeds & ETH_LINK_SPEED_40G)
 110                 phy_caps |= (1 << EFX_PHY_CAP_40000FDX);
 111
 112         return phy_caps;
 113 }
 114
 115 /*
 116  * Check requested device level configuration.
 117  * Receive and transmit configuration is checked in corresponding
 118  * modules.
 119  */
 120 static int
 121 sfc_check_conf(struct sfc_adapter *sa)
 122 {
 123         const struct rte_eth_conf *conf = &sa->eth_dev->data->dev_conf;
 124         int rc = 0;
 125
 126         sa->port.phy_adv_cap =
 127                 sfc_phy_cap_from_link_speeds(conf->link_speeds) &
 128                 sa->port.phy_adv_cap_mask;
 129         if ((sa->port.phy_adv_cap & ~(1 << EFX_PHY_CAP_AN)) == 0) {
 130                 sfc_err(sa, "No link speeds from mask %#x are supported",
 131                         conf->link_speeds);
 132                 rc = EINVAL;
 133         }
 134
 135         if (conf->lpbk_mode != 0) {
 136                 sfc_err(sa, "Loopback not supported");
 137                 rc = EINVAL;
 138         }
 139
 140         if (conf->dcb_capability_en != 0) {
 141                 sfc_err(sa, "Priority-based flow control not supported");
 142                 rc = EINVAL;
 143         }
 144
 145         if (conf->fdir_conf.mode != RTE_FDIR_MODE_NONE) {
 146                 sfc_err(sa, "Flow Director not supported");
 147                 rc = EINVAL;
 148         }
 149
 150         if ((conf->intr_conf.lsc != 0) &&
 151             (sa->intr.type != EFX_INTR_LINE) &&
 152             (sa->intr.type != EFX_INTR_MESSAGE)) {
 153                 sfc_err(sa, "Link status change interrupt not supported");
 154                 rc = EINVAL;
 155         }
 156
 157         if (conf->intr_conf.rxq != 0) {
 158                 sfc_err(sa, "Receive queue interrupt not supported");
 159                 rc = EINVAL;
 160         }
 161
 162         return rc;
 163 }
 164
 165 /*
 166  * Find out maximum number of receive and transmit queues which could be
 167  * advertised.
 168  *
 169  * NIC is kept initialized on success to allow other modules acquire
 170  * defaults and capabilities.
 171  */
 172 static int
 173 sfc_estimate_resource_limits(struct sfc_adapter *sa)
 174 {
 175         const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic);
 176         efx_drv_limits_t limits;
 177         int rc;
 178         uint32_t evq_allocated;
 179         uint32_t rxq_allocated;
 180         uint32_t txq_allocated;
 181
 182         memset(&limits, 0, sizeof(limits));
 183
 184         /* Request at least one Rx and Tx queue */
 185         limits.edl_min_rxq_count = 1;
 186         limits.edl_min_txq_count = 1;
 187         /* Management event queue plus event queue for each Tx and Rx queue */
 188         limits.edl_min_evq_count =
 189                 1 + limits.edl_min_rxq_count + limits.edl_min_txq_count;
 190
 191         /* Divide by number of functions to guarantee that all functions
 192          * will get promised resources
 193          */
 194         /* FIXME Divide by number of functions (not 2) below */
 195         limits.edl_max_evq_count = encp->enc_evq_limit / 2;
 196         SFC_ASSERT(limits.edl_max_evq_count >= limits.edl_min_rxq_count);
 197
 198         /* Split equally between receive and transmit */
 199         limits.edl_max_rxq_count =
 200                 MIN(encp->enc_rxq_limit, (limits.edl_max_evq_count - 1) / 2);
 201         SFC_ASSERT(limits.edl_max_rxq_count >= limits.edl_min_rxq_count);
 202
 203         limits.edl_max_txq_count =
 204                 MIN(encp->enc_txq_limit,
 205                     limits.edl_max_evq_count - 1 - limits.edl_max_rxq_count);
 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 int
 265 sfc_start(struct sfc_adapter *sa)
 266 {
 267         int rc;
 268
 269         sfc_log_init(sa, "entry");
 270
 271         SFC_ASSERT(sfc_adapter_is_locked(sa));
 272
 273         switch (sa->state) {
 274         case SFC_ADAPTER_CONFIGURED:
 275                 break;
 276         case SFC_ADAPTER_STARTED:
 277                 sfc_info(sa, "already started");
 278                 return 0;
 279         default:
 280                 rc = EINVAL;
 281                 goto fail_bad_state;
 282         }
 283
 284         sa->state = SFC_ADAPTER_STARTING;
 285
 286         sfc_log_init(sa, "set resource limits");
 287         rc = sfc_set_drv_limits(sa);
 288         if (rc != 0)
 289                 goto fail_set_drv_limits;
 290
 291         sfc_log_init(sa, "init nic");
 292         rc = efx_nic_init(sa->nic);
 293         if (rc != 0)
 294                 goto fail_nic_init;
 295
 296         rc = sfc_intr_start(sa);
 297         if (rc != 0)
 298                 goto fail_intr_start;
 299
 300         rc = sfc_ev_start(sa);
 301         if (rc != 0)
 302                 goto fail_ev_start;
 303
 304         rc = sfc_port_start(sa);
 305         if (rc != 0)
 306                 goto fail_port_start;
 307
 308         rc = sfc_rx_start(sa);
 309         if (rc != 0)
 310                 goto fail_rx_start;
 311
 312         rc = sfc_tx_start(sa);
 313         if (rc != 0)
 314                 goto fail_tx_start;
 315
 316         sa->state = SFC_ADAPTER_STARTED;
 317         sfc_log_init(sa, "done");
 318         return 0;
 319
 320 fail_tx_start:
 321         sfc_rx_stop(sa);
 322
 323 fail_rx_start:
 324         sfc_port_stop(sa);
 325
 326 fail_port_start:
 327         sfc_ev_stop(sa);
 328
 329 fail_ev_start:
 330         sfc_intr_stop(sa);
 331
 332 fail_intr_start:
 333         efx_nic_fini(sa->nic);
 334
 335 fail_nic_init:
 336 fail_set_drv_limits:
 337         sa->state = SFC_ADAPTER_CONFIGURED;
 338 fail_bad_state:
 339         sfc_log_init(sa, "failed %d", rc);
 340         return rc;
 341 }
 342
 343 void
 344 sfc_stop(struct sfc_adapter *sa)
 345 {
 346         sfc_log_init(sa, "entry");
 347
 348         SFC_ASSERT(sfc_adapter_is_locked(sa));
 349
 350         switch (sa->state) {
 351         case SFC_ADAPTER_STARTED:
 352                 break;
 353         case SFC_ADAPTER_CONFIGURED:
 354                 sfc_info(sa, "already stopped");
 355                 return;
 356         default:
 357                 sfc_err(sa, "stop in unexpected state %u", sa->state);
 358                 SFC_ASSERT(B_FALSE);
 359                 return;
 360         }
 361
 362         sa->state = SFC_ADAPTER_STOPPING;
 363
 364         sfc_tx_stop(sa);
 365         sfc_rx_stop(sa);
 366         sfc_port_stop(sa);
 367         sfc_ev_stop(sa);
 368         sfc_intr_stop(sa);
 369         efx_nic_fini(sa->nic);
 370
 371         sa->state = SFC_ADAPTER_CONFIGURED;
 372         sfc_log_init(sa, "done");
 373 }
 374
 375 int
 376 sfc_configure(struct sfc_adapter *sa)
 377 {
 378         int rc;
 379
 380         sfc_log_init(sa, "entry");
 381
 382         SFC_ASSERT(sfc_adapter_is_locked(sa));
 383
 384         SFC_ASSERT(sa->state == SFC_ADAPTER_INITIALIZED);
 385         sa->state = SFC_ADAPTER_CONFIGURING;
 386
 387         rc = sfc_check_conf(sa);
 388         if (rc != 0)
 389                 goto fail_check_conf;
 390
 391         rc = sfc_intr_init(sa);
 392         if (rc != 0)
 393                 goto fail_intr_init;
 394
 395         rc = sfc_ev_init(sa);
 396         if (rc != 0)
 397                 goto fail_ev_init;
 398
 399         rc = sfc_port_init(sa);
 400         if (rc != 0)
 401                 goto fail_port_init;
 402
 403         rc = sfc_rx_init(sa);
 404         if (rc != 0)
 405                 goto fail_rx_init;
 406
 407         rc = sfc_tx_init(sa);
 408         if (rc != 0)
 409                 goto fail_tx_init;
 410
 411         sa->state = SFC_ADAPTER_CONFIGURED;
 412         sfc_log_init(sa, "done");
 413         return 0;
 414
 415 fail_tx_init:
 416         sfc_rx_fini(sa);
 417
 418 fail_rx_init:
 419         sfc_port_fini(sa);
 420
 421 fail_port_init:
 422         sfc_ev_fini(sa);
 423
 424 fail_ev_init:
 425         sfc_intr_fini(sa);
 426
 427 fail_intr_init:
 428 fail_check_conf:
 429         sa->state = SFC_ADAPTER_INITIALIZED;
 430         sfc_log_init(sa, "failed %d", rc);
 431         return rc;
 432 }
 433
 434 void
 435 sfc_close(struct sfc_adapter *sa)
 436 {
 437         sfc_log_init(sa, "entry");
 438
 439         SFC_ASSERT(sfc_adapter_is_locked(sa));
 440
 441         SFC_ASSERT(sa->state == SFC_ADAPTER_CONFIGURED);
 442         sa->state = SFC_ADAPTER_CLOSING;
 443
 444         sfc_tx_fini(sa);
 445         sfc_rx_fini(sa);
 446         sfc_port_fini(sa);
 447         sfc_ev_fini(sa);
 448         sfc_intr_fini(sa);
 449
 450         sa->state = SFC_ADAPTER_INITIALIZED;
 451         sfc_log_init(sa, "done");
 452 }
 453
 454 static int
 455 sfc_mem_bar_init(struct sfc_adapter *sa)
 456 {
 457         struct rte_eth_dev *eth_dev = sa->eth_dev;
 458         struct rte_pci_device *pci_dev = SFC_DEV_TO_PCI(eth_dev);
 459         efsys_bar_t *ebp = &sa->mem_bar;
 460         unsigned int i;
 461         struct rte_mem_resource *res;
 462
 463         for (i = 0; i < RTE_DIM(pci_dev->mem_resource); i++) {
 464                 res = &pci_dev->mem_resource[i];
 465                 if ((res->len != 0) && (res->phys_addr != 0)) {
 466                         /* Found first memory BAR */
 467                         SFC_BAR_LOCK_INIT(ebp, eth_dev->data->name);
 468                         ebp->esb_rid = i;
 469                         ebp->esb_dev = pci_dev;
 470                         ebp->esb_base = res->addr;
 471                         return 0;
 472                 }
 473         }
 474
 475         return EFAULT;
 476 }
 477
 478 static void
 479 sfc_mem_bar_fini(struct sfc_adapter *sa)
 480 {
 481         efsys_bar_t *ebp = &sa->mem_bar;
 482
 483         SFC_BAR_LOCK_DESTROY(ebp);
 484         memset(ebp, 0, sizeof(*ebp));
 485 }
 486
 487 int
 488 sfc_attach(struct sfc_adapter *sa)
 489 {
 490         struct rte_pci_device *pci_dev = SFC_DEV_TO_PCI(sa->eth_dev);
 491         const efx_nic_cfg_t *encp;
 492         efx_nic_t *enp;
 493         int rc;
 494
 495         sfc_log_init(sa, "entry");
 496
 497         SFC_ASSERT(sfc_adapter_is_locked(sa));
 498
 499         sa->socket_id = rte_socket_id();
 500
 501         sfc_log_init(sa, "init mem bar");
 502         rc = sfc_mem_bar_init(sa);
 503         if (rc != 0)
 504                 goto fail_mem_bar_init;
 505
 506         sfc_log_init(sa, "get family");
 507         rc = efx_family(pci_dev->id.vendor_id, pci_dev->id.device_id,
 508                         &sa->family);
 509         if (rc != 0)
 510                 goto fail_family;
 511         sfc_log_init(sa, "family is %u", sa->family);
 512
 513         sfc_log_init(sa, "create nic");
 514         rte_spinlock_init(&sa->nic_lock);
 515         rc = efx_nic_create(sa->family, (efsys_identifier_t *)sa,
 516                             &sa->mem_bar, &sa->nic_lock, &enp);
 517         if (rc != 0)
 518                 goto fail_nic_create;
 519         sa->nic = enp;
 520
 521         rc = sfc_mcdi_init(sa);
 522         if (rc != 0)
 523                 goto fail_mcdi_init;
 524
 525         sfc_log_init(sa, "probe nic");
 526         rc = efx_nic_probe(enp);
 527         if (rc != 0)
 528                 goto fail_nic_probe;
 529
 530         efx_mcdi_new_epoch(enp);
 531
 532         sfc_log_init(sa, "reset nic");
 533         rc = efx_nic_reset(enp);
 534         if (rc != 0)
 535                 goto fail_nic_reset;
 536
 537         sfc_log_init(sa, "estimate resource limits");
 538         rc = sfc_estimate_resource_limits(sa);
 539         if (rc != 0)
 540                 goto fail_estimate_rsrc_limits;
 541
 542         encp = efx_nic_cfg_get(sa->nic);
 543         sa->txq_max_entries = encp->enc_txq_max_ndescs;
 544         SFC_ASSERT(rte_is_power_of_2(sa->txq_max_entries));
 545
 546         rc = sfc_intr_attach(sa);
 547         if (rc != 0)
 548                 goto fail_intr_attach;
 549
 550         efx_phy_adv_cap_get(sa->nic, EFX_PHY_CAP_PERM,
 551                             &sa->port.phy_adv_cap_mask);
 552
 553         sfc_log_init(sa, "fini nic");
 554         efx_nic_fini(enp);
 555
 556         sa->state = SFC_ADAPTER_INITIALIZED;
 557
 558         sfc_log_init(sa, "done");
 559         return 0;
 560
 561 fail_intr_attach:
 562 fail_estimate_rsrc_limits:
 563 fail_nic_reset:
 564         sfc_log_init(sa, "unprobe nic");
 565         efx_nic_unprobe(enp);
 566
 567 fail_nic_probe:
 568         sfc_mcdi_fini(sa);
 569
 570 fail_mcdi_init:
 571         sfc_log_init(sa, "destroy nic");
 572         sa->nic = NULL;
 573         efx_nic_destroy(enp);
 574
 575 fail_nic_create:
 576 fail_family:
 577         sfc_mem_bar_fini(sa);
 578
 579 fail_mem_bar_init:
 580         sfc_log_init(sa, "failed %d", rc);
 581         return rc;
 582 }
 583
 584 void
 585 sfc_detach(struct sfc_adapter *sa)
 586 {
 587         efx_nic_t *enp = sa->nic;
 588
 589         sfc_log_init(sa, "entry");
 590
 591         SFC_ASSERT(sfc_adapter_is_locked(sa));
 592
 593         sfc_intr_detach(sa);
 594
 595         sfc_log_init(sa, "unprobe nic");
 596         efx_nic_unprobe(enp);
 597
 598         sfc_mcdi_fini(sa);
 599
 600         sfc_log_init(sa, "destroy nic");
 601         sa->nic = NULL;
 602         efx_nic_destroy(enp);
 603
 604         sfc_mem_bar_fini(sa);
 605
 606         sa->state = SFC_ADAPTER_UNINITIALIZED;
 607 }