net/ice/base: use package info from ice segment metadata

[dpdk.git] / drivers / net / dpaa2 / dpaa2_rxtx.c

diff --git a/drivers/net/dpaa2/dpaa2_rxtx.c b/drivers/net/dpaa2/dpaa2_rxtx.c
index 86cb952..9cca6d1 100644 (file)
--- a/drivers/net/dpaa2/dpaa2_rxtx.c
+++ b/drivers/net/dpaa2/dpaa2_rxtx.c
@@ -31,6 +31,13 @@ dpaa2_dev_rx_parse_slow(struct rte_mbuf *mbuf,
 
 static void enable_tx_tstamp(struct qbman_fd *fd) __rte_unused;
 
+static inline rte_mbuf_timestamp_t *
+dpaa2_timestamp_dynfield(struct rte_mbuf *mbuf)
+{
+       return RTE_MBUF_DYNFIELD(mbuf,
+               dpaa2_timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
 #define DPAA2_MBUF_TO_CONTIG_FD(_mbuf, _fd, _bpid)  do { \
        DPAA2_SET_FD_ADDR(_fd, DPAA2_MBUF_VADDR_TO_IOVA(_mbuf)); \
        DPAA2_SET_FD_LEN(_fd, _mbuf->data_len); \
@@ -108,10 +115,11 @@ dpaa2_dev_rx_parse_new(struct rte_mbuf *m, const struct qbman_fd *fd,
        m->hash.rss = fd->simple.flc_hi;
        m->ol_flags |= PKT_RX_RSS_HASH;
 
-       if (dpaa2_enable_ts) {
-               m->timestamp = annotation->word2;
-               m->ol_flags |= PKT_RX_TIMESTAMP;
-               DPAA2_PMD_DP_DEBUG("pkt timestamp:0x%" PRIx64 "", m->timestamp);
+       if (dpaa2_enable_ts[m->port]) {
+               *dpaa2_timestamp_dynfield(m) = annotation->word2;
+               m->ol_flags |= dpaa2_timestamp_rx_dynflag;
+               DPAA2_PMD_DP_DEBUG("pkt timestamp:0x%" PRIx64 "",
+                               *dpaa2_timestamp_dynfield(m));
        }
 
        DPAA2_PMD_DP_DEBUG("HW frc = 0x%x\t packet type =0x%x "
@@ -223,9 +231,12 @@ dpaa2_dev_rx_parse(struct rte_mbuf *mbuf, void *hw_annot_addr)
        else if (BIT_ISSET_AT_POS(annotation->word8, DPAA2_ETH_FAS_L4CE))
                mbuf->ol_flags |= PKT_RX_L4_CKSUM_BAD;
 
-       mbuf->ol_flags |= PKT_RX_TIMESTAMP;
-       mbuf->timestamp = annotation->word2;
-       DPAA2_PMD_DP_DEBUG("pkt timestamp: 0x%" PRIx64 "", mbuf->timestamp);
+       if (dpaa2_enable_ts[mbuf->port]) {
+               *dpaa2_timestamp_dynfield(mbuf) = annotation->word2;
+               mbuf->ol_flags |= dpaa2_timestamp_rx_dynflag;
+               DPAA2_PMD_DP_DEBUG("pkt timestamp: 0x%" PRIx64 "",
+                               *dpaa2_timestamp_dynfield(mbuf));
+       }
 
        /* Check detailed parsing requirement */
        if (annotation->word3 & 0x7FFFFC3FFFF)
@@ -629,7 +640,7 @@ dpaa2_dev_prefetch_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
                else
                        bufs[num_rx] = eth_fd_to_mbuf(fd, eth_data->port_id);
 #if defined(RTE_LIBRTE_IEEE1588)
-               priv->rx_timestamp = bufs[num_rx]->timestamp;
+               priv->rx_timestamp = *dpaa2_timestamp_dynfield(bufs[num_rx]);
 #endif
 
                if (eth_data->dev_conf.rxmode.offloads &
@@ -710,7 +721,7 @@ dpaa2_dev_process_atomic_event(struct qbman_swp *swp __rte_unused,
        ev->mbuf = eth_fd_to_mbuf(fd, rxq->eth_data->port_id);
 
        dqrr_index = qbman_get_dqrr_idx(dq);
-       ev->mbuf->seqn = dqrr_index + 1;
+       *dpaa2_seqn(ev->mbuf) = dqrr_index + 1;
        DPAA2_PER_LCORE_DQRR_SIZE++;
        DPAA2_PER_LCORE_DQRR_HELD |= 1 << dqrr_index;
        DPAA2_PER_LCORE_DQRR_MBUF(dqrr_index) = ev->mbuf;
@@ -736,9 +747,9 @@ dpaa2_dev_process_ordered_event(struct qbman_swp *swp,
 
        ev->mbuf = eth_fd_to_mbuf(fd, rxq->eth_data->port_id);
 
-       ev->mbuf->seqn = DPAA2_ENQUEUE_FLAG_ORP;
-       ev->mbuf->seqn |= qbman_result_DQ_odpid(dq) << DPAA2_EQCR_OPRID_SHIFT;
-       ev->mbuf->seqn |= qbman_result_DQ_seqnum(dq) << DPAA2_EQCR_SEQNUM_SHIFT;
+       *dpaa2_seqn(ev->mbuf) = DPAA2_ENQUEUE_FLAG_ORP;
+       *dpaa2_seqn(ev->mbuf) |= qbman_result_DQ_odpid(dq) << DPAA2_EQCR_OPRID_SHIFT;
+       *dpaa2_seqn(ev->mbuf) |= qbman_result_DQ_seqnum(dq) << DPAA2_EQCR_SEQNUM_SHIFT;
 
        qbman_swp_dqrr_consume(swp, dq);
 }
@@ -1063,14 +1074,14 @@ dpaa2_dev_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
                        dpaa2_eqcr_size : nb_pkts;
 
                for (loop = 0; loop < frames_to_send; loop++) {
-                       if ((*bufs)->seqn) {
-                               uint8_t dqrr_index = (*bufs)->seqn - 1;
+                       if (*dpaa2_seqn(*bufs)) {
+                               uint8_t dqrr_index = *dpaa2_seqn(*bufs) - 1;
 
                                flags[loop] = QBMAN_ENQUEUE_FLAG_DCA |
                                                dqrr_index;
                                DPAA2_PER_LCORE_DQRR_SIZE--;
                                DPAA2_PER_LCORE_DQRR_HELD &= ~(1 << dqrr_index);
-                               (*bufs)->seqn = DPAA2_INVALID_MBUF_SEQN;
+                               *dpaa2_seqn(*bufs) = DPAA2_INVALID_MBUF_SEQN;
                        }
 
                        if (likely(RTE_MBUF_DIRECT(*bufs))) {
@@ -1230,10 +1241,10 @@ dpaa2_set_enqueue_descriptor(struct dpaa2_queue *dpaa2_q,
 
        qbman_eq_desc_set_fq(eqdesc, dpaa2_q->fqid);
 
-       if (m->seqn & DPAA2_ENQUEUE_FLAG_ORP) {
-               orpid = (m->seqn & DPAA2_EQCR_OPRID_MASK) >>
+       if (*dpaa2_seqn(m) & DPAA2_ENQUEUE_FLAG_ORP) {
+               orpid = (*dpaa2_seqn(m) & DPAA2_EQCR_OPRID_MASK) >>
                        DPAA2_EQCR_OPRID_SHIFT;
-               seqnum = (m->seqn & DPAA2_EQCR_SEQNUM_MASK) >>
+               seqnum = (*dpaa2_seqn(m) & DPAA2_EQCR_SEQNUM_MASK) >>
                        DPAA2_EQCR_SEQNUM_SHIFT;
 
                if (!priv->en_loose_ordered) {
@@ -1255,12 +1266,12 @@ dpaa2_set_enqueue_descriptor(struct dpaa2_queue *dpaa2_q,
                        qbman_eq_desc_set_orp(eqdesc, 0, orpid, seqnum, 0);
                }
        } else {
-               dq_idx = m->seqn - 1;
+               dq_idx = *dpaa2_seqn(m) - 1;
                qbman_eq_desc_set_dca(eqdesc, 1, dq_idx, 0);
                DPAA2_PER_LCORE_DQRR_SIZE--;
                DPAA2_PER_LCORE_DQRR_HELD &= ~(1 << dq_idx);
        }
-       m->seqn = DPAA2_INVALID_MBUF_SEQN;
+       *dpaa2_seqn(m) = DPAA2_INVALID_MBUF_SEQN;
 }
 
 /* Callback to handle sending ordered packets through WRIOP based interface */
@@ -1314,7 +1325,7 @@ dpaa2_dev_tx_ordered(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
                        dpaa2_eqcr_size : nb_pkts;
 
                if (!priv->en_loose_ordered) {
-                       if ((*bufs)->seqn & DPAA2_ENQUEUE_FLAG_ORP) {
+                       if (*dpaa2_seqn(*bufs) & DPAA2_ENQUEUE_FLAG_ORP) {
                                num_free_eq_desc = dpaa2_free_eq_descriptors();
                                if (num_free_eq_desc < frames_to_send)
                                        frames_to_send = num_free_eq_desc;
@@ -1325,7 +1336,7 @@ dpaa2_dev_tx_ordered(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
                        /*Prepare enqueue descriptor*/
                        qbman_eq_desc_clear(&eqdesc[loop]);
 
-                       if ((*bufs)->seqn) {
+                       if (*dpaa2_seqn(*bufs)) {
                                /* Use only queue 0 for Tx in case of atomic/
                                 * ordered packets as packets can get unordered
                                 * when being tranmitted out from the interface