net/ixgbe/base: remove X550em SFP iXFI setup
[dpdk.git] / drivers / net / sfc / sfc_tx.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 #include "sfc.h"
31 #include "sfc_debug.h"
32 #include "sfc_log.h"
33 #include "sfc_ev.h"
34 #include "sfc_tx.h"
35 #include "sfc_tweak.h"
36
37 /*
38  * Maximum number of TX queue flush attempts in case of
39  * failure or flush timeout
40  */
41 #define SFC_TX_QFLUSH_ATTEMPTS          (3)
42
43 /*
44  * Time to wait between event queue polling attempts when waiting for TX
45  * queue flush done or flush failed events
46  */
47 #define SFC_TX_QFLUSH_POLL_WAIT_MS      (1)
48
49 /*
50  * Maximum number of event queue polling attempts when waiting for TX queue
51  * flush done or flush failed events; it defines TX queue flush attempt timeout
52  * together with SFC_TX_QFLUSH_POLL_WAIT_MS
53  */
54 #define SFC_TX_QFLUSH_POLL_ATTEMPTS     (2000)
55
56 static int
57 sfc_tx_qcheck_conf(struct sfc_adapter *sa, uint16_t nb_tx_desc,
58                    const struct rte_eth_txconf *tx_conf)
59 {
60         unsigned int flags = tx_conf->txq_flags;
61         const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic);
62         int rc = 0;
63
64         if (tx_conf->tx_rs_thresh != 0) {
65                 sfc_err(sa, "RS bit in transmit descriptor is not supported");
66                 rc = EINVAL;
67         }
68
69         if (tx_conf->tx_free_thresh > EFX_TXQ_LIMIT(nb_tx_desc)) {
70                 sfc_err(sa,
71                         "TxQ free threshold too large: %u vs maximum %u",
72                         tx_conf->tx_free_thresh, EFX_TXQ_LIMIT(nb_tx_desc));
73                 rc = EINVAL;
74         }
75
76         if (tx_conf->tx_thresh.pthresh != 0 ||
77             tx_conf->tx_thresh.hthresh != 0 ||
78             tx_conf->tx_thresh.wthresh != 0) {
79                 sfc_err(sa,
80                         "prefetch/host/writeback thresholds are not supported");
81                 rc = EINVAL;
82         }
83
84         if (!encp->enc_hw_tx_insert_vlan_enabled &&
85             (flags & ETH_TXQ_FLAGS_NOVLANOFFL) == 0) {
86                 sfc_err(sa, "VLAN offload is not supported");
87                 rc = EINVAL;
88         }
89
90         if ((flags & ETH_TXQ_FLAGS_NOXSUMSCTP) == 0) {
91                 sfc_err(sa, "SCTP offload is not supported");
92                 rc = EINVAL;
93         }
94
95         /* We either perform both TCP and UDP offload, or no offload at all */
96         if (((flags & ETH_TXQ_FLAGS_NOXSUMTCP) == 0) !=
97             ((flags & ETH_TXQ_FLAGS_NOXSUMUDP) == 0)) {
98                 sfc_err(sa, "TCP and UDP offloads can't be set independently");
99                 rc = EINVAL;
100         }
101
102         return rc;
103 }
104
105 void
106 sfc_tx_qflush_done(struct sfc_txq *txq)
107 {
108         txq->state |= SFC_TXQ_FLUSHED;
109         txq->state &= ~SFC_TXQ_FLUSHING;
110 }
111
112 static void
113 sfc_tx_reap(struct sfc_txq *txq)
114 {
115         unsigned int    completed;
116
117
118         sfc_ev_qpoll(txq->evq);
119
120         for (completed = txq->completed;
121              completed != txq->pending; completed++) {
122                 struct sfc_tx_sw_desc *txd;
123
124                 txd = &txq->sw_ring[completed & txq->ptr_mask];
125
126                 if (txd->mbuf != NULL) {
127                         rte_pktmbuf_free(txd->mbuf);
128                         txd->mbuf = NULL;
129                 }
130         }
131
132         txq->completed = completed;
133 }
134
135 int
136 sfc_tx_qinit(struct sfc_adapter *sa, unsigned int sw_index,
137              uint16_t nb_tx_desc, unsigned int socket_id,
138              const struct rte_eth_txconf *tx_conf)
139 {
140         struct sfc_txq_info *txq_info;
141         struct sfc_evq *evq;
142         struct sfc_txq *txq;
143         unsigned int evq_index = sfc_evq_index_by_txq_sw_index(sa, sw_index);
144         int rc = 0;
145
146         sfc_log_init(sa, "TxQ = %u", sw_index);
147
148         rc = sfc_tx_qcheck_conf(sa, nb_tx_desc, tx_conf);
149         if (rc != 0)
150                 goto fail_bad_conf;
151
152         SFC_ASSERT(sw_index < sa->txq_count);
153         txq_info = &sa->txq_info[sw_index];
154
155         SFC_ASSERT(nb_tx_desc <= sa->txq_max_entries);
156         txq_info->entries = nb_tx_desc;
157
158         rc = sfc_ev_qinit(sa, evq_index, txq_info->entries, socket_id);
159         if (rc != 0)
160                 goto fail_ev_qinit;
161
162         evq = sa->evq_info[evq_index].evq;
163
164         rc = ENOMEM;
165         txq = rte_zmalloc_socket("sfc-txq", sizeof(*txq), 0, socket_id);
166         if (txq == NULL)
167                 goto fail_txq_alloc;
168
169         rc = sfc_dma_alloc(sa, "txq", sw_index, EFX_TXQ_SIZE(txq_info->entries),
170                            socket_id, &txq->mem);
171         if (rc != 0)
172                 goto fail_dma_alloc;
173
174         rc = ENOMEM;
175         txq->pend_desc = rte_calloc_socket("sfc-txq-pend-desc",
176                                            EFX_TXQ_LIMIT(txq_info->entries),
177                                            sizeof(efx_desc_t), 0, socket_id);
178         if (txq->pend_desc == NULL)
179                 goto fail_pend_desc_alloc;
180
181         rc = ENOMEM;
182         txq->sw_ring = rte_calloc_socket("sfc-txq-desc", txq_info->entries,
183                                          sizeof(*txq->sw_ring), 0, socket_id);
184         if (txq->sw_ring == NULL)
185                 goto fail_desc_alloc;
186
187         if (sa->tso) {
188                 rc = sfc_tso_alloc_tsoh_objs(txq->sw_ring, txq_info->entries,
189                                              socket_id);
190                 if (rc != 0)
191                         goto fail_alloc_tsoh_objs;
192         }
193
194         txq->state = SFC_TXQ_INITIALIZED;
195         txq->ptr_mask = txq_info->entries - 1;
196         txq->free_thresh = (tx_conf->tx_free_thresh) ? tx_conf->tx_free_thresh :
197                                                      SFC_TX_DEFAULT_FREE_THRESH;
198         txq->hw_index = sw_index;
199         txq->flags = tx_conf->txq_flags;
200         txq->evq = evq;
201
202         evq->txq = txq;
203
204         txq_info->txq = txq;
205         txq_info->deferred_start = (tx_conf->tx_deferred_start != 0);
206
207         return 0;
208
209 fail_alloc_tsoh_objs:
210         rte_free(txq->sw_ring);
211
212 fail_desc_alloc:
213         rte_free(txq->pend_desc);
214
215 fail_pend_desc_alloc:
216         sfc_dma_free(sa, &txq->mem);
217
218 fail_dma_alloc:
219         rte_free(txq);
220
221 fail_txq_alloc:
222         sfc_ev_qfini(sa, evq_index);
223
224 fail_ev_qinit:
225         txq_info->entries = 0;
226
227 fail_bad_conf:
228         sfc_log_init(sa, "failed (TxQ = %u, rc = %d)", sw_index, rc);
229         return rc;
230 }
231
232 void
233 sfc_tx_qfini(struct sfc_adapter *sa, unsigned int sw_index)
234 {
235         struct sfc_txq_info *txq_info;
236         struct sfc_txq *txq;
237
238         sfc_log_init(sa, "TxQ = %u", sw_index);
239
240         SFC_ASSERT(sw_index < sa->txq_count);
241         txq_info = &sa->txq_info[sw_index];
242
243         txq = txq_info->txq;
244         SFC_ASSERT(txq != NULL);
245         SFC_ASSERT(txq->state == SFC_TXQ_INITIALIZED);
246
247         sfc_tso_free_tsoh_objs(txq->sw_ring, txq_info->entries);
248
249         txq_info->txq = NULL;
250         txq_info->entries = 0;
251
252         rte_free(txq->sw_ring);
253         rte_free(txq->pend_desc);
254         sfc_dma_free(sa, &txq->mem);
255         rte_free(txq);
256 }
257
258 static int
259 sfc_tx_qinit_info(struct sfc_adapter *sa, unsigned int sw_index)
260 {
261         sfc_log_init(sa, "TxQ = %u", sw_index);
262
263         return 0;
264 }
265
266 static int
267 sfc_tx_check_mode(struct sfc_adapter *sa, const struct rte_eth_txmode *txmode)
268 {
269         int rc = 0;
270
271         switch (txmode->mq_mode) {
272         case ETH_MQ_TX_NONE:
273                 break;
274         default:
275                 sfc_err(sa, "Tx multi-queue mode %u not supported",
276                         txmode->mq_mode);
277                 rc = EINVAL;
278         }
279
280         /*
281          * These features are claimed to be i40e-specific,
282          * but it does make sense to double-check their absence
283          */
284         if (txmode->hw_vlan_reject_tagged) {
285                 sfc_err(sa, "Rejecting tagged packets not supported");
286                 rc = EINVAL;
287         }
288
289         if (txmode->hw_vlan_reject_untagged) {
290                 sfc_err(sa, "Rejecting untagged packets not supported");
291                 rc = EINVAL;
292         }
293
294         if (txmode->hw_vlan_insert_pvid) {
295                 sfc_err(sa, "Port-based VLAN insertion not supported");
296                 rc = EINVAL;
297         }
298
299         return rc;
300 }
301
302 int
303 sfc_tx_init(struct sfc_adapter *sa)
304 {
305         const struct rte_eth_conf *dev_conf = &sa->eth_dev->data->dev_conf;
306         unsigned int sw_index;
307         int rc = 0;
308
309         rc = sfc_tx_check_mode(sa, &dev_conf->txmode);
310         if (rc != 0)
311                 goto fail_check_mode;
312
313         sa->txq_count = sa->eth_dev->data->nb_tx_queues;
314
315         sa->txq_info = rte_calloc_socket("sfc-txqs", sa->txq_count,
316                                          sizeof(sa->txq_info[0]), 0,
317                                          sa->socket_id);
318         if (sa->txq_info == NULL)
319                 goto fail_txqs_alloc;
320
321         for (sw_index = 0; sw_index < sa->txq_count; ++sw_index) {
322                 rc = sfc_tx_qinit_info(sa, sw_index);
323                 if (rc != 0)
324                         goto fail_tx_qinit_info;
325         }
326
327         return 0;
328
329 fail_tx_qinit_info:
330         rte_free(sa->txq_info);
331         sa->txq_info = NULL;
332
333 fail_txqs_alloc:
334         sa->txq_count = 0;
335
336 fail_check_mode:
337         sfc_log_init(sa, "failed (rc = %d)", rc);
338         return rc;
339 }
340
341 void
342 sfc_tx_fini(struct sfc_adapter *sa)
343 {
344         int sw_index;
345
346         sw_index = sa->txq_count;
347         while (--sw_index >= 0) {
348                 if (sa->txq_info[sw_index].txq != NULL)
349                         sfc_tx_qfini(sa, sw_index);
350         }
351
352         rte_free(sa->txq_info);
353         sa->txq_info = NULL;
354         sa->txq_count = 0;
355 }
356
357 int
358 sfc_tx_qstart(struct sfc_adapter *sa, unsigned int sw_index)
359 {
360         struct rte_eth_dev_data *dev_data;
361         struct sfc_txq_info *txq_info;
362         struct sfc_txq *txq;
363         struct sfc_evq *evq;
364         uint16_t flags;
365         unsigned int desc_index;
366         int rc = 0;
367
368         sfc_log_init(sa, "TxQ = %u", sw_index);
369
370         SFC_ASSERT(sw_index < sa->txq_count);
371         txq_info = &sa->txq_info[sw_index];
372
373         txq = txq_info->txq;
374
375         SFC_ASSERT(txq->state == SFC_TXQ_INITIALIZED);
376
377         evq = txq->evq;
378
379         rc = sfc_ev_qstart(sa, evq->evq_index);
380         if (rc != 0)
381                 goto fail_ev_qstart;
382
383         /*
384          * It seems that DPDK has no controls regarding IPv4 offloads,
385          * hence, we always enable it here
386          */
387         if ((txq->flags & ETH_TXQ_FLAGS_NOXSUMTCP) ||
388             (txq->flags & ETH_TXQ_FLAGS_NOXSUMUDP)) {
389                 flags = EFX_TXQ_CKSUM_IPV4;
390         } else {
391                 flags = EFX_TXQ_CKSUM_IPV4 | EFX_TXQ_CKSUM_TCPUDP;
392
393                 if (sa->tso)
394                         flags |= EFX_TXQ_FATSOV2;
395         }
396
397         rc = efx_tx_qcreate(sa->nic, sw_index, 0, &txq->mem,
398                             txq_info->entries, 0 /* not used on EF10 */,
399                             flags, evq->common,
400                             &txq->common, &desc_index);
401         if (rc != 0) {
402                 if (sa->tso && (rc == ENOSPC))
403                         sfc_err(sa, "ran out of TSO contexts");
404
405                 goto fail_tx_qcreate;
406         }
407
408         txq->added = txq->pending = txq->completed = desc_index;
409         txq->hw_vlan_tci = 0;
410
411         efx_tx_qenable(txq->common);
412
413         txq->state |= (SFC_TXQ_STARTED | SFC_TXQ_RUNNING);
414
415         /*
416          * It seems to be used by DPDK for debug purposes only ('rte_ether')
417          */
418         dev_data = sa->eth_dev->data;
419         dev_data->tx_queue_state[sw_index] = RTE_ETH_QUEUE_STATE_STARTED;
420
421         return 0;
422
423 fail_tx_qcreate:
424         sfc_ev_qstop(sa, evq->evq_index);
425
426 fail_ev_qstart:
427         return rc;
428 }
429
430 void
431 sfc_tx_qstop(struct sfc_adapter *sa, unsigned int sw_index)
432 {
433         struct rte_eth_dev_data *dev_data;
434         struct sfc_txq_info *txq_info;
435         struct sfc_txq *txq;
436         unsigned int retry_count;
437         unsigned int wait_count;
438         unsigned int txds;
439
440         sfc_log_init(sa, "TxQ = %u", sw_index);
441
442         SFC_ASSERT(sw_index < sa->txq_count);
443         txq_info = &sa->txq_info[sw_index];
444
445         txq = txq_info->txq;
446
447         if (txq->state == SFC_TXQ_INITIALIZED)
448                 return;
449
450         SFC_ASSERT(txq->state & SFC_TXQ_STARTED);
451
452         txq->state &= ~SFC_TXQ_RUNNING;
453
454         /*
455          * Retry TX queue flushing in case of flush failed or
456          * timeout; in the worst case it can delay for 6 seconds
457          */
458         for (retry_count = 0;
459              ((txq->state & SFC_TXQ_FLUSHED) == 0) &&
460              (retry_count < SFC_TX_QFLUSH_ATTEMPTS);
461              ++retry_count) {
462                 if (efx_tx_qflush(txq->common) != 0) {
463                         txq->state |= SFC_TXQ_FLUSHING;
464                         break;
465                 }
466
467                 /*
468                  * Wait for TX queue flush done or flush failed event at least
469                  * SFC_TX_QFLUSH_POLL_WAIT_MS milliseconds and not more
470                  * than 2 seconds (SFC_TX_QFLUSH_POLL_WAIT_MS multiplied
471                  * by SFC_TX_QFLUSH_POLL_ATTEMPTS)
472                  */
473                 wait_count = 0;
474                 do {
475                         rte_delay_ms(SFC_TX_QFLUSH_POLL_WAIT_MS);
476                         sfc_ev_qpoll(txq->evq);
477                 } while ((txq->state & SFC_TXQ_FLUSHING) &&
478                          wait_count++ < SFC_TX_QFLUSH_POLL_ATTEMPTS);
479
480                 if (txq->state & SFC_TXQ_FLUSHING)
481                         sfc_err(sa, "TxQ %u flush timed out", sw_index);
482
483                 if (txq->state & SFC_TXQ_FLUSHED)
484                         sfc_info(sa, "TxQ %u flushed", sw_index);
485         }
486
487         sfc_tx_reap(txq);
488
489         for (txds = 0; txds < txq_info->entries; txds++) {
490                 if (txq->sw_ring[txds].mbuf != NULL) {
491                         rte_pktmbuf_free(txq->sw_ring[txds].mbuf);
492                         txq->sw_ring[txds].mbuf = NULL;
493                 }
494         }
495
496         txq->state = SFC_TXQ_INITIALIZED;
497
498         efx_tx_qdestroy(txq->common);
499
500         sfc_ev_qstop(sa, txq->evq->evq_index);
501
502         /*
503          * It seems to be used by DPDK for debug purposes only ('rte_ether')
504          */
505         dev_data = sa->eth_dev->data;
506         dev_data->tx_queue_state[sw_index] = RTE_ETH_QUEUE_STATE_STOPPED;
507 }
508
509 int
510 sfc_tx_start(struct sfc_adapter *sa)
511 {
512         unsigned int sw_index;
513         int rc = 0;
514
515         sfc_log_init(sa, "txq_count = %u", sa->txq_count);
516
517         if (sa->tso) {
518                 if (!efx_nic_cfg_get(sa->nic)->enc_fw_assisted_tso_v2_enabled) {
519                         sfc_warn(sa, "TSO support was unable to be restored");
520                         sa->tso = B_FALSE;
521                 }
522         }
523
524         rc = efx_tx_init(sa->nic);
525         if (rc != 0)
526                 goto fail_efx_tx_init;
527
528         for (sw_index = 0; sw_index < sa->txq_count; ++sw_index) {
529                 if (!(sa->txq_info[sw_index].deferred_start) ||
530                     sa->txq_info[sw_index].deferred_started) {
531                         rc = sfc_tx_qstart(sa, sw_index);
532                         if (rc != 0)
533                                 goto fail_tx_qstart;
534                 }
535         }
536
537         return 0;
538
539 fail_tx_qstart:
540         while (sw_index-- > 0)
541                 sfc_tx_qstop(sa, sw_index);
542
543         efx_tx_fini(sa->nic);
544
545 fail_efx_tx_init:
546         sfc_log_init(sa, "failed (rc = %d)", rc);
547         return rc;
548 }
549
550 void
551 sfc_tx_stop(struct sfc_adapter *sa)
552 {
553         unsigned int sw_index;
554
555         sfc_log_init(sa, "txq_count = %u", sa->txq_count);
556
557         sw_index = sa->txq_count;
558         while (sw_index-- > 0) {
559                 if (sa->txq_info[sw_index].txq != NULL)
560                         sfc_tx_qstop(sa, sw_index);
561         }
562
563         efx_tx_fini(sa->nic);
564 }
565
566 /*
567  * The function is used to insert or update VLAN tag;
568  * the firmware has state of the firmware tag to insert per TxQ
569  * (controlled by option descriptors), hence, if the tag of the
570  * packet to be sent is different from one remembered by the firmware,
571  * the function will update it
572  */
573 static unsigned int
574 sfc_tx_maybe_insert_tag(struct sfc_txq *txq, struct rte_mbuf *m,
575                         efx_desc_t **pend)
576 {
577         uint16_t this_tag = ((m->ol_flags & PKT_TX_VLAN_PKT) ?
578                              m->vlan_tci : 0);
579
580         if (this_tag == txq->hw_vlan_tci)
581                 return 0;
582
583         /*
584          * The expression inside SFC_ASSERT() is not desired to be checked in
585          * a non-debug build because it might be too expensive on the data path
586          */
587         SFC_ASSERT(efx_nic_cfg_get(txq->evq->sa->nic)->enc_hw_tx_insert_vlan_enabled);
588
589         efx_tx_qdesc_vlantci_create(txq->common, rte_cpu_to_be_16(this_tag),
590                                     *pend);
591         (*pend)++;
592         txq->hw_vlan_tci = this_tag;
593
594         return 1;
595 }
596
597 uint16_t
598 sfc_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
599 {
600         struct sfc_txq *txq = (struct sfc_txq *)tx_queue;
601         unsigned int added = txq->added;
602         unsigned int pushed = added;
603         unsigned int pkts_sent = 0;
604         efx_desc_t *pend = &txq->pend_desc[0];
605         const unsigned int hard_max_fill = EFX_TXQ_LIMIT(txq->ptr_mask + 1);
606         const unsigned int soft_max_fill = hard_max_fill - txq->free_thresh;
607         unsigned int fill_level = added - txq->completed;
608         boolean_t reap_done;
609         int rc __rte_unused;
610         struct rte_mbuf **pktp;
611
612         if (unlikely((txq->state & SFC_TXQ_RUNNING) == 0))
613                 goto done;
614
615         /*
616          * If insufficient space for a single packet is present,
617          * we should reap; otherwise, we shouldn't do that all the time
618          * to avoid latency increase
619          */
620         reap_done = (fill_level > soft_max_fill);
621
622         if (reap_done) {
623                 sfc_tx_reap(txq);
624                 /*
625                  * Recalculate fill level since 'txq->completed'
626                  * might have changed on reap
627                  */
628                 fill_level = added - txq->completed;
629         }
630
631         for (pkts_sent = 0, pktp = &tx_pkts[0];
632              (pkts_sent < nb_pkts) && (fill_level <= soft_max_fill);
633              pkts_sent++, pktp++) {
634                 struct rte_mbuf         *m_seg = *pktp;
635                 size_t                  pkt_len = m_seg->pkt_len;
636                 unsigned int            pkt_descs = 0;
637                 size_t                  in_off = 0;
638
639                 /*
640                  * Here VLAN TCI is expected to be zero in case if no
641                  * DEV_TX_VLAN_OFFLOAD capability is advertised;
642                  * if the calling app ignores the absence of
643                  * DEV_TX_VLAN_OFFLOAD and pushes VLAN TCI, then
644                  * TX_ERROR will occur
645                  */
646                 pkt_descs += sfc_tx_maybe_insert_tag(txq, m_seg, &pend);
647
648                 if (m_seg->ol_flags & PKT_TX_TCP_SEG) {
649                         /*
650                          * We expect correct 'pkt->l[2, 3, 4]_len' values
651                          * to be set correctly by the caller
652                          */
653                         if (sfc_tso_do(txq, added, &m_seg, &in_off, &pend,
654                                        &pkt_descs, &pkt_len) != 0) {
655                                 /* We may have reached this place for
656                                  * one of the following reasons:
657                                  *
658                                  * 1) Packet header length is greater
659                                  *    than SFC_TSOH_STD_LEN
660                                  * 2) TCP header starts at more then
661                                  *    208 bytes into the frame
662                                  *
663                                  * We will deceive RTE saying that we have sent
664                                  * the packet, but we will actually drop it.
665                                  * Hence, we should revert 'pend' to the
666                                  * previous state (in case we have added
667                                  * VLAN descriptor) and start processing
668                                  * another one packet. But the original
669                                  * mbuf shouldn't be orphaned
670                                  */
671                                 pend -= pkt_descs;
672
673                                 rte_pktmbuf_free(*pktp);
674
675                                 continue;
676                         }
677
678                         /*
679                          * We've only added 2 FATSOv2 option descriptors
680                          * and 1 descriptor for the linearized packet header.
681                          * The outstanding work will be done in the same manner
682                          * as for the usual non-TSO path
683                          */
684                 }
685
686                 for (; m_seg != NULL; m_seg = m_seg->next) {
687                         efsys_dma_addr_t        next_frag;
688                         size_t                  seg_len;
689
690                         seg_len = m_seg->data_len;
691                         next_frag = rte_mbuf_data_dma_addr(m_seg);
692
693                         /*
694                          * If we've started TSO transaction few steps earlier,
695                          * we'll skip packet header using an offset in the
696                          * current segment (which has been set to the
697                          * first one containing payload)
698                          */
699                         seg_len -= in_off;
700                         next_frag += in_off;
701                         in_off = 0;
702
703                         do {
704                                 efsys_dma_addr_t        frag_addr = next_frag;
705                                 size_t                  frag_len;
706
707                                 next_frag = RTE_ALIGN(frag_addr + 1,
708                                                       SFC_TX_SEG_BOUNDARY);
709                                 frag_len = MIN(next_frag - frag_addr, seg_len);
710                                 seg_len -= frag_len;
711                                 pkt_len -= frag_len;
712
713                                 efx_tx_qdesc_dma_create(txq->common,
714                                                         frag_addr, frag_len,
715                                                         (pkt_len == 0),
716                                                         pend++);
717
718                                 pkt_descs++;
719                         } while (seg_len != 0);
720                 }
721
722                 added += pkt_descs;
723
724                 fill_level += pkt_descs;
725                 if (unlikely(fill_level > hard_max_fill)) {
726                         /*
727                          * Our estimation for maximum number of descriptors
728                          * required to send a packet seems to be wrong.
729                          * Try to reap (if we haven't yet).
730                          */
731                         if (!reap_done) {
732                                 sfc_tx_reap(txq);
733                                 reap_done = B_TRUE;
734                                 fill_level = added - txq->completed;
735                                 if (fill_level > hard_max_fill) {
736                                         pend -= pkt_descs;
737                                         break;
738                                 }
739                         } else {
740                                 pend -= pkt_descs;
741                                 break;
742                         }
743                 }
744
745                 /* Assign mbuf to the last used desc */
746                 txq->sw_ring[(added - 1) & txq->ptr_mask].mbuf = *pktp;
747         }
748
749         if (likely(pkts_sent > 0)) {
750                 rc = efx_tx_qdesc_post(txq->common, txq->pend_desc,
751                                        pend - &txq->pend_desc[0],
752                                        txq->completed, &txq->added);
753                 SFC_ASSERT(rc == 0);
754
755                 if (likely(pushed != txq->added))
756                         efx_tx_qpush(txq->common, txq->added, pushed);
757         }
758
759 #if SFC_TX_XMIT_PKTS_REAP_AT_LEAST_ONCE
760         if (!reap_done)
761                 sfc_tx_reap(txq);
762 #endif
763
764 done:
765         return pkts_sent;
766 }