drivers/net/igc/igc_txrx.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2020 Intel Corporation
   3  */
   4
   5 #include <rte_config.h>
   6 #include <rte_malloc.h>
   7 #include <rte_ethdev_driver.h>
   8 #include <rte_net.h>
   9
  10 #include "igc_logs.h"
  11 #include "igc_txrx.h"
  12
  13 #ifdef RTE_PMD_USE_PREFETCH
  14 #define rte_igc_prefetch(p)             rte_prefetch0(p)
  15 #else
  16 #define rte_igc_prefetch(p)             do {} while (0)
  17 #endif
  18
  19 #ifdef RTE_PMD_PACKET_PREFETCH
  20 #define rte_packet_prefetch(p)          rte_prefetch1(p)
  21 #else
  22 #define rte_packet_prefetch(p)          do {} while (0)
  23 #endif
  24
  25 /* Multicast / Unicast table offset mask. */
  26 #define IGC_RCTL_MO_MSK                 (3u << IGC_RCTL_MO_SHIFT)
  27
  28 /* Loopback mode. */
  29 #define IGC_RCTL_LBM_SHIFT              6
  30 #define IGC_RCTL_LBM_MSK                (3u << IGC_RCTL_LBM_SHIFT)
  31
  32 /* Hash select for MTA */
  33 #define IGC_RCTL_HSEL_SHIFT             8
  34 #define IGC_RCTL_HSEL_MSK               (3u << IGC_RCTL_HSEL_SHIFT)
  35 #define IGC_RCTL_PSP                    (1u << 21)
  36
  37 /* Receive buffer size for header buffer */
  38 #define IGC_SRRCTL_BSIZEHEADER_SHIFT    8
  39
  40 /* RX descriptor status and error flags */
  41 #define IGC_RXD_STAT_L4CS               (1u << 5)
  42 #define IGC_RXD_STAT_VEXT               (1u << 9)
  43 #define IGC_RXD_STAT_LLINT              (1u << 11)
  44 #define IGC_RXD_STAT_SCRC               (1u << 12)
  45 #define IGC_RXD_STAT_SMDT_MASK          (3u << 13)
  46 #define IGC_RXD_STAT_MC                 (1u << 19)
  47 #define IGC_RXD_EXT_ERR_L4E             (1u << 29)
  48 #define IGC_RXD_EXT_ERR_IPE             (1u << 30)
  49 #define IGC_RXD_EXT_ERR_RXE             (1u << 31)
  50 #define IGC_RXD_RSS_TYPE_MASK           0xfu
  51 #define IGC_RXD_PCTYPE_MASK             (0x7fu << 4)
  52 #define IGC_RXD_ETQF_SHIFT              12
  53 #define IGC_RXD_ETQF_MSK                (0xfu << IGC_RXD_ETQF_SHIFT)
  54 #define IGC_RXD_VPKT                    (1u << 16)
  55
  56 /* TXD control bits */
  57 #define IGC_TXDCTL_PTHRESH_SHIFT        0
  58 #define IGC_TXDCTL_HTHRESH_SHIFT        8
  59 #define IGC_TXDCTL_WTHRESH_SHIFT        16
  60 #define IGC_TXDCTL_PTHRESH_MSK          (0x1fu << IGC_TXDCTL_PTHRESH_SHIFT)
  61 #define IGC_TXDCTL_HTHRESH_MSK          (0x1fu << IGC_TXDCTL_HTHRESH_SHIFT)
  62 #define IGC_TXDCTL_WTHRESH_MSK          (0x1fu << IGC_TXDCTL_WTHRESH_SHIFT)
  63
  64 /* RXD control bits */
  65 #define IGC_RXDCTL_PTHRESH_SHIFT        0
  66 #define IGC_RXDCTL_HTHRESH_SHIFT        8
  67 #define IGC_RXDCTL_WTHRESH_SHIFT        16
  68 #define IGC_RXDCTL_PTHRESH_MSK          (0x1fu << IGC_RXDCTL_PTHRESH_SHIFT)
  69 #define IGC_RXDCTL_HTHRESH_MSK          (0x1fu << IGC_RXDCTL_HTHRESH_SHIFT)
  70 #define IGC_RXDCTL_WTHRESH_MSK          (0x1fu << IGC_RXDCTL_WTHRESH_SHIFT)
  71
  72 #define IGC_TSO_MAX_HDRLEN              512
  73 #define IGC_TSO_MAX_MSS                 9216
  74
  75 /* Bit Mask to indicate what bits required for building TX context */
  76 #define IGC_TX_OFFLOAD_MASK (           \
  77                 PKT_TX_OUTER_IPV4 |     \
  78                 PKT_TX_IPV6 |           \
  79                 PKT_TX_IPV4 |           \
  80                 PKT_TX_VLAN_PKT |       \
  81                 PKT_TX_IP_CKSUM |       \
  82                 PKT_TX_L4_MASK |        \
  83                 PKT_TX_TCP_SEG |        \
  84                 PKT_TX_UDP_SEG)
  85
  86 #define IGC_TX_OFFLOAD_SEG      (PKT_TX_TCP_SEG | PKT_TX_UDP_SEG)
  87
  88 #define IGC_ADVTXD_POPTS_TXSM   0x00000200 /* L4 Checksum offload request */
  89 #define IGC_ADVTXD_POPTS_IXSM   0x00000100 /* IP Checksum offload request */
  90
  91 /* L4 Packet TYPE of Reserved */
  92 #define IGC_ADVTXD_TUCMD_L4T_RSV        0x00001800
  93
  94 #define IGC_TX_OFFLOAD_NOTSUP_MASK (PKT_TX_OFFLOAD_MASK ^ IGC_TX_OFFLOAD_MASK)
  95
  96 /**
  97  * Structure associated with each descriptor of the RX ring of a RX queue.
  98  */
  99 struct igc_rx_entry {
 100         struct rte_mbuf *mbuf; /**< mbuf associated with RX descriptor. */
 101 };
 102
 103 /**
 104  * Structure associated with each RX queue.
 105  */
 106 struct igc_rx_queue {
 107         struct rte_mempool  *mb_pool;   /**< mbuf pool to populate RX ring. */
 108         volatile union igc_adv_rx_desc *rx_ring;
 109         /**< RX ring virtual address. */
 110         uint64_t            rx_ring_phys_addr; /**< RX ring DMA address. */
 111         volatile uint32_t   *rdt_reg_addr; /**< RDT register address. */
 112         volatile uint32_t   *rdh_reg_addr; /**< RDH register address. */
 113         struct igc_rx_entry *sw_ring;   /**< address of RX software ring. */
 114         struct rte_mbuf *pkt_first_seg; /**< First segment of current packet. */
 115         struct rte_mbuf *pkt_last_seg;  /**< Last segment of current packet. */
 116         uint16_t            nb_rx_desc; /**< number of RX descriptors. */
 117         uint16_t            rx_tail;    /**< current value of RDT register. */
 118         uint16_t            nb_rx_hold; /**< number of held free RX desc. */
 119         uint16_t            rx_free_thresh; /**< max free RX desc to hold. */
 120         uint16_t            queue_id;   /**< RX queue index. */
 121         uint16_t            reg_idx;    /**< RX queue register index. */
 122         uint16_t            port_id;    /**< Device port identifier. */
 123         uint8_t             pthresh;    /**< Prefetch threshold register. */
 124         uint8_t             hthresh;    /**< Host threshold register. */
 125         uint8_t             wthresh;    /**< Write-back threshold register. */
 126         uint8_t             crc_len;    /**< 0 if CRC stripped, 4 otherwise. */
 127         uint8_t             drop_en;    /**< If not 0, set SRRCTL.Drop_En. */
 128         uint32_t            flags;      /**< RX flags. */
 129         uint64_t            offloads;   /**< offloads of DEV_RX_OFFLOAD_* */
 130 };
 131
 132 /** Offload features */
 133 union igc_tx_offload {
 134         uint64_t data;
 135         struct {
 136                 uint64_t l3_len:9; /**< L3 (IP) Header Length. */
 137                 uint64_t l2_len:7; /**< L2 (MAC) Header Length. */
 138                 uint64_t vlan_tci:16;
 139                 /**< VLAN Tag Control Identifier(CPU order). */
 140                 uint64_t l4_len:8; /**< L4 (TCP/UDP) Header Length. */
 141                 uint64_t tso_segsz:16; /**< TCP TSO segment size. */
 142                 /* uint64_t unused:8; */
 143         };
 144 };
 145
 146 /*
 147  * Compare mask for igc_tx_offload.data,
 148  * should be in sync with igc_tx_offload layout.
 149  */
 150 #define TX_MACIP_LEN_CMP_MASK   0x000000000000FFFFULL /**< L2L3 header mask. */
 151 #define TX_VLAN_CMP_MASK        0x00000000FFFF0000ULL /**< Vlan mask. */
 152 #define TX_TCP_LEN_CMP_MASK     0x000000FF00000000ULL /**< TCP header mask. */
 153 #define TX_TSO_MSS_CMP_MASK     0x00FFFF0000000000ULL /**< TSO segsz mask. */
 154 /** Mac + IP + TCP + Mss mask. */
 155 #define TX_TSO_CMP_MASK \
 156         (TX_MACIP_LEN_CMP_MASK | TX_TCP_LEN_CMP_MASK | TX_TSO_MSS_CMP_MASK)
 157
 158 /**
 159  * Structure to check if new context need be built
 160  */
 161 struct igc_advctx_info {
 162         uint64_t flags;           /**< ol_flags related to context build. */
 163         /** tx offload: vlan, tso, l2-l3-l4 lengths. */
 164         union igc_tx_offload tx_offload;
 165         /** compare mask for tx offload. */
 166         union igc_tx_offload tx_offload_mask;
 167 };
 168
 169 /**
 170  * Hardware context number
 171  */
 172 enum {
 173         IGC_CTX_0    = 0, /**< CTX0    */
 174         IGC_CTX_1    = 1, /**< CTX1    */
 175         IGC_CTX_NUM  = 2, /**< CTX_NUM */
 176 };
 177
 178 /**
 179  * Structure associated with each descriptor of the TX ring of a TX queue.
 180  */
 181 struct igc_tx_entry {
 182         struct rte_mbuf *mbuf; /**< mbuf associated with TX desc, if any. */
 183         uint16_t next_id; /**< Index of next descriptor in ring. */
 184         uint16_t last_id; /**< Index of last scattered descriptor. */
 185 };
 186
 187 /**
 188  * Structure associated with each TX queue.
 189  */
 190 struct igc_tx_queue {
 191         volatile union igc_adv_tx_desc *tx_ring; /**< TX ring address */
 192         uint64_t               tx_ring_phys_addr; /**< TX ring DMA address. */
 193         struct igc_tx_entry    *sw_ring; /**< virtual address of SW ring. */
 194         volatile uint32_t      *tdt_reg_addr; /**< Address of TDT register. */
 195         uint32_t               txd_type;      /**< Device-specific TXD type */
 196         uint16_t               nb_tx_desc;    /**< number of TX descriptors. */
 197         uint16_t               tx_tail;  /**< Current value of TDT register. */
 198         uint16_t               tx_head;
 199         /**< Index of first used TX descriptor. */
 200         uint16_t               queue_id; /**< TX queue index. */
 201         uint16_t               reg_idx;  /**< TX queue register index. */
 202         uint16_t               port_id;  /**< Device port identifier. */
 203         uint8_t                pthresh;  /**< Prefetch threshold register. */
 204         uint8_t                hthresh;  /**< Host threshold register. */
 205         uint8_t                wthresh;  /**< Write-back threshold register. */
 206         uint8_t                ctx_curr;
 207
 208         /**< Start context position for transmit queue. */
 209         struct igc_advctx_info ctx_cache[IGC_CTX_NUM];
 210         /**< Hardware context history.*/
 211         uint64_t               offloads; /**< offloads of DEV_TX_OFFLOAD_* */
 212 };
 213
 214 static inline uint64_t
 215 rx_desc_statuserr_to_pkt_flags(uint32_t statuserr)
 216 {
 217         static uint64_t l4_chksum_flags[] = {0, 0, PKT_RX_L4_CKSUM_GOOD,
 218                         PKT_RX_L4_CKSUM_BAD};
 219
 220         static uint64_t l3_chksum_flags[] = {0, 0, PKT_RX_IP_CKSUM_GOOD,
 221                         PKT_RX_IP_CKSUM_BAD};
 222         uint64_t pkt_flags = 0;
 223         uint32_t tmp;
 224
 225         if (statuserr & IGC_RXD_STAT_VP)
 226                 pkt_flags |= PKT_RX_VLAN_STRIPPED;
 227
 228         tmp = !!(statuserr & (IGC_RXD_STAT_L4CS | IGC_RXD_STAT_UDPCS));
 229         tmp = (tmp << 1) | (uint32_t)!!(statuserr & IGC_RXD_EXT_ERR_L4E);
 230         pkt_flags |= l4_chksum_flags[tmp];
 231
 232         tmp = !!(statuserr & IGC_RXD_STAT_IPCS);
 233         tmp = (tmp << 1) | (uint32_t)!!(statuserr & IGC_RXD_EXT_ERR_IPE);
 234         pkt_flags |= l3_chksum_flags[tmp];
 235
 236         return pkt_flags;
 237 }
 238
 239 #define IGC_PACKET_TYPE_IPV4              0X01
 240 #define IGC_PACKET_TYPE_IPV4_TCP          0X11
 241 #define IGC_PACKET_TYPE_IPV4_UDP          0X21
 242 #define IGC_PACKET_TYPE_IPV4_SCTP         0X41
 243 #define IGC_PACKET_TYPE_IPV4_EXT          0X03
 244 #define IGC_PACKET_TYPE_IPV4_EXT_SCTP     0X43
 245 #define IGC_PACKET_TYPE_IPV6              0X04
 246 #define IGC_PACKET_TYPE_IPV6_TCP          0X14
 247 #define IGC_PACKET_TYPE_IPV6_UDP          0X24
 248 #define IGC_PACKET_TYPE_IPV6_EXT          0X0C
 249 #define IGC_PACKET_TYPE_IPV6_EXT_TCP      0X1C
 250 #define IGC_PACKET_TYPE_IPV6_EXT_UDP      0X2C
 251 #define IGC_PACKET_TYPE_IPV4_IPV6         0X05
 252 #define IGC_PACKET_TYPE_IPV4_IPV6_TCP     0X15
 253 #define IGC_PACKET_TYPE_IPV4_IPV6_UDP     0X25
 254 #define IGC_PACKET_TYPE_IPV4_IPV6_EXT     0X0D
 255 #define IGC_PACKET_TYPE_IPV4_IPV6_EXT_TCP 0X1D
 256 #define IGC_PACKET_TYPE_IPV4_IPV6_EXT_UDP 0X2D
 257 #define IGC_PACKET_TYPE_MAX               0X80
 258 #define IGC_PACKET_TYPE_MASK              0X7F
 259 #define IGC_PACKET_TYPE_SHIFT             0X04
 260
 261 static inline uint32_t
 262 rx_desc_pkt_info_to_pkt_type(uint32_t pkt_info)
 263 {
 264         static const uint32_t
 265                 ptype_table[IGC_PACKET_TYPE_MAX] __rte_cache_aligned = {
 266                 [IGC_PACKET_TYPE_IPV4] = RTE_PTYPE_L2_ETHER |
 267                         RTE_PTYPE_L3_IPV4,
 268                 [IGC_PACKET_TYPE_IPV4_EXT] = RTE_PTYPE_L2_ETHER |
 269                         RTE_PTYPE_L3_IPV4_EXT,
 270                 [IGC_PACKET_TYPE_IPV6] = RTE_PTYPE_L2_ETHER |
 271                         RTE_PTYPE_L3_IPV6,
 272                 [IGC_PACKET_TYPE_IPV4_IPV6] = RTE_PTYPE_L2_ETHER |
 273                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 274                         RTE_PTYPE_INNER_L3_IPV6,
 275                 [IGC_PACKET_TYPE_IPV6_EXT] = RTE_PTYPE_L2_ETHER |
 276                         RTE_PTYPE_L3_IPV6_EXT,
 277                 [IGC_PACKET_TYPE_IPV4_IPV6_EXT] = RTE_PTYPE_L2_ETHER |
 278                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 279                         RTE_PTYPE_INNER_L3_IPV6_EXT,
 280                 [IGC_PACKET_TYPE_IPV4_TCP] = RTE_PTYPE_L2_ETHER |
 281                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_L4_TCP,
 282                 [IGC_PACKET_TYPE_IPV6_TCP] = RTE_PTYPE_L2_ETHER |
 283                         RTE_PTYPE_L3_IPV6 | RTE_PTYPE_L4_TCP,
 284                 [IGC_PACKET_TYPE_IPV4_IPV6_TCP] = RTE_PTYPE_L2_ETHER |
 285                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 286                         RTE_PTYPE_INNER_L3_IPV6 | RTE_PTYPE_INNER_L4_TCP,
 287                 [IGC_PACKET_TYPE_IPV6_EXT_TCP] = RTE_PTYPE_L2_ETHER |
 288                         RTE_PTYPE_L3_IPV6_EXT | RTE_PTYPE_L4_TCP,
 289                 [IGC_PACKET_TYPE_IPV4_IPV6_EXT_TCP] = RTE_PTYPE_L2_ETHER |
 290                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 291                         RTE_PTYPE_INNER_L3_IPV6_EXT | RTE_PTYPE_INNER_L4_TCP,
 292                 [IGC_PACKET_TYPE_IPV4_UDP] = RTE_PTYPE_L2_ETHER |
 293                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_L4_UDP,
 294                 [IGC_PACKET_TYPE_IPV6_UDP] = RTE_PTYPE_L2_ETHER |
 295                         RTE_PTYPE_L3_IPV6 | RTE_PTYPE_L4_UDP,
 296                 [IGC_PACKET_TYPE_IPV4_IPV6_UDP] =  RTE_PTYPE_L2_ETHER |
 297                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 298                         RTE_PTYPE_INNER_L3_IPV6 | RTE_PTYPE_INNER_L4_UDP,
 299                 [IGC_PACKET_TYPE_IPV6_EXT_UDP] = RTE_PTYPE_L2_ETHER |
 300                         RTE_PTYPE_L3_IPV6_EXT | RTE_PTYPE_L4_UDP,
 301                 [IGC_PACKET_TYPE_IPV4_IPV6_EXT_UDP] = RTE_PTYPE_L2_ETHER |
 302                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 303                         RTE_PTYPE_INNER_L3_IPV6_EXT | RTE_PTYPE_INNER_L4_UDP,
 304                 [IGC_PACKET_TYPE_IPV4_SCTP] = RTE_PTYPE_L2_ETHER |
 305                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_L4_SCTP,
 306                 [IGC_PACKET_TYPE_IPV4_EXT_SCTP] = RTE_PTYPE_L2_ETHER |
 307                         RTE_PTYPE_L3_IPV4_EXT | RTE_PTYPE_L4_SCTP,
 308         };
 309         if (unlikely(pkt_info & IGC_RXDADV_PKTTYPE_ETQF))
 310                 return RTE_PTYPE_UNKNOWN;
 311
 312         pkt_info = (pkt_info >> IGC_PACKET_TYPE_SHIFT) & IGC_PACKET_TYPE_MASK;
 313
 314         return ptype_table[pkt_info];
 315 }
 316
 317 static inline void
 318 rx_desc_get_pkt_info(struct igc_rx_queue *rxq, struct rte_mbuf *rxm,
 319                 union igc_adv_rx_desc *rxd, uint32_t staterr)
 320 {
 321         uint64_t pkt_flags;
 322         uint32_t hlen_type_rss;
 323         uint16_t pkt_info;
 324
 325         /* Prefetch data of first segment, if configured to do so. */
 326         rte_packet_prefetch((char *)rxm->buf_addr + rxm->data_off);
 327
 328         rxm->port = rxq->port_id;
 329         hlen_type_rss = rte_le_to_cpu_32(rxd->wb.lower.lo_dword.data);
 330         rxm->hash.rss = rte_le_to_cpu_32(rxd->wb.lower.hi_dword.rss);
 331         rxm->vlan_tci = rte_le_to_cpu_16(rxd->wb.upper.vlan);
 332
 333         pkt_flags = (hlen_type_rss & IGC_RXD_RSS_TYPE_MASK) ?
 334                         PKT_RX_RSS_HASH : 0;
 335
 336         if (hlen_type_rss & IGC_RXD_VPKT)
 337                 pkt_flags |= PKT_RX_VLAN;
 338
 339         pkt_flags |= rx_desc_statuserr_to_pkt_flags(staterr);
 340
 341         rxm->ol_flags = pkt_flags;
 342         pkt_info = rte_le_to_cpu_16(rxd->wb.lower.lo_dword.hs_rss.pkt_info);
 343         rxm->packet_type = rx_desc_pkt_info_to_pkt_type(pkt_info);
 344 }
 345
 346 static uint16_t
 347 igc_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
 348 {
 349         struct igc_rx_queue * const rxq = rx_queue;
 350         volatile union igc_adv_rx_desc * const rx_ring = rxq->rx_ring;
 351         struct igc_rx_entry * const sw_ring = rxq->sw_ring;
 352         uint16_t rx_id = rxq->rx_tail;
 353         uint16_t nb_rx = 0;
 354         uint16_t nb_hold = 0;
 355
 356         while (nb_rx < nb_pkts) {
 357                 volatile union igc_adv_rx_desc *rxdp;
 358                 struct igc_rx_entry *rxe;
 359                 struct rte_mbuf *rxm;
 360                 struct rte_mbuf *nmb;
 361                 union igc_adv_rx_desc rxd;
 362                 uint32_t staterr;
 363                 uint16_t data_len;
 364
 365                 /*
 366                  * The order of operations here is important as the DD status
 367                  * bit must not be read after any other descriptor fields.
 368                  * rx_ring and rxdp are pointing to volatile data so the order
 369                  * of accesses cannot be reordered by the compiler. If they were
 370                  * not volatile, they could be reordered which could lead to
 371                  * using invalid descriptor fields when read from rxd.
 372                  */
 373                 rxdp = &rx_ring[rx_id];
 374                 staterr = rte_cpu_to_le_32(rxdp->wb.upper.status_error);
 375                 if (!(staterr & IGC_RXD_STAT_DD))
 376                         break;
 377                 rxd = *rxdp;
 378
 379                 /*
 380                  * End of packet.
 381                  *
 382                  * If the IGC_RXD_STAT_EOP flag is not set, the RX packet is
 383                  * likely to be invalid and to be dropped by the various
 384                  * validation checks performed by the network stack.
 385                  *
 386                  * Allocate a new mbuf to replenish the RX ring descriptor.
 387                  * If the allocation fails:
 388                  *    - arrange for that RX descriptor to be the first one
 389                  *      being parsed the next time the receive function is
 390                  *      invoked [on the same queue].
 391                  *
 392                  *    - Stop parsing the RX ring and return immediately.
 393                  *
 394                  * This policy does not drop the packet received in the RX
 395                  * descriptor for which the allocation of a new mbuf failed.
 396                  * Thus, it allows that packet to be later retrieved if
 397                  * mbuf have been freed in the mean time.
 398                  * As a side effect, holding RX descriptors instead of
 399                  * systematically giving them back to the NIC may lead to
 400                  * RX ring exhaustion situations.
 401                  * However, the NIC can gracefully prevent such situations
 402                  * to happen by sending specific "back-pressure" flow control
 403                  * frames to its peer(s).
 404                  */
 405                 PMD_RX_LOG(DEBUG,
 406                         "port_id=%u queue_id=%u rx_id=%u staterr=0x%x data_len=%u",
 407                         rxq->port_id, rxq->queue_id, rx_id, staterr,
 408                         rte_le_to_cpu_16(rxd.wb.upper.length));
 409
 410                 nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
 411                 if (nmb == NULL) {
 412                         unsigned int id;
 413                         PMD_RX_LOG(DEBUG,
 414                                 "RX mbuf alloc failed, port_id=%u queue_id=%u",
 415                                 rxq->port_id, rxq->queue_id);
 416                         id = rxq->port_id;
 417                         rte_eth_devices[id].data->rx_mbuf_alloc_failed++;
 418                         break;
 419                 }
 420
 421                 nb_hold++;
 422                 rxe = &sw_ring[rx_id];
 423                 rx_id++;
 424                 if (rx_id >= rxq->nb_rx_desc)
 425                         rx_id = 0;
 426
 427                 /* Prefetch next mbuf while processing current one. */
 428                 rte_igc_prefetch(sw_ring[rx_id].mbuf);
 429
 430                 /*
 431                  * When next RX descriptor is on a cache-line boundary,
 432                  * prefetch the next 4 RX descriptors and the next 8 pointers
 433                  * to mbufs.
 434                  */
 435                 if ((rx_id & 0x3) == 0) {
 436                         rte_igc_prefetch(&rx_ring[rx_id]);
 437                         rte_igc_prefetch(&sw_ring[rx_id]);
 438                 }
 439
 440                 /*
 441                  * Update RX descriptor with the physical address of the new
 442                  * data buffer of the new allocated mbuf.
 443                  */
 444                 rxm = rxe->mbuf;
 445                 rxe->mbuf = nmb;
 446                 rxdp->read.hdr_addr = 0;
 447                 rxdp->read.pkt_addr =
 448                         rte_cpu_to_le_64(rte_mbuf_data_iova_default(nmb));
 449                 rxm->next = NULL;
 450
 451                 rxm->data_off = RTE_PKTMBUF_HEADROOM;
 452                 data_len = rte_le_to_cpu_16(rxd.wb.upper.length) - rxq->crc_len;
 453                 rxm->data_len = data_len;
 454                 rxm->pkt_len = data_len;
 455                 rxm->nb_segs = 1;
 456
 457                 rx_desc_get_pkt_info(rxq, rxm, &rxd, staterr);
 458
 459                 /*
 460                  * Store the mbuf address into the next entry of the array
 461                  * of returned packets.
 462                  */
 463                 rx_pkts[nb_rx++] = rxm;
 464         }
 465         rxq->rx_tail = rx_id;
 466
 467         /*
 468          * If the number of free RX descriptors is greater than the RX free
 469          * threshold of the queue, advance the Receive Descriptor Tail (RDT)
 470          * register.
 471          * Update the RDT with the value of the last processed RX descriptor
 472          * minus 1, to guarantee that the RDT register is never equal to the
 473          * RDH register, which creates a "full" ring situation from the
 474          * hardware point of view...
 475          */
 476         nb_hold = nb_hold + rxq->nb_rx_hold;
 477         if (nb_hold > rxq->rx_free_thresh) {
 478                 PMD_RX_LOG(DEBUG,
 479                         "port_id=%u queue_id=%u rx_tail=%u nb_hold=%u nb_rx=%u",
 480                         rxq->port_id, rxq->queue_id, rx_id, nb_hold, nb_rx);
 481                 rx_id = (rx_id == 0) ? (rxq->nb_rx_desc - 1) : (rx_id - 1);
 482                 IGC_PCI_REG_WRITE(rxq->rdt_reg_addr, rx_id);
 483                 nb_hold = 0;
 484         }
 485         rxq->nb_rx_hold = nb_hold;
 486         return nb_rx;
 487 }
 488
 489 static uint16_t
 490 igc_recv_scattered_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
 491                         uint16_t nb_pkts)
 492 {
 493         struct igc_rx_queue * const rxq = rx_queue;
 494         volatile union igc_adv_rx_desc * const rx_ring = rxq->rx_ring;
 495         struct igc_rx_entry * const sw_ring = rxq->sw_ring;
 496         struct rte_mbuf *first_seg = rxq->pkt_first_seg;
 497         struct rte_mbuf *last_seg = rxq->pkt_last_seg;
 498
 499         uint16_t rx_id = rxq->rx_tail;
 500         uint16_t nb_rx = 0;
 501         uint16_t nb_hold = 0;
 502
 503         while (nb_rx < nb_pkts) {
 504                 volatile union igc_adv_rx_desc *rxdp;
 505                 struct igc_rx_entry *rxe;
 506                 struct rte_mbuf *rxm;
 507                 struct rte_mbuf *nmb;
 508                 union igc_adv_rx_desc rxd;
 509                 uint32_t staterr;
 510                 uint16_t data_len;
 511
 512 next_desc:
 513                 /*
 514                  * The order of operations here is important as the DD status
 515                  * bit must not be read after any other descriptor fields.
 516                  * rx_ring and rxdp are pointing to volatile data so the order
 517                  * of accesses cannot be reordered by the compiler. If they were
 518                  * not volatile, they could be reordered which could lead to
 519                  * using invalid descriptor fields when read from rxd.
 520                  */
 521                 rxdp = &rx_ring[rx_id];
 522                 staterr = rte_cpu_to_le_32(rxdp->wb.upper.status_error);
 523                 if (!(staterr & IGC_RXD_STAT_DD))
 524                         break;
 525                 rxd = *rxdp;
 526
 527                 /*
 528                  * Descriptor done.
 529                  *
 530                  * Allocate a new mbuf to replenish the RX ring descriptor.
 531                  * If the allocation fails:
 532                  *    - arrange for that RX descriptor to be the first one
 533                  *      being parsed the next time the receive function is
 534                  *      invoked [on the same queue].
 535                  *
 536                  *    - Stop parsing the RX ring and return immediately.
 537                  *
 538                  * This policy does not drop the packet received in the RX
 539                  * descriptor for which the allocation of a new mbuf failed.
 540                  * Thus, it allows that packet to be later retrieved if
 541                  * mbuf have been freed in the mean time.
 542                  * As a side effect, holding RX descriptors instead of
 543                  * systematically giving them back to the NIC may lead to
 544                  * RX ring exhaustion situations.
 545                  * However, the NIC can gracefully prevent such situations
 546                  * to happen by sending specific "back-pressure" flow control
 547                  * frames to its peer(s).
 548                  */
 549                 PMD_RX_LOG(DEBUG,
 550                         "port_id=%u queue_id=%u rx_id=%u staterr=0x%x data_len=%u",
 551                         rxq->port_id, rxq->queue_id, rx_id, staterr,
 552                         rte_le_to_cpu_16(rxd.wb.upper.length));
 553
 554                 nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
 555                 if (nmb == NULL) {
 556                         unsigned int id;
 557                         PMD_RX_LOG(DEBUG,
 558                                 "RX mbuf alloc failed, port_id=%u queue_id=%u",
 559                                 rxq->port_id, rxq->queue_id);
 560                         id = rxq->port_id;
 561                         rte_eth_devices[id].data->rx_mbuf_alloc_failed++;
 562                         break;
 563                 }
 564
 565                 nb_hold++;
 566                 rxe = &sw_ring[rx_id];
 567                 rx_id++;
 568                 if (rx_id >= rxq->nb_rx_desc)
 569                         rx_id = 0;
 570
 571                 /* Prefetch next mbuf while processing current one. */
 572                 rte_igc_prefetch(sw_ring[rx_id].mbuf);
 573
 574                 /*
 575                  * When next RX descriptor is on a cache-line boundary,
 576                  * prefetch the next 4 RX descriptors and the next 8 pointers
 577                  * to mbufs.
 578                  */
 579                 if ((rx_id & 0x3) == 0) {
 580                         rte_igc_prefetch(&rx_ring[rx_id]);
 581                         rte_igc_prefetch(&sw_ring[rx_id]);
 582                 }
 583
 584                 /*
 585                  * Update RX descriptor with the physical address of the new
 586                  * data buffer of the new allocated mbuf.
 587                  */
 588                 rxm = rxe->mbuf;
 589                 rxe->mbuf = nmb;
 590                 rxdp->read.hdr_addr = 0;
 591                 rxdp->read.pkt_addr =
 592                         rte_cpu_to_le_64(rte_mbuf_data_iova_default(nmb));
 593                 rxm->next = NULL;
 594
 595                 /*
 596                  * Set data length & data buffer address of mbuf.
 597                  */
 598                 rxm->data_off = RTE_PKTMBUF_HEADROOM;
 599                 data_len = rte_le_to_cpu_16(rxd.wb.upper.length);
 600                 rxm->data_len = data_len;
 601
 602                 /*
 603                  * If this is the first buffer of the received packet,
 604                  * set the pointer to the first mbuf of the packet and
 605                  * initialize its context.
 606                  * Otherwise, update the total length and the number of segments
 607                  * of the current scattered packet, and update the pointer to
 608                  * the last mbuf of the current packet.
 609                  */
 610                 if (first_seg == NULL) {
 611                         first_seg = rxm;
 612                         first_seg->pkt_len = data_len;
 613                         first_seg->nb_segs = 1;
 614                 } else {
 615                         first_seg->pkt_len += data_len;
 616                         first_seg->nb_segs++;
 617                         last_seg->next = rxm;
 618                 }
 619
 620                 /*
 621                  * If this is not the last buffer of the received packet,
 622                  * update the pointer to the last mbuf of the current scattered
 623                  * packet and continue to parse the RX ring.
 624                  */
 625                 if (!(staterr & IGC_RXD_STAT_EOP)) {
 626                         last_seg = rxm;
 627                         goto next_desc;
 628                 }
 629
 630                 /*
 631                  * This is the last buffer of the received packet.
 632                  * If the CRC is not stripped by the hardware:
 633                  *   - Subtract the CRC length from the total packet length.
 634                  *   - If the last buffer only contains the whole CRC or a part
 635                  *     of it, free the mbuf associated to the last buffer.
 636                  *     If part of the CRC is also contained in the previous
 637                  *     mbuf, subtract the length of that CRC part from the
 638                  *     data length of the previous mbuf.
 639                  */
 640                 if (unlikely(rxq->crc_len > 0)) {
 641                         first_seg->pkt_len -= RTE_ETHER_CRC_LEN;
 642                         if (data_len <= RTE_ETHER_CRC_LEN) {
 643                                 rte_pktmbuf_free_seg(rxm);
 644                                 first_seg->nb_segs--;
 645                                 last_seg->data_len = last_seg->data_len -
 646                                          (RTE_ETHER_CRC_LEN - data_len);
 647                                 last_seg->next = NULL;
 648                         } else {
 649                                 rxm->data_len = (uint16_t)
 650                                         (data_len - RTE_ETHER_CRC_LEN);
 651                         }
 652                 }
 653
 654                 rx_desc_get_pkt_info(rxq, first_seg, &rxd, staterr);
 655
 656                 /*
 657                  * Store the mbuf address into the next entry of the array
 658                  * of returned packets.
 659                  */
 660                 rx_pkts[nb_rx++] = first_seg;
 661
 662                 /* Setup receipt context for a new packet. */
 663                 first_seg = NULL;
 664         }
 665         rxq->rx_tail = rx_id;
 666
 667         /*
 668          * Save receive context.
 669          */
 670         rxq->pkt_first_seg = first_seg;
 671         rxq->pkt_last_seg = last_seg;
 672
 673         /*
 674          * If the number of free RX descriptors is greater than the RX free
 675          * threshold of the queue, advance the Receive Descriptor Tail (RDT)
 676          * register.
 677          * Update the RDT with the value of the last processed RX descriptor
 678          * minus 1, to guarantee that the RDT register is never equal to the
 679          * RDH register, which creates a "full" ring situation from the
 680          * hardware point of view...
 681          */
 682         nb_hold = nb_hold + rxq->nb_rx_hold;
 683         if (nb_hold > rxq->rx_free_thresh) {
 684                 PMD_RX_LOG(DEBUG,
 685                         "port_id=%u queue_id=%u rx_tail=%u nb_hold=%u nb_rx=%u",
 686                         rxq->port_id, rxq->queue_id, rx_id, nb_hold, nb_rx);
 687                 rx_id = (rx_id == 0) ? (rxq->nb_rx_desc - 1) : (rx_id - 1);
 688                 IGC_PCI_REG_WRITE(rxq->rdt_reg_addr, rx_id);
 689                 nb_hold = 0;
 690         }
 691         rxq->nb_rx_hold = nb_hold;
 692         return nb_rx;
 693 }
 694
 695 static void
 696 igc_rx_queue_release_mbufs(struct igc_rx_queue *rxq)
 697 {
 698         unsigned int i;
 699
 700         if (rxq->sw_ring != NULL) {
 701                 for (i = 0; i < rxq->nb_rx_desc; i++) {
 702                         if (rxq->sw_ring[i].mbuf != NULL) {
 703                                 rte_pktmbuf_free_seg(rxq->sw_ring[i].mbuf);
 704                                 rxq->sw_ring[i].mbuf = NULL;
 705                         }
 706                 }
 707         }
 708 }
 709
 710 static void
 711 igc_rx_queue_release(struct igc_rx_queue *rxq)
 712 {
 713         igc_rx_queue_release_mbufs(rxq);
 714         rte_free(rxq->sw_ring);
 715         rte_free(rxq);
 716 }
 717
 718 void eth_igc_rx_queue_release(void *rxq)
 719 {
 720         if (rxq)
 721                 igc_rx_queue_release(rxq);
 722 }
 723
 724 uint32_t eth_igc_rx_queue_count(struct rte_eth_dev *dev,
 725                 uint16_t rx_queue_id)
 726 {
 727         /**
 728          * Check the DD bit of a rx descriptor of each 4 in a group,
 729          * to avoid checking too frequently and downgrading performance
 730          * too much.
 731          */
 732 #define IGC_RXQ_SCAN_INTERVAL 4
 733
 734         volatile union igc_adv_rx_desc *rxdp;
 735         struct igc_rx_queue *rxq;
 736         uint16_t desc = 0;
 737
 738         rxq = dev->data->rx_queues[rx_queue_id];
 739         rxdp = &rxq->rx_ring[rxq->rx_tail];
 740
 741         while (desc < rxq->nb_rx_desc - rxq->rx_tail) {
 742                 if (unlikely(!(rxdp->wb.upper.status_error &
 743                                 IGC_RXD_STAT_DD)))
 744                         return desc;
 745                 desc += IGC_RXQ_SCAN_INTERVAL;
 746                 rxdp += IGC_RXQ_SCAN_INTERVAL;
 747         }
 748         rxdp = &rxq->rx_ring[rxq->rx_tail + desc - rxq->nb_rx_desc];
 749
 750         while (desc < rxq->nb_rx_desc &&
 751                 (rxdp->wb.upper.status_error & IGC_RXD_STAT_DD)) {
 752                 desc += IGC_RXQ_SCAN_INTERVAL;
 753                 rxdp += IGC_RXQ_SCAN_INTERVAL;
 754         }
 755
 756         return desc;
 757 }
 758
 759 int eth_igc_rx_descriptor_done(void *rx_queue, uint16_t offset)
 760 {
 761         volatile union igc_adv_rx_desc *rxdp;
 762         struct igc_rx_queue *rxq = rx_queue;
 763         uint32_t desc;
 764
 765         if (unlikely(!rxq || offset >= rxq->nb_rx_desc))
 766                 return 0;
 767
 768         desc = rxq->rx_tail + offset;
 769         if (desc >= rxq->nb_rx_desc)
 770                 desc -= rxq->nb_rx_desc;
 771
 772         rxdp = &rxq->rx_ring[desc];
 773         return !!(rxdp->wb.upper.status_error &
 774                         rte_cpu_to_le_32(IGC_RXD_STAT_DD));
 775 }
 776
 777 int eth_igc_rx_descriptor_status(void *rx_queue, uint16_t offset)
 778 {
 779         struct igc_rx_queue *rxq = rx_queue;
 780         volatile uint32_t *status;
 781         uint32_t desc;
 782
 783         if (unlikely(!rxq || offset >= rxq->nb_rx_desc))
 784                 return -EINVAL;
 785
 786         if (offset >= rxq->nb_rx_desc - rxq->nb_rx_hold)
 787                 return RTE_ETH_RX_DESC_UNAVAIL;
 788
 789         desc = rxq->rx_tail + offset;
 790         if (desc >= rxq->nb_rx_desc)
 791                 desc -= rxq->nb_rx_desc;
 792
 793         status = &rxq->rx_ring[desc].wb.upper.status_error;
 794         if (*status & rte_cpu_to_le_32(IGC_RXD_STAT_DD))
 795                 return RTE_ETH_RX_DESC_DONE;
 796
 797         return RTE_ETH_RX_DESC_AVAIL;
 798 }
 799
 800 static int
 801 igc_alloc_rx_queue_mbufs(struct igc_rx_queue *rxq)
 802 {
 803         struct igc_rx_entry *rxe = rxq->sw_ring;
 804         uint64_t dma_addr;
 805         unsigned int i;
 806
 807         /* Initialize software ring entries. */
 808         for (i = 0; i < rxq->nb_rx_desc; i++) {
 809                 volatile union igc_adv_rx_desc *rxd;
 810                 struct rte_mbuf *mbuf = rte_mbuf_raw_alloc(rxq->mb_pool);
 811
 812                 if (mbuf == NULL) {
 813                         PMD_DRV_LOG(ERR, "RX mbuf alloc failed, queue_id=%hu",
 814                                 rxq->queue_id);
 815                         return -ENOMEM;
 816                 }
 817                 dma_addr = rte_cpu_to_le_64(rte_mbuf_data_iova_default(mbuf));
 818                 rxd = &rxq->rx_ring[i];
 819                 rxd->read.hdr_addr = 0;
 820                 rxd->read.pkt_addr = dma_addr;
 821                 rxe[i].mbuf = mbuf;
 822         }
 823
 824         return 0;
 825 }
 826
 827 /*
 828  * RSS random key supplied in section 7.1.2.9.3 of the Intel I225 datasheet.
 829  * Used as the default key.
 830  */
 831 static uint8_t default_rss_key[40] = {
 832         0x6D, 0x5A, 0x56, 0xDA, 0x25, 0x5B, 0x0E, 0xC2,
 833         0x41, 0x67, 0x25, 0x3D, 0x43, 0xA3, 0x8F, 0xB0,
 834         0xD0, 0xCA, 0x2B, 0xCB, 0xAE, 0x7B, 0x30, 0xB4,
 835         0x77, 0xCB, 0x2D, 0xA3, 0x80, 0x30, 0xF2, 0x0C,
 836         0x6A, 0x42, 0xB7, 0x3B, 0xBE, 0xAC, 0x01, 0xFA,
 837 };
 838
 839 static void
 840 igc_rss_disable(struct rte_eth_dev *dev)
 841 {
 842         struct igc_hw *hw = IGC_DEV_PRIVATE_HW(dev);
 843         uint32_t mrqc;
 844
 845         mrqc = IGC_READ_REG(hw, IGC_MRQC);
 846         mrqc &= ~IGC_MRQC_ENABLE_MASK;
 847         IGC_WRITE_REG(hw, IGC_MRQC, mrqc);
 848 }
 849
 850 static void
 851 igc_hw_rss_hash_set(struct igc_hw *hw, struct rte_eth_rss_conf *rss_conf)
 852 {
 853         uint32_t *hash_key = (uint32_t *)rss_conf->rss_key;
 854         uint32_t mrqc;
 855         uint64_t rss_hf;
 856
 857         if (hash_key != NULL) {
 858                 uint8_t i;
 859
 860                 /* Fill in RSS hash key */
 861                 for (i = 0; i < IGC_HKEY_MAX_INDEX; i++)
 862                         IGC_WRITE_REG_LE_VALUE(hw, IGC_RSSRK(i), hash_key[i]);
 863         }
 864
 865         /* Set configured hashing protocols in MRQC register */
 866         rss_hf = rss_conf->rss_hf;
 867         mrqc = IGC_MRQC_ENABLE_RSS_4Q; /* RSS enabled. */
 868         if (rss_hf & ETH_RSS_IPV4)
 869                 mrqc |= IGC_MRQC_RSS_FIELD_IPV4;
 870         if (rss_hf & ETH_RSS_NONFRAG_IPV4_TCP)
 871                 mrqc |= IGC_MRQC_RSS_FIELD_IPV4_TCP;
 872         if (rss_hf & ETH_RSS_IPV6)
 873                 mrqc |= IGC_MRQC_RSS_FIELD_IPV6;
 874         if (rss_hf & ETH_RSS_IPV6_EX)
 875                 mrqc |= IGC_MRQC_RSS_FIELD_IPV6_EX;
 876         if (rss_hf & ETH_RSS_NONFRAG_IPV6_TCP)
 877                 mrqc |= IGC_MRQC_RSS_FIELD_IPV6_TCP;
 878         if (rss_hf & ETH_RSS_IPV6_TCP_EX)
 879                 mrqc |= IGC_MRQC_RSS_FIELD_IPV6_TCP_EX;
 880         if (rss_hf & ETH_RSS_NONFRAG_IPV4_UDP)
 881                 mrqc |= IGC_MRQC_RSS_FIELD_IPV4_UDP;
 882         if (rss_hf & ETH_RSS_NONFRAG_IPV6_UDP)
 883                 mrqc |= IGC_MRQC_RSS_FIELD_IPV6_UDP;
 884         if (rss_hf & ETH_RSS_IPV6_UDP_EX)
 885                 mrqc |= IGC_MRQC_RSS_FIELD_IPV6_UDP_EX;
 886         IGC_WRITE_REG(hw, IGC_MRQC, mrqc);
 887 }
 888
 889 static void
 890 igc_rss_configure(struct rte_eth_dev *dev)
 891 {
 892         struct rte_eth_rss_conf rss_conf;
 893         struct igc_hw *hw = IGC_DEV_PRIVATE_HW(dev);
 894         uint16_t i;
 895
 896         /* Fill in redirection table. */
 897         for (i = 0; i < IGC_RSS_RDT_SIZD; i++) {
 898                 union igc_rss_reta_reg reta;
 899                 uint16_t q_idx, reta_idx;
 900
 901                 q_idx = (uint8_t)((dev->data->nb_rx_queues > 1) ?
 902                                    i % dev->data->nb_rx_queues : 0);
 903                 reta_idx = i % sizeof(reta);
 904                 reta.bytes[reta_idx] = q_idx;
 905                 if (reta_idx == sizeof(reta) - 1)
 906                         IGC_WRITE_REG_LE_VALUE(hw,
 907                                 IGC_RETA(i / sizeof(reta)), reta.dword);
 908         }
 909
 910         /*
 911          * Configure the RSS key and the RSS protocols used to compute
 912          * the RSS hash of input packets.
 913          */
 914         rss_conf = dev->data->dev_conf.rx_adv_conf.rss_conf;
 915         if (rss_conf.rss_key == NULL)
 916                 rss_conf.rss_key = default_rss_key;
 917         igc_hw_rss_hash_set(hw, &rss_conf);
 918 }
 919
 920 static int
 921 igc_dev_mq_rx_configure(struct rte_eth_dev *dev)
 922 {
 923         if (RTE_ETH_DEV_SRIOV(dev).active) {
 924                 PMD_DRV_LOG(ERR, "SRIOV unsupported!");
 925                 return -EINVAL;
 926         }
 927
 928         switch (dev->data->dev_conf.rxmode.mq_mode) {
 929         case ETH_MQ_RX_RSS:
 930                 igc_rss_configure(dev);
 931                 break;
 932         case ETH_MQ_RX_NONE:
 933                 /*
 934                  * configure RSS register for following,
 935                  * then disable the RSS logic
 936                  */
 937                 igc_rss_configure(dev);
 938                 igc_rss_disable(dev);
 939                 break;
 940         default:
 941                 PMD_DRV_LOG(ERR, "rx mode(%d) not supported!",
 942                         dev->data->dev_conf.rxmode.mq_mode);
 943                 return -EINVAL;
 944         }
 945         return 0;
 946 }
 947
 948 int
 949 igc_rx_init(struct rte_eth_dev *dev)
 950 {
 951         struct igc_rx_queue *rxq;
 952         struct igc_hw *hw = IGC_DEV_PRIVATE_HW(dev);
 953         uint64_t offloads = dev->data->dev_conf.rxmode.offloads;
 954         uint32_t max_rx_pkt_len = dev->data->dev_conf.rxmode.max_rx_pkt_len;
 955         uint32_t rctl;
 956         uint32_t rxcsum;
 957         uint16_t buf_size;
 958         uint16_t rctl_bsize;
 959         uint16_t i;
 960         int ret;
 961
 962         dev->rx_pkt_burst = igc_recv_pkts;
 963
 964         /*
 965          * Make sure receives are disabled while setting
 966          * up the descriptor ring.
 967          */
 968         rctl = IGC_READ_REG(hw, IGC_RCTL);
 969         IGC_WRITE_REG(hw, IGC_RCTL, rctl & ~IGC_RCTL_EN);
 970
 971         /* Configure support of jumbo frames, if any. */
 972         if (offloads & DEV_RX_OFFLOAD_JUMBO_FRAME) {
 973                 rctl |= IGC_RCTL_LPE;
 974
 975                 /*
 976                  * Set maximum packet length by default, and might be updated
 977                  * together with enabling/disabling dual VLAN.
 978                  */
 979                 IGC_WRITE_REG(hw, IGC_RLPML, max_rx_pkt_len);
 980         } else {
 981                 rctl &= ~IGC_RCTL_LPE;
 982         }
 983
 984         /* Configure and enable each RX queue. */
 985         rctl_bsize = 0;
 986         for (i = 0; i < dev->data->nb_rx_queues; i++) {
 987                 uint64_t bus_addr;
 988                 uint32_t rxdctl;
 989                 uint32_t srrctl;
 990
 991                 rxq = dev->data->rx_queues[i];
 992                 rxq->flags = 0;
 993
 994                 /* Allocate buffers for descriptor rings and set up queue */
 995                 ret = igc_alloc_rx_queue_mbufs(rxq);
 996                 if (ret)
 997                         return ret;
 998
 999                 /*
1000                  * Reset crc_len in case it was changed after queue setup by a
1001                  * call to configure
1002                  */
1003                 rxq->crc_len = (offloads & DEV_RX_OFFLOAD_KEEP_CRC) ?
1004                                 RTE_ETHER_CRC_LEN : 0;
1005
1006                 bus_addr = rxq->rx_ring_phys_addr;
1007                 IGC_WRITE_REG(hw, IGC_RDLEN(rxq->reg_idx),
1008                                 rxq->nb_rx_desc *
1009                                 sizeof(union igc_adv_rx_desc));
1010                 IGC_WRITE_REG(hw, IGC_RDBAH(rxq->reg_idx),
1011                                 (uint32_t)(bus_addr >> 32));
1012                 IGC_WRITE_REG(hw, IGC_RDBAL(rxq->reg_idx),
1013                                 (uint32_t)bus_addr);
1014
1015                 /* set descriptor configuration */
1016                 srrctl = IGC_SRRCTL_DESCTYPE_ADV_ONEBUF;
1017
1018                 srrctl |= (uint32_t)(RTE_PKTMBUF_HEADROOM / 64) <<
1019                                 IGC_SRRCTL_BSIZEHEADER_SHIFT;
1020                 /*
1021                  * Configure RX buffer size.
1022                  */
1023                 buf_size = (uint16_t)(rte_pktmbuf_data_room_size(rxq->mb_pool) -
1024                         RTE_PKTMBUF_HEADROOM);
1025                 if (buf_size >= 1024) {
1026                         /*
1027                          * Configure the BSIZEPACKET field of the SRRCTL
1028                          * register of the queue.
1029                          * Value is in 1 KB resolution, from 1 KB to 16 KB.
1030                          * If this field is equal to 0b, then RCTL.BSIZE
1031                          * determines the RX packet buffer size.
1032                          */
1033
1034                         srrctl |= ((buf_size >> IGC_SRRCTL_BSIZEPKT_SHIFT) &
1035                                    IGC_SRRCTL_BSIZEPKT_MASK);
1036                         buf_size = (uint16_t)((srrctl &
1037                                         IGC_SRRCTL_BSIZEPKT_MASK) <<
1038                                         IGC_SRRCTL_BSIZEPKT_SHIFT);
1039
1040                         /* It adds dual VLAN length for supporting dual VLAN */
1041                         if (max_rx_pkt_len + 2 * VLAN_TAG_SIZE > buf_size)
1042                                 dev->data->scattered_rx = 1;
1043                 } else {
1044                         /*
1045                          * Use BSIZE field of the device RCTL register.
1046                          */
1047                         if (rctl_bsize == 0 || rctl_bsize > buf_size)
1048                                 rctl_bsize = buf_size;
1049                         dev->data->scattered_rx = 1;
1050                 }
1051
1052                 /* Set if packets are dropped when no descriptors available */
1053                 if (rxq->drop_en)
1054                         srrctl |= IGC_SRRCTL_DROP_EN;
1055
1056                 IGC_WRITE_REG(hw, IGC_SRRCTL(rxq->reg_idx), srrctl);
1057
1058                 /* Enable this RX queue. */
1059                 rxdctl = IGC_RXDCTL_QUEUE_ENABLE;
1060                 rxdctl |= ((uint32_t)rxq->pthresh << IGC_RXDCTL_PTHRESH_SHIFT) &
1061                                 IGC_RXDCTL_PTHRESH_MSK;
1062                 rxdctl |= ((uint32_t)rxq->hthresh << IGC_RXDCTL_HTHRESH_SHIFT) &
1063                                 IGC_RXDCTL_HTHRESH_MSK;
1064                 rxdctl |= ((uint32_t)rxq->wthresh << IGC_RXDCTL_WTHRESH_SHIFT) &
1065                                 IGC_RXDCTL_WTHRESH_MSK;
1066                 IGC_WRITE_REG(hw, IGC_RXDCTL(rxq->reg_idx), rxdctl);
1067         }
1068
1069         if (offloads & DEV_RX_OFFLOAD_SCATTER)
1070                 dev->data->scattered_rx = 1;
1071
1072         if (dev->data->scattered_rx) {
1073                 PMD_DRV_LOG(DEBUG, "forcing scatter mode");
1074                 dev->rx_pkt_burst = igc_recv_scattered_pkts;
1075         }
1076         /*
1077          * Setup BSIZE field of RCTL register, if needed.
1078          * Buffer sizes >= 1024 are not [supposed to be] setup in the RCTL
1079          * register, since the code above configures the SRRCTL register of
1080          * the RX queue in such a case.
1081          * All configurable sizes are:
1082          * 16384: rctl |= (IGC_RCTL_SZ_16384 | IGC_RCTL_BSEX);
1083          *  8192: rctl |= (IGC_RCTL_SZ_8192  | IGC_RCTL_BSEX);
1084          *  4096: rctl |= (IGC_RCTL_SZ_4096  | IGC_RCTL_BSEX);
1085          *  2048: rctl |= IGC_RCTL_SZ_2048;
1086          *  1024: rctl |= IGC_RCTL_SZ_1024;
1087          *   512: rctl |= IGC_RCTL_SZ_512;
1088          *   256: rctl |= IGC_RCTL_SZ_256;
1089          */
1090         if (rctl_bsize > 0) {
1091                 if (rctl_bsize >= 512) /* 512 <= buf_size < 1024 - use 512 */
1092                         rctl |= IGC_RCTL_SZ_512;
1093                 else /* 256 <= buf_size < 512 - use 256 */
1094                         rctl |= IGC_RCTL_SZ_256;
1095         }
1096
1097         /*
1098          * Configure RSS if device configured with multiple RX queues.
1099          */
1100         igc_dev_mq_rx_configure(dev);
1101
1102         /* Update the rctl since igc_dev_mq_rx_configure may change its value */
1103         rctl |= IGC_READ_REG(hw, IGC_RCTL);
1104
1105         /*
1106          * Setup the Checksum Register.
1107          * Receive Full-Packet Checksum Offload is mutually exclusive with RSS.
1108          */
1109         rxcsum = IGC_READ_REG(hw, IGC_RXCSUM);
1110         rxcsum |= IGC_RXCSUM_PCSD;
1111
1112         /* Enable both L3/L4 rx checksum offload */
1113         if (offloads & DEV_RX_OFFLOAD_IPV4_CKSUM)
1114                 rxcsum |= IGC_RXCSUM_IPOFL;
1115         else
1116                 rxcsum &= ~IGC_RXCSUM_IPOFL;
1117
1118         if (offloads &
1119                 (DEV_RX_OFFLOAD_TCP_CKSUM | DEV_RX_OFFLOAD_UDP_CKSUM)) {
1120                 rxcsum |= IGC_RXCSUM_TUOFL;
1121                 offloads |= DEV_RX_OFFLOAD_SCTP_CKSUM;
1122         } else {
1123                 rxcsum &= ~IGC_RXCSUM_TUOFL;
1124         }
1125
1126         if (offloads & DEV_RX_OFFLOAD_SCTP_CKSUM)
1127                 rxcsum |= IGC_RXCSUM_CRCOFL;
1128         else
1129                 rxcsum &= ~IGC_RXCSUM_CRCOFL;
1130
1131         IGC_WRITE_REG(hw, IGC_RXCSUM, rxcsum);
1132
1133         /* Setup the Receive Control Register. */
1134         if (offloads & DEV_RX_OFFLOAD_KEEP_CRC)
1135                 rctl &= ~IGC_RCTL_SECRC; /* Do not Strip Ethernet CRC. */
1136         else
1137                 rctl |= IGC_RCTL_SECRC; /* Strip Ethernet CRC. */
1138
1139         rctl &= ~IGC_RCTL_MO_MSK;
1140         rctl &= ~IGC_RCTL_LBM_MSK;
1141         rctl |= IGC_RCTL_EN | IGC_RCTL_BAM | IGC_RCTL_LBM_NO |
1142                         IGC_RCTL_DPF |
1143                         (hw->mac.mc_filter_type << IGC_RCTL_MO_SHIFT);
1144
1145         rctl &= ~(IGC_RCTL_HSEL_MSK | IGC_RCTL_CFIEN | IGC_RCTL_CFI |
1146                         IGC_RCTL_PSP | IGC_RCTL_PMCF);
1147
1148         /* Make sure VLAN Filters are off. */
1149         rctl &= ~IGC_RCTL_VFE;
1150         /* Don't store bad packets. */
1151         rctl &= ~IGC_RCTL_SBP;
1152
1153         /* Enable Receives. */
1154         IGC_WRITE_REG(hw, IGC_RCTL, rctl);
1155
1156         /*
1157          * Setup the HW Rx Head and Tail Descriptor Pointers.
1158          * This needs to be done after enable.
1159          */
1160         for (i = 0; i < dev->data->nb_rx_queues; i++) {
1161                 rxq = dev->data->rx_queues[i];
1162                 IGC_WRITE_REG(hw, IGC_RDH(rxq->reg_idx), 0);
1163                 IGC_WRITE_REG(hw, IGC_RDT(rxq->reg_idx),
1164                                 rxq->nb_rx_desc - 1);
1165         }
1166
1167         return 0;
1168 }
1169
1170 static void
1171 igc_reset_rx_queue(struct igc_rx_queue *rxq)
1172 {
1173         static const union igc_adv_rx_desc zeroed_desc = { {0} };
1174         unsigned int i;
1175
1176         /* Zero out HW ring memory */
1177         for (i = 0; i < rxq->nb_rx_desc; i++)
1178                 rxq->rx_ring[i] = zeroed_desc;
1179
1180         rxq->rx_tail = 0;
1181         rxq->pkt_first_seg = NULL;
1182         rxq->pkt_last_seg = NULL;
1183 }
1184
1185 int
1186 eth_igc_rx_queue_setup(struct rte_eth_dev *dev,
1187                          uint16_t queue_idx,
1188                          uint16_t nb_desc,
1189                          unsigned int socket_id,
1190                          const struct rte_eth_rxconf *rx_conf,
1191                          struct rte_mempool *mp)
1192 {
1193         struct igc_hw *hw = IGC_DEV_PRIVATE_HW(dev);
1194         const struct rte_memzone *rz;
1195         struct igc_rx_queue *rxq;
1196         unsigned int size;
1197
1198         /*
1199          * Validate number of receive descriptors.
1200          * It must not exceed hardware maximum, and must be multiple
1201          * of IGC_RX_DESCRIPTOR_MULTIPLE.
1202          */
1203         if (nb_desc % IGC_RX_DESCRIPTOR_MULTIPLE != 0 ||
1204                 nb_desc > IGC_MAX_RXD || nb_desc < IGC_MIN_RXD) {
1205                 PMD_DRV_LOG(ERR,
1206                         "RX descriptor must be multiple of %u(cur: %u) and between %u and %u",
1207                         IGC_RX_DESCRIPTOR_MULTIPLE, nb_desc,
1208                         IGC_MIN_RXD, IGC_MAX_RXD);
1209                 return -EINVAL;
1210         }
1211
1212         /* Free memory prior to re-allocation if needed */
1213         if (dev->data->rx_queues[queue_idx] != NULL) {
1214                 igc_rx_queue_release(dev->data->rx_queues[queue_idx]);
1215                 dev->data->rx_queues[queue_idx] = NULL;
1216         }
1217
1218         /* First allocate the RX queue data structure. */
1219         rxq = rte_zmalloc("ethdev RX queue", sizeof(struct igc_rx_queue),
1220                           RTE_CACHE_LINE_SIZE);
1221         if (rxq == NULL)
1222                 return -ENOMEM;
1223         rxq->offloads = rx_conf->offloads;
1224         rxq->mb_pool = mp;
1225         rxq->nb_rx_desc = nb_desc;
1226         rxq->pthresh = rx_conf->rx_thresh.pthresh;
1227         rxq->hthresh = rx_conf->rx_thresh.hthresh;
1228         rxq->wthresh = rx_conf->rx_thresh.wthresh;
1229         rxq->drop_en = rx_conf->rx_drop_en;
1230         rxq->rx_free_thresh = rx_conf->rx_free_thresh;
1231         rxq->queue_id = queue_idx;
1232         rxq->reg_idx = queue_idx;
1233         rxq->port_id = dev->data->port_id;
1234
1235         /*
1236          *  Allocate RX ring hardware descriptors. A memzone large enough to
1237          *  handle the maximum ring size is allocated in order to allow for
1238          *  resizing in later calls to the queue setup function.
1239          */
1240         size = sizeof(union igc_adv_rx_desc) * IGC_MAX_RXD;
1241         rz = rte_eth_dma_zone_reserve(dev, "rx_ring", queue_idx, size,
1242                                       IGC_ALIGN, socket_id);
1243         if (rz == NULL) {
1244                 igc_rx_queue_release(rxq);
1245                 return -ENOMEM;
1246         }
1247         rxq->rdt_reg_addr = IGC_PCI_REG_ADDR(hw, IGC_RDT(rxq->reg_idx));
1248         rxq->rdh_reg_addr = IGC_PCI_REG_ADDR(hw, IGC_RDH(rxq->reg_idx));
1249         rxq->rx_ring_phys_addr = rz->iova;
1250         rxq->rx_ring = (union igc_adv_rx_desc *)rz->addr;
1251
1252         /* Allocate software ring. */
1253         rxq->sw_ring = rte_zmalloc("rxq->sw_ring",
1254                                    sizeof(struct igc_rx_entry) * nb_desc,
1255                                    RTE_CACHE_LINE_SIZE);
1256         if (rxq->sw_ring == NULL) {
1257                 igc_rx_queue_release(rxq);
1258                 return -ENOMEM;
1259         }
1260
1261         PMD_DRV_LOG(DEBUG, "sw_ring=%p hw_ring=%p dma_addr=0x%" PRIx64,
1262                 rxq->sw_ring, rxq->rx_ring, rxq->rx_ring_phys_addr);
1263
1264         dev->data->rx_queues[queue_idx] = rxq;
1265         igc_reset_rx_queue(rxq);
1266
1267         return 0;
1268 }
1269
1270 /* prepare packets for transmit */
1271 static uint16_t
1272 eth_igc_prep_pkts(__rte_unused void *tx_queue, struct rte_mbuf **tx_pkts,
1273                 uint16_t nb_pkts)
1274 {
1275         int i, ret;
1276         struct rte_mbuf *m;
1277
1278         for (i = 0; i < nb_pkts; i++) {
1279                 m = tx_pkts[i];
1280
1281                 /* Check some limitations for TSO in hardware */
1282                 if (m->ol_flags & IGC_TX_OFFLOAD_SEG)
1283                         if (m->tso_segsz > IGC_TSO_MAX_MSS ||
1284                                 m->l2_len + m->l3_len + m->l4_len >
1285                                 IGC_TSO_MAX_HDRLEN) {
1286                                 rte_errno = EINVAL;
1287                                 return i;
1288                         }
1289
1290                 if (m->ol_flags & IGC_TX_OFFLOAD_NOTSUP_MASK) {
1291                         rte_errno = ENOTSUP;
1292                         return i;
1293                 }
1294
1295 #ifdef RTE_LIBRTE_ETHDEV_DEBUG
1296                 ret = rte_validate_tx_offload(m);
1297                 if (ret != 0) {
1298                         rte_errno = -ret;
1299                         return i;
1300                 }
1301 #endif
1302                 ret = rte_net_intel_cksum_prepare(m);
1303                 if (ret != 0) {
1304                         rte_errno = -ret;
1305                         return i;
1306                 }
1307         }
1308
1309         return i;
1310 }
1311
1312 /*
1313  *There're some limitations in hardware for TCP segmentation offload. We
1314  *should check whether the parameters are valid.
1315  */
1316 static inline uint64_t
1317 check_tso_para(uint64_t ol_req, union igc_tx_offload ol_para)
1318 {
1319         if (!(ol_req & IGC_TX_OFFLOAD_SEG))
1320                 return ol_req;
1321         if (ol_para.tso_segsz > IGC_TSO_MAX_MSS || ol_para.l2_len +
1322                 ol_para.l3_len + ol_para.l4_len > IGC_TSO_MAX_HDRLEN) {
1323                 ol_req &= ~IGC_TX_OFFLOAD_SEG;
1324                 ol_req |= PKT_TX_TCP_CKSUM;
1325         }
1326         return ol_req;
1327 }
1328
1329 /*
1330  * Check which hardware context can be used. Use the existing match
1331  * or create a new context descriptor.
1332  */
1333 static inline uint32_t
1334 what_advctx_update(struct igc_tx_queue *txq, uint64_t flags,
1335                 union igc_tx_offload tx_offload)
1336 {
1337         uint32_t curr = txq->ctx_curr;
1338
1339         /* If match with the current context */
1340         if (likely(txq->ctx_cache[curr].flags == flags &&
1341                 txq->ctx_cache[curr].tx_offload.data ==
1342                 (txq->ctx_cache[curr].tx_offload_mask.data &
1343                 tx_offload.data))) {
1344                 return curr;
1345         }
1346
1347         /* Total two context, if match with the second context */
1348         curr ^= 1;
1349         if (likely(txq->ctx_cache[curr].flags == flags &&
1350                 txq->ctx_cache[curr].tx_offload.data ==
1351                 (txq->ctx_cache[curr].tx_offload_mask.data &
1352                 tx_offload.data))) {
1353                 txq->ctx_curr = curr;
1354                 return curr;
1355         }
1356
1357         /* Mismatch, create new one */
1358         return IGC_CTX_NUM;
1359 }
1360
1361 /*
1362  * This is a separate function, looking for optimization opportunity here
1363  * Rework required to go with the pre-defined values.
1364  */
1365 static inline void
1366 igc_set_xmit_ctx(struct igc_tx_queue *txq,
1367                 volatile struct igc_adv_tx_context_desc *ctx_txd,
1368                 uint64_t ol_flags, union igc_tx_offload tx_offload)
1369 {
1370         uint32_t type_tucmd_mlhl;
1371         uint32_t mss_l4len_idx;
1372         uint32_t ctx_curr;
1373         uint32_t vlan_macip_lens;
1374         union igc_tx_offload tx_offload_mask;
1375
1376         /* Use the previous context */
1377         txq->ctx_curr ^= 1;
1378         ctx_curr = txq->ctx_curr;
1379
1380         tx_offload_mask.data = 0;
1381         type_tucmd_mlhl = 0;
1382
1383         /* Specify which HW CTX to upload. */
1384         mss_l4len_idx = (ctx_curr << IGC_ADVTXD_IDX_SHIFT);
1385
1386         if (ol_flags & PKT_TX_VLAN_PKT)
1387                 tx_offload_mask.vlan_tci = 0xffff;
1388
1389         /* check if TCP segmentation required for this packet */
1390         if (ol_flags & IGC_TX_OFFLOAD_SEG) {
1391                 /* implies IP cksum in IPv4 */
1392                 if (ol_flags & PKT_TX_IP_CKSUM)
1393                         type_tucmd_mlhl = IGC_ADVTXD_TUCMD_IPV4 |
1394                                 IGC_ADVTXD_DTYP_CTXT | IGC_ADVTXD_DCMD_DEXT;
1395                 else
1396                         type_tucmd_mlhl = IGC_ADVTXD_TUCMD_IPV6 |
1397                                 IGC_ADVTXD_DTYP_CTXT | IGC_ADVTXD_DCMD_DEXT;
1398
1399                 if (ol_flags & PKT_TX_TCP_SEG)
1400                         type_tucmd_mlhl |= IGC_ADVTXD_TUCMD_L4T_TCP;
1401                 else
1402                         type_tucmd_mlhl |= IGC_ADVTXD_TUCMD_L4T_UDP;
1403
1404                 tx_offload_mask.data |= TX_TSO_CMP_MASK;
1405                 mss_l4len_idx |= (uint32_t)tx_offload.tso_segsz <<
1406                                 IGC_ADVTXD_MSS_SHIFT;
1407                 mss_l4len_idx |= (uint32_t)tx_offload.l4_len <<
1408                                 IGC_ADVTXD_L4LEN_SHIFT;
1409         } else { /* no TSO, check if hardware checksum is needed */
1410                 if (ol_flags & (PKT_TX_IP_CKSUM | PKT_TX_L4_MASK))
1411                         tx_offload_mask.data |= TX_MACIP_LEN_CMP_MASK;
1412
1413                 if (ol_flags & PKT_TX_IP_CKSUM)
1414                         type_tucmd_mlhl = IGC_ADVTXD_TUCMD_IPV4;
1415
1416                 switch (ol_flags & PKT_TX_L4_MASK) {
1417                 case PKT_TX_TCP_CKSUM:
1418                         type_tucmd_mlhl |= IGC_ADVTXD_TUCMD_L4T_TCP |
1419                                 IGC_ADVTXD_DTYP_CTXT | IGC_ADVTXD_DCMD_DEXT;
1420                         mss_l4len_idx |= (uint32_t)sizeof(struct rte_tcp_hdr)
1421                                 << IGC_ADVTXD_L4LEN_SHIFT;
1422                         break;
1423                 case PKT_TX_UDP_CKSUM:
1424                         type_tucmd_mlhl |= IGC_ADVTXD_TUCMD_L4T_UDP |
1425                                 IGC_ADVTXD_DTYP_CTXT | IGC_ADVTXD_DCMD_DEXT;
1426                         mss_l4len_idx |= (uint32_t)sizeof(struct rte_udp_hdr)
1427                                 << IGC_ADVTXD_L4LEN_SHIFT;
1428                         break;
1429                 case PKT_TX_SCTP_CKSUM:
1430                         type_tucmd_mlhl |= IGC_ADVTXD_TUCMD_L4T_SCTP |
1431                                 IGC_ADVTXD_DTYP_CTXT | IGC_ADVTXD_DCMD_DEXT;
1432                         mss_l4len_idx |= (uint32_t)sizeof(struct rte_sctp_hdr)
1433                                 << IGC_ADVTXD_L4LEN_SHIFT;
1434                         break;
1435                 default:
1436                         type_tucmd_mlhl |= IGC_ADVTXD_TUCMD_L4T_RSV |
1437                                 IGC_ADVTXD_DTYP_CTXT | IGC_ADVTXD_DCMD_DEXT;
1438                         break;
1439                 }
1440         }
1441
1442         txq->ctx_cache[ctx_curr].flags = ol_flags;
1443         txq->ctx_cache[ctx_curr].tx_offload.data =
1444                 tx_offload_mask.data & tx_offload.data;
1445         txq->ctx_cache[ctx_curr].tx_offload_mask = tx_offload_mask;
1446
1447         ctx_txd->type_tucmd_mlhl = rte_cpu_to_le_32(type_tucmd_mlhl);
1448         vlan_macip_lens = (uint32_t)tx_offload.data;
1449         ctx_txd->vlan_macip_lens = rte_cpu_to_le_32(vlan_macip_lens);
1450         ctx_txd->mss_l4len_idx = rte_cpu_to_le_32(mss_l4len_idx);
1451         ctx_txd->u.launch_time = 0;
1452 }
1453
1454 static inline uint32_t
1455 tx_desc_vlan_flags_to_cmdtype(uint64_t ol_flags)
1456 {
1457         uint32_t cmdtype;
1458         static uint32_t vlan_cmd[2] = {0, IGC_ADVTXD_DCMD_VLE};
1459         static uint32_t tso_cmd[2] = {0, IGC_ADVTXD_DCMD_TSE};
1460         cmdtype = vlan_cmd[(ol_flags & PKT_TX_VLAN_PKT) != 0];
1461         cmdtype |= tso_cmd[(ol_flags & IGC_TX_OFFLOAD_SEG) != 0];
1462         return cmdtype;
1463 }
1464
1465 static inline uint32_t
1466 tx_desc_cksum_flags_to_olinfo(uint64_t ol_flags)
1467 {
1468         static const uint32_t l4_olinfo[2] = {0, IGC_ADVTXD_POPTS_TXSM};
1469         static const uint32_t l3_olinfo[2] = {0, IGC_ADVTXD_POPTS_IXSM};
1470         uint32_t tmp;
1471
1472         tmp  = l4_olinfo[(ol_flags & PKT_TX_L4_MASK)  != PKT_TX_L4_NO_CKSUM];
1473         tmp |= l3_olinfo[(ol_flags & PKT_TX_IP_CKSUM) != 0];
1474         tmp |= l4_olinfo[(ol_flags & IGC_TX_OFFLOAD_SEG) != 0];
1475         return tmp;
1476 }
1477
1478 static uint16_t
1479 igc_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
1480 {
1481         struct igc_tx_queue * const txq = tx_queue;
1482         struct igc_tx_entry * const sw_ring = txq->sw_ring;
1483         struct igc_tx_entry *txe, *txn;
1484         volatile union igc_adv_tx_desc * const txr = txq->tx_ring;
1485         volatile union igc_adv_tx_desc *txd;
1486         struct rte_mbuf *tx_pkt;
1487         struct rte_mbuf *m_seg;
1488         uint64_t buf_dma_addr;
1489         uint32_t olinfo_status;
1490         uint32_t cmd_type_len;
1491         uint32_t pkt_len;
1492         uint16_t slen;
1493         uint64_t ol_flags;
1494         uint16_t tx_end;
1495         uint16_t tx_id;
1496         uint16_t tx_last;
1497         uint16_t nb_tx;
1498         uint64_t tx_ol_req;
1499         uint32_t new_ctx = 0;
1500         union igc_tx_offload tx_offload = {0};
1501
1502         tx_id = txq->tx_tail;
1503         txe = &sw_ring[tx_id];
1504
1505         for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
1506                 tx_pkt = *tx_pkts++;
1507                 pkt_len = tx_pkt->pkt_len;
1508
1509                 RTE_MBUF_PREFETCH_TO_FREE(txe->mbuf);
1510
1511                 /*
1512                  * The number of descriptors that must be allocated for a
1513                  * packet is the number of segments of that packet, plus 1
1514                  * Context Descriptor for the VLAN Tag Identifier, if any.
1515                  * Determine the last TX descriptor to allocate in the TX ring
1516                  * for the packet, starting from the current position (tx_id)
1517                  * in the ring.
1518                  */
1519                 tx_last = (uint16_t)(tx_id + tx_pkt->nb_segs - 1);
1520
1521                 ol_flags = tx_pkt->ol_flags;
1522                 tx_ol_req = ol_flags & IGC_TX_OFFLOAD_MASK;
1523
1524                 /* If a Context Descriptor need be built . */
1525                 if (tx_ol_req) {
1526                         tx_offload.l2_len = tx_pkt->l2_len;
1527                         tx_offload.l3_len = tx_pkt->l3_len;
1528                         tx_offload.l4_len = tx_pkt->l4_len;
1529                         tx_offload.vlan_tci = tx_pkt->vlan_tci;
1530                         tx_offload.tso_segsz = tx_pkt->tso_segsz;
1531                         tx_ol_req = check_tso_para(tx_ol_req, tx_offload);
1532
1533                         new_ctx = what_advctx_update(txq, tx_ol_req,
1534                                         tx_offload);
1535                         /* Only allocate context descriptor if required*/
1536                         new_ctx = (new_ctx >= IGC_CTX_NUM);
1537                         tx_last = (uint16_t)(tx_last + new_ctx);
1538                 }
1539                 if (tx_last >= txq->nb_tx_desc)
1540                         tx_last = (uint16_t)(tx_last - txq->nb_tx_desc);
1541
1542                 PMD_TX_LOG(DEBUG,
1543                         "port_id=%u queue_id=%u pktlen=%u tx_first=%u tx_last=%u",
1544                         txq->port_id, txq->queue_id, pkt_len, tx_id, tx_last);
1545
1546                 /*
1547                  * Check if there are enough free descriptors in the TX ring
1548                  * to transmit the next packet.
1549                  * This operation is based on the two following rules:
1550                  *
1551                  *   1- Only check that the last needed TX descriptor can be
1552                  *      allocated (by construction, if that descriptor is free,
1553                  *      all intermediate ones are also free).
1554                  *
1555                  *      For this purpose, the index of the last TX descriptor
1556                  *      used for a packet (the "last descriptor" of a packet)
1557                  *      is recorded in the TX entries (the last one included)
1558                  *      that are associated with all TX descriptors allocated
1559                  *      for that packet.
1560                  *
1561                  *   2- Avoid to allocate the last free TX descriptor of the
1562                  *      ring, in order to never set the TDT register with the
1563                  *      same value stored in parallel by the NIC in the TDH
1564                  *      register, which makes the TX engine of the NIC enter
1565                  *      in a deadlock situation.
1566                  *
1567                  *      By extension, avoid to allocate a free descriptor that
1568                  *      belongs to the last set of free descriptors allocated
1569                  *      to the same packet previously transmitted.
1570                  */
1571
1572                 /*
1573                  * The "last descriptor" of the previously sent packet, if any,
1574                  * which used the last descriptor to allocate.
1575                  */
1576                 tx_end = sw_ring[tx_last].last_id;
1577
1578                 /*
1579                  * The next descriptor following that "last descriptor" in the
1580                  * ring.
1581                  */
1582                 tx_end = sw_ring[tx_end].next_id;
1583
1584                 /*
1585                  * The "last descriptor" associated with that next descriptor.
1586                  */
1587                 tx_end = sw_ring[tx_end].last_id;
1588
1589                 /*
1590                  * Check that this descriptor is free.
1591                  */
1592                 if (!(txr[tx_end].wb.status & IGC_TXD_STAT_DD)) {
1593                         if (nb_tx == 0)
1594                                 return 0;
1595                         goto end_of_tx;
1596                 }
1597
1598                 /*
1599                  * Set common flags of all TX Data Descriptors.
1600                  *
1601                  * The following bits must be set in all Data Descriptors:
1602                  *   - IGC_ADVTXD_DTYP_DATA
1603                  *   - IGC_ADVTXD_DCMD_DEXT
1604                  *
1605                  * The following bits must be set in the first Data Descriptor
1606                  * and are ignored in the other ones:
1607                  *   - IGC_ADVTXD_DCMD_IFCS
1608                  *   - IGC_ADVTXD_MAC_1588
1609                  *   - IGC_ADVTXD_DCMD_VLE
1610                  *
1611                  * The following bits must only be set in the last Data
1612                  * Descriptor:
1613                  *   - IGC_TXD_CMD_EOP
1614                  *
1615                  * The following bits can be set in any Data Descriptor, but
1616                  * are only set in the last Data Descriptor:
1617                  *   - IGC_TXD_CMD_RS
1618                  */
1619                 cmd_type_len = txq->txd_type |
1620                         IGC_ADVTXD_DCMD_IFCS | IGC_ADVTXD_DCMD_DEXT;
1621                 if (tx_ol_req & IGC_TX_OFFLOAD_SEG)
1622                         pkt_len -= (tx_pkt->l2_len + tx_pkt->l3_len +
1623                                         tx_pkt->l4_len);
1624                 olinfo_status = (pkt_len << IGC_ADVTXD_PAYLEN_SHIFT);
1625
1626                 /*
1627                  * Timer 0 should be used to for packet timestamping,
1628                  * sample the packet timestamp to reg 0
1629                  */
1630                 if (ol_flags & PKT_TX_IEEE1588_TMST)
1631                         cmd_type_len |= IGC_ADVTXD_MAC_TSTAMP;
1632
1633                 if (tx_ol_req) {
1634                         /* Setup TX Advanced context descriptor if required */
1635                         if (new_ctx) {
1636                                 volatile struct igc_adv_tx_context_desc *
1637                                         ctx_txd = (volatile struct
1638                                         igc_adv_tx_context_desc *)&txr[tx_id];
1639
1640                                 txn = &sw_ring[txe->next_id];
1641                                 RTE_MBUF_PREFETCH_TO_FREE(txn->mbuf);
1642
1643                                 if (txe->mbuf != NULL) {
1644                                         rte_pktmbuf_free_seg(txe->mbuf);
1645                                         txe->mbuf = NULL;
1646                                 }
1647
1648                                 igc_set_xmit_ctx(txq, ctx_txd, tx_ol_req,
1649                                                 tx_offload);
1650
1651                                 txe->last_id = tx_last;
1652                                 tx_id = txe->next_id;
1653                                 txe = txn;
1654                         }
1655
1656                         /* Setup the TX Advanced Data Descriptor */
1657                         cmd_type_len |=
1658                                 tx_desc_vlan_flags_to_cmdtype(tx_ol_req);
1659                         olinfo_status |=
1660                                 tx_desc_cksum_flags_to_olinfo(tx_ol_req);
1661                         olinfo_status |= (uint32_t)txq->ctx_curr <<
1662                                         IGC_ADVTXD_IDX_SHIFT;
1663                 }
1664
1665                 m_seg = tx_pkt;
1666                 do {
1667                         txn = &sw_ring[txe->next_id];
1668                         RTE_MBUF_PREFETCH_TO_FREE(txn->mbuf);
1669
1670                         txd = &txr[tx_id];
1671
1672                         if (txe->mbuf != NULL)
1673                                 rte_pktmbuf_free_seg(txe->mbuf);
1674                         txe->mbuf = m_seg;
1675
1676                         /* Set up transmit descriptor */
1677                         slen = (uint16_t)m_seg->data_len;
1678                         buf_dma_addr = rte_mbuf_data_iova(m_seg);
1679                         txd->read.buffer_addr =
1680                                 rte_cpu_to_le_64(buf_dma_addr);
1681                         txd->read.cmd_type_len =
1682                                 rte_cpu_to_le_32(cmd_type_len | slen);
1683                         txd->read.olinfo_status =
1684                                 rte_cpu_to_le_32(olinfo_status);
1685                         txe->last_id = tx_last;
1686                         tx_id = txe->next_id;
1687                         txe = txn;
1688                         m_seg = m_seg->next;
1689                 } while (m_seg != NULL);
1690
1691                 /*
1692                  * The last packet data descriptor needs End Of Packet (EOP)
1693                  * and Report Status (RS).
1694                  */
1695                 txd->read.cmd_type_len |=
1696                         rte_cpu_to_le_32(IGC_TXD_CMD_EOP | IGC_TXD_CMD_RS);
1697         }
1698 end_of_tx:
1699         rte_wmb();
1700
1701         /*
1702          * Set the Transmit Descriptor Tail (TDT).
1703          */
1704         IGC_PCI_REG_WRITE_RELAXED(txq->tdt_reg_addr, tx_id);
1705         PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u tx_tail=%u nb_tx=%u",
1706                 txq->port_id, txq->queue_id, tx_id, nb_tx);
1707         txq->tx_tail = tx_id;
1708
1709         return nb_tx;
1710 }
1711
1712 int eth_igc_tx_descriptor_status(void *tx_queue, uint16_t offset)
1713 {
1714         struct igc_tx_queue *txq = tx_queue;
1715         volatile uint32_t *status;
1716         uint32_t desc;
1717
1718         if (unlikely(!txq || offset >= txq->nb_tx_desc))
1719                 return -EINVAL;
1720
1721         desc = txq->tx_tail + offset;
1722         if (desc >= txq->nb_tx_desc)
1723                 desc -= txq->nb_tx_desc;
1724
1725         status = &txq->tx_ring[desc].wb.status;
1726         if (*status & rte_cpu_to_le_32(IGC_TXD_STAT_DD))
1727                 return RTE_ETH_TX_DESC_DONE;
1728
1729         return RTE_ETH_TX_DESC_FULL;
1730 }
1731
1732 static void
1733 igc_tx_queue_release_mbufs(struct igc_tx_queue *txq)
1734 {
1735         unsigned int i;
1736
1737         if (txq->sw_ring != NULL) {
1738                 for (i = 0; i < txq->nb_tx_desc; i++) {
1739                         if (txq->sw_ring[i].mbuf != NULL) {
1740                                 rte_pktmbuf_free_seg(txq->sw_ring[i].mbuf);
1741                                 txq->sw_ring[i].mbuf = NULL;
1742                         }
1743                 }
1744         }
1745 }
1746
1747 static void
1748 igc_tx_queue_release(struct igc_tx_queue *txq)
1749 {
1750         igc_tx_queue_release_mbufs(txq);
1751         rte_free(txq->sw_ring);
1752         rte_free(txq);
1753 }
1754
1755 void eth_igc_tx_queue_release(void *txq)
1756 {
1757         if (txq)
1758                 igc_tx_queue_release(txq);
1759 }
1760
1761 static void
1762 igc_reset_tx_queue_stat(struct igc_tx_queue *txq)
1763 {
1764         txq->tx_head = 0;
1765         txq->tx_tail = 0;
1766         txq->ctx_curr = 0;
1767         memset((void *)&txq->ctx_cache, 0,
1768                 IGC_CTX_NUM * sizeof(struct igc_advctx_info));
1769 }
1770
1771 static void
1772 igc_reset_tx_queue(struct igc_tx_queue *txq)
1773 {
1774         struct igc_tx_entry *txe = txq->sw_ring;
1775         uint16_t i, prev;
1776
1777         /* Initialize ring entries */
1778         prev = (uint16_t)(txq->nb_tx_desc - 1);
1779         for (i = 0; i < txq->nb_tx_desc; i++) {
1780                 volatile union igc_adv_tx_desc *txd = &txq->tx_ring[i];
1781
1782                 txd->wb.status = IGC_TXD_STAT_DD;
1783                 txe[i].mbuf = NULL;
1784                 txe[i].last_id = i;
1785                 txe[prev].next_id = i;
1786                 prev = i;
1787         }
1788
1789         txq->txd_type = IGC_ADVTXD_DTYP_DATA;
1790         igc_reset_tx_queue_stat(txq);
1791 }
1792
1793 /*
1794  * clear all rx/tx queue
1795  */
1796 void
1797 igc_dev_clear_queues(struct rte_eth_dev *dev)
1798 {
1799         uint16_t i;
1800         struct igc_tx_queue *txq;
1801         struct igc_rx_queue *rxq;
1802
1803         for (i = 0; i < dev->data->nb_tx_queues; i++) {
1804                 txq = dev->data->tx_queues[i];
1805                 if (txq != NULL) {
1806                         igc_tx_queue_release_mbufs(txq);
1807                         igc_reset_tx_queue(txq);
1808                 }
1809         }
1810
1811         for (i = 0; i < dev->data->nb_rx_queues; i++) {
1812                 rxq = dev->data->rx_queues[i];
1813                 if (rxq != NULL) {
1814                         igc_rx_queue_release_mbufs(rxq);
1815                         igc_reset_rx_queue(rxq);
1816                 }
1817         }
1818 }
1819
1820 int eth_igc_tx_queue_setup(struct rte_eth_dev *dev, uint16_t queue_idx,
1821                 uint16_t nb_desc, unsigned int socket_id,
1822                 const struct rte_eth_txconf *tx_conf)
1823 {
1824         const struct rte_memzone *tz;
1825         struct igc_tx_queue *txq;
1826         struct igc_hw *hw;
1827         uint32_t size;
1828
1829         if (nb_desc % IGC_TX_DESCRIPTOR_MULTIPLE != 0 ||
1830                 nb_desc > IGC_MAX_TXD || nb_desc < IGC_MIN_TXD) {
1831                 PMD_DRV_LOG(ERR,
1832                         "TX-descriptor must be a multiple of %u and between %u and %u, cur: %u",
1833                         IGC_TX_DESCRIPTOR_MULTIPLE,
1834                         IGC_MAX_TXD, IGC_MIN_TXD, nb_desc);
1835                 return -EINVAL;
1836         }
1837
1838         hw = IGC_DEV_PRIVATE_HW(dev);
1839
1840         /*
1841          * The tx_free_thresh and tx_rs_thresh values are not used in the 2.5G
1842          * driver.
1843          */
1844         if (tx_conf->tx_free_thresh != 0)
1845                 PMD_DRV_LOG(INFO,
1846                         "The tx_free_thresh parameter is not used for the 2.5G driver");
1847         if (tx_conf->tx_rs_thresh != 0)
1848                 PMD_DRV_LOG(INFO,
1849                         "The tx_rs_thresh parameter is not used for the 2.5G driver");
1850         if (tx_conf->tx_thresh.wthresh == 0)
1851                 PMD_DRV_LOG(INFO,
1852                         "To improve 2.5G driver performance, consider setting the TX WTHRESH value to 4, 8, or 16.");
1853
1854         /* Free memory prior to re-allocation if needed */
1855         if (dev->data->tx_queues[queue_idx] != NULL) {
1856                 igc_tx_queue_release(dev->data->tx_queues[queue_idx]);
1857                 dev->data->tx_queues[queue_idx] = NULL;
1858         }
1859
1860         /* First allocate the tx queue data structure */
1861         txq = rte_zmalloc("ethdev TX queue", sizeof(struct igc_tx_queue),
1862                                                 RTE_CACHE_LINE_SIZE);
1863         if (txq == NULL)
1864                 return -ENOMEM;
1865
1866         /*
1867          * Allocate TX ring hardware descriptors. A memzone large enough to
1868          * handle the maximum ring size is allocated in order to allow for
1869          * resizing in later calls to the queue setup function.
1870          */
1871         size = sizeof(union igc_adv_tx_desc) * IGC_MAX_TXD;
1872         tz = rte_eth_dma_zone_reserve(dev, "tx_ring", queue_idx, size,
1873                                       IGC_ALIGN, socket_id);
1874         if (tz == NULL) {
1875                 igc_tx_queue_release(txq);
1876                 return -ENOMEM;
1877         }
1878
1879         txq->nb_tx_desc = nb_desc;
1880         txq->pthresh = tx_conf->tx_thresh.pthresh;
1881         txq->hthresh = tx_conf->tx_thresh.hthresh;
1882         txq->wthresh = tx_conf->tx_thresh.wthresh;
1883
1884         txq->queue_id = queue_idx;
1885         txq->reg_idx = queue_idx;
1886         txq->port_id = dev->data->port_id;
1887
1888         txq->tdt_reg_addr = IGC_PCI_REG_ADDR(hw, IGC_TDT(txq->reg_idx));
1889         txq->tx_ring_phys_addr = tz->iova;
1890
1891         txq->tx_ring = (union igc_adv_tx_desc *)tz->addr;
1892         /* Allocate software ring */
1893         txq->sw_ring = rte_zmalloc("txq->sw_ring",
1894                                    sizeof(struct igc_tx_entry) * nb_desc,
1895                                    RTE_CACHE_LINE_SIZE);
1896         if (txq->sw_ring == NULL) {
1897                 igc_tx_queue_release(txq);
1898                 return -ENOMEM;
1899         }
1900         PMD_DRV_LOG(DEBUG, "sw_ring=%p hw_ring=%p dma_addr=0x%" PRIx64,
1901                 txq->sw_ring, txq->tx_ring, txq->tx_ring_phys_addr);
1902
1903         igc_reset_tx_queue(txq);
1904         dev->tx_pkt_burst = igc_xmit_pkts;
1905         dev->tx_pkt_prepare = &eth_igc_prep_pkts;
1906         dev->data->tx_queues[queue_idx] = txq;
1907         txq->offloads = tx_conf->offloads;
1908
1909         return 0;
1910 }
1911
1912 int
1913 eth_igc_tx_done_cleanup(void *txqueue, uint32_t free_cnt)
1914 {
1915         struct igc_tx_queue *txq = txqueue;
1916         struct igc_tx_entry *sw_ring;
1917         volatile union igc_adv_tx_desc *txr;
1918         uint16_t tx_first; /* First segment analyzed. */
1919         uint16_t tx_id;    /* Current segment being processed. */
1920         uint16_t tx_last;  /* Last segment in the current packet. */
1921         uint16_t tx_next;  /* First segment of the next packet. */
1922         uint32_t count;
1923
1924         if (txq == NULL)
1925                 return -ENODEV;
1926
1927         count = 0;
1928         sw_ring = txq->sw_ring;
1929         txr = txq->tx_ring;
1930
1931         /*
1932          * tx_tail is the last sent packet on the sw_ring. Goto the end
1933          * of that packet (the last segment in the packet chain) and
1934          * then the next segment will be the start of the oldest segment
1935          * in the sw_ring. This is the first packet that will be
1936          * attempted to be freed.
1937          */
1938
1939         /* Get last segment in most recently added packet. */
1940         tx_first = sw_ring[txq->tx_tail].last_id;
1941
1942         /* Get the next segment, which is the oldest segment in ring. */
1943         tx_first = sw_ring[tx_first].next_id;
1944
1945         /* Set the current index to the first. */
1946         tx_id = tx_first;
1947
1948         /*
1949          * Loop through each packet. For each packet, verify that an
1950          * mbuf exists and that the last segment is free. If so, free
1951          * it and move on.
1952          */
1953         while (1) {
1954                 tx_last = sw_ring[tx_id].last_id;
1955
1956                 if (sw_ring[tx_last].mbuf) {
1957                         if (!(txr[tx_last].wb.status &
1958                                         rte_cpu_to_le_32(IGC_TXD_STAT_DD)))
1959                                 break;
1960
1961                         /* Get the start of the next packet. */
1962                         tx_next = sw_ring[tx_last].next_id;
1963
1964                         /*
1965                          * Loop through all segments in a
1966                          * packet.
1967                          */
1968                         do {
1969                                 rte_pktmbuf_free_seg(sw_ring[tx_id].mbuf);
1970                                 sw_ring[tx_id].mbuf = NULL;
1971                                 sw_ring[tx_id].last_id = tx_id;
1972
1973                                 /* Move to next segemnt. */
1974                                 tx_id = sw_ring[tx_id].next_id;
1975                         } while (tx_id != tx_next);
1976
1977                         /*
1978                          * Increment the number of packets
1979                          * freed.
1980                          */
1981                         count++;
1982                         if (unlikely(count == free_cnt))
1983                                 break;
1984                 } else {
1985                         /*
1986                          * There are multiple reasons to be here:
1987                          * 1) All the packets on the ring have been
1988                          *    freed - tx_id is equal to tx_first
1989                          *    and some packets have been freed.
1990                          *    - Done, exit
1991                          * 2) Interfaces has not sent a rings worth of
1992                          *    packets yet, so the segment after tail is
1993                          *    still empty. Or a previous call to this
1994                          *    function freed some of the segments but
1995                          *    not all so there is a hole in the list.
1996                          *    Hopefully this is a rare case.
1997                          *    - Walk the list and find the next mbuf. If
1998                          *      there isn't one, then done.
1999                          */
2000                         if (likely(tx_id == tx_first && count != 0))
2001                                 break;
2002
2003                         /*
2004                          * Walk the list and find the next mbuf, if any.
2005                          */
2006                         do {
2007                                 /* Move to next segemnt. */
2008                                 tx_id = sw_ring[tx_id].next_id;
2009
2010                                 if (sw_ring[tx_id].mbuf)
2011                                         break;
2012
2013                         } while (tx_id != tx_first);
2014
2015                         /*
2016                          * Determine why previous loop bailed. If there
2017                          * is not an mbuf, done.
2018                          */
2019                         if (sw_ring[tx_id].mbuf == NULL)
2020                                 break;
2021                 }
2022         }
2023
2024         return count;
2025 }
2026
2027 void
2028 igc_tx_init(struct rte_eth_dev *dev)
2029 {
2030         struct igc_hw *hw = IGC_DEV_PRIVATE_HW(dev);
2031         uint32_t tctl;
2032         uint32_t txdctl;
2033         uint16_t i;
2034
2035         /* Setup the Base and Length of the Tx Descriptor Rings. */
2036         for (i = 0; i < dev->data->nb_tx_queues; i++) {
2037                 struct igc_tx_queue *txq = dev->data->tx_queues[i];
2038                 uint64_t bus_addr = txq->tx_ring_phys_addr;
2039
2040                 IGC_WRITE_REG(hw, IGC_TDLEN(txq->reg_idx),
2041                                 txq->nb_tx_desc *
2042                                 sizeof(union igc_adv_tx_desc));
2043                 IGC_WRITE_REG(hw, IGC_TDBAH(txq->reg_idx),
2044                                 (uint32_t)(bus_addr >> 32));
2045                 IGC_WRITE_REG(hw, IGC_TDBAL(txq->reg_idx),
2046                                 (uint32_t)bus_addr);
2047
2048                 /* Setup the HW Tx Head and Tail descriptor pointers. */
2049                 IGC_WRITE_REG(hw, IGC_TDT(txq->reg_idx), 0);
2050                 IGC_WRITE_REG(hw, IGC_TDH(txq->reg_idx), 0);
2051
2052                 /* Setup Transmit threshold registers. */
2053                 txdctl = ((uint32_t)txq->pthresh << IGC_TXDCTL_PTHRESH_SHIFT) &
2054                                 IGC_TXDCTL_PTHRESH_MSK;
2055                 txdctl |= ((uint32_t)txq->hthresh << IGC_TXDCTL_HTHRESH_SHIFT) &
2056                                 IGC_TXDCTL_HTHRESH_MSK;
2057                 txdctl |= ((uint32_t)txq->wthresh << IGC_TXDCTL_WTHRESH_SHIFT) &
2058                                 IGC_TXDCTL_WTHRESH_MSK;
2059                 txdctl |= IGC_TXDCTL_QUEUE_ENABLE;
2060                 IGC_WRITE_REG(hw, IGC_TXDCTL(txq->reg_idx), txdctl);
2061         }
2062
2063         igc_config_collision_dist(hw);
2064
2065         /* Program the Transmit Control Register. */
2066         tctl = IGC_READ_REG(hw, IGC_TCTL);
2067         tctl &= ~IGC_TCTL_CT;
2068         tctl |= (IGC_TCTL_PSP | IGC_TCTL_RTLC | IGC_TCTL_EN |
2069                  ((uint32_t)IGC_COLLISION_THRESHOLD << IGC_CT_SHIFT));
2070
2071         /* This write will effectively turn on the transmit unit. */
2072         IGC_WRITE_REG(hw, IGC_TCTL, tctl);
2073 }
2074
2075 void
2076 eth_igc_rxq_info_get(struct rte_eth_dev *dev, uint16_t queue_id,
2077         struct rte_eth_rxq_info *qinfo)
2078 {
2079         struct igc_rx_queue *rxq;
2080
2081         rxq = dev->data->rx_queues[queue_id];
2082
2083         qinfo->mp = rxq->mb_pool;
2084         qinfo->scattered_rx = dev->data->scattered_rx;
2085         qinfo->nb_desc = rxq->nb_rx_desc;
2086
2087         qinfo->conf.rx_free_thresh = rxq->rx_free_thresh;
2088         qinfo->conf.rx_drop_en = rxq->drop_en;
2089         qinfo->conf.offloads = rxq->offloads;
2090         qinfo->conf.rx_thresh.hthresh = rxq->hthresh;
2091         qinfo->conf.rx_thresh.pthresh = rxq->pthresh;
2092         qinfo->conf.rx_thresh.wthresh = rxq->wthresh;
2093 }
2094
2095 void
2096 eth_igc_txq_info_get(struct rte_eth_dev *dev, uint16_t queue_id,
2097         struct rte_eth_txq_info *qinfo)
2098 {
2099         struct igc_tx_queue *txq;
2100
2101         txq = dev->data->tx_queues[queue_id];
2102
2103         qinfo->nb_desc = txq->nb_tx_desc;
2104
2105         qinfo->conf.tx_thresh.pthresh = txq->pthresh;
2106         qinfo->conf.tx_thresh.hthresh = txq->hthresh;
2107         qinfo->conf.tx_thresh.wthresh = txq->wthresh;
2108         qinfo->conf.offloads = txq->offloads;
2109 }