ethdev: promote sibling iterators to stable

[dpdk.git] / drivers / net / ark / ark_ethdev_rx.c

diff --git a/drivers/net/ark/ark_ethdev_rx.c b/drivers/net/ark/ark_ethdev_rx.c
index c24cc00..d255f01 100644 (file)
--- a/drivers/net/ark/ark_ethdev_rx.c
+++ b/drivers/net/ark/ark_ethdev_rx.c
@@ -4,7 +4,6 @@
 
 #include <unistd.h>
 
-#include "rte_pmd_ark.h"
 #include "ark_ethdev_rx.h"
 #include "ark_global.h"
 #include "ark_logs.h"
@@ -26,9 +25,6 @@ static uint32_t eth_ark_rx_jumbo(struct ark_rx_queue *queue,
                                 struct rte_mbuf *mbuf0,
                                 uint32_t cons_index);
 static inline int eth_ark_rx_seed_mbufs(struct ark_rx_queue *queue);
-static int eth_ark_rx_seed_recovery(struct ark_rx_queue *queue,
-                                   uint32_t *pnb,
-                                   struct rte_mbuf **mbufs);
 
 /* ************************************************************************* */
 struct ark_rx_queue {
@@ -42,6 +38,9 @@ struct ark_rx_queue {
        struct ark_udm_t *udm;
        struct ark_mpu_t *mpu;
 
+       rx_user_meta_hook_fn rx_user_meta_hook;
+       void *ext_user_data;
+
        uint32_t queue_size;
        uint32_t queue_mask;
 
@@ -54,16 +53,14 @@ struct ark_rx_queue {
        /* The queue Index is used within the dpdk device structures */
        uint16_t queue_index;
 
-       uint32_t last_cons;
+       uint32_t unused;
 
-       /* separate cache line */
-       /* second cache line - fields only used in slow path */
+       /* next cache line - fields written by device */
        RTE_MARKER cacheline1 __rte_cache_min_aligned;
 
        volatile uint32_t prod_index;   /* step 2 filled by FPGA */
 } __rte_cache_aligned;
 
-
 /* ************************************************************************* */
 static int
 eth_ark_rx_hw_setup(struct rte_eth_dev *dev,
@@ -105,9 +102,8 @@ static inline void
 eth_ark_rx_update_cons_index(struct ark_rx_queue *queue, uint32_t cons_index)
 {
        queue->cons_index = cons_index;
-       eth_ark_rx_seed_mbufs(queue);
-       if (((cons_index - queue->last_cons) >= 64U)) {
-               queue->last_cons = cons_index;
+       if ((cons_index + queue->queue_size - queue->seed_index) >= 64U) {
+               eth_ark_rx_seed_mbufs(queue);
                ark_mpu_set_producer(queue->mpu, queue->seed_index);
        }
 }
@@ -172,6 +168,8 @@ eth_ark_dev_rx_queue_setup(struct rte_eth_dev *dev,
        queue->queue_index = queue_idx;
        queue->queue_size = nb_desc;
        queue->queue_mask = nb_desc - 1;
+       queue->rx_user_meta_hook = ark->user_ext.rx_user_meta_hook;
+       queue->ext_user_data = ark->user_data[dev->data->port_id];
 
        queue->reserve_q =
                rte_zmalloc_socket("Ark_rx_queue mbuf",
@@ -248,8 +246,11 @@ eth_ark_recv_pkts(void *rx_queue,
        struct ark_rx_queue *queue;
        register uint32_t cons_index, prod_index;
        uint16_t nb;
+       uint16_t i;
        struct rte_mbuf *mbuf;
+       struct rte_mbuf **pmbuf;
        struct ark_rx_meta *meta;
+       rx_user_meta_hook_fn rx_user_meta_hook;
 
        queue = (struct ark_rx_queue *)rx_queue;
        if (unlikely(queue == 0))
@@ -258,6 +259,8 @@ eth_ark_recv_pkts(void *rx_queue,
                return 0;
        prod_index = queue->prod_index;
        cons_index = queue->cons_index;
+       if (prod_index == cons_index)
+               return 0;
        nb = 0;
 
        while (prod_index != cons_index) {
@@ -269,11 +272,8 @@ eth_ark_recv_pkts(void *rx_queue,
                /* META DATA embedded in headroom */
                meta = RTE_PTR_ADD(mbuf->buf_addr, ARK_RX_META_OFFSET);
 
-               mbuf->port = meta->port;
                mbuf->pkt_len = meta->pkt_len;
                mbuf->data_len = meta->pkt_len;
-               mbuf->timestamp = meta->timestamp;
-               rte_pmd_ark_mbuf_rx_userdata_set(mbuf, meta->user_data);
 
                if (ARK_DEBUG_CORE) {   /* debug sanity checks */
                        if ((meta->pkt_len > (1024 * 16)) ||
@@ -316,9 +316,14 @@ eth_ark_recv_pkts(void *rx_queue,
                        break;
        }
 
-       if (unlikely(nb != 0))
-               /* report next free to FPGA */
-               eth_ark_rx_update_cons_index(queue, cons_index);
+       rx_user_meta_hook = queue->rx_user_meta_hook;
+       for (pmbuf = rx_pkts, i = 0; rx_user_meta_hook && i < nb; i++) {
+               mbuf = *pmbuf++;
+               meta = RTE_PTR_ADD(mbuf->buf_addr, ARK_RX_META_OFFSET);
+               rx_user_meta_hook(mbuf, meta->user_meta, queue->ext_user_data);
+       }
+
+       eth_ark_rx_update_cons_index(queue, cons_index);
 
        return nb;
 }
@@ -347,8 +352,7 @@ eth_ark_rx_jumbo(struct ark_rx_queue *queue,
        /* HW guarantees that the data does not exceed prod_index! */
        while (remaining != 0) {
                data_len = RTE_MIN(remaining,
-                                  RTE_MBUF_DEFAULT_DATAROOM +
-                                  RTE_PKTMBUF_HEADROOM);
+                                  RTE_MBUF_DEFAULT_DATAROOM);
 
                remaining -= data_len;
                segments += 1;
@@ -357,7 +361,6 @@ eth_ark_rx_jumbo(struct ark_rx_queue *queue,
                mbuf_prev->next = mbuf;
                mbuf_prev = mbuf;
                mbuf->data_len = data_len;
-               mbuf->data_off = 0;
 
                cons_index += 1;
        }
@@ -453,11 +456,13 @@ eth_ark_rx_seed_mbufs(struct ark_rx_queue *queue)
        int status = rte_pktmbuf_alloc_bulk(queue->mb_pool, mbufs, nb);
 
        if (unlikely(status != 0)) {
-               /* Try to recover from lack of mbufs in pool */
-               status = eth_ark_rx_seed_recovery(queue, &nb, mbufs);
-               if (unlikely(status != 0)) {
-                       return -1;
-               }
+               ARK_PMD_LOG(NOTICE,
+                           "Could not allocate %u mbufs from pool"
+                           " for RX queue %u;"
+                           " %u free buffers remaining in queue\n",
+                           nb, queue->queue_index,
+                           queue->seed_index - queue->cons_index);
+               return -1;
        }
 
        if (ARK_DEBUG_CORE) {           /* DEBUG */
@@ -506,29 +511,6 @@ eth_ark_rx_seed_mbufs(struct ark_rx_queue *queue)
        return 0;
 }
 
-int
-eth_ark_rx_seed_recovery(struct ark_rx_queue *queue,
-                        uint32_t *pnb,
-                        struct rte_mbuf **mbufs)
-{
-       int status = -1;
-
-       /* Ignore small allocation failures */
-       if (*pnb <= 64)
-               return -1;
-
-       *pnb = 64U;
-       status = rte_pktmbuf_alloc_bulk(queue->mb_pool, mbufs, *pnb);
-       if (status != 0) {
-               ARK_PMD_LOG(NOTICE,
-                           "ARK: Could not allocate %u mbufs from pool for RX queue %u;"
-                           " %u free buffers remaining in queue\n",
-                           *pnb, queue->queue_index,
-                           queue->seed_index - queue->cons_index);
-       }
-       return status;
-}
-
 void
 eth_ark_rx_dump_queue(struct rte_eth_dev *dev, uint16_t queue_id,
                      const char *msg)