ixgbe: fix release queue mbufs
[dpdk.git] / drivers / net / fm10k / fm10k_rxtx.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
5  *   All rights reserved.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of Intel Corporation nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include <inttypes.h>
35
36 #include <rte_ethdev.h>
37 #include <rte_common.h>
38 #include "fm10k.h"
39 #include "base/fm10k_type.h"
40
41 #ifdef RTE_PMD_PACKET_PREFETCH
42 #define rte_packet_prefetch(p)  rte_prefetch1(p)
43 #else
44 #define rte_packet_prefetch(p)  do {} while (0)
45 #endif
46
47 #ifdef RTE_LIBRTE_FM10K_DEBUG_RX
48 static inline void dump_rxd(union fm10k_rx_desc *rxd)
49 {
50         PMD_RX_LOG(DEBUG, "+----------------|----------------+");
51         PMD_RX_LOG(DEBUG, "|     GLORT      | PKT HDR & TYPE |");
52         PMD_RX_LOG(DEBUG, "|   0x%08x   |   0x%08x   |", rxd->d.glort,
53                         rxd->d.data);
54         PMD_RX_LOG(DEBUG, "+----------------|----------------+");
55         PMD_RX_LOG(DEBUG, "|   VLAN & LEN   |     STATUS     |");
56         PMD_RX_LOG(DEBUG, "|   0x%08x   |   0x%08x   |", rxd->d.vlan_len,
57                         rxd->d.staterr);
58         PMD_RX_LOG(DEBUG, "+----------------|----------------+");
59         PMD_RX_LOG(DEBUG, "|    RESERVED    |    RSS_HASH    |");
60         PMD_RX_LOG(DEBUG, "|   0x%08x   |   0x%08x   |", 0, rxd->d.rss);
61         PMD_RX_LOG(DEBUG, "+----------------|----------------+");
62         PMD_RX_LOG(DEBUG, "|            TIME TAG             |");
63         PMD_RX_LOG(DEBUG, "|       0x%016"PRIx64"        |", rxd->q.timestamp);
64         PMD_RX_LOG(DEBUG, "+----------------|----------------+");
65 }
66 #endif
67
68 static inline void
69 rx_desc_to_ol_flags(struct rte_mbuf *m, const union fm10k_rx_desc *d)
70 {
71 #ifdef RTE_NEXT_ABI
72         static const uint32_t
73                 ptype_table[FM10K_RXD_PKTTYPE_MASK >> FM10K_RXD_PKTTYPE_SHIFT]
74                         __rte_cache_aligned = {
75                 [FM10K_PKTTYPE_OTHER] = RTE_PTYPE_L2_ETHER,
76                 [FM10K_PKTTYPE_IPV4] = RTE_PTYPE_L2_ETHER | RTE_PTYPE_L3_IPV4,
77                 [FM10K_PKTTYPE_IPV4_EX] = RTE_PTYPE_L2_ETHER |
78                         RTE_PTYPE_L3_IPV4_EXT,
79                 [FM10K_PKTTYPE_IPV6] = RTE_PTYPE_L2_ETHER | RTE_PTYPE_L3_IPV6,
80                 [FM10K_PKTTYPE_IPV6_EX] = RTE_PTYPE_L2_ETHER |
81                         RTE_PTYPE_L3_IPV6_EXT,
82                 [FM10K_PKTTYPE_IPV4 | FM10K_PKTTYPE_TCP] = RTE_PTYPE_L2_ETHER |
83                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_L4_TCP,
84                 [FM10K_PKTTYPE_IPV6 | FM10K_PKTTYPE_TCP] = RTE_PTYPE_L2_ETHER |
85                         RTE_PTYPE_L3_IPV6 | RTE_PTYPE_L4_TCP,
86                 [FM10K_PKTTYPE_IPV4 | FM10K_PKTTYPE_UDP] = RTE_PTYPE_L2_ETHER |
87                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_L4_UDP,
88                 [FM10K_PKTTYPE_IPV6 | FM10K_PKTTYPE_UDP] = RTE_PTYPE_L2_ETHER |
89                         RTE_PTYPE_L3_IPV6 | RTE_PTYPE_L4_UDP,
90         };
91
92         m->packet_type = ptype_table[(d->w.pkt_info & FM10K_RXD_PKTTYPE_MASK)
93                                                 >> FM10K_RXD_PKTTYPE_SHIFT];
94 #else /* RTE_NEXT_ABI */
95         uint16_t ptype;
96         static const uint16_t pt_lut[] = { 0,
97                 PKT_RX_IPV4_HDR, PKT_RX_IPV4_HDR_EXT,
98                 PKT_RX_IPV6_HDR, PKT_RX_IPV6_HDR_EXT,
99                 0, 0, 0
100         };
101 #endif /* RTE_NEXT_ABI */
102
103         if (d->w.pkt_info & FM10K_RXD_RSSTYPE_MASK)
104                 m->ol_flags |= PKT_RX_RSS_HASH;
105
106         if (unlikely((d->d.staterr &
107                 (FM10K_RXD_STATUS_IPCS | FM10K_RXD_STATUS_IPE)) ==
108                 (FM10K_RXD_STATUS_IPCS | FM10K_RXD_STATUS_IPE)))
109                 m->ol_flags |= PKT_RX_IP_CKSUM_BAD;
110
111         if (unlikely((d->d.staterr &
112                 (FM10K_RXD_STATUS_L4CS | FM10K_RXD_STATUS_L4E)) ==
113                 (FM10K_RXD_STATUS_L4CS | FM10K_RXD_STATUS_L4E)))
114                 m->ol_flags |= PKT_RX_L4_CKSUM_BAD;
115
116         if (d->d.staterr & FM10K_RXD_STATUS_VEXT)
117                 m->ol_flags |= PKT_RX_VLAN_PKT;
118
119         if (unlikely(d->d.staterr & FM10K_RXD_STATUS_HBO))
120                 m->ol_flags |= PKT_RX_HBUF_OVERFLOW;
121
122         if (unlikely(d->d.staterr & FM10K_RXD_STATUS_RXE))
123                 m->ol_flags |= PKT_RX_RECIP_ERR;
124
125 #ifndef RTE_NEXT_ABI
126         ptype = (d->d.data & FM10K_RXD_PKTTYPE_MASK_L3) >>
127                                                 FM10K_RXD_PKTTYPE_SHIFT;
128         m->ol_flags |= pt_lut[(uint8_t)ptype];
129 #endif
130 }
131
132 uint16_t
133 fm10k_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
134         uint16_t nb_pkts)
135 {
136         struct rte_mbuf *mbuf;
137         union fm10k_rx_desc desc;
138         struct fm10k_rx_queue *q = rx_queue;
139         uint16_t count = 0;
140         int alloc = 0;
141         uint16_t next_dd;
142         int ret;
143
144         next_dd = q->next_dd;
145
146         nb_pkts = RTE_MIN(nb_pkts, q->alloc_thresh);
147         for (count = 0; count < nb_pkts; ++count) {
148                 mbuf = q->sw_ring[next_dd];
149                 desc = q->hw_ring[next_dd];
150                 if (!(desc.d.staterr & FM10K_RXD_STATUS_DD))
151                         break;
152 #ifdef RTE_LIBRTE_FM10K_DEBUG_RX
153                 dump_rxd(&desc);
154 #endif
155                 rte_pktmbuf_pkt_len(mbuf) = desc.w.length;
156                 rte_pktmbuf_data_len(mbuf) = desc.w.length;
157
158                 mbuf->ol_flags = 0;
159 #ifdef RTE_LIBRTE_FM10K_RX_OLFLAGS_ENABLE
160                 rx_desc_to_ol_flags(mbuf, &desc);
161 #endif
162
163                 mbuf->hash.rss = desc.d.rss;
164
165                 rx_pkts[count] = mbuf;
166                 if (++next_dd == q->nb_desc) {
167                         next_dd = 0;
168                         alloc = 1;
169                 }
170
171                 /* Prefetch next mbuf while processing current one. */
172                 rte_prefetch0(q->sw_ring[next_dd]);
173
174                 /*
175                  * When next RX descriptor is on a cache-line boundary,
176                  * prefetch the next 4 RX descriptors and the next 8 pointers
177                  * to mbufs.
178                  */
179                 if ((next_dd & 0x3) == 0) {
180                         rte_prefetch0(&q->hw_ring[next_dd]);
181                         rte_prefetch0(&q->sw_ring[next_dd]);
182                 }
183         }
184
185         q->next_dd = next_dd;
186
187         if ((q->next_dd > q->next_trigger) || (alloc == 1)) {
188                 ret = rte_mempool_get_bulk(q->mp,
189                                         (void **)&q->sw_ring[q->next_alloc],
190                                         q->alloc_thresh);
191
192                 if (unlikely(ret != 0)) {
193                         uint8_t port = q->port_id;
194                         PMD_RX_LOG(ERR, "Failed to alloc mbuf");
195                         /*
196                          * Need to restore next_dd if we cannot allocate new
197                          * buffers to replenish the old ones.
198                          */
199                         q->next_dd = (q->next_dd + q->nb_desc - count) %
200                                                                 q->nb_desc;
201                         rte_eth_devices[port].data->rx_mbuf_alloc_failed++;
202                         return 0;
203                 }
204
205                 for (; q->next_alloc <= q->next_trigger; ++q->next_alloc) {
206                         mbuf = q->sw_ring[q->next_alloc];
207
208                         /* setup static mbuf fields */
209                         fm10k_pktmbuf_reset(mbuf, q->port_id);
210
211                         /* write descriptor */
212                         desc.q.pkt_addr = MBUF_DMA_ADDR_DEFAULT(mbuf);
213                         desc.q.hdr_addr = MBUF_DMA_ADDR_DEFAULT(mbuf);
214                         q->hw_ring[q->next_alloc] = desc;
215                 }
216                 FM10K_PCI_REG_WRITE(q->tail_ptr, q->next_trigger);
217                 q->next_trigger += q->alloc_thresh;
218                 if (q->next_trigger >= q->nb_desc) {
219                         q->next_trigger = q->alloc_thresh - 1;
220                         q->next_alloc = 0;
221                 }
222         }
223
224         return count;
225 }
226
227 uint16_t
228 fm10k_recv_scattered_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
229                                 uint16_t nb_pkts)
230 {
231         struct rte_mbuf *mbuf;
232         union fm10k_rx_desc desc;
233         struct fm10k_rx_queue *q = rx_queue;
234         uint16_t count = 0;
235         uint16_t nb_rcv, nb_seg;
236         int alloc = 0;
237         uint16_t next_dd;
238         struct rte_mbuf *first_seg = q->pkt_first_seg;
239         struct rte_mbuf *last_seg = q->pkt_last_seg;
240         int ret;
241
242         next_dd = q->next_dd;
243         nb_rcv = 0;
244
245         nb_seg = RTE_MIN(nb_pkts, q->alloc_thresh);
246         for (count = 0; count < nb_seg; count++) {
247                 mbuf = q->sw_ring[next_dd];
248                 desc = q->hw_ring[next_dd];
249                 if (!(desc.d.staterr & FM10K_RXD_STATUS_DD))
250                         break;
251 #ifdef RTE_LIBRTE_FM10K_DEBUG_RX
252                 dump_rxd(&desc);
253 #endif
254
255                 if (++next_dd == q->nb_desc) {
256                         next_dd = 0;
257                         alloc = 1;
258                 }
259
260                 /* Prefetch next mbuf while processing current one. */
261                 rte_prefetch0(q->sw_ring[next_dd]);
262
263                 /*
264                  * When next RX descriptor is on a cache-line boundary,
265                  * prefetch the next 4 RX descriptors and the next 8 pointers
266                  * to mbufs.
267                  */
268                 if ((next_dd & 0x3) == 0) {
269                         rte_prefetch0(&q->hw_ring[next_dd]);
270                         rte_prefetch0(&q->sw_ring[next_dd]);
271                 }
272
273                 /* Fill data length */
274                 rte_pktmbuf_data_len(mbuf) = desc.w.length;
275
276                 /*
277                  * If this is the first buffer of the received packet,
278                  * set the pointer to the first mbuf of the packet and
279                  * initialize its context.
280                  * Otherwise, update the total length and the number of segments
281                  * of the current scattered packet, and update the pointer to
282                  * the last mbuf of the current packet.
283                  */
284                 if (!first_seg) {
285                         first_seg = mbuf;
286                         first_seg->pkt_len = desc.w.length;
287                 } else {
288                         first_seg->pkt_len =
289                                         (uint16_t)(first_seg->pkt_len +
290                                         rte_pktmbuf_data_len(mbuf));
291                         first_seg->nb_segs++;
292                         last_seg->next = mbuf;
293                 }
294
295                 /*
296                  * If this is not the last buffer of the received packet,
297                  * update the pointer to the last mbuf of the current scattered
298                  * packet and continue to parse the RX ring.
299                  */
300                 if (!(desc.d.staterr & FM10K_RXD_STATUS_EOP)) {
301                         last_seg = mbuf;
302                         continue;
303                 }
304
305                 first_seg->ol_flags = 0;
306 #ifdef RTE_LIBRTE_FM10K_RX_OLFLAGS_ENABLE
307                 rx_desc_to_ol_flags(first_seg, &desc);
308 #endif
309                 first_seg->hash.rss = desc.d.rss;
310
311                 /* Prefetch data of first segment, if configured to do so. */
312                 rte_packet_prefetch((char *)first_seg->buf_addr +
313                         first_seg->data_off);
314
315                 /*
316                  * Store the mbuf address into the next entry of the array
317                  * of returned packets.
318                  */
319                 rx_pkts[nb_rcv++] = first_seg;
320
321                 /*
322                  * Setup receipt context for a new packet.
323                  */
324                 first_seg = NULL;
325         }
326
327         q->next_dd = next_dd;
328
329         if ((q->next_dd > q->next_trigger) || (alloc == 1)) {
330                 ret = rte_mempool_get_bulk(q->mp,
331                                         (void **)&q->sw_ring[q->next_alloc],
332                                         q->alloc_thresh);
333
334                 if (unlikely(ret != 0)) {
335                         uint8_t port = q->port_id;
336                         PMD_RX_LOG(ERR, "Failed to alloc mbuf");
337                         /*
338                          * Need to restore next_dd if we cannot allocate new
339                          * buffers to replenish the old ones.
340                          */
341                         q->next_dd = (q->next_dd + q->nb_desc - count) %
342                                                                 q->nb_desc;
343                         rte_eth_devices[port].data->rx_mbuf_alloc_failed++;
344                         return 0;
345                 }
346
347                 for (; q->next_alloc <= q->next_trigger; ++q->next_alloc) {
348                         mbuf = q->sw_ring[q->next_alloc];
349
350                         /* setup static mbuf fields */
351                         fm10k_pktmbuf_reset(mbuf, q->port_id);
352
353                         /* write descriptor */
354                         desc.q.pkt_addr = MBUF_DMA_ADDR_DEFAULT(mbuf);
355                         desc.q.hdr_addr = MBUF_DMA_ADDR_DEFAULT(mbuf);
356                         q->hw_ring[q->next_alloc] = desc;
357                 }
358                 FM10K_PCI_REG_WRITE(q->tail_ptr, q->next_trigger);
359                 q->next_trigger += q->alloc_thresh;
360                 if (q->next_trigger >= q->nb_desc) {
361                         q->next_trigger = q->alloc_thresh - 1;
362                         q->next_alloc = 0;
363                 }
364         }
365
366         q->pkt_first_seg = first_seg;
367         q->pkt_last_seg = last_seg;
368
369         return nb_rcv;
370 }
371
372 static inline void tx_free_descriptors(struct fm10k_tx_queue *q)
373 {
374         uint16_t next_rs, count = 0;
375
376         next_rs = fifo_peek(&q->rs_tracker);
377         if (!(q->hw_ring[next_rs].flags & FM10K_TXD_FLAG_DONE))
378                 return;
379
380         /* the DONE flag is set on this descriptor so remove the ID
381          * from the RS bit tracker and free the buffers */
382         fifo_remove(&q->rs_tracker);
383
384         /* wrap around? if so, free buffers from last_free up to but NOT
385          * including nb_desc */
386         if (q->last_free > next_rs) {
387                 count = q->nb_desc - q->last_free;
388                 while (q->last_free < q->nb_desc) {
389                         rte_pktmbuf_free_seg(q->sw_ring[q->last_free]);
390                         q->sw_ring[q->last_free] = NULL;
391                         ++q->last_free;
392                 }
393                 q->last_free = 0;
394         }
395
396         /* adjust free descriptor count before the next loop */
397         q->nb_free += count + (next_rs + 1 - q->last_free);
398
399         /* free buffers from last_free, up to and including next_rs */
400         while (q->last_free <= next_rs) {
401                 rte_pktmbuf_free_seg(q->sw_ring[q->last_free]);
402                 q->sw_ring[q->last_free] = NULL;
403                 ++q->last_free;
404         }
405
406         if (q->last_free == q->nb_desc)
407                 q->last_free = 0;
408 }
409
410 static inline void tx_xmit_pkt(struct fm10k_tx_queue *q, struct rte_mbuf *mb)
411 {
412         uint16_t last_id;
413         uint8_t flags;
414
415         /* always set the LAST flag on the last descriptor used to
416          * transmit the packet */
417         flags = FM10K_TXD_FLAG_LAST;
418         last_id = q->next_free + mb->nb_segs - 1;
419         if (last_id >= q->nb_desc)
420                 last_id = last_id - q->nb_desc;
421
422         /* but only set the RS flag on the last descriptor if rs_thresh
423          * descriptors will be used since the RS flag was last set */
424         if ((q->nb_used + mb->nb_segs) >= q->rs_thresh) {
425                 flags |= FM10K_TXD_FLAG_RS;
426                 fifo_insert(&q->rs_tracker, last_id);
427                 q->nb_used = 0;
428         } else {
429                 q->nb_used = q->nb_used + mb->nb_segs;
430         }
431
432         q->nb_free -= mb->nb_segs;
433
434         q->hw_ring[q->next_free].flags = 0;
435         /* set checksum flags on first descriptor of packet. SCTP checksum
436          * offload is not supported, but we do not explicitly check for this
437          * case in favor of greatly simplified processing. */
438         if (mb->ol_flags & (PKT_TX_IP_CKSUM | PKT_TX_L4_MASK))
439                 q->hw_ring[q->next_free].flags |= FM10K_TXD_FLAG_CSUM;
440
441         /* set vlan if requested */
442         if (mb->ol_flags & PKT_TX_VLAN_PKT)
443                 q->hw_ring[q->next_free].vlan = mb->vlan_tci;
444
445         q->sw_ring[q->next_free] = mb;
446         q->hw_ring[q->next_free].buffer_addr =
447                         rte_cpu_to_le_64(MBUF_DMA_ADDR(mb));
448         q->hw_ring[q->next_free].buflen =
449                         rte_cpu_to_le_16(rte_pktmbuf_data_len(mb));
450         if (++q->next_free == q->nb_desc)
451                 q->next_free = 0;
452
453         /* fill up the rings */
454         for (mb = mb->next; mb != NULL; mb = mb->next) {
455                 q->sw_ring[q->next_free] = mb;
456                 q->hw_ring[q->next_free].buffer_addr =
457                                 rte_cpu_to_le_64(MBUF_DMA_ADDR(mb));
458                 q->hw_ring[q->next_free].buflen =
459                                 rte_cpu_to_le_16(rte_pktmbuf_data_len(mb));
460                 q->hw_ring[q->next_free].flags = 0;
461                 if (++q->next_free == q->nb_desc)
462                         q->next_free = 0;
463         }
464
465         q->hw_ring[last_id].flags = flags;
466 }
467
468 uint16_t
469 fm10k_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts,
470         uint16_t nb_pkts)
471 {
472         struct fm10k_tx_queue *q = tx_queue;
473         struct rte_mbuf *mb;
474         uint16_t count;
475
476         for (count = 0; count < nb_pkts; ++count) {
477                 mb = tx_pkts[count];
478
479                 /* running low on descriptors? try to free some... */
480                 if (q->nb_free < q->free_thresh)
481                         tx_free_descriptors(q);
482
483                 /* make sure there are enough free descriptors to transmit the
484                  * entire packet before doing anything */
485                 if (q->nb_free < mb->nb_segs)
486                         break;
487
488                 /* sanity check to make sure the mbuf is valid */
489                 if ((mb->nb_segs == 0) ||
490                     ((mb->nb_segs > 1) && (mb->next == NULL)))
491                         break;
492
493                 /* process the packet */
494                 tx_xmit_pkt(q, mb);
495         }
496
497         /* update the tail pointer if any packets were processed */
498         if (likely(count > 0))
499                 FM10K_PCI_REG_WRITE(q->tail_ptr, q->next_free);
500
501         return count;
502 }