drivers/net/ethernet/intel/ice/ice_txrx_lib.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /* Copyright (c) 2019, Intel Corporation. */
   3
   4 #ifndef _ICE_TXRX_LIB_H_
   5 #define _ICE_TXRX_LIB_H_
   6 #include "ice.h"
   7
   8 /**
   9  * ice_set_rx_bufs_act - propagate Rx buffer action to frags
  10  * @xdp: XDP buffer representing frame (linear and frags part)
  11  * @rx_ring: Rx ring struct
  12  * act: action to store onto Rx buffers related to XDP buffer parts
  13  *
  14  * Set action that should be taken before putting Rx buffer from first frag
  15  * to the last.
  16  */
  17 static inline void
  18 ice_set_rx_bufs_act(struct xdp_buff *xdp, const struct ice_rx_ring *rx_ring,
  19                     const unsigned int act)
  20 {
  21         u32 sinfo_frags = xdp_get_shared_info_from_buff(xdp)->nr_frags;
  22         u32 nr_frags = rx_ring->nr_frags + 1;
  23         u32 idx = rx_ring->first_desc;
  24         u32 cnt = rx_ring->count;
  25         struct ice_rx_buf *buf;
  26
  27         for (int i = 0; i < nr_frags; i++) {
  28                 buf = &rx_ring->rx_buf[idx];
  29                 buf->act = act;
  30
  31                 if (++idx == cnt)
  32                         idx = 0;
  33         }
  34
  35         /* adjust pagecnt_bias on frags freed by XDP prog */
  36         if (sinfo_frags < rx_ring->nr_frags && act == ICE_XDP_CONSUMED) {
  37                 u32 delta = rx_ring->nr_frags - sinfo_frags;
  38
  39                 while (delta) {
  40                         if (idx == 0)
  41                                 idx = cnt - 1;
  42                         else
  43                                 idx--;
  44                         buf = &rx_ring->rx_buf[idx];
  45                         buf->pagecnt_bias--;
  46                         delta--;
  47                 }
  48         }
  49 }
  50
  51 /**
  52  * ice_test_staterr - tests bits in Rx descriptor status and error fields
  53  * @status_err_n: Rx descriptor status_error0 or status_error1 bits
  54  * @stat_err_bits: value to mask
  55  *
  56  * This function does some fast chicanery in order to return the
  57  * value of the mask which is really only used for boolean tests.
  58  * The status_error_len doesn't need to be shifted because it begins
  59  * at offset zero.
  60  */
  61 static inline bool
  62 ice_test_staterr(__le16 status_err_n, const u16 stat_err_bits)
  63 {
  64         return !!(status_err_n & cpu_to_le16(stat_err_bits));
  65 }
  66
  67 /**
  68  * ice_is_non_eop - process handling of non-EOP buffers
  69  * @rx_ring: Rx ring being processed
  70  * @rx_desc: Rx descriptor for current buffer
  71  *
  72  * If the buffer is an EOP buffer, this function exits returning false,
  73  * otherwise return true indicating that this is in fact a non-EOP buffer.
  74  */
  75 static inline bool
  76 ice_is_non_eop(const struct ice_rx_ring *rx_ring,
  77                const union ice_32b_rx_flex_desc *rx_desc)
  78 {
  79         /* if we are the last buffer then there is nothing else to do */
  80 #define ICE_RXD_EOF BIT(ICE_RX_FLEX_DESC_STATUS0_EOF_S)
  81         if (likely(ice_test_staterr(rx_desc->wb.status_error0, ICE_RXD_EOF)))
  82                 return false;
  83
  84         rx_ring->ring_stats->rx_stats.non_eop_descs++;
  85
  86         return true;
  87 }
  88
  89 static inline __le64
  90 ice_build_ctob(u64 td_cmd, u64 td_offset, unsigned int size, u64 td_tag)
  91 {
  92         return cpu_to_le64(ICE_TX_DESC_DTYPE_DATA |
  93                            (td_cmd    << ICE_TXD_QW1_CMD_S) |
  94                            (td_offset << ICE_TXD_QW1_OFFSET_S) |
  95                            ((u64)size << ICE_TXD_QW1_TX_BUF_SZ_S) |
  96                            (td_tag    << ICE_TXD_QW1_L2TAG1_S));
  97 }
  98
  99 /**
 100  * ice_get_vlan_tci - get VLAN TCI from Rx flex descriptor
 101  * @rx_desc: Rx 32b flex descriptor with RXDID=2
 102  *
 103  * The OS and current PF implementation only support stripping a single VLAN tag
 104  * at a time, so there should only ever be 0 or 1 tags in the l2tag* fields. If
 105  * one is found return the tag, else return 0 to mean no VLAN tag was found.
 106  */
 107 static inline u16
 108 ice_get_vlan_tci(const union ice_32b_rx_flex_desc *rx_desc)
 109 {
 110         u16 stat_err_bits;
 111
 112         stat_err_bits = BIT(ICE_RX_FLEX_DESC_STATUS0_L2TAG1P_S);
 113         if (ice_test_staterr(rx_desc->wb.status_error0, stat_err_bits))
 114                 return le16_to_cpu(rx_desc->wb.l2tag1);
 115
 116         stat_err_bits = BIT(ICE_RX_FLEX_DESC_STATUS1_L2TAG2P_S);
 117         if (ice_test_staterr(rx_desc->wb.status_error1, stat_err_bits))
 118                 return le16_to_cpu(rx_desc->wb.l2tag2_2nd);
 119
 120         return 0;
 121 }
 122
 123 /**
 124  * ice_xdp_ring_update_tail - Updates the XDP Tx ring tail register
 125  * @xdp_ring: XDP Tx ring
 126  *
 127  * This function updates the XDP Tx ring tail register.
 128  */
 129 static inline void ice_xdp_ring_update_tail(struct ice_tx_ring *xdp_ring)
 130 {
 131         /* Force memory writes to complete before letting h/w
 132          * know there are new descriptors to fetch.
 133          */
 134         wmb();
 135         writel_relaxed(xdp_ring->next_to_use, xdp_ring->tail);
 136 }
 137
 138 /**
 139  * ice_set_rs_bit - set RS bit on last produced descriptor (one behind current NTU)
 140  * @xdp_ring: XDP ring to produce the HW Tx descriptors on
 141  *
 142  * returns index of descriptor that had RS bit produced on
 143  */
 144 static inline u32 ice_set_rs_bit(const struct ice_tx_ring *xdp_ring)
 145 {
 146         u32 rs_idx = xdp_ring->next_to_use ? xdp_ring->next_to_use - 1 : xdp_ring->count - 1;
 147         struct ice_tx_desc *tx_desc;
 148
 149         tx_desc = ICE_TX_DESC(xdp_ring, rs_idx);
 150         tx_desc->cmd_type_offset_bsz |=
 151                 cpu_to_le64(ICE_TX_DESC_CMD_RS << ICE_TXD_QW1_CMD_S);
 152
 153         return rs_idx;
 154 }
 155
 156 void ice_finalize_xdp_rx(struct ice_tx_ring *xdp_ring, unsigned int xdp_res, u32 first_idx);
 157 int ice_xmit_xdp_buff(struct xdp_buff *xdp, struct ice_tx_ring *xdp_ring);
 158 int __ice_xmit_xdp_ring(struct xdp_buff *xdp, struct ice_tx_ring *xdp_ring,
 159                         bool frame);
 160 void ice_release_rx_desc(struct ice_rx_ring *rx_ring, u16 val);
 161 void
 162 ice_process_skb_fields(struct ice_rx_ring *rx_ring,
 163                        union ice_32b_rx_flex_desc *rx_desc,
 164                        struct sk_buff *skb);
 165 void
 166 ice_receive_skb(struct ice_rx_ring *rx_ring, struct sk_buff *skb, u16 vlan_tci);
 167
 168 static inline void
 169 ice_xdp_meta_set_desc(struct xdp_buff *xdp,
 170                       union ice_32b_rx_flex_desc *eop_desc)
 171 {
 172         struct ice_xdp_buff *xdp_ext = container_of(xdp, struct ice_xdp_buff,
 173                                                     xdp_buff);
 174
 175         xdp_ext->eop_desc = eop_desc;
 176 }
 177 #endif /* !_ICE_TXRX_LIB_H_ */