New upstream version 17.08
[deb_dpdk.git] / 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 };