8a7772a7e39ead7e2668406e926afddf29ee550b
[dpdk.git] / drivers / net / bnxt / bnxt_rxtx_vec_common.h
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2020 Broadcom
3  * All rights reserved.
4  */
5
6 #ifndef _BNXT_RXTX_VEC_COMMON_H_
7 #define _BNXT_RXTX_VEC_COMMON_H_
8 #include "hsi_struct_def_dpdk.h"
9 #include "bnxt_rxq.h"
10 #include "bnxt_rxr.h"
11
12 #define TX_BD_FLAGS_CMPL ((1 << TX_BD_LONG_FLAGS_BD_CNT_SFT) | \
13                           TX_BD_SHORT_FLAGS_COAL_NOW | \
14                           TX_BD_SHORT_TYPE_TX_BD_SHORT | \
15                           TX_BD_LONG_FLAGS_PACKET_END)
16
17 #define TX_BD_FLAGS_NOCMPL (TX_BD_FLAGS_CMPL | TX_BD_LONG_FLAGS_NO_CMPL)
18
19 static inline uint32_t
20 bnxt_xmit_flags_len(uint16_t len, uint16_t flags)
21 {
22         switch (len >> 9) {
23         case 0:
24                 return flags | TX_BD_LONG_FLAGS_LHINT_LT512;
25         case 1:
26                 return flags | TX_BD_LONG_FLAGS_LHINT_LT1K;
27         case 2:
28                 return flags | TX_BD_LONG_FLAGS_LHINT_LT2K;
29         case 3:
30                 return flags | TX_BD_LONG_FLAGS_LHINT_LT2K;
31         default:
32                 return flags | TX_BD_LONG_FLAGS_LHINT_GTE2K;
33         }
34 }
35
36 static inline int
37 bnxt_rxq_vec_setup_common(struct bnxt_rx_queue *rxq)
38 {
39         uintptr_t p;
40         struct rte_mbuf mb_def = { .buf_addr = 0 }; /* zeroed mbuf */
41
42         mb_def.nb_segs = 1;
43         mb_def.data_off = RTE_PKTMBUF_HEADROOM;
44         mb_def.port = rxq->port_id;
45         rte_mbuf_refcnt_set(&mb_def, 1);
46
47         /* prevent compiler reordering: rearm_data covers previous fields */
48         rte_compiler_barrier();
49         p = (uintptr_t)&mb_def.rearm_data;
50         rxq->mbuf_initializer = *(uint64_t *)p;
51         rxq->rxrearm_nb = 0;
52         rxq->rxrearm_start = 0;
53         return 0;
54 }
55
56 static inline void
57 bnxt_rxq_rearm(struct bnxt_rx_queue *rxq, struct bnxt_rx_ring_info *rxr)
58 {
59         struct rx_prod_pkt_bd *rxbds = &rxr->rx_desc_ring[rxq->rxrearm_start];
60         struct rte_mbuf **rx_bufs = &rxr->rx_buf_ring[rxq->rxrearm_start];
61         int nb, i;
62
63         /*
64          * Number of mbufs to allocate must be a multiple of four. The
65          * allocation must not go past the end of the ring.
66          */
67         nb = RTE_MIN(rxq->rxrearm_nb & ~0x3,
68                      rxq->nb_rx_desc - rxq->rxrearm_start);
69
70         /* Allocate new mbufs into the software ring. */
71         if (rte_mempool_get_bulk(rxq->mb_pool, (void *)rx_bufs, nb) < 0) {
72                 rte_eth_devices[rxq->port_id].data->rx_mbuf_alloc_failed += nb;
73
74                 for (i = 0; i < nb; i++)
75                         rx_bufs[i] = &rxq->fake_mbuf;
76                 return;
77         }
78
79         /* Initialize the mbufs in vector, process 4 mbufs per loop. */
80         for (i = 0; i < nb; i += 4) {
81                 rxbds[0].address = rte_mbuf_data_iova_default(rx_bufs[0]);
82                 rxbds[1].address = rte_mbuf_data_iova_default(rx_bufs[1]);
83                 rxbds[2].address = rte_mbuf_data_iova_default(rx_bufs[2]);
84                 rxbds[3].address = rte_mbuf_data_iova_default(rx_bufs[3]);
85
86                 rxbds += 4;
87                 rx_bufs += 4;
88         }
89
90         rxq->rxrearm_start += nb;
91         bnxt_db_write(&rxr->rx_db, rxq->rxrearm_start - 1);
92         if (rxq->rxrearm_start >= rxq->nb_rx_desc)
93                 rxq->rxrearm_start = 0;
94
95         rxq->rxrearm_nb -= nb;
96 }
97
98 /*
99  * Transmit completion function for use when DEV_TX_OFFLOAD_MBUF_FAST_FREE
100  * is enabled.
101  */
102 static inline void
103 bnxt_tx_cmp_vec_fast(struct bnxt_tx_queue *txq, int nr_pkts)
104 {
105         struct bnxt_tx_ring_info *txr = txq->tx_ring;
106         struct rte_mbuf **free = txq->free;
107         uint16_t cons, raw_cons = txr->tx_raw_cons;
108         unsigned int blk = 0;
109         uint32_t ring_mask = txr->tx_ring_struct->ring_mask;
110
111         while (nr_pkts--) {
112                 struct bnxt_sw_tx_bd *tx_buf;
113
114                 cons = raw_cons++ & ring_mask;
115                 tx_buf = &txr->tx_buf_ring[cons];
116                 free[blk++] = tx_buf->mbuf;
117                 tx_buf->mbuf = NULL;
118         }
119         if (blk)
120                 rte_mempool_put_bulk(free[0]->pool, (void **)free, blk);
121
122         txr->tx_raw_cons = raw_cons;
123 }
124
125 static inline void
126 bnxt_tx_cmp_vec(struct bnxt_tx_queue *txq, int nr_pkts)
127 {
128         struct bnxt_tx_ring_info *txr = txq->tx_ring;
129         struct rte_mbuf **free = txq->free;
130         uint16_t cons, raw_cons = txr->tx_raw_cons;
131         unsigned int blk = 0;
132         uint32_t ring_mask = txr->tx_ring_struct->ring_mask;
133
134         while (nr_pkts--) {
135                 struct bnxt_sw_tx_bd *tx_buf;
136                 struct rte_mbuf *mbuf;
137
138                 cons = raw_cons++ & ring_mask;
139                 tx_buf = &txr->tx_buf_ring[cons];
140                 mbuf = rte_pktmbuf_prefree_seg(tx_buf->mbuf);
141                 if (unlikely(mbuf == NULL))
142                         continue;
143                 tx_buf->mbuf = NULL;
144
145                 if (blk && mbuf->pool != free[0]->pool) {
146                         rte_mempool_put_bulk(free[0]->pool, (void **)free, blk);
147                         blk = 0;
148                 }
149                 free[blk++] = mbuf;
150         }
151         if (blk)
152                 rte_mempool_put_bulk(free[0]->pool, (void **)free, blk);
153
154         txr->tx_raw_cons = raw_cons;
155 }
156 #endif /* _BNXT_RXTX_VEC_COMMON_H_ */