common/cnxk: use computed value for WQE skip

[dpdk.git] / drivers / net / mlx5 / mlx5_rx.c

diff --git a/drivers/net/mlx5/mlx5_rx.c b/drivers/net/mlx5/mlx5_rx.c
index e8215f7..e5eea0a 100644 (file)
--- a/drivers/net/mlx5/mlx5_rx.c
+++ b/drivers/net/mlx5/mlx5_rx.c
@@ -73,7 +73,7 @@ rx_queue_count(struct mlx5_rxq_data *rxq)
        const unsigned int cqe_n = (1 << rxq->cqe_n);
        const unsigned int sges_n = (1 << rxq->sges_n);
        const unsigned int elts_n = (1 << rxq->elts_n);
-       const unsigned int strd_n = (1 << rxq->strd_num_n);
+       const unsigned int strd_n = RTE_BIT32(rxq->log_strd_num);
        const unsigned int cqe_cnt = cqe_n - 1;
        unsigned int cq_ci, used;
 
@@ -167,8 +167,8 @@ mlx5_rxq_info_get(struct rte_eth_dev *dev, uint16_t rx_queue_id,
        qinfo->conf.offloads = dev->data->dev_conf.rxmode.offloads;
        qinfo->scattered_rx = dev->data->scattered_rx;
        qinfo->nb_desc = mlx5_rxq_mprq_enabled(rxq) ?
-               (1 << rxq->elts_n) * (1 << rxq->strd_num_n) :
-               (1 << rxq->elts_n);
+               RTE_BIT32(rxq->elts_n) * RTE_BIT32(rxq->log_strd_num) :
+               RTE_BIT32(rxq->elts_n);
 }
 
 /**
@@ -178,7 +178,7 @@ mlx5_rxq_info_get(struct rte_eth_dev *dev, uint16_t rx_queue_id,
  *   Pointer to the device structure.
  *
  * @param rx_queue_id
- *   Rx queue identificatior.
+ *   Rx queue identification.
  *
  * @param mode
  *   Pointer to the burts mode information.
@@ -252,7 +252,7 @@ mlx5_rx_queue_count(void *rx_queue)
        dev = &rte_eth_devices[rxq->port_id];
 
        if (dev->rx_pkt_burst == NULL ||
-           dev->rx_pkt_burst == removed_rx_burst) {
+           dev->rx_pkt_burst == rte_eth_pkt_burst_dummy) {
                rte_errno = ENOTSUP;
                return -rte_errno;
        }
@@ -354,10 +354,10 @@ mlx5_rxq_initialize(struct mlx5_rxq_data *rxq)
 
                        scat = &((volatile struct mlx5_wqe_mprq *)
                                rxq->wqes)[i].dseg;
-                       addr = (uintptr_t)mlx5_mprq_buf_addr(buf,
-                                                        1 << rxq->strd_num_n);
-                       byte_count = (1 << rxq->strd_sz_n) *
-                                       (1 << rxq->strd_num_n);
+                       addr = (uintptr_t)mlx5_mprq_buf_addr
+                                       (buf, RTE_BIT32(rxq->log_strd_num));
+                       byte_count = RTE_BIT32(rxq->log_strd_sz) *
+                                    RTE_BIT32(rxq->log_strd_num);
                        lkey = mlx5_rx_addr2mr(rxq, addr);
                } else {
                        struct rte_mbuf *buf = (*rxq->elts)[i];
@@ -383,7 +383,7 @@ mlx5_rxq_initialize(struct mlx5_rxq_data *rxq)
                .ai = 0,
        };
        rxq->elts_ci = mlx5_rxq_mprq_enabled(rxq) ?
-               (wqe_n >> rxq->sges_n) * (1 << rxq->strd_num_n) : 0;
+               (wqe_n >> rxq->sges_n) * RTE_BIT32(rxq->log_strd_num) : 0;
        /* Update doorbell counter. */
        rxq->rq_ci = wqe_n >> rxq->sges_n;
        rte_io_wmb();
@@ -412,7 +412,7 @@ mlx5_rx_err_handle(struct mlx5_rxq_data *rxq, uint8_t vec)
        const uint16_t cqe_n = 1 << rxq->cqe_n;
        const uint16_t cqe_mask = cqe_n - 1;
        const uint16_t wqe_n = 1 << rxq->elts_n;
-       const uint16_t strd_n = 1 << rxq->strd_num_n;
+       const uint16_t strd_n = RTE_BIT32(rxq->log_strd_num);
        struct mlx5_rxq_ctrl *rxq_ctrl =
                        container_of(rxq, struct mlx5_rxq_ctrl, rxq);
        union {
@@ -1045,8 +1045,8 @@ uint16_t
 mlx5_rx_burst_mprq(void *dpdk_rxq, struct rte_mbuf **pkts, uint16_t pkts_n)
 {
        struct mlx5_rxq_data *rxq = dpdk_rxq;
-       const uint32_t strd_n = 1 << rxq->strd_num_n;
-       const uint32_t strd_sz = 1 << rxq->strd_sz_n;
+       const uint32_t strd_n = RTE_BIT32(rxq->log_strd_num);
+       const uint32_t strd_sz = RTE_BIT32(rxq->log_strd_sz);
        const uint32_t cq_mask = (1 << rxq->cqe_n) - 1;
        const uint32_t wq_mask = (1 << rxq->elts_n) - 1;
        volatile struct mlx5_cqe *cqe = &(*rxq->cqes)[rxq->cq_ci & cq_mask];
@@ -1153,31 +1153,6 @@ mlx5_rx_burst_mprq(void *dpdk_rxq, struct rte_mbuf **pkts, uint16_t pkts_n)
        return i;
 }
 
-/**
- * Dummy DPDK callback for RX.
- *
- * This function is used to temporarily replace the real callback during
- * unsafe control operations on the queue, or in case of error.
- *
- * @param dpdk_rxq
- *   Generic pointer to RX queue structure.
- * @param[out] pkts
- *   Array to store received packets.
- * @param pkts_n
- *   Maximum number of packets in array.
- *
- * @return
- *   Number of packets successfully received (<= pkts_n).
- */
-uint16_t
-removed_rx_burst(void *dpdk_rxq __rte_unused,
-                struct rte_mbuf **pkts __rte_unused,
-                uint16_t pkts_n __rte_unused)
-{
-       rte_mb();
-       return 0;
-}
-
 /*
  * Vectorized Rx routines are not compiled in when required vector instructions
  * are not supported on a target architecture.
@@ -1212,4 +1187,3 @@ mlx5_check_vec_rx_support(struct rte_eth_dev *dev __rte_unused)
 {
        return -ENOTSUP;
 }
-