drivers/net/sfc/sfc_ef10_tx.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  * Copyright (c) 2016 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 #include <stdbool.h>
  33
  34 #include <rte_mbuf.h>
  35 #include <rte_io.h>
  36
  37 #include "efx.h"
  38 #include "efx_types.h"
  39 #include "efx_regs.h"
  40 #include "efx_regs_ef10.h"
  41
  42 #include "sfc_dp_tx.h"
  43 #include "sfc_tweak.h"
  44 #include "sfc_kvargs.h"
  45 #include "sfc_ef10.h"
  46
  47 #define sfc_ef10_tx_err(dpq, ...) \
  48         SFC_DP_LOG(SFC_KVARG_DATAPATH_EF10, ERR, dpq, __VA_ARGS__)
  49
  50 /** Maximum length of the DMA descriptor data */
  51 #define SFC_EF10_TX_DMA_DESC_LEN_MAX \
  52         ((1u << ESF_DZ_TX_KER_BYTE_CNT_WIDTH) - 1)
  53
  54 /**
  55  * Maximum number of descriptors/buffers in the Tx ring.
  56  * It should guarantee that corresponding event queue never overfill.
  57  * EF10 native datapath uses event queue of the same size as Tx queue.
  58  * Maximum number of events on datapath can be estimated as number of
  59  * Tx queue entries (one event per Tx buffer in the worst case) plus
  60  * Tx error and flush events.
  61  */
  62 #define SFC_EF10_TXQ_LIMIT(_ndesc) \
  63         ((_ndesc) - 1 /* head must not step on tail */ - \
  64          (SFC_EF10_EV_PER_CACHE_LINE - 1) /* max unused EvQ entries */ - \
  65          1 /* Rx error */ - 1 /* flush */)
  66
  67 struct sfc_ef10_tx_sw_desc {
  68         struct rte_mbuf                 *mbuf;
  69 };
  70
  71 struct sfc_ef10_txq {
  72         unsigned int                    flags;
  73 #define SFC_EF10_TXQ_STARTED            0x1
  74 #define SFC_EF10_TXQ_NOT_RUNNING        0x2
  75 #define SFC_EF10_TXQ_EXCEPTION          0x4
  76
  77         unsigned int                    ptr_mask;
  78         unsigned int                    added;
  79         unsigned int                    completed;
  80         unsigned int                    free_thresh;
  81         unsigned int                    evq_read_ptr;
  82         struct sfc_ef10_tx_sw_desc      *sw_ring;
  83         efx_qword_t                     *txq_hw_ring;
  84         volatile void                   *doorbell;
  85         efx_qword_t                     *evq_hw_ring;
  86
  87         /* Datapath transmit queue anchor */
  88         struct sfc_dp_txq               dp;
  89 };
  90
  91 static inline struct sfc_ef10_txq *
  92 sfc_ef10_txq_by_dp_txq(struct sfc_dp_txq *dp_txq)
  93 {
  94         return container_of(dp_txq, struct sfc_ef10_txq, dp);
  95 }
  96
  97 static bool
  98 sfc_ef10_tx_get_event(struct sfc_ef10_txq *txq, efx_qword_t *tx_ev)
  99 {
 100         volatile efx_qword_t *evq_hw_ring = txq->evq_hw_ring;
 101
 102         /*
 103          * Exception flag is set when reap is done.
 104          * It is never done twice per packet burst get and absence of
 105          * the flag is checked on burst get entry.
 106          */
 107         SFC_ASSERT((txq->flags & SFC_EF10_TXQ_EXCEPTION) == 0);
 108
 109         *tx_ev = evq_hw_ring[txq->evq_read_ptr & txq->ptr_mask];
 110
 111         if (!sfc_ef10_ev_present(*tx_ev))
 112                 return false;
 113
 114         if (unlikely(EFX_QWORD_FIELD(*tx_ev, FSF_AZ_EV_CODE) !=
 115                      FSE_AZ_EV_CODE_TX_EV)) {
 116                 /*
 117                  * Do not move read_ptr to keep the event for exception
 118                  * handling by the control path.
 119                  */
 120                 txq->flags |= SFC_EF10_TXQ_EXCEPTION;
 121                 sfc_ef10_tx_err(&txq->dp.dpq,
 122                                 "TxQ exception at EvQ read ptr %#x",
 123                                 txq->evq_read_ptr);
 124                 return false;
 125         }
 126
 127         txq->evq_read_ptr++;
 128         return true;
 129 }
 130
 131 static unsigned int
 132 sfc_ef10_tx_process_events(struct sfc_ef10_txq *txq)
 133 {
 134         const unsigned int curr_done = txq->completed - 1;
 135         unsigned int anew_done = curr_done;
 136         efx_qword_t tx_ev;
 137
 138         while (sfc_ef10_tx_get_event(txq, &tx_ev)) {
 139                 /*
 140                  * DROP_EVENT is an internal to the NIC, software should
 141                  * never see it and, therefore, may ignore it.
 142                  */
 143
 144                 /* Update the latest done descriptor */
 145                 anew_done = EFX_QWORD_FIELD(tx_ev, ESF_DZ_TX_DESCR_INDX);
 146         }
 147         return (anew_done - curr_done) & txq->ptr_mask;
 148 }
 149
 150 static void
 151 sfc_ef10_tx_reap(struct sfc_ef10_txq *txq)
 152 {
 153         const unsigned int old_read_ptr = txq->evq_read_ptr;
 154         const unsigned int ptr_mask = txq->ptr_mask;
 155         unsigned int completed = txq->completed;
 156         unsigned int pending = completed;
 157
 158         pending += sfc_ef10_tx_process_events(txq);
 159
 160         if (pending != completed) {
 161                 do {
 162                         struct sfc_ef10_tx_sw_desc *txd;
 163
 164                         txd = &txq->sw_ring[completed & ptr_mask];
 165
 166                         if (txd->mbuf != NULL) {
 167                                 rte_pktmbuf_free(txd->mbuf);
 168                                 txd->mbuf = NULL;
 169                         }
 170                 } while (++completed != pending);
 171
 172                 txq->completed = completed;
 173         }
 174
 175         sfc_ef10_ev_qclear(txq->evq_hw_ring, ptr_mask, old_read_ptr,
 176                            txq->evq_read_ptr);
 177 }
 178
 179 static void
 180 sfc_ef10_tx_qdesc_dma_create(phys_addr_t addr, uint16_t size, bool eop,
 181                              efx_qword_t *edp)
 182 {
 183         EFX_POPULATE_QWORD_4(*edp,
 184                              ESF_DZ_TX_KER_TYPE, 0,
 185                              ESF_DZ_TX_KER_CONT, !eop,
 186                              ESF_DZ_TX_KER_BYTE_CNT, size,
 187                              ESF_DZ_TX_KER_BUF_ADDR, addr);
 188 }
 189
 190 static inline void
 191 sfc_ef10_tx_qpush(struct sfc_ef10_txq *txq, unsigned int added,
 192                   unsigned int pushed)
 193 {
 194         efx_qword_t desc;
 195         efx_oword_t oword;
 196
 197         /*
 198          * This improves performance by pushing a TX descriptor at the same
 199          * time as the doorbell. The descriptor must be added to the TXQ,
 200          * so that can be used if the hardware decides not to use the pushed
 201          * descriptor.
 202          */
 203         desc.eq_u64[0] = txq->txq_hw_ring[pushed & txq->ptr_mask].eq_u64[0];
 204         EFX_POPULATE_OWORD_3(oword,
 205                 ERF_DZ_TX_DESC_WPTR, added & txq->ptr_mask,
 206                 ERF_DZ_TX_DESC_HWORD, EFX_QWORD_FIELD(desc, EFX_DWORD_1),
 207                 ERF_DZ_TX_DESC_LWORD, EFX_QWORD_FIELD(desc, EFX_DWORD_0));
 208
 209         /* DMA sync to device is not required */
 210
 211         /*
 212          * rte_io_wmb() which guarantees that the STORE operations
 213          * (i.e. Tx and event descriptor updates) that precede
 214          * the rte_io_wmb() call are visible to NIC before the STORE
 215          * operations that follow it (i.e. doorbell write).
 216          */
 217         rte_io_wmb();
 218
 219         *(volatile __m128i *)txq->doorbell = oword.eo_u128[0];
 220 }
 221
 222 static unsigned int
 223 sfc_ef10_tx_pkt_descs_max(const struct rte_mbuf *m)
 224 {
 225         unsigned int extra_descs_per_seg;
 226         unsigned int extra_descs_per_pkt;
 227
 228         /*
 229          * VLAN offload is not supported yet, so no extra descriptors
 230          * are required for VLAN option descriptor.
 231          */
 232
 233 /** Maximum length of the mbuf segment data */
 234 #define SFC_MBUF_SEG_LEN_MAX            UINT16_MAX
 235         RTE_BUILD_BUG_ON(sizeof(m->data_len) != 2);
 236
 237         /*
 238          * Each segment is already counted once below.  So, calculate
 239          * how many extra DMA descriptors may be required per segment in
 240          * the worst case because of maximum DMA descriptor length limit.
 241          * If maximum segment length is less or equal to maximum DMA
 242          * descriptor length, no extra DMA descriptors are required.
 243          */
 244         extra_descs_per_seg =
 245                 (SFC_MBUF_SEG_LEN_MAX - 1) / SFC_EF10_TX_DMA_DESC_LEN_MAX;
 246
 247 /** Maximum length of the packet */
 248 #define SFC_MBUF_PKT_LEN_MAX            UINT32_MAX
 249         RTE_BUILD_BUG_ON(sizeof(m->pkt_len) != 4);
 250
 251         /*
 252          * One more limitation on maximum number of extra DMA descriptors
 253          * comes from slicing entire packet because of DMA descriptor length
 254          * limit taking into account that there is at least one segment
 255          * which is already counted below (so division of the maximum
 256          * packet length minus one with round down).
 257          * TSO is not supported yet, so packet length is limited by
 258          * maximum PDU size.
 259          */
 260         extra_descs_per_pkt =
 261                 (RTE_MIN((unsigned int)EFX_MAC_PDU_MAX,
 262                          SFC_MBUF_PKT_LEN_MAX) - 1) /
 263                 SFC_EF10_TX_DMA_DESC_LEN_MAX;
 264
 265         return m->nb_segs + RTE_MIN(m->nb_segs * extra_descs_per_seg,
 266                                     extra_descs_per_pkt);
 267 }
 268
 269 static uint16_t
 270 sfc_ef10_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
 271 {
 272         struct sfc_ef10_txq * const txq = sfc_ef10_txq_by_dp_txq(tx_queue);
 273         unsigned int ptr_mask;
 274         unsigned int added;
 275         unsigned int dma_desc_space;
 276         bool reap_done;
 277         struct rte_mbuf **pktp;
 278         struct rte_mbuf **pktp_end;
 279
 280         if (unlikely(txq->flags &
 281                      (SFC_EF10_TXQ_NOT_RUNNING | SFC_EF10_TXQ_EXCEPTION)))
 282                 return 0;
 283
 284         ptr_mask = txq->ptr_mask;
 285         added = txq->added;
 286         dma_desc_space = SFC_EF10_TXQ_LIMIT(ptr_mask + 1) -
 287                          (added - txq->completed);
 288
 289         reap_done = (dma_desc_space < txq->free_thresh);
 290         if (reap_done) {
 291                 sfc_ef10_tx_reap(txq);
 292                 dma_desc_space = SFC_EF10_TXQ_LIMIT(ptr_mask + 1) -
 293                                  (added - txq->completed);
 294         }
 295
 296         for (pktp = &tx_pkts[0], pktp_end = &tx_pkts[nb_pkts];
 297              pktp != pktp_end;
 298              ++pktp) {
 299                 struct rte_mbuf *m_seg = *pktp;
 300                 unsigned int pkt_start = added;
 301                 uint32_t pkt_len;
 302
 303                 if (likely(pktp + 1 != pktp_end))
 304                         rte_mbuf_prefetch_part1(pktp[1]);
 305
 306                 if (sfc_ef10_tx_pkt_descs_max(m_seg) > dma_desc_space) {
 307                         if (reap_done)
 308                                 break;
 309
 310                         /* Push already prepared descriptors before polling */
 311                         if (added != txq->added) {
 312                                 sfc_ef10_tx_qpush(txq, added, txq->added);
 313                                 txq->added = added;
 314                         }
 315
 316                         sfc_ef10_tx_reap(txq);
 317                         reap_done = true;
 318                         dma_desc_space = SFC_EF10_TXQ_LIMIT(ptr_mask + 1) -
 319                                 (added - txq->completed);
 320                         if (sfc_ef10_tx_pkt_descs_max(m_seg) > dma_desc_space)
 321                                 break;
 322                 }
 323
 324                 pkt_len = m_seg->pkt_len;
 325                 do {
 326                         phys_addr_t seg_addr = rte_mbuf_data_dma_addr(m_seg);
 327                         unsigned int seg_len = rte_pktmbuf_data_len(m_seg);
 328
 329                         SFC_ASSERT(seg_len <= SFC_EF10_TX_DMA_DESC_LEN_MAX);
 330
 331                         pkt_len -= seg_len;
 332
 333                         sfc_ef10_tx_qdesc_dma_create(seg_addr,
 334                                 seg_len, (pkt_len == 0),
 335                                 &txq->txq_hw_ring[added & ptr_mask]);
 336                         ++added;
 337
 338                 } while ((m_seg = m_seg->next) != 0);
 339
 340                 dma_desc_space -= (added - pkt_start);
 341
 342                 /* Assign mbuf to the last used desc */
 343                 txq->sw_ring[(added - 1) & ptr_mask].mbuf = *pktp;
 344         }
 345
 346         if (likely(added != txq->added)) {
 347                 sfc_ef10_tx_qpush(txq, added, txq->added);
 348                 txq->added = added;
 349         }
 350
 351 #if SFC_TX_XMIT_PKTS_REAP_AT_LEAST_ONCE
 352         if (!reap_done)
 353                 sfc_ef10_tx_reap(txq);
 354 #endif
 355
 356         return pktp - &tx_pkts[0];
 357 }
 358
 359 static void
 360 sfc_ef10_simple_tx_reap(struct sfc_ef10_txq *txq)
 361 {
 362         const unsigned int old_read_ptr = txq->evq_read_ptr;
 363         const unsigned int ptr_mask = txq->ptr_mask;
 364         unsigned int completed = txq->completed;
 365         unsigned int pending = completed;
 366
 367         pending += sfc_ef10_tx_process_events(txq);
 368
 369         if (pending != completed) {
 370                 do {
 371                         struct sfc_ef10_tx_sw_desc *txd;
 372
 373                         txd = &txq->sw_ring[completed & ptr_mask];
 374
 375                         rte_pktmbuf_free_seg(txd->mbuf);
 376                 } while (++completed != pending);
 377
 378                 txq->completed = completed;
 379         }
 380
 381         sfc_ef10_ev_qclear(txq->evq_hw_ring, ptr_mask, old_read_ptr,
 382                            txq->evq_read_ptr);
 383 }
 384
 385
 386 static uint16_t
 387 sfc_ef10_simple_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts,
 388                           uint16_t nb_pkts)
 389 {
 390         struct sfc_ef10_txq * const txq = sfc_ef10_txq_by_dp_txq(tx_queue);
 391         unsigned int ptr_mask;
 392         unsigned int added;
 393         unsigned int dma_desc_space;
 394         bool reap_done;
 395         struct rte_mbuf **pktp;
 396         struct rte_mbuf **pktp_end;
 397
 398         if (unlikely(txq->flags &
 399                      (SFC_EF10_TXQ_NOT_RUNNING | SFC_EF10_TXQ_EXCEPTION)))
 400                 return 0;
 401
 402         ptr_mask = txq->ptr_mask;
 403         added = txq->added;
 404         dma_desc_space = SFC_EF10_TXQ_LIMIT(ptr_mask + 1) -
 405                          (added - txq->completed);
 406
 407         reap_done = (dma_desc_space < RTE_MAX(txq->free_thresh, nb_pkts));
 408         if (reap_done) {
 409                 sfc_ef10_simple_tx_reap(txq);
 410                 dma_desc_space = SFC_EF10_TXQ_LIMIT(ptr_mask + 1) -
 411                                  (added - txq->completed);
 412         }
 413
 414         pktp_end = &tx_pkts[MIN(nb_pkts, dma_desc_space)];
 415         for (pktp = &tx_pkts[0]; pktp != pktp_end; ++pktp) {
 416                 struct rte_mbuf *pkt = *pktp;
 417                 unsigned int id = added & ptr_mask;
 418
 419                 SFC_ASSERT(rte_pktmbuf_data_len(pkt) <=
 420                            SFC_EF10_TX_DMA_DESC_LEN_MAX);
 421
 422                 sfc_ef10_tx_qdesc_dma_create(rte_mbuf_data_dma_addr(pkt),
 423                                              rte_pktmbuf_data_len(pkt),
 424                                              true, &txq->txq_hw_ring[id]);
 425
 426                 txq->sw_ring[id].mbuf = pkt;
 427
 428                 ++added;
 429         }
 430
 431         if (likely(added != txq->added)) {
 432                 sfc_ef10_tx_qpush(txq, added, txq->added);
 433                 txq->added = added;
 434         }
 435
 436 #if SFC_TX_XMIT_PKTS_REAP_AT_LEAST_ONCE
 437         if (!reap_done)
 438                 sfc_ef10_simple_tx_reap(txq);
 439 #endif
 440
 441         return pktp - &tx_pkts[0];
 442 }
 443
 444
 445 static sfc_dp_tx_qcreate_t sfc_ef10_tx_qcreate;
 446 static int
 447 sfc_ef10_tx_qcreate(uint16_t port_id, uint16_t queue_id,
 448                     const struct rte_pci_addr *pci_addr, int socket_id,
 449                     const struct sfc_dp_tx_qcreate_info *info,
 450                     struct sfc_dp_txq **dp_txqp)
 451 {
 452         struct sfc_ef10_txq *txq;
 453         int rc;
 454
 455         rc = EINVAL;
 456         if (info->txq_entries != info->evq_entries)
 457                 goto fail_bad_args;
 458
 459         rc = ENOMEM;
 460         txq = rte_zmalloc_socket("sfc-ef10-txq", sizeof(*txq),
 461                                  RTE_CACHE_LINE_SIZE, socket_id);
 462         if (txq == NULL)
 463                 goto fail_txq_alloc;
 464
 465         sfc_dp_queue_init(&txq->dp.dpq, port_id, queue_id, pci_addr);
 466
 467         rc = ENOMEM;
 468         txq->sw_ring = rte_calloc_socket("sfc-ef10-txq-sw_ring",
 469                                          info->txq_entries,
 470                                          sizeof(*txq->sw_ring),
 471                                          RTE_CACHE_LINE_SIZE, socket_id);
 472         if (txq->sw_ring == NULL)
 473                 goto fail_sw_ring_alloc;
 474
 475         txq->flags = SFC_EF10_TXQ_NOT_RUNNING;
 476         txq->ptr_mask = info->txq_entries - 1;
 477         txq->free_thresh = info->free_thresh;
 478         txq->txq_hw_ring = info->txq_hw_ring;
 479         txq->doorbell = (volatile uint8_t *)info->mem_bar +
 480                         ER_DZ_TX_DESC_UPD_REG_OFST +
 481                         info->hw_index * ER_DZ_TX_DESC_UPD_REG_STEP;
 482         txq->evq_hw_ring = info->evq_hw_ring;
 483
 484         *dp_txqp = &txq->dp;
 485         return 0;
 486
 487 fail_sw_ring_alloc:
 488         rte_free(txq);
 489
 490 fail_txq_alloc:
 491 fail_bad_args:
 492         return rc;
 493 }
 494
 495 static sfc_dp_tx_qdestroy_t sfc_ef10_tx_qdestroy;
 496 static void
 497 sfc_ef10_tx_qdestroy(struct sfc_dp_txq *dp_txq)
 498 {
 499         struct sfc_ef10_txq *txq = sfc_ef10_txq_by_dp_txq(dp_txq);
 500
 501         rte_free(txq->sw_ring);
 502         rte_free(txq);
 503 }
 504
 505 static sfc_dp_tx_qstart_t sfc_ef10_tx_qstart;
 506 static int
 507 sfc_ef10_tx_qstart(struct sfc_dp_txq *dp_txq, unsigned int evq_read_ptr,
 508                    unsigned int txq_desc_index)
 509 {
 510         struct sfc_ef10_txq *txq = sfc_ef10_txq_by_dp_txq(dp_txq);
 511
 512         txq->evq_read_ptr = evq_read_ptr;
 513         txq->added = txq->completed = txq_desc_index;
 514
 515         txq->flags |= SFC_EF10_TXQ_STARTED;
 516         txq->flags &= ~(SFC_EF10_TXQ_NOT_RUNNING | SFC_EF10_TXQ_EXCEPTION);
 517
 518         return 0;
 519 }
 520
 521 static sfc_dp_tx_qstop_t sfc_ef10_tx_qstop;
 522 static void
 523 sfc_ef10_tx_qstop(struct sfc_dp_txq *dp_txq, unsigned int *evq_read_ptr)
 524 {
 525         struct sfc_ef10_txq *txq = sfc_ef10_txq_by_dp_txq(dp_txq);
 526
 527         txq->flags |= SFC_EF10_TXQ_NOT_RUNNING;
 528
 529         *evq_read_ptr = txq->evq_read_ptr;
 530 }
 531
 532 static sfc_dp_tx_qtx_ev_t sfc_ef10_tx_qtx_ev;
 533 static bool
 534 sfc_ef10_tx_qtx_ev(struct sfc_dp_txq *dp_txq, __rte_unused unsigned int id)
 535 {
 536         __rte_unused struct sfc_ef10_txq *txq = sfc_ef10_txq_by_dp_txq(dp_txq);
 537
 538         SFC_ASSERT(txq->flags & SFC_EF10_TXQ_NOT_RUNNING);
 539
 540         /*
 541          * It is safe to ignore Tx event since we reap all mbufs on
 542          * queue purge anyway.
 543          */
 544
 545         return false;
 546 }
 547
 548 static sfc_dp_tx_qreap_t sfc_ef10_tx_qreap;
 549 static void
 550 sfc_ef10_tx_qreap(struct sfc_dp_txq *dp_txq)
 551 {
 552         struct sfc_ef10_txq *txq = sfc_ef10_txq_by_dp_txq(dp_txq);
 553         unsigned int completed;
 554
 555         for (completed = txq->completed; completed != txq->added; ++completed) {
 556                 struct sfc_ef10_tx_sw_desc *txd;
 557
 558                 txd = &txq->sw_ring[completed & txq->ptr_mask];
 559                 if (txd->mbuf != NULL) {
 560                         rte_pktmbuf_free(txd->mbuf);
 561                         txd->mbuf = NULL;
 562                 }
 563         }
 564
 565         txq->flags &= ~SFC_EF10_TXQ_STARTED;
 566 }
 567
 568 struct sfc_dp_tx sfc_ef10_tx = {
 569         .dp = {
 570                 .name           = SFC_KVARG_DATAPATH_EF10,
 571                 .type           = SFC_DP_TX,
 572                 .hw_fw_caps     = SFC_DP_HW_FW_CAP_EF10,
 573         },
 574         .features               = SFC_DP_TX_FEAT_MULTI_SEG |
 575                                   SFC_DP_TX_FEAT_MULTI_PROCESS,
 576         .qcreate                = sfc_ef10_tx_qcreate,
 577         .qdestroy               = sfc_ef10_tx_qdestroy,
 578         .qstart                 = sfc_ef10_tx_qstart,
 579         .qtx_ev                 = sfc_ef10_tx_qtx_ev,
 580         .qstop                  = sfc_ef10_tx_qstop,
 581         .qreap                  = sfc_ef10_tx_qreap,
 582         .pkt_burst              = sfc_ef10_xmit_pkts,
 583 };
 584
 585 struct sfc_dp_tx sfc_ef10_simple_tx = {
 586         .dp = {
 587                 .name           = SFC_KVARG_DATAPATH_EF10_SIMPLE,
 588                 .type           = SFC_DP_TX,
 589         },
 590         .features               = SFC_DP_TX_FEAT_MULTI_PROCESS,
 591         .qcreate                = sfc_ef10_tx_qcreate,
 592         .qdestroy               = sfc_ef10_tx_qdestroy,
 593         .qstart                 = sfc_ef10_tx_qstart,
 594         .qtx_ev                 = sfc_ef10_tx_qtx_ev,
 595         .qstop                  = sfc_ef10_tx_qstop,
 596         .qreap                  = sfc_ef10_tx_qreap,
 597         .pkt_burst              = sfc_ef10_simple_xmit_pkts,
 598 };