Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (c) 2023 Corigine, Inc.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "nfp_nfd3.h"
7 : :
8 : : #include <bus_pci_driver.h>
9 : : #include <rte_malloc.h>
10 : :
11 : : #include "../flower/nfp_flower.h"
12 : : #include "../nfp_logs.h"
13 : :
14 : : /* Flags in the host TX descriptor */
15 : : #define NFD3_DESC_TX_CSUM RTE_BIT32(7)
16 : : #define NFD3_DESC_TX_IP4_CSUM RTE_BIT32(6)
17 : : #define NFD3_DESC_TX_TCP_CSUM RTE_BIT32(5)
18 : : #define NFD3_DESC_TX_UDP_CSUM RTE_BIT32(4)
19 : : #define NFD3_DESC_TX_VLAN RTE_BIT32(3)
20 : : #define NFD3_DESC_TX_LSO RTE_BIT32(2)
21 : : #define NFD3_DESC_TX_ENCAP RTE_BIT32(1)
22 : : #define NFD3_DESC_TX_O_IP4_CSUM RTE_BIT32(0)
23 : :
24 : : /* Set NFD3 TX descriptor for TSO */
25 : : static void
26 : 0 : nfp_net_nfd3_tx_tso(struct nfp_net_txq *txq,
27 : : struct nfp_net_nfd3_tx_desc *txd,
28 : : struct rte_mbuf *mb)
29 : : {
30 : : uint64_t ol_flags;
31 : 0 : struct nfp_net_hw *hw = txq->hw;
32 : :
33 [ # # ]: 0 : if ((hw->super.ctrl & NFP_NET_CFG_CTRL_LSO_ANY) == 0)
34 : 0 : goto clean_txd;
35 : :
36 : 0 : ol_flags = mb->ol_flags;
37 [ # # ]: 0 : if ((ol_flags & RTE_MBUF_F_TX_TCP_SEG) == 0 &&
38 : : (ol_flags & RTE_MBUF_F_TX_UDP_SEG) == 0)
39 : 0 : goto clean_txd;
40 : :
41 : 0 : txd->l3_offset = mb->l2_len;
42 : 0 : txd->l4_offset = mb->l2_len + mb->l3_len;
43 : 0 : txd->lso_hdrlen = mb->l2_len + mb->l3_len + mb->l4_len;
44 : :
45 [ # # ]: 0 : if ((ol_flags & RTE_MBUF_F_TX_TUNNEL_MASK) != 0) {
46 : 0 : txd->l3_offset += mb->outer_l2_len + mb->outer_l3_len;
47 : 0 : txd->l4_offset += mb->outer_l2_len + mb->outer_l3_len;
48 : 0 : txd->lso_hdrlen += mb->outer_l2_len + mb->outer_l3_len;
49 : : }
50 : :
51 : 0 : txd->mss = rte_cpu_to_le_16(mb->tso_segsz);
52 : 0 : txd->flags = NFD3_DESC_TX_LSO;
53 : :
54 : 0 : return;
55 : :
56 : 0 : clean_txd:
57 : 0 : txd->flags = 0;
58 : 0 : txd->l3_offset = 0;
59 : 0 : txd->l4_offset = 0;
60 : 0 : txd->lso_hdrlen = 0;
61 : 0 : txd->mss = 0;
62 : : }
63 : :
64 : : /* Set TX CSUM offload flags in NFD3 TX descriptor */
65 : : static void
66 : 0 : nfp_net_nfd3_tx_cksum(struct nfp_net_txq *txq,
67 : : struct nfp_net_nfd3_tx_desc *txd,
68 : : struct rte_mbuf *mb)
69 : : {
70 : : uint64_t ol_flags;
71 : 0 : struct nfp_net_hw *hw = txq->hw;
72 : :
73 [ # # ]: 0 : if ((hw->super.ctrl & NFP_NET_CFG_CTRL_TXCSUM) == 0)
74 : : return;
75 : :
76 : 0 : ol_flags = mb->ol_flags;
77 : :
78 : : /* Set TCP csum offload if TSO enabled. */
79 [ # # ]: 0 : if ((ol_flags & RTE_MBUF_F_TX_TCP_SEG) != 0)
80 : 0 : txd->flags |= NFD3_DESC_TX_TCP_CSUM;
81 : :
82 : : /* Set UDP csum offload if UFO enabled. */
83 [ # # ]: 0 : if ((ol_flags & RTE_MBUF_F_TX_UDP_SEG) != 0)
84 : 0 : txd->flags |= NFD3_DESC_TX_UDP_CSUM;
85 : :
86 : : /* IPv6 does not need checksum */
87 [ # # ]: 0 : if ((ol_flags & RTE_MBUF_F_TX_IP_CKSUM) != 0)
88 : 0 : txd->flags |= NFD3_DESC_TX_IP4_CSUM;
89 : :
90 [ # # ]: 0 : if ((ol_flags & RTE_MBUF_F_TX_TUNNEL_MASK) != 0)
91 : 0 : txd->flags |= NFD3_DESC_TX_ENCAP;
92 : :
93 [ # # # ]: 0 : switch (ol_flags & RTE_MBUF_F_TX_L4_MASK) {
94 : 0 : case RTE_MBUF_F_TX_UDP_CKSUM:
95 : 0 : txd->flags |= NFD3_DESC_TX_UDP_CSUM;
96 : 0 : break;
97 : 0 : case RTE_MBUF_F_TX_TCP_CKSUM:
98 : 0 : txd->flags |= NFD3_DESC_TX_TCP_CSUM;
99 : 0 : break;
100 : : }
101 : :
102 [ # # ]: 0 : if ((ol_flags & (RTE_MBUF_F_TX_IP_CKSUM | RTE_MBUF_F_TX_L4_MASK)) != 0)
103 : 0 : txd->flags |= NFD3_DESC_TX_CSUM;
104 : : }
105 : :
106 : : uint32_t
107 [ # # ]: 0 : nfp_flower_nfd3_pkt_add_metadata(struct rte_mbuf *mbuf,
108 : : uint32_t port_id)
109 : : {
110 : : char *meta_offset;
111 : :
112 : : meta_offset = rte_pktmbuf_prepend(mbuf, FLOWER_PKT_DATA_OFFSET);
113 : 0 : *(rte_be32_t *)meta_offset = rte_cpu_to_be_32(NFP_NET_META_PORTID);
114 : : meta_offset += NFP_NET_META_HEADER_SIZE;
115 [ # # ]: 0 : *(rte_be32_t *)meta_offset = rte_cpu_to_be_32(port_id);
116 : :
117 : 0 : return FLOWER_PKT_DATA_OFFSET;
118 : : }
119 : :
120 : : /*
121 : : * Set vlan info in the nfd3 tx desc
122 : : *
123 : : * If enable NFP_NET_CFG_CTRL_TXVLAN_V2
124 : : * Vlan_info is stored in the meta and is handled in the @nfp_net_nfd3_set_meta_vlan()
125 : : * else if enable NFP_NET_CFG_CTRL_TXVLAN
126 : : * Vlan_info is stored in the tx_desc and is handled in the @nfp_net_nfd3_tx_vlan()
127 : : */
128 : : static inline void
129 : : nfp_net_nfd3_tx_vlan(struct nfp_net_txq *txq,
130 : : struct nfp_net_nfd3_tx_desc *txd,
131 : : struct rte_mbuf *mb)
132 : : {
133 : 0 : struct nfp_net_hw *hw = txq->hw;
134 : :
135 [ # # ]: 0 : if ((hw->super.ctrl & NFP_NET_CFG_CTRL_TXVLAN_V2) != 0 ||
136 : : (hw->super.ctrl & NFP_NET_CFG_CTRL_TXVLAN) == 0)
137 : : return;
138 : :
139 [ # # ]: 0 : if ((mb->ol_flags & RTE_MBUF_F_TX_VLAN) != 0) {
140 : 0 : txd->flags |= NFD3_DESC_TX_VLAN;
141 : 0 : txd->vlan = mb->vlan_tci;
142 : : }
143 : : }
144 : :
145 : : static inline int
146 : 0 : nfp_net_nfd3_set_meta_data(struct nfp_net_meta_raw *meta_data,
147 : : struct nfp_net_txq *txq,
148 : : struct rte_mbuf *pkt)
149 : : {
150 : : char *meta;
151 : : uint8_t layer = 0;
152 : : uint32_t meta_info;
153 : : struct nfp_net_hw *hw;
154 : : uint8_t vlan_layer = 0;
155 : : uint8_t ipsec_layer = 0;
156 : :
157 : 0 : hw = txq->hw;
158 : :
159 [ # # ]: 0 : if ((pkt->ol_flags & RTE_MBUF_F_TX_VLAN) != 0 &&
160 [ # # ]: 0 : (hw->super.ctrl & NFP_NET_CFG_CTRL_TXVLAN_V2) != 0) {
161 [ # # ]: 0 : if (meta_data->length == 0)
162 : 0 : meta_data->length = NFP_NET_META_HEADER_SIZE;
163 : 0 : meta_data->length += NFP_NET_META_FIELD_SIZE;
164 : 0 : meta_data->header |= NFP_NET_META_VLAN;
165 : : }
166 : :
167 [ # # ]: 0 : if ((pkt->ol_flags & RTE_MBUF_F_TX_SEC_OFFLOAD) != 0 &&
168 [ # # ]: 0 : (hw->super.ctrl_ext & NFP_NET_CFG_CTRL_IPSEC) != 0) {
169 : : uint32_t ipsec_type = NFP_NET_META_IPSEC |
170 : : NFP_NET_META_IPSEC << NFP_NET_META_FIELD_SIZE |
171 : : NFP_NET_META_IPSEC << (2 * NFP_NET_META_FIELD_SIZE);
172 [ # # ]: 0 : if (meta_data->length == 0)
173 : 0 : meta_data->length = NFP_NET_META_FIELD_SIZE;
174 : 0 : uint8_t ipsec_offset = meta_data->length - NFP_NET_META_FIELD_SIZE;
175 : 0 : meta_data->header |= (ipsec_type << ipsec_offset);
176 : 0 : meta_data->length += 3 * NFP_NET_META_FIELD_SIZE;
177 : : }
178 : :
179 [ # # ]: 0 : if (meta_data->length == 0)
180 : : return 0;
181 : :
182 : 0 : meta_info = meta_data->header;
183 [ # # # # ]: 0 : meta_data->header = rte_cpu_to_be_32(meta_data->header);
184 : : meta = rte_pktmbuf_prepend(pkt, meta_data->length);
185 : 0 : memcpy(meta, &meta_data->header, sizeof(meta_data->header));
186 : 0 : meta += NFP_NET_META_HEADER_SIZE;
187 : :
188 [ # # ]: 0 : for (; meta_info != 0; meta_info >>= NFP_NET_META_FIELD_SIZE, layer++,
189 : 0 : meta += NFP_NET_META_FIELD_SIZE) {
190 [ # # # ]: 0 : switch (meta_info & NFP_NET_META_FIELD_MASK) {
191 : 0 : case NFP_NET_META_VLAN:
192 [ # # ]: 0 : if (vlan_layer > 0) {
193 : 0 : PMD_DRV_LOG(ERR, "At most 1 layers of vlan is supported");
194 : 0 : return -EINVAL;
195 : : }
196 : :
197 : 0 : nfp_net_set_meta_vlan(meta_data, pkt, layer);
198 : : vlan_layer++;
199 : 0 : break;
200 : 0 : case NFP_NET_META_IPSEC:
201 [ # # ]: 0 : if (ipsec_layer > 2) {
202 : 0 : PMD_DRV_LOG(ERR, "At most 3 layers of ipsec is supported for now.");
203 : 0 : return -EINVAL;
204 : : }
205 : :
206 : 0 : nfp_net_set_meta_ipsec(meta_data, txq, pkt, layer, ipsec_layer);
207 : 0 : ipsec_layer++;
208 : 0 : break;
209 : 0 : default:
210 : 0 : PMD_DRV_LOG(ERR, "The metadata type not supported");
211 : 0 : return -ENOTSUP;
212 : : }
213 : :
214 : 0 : memcpy(meta, &meta_data->data[layer], sizeof(meta_data->data[layer]));
215 : : }
216 : :
217 : : return 0;
218 : : }
219 : :
220 : : uint16_t
221 : 0 : nfp_net_nfd3_xmit_pkts(void *tx_queue,
222 : : struct rte_mbuf **tx_pkts,
223 : : uint16_t nb_pkts)
224 : : {
225 : 0 : return nfp_net_nfd3_xmit_pkts_common(tx_queue, tx_pkts, nb_pkts, false);
226 : : }
227 : :
228 : : uint16_t
229 : 0 : nfp_net_nfd3_xmit_pkts_common(void *tx_queue,
230 : : struct rte_mbuf **tx_pkts,
231 : : uint16_t nb_pkts,
232 : : bool repr_flag)
233 : : {
234 : : int ret;
235 : : uint16_t i;
236 : : uint8_t offset;
237 : : uint32_t pkt_size;
238 : : uint16_t dma_size;
239 : : uint64_t dma_addr;
240 : : uint16_t free_descs;
241 : : struct rte_mbuf *pkt;
242 : : uint16_t issued_descs;
243 : : struct nfp_net_hw *hw;
244 : : struct rte_mbuf **lmbuf;
245 : : struct nfp_net_txq *txq;
246 : : struct nfp_net_nfd3_tx_desc txd;
247 : : struct nfp_net_nfd3_tx_desc *txds;
248 : :
249 : : txq = tx_queue;
250 : 0 : hw = txq->hw;
251 [ # # ]: 0 : txds = &txq->txds[txq->wr_p];
252 : :
253 : : PMD_TX_LOG(DEBUG, "working for queue %hu at pos %d and %hu packets",
254 : : txq->qidx, txq->wr_p, nb_pkts);
255 : :
256 [ # # # # ]: 0 : if (nfp_net_nfd3_free_tx_desc(txq) < NFD3_TX_DESC_PER_PKT * nb_pkts ||
257 : : nfp_net_nfd3_txq_full(txq))
258 : 0 : nfp_net_tx_free_bufs(txq);
259 : :
260 : 0 : free_descs = nfp_net_nfd3_free_tx_desc(txq);
261 [ # # ]: 0 : if (unlikely(free_descs == 0))
262 : : return 0;
263 : :
264 : : pkt = *tx_pkts;
265 : :
266 : : issued_descs = 0;
267 : : PMD_TX_LOG(DEBUG, "queue: %hu. Sending %hu packets", txq->qidx, nb_pkts);
268 : :
269 : : /* Sending packets */
270 [ # # ]: 0 : for (i = 0; i < nb_pkts && free_descs > 0; i++) {
271 : : /* Grabbing the mbuf linked to the current descriptor */
272 : 0 : lmbuf = &txq->txbufs[txq->wr_p].mbuf;
273 : : /* Warming the cache for releasing the mbuf later on */
274 [ # # ]: 0 : RTE_MBUF_PREFETCH_TO_FREE(*lmbuf);
275 : :
276 : 0 : pkt = *(tx_pkts + i);
277 : :
278 [ # # ]: 0 : if (!repr_flag) {
279 : : struct nfp_net_meta_raw meta_data;
280 : : memset(&meta_data, 0, sizeof(meta_data));
281 : 0 : ret = nfp_net_nfd3_set_meta_data(&meta_data, txq, pkt);
282 [ # # ]: 0 : if (unlikely(ret != 0))
283 : 0 : goto xmit_end;
284 : :
285 : 0 : offset = meta_data.length;
286 : : } else {
287 : : offset = FLOWER_PKT_DATA_OFFSET;
288 : : }
289 : :
290 [ # # # # ]: 0 : if (unlikely(pkt->nb_segs > 1 &&
291 : : (hw->super.ctrl & NFP_NET_CFG_CTRL_GATHER) == 0)) {
292 : : PMD_TX_LOG(ERR, "Multisegment packet not supported");
293 : 0 : goto xmit_end;
294 : : }
295 : :
296 : : /* Checking if we have enough descriptors */
297 [ # # ]: 0 : if (unlikely(pkt->nb_segs > free_descs))
298 : 0 : goto xmit_end;
299 : :
300 : : /*
301 : : * Checksum and VLAN flags just in the first descriptor for a
302 : : * multisegment packet, but TSO info needs to be in all of them.
303 : : */
304 : 0 : txd.data_len = pkt->pkt_len;
305 : 0 : nfp_net_nfd3_tx_tso(txq, &txd, pkt);
306 : 0 : nfp_net_nfd3_tx_cksum(txq, &txd, pkt);
307 : : nfp_net_nfd3_tx_vlan(txq, &txd, pkt);
308 : :
309 : : /*
310 : : * Mbuf data_len is the data in one segment and pkt_len data
311 : : * in the whole packet. When the packet is just one segment,
312 : : * then data_len = pkt_len.
313 : : */
314 : : pkt_size = pkt->pkt_len;
315 : :
316 [ # # ]: 0 : while (pkt != NULL && free_descs > 0) {
317 : : /* Copying TSO, VLAN and cksum info */
318 : 0 : *txds = txd;
319 : :
320 : : /* Releasing mbuf used by this descriptor previously */
321 [ # # ]: 0 : if (*lmbuf != NULL)
322 : : rte_pktmbuf_free_seg(*lmbuf);
323 : :
324 : : /*
325 : : * Linking mbuf with descriptor for being released
326 : : * next time descriptor is used.
327 : : */
328 : 0 : *lmbuf = pkt;
329 : :
330 [ # # ]: 0 : dma_size = pkt->data_len;
331 : : dma_addr = rte_mbuf_data_iova(pkt);
332 : :
333 : : /* Filling descriptors fields */
334 : 0 : txds->dma_len = dma_size;
335 : 0 : txds->data_len = txd.data_len;
336 : 0 : txds->dma_addr_hi = (dma_addr >> 32) & 0xff;
337 : 0 : txds->dma_addr_lo = (dma_addr & 0xffffffff);
338 : 0 : free_descs--;
339 : :
340 : 0 : txq->wr_p++;
341 [ # # ]: 0 : if (unlikely(txq->wr_p == txq->tx_count)) /* Wrapping */
342 : 0 : txq->wr_p = 0;
343 : :
344 : 0 : pkt_size -= dma_size;
345 : :
346 : : /*
347 : : * Making the EOP, packets with just one segment
348 : : * the priority.
349 : : */
350 [ # # ]: 0 : if (likely(pkt_size == 0))
351 : 0 : txds->offset_eop = NFD3_DESC_TX_EOP;
352 : : else
353 : 0 : txds->offset_eop = 0;
354 : :
355 : : /* Set the meta_len */
356 : 0 : txds->offset_eop |= offset;
357 : :
358 : 0 : pkt = pkt->next;
359 : : /* Referencing next free TX descriptor */
360 : 0 : txds = &txq->txds[txq->wr_p];
361 : 0 : lmbuf = &txq->txbufs[txq->wr_p].mbuf;
362 : 0 : issued_descs++;
363 : : }
364 : : }
365 : :
366 : 0 : xmit_end:
367 : : /* Increment write pointers. Force memory write before we let HW know */
368 : : rte_wmb();
369 : 0 : nfp_qcp_ptr_add(txq->qcp_q, NFP_QCP_WRITE_PTR, issued_descs);
370 : :
371 : 0 : return i;
372 : : }
373 : :
374 : : int
375 : 0 : nfp_net_nfd3_tx_queue_setup(struct rte_eth_dev *dev,
376 : : uint16_t queue_idx,
377 : : uint16_t nb_desc,
378 : : unsigned int socket_id,
379 : : const struct rte_eth_txconf *tx_conf)
380 : : {
381 : : size_t size;
382 : : uint32_t tx_desc_sz;
383 : : uint16_t min_tx_desc;
384 : : uint16_t max_tx_desc;
385 : : struct nfp_net_hw *hw;
386 : : struct nfp_net_txq *txq;
387 : : uint16_t tx_free_thresh;
388 : : const struct rte_memzone *tz;
389 : :
390 : 0 : hw = nfp_net_get_hw(dev);
391 : :
392 : 0 : nfp_net_tx_desc_limits(hw, &min_tx_desc, &max_tx_desc);
393 : :
394 : : /* Validating number of descriptors */
395 : 0 : tx_desc_sz = nb_desc * sizeof(struct nfp_net_nfd3_tx_desc);
396 [ # # ]: 0 : if ((NFD3_TX_DESC_PER_PKT * tx_desc_sz) % NFP_ALIGN_RING_DESC != 0 ||
397 [ # # # # ]: 0 : nb_desc > max_tx_desc || nb_desc < min_tx_desc) {
398 : 0 : PMD_DRV_LOG(ERR, "Wrong nb_desc value");
399 : 0 : return -EINVAL;
400 : : }
401 : :
402 [ # # ]: 0 : tx_free_thresh = (tx_conf->tx_free_thresh != 0) ?
403 : : tx_conf->tx_free_thresh : DEFAULT_TX_FREE_THRESH;
404 [ # # ]: 0 : if (tx_free_thresh > nb_desc) {
405 : 0 : PMD_DRV_LOG(ERR, "tx_free_thresh must be less than the number of TX "
406 : : "descriptors. (tx_free_thresh=%u port=%d queue=%d)",
407 : : tx_free_thresh, dev->data->port_id, queue_idx);
408 : 0 : return -EINVAL;
409 : : }
410 : :
411 : : /*
412 : : * Free memory prior to re-allocation if needed. This is the case after
413 : : * calling nfp_net_stop().
414 : : */
415 [ # # ]: 0 : if (dev->data->tx_queues[queue_idx] != NULL) {
416 : : PMD_TX_LOG(DEBUG, "Freeing memory prior to re-allocation %d",
417 : : queue_idx);
418 : 0 : nfp_net_tx_queue_release(dev, queue_idx);
419 : 0 : dev->data->tx_queues[queue_idx] = NULL;
420 : : }
421 : :
422 : : /* Allocating tx queue data structure */
423 : 0 : txq = rte_zmalloc_socket("ethdev TX queue", sizeof(struct nfp_net_txq),
424 : : RTE_CACHE_LINE_SIZE, socket_id);
425 [ # # ]: 0 : if (txq == NULL) {
426 : 0 : PMD_DRV_LOG(ERR, "Error allocating tx dma");
427 : 0 : return -ENOMEM;
428 : : }
429 : :
430 : 0 : dev->data->tx_queues[queue_idx] = txq;
431 : :
432 : : /*
433 : : * Allocate TX ring hardware descriptors. A memzone large enough to
434 : : * handle the maximum ring size is allocated in order to allow for
435 : : * resizing in later calls to the queue setup function.
436 : : */
437 : 0 : size = sizeof(struct nfp_net_nfd3_tx_desc) * NFD3_TX_DESC_PER_PKT * max_tx_desc;
438 : 0 : tz = rte_eth_dma_zone_reserve(dev, "tx_ring", queue_idx, size,
439 : : NFP_MEMZONE_ALIGN, socket_id);
440 [ # # ]: 0 : if (tz == NULL) {
441 : 0 : PMD_DRV_LOG(ERR, "Error allocating tx dma");
442 : 0 : nfp_net_tx_queue_release(dev, queue_idx);
443 : 0 : dev->data->tx_queues[queue_idx] = NULL;
444 : 0 : return -ENOMEM;
445 : : }
446 : :
447 : 0 : txq->tx_count = nb_desc * NFD3_TX_DESC_PER_PKT;
448 : 0 : txq->tx_free_thresh = tx_free_thresh;
449 : :
450 : : /* Queue mapping based on firmware configuration */
451 : 0 : txq->qidx = queue_idx;
452 : 0 : txq->tx_qcidx = queue_idx * hw->stride_tx;
453 : 0 : txq->qcp_q = hw->tx_bar + NFP_QCP_QUEUE_OFF(txq->tx_qcidx);
454 : 0 : txq->port_id = dev->data->port_id;
455 : :
456 : : /* Saving physical and virtual addresses for the TX ring */
457 : 0 : txq->dma = tz->iova;
458 : 0 : txq->txds = tz->addr;
459 : :
460 : : /* Mbuf pointers array for referencing mbufs linked to TX descriptors */
461 : 0 : txq->txbufs = rte_zmalloc_socket("txq->txbufs",
462 : 0 : sizeof(*txq->txbufs) * txq->tx_count,
463 : : RTE_CACHE_LINE_SIZE, socket_id);
464 [ # # ]: 0 : if (txq->txbufs == NULL) {
465 : 0 : nfp_net_tx_queue_release(dev, queue_idx);
466 : 0 : dev->data->tx_queues[queue_idx] = NULL;
467 : 0 : return -ENOMEM;
468 : : }
469 : :
470 : 0 : nfp_net_reset_tx_queue(txq);
471 : :
472 : 0 : txq->hw = hw;
473 : :
474 : : /*
475 : : * Telling the HW about the physical address of the TX ring and number
476 : : * of descriptors in log2 format.
477 : : */
478 : 0 : nn_cfg_writeq(&hw->super, NFP_NET_CFG_TXR_ADDR(queue_idx), txq->dma);
479 [ # # ]: 0 : nn_cfg_writeb(&hw->super, NFP_NET_CFG_TXR_SZ(queue_idx), rte_log2_u32(txq->tx_count));
480 : :
481 : 0 : return 0;
482 : : }
|